@knaus94/prisma-extension-cache-manager 1.4.2 → 1.5.0

package/dist/index.d.ts

@@ -1,7 +1,12 @@
 import { ModelExtension, PrismaRedisCacheConfig } from "./types";
+/**
+ * Основная функция расширения Prisma для управления кешированием с использованием Redis.
+ * @param config - Конфигурация для кеша Redis и TTL по умолчанию.
+ * @returns Prisma расширение.
+ */
 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;
+    $cache: import("cache-manager-ioredis-yet").RedisCache;
 }>>;
 export default _default;

package/dist/index.js

@@ -1,23 +1,124 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const extension_1 = require("@prisma/client/extension");
 const types_1 = require("./types");
 const crypto_1 = require("crypto");
+const library_1 = require("@prisma/client/runtime/library");
+const extension_1 = require("@prisma/client/extension");
+const msgpack5_1 = __importDefault(require("msgpack5"));
+/**
+ * Генерирует уникальный ключ для кеширования на основе модели и аргументов запроса.
+ * @param options - Опции для генерации ключа.
+ * @returns Сгенерированный ключ.
+ */
 function generateComposedKey(options) {
     const hash = (0, crypto_1.createHash)("md5")
-        .update(JSON.stringify(options?.queryArgs))
+        .update(JSON.stringify(options.queryArgs))
         .digest("hex");
     return `${options.model}@${hash}`;
 }
+/**
+ * Создаёт ключ с опциональным пространством имен.
+ * @param key - Основной ключ.
+ * @param namespace - Пространство имен.
+ * @returns Полный ключ с пространством имен, если оно указано.
+ */
 function createKey(key, namespace) {
     return namespace ? `${namespace}:${key}` : key;
 }
+// Универсальная функция для сериализации данных
 function serializeData(data) {
-    return JSON.stringify({ data });
+    if (data instanceof Date) {
+        return { __type: "Date", value: data.toISOString() };
+    }
+    else if (data instanceof library_1.Decimal) {
+        return { __type: "Decimal", value: data.toString() };
+    }
+    else if (Array.isArray(data)) {
+        return data.map(serializeData); // Рекурсивно обрабатываем массивы
+    }
+    else if (data !== null && typeof data === "object") {
+        return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, serializeData(value)]));
+    }
+    return data; // Простые значения возвращаем как есть
+}
+// Универсальная функция для десериализации данных
+function deserializeData(data) {
+    if (data && data.__type === "Date") {
+        return new Date(data.value);
+    }
+    else if (data && data.__type === "Decimal") {
+        return new library_1.Decimal(data.value);
+    }
+    else if (Array.isArray(data)) {
+        return data.map(deserializeData); // Рекурсивно обрабатываем массивы
+    }
+    else if (data !== null && typeof data === "object") {
+        return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, deserializeData(value)]));
+    }
+    return data; // Простые значения возвращаем как есть
 }
-function deserializeData(serializedData) {
-    return JSON.parse(serializedData).data;
+/**
+ * Обрабатывает удаление ключей из кеша после операций записи.
+ * @param cache - Кеш-менеджер.
+ * @param uncacheOption - Опции удаления кеша.
+ * @param result - Результат операции.
+ * @returns Promise<boolean> указывающий на успешность удаления.
+ */
+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.store.mdel(...keysToDelete);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
 }
+/**
+ * Определяет, следует ли использовать кеширование для текущей операции.
+ * @param cacheOption - Опции кеширования.
+ * @returns boolean указывающий, использовать ли кеш.
+ */
+function shouldUseCache(cacheOption) {
+    return (cacheOption !== undefined &&
+        ["boolean", "object", "number", "string"].includes(typeof cacheOption));
+}
+/**
+ * Определяет, следует ли использовать удаление из кеша для текущей операции.
+ * @param uncacheOption - Опции удаления кеша.
+ * @returns boolean указывающий, использовать ли удаление кеша.
+ */
+function shouldUseUncache(uncacheOption) {
+    return (uncacheOption !== undefined &&
+        (typeof uncacheOption === "function" ||
+            typeof uncacheOption === "string" ||
+            Array.isArray(uncacheOption)));
+}
+/**
+ * Основная функция расширения Prisma для управления кешированием с использованием Redis.
+ * @param config - Конфигурация для кеша Redis и TTL по умолчанию.
+ * @returns Prisma расширение.
+ */
 exports.default = ({ cache, defaultTTL }) => {
     return extension_1.Prisma.defineExtension({
         name: "prisma-extension-cache-manager",
@@ -29,9 +130,16 @@ exports.default = ({ cache, defaultTTL }) => {
         },
         query: {
             $allModels: {
+                /**
+                 * Обрабатывает все операции моделей, добавляя логику кеширования.
+                 * @param params - Параметры операции.
+                 * @returns Результат операции, возможно из кеша.
+                 */
                 async $allOperations({ model, operation, args, query }) {
-                    if (!types_1.CACHE_OPERATIONS.includes(operation))
+                    // Проверяем, относится ли операция к кешируемым
+                    if (!types_1.CACHE_OPERATIONS.includes(operation)) {
                         return query(args);
+                    }
                     const isWriteOperation = [
                         "create",
                         "createMany",
@@ -40,88 +148,63 @@ exports.default = ({ cache, defaultTTL }) => {
                         "update",
                     ].includes(operation);
                     const { cache: cacheOption, uncache: uncacheOption, ...queryArgs } = args;
-                    function processUncache(result) {
-                        const option = uncacheOption;
-                        let keysToDelete = [];
-                        if (typeof option === "function") {
-                            const keys = option(result);
-                            keysToDelete = Array.isArray(keys) ? keys : [keys];
-                        }
-                        else if (typeof option === "string") {
-                            keysToDelete = [option];
-                        }
-                        else if (Array.isArray(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;
-                        return cache.store
-                            .mdel(...keysToDelete)
-                            .then(() => true)
-                            .catch(() => false);
-                    }
-                    const useCache = cacheOption !== undefined &&
-                        ["boolean", "object", "number", "string"].includes(typeof cacheOption);
-                    const useUncache = uncacheOption !== undefined &&
-                        (typeof uncacheOption === "function" ||
-                            typeof uncacheOption === "string" ||
-                            Array.isArray(uncacheOption));
+                    const useCache = shouldUseCache(cacheOption);
+                    const useUncache = shouldUseUncache(uncacheOption);
+                    // Если не используем кеш, просто выполняем запрос и обрабатываем удаление кеша, если требуется
                     if (!useCache) {
                         const result = await query(queryArgs);
-                        if (useUncache)
-                            processUncache(result);
+                        if (useUncache) {
+                            await processUncache(cache, uncacheOption, result);
+                        }
                         return result;
                     }
+                    // Генерация ключа кеша
+                    let cacheKey;
+                    let ttl;
                     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) {
-                                return deserializeData(cached);
-                            }
-                        }
-                        const result = await query(queryArgs);
-                        if (useUncache)
-                            processUncache(result);
-                        const ttl = typeof cacheOption === "number"
-                            ? cacheOption
-                            : defaultTTL ?? undefined;
-                        await cache.set(cacheKey, serializeData(result), ttl);
-                        return result;
+                        cacheKey =
+                            typeof cacheOption === "string"
+                                ? cacheOption
+                                : generateComposedKey({ model, queryArgs });
+                        ttl = typeof cacheOption === "number" ? cacheOption : defaultTTL;
                     }
-                    if (typeof cacheOption.key === "function") {
+                    else if (typeof cacheOption.key === "function") {
                         const result = await query(queryArgs);
-                        if (useUncache)
-                            processUncache(result);
-                        const customCacheKey = cacheOption.key(result);
-                        await cache.set(customCacheKey, serializeData(result), cacheOption.ttl ?? defaultTTL);
+                        if (useUncache) {
+                            await processUncache(cache, uncacheOption, result);
+                        }
+                        cacheKey = cacheOption.key(result);
+                        ttl = cacheOption.ttl ?? defaultTTL;
+                        await cache.set(cacheKey, msgpack5_1.default.encode(serializeData(result)), ttl);
                         return result;
                     }
-                    const customCacheKey = createKey(cacheOption.key, cacheOption.namespace) ||
-                        generateComposedKey({
-                            model,
-                            queryArgs,
-                        });
+                    else {
+                        cacheKey =
+                            createKey(cacheOption.key, cacheOption.namespace) ||
+                                generateComposedKey({ model, queryArgs });
+                        ttl = cacheOption.ttl ?? defaultTTL;
+                    }
+                    // Для операций чтения пытаемся получить данные из кеша
                     if (!isWriteOperation) {
-                        const cached = await cache.get(customCacheKey);
-                        if (cached) {
-                            return deserializeData(cached);
+                        try {
+                            const cached = await cache.store.client.getBuffer(cacheKey);
+                            if (cached) {
+                                return deserializeData(msgpack5_1.default.decode(cached));
+                            }
                         }
+                        catch { }
                     }
+                    // Выполняем запрос к базе данных
                     const result = await query(queryArgs);
-                    if (useUncache)
-                        processUncache(result);
-                    await cache.set(customCacheKey, serializeData(result), cacheOption.ttl ?? defaultTTL);
+                    // Обрабатываем удаление кеша, если требуется
+                    if (useUncache) {
+                        await processUncache(cache, uncacheOption, result);
+                    }
+                    // Сохраняем результат в кеш
+                    try {
+                        await cache.set(cacheKey, msgpack5_1.default.encode(serializeData(result)), ttl);
+                    }
+                    catch { }
                     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", "createMany", "updateMany"];
+import { RedisCache } from "cache-manager-ioredis-yet";
+export declare const REQUIRED_ARGS_OPERATIONS: readonly ["delete", "findUnique", "findUniqueOrThrow", "aggregate", "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", "createMany", "updateMany", "findMany", "findFirst", "findFirstOrThrow", "count"];
+export declare const CACHE_OPERATIONS: readonly ["delete", "findUnique", "findUniqueOrThrow", "aggregate", "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>>) => Prisma.PrismaPromise<Prisma.Result<T, A, O>>;
@@ -34,7 +34,7 @@ export interface PrismaCacheArgs<T, A, O extends RequiredArgsOperation | Optiona
     }[];
 }
 export interface PrismaRedisCacheConfig {
-    cache: Cache;
+    cache: RedisCache;
     defaultTTL?: number;
 }
 export {};

package/dist/types.js

@@ -5,6 +5,7 @@ exports.REQUIRED_ARGS_OPERATIONS = [
     "delete",
     "findUnique",
     "findUniqueOrThrow",
+    "aggregate",
     "groupBy",
     "update",
     "upsert",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knaus94/prisma-extension-cache-manager",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/knaus94/prisma-extension-cache-manager.git"
@@ -55,6 +55,8 @@
   },
   "dependencies": {
     "@prisma/client": "^5.7.1",
-    "cache-manager": "^5.2.1"
+    "cache-manager": "^5.2.3",
+    "cache-manager-ioredis-yet": "^2.1.1",
+    "msgpack5": "^6.0.2"
   }
 }