spice-js 2.6.72 → 2.6.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-js",
-  "version": "2.6.72",
+  "version": "2.6.74",
   "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) {
@@ -499,7 +499,8 @@ export default class SpiceModel {
         if (args.skip_hooks !== true) {
           await this.run_hook(args, "get", "before");
         }
-        let key = `get::${this.type}::${args.id}`;
+        // ⚡ Include columns in cache key if specified
+        let key = `get::${this.type}::${args.id}${args.columns ? `::${args.columns}` : ""}`;
         let results = {};
 
         if (this.shouldUseCache(this.type)) {
@@ -515,12 +516,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 +534,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);
           }
         }
 
@@ -553,6 +554,7 @@ export default class SpiceModel {
             args.skip_read_serialize !== true &&
             args.skip_serialize !== true
           ) {
+            // ⚡ Pass columns to do_serialize so it can skip irrelevant modifiers
             results = await this.do_serialize(
               results,
               "read",
@@ -561,6 +563,12 @@ export default class SpiceModel {
               await this.propsToBeRemoved(results)
             );
           }
+          
+          // ⚡ OPTIMIZED: Filter results by columns if specified
+          if (args.columns) {
+            results = this.filterResultsByColumns([results], args.columns)[0];
+          }
+          
           if (args.skip_hooks !== true) {
             await this.run_hook(results, "get", "after");
           }
@@ -569,11 +577,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 +683,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 +716,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 +748,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 +791,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 +821,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 +851,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 +865,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 +875,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 +1139,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 +1270,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 +1315,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 }) {
@@ -1501,9 +1541,10 @@ export default class SpiceModel {
     return original_is_array ? data : data[0];
   }
 
-  addModifier({ when, execute }) {
+  addModifier({ when, execute, field = null }) {
     if (this[_serializers][when]) {
-      this[_serializers][when]["modifiers"].push(execute);
+      // Store as object with field info for column-based filtering
+      this[_serializers][when]["modifiers"].push({ execute, field });
     }
   }
 
@@ -1524,11 +1565,13 @@ export default class SpiceModel {
       if (properties[i].map) {
         switch (properties[i].map.type) {
           case MapType.MODEL: {
+            const destinationField = properties[i].map.destination || i;
             switch (properties[i].type) {
               case String:
               case "string": {
                 this.addModifier({
                   when: properties[i].map.when || "read",
+                  field: destinationField, // ⚡ Track which field this modifier populates
                   execute: async (data) => {
                     return await this.mapToObject(
                       data,
@@ -1536,7 +1579,7 @@ export default class SpiceModel {
                         spice.models[properties[i].map.reference]
                       : properties[i].map.reference,
                       i,
-                      properties[i].map.destination || i,
+                      destinationField,
                       properties[i]
                     );
                   },
@@ -1547,6 +1590,7 @@ export default class SpiceModel {
               case "array": {
                 this.addModifier({
                   when: properties[i].map.when || "read",
+                  field: destinationField, // ⚡ Track which field this modifier populates
                   execute: async (data) => {
                     return await this.mapToObjectArray(
                       data,
@@ -1554,7 +1598,7 @@ export default class SpiceModel {
                         spice.models[properties[i].map.reference]
                       : properties[i].map.reference,
                       i,
-                      properties[i].map.destination || i,
+                      destinationField,
                       properties[i]
                     );
                   },
@@ -1572,11 +1616,39 @@ export default class SpiceModel {
     }
   }
 
+  // ⚡ Parse columns string into a Set for fast lookup
+  parseRequestedColumns(columns) {
+    if (!columns || columns === "") return null;
+    
+    // Extract field names from column specifications
+    // Handles: "field", "`field`", "table.field", "`table`.`field`", "expr AS alias"
+    const fields = new Set();
+    const columnList = columns.split(",").map((c) => c.trim());
+    
+    for (const col of columnList) {
+      // Check for AS alias
+      const aliasMatch = col.match(/\s+AS\s+`?([\w]+)`?$/i);
+      if (aliasMatch) {
+        fields.add(aliasMatch[1]);
+        continue;
+      }
+      
+      // Get the last part after dots (the field name)
+      const parts = col.replace(/`/g, "").split(".");
+      const fieldName = parts[parts.length - 1];
+      if (fieldName && fieldName !== "*") {
+        fields.add(fieldName);
+      }
+    }
+    
+    return fields.size > 0 ? fields : null;
+  }
+
   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;
@@ -1588,11 +1660,21 @@ export default class SpiceModel {
         this[_external_modifier_loaded] = true;
       }
 
+      // ⚡ OPTIMIZED: Parse requested columns for selective modifier execution
+      const requestedColumns = this.parseRequestedColumns(args?.columns);
+
       // Cache the modifiers lookup for the specified type.
       const modifiers = this[_serializers]?.[type]?.modifiers || [];
       for (const modifier of modifiers) {
         try {
-          data = await modifier(data, old_data, this[_ctx], this.type);
+          // ⚡ OPTIMIZED: Skip field-specific modifiers if columns specified and field not requested
+          if (requestedColumns && modifier.field && !requestedColumns.has(modifier.field)) {
+            continue; // Skip this modifier - field not in requested columns
+          }
+          
+          // Execute modifier (supports both old function format and new object format)
+          const executeFn = typeof modifier === "function" ? modifier : modifier.execute;
+          data = await executeFn(data, old_data, this[_ctx], this.type);
         } catch (error) {
           console.error("Modifier error in do_serialize:", error.stack);
         }
@@ -1640,11 +1722,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);
     }
   }
 }