@knaus94/prisma-extension-cache-manager 2.0.0 → 2.0.2

package/README.md

@@ -6,7 +6,6 @@ A caching extension for [Prisma](https://www.prisma.io/), compatible with [cache
 
 - [cache-manager](https://www.npmjs.com/package/cache-manager) compatibility
 - Only model queries can be cacheable (no $query or $queryRaw)
-- Supported Decimal
 
 ## Installation
 

package/dist/index.d.ts

@@ -1,8 +1,5 @@
 import { ModelExtension, PrismaRedisCacheConfig } from "./types";
-/**
- * Prisma extension that adds transparent Redis caching.
- */
-declare const _default: ({ cache, debug, ttl: defaultTTL }: PrismaRedisCacheConfig) => (client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {
+declare const _default: ({ cache }: 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

@@ -1,167 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const object_code_1 = require("object-code");
 const types_1 = require("./types");
-const crypto_1 = require("crypto");
 const extension_1 = require("@prisma/client/extension");
-/**
- * Produce a stable cache key from model name and query arguments.
- */
-function generateComposedKey(options) {
-    const hash = (0, crypto_1.createHash)("md5")
-        .update(JSON.stringify(options.queryArgs))
-        .digest("hex");
-    return `${options.model}@${hash}`;
-}
-/**
- * Prefix the key with a namespace (if present).
- */
-function createKey(key, namespace) {
-    return namespace ? `${namespace}:${key}` : key;
-}
-/**
- * Delete keys from cache after a write operation.
- */
-async function processUncache(cache, uncacheOption, result) {
-    let keysToDelete = [];
-    if (typeof uncacheOption === "function") {
-        const keys = uncacheOption(result);
-        keysToDelete = Array.isArray(keys) ? keys : [keys];
-    }
-    else if (typeof uncacheOption === "string") {
-        keysToDelete = [uncacheOption];
-    }
-    else if (Array.isArray(uncacheOption)) {
-        if (typeof uncacheOption[0] === "string") {
-            keysToDelete = uncacheOption;
-        }
-        else if (typeof uncacheOption[0] === "object") {
-            keysToDelete = uncacheOption.map((obj) => obj.namespace ? `${obj.namespace}:${obj.key}` : obj.key);
-        }
-    }
-    if (keysToDelete.length === 0)
-        return true;
-    try {
-        await cache.mdel(keysToDelete);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Decide whether cache option is valid.
- */
-const shouldUseCache = (opt) => opt !== undefined &&
-    ["boolean", "object", "number", "string"].includes(typeof opt);
-/**
- * Decide whether uncache option is valid.
- */
-const shouldUseUncache = (opt) => opt !== undefined &&
-    (typeof opt === "function" || typeof opt === "string" || Array.isArray(opt));
-/**
- * Prisma extension that adds transparent Redis caching.
- */
-exports.default = ({ cache, debug, ttl: defaultTTL }) => extension_1.Prisma.defineExtension({
+/* helpers -------------------------------------------------------------- */
+const composedKey = (m, a) => `${m}@${(0, object_code_1.hash)(a)}`;
+const ns = (k, n) => (n ? `${n}:${k}` : k);
+const isWrite = (op) => ["create", "createMany", "updateMany", "upsert", "update"].includes(op);
+/* uncache → массив строк */
+const toUncache = (opt, res) => !opt
+    ? []
+    : typeof opt === "function"
+        ? [].concat(opt(res))
+        : typeof opt === "string"
+            ? [opt]
+            : opt.map((o) => typeof o === "string" ? o : ns(o.key, o.namespace));
+const processUncache = async (cache, opt, res) => {
+    const keys = toUncache(opt, res);
+    if (keys.length)
+        await cache.mdel(keys).catch(() => { });
+};
+/* extension ------------------------------------------------------------ */
+exports.default = ({ cache }) => extension_1.Prisma.defineExtension({
     name: "prisma-extension-cache-manager",
-    client: {
-        $cache: cache,
-    },
-    model: {
-        $allModels: {},
-    },
+    client: { $cache: cache },
+    model: { $allModels: {} },
     query: {
         $allModels: {
             async $allOperations({ model, operation, args, query }) {
-                if (!types_1.CACHE_OPERATIONS.includes(operation)) {
+                if (!types_1.CACHE_OPERATIONS.includes(operation))
                     return query(args);
+                const { cache: cOpt, uncache, ...queryArgs } = args;
+                if (cOpt === undefined) {
+                    const db = await query(queryArgs);
+                    await processUncache(cache, uncache, db);
+                    return db;
                 }
-                const isWriteOp = [
-                    "create",
-                    "createMany",
-                    "updateMany",
-                    "upsert",
-                    "update",
-                ].includes(operation);
-                const { cache: cacheOption, uncache: uncacheOption, ...queryArgs } = args;
-                const useCache = shouldUseCache(cacheOption);
-                const useUncache = shouldUseUncache(uncacheOption);
-                // --- No cache requested -----------------------------------------
-                if (!useCache) {
-                    const res = await query(queryArgs);
-                    if (useUncache)
-                        await processUncache(cache, uncacheOption, res);
-                    return res;
-                }
-                // --- Build key & ttl --------------------------------------------
-                let cacheKey;
-                let ttl;
-                if (["boolean", "number", "string"].includes(typeof cacheOption)) {
-                    cacheKey =
-                        typeof cacheOption === "string"
-                            ? cacheOption
-                            : generateComposedKey({ model, queryArgs });
-                    ttl = typeof cacheOption === "number" ? cacheOption : undefined;
+                let key;
+                let ttlMs;
+                if (typeof cOpt !== "object" || Array.isArray(cOpt)) {
+                    key =
+                        typeof cOpt === "string" ? cOpt : composedKey(model, queryArgs);
+                    if (typeof cOpt === "number")
+                        ttlMs = cOpt;
                 }
-                else if (typeof cacheOption.key === "function") {
-                    // Key depends on DB result – run query first
-                    const res = await query(queryArgs);
-                    if (useUncache)
-                        await processUncache(cache, uncacheOption, res);
-                    cacheKey = cacheOption.key(res);
-                    ttl = cacheOption.ttl ?? defaultTTL;
-                    if (ttl && ttl > 0) {
-                        await cache.set(cacheKey, res, Math.ceil(ttl / 1000));
-                    }
-                    else {
-                        await cache.set(cacheKey, res);
-                    }
-                    if (debug)
-                        console.log("Data cached (fn key):", cacheKey);
-                    return res;
+                else if (typeof cOpt.key === "function") {
+                    const db = await query(queryArgs);
+                    await processUncache(cache, uncache, db);
+                    key = cOpt.key(db);
+                    ttlMs = cOpt.ttl ?? undefined;
+                    await cache.set(key, db, Math.ceil((ttlMs ?? 0) / 1000));
+                    return db;
                 }
                 else {
-                    cacheKey =
-                        createKey(cacheOption.key, cacheOption.namespace) ||
-                            generateComposedKey({ model, queryArgs });
-                    ttl = cacheOption.ttl;
-                }
-                // --- Try cache for read ops -------------------------------------
-                if (!isWriteOp) {
-                    try {
-                        const cached = await cache.get(cacheKey);
-                        if (cached !== undefined && cached !== null) {
-                            if (debug)
-                                console.log("Cache hit:", cacheKey);
-                            return cached;
-                        }
-                        if (debug)
-                            console.log("Cache miss:", cacheKey);
-                    }
-                    catch (e) {
-                        if (debug)
-                            console.error("Cache get failed", e);
-                    }
-                }
-                // --- Fallback to DB ---------------------------------------------
-                const res = await query(queryArgs);
-                if (useUncache)
-                    await processUncache(cache, uncacheOption, res);
-                ttl = ttl ?? defaultTTL;
-                try {
-                    if (ttl && ttl > 0) {
-                        await cache.set(cacheKey, res, Math.ceil(ttl / 1000));
-                    }
-                    else {
-                        await cache.set(cacheKey, res);
-                    }
-                    if (debug)
-                        console.log("Data cached:", cacheKey);
+                    key = ns(cOpt.key ?? composedKey(model, queryArgs), cOpt.namespace);
+                    ttlMs = cOpt.ttl ?? undefined;
                 }
-                catch (e) {
-                    if (debug)
-                        console.error("Cache set failed", e);
+                if (!isWrite(operation)) {
+                    const hit = await cache.get(key).catch(() => undefined);
+                    if (hit !== undefined && hit !== null)
+                        return hit;
                 }
-                return res;
+                const db = await query(queryArgs);
+                await processUncache(cache, uncache, db);
+                await cache.set(key, db, ttlMs !== undefined ? Math.ceil(ttlMs / 1000) : undefined);
+                return db;
             },
         },
     },

package/dist/types.d.ts

@@ -35,7 +35,5 @@ export interface PrismaCacheArgs<T, A, O extends RequiredArgsOperation | Optiona
 }
 export interface PrismaRedisCacheConfig {
     cache: Cache;
-    debug?: boolean;
-    ttl?: number;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knaus94/prisma-extension-cache-manager",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/knaus94/prisma-extension-cache-manager.git"
@@ -55,7 +55,8 @@
   },
   "dependencies": {
     "@prisma/client": "^6.8.2",
-    "cache-manager": "^6.4.3"
+    "cache-manager": "^6.4.3",
+    "object-code": "^1.3.3"
   },
   "peerDependencies": {
     "@nestjs/cache-manager": "^3.0.1",