@dnax/core 0.69.5 → 0.69.7

package/app/hono.ts

@@ -578,9 +578,11 @@ function HonoInstance(): typeof app {
 
         // find
         if (action == "find") {
-          response = await rest.find(collection, body?.params || {}, {
-            withMeta: body?.withMeta || false,
-          });
+          response = await rest.find(collection, body?.params || {});
+        }
+
+        if (action == "findWithMeta") {
+          response = await rest.findWithMeta(collection, body?.params || {});
         }
 
         if (action == "listActivity") {
@@ -618,10 +620,7 @@ function HonoInstance(): typeof app {
           response = await rest.findOne(
             collection,
             body?.id || body._id,
-            body?.params || {},
-            {
-              withMeta: body?.withMeta || false,
-            }
+            body?.params || {}
           );
         }
         if (action == "insertOne") {
@@ -673,7 +672,7 @@ function HonoInstance(): typeof app {
         Array.isArray(col?.api?.fields?.select)
       ) {
         const selectedFields = [];
-        if (body?.withMeta) {
+        if (action == "findWithMeta") {
           response.data = pick(response.data, col?.api?.fields?.select);
         } else {
           response = pick(response, col?.api?.fields?.select);
@@ -685,23 +684,16 @@ function HonoInstance(): typeof app {
         typeof col?.api?.fields?.select == "function"
       ) {
         let selectedFields = [];
-        if (body?.withMeta) {
-          selectedFields = await col?.api?.fields?.select({
-            action: action,
-            c: c,
-            rest: rest,
-            session: sessionStorage() as any,
-          });
-          selectedFields = [...new Set(selectedFields)];
+        selectedFields = await col?.api?.fields?.select({
+          action: action,
+          c: c,
+          rest: rest,
+          session: sessionStorage() as any,
+        });
+        selectedFields = [...new Set(selectedFields)];
+        if (action == "findWithMeta") {
           response.data = pick(response.data, selectedFields);
         } else {
-          selectedFields = await col?.api?.fields?.select({
-            action: action,
-            c: c,
-            rest: rest,
-            session: sessionStorage() as any,
-          });
-          selectedFields = [...new Set(selectedFields)];
           response = pick(response, selectedFields);
         }
       }
@@ -714,17 +706,11 @@ function HonoInstance(): typeof app {
         let privateFields = col?.api?.fields?.hidden || [];
         privateFields.push("password");
         privateFields = [...new Set(privateFields)];
-        if (body?.withMeta) {
-          // If use Meta are included
-          try {
-            response.data = omit(response.data, privateFields);
-          } catch (e) {}
+        if (action == "findWithMeta") {
+          response.data = omit(response.data, privateFields);
         } else {
           response = omit(response, privateFields);
         }
-        if (response.hits) {
-          response.hits = omit(response.hits, privateFields);
-        }
       }
 
       // hidden is function
@@ -734,54 +720,28 @@ function HonoInstance(): typeof app {
       ) {
         let privateFields = [];
 
-        if (body?.withMeta) {
-          // If use Meta are included
-          try {
-            privateFields = await col?.api?.fields?.hidden({
-              action: action,
-              c: c,
-              rest: rest,
-              session: sessionStorage() as any,
-            });
-            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({
-            action: action,
-            c: c,
-            rest: rest,
-            session: sessionStorage() as any,
-          });
-          privateFields.push("password");
-          privateFields = [...new Set(privateFields)];
+        privateFields = await col?.api?.fields?.hidden({
+          action: action,
+          c: c,
+          rest: rest,
+          session: sessionStorage() as any,
+        });
+        privateFields.push("password");
+        privateFields = [...new Set(privateFields)];
 
-          if (response?.hits) {
-            response.hits = omit(response?.hits, privateFields);
-          }
+        if (action == "findWithMeta") {
+          response.data = omit(response.data, privateFields);
+        } else {
           response = omit(response, privateFields);
         }
       }
 
-      if (
-        !col?.api?.fields?.hidden &&
-        !col?.api?.fields?.select &&
-        body?.withMeta
-      ) {
-        response.data = omit(response.data, ["password"]);
-        response.meta = response.meta || {};
-      }
-
-      if (response?.hits && col?.privateFields?.length) {
-        response = omit(response, col?.privateFields);
+      if (action == "findWithMeta" && col?.privateFields?.length) {
+        response.data = omit(response.data, col?.privateFields);
       }
 
       if (response?.data && col?.privateFields?.length) {
-        response = omit(response, col?.privateFields);
+        response.data = omit(response.data, col?.privateFields);
       }
 
       return c.json(response);

package/driver/mongo/@types.ts

@@ -8,15 +8,23 @@ export type Lookup = {
 };
 
 export type findParam = {
-  $match?: object;
-  $sort?: object;
+  $match?: {
+    _id?: string;
+    [key: string]: any;
+  };
+  $sort?: {
+    [key: string]: 1 | -1;
+  };
   $skip?: number;
   $limit?: number;
   $include?: Array<string | Lookup>;
   $project?: object;
-  $matchInclude?: object;
+  $matchInclude?: {
+    _id?: string;
+    [key: string]: any;
+  };
   $group?: {
-    _id: any;
+    _id?: any;
     [key: string]: any;
   };
   $sample?: {

package/driver/mongo/rest.ts

@@ -6,11 +6,13 @@ import type { Actions, Collection, Tenant } from "./../../types/index";
 import { isArray } from "radash";
 import { omit } from "../../utils";
 import {
+  AggregationCursor,
   ChangeStream,
   ClientSession,
   MongoClient,
   ObjectId,
   type ChangeStreamOptions,
+  type Document,
   type FilterOperations,
 } from "mongodb";
 import { contextError, fn, toJson, dotJson, getEntryBykeys } from "../../utils";
@@ -798,6 +800,152 @@ class useRest {
     });
   }
 
+  async findWithMeta(
+    collection: string,
+    params?: findParam,
+    options?: optionCb
+  ): Promise<{ meta: object; data: Array<any> }> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let meta = {
+          ts: 0, // time duration
+        };
+        let start = Date.now();
+
+        if (!params) params = {};
+        if (options?.cleanDeep) {
+          params = cleanDeep(params);
+        }
+
+        let useHook = options?.useHook ?? this.#useHook;
+        let useCustomApi = options?.useCustomApi ?? this.#useCustomApi;
+        let sharedData = {};
+        let result = {
+          docs: [] as any[] | Document[],
+        };
+
+        let col = getCollection(collection, this.#tenant_id);
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            sharedData: sharedData,
+            c: this.#c,
+            error: fn.error,
+            driver: "mongodb",
+            io: Cfg.io,
+            action: "find",
+            params: params,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeFindWithMeta && useHook) {
+          await col.hooks.beforeFindWithMeta({
+            sharedData: sharedData,
+            c: this.#c,
+            driver: "mongodb",
+            action: "find",
+            io: Cfg.io,
+            params: params,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.customApi?.findWithMeta && useCustomApi) {
+          let result = (await col?.customApi?.findWithMeta({
+            io: Cfg.io,
+            error: fn.error,
+            session: sessionStorage(),
+            params: params,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+              useCustomApi: false,
+            }),
+          })) as any;
+          // Temp dexecution en ms
+          meta.ts = Date.now() - start;
+          return resolve({
+            meta: meta,
+            data: result,
+          });
+        }
+
+        result.docs =
+          (await this.#tenant.database.db
+            ?.collection(collection)
+            .aggregate(formatData(buildPipeline(params, col)), {
+              allowDiskUse: true,
+            })
+            .toArray()) || [];
+
+        result.docs = toJson(result.docs);
+        meta.ts = Date.now() - start;
+        if (col?.hooks?.afterFindWithMeta && useHook) {
+          await col.hooks.afterFindWithMeta({
+            sharedData: sharedData,
+            c: this.#c,
+            io: Cfg.io,
+            driver: "mongodb",
+            action: "find",
+            meta: meta,
+            count: result?.docs?.length || 0,
+            params: toJson(params),
+            session: sessionStorage(),
+            result: result.docs,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        let resultDocs = toJson([...(result?.docs || [])]);
+        return resolve({
+          meta: meta,
+          data: resultDocs,
+        });
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+
+  async findWithCursor(
+    collection: string,
+    params?: findParam,
+    options?: Pick<optionCb, "cleanDeep"> & {
+      batchSize?: number;
+    }
+  ): Promise<AggregationCursor<Document>> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (!params) params = {};
+        if (options?.cleanDeep) {
+          params = cleanDeep(params);
+        }
+
+        let col = getCollection(collection, this.#tenant_id);
+
+        await this.#tenant.database.db
+          ?.collection(collection)
+          .aggregate(formatData(buildPipeline(params, col)), {
+            allowDiskUse: true,
+            batchSize: options?.batchSize,
+          });
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+
   async count(
     collection: string,
     params: findParam,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.69.5",
+  "version": "0.69.7",
   "module": "index.ts",
   "type": "module",
   "bin": {},
@@ -22,7 +22,6 @@
   "dependencies": {
     "@colors/colors": "^1.6.0",
     "@lukeed/ms": "^2.0.2",
-    "@types/blessed": "^0.1.25",
     "bentocache": "^1.5.0",
     "boxen": "^7.1.1",
     "chokidar": "3.6.0",

package/types/index.ts

@@ -237,7 +237,7 @@ export type hooksCtx = (ctx: {
   sharedData?: any;
   action?: Actions;
   c?: Context;
-  meta?: { total?: number; count?: number; [key: string]: any };
+  meta?: { ts:number; [key: string]: any };
   rest: InstanceType<typeof useRest>;
   session?: sessionCtx;
   io: socketIoType;
@@ -317,8 +317,10 @@ export type Collection = {
     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;
+    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;
@@ -345,6 +347,8 @@ export type Collection = {
     afterDelete?: hooksCtx;
     beforeInsert?: hooksCtx;
     afterInsert?: hooksCtx;
+    beforeFindWithMeta?: hooksCtx;
+    afterFindWithMeta?: hooksCtx;
     beforeAggregate?: hooksCtx;
     afterAggregate?: hooksCtx;
     beforeCount?: hooksCtx;
@@ -374,6 +378,7 @@ export type Collection = {
     count?: accessCtx;
     search?: accessCtx;
     listActivity?: accessCtx;
+    findWithMeta?: accessCtx;
   };
   tenant_id?: string;
   slug: string;
@@ -565,6 +570,7 @@ export type Q = {
     | "execService"
     | "batch"
     | "count"
+    | "findWithMeta"
     | "execToolkit"
     | "search"
     | "listActivity";