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

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,166 +1,83 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
-const crypto_1 = require("crypto");
+const object_code_1 = require("object-code");
 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 hashKey = (m, a) => `${m}@${(0, object_code_1.hash)(a)}`;
+const ns = (k, n) => (n ? `${n}:${k}` : k);
+const WRITE_OPS = new Set([
+    "create",
+    "createMany",
+    "updateMany",
+    "upsert",
+    "update",
+]);
+const toUncache = (opt, res) => !opt
+    ? []
+    : typeof opt === "function"
+        ? Array(opt(res))
+        : typeof opt === "string"
+            ? [opt]
+            : opt.map((o) => typeof o === "string" ? o : ns(o.key, o.namespace));
+/* 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 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);
+                const { cache: cOpt, uncache, ...queryArgs } = args;
+                const finish = async (res) => {
+                    const dels = toUncache(uncache, res);
+                    if (dels.length)
+                        cache.mdel(dels).catch(() => { });
                     return res;
-                }
-                // --- Build key & ttl --------------------------------------------
-                let cacheKey;
+                };
+                if (cOpt === undefined)
+                    return finish(await query(queryArgs));
+                /* key + ttl */
+                let key;
                 let ttl;
-                if (["boolean", "number", "string"].includes(typeof cacheOption)) {
-                    cacheKey =
-                        typeof cacheOption === "string"
-                            ? cacheOption
-                            : generateComposedKey({ model, queryArgs });
-                    ttl = typeof cacheOption === "number" ? cacheOption : undefined;
+                if (typeof cOpt !== "object" || Array.isArray(cOpt)) {
+                    key = typeof cOpt === "string" ? cOpt : hashKey(model, queryArgs);
+                    if (typeof cOpt === "number")
+                        ttl = cOpt;
                 }
-                else if (typeof cacheOption.key === "function") {
-                    // Key depends on DB result – run query first
+                else if (typeof cOpt.key === "function") {
                     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);
+                    await finish(res);
+                    key = cOpt.key(res);
+                    ttl = cOpt.ttl; // как есть
+                    try {
+                        await cache.set(key, res, ttl);
                     }
-                    if (debug)
-                        console.log("Data cached (fn key):", cacheKey);
+                    catch { }
                     return res;
                 }
                 else {
-                    cacheKey =
-                        createKey(cacheOption.key, cacheOption.namespace) ||
-                            generateComposedKey({ model, queryArgs });
-                    ttl = cacheOption.ttl;
+                    key = ns(cOpt.key ?? hashKey(model, queryArgs), cOpt.namespace);
+                    ttl = cOpt.ttl;
                 }
-                // --- Try cache for read ops -------------------------------------
-                if (!isWriteOp) {
+                /* try cache for reads */
+                if (!WRITE_OPS.has(operation)) {
                     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);
+                        const hit = await cache.get(key);
+                        if (hit != null)
+                            return hit;
                     }
+                    catch { }
                 }
-                // --- Fallback to DB ---------------------------------------------
+                /* DB round-trip */
                 const res = await query(queryArgs);
-                if (useUncache)
-                    await processUncache(cache, uncacheOption, res);
-                ttl = ttl ?? defaultTTL;
+                await finish(res);
                 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);
-                }
-                catch (e) {
-                    if (debug)
-                        console.error("Cache set failed", e);
+                    await cache.set(key, res, ttl);
                 }
+                catch { }
                 return res;
             },
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knaus94/prisma-extension-cache-manager",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "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",