@knaus94/prisma-extension-cache-manager 1.3.8 → 1.4.0

package/README.md

@@ -27,9 +27,7 @@ async function main() {
     ttl: 10000,
     max: 200,
   });
-  const prisma = new PrismaClient().$extends(
-    cacheExtension({ cache })
-  );
+  const prisma = new PrismaClient().$extends(cacheExtension({ cache }));
   await prisma.user.findUniqueOrThrow({
     where: {
       email: user.email,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { ModelExtension, PrismaRedisCacheConfig } from "./types";
-declare const _default: ({ cache }: PrismaRedisCacheConfig) => (client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {
+declare const _default: ({ cache, defaultTTL }: PrismaRedisCacheConfig) => (client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {
     $allModels: ModelExtension;
 }, {}, {
     $cache: import("cache-manager").Cache;

package/dist/index.js

@@ -7,7 +7,10 @@ function generateComposedKey(options) {
     const hash = (0, crypto_1.createHash)("md5")
         .update(JSON.stringify(options?.queryArgs))
         .digest("hex");
-    return `Prisma@${options.model}@${hash}`;
+    return `${options.model}@${hash}`;
+}
+function createKey(key, namespace) {
+    return namespace ? `${namespace}:${key}` : key;
 }
 function serializeData(data) {
     return JSON.stringify({ data });
@@ -15,7 +18,7 @@ function serializeData(data) {
 function deserializeData(serializedData) {
     return JSON.parse(serializedData).data;
 }
-exports.default = ({ cache }) => {
+exports.default = ({ cache, defaultTTL }) => {
     return extension_1.Prisma.defineExtension({
         name: "prisma-extension-cache-manager",
         client: {
@@ -31,6 +34,8 @@ exports.default = ({ cache }) => {
                         return query(args);
                     const isWriteOperation = [
                         "create",
+                        "createMany",
+                        "updateMany",
                         "upsert",
                         "update",
                     ].includes(operation);
@@ -46,7 +51,12 @@ exports.default = ({ cache }) => {
                             keysToDelete = [option];
                         }
                         else if (Array.isArray(option)) {
-                            keysToDelete = option;
+                            if (typeof option[0] === "string") {
+                                keysToDelete = option;
+                            }
+                            else if (typeof option[0] === "object") {
+                                keysToDelete = option.map((obj) => obj.namespace ? `${obj.namespace}:${obj.key}` : obj.key);
+                            }
                         }
                         if (!keysToDelete.length)
                             return true;
@@ -56,7 +66,7 @@ exports.default = ({ cache }) => {
                             .catch(() => false);
                     }
                     const useCache = cacheOption !== undefined &&
-                        ["boolean", "object", "number"].includes(typeof cacheOption);
+                        ["boolean", "object", "number", "string"].includes(typeof cacheOption);
                     const useUncache = uncacheOption !== undefined &&
                         (typeof uncacheOption === "function" ||
                             typeof uncacheOption === "string" ||
@@ -67,11 +77,13 @@ exports.default = ({ cache }) => {
                             processUncache(result);
                         return result;
                     }
-                    if (["boolean", "number"].includes(typeof cacheOption)) {
-                        const cacheKey = generateComposedKey({
-                            model,
-                            queryArgs,
-                        });
+                    if (["boolean", "number", "string"].includes(typeof cacheOption)) {
+                        const cacheKey = typeof cacheOption === "string"
+                            ? cacheOption
+                            : generateComposedKey({
+                                model,
+                                queryArgs,
+                            });
                         if (!isWriteOperation) {
                             const cached = await cache.get(cacheKey);
                             if (cached) {
@@ -81,20 +93,21 @@ exports.default = ({ cache }) => {
                         const result = await query(queryArgs);
                         if (useUncache)
                             processUncache(result);
-                        const ttl = typeof cacheOption === "number" ? cacheOption : undefined;
+                        const ttl = typeof cacheOption === "number"
+                            ? cacheOption
+                            : defaultTTL ?? undefined;
                         await cache.set(cacheKey, serializeData(result), ttl);
                         return result;
                     }
-                    const { key, ttl } = cacheOption;
-                    if (typeof key === "function") {
+                    if (typeof cacheOption.key === "function") {
                         const result = await query(queryArgs);
                         if (useUncache)
                             processUncache(result);
-                        const customCacheKey = key(result);
-                        await cache.set(customCacheKey, serializeData(result), ttl);
+                        const customCacheKey = cacheOption.key(result);
+                        await cache.set(customCacheKey, serializeData(result), cacheOption.ttl ?? defaultTTL);
                         return result;
                     }
-                    const customCacheKey = key ||
+                    const customCacheKey = createKey(cacheOption.key, cacheOption.namespace) ||
                         generateComposedKey({
                             model,
                             queryArgs,
@@ -108,7 +121,7 @@ exports.default = ({ cache }) => {
                     const result = await query(queryArgs);
                     if (useUncache)
                         processUncache(result);
-                    await cache.set(customCacheKey, serializeData(result), ttl);
+                    await cache.set(customCacheKey, serializeData(result), cacheOption.ttl ?? defaultTTL);
                     return result;
                 },
             },

package/dist/types.d.ts

@@ -1,8 +1,8 @@
 import { Prisma } from "@prisma/client/extension";
 import { Cache } from "cache-manager";
-export declare const REQUIRED_ARGS_OPERATIONS: readonly ["delete", "findUnique", "findUniqueOrThrow", "groupBy", "update", "upsert", "create"];
+export declare const REQUIRED_ARGS_OPERATIONS: readonly ["delete", "findUnique", "findUniqueOrThrow", "groupBy", "update", "upsert", "create", "createMany", "updateMany"];
 export declare const OPTIONAL_ARGS_OPERATIONS: readonly ["findMany", "findFirst", "findFirstOrThrow", "count"];
-export declare const CACHE_OPERATIONS: readonly ["delete", "findUnique", "findUniqueOrThrow", "groupBy", "update", "upsert", "create", "findMany", "findFirst", "findFirstOrThrow", "count"];
+export declare const CACHE_OPERATIONS: readonly ["delete", "findUnique", "findUniqueOrThrow", "groupBy", "update", "upsert", "create", "createMany", "updateMany", "findMany", "findFirst", "findFirstOrThrow", "count"];
 type RequiredArgsOperation = (typeof REQUIRED_ARGS_OPERATIONS)[number];
 type OptionalArgsOperation = (typeof OPTIONAL_ARGS_OPERATIONS)[number];
 type RequiredArgsFunction<O extends RequiredArgsOperation> = <T, A>(this: T, args: Prisma.Exact<A, Prisma.Args<T, O> & PrismaCacheArgs<T, A, O>>) => Promise<Prisma.Result<T, A, O>>;
@@ -17,16 +17,24 @@ export interface CacheOptions<T, A, O extends RequiredArgsOperation | OptionalAr
      * Cache key
      */
     key: ((result: Prisma.Result<T, A, O>) => string) | string;
+    /**
+     * Cache namespace
+     */
+    namespace?: string;
     /**
      * Time to live
      */
     ttl?: number;
 }
 export interface PrismaCacheArgs<T, A, O extends RequiredArgsOperation | OptionalArgsOperation> {
-    cache?: boolean | number | CacheOptions<T, A, O>;
-    uncache?: ((result: Prisma.Result<T, A, O>) => string[] | string) | string | string[];
+    cache?: boolean | number | string | CacheOptions<T, A, O>;
+    uncache?: ((result: Prisma.Result<T, A, O>) => string[] | string) | string | string[] | {
+        key: string;
+        namespace?: string;
+    }[];
 }
 export interface PrismaRedisCacheConfig {
     cache: Cache;
+    defaultTTL?: number;
 }
 export {};

package/dist/types.js

@@ -9,6 +9,8 @@ exports.REQUIRED_ARGS_OPERATIONS = [
     "update",
     "upsert",
     "create",
+    "createMany",
+    "updateMany",
 ];
 exports.OPTIONAL_ARGS_OPERATIONS = [
     "findMany",

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "@knaus94/prisma-extension-cache-manager",
-  "version": "1.3.8",
+  "version": "1.4.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/knaus94/prisma-extension-cache-manager.git"
   },
-  "homepage": "https://github.com/knaus94/prisma-extension-cache-manager",
-  "bugs": "https://github.com/knaus94/prisma-extension-cache-manager/issues",
   "author": {
     "name": "knaus94",
     "url": "https://github.com/knaus94"
@@ -59,4 +57,4 @@
     "@prisma/client": "^5.7.1",
     "cache-manager": "^5.2.1"
   }
-}
+}