feat: Invalidate related models when mutating

.gitignore

@@ -106,3 +106,6 @@ dist
 # Ignore Prisma SQLite database
 dev.db
 dev.db-journal
+
+# IntelliJ IDEA project files
+.idea

README.md

@@ -147,13 +147,14 @@ Options:
   - `cacheKey`: (optional) string. Default is the model value.
   - `cacheTime`: (optional) number (in seconds).
   - `excludeMethods`: (optional) (string) an array of Prisma methods to exclude from being cached for this model.
+  - `invalidateRelated`: (optional) (string) an array of Prisma models to invalidate when mutating this model.
 
     Example:
 
     ```js
     createPrismaRedisCache({
       models: [
-        { model: "User", cacheTime: 60 },
+        { model: "User", cacheTime: 60, invalidateRelated: ["Post"] },
         { model: "Post", cacheKey: "article", excludeMethods: ["findFirst"] },
       ],
     });

src/index.ts

@@ -81,11 +81,7 @@ export const createPrismaRedisCache = ({
 
       // For each defined model in `models` we check if they defined any caching methods to be excluded
       const excludedCacheMethodsInModels = models?.find(({ model, excludeMethods }) => {
-        if (model === params.model && excludeMethods?.length) {
-          return true;
-        }
-
-        return false;
+        return model === params.model && excludeMethods?.length;
       });
 
       // Do not define a cache function for any Prisma model if it already exists
@@ -137,6 +133,18 @@ export const createPrismaRedisCache = ({
       // If we successfully executed the Mutation we clear and invalidate the cache for the Prisma model
       if (defaultMutationMethods.includes(params.action as PrismaMutationAction)) {
         await cache.invalidateAll(`*${params.model}~*`);
+
+        await Promise.all(
+          (models || [])
+            .filter(({ model }) => model === params.model)
+            .map(async ({ invalidateRelated }) => {
+              if (invalidateRelated) {
+                await Promise.all(
+                  invalidateRelated.map(async (relatedModel) => cache.invalidateAll(`*${relatedModel}~*`)),
+                );
+              }
+            }),
+        );
       }
     }
 

src/types.ts

@@ -60,10 +60,11 @@ export type TtlFunction = (data: any) => number;
 
 export type CreatePrismaRedisCache = {
   models?: {
-    model: string;
+    model: string | Prisma.ModelName;
     cacheKey?: string;
     cacheTime?: number | TtlFunction;
     excludeMethods?: PrismaQueryAction[];
+    invalidateRelated?: string[] | Prisma.ModelName[];
   }[];
   storage?:
     | {

test/index.test.ts

@@ -284,6 +284,63 @@ describe.each<{
     expect(JSON.parse((await redis.get(cacheKey2)) as string)).toMatchObject(dbValue);
   });
 
+  test("should invalidate a Prisma model cache and related Prisma models after data mutation", async () => {
+    const middleware = createPrismaRedisCache({
+      models: [
+        {
+          model: model1,
+          invalidateRelated: [model2],
+        },
+      ],
+      storage: { type: "redis", options: { client: redis, invalidation: true } },
+      cacheTime,
+    });
+
+    // Run a "fake" User Prisma query
+    await middleware(
+      {
+        args,
+        action: action1,
+        model: model1,
+        dataPath: [],
+        runInTransaction: false,
+      },
+      next,
+    );
+
+    // Run a "fake" Post Prisma query
+    await middleware(
+      {
+        args,
+        action: action2,
+        model: model2,
+        dataPath: [],
+        runInTransaction: false,
+      },
+      next,
+    );
+
+    // Test if data exists in the cache
+    expect(JSON.parse((await redis.get(cacheKey1)) as string)).toMatchObject(dbValue);
+    expect(JSON.parse((await redis.get(cacheKey2)) as string)).toMatchObject(dbValue);
+
+    // Run a "fake" User Prisma mutation
+    await middleware(
+      {
+        args,
+        action: "create",
+        model: model1,
+        dataPath: [],
+        runInTransaction: false,
+      },
+      next,
+    );
+
+    // Test if the cache was invalidated and cleared properly
+    assert.equal(JSON.parse((await redis.get(cacheKey1)) as string), null);
+    assert.equal(JSON.parse((await redis.get(cacheKey2)) as string), null);
+  });
+
   test("should not invalidate a Prisma model if cache method is excluded", async () => {
     const middleware = createPrismaRedisCache({
       storage: { type: "redis", options: { client: redis, invalidation: true } },