@dnax/core 0.70.3 → 0.70.5

package/app/hono.ts

@@ -578,7 +578,13 @@ function HonoInstance(): typeof app {
 
         // find
         if (action == "find") {
-          response = await rest.find(collection, body?.params || {});
+          if (col?.cache?.fetch && useCache) {
+            // la fonctionnalité de cache n'est pas configuré
+            return fn.error(`Cache features not configured`, 400);
+          }
+          response = await rest.find(collection, body?.params || {}, {
+            useCache: useCache ?? false,
+          });
         }
 
         if (action == "findWithMeta") {

package/driver/mongo/rest.ts

@@ -18,7 +18,6 @@ import {
 import { contextError, fn, toJson, dotJson, getEntryBykeys } from "../../utils";
 import v, { type Schema } from "joi";
 import type { Context } from "hono";
-import { MeiliSearch } from "../../lib/meilisearch";
 import type { SearchParams } from "meilisearch";
 
 import type {
@@ -41,6 +40,7 @@ import {
 } from "./utils";
 import { Cfg } from "../../config";
 import cleanDeep from "clean-deep";
+import { useCache } from "../../lib/bento";
 
 type options = {
   tenant_id: string;
@@ -55,7 +55,6 @@ type optionCb = {
   cleanDeep?: boolean;
   useCustomApi?: boolean;
   elementAt?: Number | null;
-  withMeta?: boolean;
 };
 
 type QueryBatchType<T extends "findOne" | "find"> = {
@@ -571,6 +570,20 @@ class useRest {
           state: sessionStorage()?.get()?.state,
           uuid: sessionStorage()?.get()?.uuid, */
         } as activityInput);
+        if (col?.cache?.invalidate) {
+          col.cache.invalidate({
+            operationType: "insert",
+            rest: new useRest({
+              useCustomApi: false,
+              session: this.#session,
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+            action: "insertOne",
+            ids: [String(data?._id)],
+            tags: [String(data?._id)],
+          });
+        }
         return resolve(toJson(data));
       } catch (err) {
         return reject(err);
@@ -738,6 +751,20 @@ class useRest {
           state: sessionStorage()?.get()?.state,
           uuid: sessionStorage()?.get()?.uuid, */
         });
+        if (col?.cache?.invalidate) {
+          col.cache.invalidate({
+            operationType: "insert",
+            rest: new useRest({
+              useCustomApi: false,
+              session: this.#session,
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+            action: "insertMany",
+            ids: data.map((d) => String(d?._id)) || [],
+            tags: data.map((d) => String(d?._id)) || [],
+          });
+        }
         return resolve(toJson(data));
       } catch (err) {
         reject(err);
@@ -793,8 +820,10 @@ class useRest {
   async find(
     collection: string,
     params?: findParam,
-    options?: optionCb
-  ): Promise<{ _id: string; [key: string]: any }[]> {
+    options?: optionCb & {
+      useCache?: boolean;
+    }
+  ): Promise<{ _id: string; [key: string]: any }[] | Array<any>> {
     return new Promise(async (resolve, reject) => {
       try {
         if (!params) params = {};
@@ -802,6 +831,8 @@ class useRest {
           params = cleanDeep(params);
         }
 
+        let useCacheBool = options?.useCache ?? false;
+
         let useHook = options?.useHook ?? this.#useHook;
         let useCustomApi = options?.useCustomApi ?? this.#useCustomApi;
         let sharedData = {};
@@ -810,6 +841,17 @@ class useRest {
         };
 
         let col = getCollection(collection, this.#tenant_id);
+        if (useCacheBool && col?.cache?.fetch) {
+          let cacheResult = await col.cache.fetch({
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+            params: params,
+          });
+          return cacheResult || [];
+        }
+
         if (col?.hooks?.beforeOperation && useHook) {
           await col.hooks.beforeOperation({
             sharedData: sharedData,
@@ -1511,6 +1553,20 @@ class useRest {
           state: sessionStorage()?.get()?.state,
           uuid: sessionStorage()?.get()?.uuid, */
         });
+        if (col?.cache?.invalidate) {
+          col.cache.invalidate({
+            operationType: "update",
+            rest: new useRest({
+              useCustomApi: false,
+              session: this.#session,
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+            action: "updateOne",
+            ids: [id],
+            tags: [id],
+          });
+        }
         return resolve(toJson(result?.doc || {}));
       } catch (err) {
         return reject(err);
@@ -1651,7 +1707,20 @@ class useRest {
           state: sessionStorage()?.get()?.state,
           uuid: sessionStorage()?.get()?.uuid, */
         });
-
+        if (col?.cache?.invalidate) {
+          col.cache.invalidate({
+            operationType: "update",
+            rest: new useRest({
+              useCustomApi: false,
+              session: this.#session,
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+            action: "findAndUpdate",
+            ids: result?.docs?.map((d) => String(d?._id)) || [],
+            tags: result?.docs.map((d) => String(d?._id)) || [],
+          });
+        }
         return resolve({
           docs: result.docs,
           matchedCount: up_?.matchedCount || 0,
@@ -1798,6 +1867,20 @@ class useRest {
           state: sessionStorage()?.get()?.state,
           uuid: sessionStorage()?.get()?.uuid, */
         });
+        if (col?.cache?.invalidate) {
+          col.cache.invalidate({
+            operationType: "update",
+            rest: new useRest({
+              useCustomApi: false,
+              session: this.#session,
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+            action: "findOneAndUpdate",
+            ids: [doc?._id],
+            tags: [doc?._id],
+          });
+        }
         return resolve(toJson(result?.doc || {}));
       } catch (err) {
         return reject(err);
@@ -2025,6 +2108,20 @@ class useRest {
             state: sessionStorage()?.get()?.state,
             uuid: sessionStorage()?.get()?.uuid, */
           });
+          if (col?.cache?.invalidate) {
+            col.cache.invalidate({
+              operationType: "update",
+              rest: new useRest({
+                useCustomApi: false,
+                session: this.#session,
+                useHook: false,
+                tenant_id: this.#tenant_id,
+              }),
+              action: "updateMany",
+              ids: ids,
+              tags: ids,
+            });
+          }
           return resolve(result.docs);
         } else {
           throw new contextError("List of id required", 400);
@@ -2187,6 +2284,21 @@ class useRest {
           uuid: sessionStorage()?.get()?.uuid, */
         });
 
+        if (col?.cache?.invalidate) {
+          col.cache.invalidate({
+            operationType: "delete",
+            rest: new useRest({
+              useCustomApi: false,
+              session: this.#session,
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+            action: "deleteOne",
+            ids: [id],
+            tags: [id],
+          });
+        }
+
         return resolve(doc);
       } catch (err) {
         return resolve(err);
@@ -2345,6 +2457,20 @@ class useRest {
           state: sessionStorage()?.get()?.state,
           uuid: sessionStorage()?.get()?.uuid, */
         });
+        if (col?.cache?.invalidate) {
+          col.cache.invalidate({
+            operationType: "delete",
+            rest: new useRest({
+              useCustomApi: false,
+              session: this.#session,
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+            action: "deleteMany",
+            ids: ids,
+            tags: ids,
+          });
+        }
         return resolve(deletedIds);
       } catch (err) {
         return reject(err);

package/lib/bento/index.ts

@@ -1,6 +1,7 @@
 import { BentoCache, bentostore } from "bentocache";
 import { memoryDriver } from "bentocache/drivers/memory";
 import { fileDriver } from "bentocache/drivers/file";
+import { useKey } from "../../utils";
 import { v4 } from "uuid";
 import fs from "fs-extra";
 import path from "path";
@@ -43,4 +44,6 @@ function useCache(
   return bento;
 }
 
+useCache.Key = useKey;
+
 export { useCache };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.70.3",
+  "version": "0.70.5",
   "module": "index.ts",
   "type": "module",
   "bin": {},

package/types/index.ts

@@ -3,7 +3,7 @@ import { Cron } from "croner";
 //import type{ updateParams } from "./../driver/mongo/@types";
 //import * as v from "valibot";
 import type { Db, MongoClient } from "mongodb";
-import { WorkflowInstance } from "../lib/workflow";
+import { BentoCache, bentostore } from "bentocache";
 
 import { useRest } from "../driver/mongo/rest";
 import { sessionStorage } from "../lib/asyncLocalStorage";
@@ -308,6 +308,19 @@ export type Collection = {
     accept?: Array<string> | string;
     filesystemAdapter?: any;
   };
+  cache?:{
+    fetch?:(ctx:{
+      rest:InstanceType<typeof useRest>;
+      params:findParam;
+    })=>Promise<Array<any>>;
+    invalidate?:(ctx:{
+      rest:InstanceType<typeof useRest>;
+      action:Actions;
+      ids:Array<string>;
+      tags:Array<string>;
+      operationType:"insert"|"update"|"delete";
+    })=>Promise<any>;
+  };
   customApi?: {
     aggregate?: (ctx: ctxApi) => Array<object> | null | undefined | typeof fn.error;
     insertOne?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
@@ -316,11 +329,10 @@ export type Collection = {
     updateMany?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
     deleteOne?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
     deleteMany?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
-    find?: (ctx: ctxApi) => Array<object> | null | undefined | typeof fn.error;
+    find?: (ctx: ctxApi) => Array<any> | undefined | typeof fn.error;
     findWithMeta?: (ctx: ctxApi) => { meta: object; data: Array<object> } | null | undefined | typeof fn.error;
     findOne?: (ctx: ctxApi) => object | null | undefined | typeof fn.error;
     count?: (ctx: ctxApi) => number | null | undefined | typeof fn.error;
-    
   };
 
   schema?: object;

package/utils/index.ts

@@ -21,6 +21,7 @@ import * as _ from "radash";
 import { email } from "../lib/mail";
 
 import { deepEqual } from "json-joy/lib/json-equal/deepEqual";
+import type { SupportedCryptoAlgorithms } from "bun";
 //import {applyPatch} from "json-joy/lib/json-patch"
 
 function copy(data: object): object | any {
@@ -549,6 +550,26 @@ function containsForbiddenOperators(
   );
 }
 
+// create key hash with bun hash
+function useKey(
+  key: object | string,
+  algorithm: SupportedCryptoAlgorithms = "sha256"
+): string {
+  if (!key) throw new Error("key is required");
+  let hashKey = null;
+  if (typeof key == "string") {
+    hashKey = key;
+  }
+  if (typeof key == "object") {
+    hashKey = JSON.stringify(key);
+  }
+
+  let hasher = new Bun.CryptoHasher(algorithm || "sha256");
+  hasher.update(hashKey as any);
+  let n = hasher.digest("base64");
+  return n;
+}
+
 const contextError = ContextError;
 export {
   file,
@@ -585,4 +606,5 @@ export {
   applyPatch,
   createPatch,
   containsForbiddenOperators,
+  useKey,
 };