spice-js 2.6.72 → 2.6.73

package/package.json

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

package/src/models/SpiceModel.js

@@ -486,10 +486,10 @@ export default class SpiceModel {
   }
 
   async get(args) {
-    // Profiling: zero overhead when disabled (single falsy check)
-    const p = this[_ctx]?.profiler,
-      c = p?.start(`${this.type}.get`, { id: args?.id });
-    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) {
@@ -515,12 +515,12 @@ export default class SpiceModel {
 
           if (isCacheEmpty || shouldRefresh) {
             // Retrieve from the database and update cache
-            const pDb = p,
-              cDb = pDb?.start(`${this.type}.get.database`);
-            try {
+            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);
-            } finally {
-              cDb && pDb.end(cDb);
             }
             await this.getCacheProviderObject(this.type).set(
               key,
@@ -533,12 +533,12 @@ export default class SpiceModel {
           }
         } else {
           // Directly fetch from the database if caching is disabled
-          const pDb = p,
-            cDb = pDb?.start(`${this.type}.get.database`);
-          try {
+          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);
-          } finally {
-            cDb && pDb.end(cDb);
           }
         }
 
@@ -569,11 +569,16 @@ 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;
-    } finally {
-      c && p.end(c);
     }
   }
 
@@ -670,10 +675,10 @@ export default class SpiceModel {
   }
 
   async update(args) {
-    // Profiling: zero overhead when disabled (single falsy check)
-    const p = this[_ctx]?.profiler,
-      c = p?.start(`${this.type}.update`, { id: args?.id });
-    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);
@@ -703,12 +708,12 @@ export default class SpiceModel {
       }
       let db_data = cover_obj.new || this;
 
-      const pDb = p,
-        cDb = pDb?.start(`${this.type}.update.database`);
-      try {
+      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);
-      } finally {
-        cDb && pDb.end(cDb);
       }
       this.setMonitor();
 
@@ -735,19 +740,24 @@ 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;
-    } finally {
-      c && p.end(c);
     }
   }
 
   async create(args = {}) {
-    // Profiling: zero overhead when disabled (single falsy check)
-    const p = this[_ctx]?.profiler,
-      c = p?.start(`${this.type}.create`);
-    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 });
@@ -773,13 +783,13 @@ export default class SpiceModel {
         await this.run_hook(workingForm, "create", "before");
       }
 
-      const pDb = p,
-        cDb = pDb?.start(`${this.type}.create.database`);
       let results;
-      try {
+      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);
-      } finally {
-        cDb && pDb.end(cDb);
       }
       this.setMonitor();
 
@@ -803,11 +813,16 @@ 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;
-    } finally {
-      c && p.end(c);
     }
   }
 
@@ -828,10 +843,10 @@ export default class SpiceModel {
   }
 
   async delete(args) {
-    // Profiling: zero overhead when disabled (single falsy check)
-    const p = this[_ctx]?.profiler,
-      c = p?.start(`${this.type}.delete`, { id: args?.id });
-    try {
+    // Profiling: use track() for proper async context forking
+    const p = this[_ctx]?.profiler;
+
+    const doDelete = async () => {
       let item_exist = await this.exist(args.id);
 
       if (!item_exist) {
@@ -842,9 +857,8 @@ export default class SpiceModel {
         await this.run_hook(args, "delete", "before");
       }
       let delete_response = {};
-      const pDb = p,
-        cDb = pDb?.start(`${this.type}.delete.database`);
-      try {
+
+      const dbOperation = async () => {
         if (args.hard) {
           delete_response = await this.database.delete(args.id);
           this.setMonitor();
@@ -853,18 +867,28 @@ export default class SpiceModel {
           results.deleted = true;
           delete_response = await this.database.update(args.id, results);
         }
-      } finally {
-        cDb && pDb.end(cDb);
+      };
+
+      if (p) {
+        await p.track(`${this.type}.delete.database`, dbOperation);
+      } else {
+        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;
-    } finally {
-      c && p.end(c);
     }
   }
 
@@ -1107,13 +1131,10 @@ export default class SpiceModel {
   }
 
   async list(args = {}) {
-    // Profiling: zero overhead when disabled (single falsy check)
-    const p = this[_ctx]?.profiler,
-      c = p?.start(`${this.type}.list`, {
-        limit: args?.limit,
-        offset: args?.offset,
-      });
-    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
@@ -1241,19 +1262,27 @@ 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;
-    } finally {
-      c && p.end(c);
     }
   }
 
   async fetchResults(args, query) {
-    // Profiling: zero overhead when disabled (single falsy check)
-    const p = this[_ctx]?.profiler,
-      c = p?.start(`${this.type}.fetchResults`);
-    try {
+    // 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") {
@@ -1278,9 +1307,12 @@ export default class SpiceModel {
         );
         return result;
       }
-    } finally {
-      c && p.end(c);
+    };
+
+    if (p) {
+      return await p.track(`${this.type}.fetchResults`, doFetch);
     }
+    return await doFetch();
   }
 
   addHook({ operation, when, execute }) {
@@ -1573,10 +1605,10 @@ export default class SpiceModel {
   }
 
   async do_serialize(data, type, old_data, args, path_to_be_removed = []) {
-    // Profiling: zero overhead when disabled (single falsy check)
-    const p = this[_ctx]?.profiler,
-      c = p?.start(`${this.type}.do_serialize`, { type });
-    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;
@@ -1640,11 +1672,18 @@ 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;
-    } finally {
-      c && p.end(c);
     }
   }
 }