spice-js 2.6.70 → 2.6.72

package/src/models/SpiceModel.js

@@ -42,6 +42,10 @@ if (!Promise.allSettled) {
     );
 }
 export default class SpiceModel {
+  // ⚡ Static caches for performance optimization
+  static _defaultsCache = {};
+  static _hiddenPropsCache = {};
+
   constructor(args = {}) {
     try {
       var dbtype =
@@ -165,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";
@@ -186,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;
               }
@@ -478,6 +486,9 @@ 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 {
       if (args.mapping_dept) this[_mapping_dept] = args.mapping_dept;
 
@@ -504,7 +515,13 @@ export default class SpiceModel {
 
           if (isCacheEmpty || shouldRefresh) {
             // Retrieve from the database and update cache
-            results = await this.database.get(args.id);
+            const pDb = p,
+              cDb = pDb?.start(`${this.type}.get.database`);
+            try {
+              results = await this.database.get(args.id);
+            } finally {
+              cDb && pDb.end(cDb);
+            }
             await this.getCacheProviderObject(this.type).set(
               key,
               { value: results, time: new Date().getTime() },
@@ -516,7 +533,13 @@ export default class SpiceModel {
           }
         } else {
           // Directly fetch from the database if caching is disabled
-          results = await this.database.get(args.id);
+          const pDb = p,
+            cDb = pDb?.start(`${this.type}.get.database`);
+          try {
+            results = await this.database.get(args.id);
+          } finally {
+            cDb && pDb.end(cDb);
+          }
         }
 
         if (results.type !== undefined && results.type !== this.type) {
@@ -549,6 +572,8 @@ export default class SpiceModel {
     } catch (e) {
       console.log(e.message, e);
       throw e;
+    } finally {
+      c && p.end(c);
     }
   }
 
@@ -645,6 +670,9 @@ 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 {
       this.updated_at = new SDate().now();
       let results = await this.database.get(args.id);
@@ -675,7 +703,13 @@ export default class SpiceModel {
       }
       let db_data = cover_obj.new || this;
 
-      await this.database.update(args.id, db_data, args._ttl);
+      const pDb = p,
+        cDb = pDb?.start(`${this.type}.update.database`);
+      try {
+        await this.database.update(args.id, db_data, args._ttl);
+      } finally {
+        cDb && pDb.end(cDb);
+      }
       this.setMonitor();
 
       if (args.skip_read_serialize != true && args.skip_serialize != true) {
@@ -704,10 +738,15 @@ export default class SpiceModel {
     } 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 {
       let form;
       this.created_at = new SDate().now();
@@ -734,7 +773,14 @@ export default class SpiceModel {
         await this.run_hook(workingForm, "create", "before");
       }
 
-      let results = await this.database.insert(id, workingForm, args._ttl);
+      const pDb = p,
+        cDb = pDb?.start(`${this.type}.create.database`);
+      let results;
+      try {
+        results = await this.database.insert(id, workingForm, args._ttl);
+      } finally {
+        cDb && pDb.end(cDb);
+      }
       this.setMonitor();
 
       if (args.skip_read_serialize != true && args.skip_serialize != true) {
@@ -760,6 +806,8 @@ export default class SpiceModel {
     } catch (e) {
       console.log(e.stack);
       throw e;
+    } finally {
+      c && p.end(c);
     }
   }
 
@@ -780,24 +828,33 @@ export default class SpiceModel {
   }
 
   async delete(args) {
-    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);
+    // Profiling: zero overhead when disabled (single falsy check)
+    const p = this[_ctx]?.profiler,
+      c = p?.start(`${this.type}.delete`, { id: args?.id });
     try {
+      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();
-      } else {
-        delete results["id"];
-        results.deleted = true;
-        delete_response = await this.database.update(args.id, results);
+      const pDb = p,
+        cDb = pDb?.start(`${this.type}.delete.database`);
+      try {
+        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);
+        }
+      } finally {
+        cDb && pDb.end(cDb);
       }
       if (args.skip_hooks != true) {
         await this.run_hook(results, "delete", "after", results);
@@ -806,6 +863,8 @@ export default class SpiceModel {
     } catch (e) {
       console.log(e.stack);
       throw e;
+    } finally {
+      c && p.end(c);
     }
   }
 
@@ -1013,9 +1072,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]+)`?$/;
@@ -1049,6 +1107,12 @@ 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 {
       if (args.mapping_dept) this[_mapping_dept] = args.mapping_dept;
 
@@ -1122,13 +1186,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`;
@@ -1179,33 +1244,42 @@ export default class SpiceModel {
     } catch (e) {
       console.log(e.stack);
       throw e;
+    } finally {
+      c && p.end(c);
     }
   }
 
   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: zero overhead when disabled (single falsy check)
+    const p = this[_ctx]?.profiler,
+      c = p?.start(`${this.type}.fetchResults`);
+    try {
+      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;
+      }
+    } finally {
+      c && p.end(c);
     }
   }
 
@@ -1257,6 +1331,47 @@ export default class SpiceModel {
     return true;
   }
 
+  // ⚡ 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];
+        if (def !== undefined) {
+          if (_.isFunction(def)) {
+            dynamicDefaults.push({ key, fn: def });
+          } else {
+            staticDefaults[key] = def;
+          }
+        }
+      }
+
+      SpiceModel._defaultsCache[cacheKey] = {
+        staticDefaults,
+        dynamicDefaults,
+        hasDefaults:
+          Object.keys(staticDefaults).length > 0 || dynamicDefaults.length > 0,
+      };
+    }
+
+    return SpiceModel._defaultsCache[cacheKey];
+  }
+
+  // ⚡ OPTIMIZED: Cache hidden props per model type
+  getHiddenProps() {
+    if (!SpiceModel._hiddenPropsCache[this.type]) {
+      SpiceModel._hiddenPropsCache[this.type] = Object.keys(this.props).filter(
+        (key) => this.props[key]?.hide
+      );
+    }
+    return SpiceModel._hiddenPropsCache[this.type];
+  }
+
   async mapToObject(data, Class, source_property, store_property, property) {
     let original_is_array = _.isArray(data);
     if (!original_is_array) {
@@ -1417,9 +1532,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]
@@ -1435,9 +1550,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]
@@ -1458,6 +1573,9 @@ 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 {
       // Early exit if serialization should not run.
       if (!this.shouldSerializerRun(args, type)) {
@@ -1486,26 +1604,30 @@ export default class SpiceModel {
         data = [data];
       }
 
-      // Compute the defaults from properties using reduce.
-      const defaults = Object.keys(this.props).reduce((acc, key) => {
-        const def = this.props[key]?.defaults?.[type];
-        if (def !== undefined) {
-          acc[key] = _.isFunction(def)
-            ? def({ old_data: data, new_data: old_data })
-            : def;
-        }
-        return acc;
-      }, {});
+      // ⚡ OPTIMIZED: Use cached defaults metadata instead of computing every time
+      const { staticDefaults, dynamicDefaults, hasDefaults } =
+        this.getDefaultsMetadata(type);
 
-      // Merge defaults into each object.
-      data = data.map((item) => _.defaults(item, defaults));
+      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;
+        });
+      }
 
       // If type is "read", clean the data by omitting certain props.
       if (type === "read") {
-        // Collect hidden properties from schema.
-        const hiddenProps = Object.keys(this.props).filter(
-          (key) => this.props[key]?.hide
-        );
+        // ⚡ OPTIMIZED: Use cached hidden props instead of computing every time
+        const hiddenProps = this.getHiddenProps();
         // Combine default props to remove.
         const propsToClean = [
           "deleted",
@@ -1521,6 +1643,8 @@ export default class SpiceModel {
     } catch (error) {
       console.error("Error in do_serialize:", error.stack);
       throw error;
+    } finally {
+      c && p.end(c);
     }
   }
 }