Prepare v2.0.0 branch for master

.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  pull_request:
+    branches: [master, main]
+  push:
+    branches: [master, main]
+
+jobs:
+  test:
+    name: Build & Test
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: |
+            8.x
+            9.x
+            10.x
+
+      - name: Restore
+        run: dotnet restore
+
+      - name: Build
+        run: dotnet build --no-restore --configuration Release
+
+      - name: Test
+        run: dotnet test CleverCache.Tests/CleverCache.Tests.csproj --no-build --configuration Release --logger "trx" --verbosity normal

.github/workflows/publish-wiki.yml

@@ -0,0 +1,22 @@
+name: Publish Wiki
+
+on:
+  push:
+    branches: [main]
+    paths: ['wiki/**']
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Push wiki to GitHub Wiki
+        uses: Andrew-Chen-Wang/github-wiki-action@v4
+        with:
+          path: wiki/
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+

.github/workflows/update-about.yml

@@ -0,0 +1,45 @@
+name: Update Repo About
+# Requires a classic PAT with 'public_repo' scope stored as SYNC_META_TOKEN.
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  update:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Extract metadata from csproj
+        id: meta
+        run: |
+          DESCRIPTION=$(grep -oPm1 '(?<=<Description>)[^<]+' CleverCache.csproj)
+          TAGS=$(grep -oPm1 '(?<=<PackageTags>)[^<]+' CleverCache.csproj)
+
+          echo "description=$DESCRIPTION" >> $GITHUB_OUTPUT
+          echo "tags=$TAGS" >> $GITHUB_OUTPUT
+
+      - name: Update description and homepage
+        run: |
+          gh repo edit "$GITHUB_REPOSITORY" \
+            --description "${{ steps.meta.outputs.description }}" \
+            --homepage "https://github.com/$GITHUB_REPOSITORY/wiki"
+        env:
+          GH_TOKEN: ${{ secrets.SYNC_META_TOKEN }}
+
+      - name: Replace topics from PackageTags
+        run: |
+          # Convert comma-separated tags to a JSON array of lowercase, hyphenated topics
+          TOPICS_JSON=$(echo "${{ steps.meta.outputs.tags }}" \
+            | tr ',' '\n' \
+            | sed 's/^ *//;s/ *$//' \
+            | tr '[:upper:]' '[:lower:]' \
+            | tr ' ' '-' \
+            | jq -R . \
+            | jq -sc '{names: .}')
+
+          echo "Topics: $TOPICS_JSON"
+          echo "$TOPICS_JSON" | gh api --method PUT "/repos/$GITHUB_REPOSITORY/topics" --input -
+        env:
+          GH_TOKEN: ${{ secrets.SYNC_META_TOKEN }}

.gitignore

@@ -6,3 +6,6 @@
 /obj
 /bin
 
+
+/*/bin/*
+/*/obj/*

Attributes/DependentCachesAttribute.cs

@@ -1,13 +1,31 @@
 namespace CleverCache.Attributes;
 
+/// <summary>
+/// Declares cache dependency relationships for an entity type.
+/// Use <c>builder.Services.AddCleverCache(o => o.ScanAssemblyContaining&lt;T&gt;())</c> to register
+/// these at startup. When any entry for this type is invalidated, entries for all declared
+/// dependent types are also invalidated.
+/// </summary>
+/// <example>
+/// <code>
+/// // Invalidating Order also invalidates OrderLine and OrderNote
+/// [DependentCaches([typeof(OrderLine), typeof(OrderNote)])]
+/// public class Order { }
+///
+/// // reverse: true also invalidates Order when OrderLine changes
+/// [DependentCaches([typeof(OrderLine)], reverse: true)]
+/// public class Order { }
+/// </code>
+/// </example>
 [AttributeUsage(AttributeTargets.Class)]
-public class DependantCachesAttribute(
+public class DependentCachesAttribute(
 	Type[] types,
-	DependentCacheNavigationScanMode navigationScanMode = DependentCacheNavigationScanMode.None,
 	bool reverse = false
 ) : Attribute
 {
-	public Type[] DependantTypes { get; } = types ?? [];
-	public DependentCacheNavigationScanMode NavigationScanMode { get; set; } = navigationScanMode;
+	/// <summary>The entity types that should also be invalidated when this type's entries are evicted.</summary>
+	public Type[] DependentTypes { get; } = types ?? [];
+
+	/// <summary>When <c>true</c>, also registers the inverse dependency so that invalidating any dependent type also invalidates this type.</summary>
 	public bool Reverse { get; set; } = reverse;
 }

CacheKeyManager.cs

@@ -1,7 +1,7 @@
 namespace CleverCache;
 using System.Collections.Concurrent;
 
-public abstract class CacheEntryManager: ICacheEntryManager
+internal abstract class CacheEntryManager
 {
 	// type -> set of keys (thread-safe “set” via ConcurrentDictionary<TKey, byte>)
 	private readonly ConcurrentDictionary<Type, ConcurrentDictionary<object, byte>> _keysByType = new();
@@ -31,12 +31,38 @@ public void AddKeyToTypes(Type[] types, object key)
 
 	}
 
+	/// <summary>
+	/// Removes a key from every type's tracked key set.
+	/// Called after a key is removed from the store so the tracking set stays in sync.
+	/// </summary>
+	protected void RemoveKeyFromAllTypes(object key)
+	{
+		foreach (var typeSet in _keysByType.Values)
+			typeSet.TryRemove(key, out _);
+	}
+
 	/// <summary>
 	/// Snapshot keys for a given type (safe to enumerate).
 	/// </summary>
 	protected object[] SnapshotKeysFor(Type type) =>
 		_keysByType.TryGetValue(type, out var set) ? set.Keys.ToArray() : [];
 
+	/// <summary>
+	/// Snapshot of the full dependency graph and tracked keys.
+	/// </summary>
+	protected CleverCacheDiagnostics SnapshotDiagnostics()
+	{
+		var dependants = _dependants.ToDictionary(
+			kvp => kvp.Key,
+			kvp => (IReadOnlyList<Type>)kvp.Value.Keys.OrderBy(t => t.Name).ToList());
+
+		var keysByType = _keysByType.ToDictionary(
+			kvp => kvp.Key,
+			kvp => (IReadOnlyList<object>)kvp.Value.Keys.ToList());
+
+		return new CleverCacheDiagnostics(dependants, keysByType);
+	}
+
 	/// <summary>
 	/// Transitive closure over dependents, cycle-safe
 	/// </summary>

CleverCache.EntityFrameworkCore/CleverCache.EntityFrameworkCore.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<PropertyGroup>
+		<PackageId>CleverCache.EntityFrameworkCore</PackageId>
+		<Version>2.0.0</Version>
+		<PackageProjectUrl>https://github.com/chunty/CleverCache/wiki/Getting-Started</PackageProjectUrl>
+		<Description>EF Core integration for CleverCache — automatic cache invalidation via SaveChangesInterceptor and DbSet navigation scanning.</Description>
+		<PackageTags>MemoryCache,Cache Invalidation,EntityFrameworkCore,EF Core</PackageTags>
+		<PackageReadmeFile>NuGetReadMe.md</PackageReadmeFile>
+	</PropertyGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\CleverCache.csproj" />
+		<PackageReference Include="Microsoft.EntityFrameworkCore" />
+		<PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" />
+	</ItemGroup>
+	<ItemGroup>
+		<None Include="NuGetReadMe.md" Pack="true" PackagePath="NuGetReadMe.md" />
+	</ItemGroup>
+	<ItemGroup>
+		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+			<_Parameter1>CleverCache.Tests</_Parameter1>
+		</AssemblyAttribute>
+	</ItemGroup>
+</Project>

CleverCache.EntityFrameworkCore/DependencyInjection/ApplicationBuilderExtensions.cs

@@ -0,0 +1,63 @@
+using Microsoft.AspNetCore.Builder;
+
+namespace CleverCache.EntityFrameworkCore.DependencyInjection;
+
+public static class ApplicationBuilderExtensions
+{
+	/// <summary>
+	/// Scans the <see cref="DbContext"/> navigation properties for <typeparamref name="TContext"/>
+	/// and registers the discovered cache dependency rules at startup.
+	/// Can be called multiple times for multiple <see cref="DbContext"/> types, each with their own scan options.
+	/// </summary>
+	/// <remarks>
+	/// Use this overload in ASP.NET Core apps where <see cref="IApplicationBuilder"/> is available.
+	/// For worker services or console apps, use the <see cref="IServiceProvider"/> overload instead.
+	/// </remarks>
+	/// <example>
+	/// <code>
+	/// app.ScanDbSetsForCacheDependencies&lt;AppDbContext&gt;(o =>
+	///     o.NavigationScanMode = DependentCacheNavigationScanMode.Direct);
+	/// </code>
+	/// </example>
+	public static IApplicationBuilder ScanDbSetsForCacheDependencies<TContext>(
+		this IApplicationBuilder app,
+		Action<CleverCacheScanOptions>? configure = null)
+		where TContext : DbContext
+	{
+		app.ApplicationServices.ScanDbSetsForCacheDependencies<TContext>(configure);
+		return app;
+	}
+
+	/// <summary>
+	/// Scans the <see cref="DbContext"/> navigation properties for <typeparamref name="TContext"/>
+	/// and registers the discovered cache dependency rules at startup.
+	/// Can be called multiple times for multiple <see cref="DbContext"/> types, each with their own scan options.
+	/// </summary>
+	/// <remarks>
+	/// Use this overload in worker services or console apps where <see cref="IApplicationBuilder"/> is not available.
+	/// </remarks>
+	/// <example>
+	/// <code>
+	/// host.Services.ScanDbSetsForCacheDependencies&lt;AppDbContext&gt;(o =>
+	///     o.NavigationScanMode = DependentCacheNavigationScanMode.Direct);
+	/// await host.RunAsync();
+	/// </code>
+	/// </example>
+	public static IServiceProvider ScanDbSetsForCacheDependencies<TContext>(
+		this IServiceProvider services,
+		Action<CleverCacheScanOptions>? configure = null)
+		where TContext : DbContext
+	{
+		var cache = services.GetRequiredService<ICleverCache>();
+		var scanOptions = new CleverCacheScanOptions();
+		configure?.Invoke(scanOptions);
+
+		using var scope = services.CreateScope();
+		var dbContext = scope.ServiceProvider.GetRequiredService<TContext>();
+
+		foreach (var dep in dbContext.DiscoverDependentCaches(scanOptions))
+			cache.AddDependentCache(dep.Type, dep.DependentType);
+
+		return services;
+	}
+}

CleverCache.EntityFrameworkCore/DependencyInjection/ServiceCollectionExtensions.cs

@@ -0,0 +1,20 @@
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+
+namespace CleverCache.EntityFrameworkCore.DependencyInjection;
+
+public static class ServiceCollectionExtensions
+{
+	/// <summary>
+	/// Registers CleverCache services and the EF Core <see cref="CleverCacheInterceptor"/>.
+	/// This is the single call needed when using EF Core — there is no need to also call <c>AddCleverCache()</c>.
+	/// </summary>
+	public static IServiceCollection AddCleverCacheEntityFramework(this IServiceCollection services,
+		Action<CleverCacheOptions>? options = null)
+	{
+		services.AddCleverCache(options);
+		services.TryAddScoped<CleverCacheInterceptor>();
+		services.AddScoped<IInterceptor, CleverCacheInterceptor>();
+		return services;
+	}
+}

CleverCache.EntityFrameworkCore/Exceptions/MissingInterceptorException.cs

@@ -0,0 +1,4 @@
+namespace CleverCache.EntityFrameworkCore.Exceptions;
+
+internal class MissingInterceptorException() :
+	Exception("CleverCache requires CleverCacheInterceptor to be registered. Call AddCleverCacheEntityFramework() on your IServiceCollection.");

CleverCache.EntityFrameworkCore/Extensions/DbContextExtensions.cs

@@ -0,0 +1,32 @@
+using CleverCache.EntityFrameworkCore.Exceptions;
+using CleverCache.EntityFrameworkCore.Helpers;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace CleverCache.EntityFrameworkCore.Extensions;
+
+internal static class DbContextExtensions
+{
+	public static void EnsureCleverCacheInterceptor(this DbContext dbContext)
+	{
+		var isRegistered = dbContext.GetService<IDbContextOptions>().Extensions
+			.OfType<CoreOptionsExtension>()
+			.Any(e => e.Interceptors != null
+			          && e.Interceptors.Any(i => i.GetType() == typeof(CleverCacheInterceptor)));
+
+		if (!isRegistered) throw new MissingInterceptorException();
+	}
+
+	public static List<DependentCache> DiscoverDependentCaches(this DbContext dbContext, CleverCacheScanOptions scanOptions)
+	{
+		if (scanOptions.NavigationScanMode == DependentCacheNavigationScanMode.None)
+			return [];
+
+		HashSet<DependentCache> dependentCaches = [];
+
+		foreach (var entityType in dbContext.Model.GetEntityTypes())
+			NavigationScanningHelper.Scan(scanOptions, entityType, dependentCaches);
+
+		return [.. dependentCaches];
+	}
+}

Extensions/DbOptionsBuilderExtensions.cs → CleverCache.EntityFrameworkCore/Extensions/DbOptionsBuilderExtensions.cs

@@ -1,13 +1,16 @@
-namespace CleverCache.Extensions;
+namespace CleverCache.EntityFrameworkCore.Extensions;
 
 public static class DbOptionsBuilderExtensions
 {
+	/// <summary>
+	/// Adds <see cref="CleverCacheInterceptor"/> to the <see cref="DbContextOptionsBuilder"/>.
+	/// Use this when you prefer constructor injection over the DI-based interceptor registration.
+	/// </summary>
 	public static DbContextOptionsBuilder AddCleverCache(this DbContextOptionsBuilder optionsBuilder,
 		IServiceProvider serviceProvider)
 	{
 		var interceptor = serviceProvider.GetRequiredService<CleverCacheInterceptor>();
-
 		optionsBuilder.AddInterceptors(interceptor);
 		return optionsBuilder;
 	}
-}
+}

CleverCache.EntityFrameworkCore/GlobalUsings.cs

@@ -0,0 +1,11 @@
+// Global using directives
+
+global using Microsoft.AspNetCore.Builder;
+global using Microsoft.EntityFrameworkCore;
+global using Microsoft.Extensions.DependencyInjection;
+global using CleverCache;
+global using CleverCache.DependencyInjection;
+global using CleverCache.Models;
+global using CleverCache.EntityFrameworkCore.Models;
+global using CleverCache.EntityFrameworkCore.Interceptors;
+global using CleverCache.EntityFrameworkCore.Extensions;