@knaus94/prisma-extension-cache-manager 0.0.2

package/README.md

@@ -0,0 +1 @@
+# prisma-extension-cache-manager

package/dist/index.d.mts

@@ -0,0 +1,43 @@
+import * as _prisma_client_extension from '@prisma/client/extension';
+import { Prisma } from '@prisma/client/extension';
+import * as _prisma_client_runtime_library from '@prisma/client/runtime/library';
+import * as cache_manager from 'cache-manager';
+import { Cache } from 'cache-manager';
+
+declare const REQUIRED_ARGS_OPERATIONS: readonly ["findUnique", "findUniqueOrThrow", "groupBy"];
+declare const OPTIONAL_ARGS_OPERATIONS: readonly ["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>) => Promise<Prisma.Result<T, A, O>>;
+type OptionalArgsFunction<O extends OptionalArgsOperation> = <T, A>(this: T, args?: Prisma.Exact<A, Prisma.Args<T, O> & PrismaCacheArgs>) => Promise<Prisma.Result<T, A, O>>;
+type ModelExtension = {
+    [O1 in RequiredArgsOperation]: RequiredArgsFunction<O1>;
+} & {
+    [O2 in OptionalArgsOperation]: OptionalArgsFunction<O2>;
+};
+interface CacheOptions {
+    /**
+     * Cache key
+     */
+    key: string;
+    /**
+     * Time to live
+     */
+    ttl?: number;
+}
+interface PrismaCacheArgs {
+    cache?: boolean | CacheOptions;
+}
+interface PrismaRedisCacheConfig {
+    cache: Cache;
+}
+
+declare const _default: ({ cache }: PrismaRedisCacheConfig) => (client: any) => _prisma_client_extension.PrismaClientExtends<_prisma_client_runtime_library.InternalArgs<{}, {
+    $allModels: ModelExtension;
+}, {}, {
+    cache: {
+        store: cache_manager.Cache;
+    };
+}>>;
+
+export { _default as default };

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import * as _prisma_client_extension from '@prisma/client/extension';
+import { Prisma } from '@prisma/client/extension';
+import * as _prisma_client_runtime_library from '@prisma/client/runtime/library';
+import * as cache_manager from 'cache-manager';
+import { Cache } from 'cache-manager';
+
+declare const REQUIRED_ARGS_OPERATIONS: readonly ["findUnique", "findUniqueOrThrow", "groupBy"];
+declare const OPTIONAL_ARGS_OPERATIONS: readonly ["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>) => Promise<Prisma.Result<T, A, O>>;
+type OptionalArgsFunction<O extends OptionalArgsOperation> = <T, A>(this: T, args?: Prisma.Exact<A, Prisma.Args<T, O> & PrismaCacheArgs>) => Promise<Prisma.Result<T, A, O>>;
+type ModelExtension = {
+    [O1 in RequiredArgsOperation]: RequiredArgsFunction<O1>;
+} & {
+    [O2 in OptionalArgsOperation]: OptionalArgsFunction<O2>;
+};
+interface CacheOptions {
+    /**
+     * Cache key
+     */
+    key: string;
+    /**
+     * Time to live
+     */
+    ttl?: number;
+}
+interface PrismaCacheArgs {
+    cache?: boolean | CacheOptions;
+}
+interface PrismaRedisCacheConfig {
+    cache: Cache;
+}
+
+declare const _default: ({ cache }: PrismaRedisCacheConfig) => (client: any) => _prisma_client_extension.PrismaClientExtends<_prisma_client_runtime_library.InternalArgs<{}, {
+    $allModels: ModelExtension;
+}, {}, {
+    cache: {
+        store: cache_manager.Cache;
+    };
+}>>;
+
+export { _default as default };

package/dist/index.global.js

@@ -0,0 +1,168 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // node_modules/@prisma/client/scripts/default-index.js
+  var require_default_index = __commonJS({
+    "node_modules/@prisma/client/scripts/default-index.js"(exports, module) {
+      "use strict";
+      var __defProp2 = Object.defineProperty;
+      var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+      var __getOwnPropNames2 = Object.getOwnPropertyNames;
+      var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+      var __export = (target, all) => {
+        for (var name in all)
+          __defProp2(target, name, { get: all[name], enumerable: true });
+      };
+      var __copyProps2 = (to, from, except, desc) => {
+        if (from && typeof from === "object" || typeof from === "function") {
+          for (let key of __getOwnPropNames2(from))
+            if (!__hasOwnProp2.call(to, key) && key !== except)
+              __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        }
+        return to;
+      };
+      var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+      var default_index_exports = {};
+      __export(default_index_exports, {
+        Prisma: () => Prisma2,
+        PrismaClient: () => PrismaClient,
+        default: () => default_index_default
+      });
+      module.exports = __toCommonJS(default_index_exports);
+      var prisma = {
+        enginesVersion: "0a83d8541752d7582de2ebc1ece46519ce72a848"
+      };
+      var version = "5.8.0";
+      var clientVersion = version;
+      var PrismaClient = class {
+        constructor() {
+          throw new Error(
+            `@prisma/client did not initialize yet. Please run "prisma generate" and try to import it again.
+In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues`
+          );
+        }
+      };
+      function defineExtension(ext) {
+        if (typeof ext === "function") {
+          return ext;
+        }
+        return (client) => client.$extends(ext);
+      }
+      function getExtensionContext(that) {
+        return that;
+      }
+      var Prisma2 = {
+        defineExtension,
+        getExtensionContext,
+        prismaVersion: { client: clientVersion, engine: prisma.enginesVersion }
+      };
+      var default_index_default = { Prisma: Prisma2 };
+    }
+  });
+
+  // node_modules/@prisma/client/extension.js
+  var require_extension = __commonJS({
+    "node_modules/@prisma/client/extension.js"(exports, module) {
+      "use strict";
+      module.exports = {
+        ...require_default_index()
+      };
+    }
+  });
+
+  // src/index.ts
+  var import_extension = __toESM(require_extension());
+
+  // src/types.ts
+  var REQUIRED_ARGS_OPERATIONS = [
+    "findUnique",
+    "findUniqueOrThrow",
+    "groupBy"
+  ];
+  var OPTIONAL_ARGS_OPERATIONS = [
+    "findMany",
+    "findFirst",
+    "findFirstOrThrow",
+    "count"
+  ];
+  var CACHE_OPERATIONS = [
+    ...REQUIRED_ARGS_OPERATIONS,
+    ...OPTIONAL_ARGS_OPERATIONS
+  ];
+
+  // src/index.ts
+  var src_default = ({ cache }) => {
+    return import_extension.Prisma.defineExtension({
+      name: "prisma-extension-cache-manager",
+      client: {
+        cache: { store: cache }
+      },
+      model: {
+        $allModels: {}
+      },
+      query: {
+        $allModels: {
+          async $allOperations({ model, operation, args, query }) {
+            let result;
+            const useCache = ["boolean", "object"].includes(typeof args["cache"]) && args["cache"] !== null && CACHE_OPERATIONS.includes(operation);
+            if (!useCache)
+              return query(args);
+            const queryArgs = {
+              ...args
+            };
+            delete queryArgs["cache"];
+            if (typeof args["cache"] === "boolean") {
+              const cacheKey = `prisma-${model}-${JSON.stringify(queryArgs)}`;
+              const cached2 = await cache.get(cacheKey);
+              if (cached2) {
+                return typeof cached2 === "string" ? JSON.parse(cached2) : cached2;
+              }
+              result = await query(queryArgs);
+              await cache.set(cacheKey, JSON.stringify(result));
+              return result;
+            }
+            const { key, ttl } = args["cache"];
+            const customCacheKey = key || `prisma-custom-${model}-${JSON.stringify(queryArgs)}`;
+            const cached = await cache.get(customCacheKey);
+            if (cached) {
+              return typeof cached === "string" ? JSON.parse(cached) : cached;
+            }
+            result = await query(queryArgs);
+            const value = JSON.stringify(result);
+            if (ttl) {
+              await cache.set(customCacheKey, value, ttl);
+            } else {
+              await cache.set(customCacheKey, value);
+            }
+            return result;
+          }
+        }
+      }
+    });
+  };
+})();

package/dist/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_extension = require("@prisma/client/extension");
+
+// src/types.ts
+var REQUIRED_ARGS_OPERATIONS = [
+  "findUnique",
+  "findUniqueOrThrow",
+  "groupBy"
+];
+var OPTIONAL_ARGS_OPERATIONS = [
+  "findMany",
+  "findFirst",
+  "findFirstOrThrow",
+  "count"
+];
+var CACHE_OPERATIONS = [
+  ...REQUIRED_ARGS_OPERATIONS,
+  ...OPTIONAL_ARGS_OPERATIONS
+];
+
+// src/index.ts
+var src_default = ({ cache }) => {
+  return import_extension.Prisma.defineExtension({
+    name: "prisma-extension-cache-manager",
+    client: {
+      cache: { store: cache }
+    },
+    model: {
+      $allModels: {}
+    },
+    query: {
+      $allModels: {
+        async $allOperations({ model, operation, args, query }) {
+          let result;
+          const useCache = ["boolean", "object"].includes(typeof args["cache"]) && args["cache"] !== null && CACHE_OPERATIONS.includes(operation);
+          if (!useCache)
+            return query(args);
+          const queryArgs = {
+            ...args
+          };
+          delete queryArgs["cache"];
+          if (typeof args["cache"] === "boolean") {
+            const cacheKey = `prisma-${model}-${JSON.stringify(queryArgs)}`;
+            const cached2 = await cache.get(cacheKey);
+            if (cached2) {
+              return typeof cached2 === "string" ? JSON.parse(cached2) : cached2;
+            }
+            result = await query(queryArgs);
+            await cache.set(cacheKey, JSON.stringify(result));
+            return result;
+          }
+          const { key, ttl } = args["cache"];
+          const customCacheKey = key || `prisma-custom-${model}-${JSON.stringify(queryArgs)}`;
+          const cached = await cache.get(customCacheKey);
+          if (cached) {
+            return typeof cached === "string" ? JSON.parse(cached) : cached;
+          }
+          result = await query(queryArgs);
+          const value = JSON.stringify(result);
+          if (ttl) {
+            await cache.set(customCacheKey, value, ttl);
+          } else {
+            await cache.set(customCacheKey, value);
+          }
+          return result;
+        }
+      }
+    }
+  });
+};

package/dist/index.mjs

@@ -0,0 +1,73 @@
+// src/index.ts
+import { Prisma } from "@prisma/client/extension";
+
+// src/types.ts
+var REQUIRED_ARGS_OPERATIONS = [
+  "findUnique",
+  "findUniqueOrThrow",
+  "groupBy"
+];
+var OPTIONAL_ARGS_OPERATIONS = [
+  "findMany",
+  "findFirst",
+  "findFirstOrThrow",
+  "count"
+];
+var CACHE_OPERATIONS = [
+  ...REQUIRED_ARGS_OPERATIONS,
+  ...OPTIONAL_ARGS_OPERATIONS
+];
+
+// src/index.ts
+var src_default = ({ cache }) => {
+  return Prisma.defineExtension({
+    name: "prisma-extension-cache-manager",
+    client: {
+      cache: { store: cache }
+    },
+    model: {
+      $allModels: {}
+    },
+    query: {
+      $allModels: {
+        async $allOperations({ model, operation, args, query }) {
+          let result;
+          const useCache = ["boolean", "object"].includes(typeof args["cache"]) && args["cache"] !== null && CACHE_OPERATIONS.includes(operation);
+          if (!useCache)
+            return query(args);
+          const queryArgs = {
+            ...args
+          };
+          delete queryArgs["cache"];
+          if (typeof args["cache"] === "boolean") {
+            const cacheKey = `prisma-${model}-${JSON.stringify(queryArgs)}`;
+            const cached2 = await cache.get(cacheKey);
+            if (cached2) {
+              return typeof cached2 === "string" ? JSON.parse(cached2) : cached2;
+            }
+            result = await query(queryArgs);
+            await cache.set(cacheKey, JSON.stringify(result));
+            return result;
+          }
+          const { key, ttl } = args["cache"];
+          const customCacheKey = key || `prisma-custom-${model}-${JSON.stringify(queryArgs)}`;
+          const cached = await cache.get(customCacheKey);
+          if (cached) {
+            return typeof cached === "string" ? JSON.parse(cached) : cached;
+          }
+          result = await query(queryArgs);
+          const value = JSON.stringify(result);
+          if (ttl) {
+            await cache.set(customCacheKey, value, ttl);
+          } else {
+            await cache.set(customCacheKey, value);
+          }
+          return result;
+        }
+      }
+    }
+  });
+};
+export {
+  src_default as default
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@knaus94/prisma-extension-cache-manager",
+  "version": "0.0.2",
+  "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"
+  },
+  "keywords": [
+    "prisma",
+    "extension",
+    "cache-manager",
+    "cache"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {}
+  },
+  "files": [
+    "dist/**/*",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "format": "prettier --write .",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "prettier": "^3.1.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ]
+  },
+  "dependencies": {
+    "@prisma/client": "^5.7.1",
+    "cache-manager": "^5.2.1"
+  }
+}