@dnax/core 0.52.2 → 0.52.4

package/app/ctrl.ts

@@ -16,6 +16,7 @@ const actions = [
   "upload",
   "batch",
   "count",
+  "search",
 ];
 
 function getAction(action: string) {

package/app/hono.ts

@@ -14,6 +14,7 @@ import { consola } from "consola";
 import { cors } from "hono/cors";
 import { asyncLocalStorage, sessionStorage } from "../lib/asyncLocalStorage";
 import { localSession } from "../lib/session";
+import { crypt } from "../lib/crypto";
 import {
   cleanPath,
   ContextError,
@@ -40,6 +41,7 @@ import { ipRestriction } from "hono/ip-restriction";
 import { logger } from "hono/logger";
 import { csrf } from "hono/csrf";
 import { v4 } from "uuid";
+import type { SearchParams } from "meilisearch";
 const cache = bentoCache.namespace("DNAX_API");
 const app = new Hono();
 const API_PATH = "/api";
@@ -498,24 +500,66 @@ function HonoInstance(): typeof app {
         if (action == "count") {
           response = await rest.count(collection, body?.params || {});
         }
+
+        if (action == "search") {
+          let searchOption = {
+            term: body?.params?.term as string,
+            options: body?.params?.searchOptions as SearchParams,
+          };
+
+          if (col?.hooks?.beforeSearch) {
+            await col?.hooks?.beforeSearch({
+              io: Cfg.io,
+              data: body,
+              c: c,
+              rest: rest,
+              action: "search",
+              session: sessionStorage(),
+              error: fn.error,
+              search: searchOption,
+            });
+          }
+
+          response = await rest.search(
+            collection,
+            searchOption.term,
+            searchOption.options || {}
+          );
+
+          if (col?.hooks?.afterSearch) {
+            await col?.hooks?.afterSearch({
+              io: Cfg.io,
+              data: body,
+              c: c,
+              rest: rest,
+              action: "search",
+              session: sessionStorage(),
+              error: fn.error,
+              search: searchOption,
+              result: response,
+            });
+          }
+        }
         // find
         if (action == "find") {
           if (col?.cache?.enabled && useCache) {
-            let keyCache = bentoKey({
-              data: body,
-              query: c.req.query,
+            let keyCache = crypt.AES.generateKey({
+              body: body,
+              query: c?.req?.query,
             });
 
             // if customCache
-            if (col?.cache?.customCache) {
-              let fetchFromCache = await col?.cache?.customCache({
+            if (col?.cache?.fetch) {
+              let fetchFromCache = await col?.cache?.fetch({
+                key: keyCache,
                 action: action,
+                params: body?.params,
                 rest: rest,
                 session: sessionStorage(),
+                state: col?.cache?.state || {},
                 c: c,
               });
-
-              if (!fetchFromCache.isStale) {
+              if (!fetchFromCache?.isStale) {
                 response = fetchFromCache.data;
               } else {
                 response = await rest.find(collection, body?.params || {}, {
@@ -523,28 +567,6 @@ function HonoInstance(): typeof app {
                 });
               }
             }
-            // if not customCache
-            if (!col?.cache?.customCache) {
-              let responseFromCache = await cache.get({
-                key: keyCache,
-              });
-              if (responseFromCache) {
-                response = responseFromCache;
-              } else {
-                response = await rest.find(collection, body?.params || {}, {
-                  withMeta: body?.withMeta || false,
-                });
-                await cache.set({
-                  key: keyCache,
-                  value: response,
-                  ttl: col?.cache?.ttl || "1m",
-                });
-              }
-
-              /* response = await rest.find(collection, body?.params || {}, {
-                  withMeta: body?.withMeta || false,
-                }); */
-            }
           } else {
             response = await rest.find(collection, body?.params || {}, {
               withMeta: body?.withMeta || false,
@@ -659,6 +681,9 @@ function HonoInstance(): typeof app {
         } else {
           response = omit(response, privateFields);
         }
+        if (response.hits) {
+          response.hits = omit(response.hits, privateFields);
+        }
       }
 
       // hidden is function
@@ -680,6 +705,9 @@ function HonoInstance(): typeof app {
             privateFields.push("password");
             privateFields = [...new Set(privateFields)];
             response.data = omit(response.data, privateFields);
+            if (response?.hits) {
+              response.hits = omit(response.hits, privateFields);
+            }
           } catch (e) {}
         } else {
           privateFields = await col?.api?.fields?.hidden({
@@ -690,6 +718,10 @@ function HonoInstance(): typeof app {
           });
           privateFields.push("password");
           privateFields = [...new Set(privateFields)];
+
+          if (response?.hits) {
+            response.hits = omit(response?.hits, privateFields);
+          }
           response = omit(response, privateFields);
         }
       }
@@ -703,6 +735,14 @@ function HonoInstance(): typeof app {
         response.meta = response.meta || {};
       }
 
+      if (response?.hits && col?.privateFields?.length) {
+        response = omit(response, col?.privateFields);
+      }
+
+      if (response?.data && col?.privateFields?.length) {
+        response = omit(response, col?.privateFields);
+      }
+
       return c.json(response);
     } catch (err: any) {
       if (Cfg?.debug) console.log(err?.message | err);

package/driver/mongo/connect.ts

@@ -13,7 +13,8 @@ async function connectToMongo(t: Tenant) {
     await client
       .connect()
       .then((e) => {
-        //consola.log(`[${t.id}] : Connected to db ✅`.green);
+        console.log("\n");
+        consola.success(`DB connected : [${t.id}] ✅`.green);
         t.database.isConnected = true;
         t.database.client = client;
         t.database.db = client.db();

package/driver/mongo/rest.ts

@@ -8,6 +8,8 @@ import { ChangeStream, ClientSession, MongoClient, ObjectId } from "mongodb";
 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 {
   findOneParam,
@@ -93,6 +95,9 @@ class useRest {
       $skip?: number;
     }) => Promise<Array<any>>;
   };
+  meilisearch: {
+    client: InstanceType<typeof MeiliSearch>;
+  };
 
   constructor(options: options) {
     this.#c = options?.c;
@@ -102,7 +107,9 @@ class useRest {
     this.#tenant = getTenant(this.#tenant_id);
     this.#useHook = options?.useHook ?? true;
     this.db = this.#tenant.database.db;
-
+    this.meilisearch = {
+      client: this.#tenant.searchEngine?.meilisearch?.client!,
+    };
     this.activity = {
       save: async (activityInput) => {
         return await restActivity.save(this.#tenant, activityInput);
@@ -383,6 +390,28 @@ class useRest {
             sessionStorage()?.get()?.state?.by ||
             null,
         });
+
+        try {
+          col?.cache?.watch({
+            action: "insertOne",
+            c: this.#c,
+            session: sessionStorage(),
+            rest: this,
+            state: col?.cache?.state || {},
+            result: toJson(data),
+          });
+        } catch (err) {}
+
+        // meilisearch engine
+        if (
+          this.#tenant?.searchEngine?.meilisearch?.enabled &&
+          col?.searchEngine?.meilisearch?.dispatchAction == "auto"
+        ) {
+          this.meilisearch.client
+            .index(col?.searchEngine?.meilisearch?.index)
+            .addDocuments([toJson(data)])
+            .catch();
+        }
         return resolve(toJson(data));
       } catch (err) {
         return reject(err);
@@ -503,7 +532,25 @@ class useRest {
             sessionStorage()?.get().state?.by ||
             null,
         });
-
+        try {
+          col?.cache?.watch({
+            action: "insertMany",
+            c: this.#c,
+            session: sessionStorage(),
+            rest: this,
+            state: col?.cache?.state || {},
+            result: toJson(data),
+          });
+        } catch (err) {}
+        if (
+          this.#tenant?.searchEngine?.meilisearch?.enabled &&
+          col?.searchEngine?.meilisearch?.dispatchAction == "auto"
+        ) {
+          this.meilisearch.client
+            .index(col?.searchEngine?.meilisearch?.index)
+            .addDocuments(toJson(data))
+            .catch();
+        }
         return resolve(toJson(data));
       } catch (err) {
         reject(err);
@@ -1104,7 +1151,26 @@ class useRest {
             sessionStorage().get().state?.by ||
             null,
         });
-        return resolve(result.doc);
+        try {
+          col?.cache?.watch({
+            action: "insertMany",
+            c: this.#c,
+            session: sessionStorage(),
+            rest: this,
+            state: col?.cache?.state || {},
+            result: toJson(result?.doc || {}),
+          });
+        } catch (err) {}
+        if (
+          this.#tenant?.searchEngine?.meilisearch?.enabled &&
+          col?.searchEngine?.meilisearch?.dispatchAction == "auto"
+        ) {
+          this.meilisearch.client
+            .index(col?.searchEngine?.meilisearch?.index)
+            .updateDocuments([{ ...toJson(result?.doc || {}) }])
+            .catch();
+        }
+        return resolve(toJson(result?.doc || {}));
       } catch (err) {
         return reject(err);
       }
@@ -1174,6 +1240,18 @@ class useRest {
             allowDiskUse: true,
           })
           .toArray();
+
+        if (
+          this.#tenant?.searchEngine?.meilisearch?.enabled &&
+          col?.searchEngine?.meilisearch?.dispatchAction == "auto"
+        ) {
+          this.meilisearch.client
+            .index(col?.searchEngine?.meilisearch?.index)
+            .updateDocuments(result.docs)
+            .catch();
+        }
+        ``;
+
         return resolve({
           docs: result.docs,
           matchedCount: up_?.matchedCount || 0,
@@ -1245,7 +1323,19 @@ class useRest {
               session: this.#session ? this.#session : undefined,
             }
           );
-
+        if (
+          this.#tenant?.searchEngine?.meilisearch?.enabled &&
+          col?.searchEngine?.meilisearch?.dispatchAction == "auto"
+        ) {
+          this.meilisearch.client
+            .index(col?.searchEngine?.meilisearch?.index)
+            .updateDocuments([
+              {
+                ...toJson(result.doc || {}),
+              },
+            ])
+            .catch();
+        }
         return resolve(result.doc);
       } catch (err) {
         return reject(err);
@@ -1253,6 +1343,44 @@ class useRest {
     });
   }
 
+  async search(
+    collection: string,
+    term: string,
+    searchOptions: SearchParams
+  ): Promise<{
+    hits: Array<object>;
+    limit: number;
+    offset: number;
+    total: number;
+    processingTimeMs: number;
+    facetDistribution?: object;
+    facetsStats?: object;
+    estimatedTotalHits?: number;
+    totalHits?: number;
+    hitsPerPage?: number;
+    page?: number;
+  }> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let index = getCollection(collection, this.#tenant_id)?.searchEngine
+          ?.meilisearch?.index!;
+
+        if (!index)
+          return reject({
+            code: 400,
+            message: "Search engine Index required",
+          });
+
+        let result = this.meilisearch.client.index(index).search(term, {
+          ...searchOptions,
+        });
+        resolve(result);
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+
   async updateMany(
     collection: string,
     ids: Array<string>,
@@ -1418,6 +1546,25 @@ class useRest {
               sessionStorage().get().state?.by ||
               null,
           });
+          try {
+            col?.cache?.watch({
+              action: "updateMany",
+              c: this.#c,
+              session: sessionStorage(),
+              rest: this,
+              state: col?.cache?.state || {},
+              result: toJson(result?.docs || []),
+            });
+          } catch (err) {}
+          if (
+            this.#tenant?.searchEngine?.meilisearch?.enabled &&
+            col?.searchEngine?.meilisearch?.dispatchAction == "auto"
+          ) {
+            this.meilisearch.client
+              .index(col?.searchEngine?.meilisearch?.index)
+              .updateDocuments(result.docs)
+              .catch();
+          }
           return resolve(result.docs);
         } else {
           throw new contextError("List of id required", 400);
@@ -1533,6 +1680,25 @@ class useRest {
             sessionStorage().get().state?.by ||
             null,
         });
+        try {
+          col?.cache?.watch({
+            action: "deleteOne",
+            c: this.#c,
+            session: sessionStorage(),
+            rest: this,
+            state: col?.cache?.state || {},
+            result: toJson(doc || {}),
+          });
+        } catch (err) {}
+        if (
+          this.#tenant.searchEngine.meilisearch.enabled &&
+          col?.searchEngine?.meilisearch?.dispatchAction == "auto"
+        ) {
+          this.meilisearch.client
+            .index(col?.searchEngine?.meilisearch?.index)
+            .deleteDocument(id)
+            .catch();
+        }
         return resolve(doc);
       } catch (err) {
         return resolve(err);
@@ -1648,7 +1814,25 @@ class useRest {
             sessionStorage().get().state?.by ||
             null,
         });
-
+        try {
+          col?.cache?.watch({
+            action: "deleteMany",
+            c: this.#c,
+            session: sessionStorage(),
+            rest: this,
+            state: col?.cache?.state || {},
+            result: deletedIds || [],
+          });
+        } catch (err) {}
+        if (
+          this.#tenant.searchEngine.meilisearch.enabled &&
+          col?.searchEngine?.meilisearch?.dispatchAction == "auto"
+        ) {
+          this.meilisearch.client
+            .index(col?.searchEngine?.meilisearch?.index)
+            .deleteDocuments(deletedIds)
+            .catch();
+        }
         return resolve(deletedIds);
       } catch (err) {
         return reject(err);

package/lib/collection.ts

@@ -70,20 +70,82 @@ async function syncCollectionDatabase() {
         const collections: Collection[] | undefined = Cfg.collections?.filter(
           (cn) => cn.tenant_id == t.id
         );
-
         if (collections?.length) {
+          // searchEngine Section
+          if (t?.searchEngine?.meilisearch?.enabled) {
+            let allIndex_ = await t?.searchEngine?.meilisearch?.client
+              ?.getIndexes()
+              .then((e) => e.results)
+              .catch((err) => []);
+
+            for await (let c of collections) {
+              if (c?.searchEngine?.meilisearch?.index) {
+                if (c?.searchEngine?.meilisearch?.dispatchAction) {
+                  c.searchEngine.meilisearch.dispatchAction = "auto";
+                }
+
+                let indexExist = allIndex_?.find(
+                  (index) => index?.uid == c?.searchEngine?.meilisearch?.index
+                );
+                if (!indexExist) {
+                  await t.searchEngine.meilisearch.client
+                    ?.createIndex(c?.searchEngine?.meilisearch?.index, {
+                      primaryKey:
+                        c?.searchEngine?.meilisearch?.primaryKey || "_id",
+                    })
+                    .catch((err) => {
+                      //consola.error(err?.message);
+                    });
+                }
+
+                let attributes = await t?.searchEngine?.meilisearch?.client
+                  ?.index(c?.searchEngine?.meilisearch?.index)
+                  .getFilterableAttributes()
+                  .catch();
+
+                if (
+                  c?.searchEngine?.meilisearch?.filterableAttributes?.length
+                ) {
+                  let s = false;
+                  if (
+                    !deepEqual(
+                      attributes,
+                      c?.searchEngine?.meilisearch?.filterableAttributes
+                    )
+                  ) {
+                    await t?.searchEngine?.meilisearch?.client
+                      ?.index(c?.searchEngine?.meilisearch?.index)
+                      .updateFilterableAttributes(
+                        c?.searchEngine?.meilisearch?.filterableAttributes
+                      )
+                      .catch();
+                  }
+                }
+              }
+            }
+          }
+          // DatabaseSection
           for await (let c of collections) {
             // boucle sur les collections
             //console.log(c?.slug,c.init)
             if (c?.init && typeof c?.init == "function") {
               await c?.init({
                 rest: new useRest({
-                  tenant_id: t.id,
+                  tenant_id: t?.id,
                 }),
                 collection: c?.slug,
               });
             }
 
+            if (c?.cache?.enabled && c?.cache?.init) {
+              c?.cache?.init({
+                rest: new useRest({
+                  tenant_id: t.id,
+                }),
+                state: c?.cache?.state || {},
+              });
+            }
+
             let collectionExist = collectionsInDatabase?.find(
               (col) => col?.name == c.slug
             );

package/lib/crypto.ts

@@ -1,5 +1,4 @@
-import crypto from "node:crypto";
-
+import cr from "node:crypto";
 class AES {
   #key;
   constructor(
@@ -10,16 +9,21 @@ class AES {
     }
   ) {
     // Crée une clé de 256 bits (32 octets) en utilisant un hachage SHA-256 de la clé secrète fournie
-    this.#key = crypto.createHash("sha256").update(options.secretKey).digest();
+    this.#key = cr.createHash("sha256").update(options.secretKey).digest();
+  }
+
+  static generateKey(data: any) {
+    const stringData = typeof data === "string" ? data : JSON.stringify(data);
+    return cr.createHash("sha256").update(stringData).digest("hex");
   }
 
   // Fonction de chiffrement
   encrypt(data: string | object) {
     let dataEncoding = JSON.stringify(data);
-    const iv = crypto.randomBytes(12); // Génère un IV de 12 octets pour AES-GCM
+    const iv = cr.randomBytes(12); // Génère un IV de 12 octets pour AES-GCM
 
     // Crée un objet de chiffrement avec AES-256-GCM, la clé et l'IV
-    const cipher = crypto.createCipheriv("aes-256-gcm", this.#key, iv);
+    const cipher = cr.createCipheriv("aes-256-gcm", this.#key, iv);
 
     // Chiffre le message et convertit le texte chiffré en hexadécimal
     let encrypted = cipher.update(dataEncoding, "utf8", "hex");
@@ -42,7 +46,7 @@ class AES {
     const ciphertext = encryptedData.slice(56); // Extrait les données chiffrées
  */
     // Crée un objet de déchiffrement avec AES-256-GCM, la clé et l'IV
-    const decipher = crypto.createDecipheriv(
+    const decipher = cr.createDecipheriv(
       "aes-256-gcm",
       this.#key,
       Buffer.from(iv, "hex")
@@ -65,4 +69,6 @@ const crypt = {
   AES,
 };
 
-export { crypt };
+const crypto = crypt;
+
+export { crypt, crypto };

package/lib/index.ts

@@ -1,4 +1,5 @@
 import { loadAllCollections, syncCollectionDatabase } from "./collection";
+import { syncMeilisearchClientOnTenant } from "./meilisearch";
 import { connectTenantsDatabase } from "../driver";
 import { loadEndpoints } from "./endpoint";
 import { loadServices } from "./service";
@@ -9,6 +10,7 @@ import { loadAutoRoutes } from "./routes";
 import { initScript } from "../lib/scripts";
 import { syncAdapterFileSystem } from "./media";
 import { runGenTypes } from "../types/gen";
+
 // load all ressource
 async function init(cf = { app: null }) {
   await loadSocket();
@@ -23,6 +25,9 @@ async function init(cf = { app: null }) {
   // sync all collections database ( Indexes)
   syncCollectionDatabase();
 
+  // sync
+  syncMeilisearchClientOnTenant();
+
   // load Service
   loadServices();
 

package/lib/meilisearch/index.ts

@@ -0,0 +1,25 @@
+import { MeiliSearch } from "meilisearch";
+import { Cfg } from "../../config";
+function getClient(config: {
+  host: string;
+  apiKey?: string;
+}): InstanceType<typeof MeiliSearch> {
+  const client = new MeiliSearch({
+    host: config?.host,
+    apiKey: config?.apiKey,
+  });
+  return client;
+}
+
+async function syncMeilisearchClientOnTenant() {
+  for await (let t of Cfg.tenants) {
+    if (t?.searchEngine?.meilisearch?.enabled) {
+      t.searchEngine.meilisearch.client = getClient({
+        host: t.searchEngine.meilisearch.host,
+        apiKey: t.searchEngine.meilisearch.apiKey,
+      });
+    }
+  }
+}
+
+export { MeiliSearch, getClient, syncMeilisearchClientOnTenant };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.52.2",
+  "version": "0.52.4",
   "module": "index.ts",
   "type": "module",
   "bin": {
@@ -41,6 +41,7 @@
     "joi": "17.13.3",
     "json-joy": "16.8.0",
     "jsonwebtoken": "^9.0.2",
+    "meilisearch": "^0.50.0",
     "mime-types": "^2.1.35",
     "mingo": "^6.5.0",
     "moment": "^2.30.1",

package/types/index.ts

@@ -1,7 +1,7 @@
 import type { AnySchema } from "joi";
 import { Cron } from "croner";
-import { updateParams } from "./../driver/mongo/@types";
-import * as v from "valibot";
+//import type{ updateParams } from "./../driver/mongo/@types";
+//import * as v from "valibot";
 import type { Db, MongoClient } from "mongodb";
 
 import { useRest } from "../driver/mongo/rest";
@@ -19,6 +19,7 @@ import type {
 } from "../driver/mongo/@types";
 import type { RouterRoute } from "hono/types";
 import type { MongoClientOptions } from "mongodb";
+import type { SearchParams } from "meilisearch";
 export type Socket = {
   enabled: boolean;
   exec: (ctx: { rest: useRest; io: socketIoType }) => void;
@@ -29,8 +30,17 @@ export type Tenant = {
   name?: string;
   enabled?: boolean;
   dir: string;
+  searchEngine?: {
+    meilisearch?: {
+      enabled?: boolean;
+      host: string;
+      apiKey: string;
+
+      client?: InstanceType<typeof import("meilisearch").MeiliSearch>;
+    };
+  };
   database: {
-    driver: "mongodb";
+    driver?: "mongodb";
     /**
      * Connection URI string to connect
      */
@@ -54,7 +64,8 @@ export type Actions =
   | "deleteMany"
   | "authCollection"
   | "aggregate"
-  | "upload";
+  | "upload"
+  | "search";
 
 type omitWhenType = "insertOne" | "insertMany" | "updateOne" | "updateMany";
 
@@ -197,6 +208,10 @@ export type sessionCtx = {
 };
 
 export type hooksCtx = (ctx: {
+  search?: {
+    term: string;
+    options: SearchParams;
+  };
   filter?: any;
   result?: any | null | object | undefined;
   driver?: "mongodb" | "postgres";
@@ -244,7 +259,7 @@ export type ctxApi = {
   rest: useRest;
   data?: any;
   session?: sessionCtx;
-  io?: Io;
+  io?: socketIoType;
   params?: findParam;
   id?: string;
   ids?: string[];
@@ -288,20 +303,62 @@ export type Collection = {
     findOne?: (ctx: ctxApi) => object;
     count?: (ctx: ctxApi) => number;
   };
+  searchEngine?: {
+    meilisearch: {
+      /**
+       * unique name of the index on meilisearch
+       */
+      index: string;
+      primaryKey?: string;
+      /**
+       * default value :auto
+       */
+      dispatchAction: "auto" | "manual";
+      filterableAttributes?: Array<string>;
+    };
+  };
   /**
    * Cache available for action 'find' | 'findOne'
    */
   cache?: {
     enabled?: boolean;
-    ttl: string;
-    triggerEvents: ["find", "findOne"];
-    /**
-     * Overwrite cache bahavior
-     * @param ctx
-     * @returns <any>
-     */
-    customCache?: (ctx: {
-      action: "find" | "findOne";
+    state?: {
+      [key: string]: any;
+    };
+    init?: (ctx: {
+      rest: InstanceType<typeof useRest>;
+      state: {
+        [key: string]: any;
+      };
+    }) => void;
+    watch: (ctx: {
+      action:
+        | "insertOne"
+        | "insertMany"
+        | "updateOne"
+        | "updateMany"
+        | "deleteOne"
+        | "deleteMany"
+        | "findOneAndUpdate";
+      rest: InstanceType<typeof useRest>;
+      c?: Context;
+      session?: sessionCtx;
+      result: any;
+      state: {
+        [key: string]: any;
+      };
+    }) => void;
+    fetch?: (ctx: {
+      state: {
+        [key: string]: any;
+      };
+      body: {
+        params: findParam;
+        pipeline: Array<object>;
+        withMeta: boolean;
+      };
+      key: string;
+      action: "find" | "aggregate";
       rest: InstanceType<typeof useRest>;
       c: Context;
       session: sessionCtx;
@@ -340,6 +397,8 @@ export type Collection = {
     afterCount?: hooksCtx;
     beforeUpload?: hooksCtx;
     afterUpload?: hooksCtx;
+    beforeSearch?: hooksCtx;
+    afterSearch?: hooksCtx;
   };
   access?: {
     "*"?: accessCtx;
@@ -357,9 +416,11 @@ export type Collection = {
     aggregate?: accessCtx;
     upload?: accessCtx;
     count?: accessCtx;
+    search?: accessCtx;
   };
   tenant_id?: string;
   slug: string;
+  privateFields?: string[];
   timestamps?: boolean;
   description?: string;
   fields?: Field[];
@@ -542,7 +603,8 @@ export type Q = {
     | "execService"
     | "batch"
     | "count"
-    | "execToolkit";
+    | "execToolkit"
+    | "search";
 };
 
 export type routeOption = {