@knaus94/prisma-extension-cache-manager 1.2.0 → 1.2.2

package/README.md

@@ -1 +1,75 @@
-# prisma-extension-cache-manager
+# @knaus94/prisma-extension-cache-manager
+
+A caching extension for [Prisma](https://www.prisma.io/), compatible with [cache-manager](https://www.npmjs.com/package/cache-manager).
+
+## Features
+
+- [cache-manager](https://www.npmjs.com/package/cache-manager) compatibility
+- Only model queries can be cacheable (no $query or $queryRaw)
+- In-memory cache is recommended, since types like Date or Prisma.Decimal would be lost if using JSON serialization (maybe will try to use some binary serialization in the future)
+
+## Installation
+
+Install:
+
+```
+npm i @knaus94/prisma-extension-cache-manager
+```
+
+## Usage
+
+```typescript
+import { PrismaClient } from "@prisma/client";
+import * as cm from "cache-manager";
+import cacheExtension from "@knaus94/prisma-extension-cache-manager";
+
+async function main() {
+  const cache = await cm.caching("memory", {
+    ttl: 10000,
+    max: 200,
+  });
+  const prisma = new PrismaClient().$extends(cacheExtension({ cache }));
+  await prisma.user.findUniqueOrThrow({
+    where: {
+      email: user.email,
+    },
+    cache: true, // using cache default settings
+  });
+  await prisma.user.findMany({
+    cache: 5000, // setting ttl in milliseconds
+  });
+  await prisma.user.count({
+    cache: {
+      ttl: 2000,
+      key: "user_count", // custom cache key
+    },
+  });
+  await prisma.user.update({
+    data: {},
+    cache: {
+      ttl: 2000,
+      key: (result) => `user-${user.id}`, // custom cache key by result (There will be no reading from the cache, only a write down)
+    },
+  });
+  await prisma.user.create({
+    data: {},
+    unchace: `user_count`, // delete key from cache
+  });
+  await prisma.user.create({
+    data: {},
+    cache: {
+      ttl: 2000,
+      key: (result) => `user-${user.id}`, // custom cache key by result (There will be no reading from the cache, only a write down)
+    },
+    unchace: [`user_count`, `users`], // delete keys from cache
+  });
+}
+
+main().catch(console.error);
+```
+
+## Learn more
+
+- [Docs — Client extensions](https://www.prisma.io/docs/concepts/components/prisma-client/client-extensions)
+- [Docs — Shared extensions](https://www.prisma.io/docs/concepts/components/prisma-client/client-extensions/shared-extensions)
+- [Preview announcement blog post](https://www.prisma.io/blog/client-extensions-preview-8t3w27xkrxxn#introduction)

package/dist/index.js

@@ -23,7 +23,7 @@ exports.default = ({ cache }) => {
                 async $allOperations({ model, operation, args, query }) {
                     if (!types_1.CACHE_OPERATIONS.includes(operation))
                         return query(args);
-                    const isCreateOperation = [
+                    const isWriteOperation = [
                         "create",
                         "upsert",
                         "update",
@@ -50,7 +50,7 @@ exports.default = ({ cache }) => {
                             .catch(() => false);
                     }
                     const useCache = cacheOption !== undefined &&
-                        ["boolean", "object"].includes(typeof cacheOption);
+                        ["boolean", "object", "number"].includes(typeof cacheOption);
                     const useUncache = uncacheOption !== undefined &&
                         (typeof uncacheOption === "function" ||
                             typeof uncacheOption === "string" ||
@@ -61,12 +61,12 @@ exports.default = ({ cache }) => {
                             processUncache(result);
                         return result;
                     }
-                    if (typeof cacheOption === "boolean") {
+                    if (["boolean", "number"].includes(typeof cacheOption)) {
                         const cacheKey = generateComposedKey({
                             model,
                             queryArgs,
                         });
-                        if (!isCreateOperation) {
+                        if (!isWriteOperation) {
                             const cached = await cache.get(cacheKey);
                             if (cached) {
                                 return typeof cached === "string" ? JSON.parse(cached) : cached;
@@ -75,7 +75,7 @@ exports.default = ({ cache }) => {
                         const result = await query(queryArgs);
                         if (useUncache)
                             processUncache(result);
-                        await cache.set(cacheKey, JSON.stringify(result));
+                        await cache.set(cacheKey, JSON.stringify(result), typeof cacheOption === "number" ? cacheOption : undefined);
                         return result;
                     }
                     const { key, ttl } = cacheOption;
@@ -84,13 +84,7 @@ exports.default = ({ cache }) => {
                         if (useUncache)
                             processUncache(result);
                         const customCacheKey = key(result);
-                        const value = JSON.stringify(result);
-                        if (ttl) {
-                            await cache.set(customCacheKey, value, ttl);
-                        }
-                        else {
-                            await cache.set(customCacheKey, value);
-                        }
+                        await cache.set(customCacheKey, JSON.stringify(result), ttl);
                         return result;
                     }
                     const customCacheKey = key ||
@@ -98,7 +92,7 @@ exports.default = ({ cache }) => {
                             model,
                             queryArgs,
                         });
-                    if (!isCreateOperation) {
+                    if (!isWriteOperation) {
                         const cached = await cache.get(customCacheKey);
                         if (cached) {
                             return typeof cached === "string" ? JSON.parse(cached) : cached;
@@ -107,13 +101,7 @@ exports.default = ({ cache }) => {
                     const result = await query(queryArgs);
                     if (useUncache)
                         processUncache(result);
-                    const value = JSON.stringify(result);
-                    if (ttl) {
-                        await cache.set(customCacheKey, value, ttl);
-                    }
-                    else {
-                        await cache.set(customCacheKey, value);
-                    }
+                    await cache.set(customCacheKey, JSON.stringify(result), ttl);
                     return result;
                 },
             },

package/dist/types.d.ts

@@ -23,7 +23,7 @@ export interface CacheOptions<T, A, O extends RequiredArgsOperation | OptionalAr
     ttl?: number;
 }
 export interface PrismaCacheArgs<T, A, O extends RequiredArgsOperation | OptionalArgsOperation> {
-    cache?: boolean | CacheOptions<T, A, O>;
+    cache?: boolean | number | CacheOptions<T, A, O>;
     uncache?: ((result: Prisma.Result<T, A, O>) => string[] | string) | string | string[];
 }
 export interface PrismaRedisCacheConfig {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knaus94/prisma-extension-cache-manager",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/knaus94/prisma-extension-cache-manager.git"