spice-js 2.6.71 → 2.6.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-js",
-  "version": "2.6.71",
+  "version": "2.6.73",
   "description": "spice",
   "main": "build/index.js",
   "repository": {

package/src/models/SpiceModel.js

@@ -45,7 +45,7 @@ export default class SpiceModel {
   // ⚡ Static caches for performance optimization
   static _defaultsCache = {};
   static _hiddenPropsCache = {};
-  
+
   constructor(args = {}) {
     try {
       var dbtype =
@@ -169,15 +169,17 @@ export default class SpiceModel {
               }
               case Number:
               case "number": {
-                this[i] = _.isNumber(args.args[i])
-                  ? args.args[i]
+                this[i] =
+                  _.isNumber(args.args[i]) ?
+                    args.args[i]
                   : Number(args.args[i]);
                 break;
               }
               case Boolean:
               case "boolean": {
-                this[i] = _.isBoolean(args.args[i])
-                  ? args.args[i]
+                this[i] =
+                  _.isBoolean(args.args[i]) ?
+                    args.args[i]
                   : args.args[i] == "true" ||
                     args.args[i] == 1 ||
                     args.args[i] == "True";
@@ -190,15 +192,17 @@ export default class SpiceModel {
               }
               case Array:
               case "array": {
-                this[i] = _.isArray(args.args[i])
-                  ? args.args[i]
+                this[i] =
+                  _.isArray(args.args[i]) ?
+                    args.args[i]
                   : JSON.parse(args.args[i]);
                 break;
               }
               case Object:
               case "object": {
-                this[i] = _.isObject(args.args[i])
-                  ? args.args[i]
+                this[i] =
+                  _.isObject(args.args[i]) ?
+                    args.args[i]
                   : JSON.parse(args.args[i]);
                 break;
               }
@@ -482,7 +486,10 @@ export default class SpiceModel {
   }
 
   async get(args) {
-    try {
+    // Profiling: use track() for proper async context forking
+    const p = this[_ctx]?.profiler;
+
+    const doGet = async () => {
       if (args.mapping_dept) this[_mapping_dept] = args.mapping_dept;
 
       if (!args) {
@@ -508,7 +515,13 @@ export default class SpiceModel {
 
           if (isCacheEmpty || shouldRefresh) {
             // Retrieve from the database and update cache
-            results = await this.database.get(args.id);
+            if (p) {
+              results = await p.track(`${this.type}.get.database`, async () => {
+                return await this.database.get(args.id);
+              });
+            } else {
+              results = await this.database.get(args.id);
+            }
             await this.getCacheProviderObject(this.type).set(
               key,
               { value: results, time: new Date().getTime() },
@@ -520,7 +533,13 @@ export default class SpiceModel {
           }
         } else {
           // Directly fetch from the database if caching is disabled
-          results = await this.database.get(args.id);
+          if (p) {
+            results = await p.track(`${this.type}.get.database`, async () => {
+              return await this.database.get(args.id);
+            });
+          } else {
+            results = await this.database.get(args.id);
+          }
         }
 
         if (results.type !== undefined && results.type !== this.type) {
@@ -550,6 +569,13 @@ export default class SpiceModel {
           throw new Error(`${this.type} does not exist`);
         }
       }
+    };
+
+    try {
+      if (p) {
+        return await p.track(`${this.type}.get`, doGet, { id: args?.id });
+      }
+      return await doGet();
     } catch (e) {
       console.log(e.message, e);
       throw e;
@@ -649,7 +675,10 @@ export default class SpiceModel {
   }
 
   async update(args) {
-    try {
+    // Profiling: use track() for proper async context forking
+    const p = this[_ctx]?.profiler;
+
+    const doUpdate = async () => {
       this.updated_at = new SDate().now();
       let results = await this.database.get(args.id);
       let item_exist = await this.exist(results);
@@ -679,7 +708,13 @@ export default class SpiceModel {
       }
       let db_data = cover_obj.new || this;
 
-      await this.database.update(args.id, db_data, args._ttl);
+      if (p) {
+        await p.track(`${this.type}.update.database`, async () => {
+          await this.database.update(args.id, db_data, args._ttl);
+        });
+      } else {
+        await this.database.update(args.id, db_data, args._ttl);
+      }
       this.setMonitor();
 
       if (args.skip_read_serialize != true && args.skip_serialize != true) {
@@ -705,6 +740,13 @@ export default class SpiceModel {
       }
       this.id = args.id;
       return { ...cover_obj.new, id: args.id };
+    };
+
+    try {
+      if (p) {
+        return await p.track(`${this.type}.update`, doUpdate, { id: args?.id });
+      }
+      return await doUpdate();
     } catch (e) {
       console.log("Error on update", e, e.stack);
       throw e;
@@ -712,7 +754,10 @@ export default class SpiceModel {
   }
 
   async create(args = {}) {
-    try {
+    // Profiling: use track() for proper async context forking
+    const p = this[_ctx]?.profiler;
+
+    const doCreate = async () => {
       let form;
       this.created_at = new SDate().now();
       args = _.defaults(args, { id_prefix: this.type });
@@ -738,7 +783,14 @@ export default class SpiceModel {
         await this.run_hook(workingForm, "create", "before");
       }
 
-      let results = await this.database.insert(id, workingForm, args._ttl);
+      let results;
+      if (p) {
+        results = await p.track(`${this.type}.create.database`, async () => {
+          return await this.database.insert(id, workingForm, args._ttl);
+        });
+      } else {
+        results = await this.database.insert(id, workingForm, args._ttl);
+      }
       this.setMonitor();
 
       if (args.skip_read_serialize != true && args.skip_serialize != true) {
@@ -761,6 +813,13 @@ export default class SpiceModel {
         );
       }
       return { ...results, id };
+    };
+
+    try {
+      if (p) {
+        return await p.track(`${this.type}.create`, doCreate);
+      }
+      return await doCreate();
     } catch (e) {
       console.log(e.stack);
       throw e;
@@ -784,29 +843,49 @@ export default class SpiceModel {
   }
 
   async delete(args) {
-    let item_exist = await this.exist(args.id);
+    // Profiling: use track() for proper async context forking
+    const p = this[_ctx]?.profiler;
 
-    if (!item_exist) {
-      throw new Error(`${this.type} does not exist.`);
-    }
-    let results = await this.database.get(args.id);
-    try {
+    const doDelete = async () => {
+      let item_exist = await this.exist(args.id);
+
+      if (!item_exist) {
+        throw new Error(`${this.type} does not exist.`);
+      }
+      let results = await this.database.get(args.id);
       if (args.skip_hooks != true) {
         await this.run_hook(args, "delete", "before");
       }
       let delete_response = {};
-      if (args.hard) {
-        delete_response = await this.database.delete(args.id);
-        this.setMonitor();
+
+      const dbOperation = async () => {
+        if (args.hard) {
+          delete_response = await this.database.delete(args.id);
+          this.setMonitor();
+        } else {
+          delete results["id"];
+          results.deleted = true;
+          delete_response = await this.database.update(args.id, results);
+        }
+      };
+
+      if (p) {
+        await p.track(`${this.type}.delete.database`, dbOperation);
       } else {
-        delete results["id"];
-        results.deleted = true;
-        delete_response = await this.database.update(args.id, results);
+        await dbOperation();
       }
+
       if (args.skip_hooks != true) {
         await this.run_hook(results, "delete", "after", results);
       }
       return {};
+    };
+
+    try {
+      if (p) {
+        return await p.track(`${this.type}.delete`, doDelete, { id: args?.id });
+      }
+      return await doDelete();
     } catch (e) {
       console.log(e.stack);
       throw e;
@@ -1017,9 +1096,8 @@ export default class SpiceModel {
       const aliasRegex = /\s+AS\s+`?([\w]+)`?$/i;
       const aliasMatch = col.match(aliasRegex);
       const explicitAlias = aliasMatch ? aliasMatch[1] : null;
-      const colWithoutAlias = explicitAlias
-        ? col.replace(aliasRegex, "").trim()
-        : col;
+      const colWithoutAlias =
+        explicitAlias ? col.replace(aliasRegex, "").trim() : col;
 
       // `table`.`col` or table.col
       const columnRegex = /^`?([\w]+)`?\.`?([\w]+)`?$/;
@@ -1053,7 +1131,10 @@ export default class SpiceModel {
   }
 
   async list(args = {}) {
-    try {
+    // Profiling: use track() for proper async context forking
+    const p = this[_ctx]?.profiler;
+
+    const doList = async () => {
       if (args.mapping_dept) this[_mapping_dept] = args.mapping_dept;
 
       // Find alias tokens from query/columns/sort
@@ -1126,13 +1207,14 @@ export default class SpiceModel {
       // LIMIT/OFFSET/SORT
       args.limit = Number(args.limit) || undefined;
       args.offset = Number(args.offset) || 0;
-      args.sort = args.sort
-        ? args.sort
+      args.sort =
+        args.sort ?
+          args.sort
             .split(",")
             .map((item) =>
-              item.includes(".")
-                ? item
-                : `\`${this.type}\`.${this.formatSortComponent(item)}`
+              item.includes(".") ? item : (
+                `\`${this.type}\`.${this.formatSortComponent(item)}`
+              )
             )
             .join(",")
         : `\`${this.type}\`.created_at DESC`;
@@ -1180,6 +1262,16 @@ export default class SpiceModel {
 
       results.data = this.filterResultsByColumns(results.data, args.columns);
       return results;
+    };
+
+    try {
+      if (p) {
+        return await p.track(`${this.type}.list`, doList, {
+          limit: args?.limit,
+          offset: args?.offset,
+        });
+      }
+      return await doList();
     } catch (e) {
       console.log(e.stack);
       throw e;
@@ -1187,30 +1279,40 @@ export default class SpiceModel {
   }
 
   async fetchResults(args, query) {
-    if (args.is_custom_query === "true" && args.ids.length > 0) {
-      return await this.database.query(query);
-    } else if (args.is_full_text === "true") {
-      return await this.database.full_text_search(
-        this.type,
-        query || "",
-        args.limit,
-        args.offset,
-        args._join
-      );
-    } else {
-      let result = await this.database.search(
-        this.type,
-        args.columns || "",
-        query || "",
-        args.limit,
-        args.offset,
-        args.sort,
-        args.do_count,
-        args.statement_consistent,
-        args._join
-      );
-      return result;
+    // Profiling: use track() for proper async context forking
+    const p = this[_ctx]?.profiler;
+
+    const doFetch = async () => {
+      if (args.is_custom_query === "true" && args.ids.length > 0) {
+        return await this.database.query(query);
+      } else if (args.is_full_text === "true") {
+        return await this.database.full_text_search(
+          this.type,
+          query || "",
+          args.limit,
+          args.offset,
+          args._join
+        );
+      } else {
+        let result = await this.database.search(
+          this.type,
+          args.columns || "",
+          query || "",
+          args.limit,
+          args.offset,
+          args.sort,
+          args.do_count,
+          args.statement_consistent,
+          args._join
+        );
+        return result;
+      }
+    };
+
+    if (p) {
+      return await p.track(`${this.type}.fetchResults`, doFetch);
     }
+    return await doFetch();
   }
 
   addHook({ operation, when, execute }) {
@@ -1264,11 +1366,11 @@ export default class SpiceModel {
   // ⚡ OPTIMIZED: Cache defaults metadata per model type
   getDefaultsMetadata(type) {
     const cacheKey = `${this.type}::${type}`;
-    
+
     if (!SpiceModel._defaultsCache[cacheKey]) {
       const staticDefaults = {};
       const dynamicDefaults = [];
-      
+
       // Pre-compute once per model type
       for (const key in this.props) {
         const def = this.props[key]?.defaults?.[type];
@@ -1280,14 +1382,15 @@ export default class SpiceModel {
           }
         }
       }
-      
+
       SpiceModel._defaultsCache[cacheKey] = {
         staticDefaults,
         dynamicDefaults,
-        hasDefaults: Object.keys(staticDefaults).length > 0 || dynamicDefaults.length > 0
+        hasDefaults:
+          Object.keys(staticDefaults).length > 0 || dynamicDefaults.length > 0,
       };
     }
-    
+
     return SpiceModel._defaultsCache[cacheKey];
   }
 
@@ -1461,9 +1564,9 @@ export default class SpiceModel {
                   execute: async (data) => {
                     return await this.mapToObject(
                       data,
-                      _.isString(properties[i].map.reference)
-                        ? spice.models[properties[i].map.reference]
-                        : properties[i].map.reference,
+                      _.isString(properties[i].map.reference) ?
+                        spice.models[properties[i].map.reference]
+                      : properties[i].map.reference,
                       i,
                       properties[i].map.destination || i,
                       properties[i]
@@ -1479,9 +1582,9 @@ export default class SpiceModel {
                   execute: async (data) => {
                     return await this.mapToObjectArray(
                       data,
-                      _.isString(properties[i].map.reference)
-                        ? spice.models[properties[i].map.reference]
-                        : properties[i].map.reference,
+                      _.isString(properties[i].map.reference) ?
+                        spice.models[properties[i].map.reference]
+                      : properties[i].map.reference,
                       i,
                       properties[i].map.destination || i,
                       properties[i]
@@ -1502,7 +1605,10 @@ export default class SpiceModel {
   }
 
   async do_serialize(data, type, old_data, args, path_to_be_removed = []) {
-    try {
+    // Profiling: use track() for proper async context forking
+    const p = this[_ctx]?.profiler;
+
+    const doSerialize = async () => {
       // Early exit if serialization should not run.
       if (!this.shouldSerializerRun(args, type)) {
         return data;
@@ -1531,20 +1637,21 @@ export default class SpiceModel {
       }
 
       // ⚡ OPTIMIZED: Use cached defaults metadata instead of computing every time
-      const { staticDefaults, dynamicDefaults, hasDefaults } = this.getDefaultsMetadata(type);
-      
+      const { staticDefaults, dynamicDefaults, hasDefaults } =
+        this.getDefaultsMetadata(type);
+
       if (hasDefaults) {
         data = data.map((item) => {
           // Apply static defaults first (fast - no function calls)
           const result = _.defaults({}, item, staticDefaults);
-          
+
           // Only compute dynamic defaults if there are any
           for (const { key, fn } of dynamicDefaults) {
             if (result[key] === undefined) {
               result[key] = fn({ old_data: data, new_data: old_data });
             }
           }
-          
+
           return result;
         });
       }
@@ -1565,6 +1672,15 @@ export default class SpiceModel {
 
       // Return in the original format (array or single object).
       return originalIsArray ? data : data[0];
+    };
+
+    try {
+      if (p) {
+        return await p.track(`${this.type}.do_serialize`, doSerialize, {
+          type,
+        });
+      }
+      return await doSerialize();
     } catch (error) {
       console.error("Error in do_serialize:", error.stack);
       throw error;