spice-js 2.6.71 → 2.6.73

package/build/models/SpiceModel.js

@@ -566,67 +566,109 @@ class SpiceModel {
     var _this4 = this;
 
     return _asyncToGenerator(function* () {
-      try {
-        if (args.mapping_dept) _this4[_mapping_dept] = args.mapping_dept;
+      var _this4$_ctx;
 
-        if (!args) {
-          args = {};
-        }
+      // Profiling: use track() for proper async context forking
+      var p = (_this4$_ctx = _this4[_ctx]) == null ? void 0 : _this4$_ctx.profiler;
 
-        if (_.isString(args.id)) {
-          if (args.skip_hooks !== true) {
-            yield _this4.run_hook(args, "get", "before");
+      var doGet =
+      /*#__PURE__*/
+      function () {
+        var _ref2 = _asyncToGenerator(function* () {
+          if (args.mapping_dept) _this4[_mapping_dept] = args.mapping_dept;
+
+          if (!args) {
+            args = {};
           }
 
-          var key = "get::" + _this4.type + "::" + args.id;
-          var results = {};
+          if (_.isString(args.id)) {
+            if (args.skip_hooks !== true) {
+              yield _this4.run_hook(args, "get", "before");
+            }
 
-          if (_this4.shouldUseCache(_this4.type)) {
-            // Retrieve the cached results
-            var cached_results = yield _this4.getCacheProviderObject(_this4.type).get(key); // Check if the cache is empty
+            var key = "get::" + _this4.type + "::" + args.id;
+            var results = {};
 
-            var isCacheEmpty = (cached_results == null ? void 0 : cached_results.value) === undefined; // Check if the cached result should be refreshed
+            if (_this4.shouldUseCache(_this4.type)) {
+              // Retrieve the cached results
+              var cached_results = yield _this4.getCacheProviderObject(_this4.type).get(key); // Check if the cache is empty
 
-            var shouldRefresh = yield _this4.shouldForceRefresh(cached_results); // Force a refresh for "workflow" type if needed
+              var isCacheEmpty = (cached_results == null ? void 0 : cached_results.value) === undefined; // Check if the cached result should be refreshed
 
-            if (isCacheEmpty || shouldRefresh) {
-              // Retrieve from the database and update cache
-              results = yield _this4.database.get(args.id);
-              yield _this4.getCacheProviderObject(_this4.type).set(key, {
-                value: results,
-                time: new Date().getTime()
-              }, _this4.getCacheConfig(_this4.type));
-            } else {
-              // Use the cached value
-              results = cached_results.value;
-            }
-          } else {
-            // Directly fetch from the database if caching is disabled
-            results = yield _this4.database.get(args.id);
-          }
+              var shouldRefresh = yield _this4.shouldForceRefresh(cached_results); // Force a refresh for "workflow" type if needed
 
-          if (results.type !== undefined && results.type !== _this4.type) {
-            throw new Error(_this4.type + " does not exist type");
-          }
+              if (isCacheEmpty || shouldRefresh) {
+                // Retrieve from the database and update cache
+                if (p) {
+                  results = yield p.track(_this4.type + ".get.database",
+                  /*#__PURE__*/
+                  _asyncToGenerator(function* () {
+                    return yield _this4.database.get(args.id);
+                  }));
+                } else {
+                  results = yield _this4.database.get(args.id);
+                }
 
-          if (results._type !== undefined && results._type !== _this4.type) {
-            throw new Error(_this4.type + " does not exist _type");
-          }
+                yield _this4.getCacheProviderObject(_this4.type).set(key, {
+                  value: results,
+                  time: new Date().getTime()
+                }, _this4.getCacheConfig(_this4.type));
+              } else {
+                // Use the cached value
+                results = cached_results.value;
+              }
+            } else {
+              // Directly fetch from the database if caching is disabled
+              if (p) {
+                results = yield p.track(_this4.type + ".get.database",
+                /*#__PURE__*/
+                _asyncToGenerator(function* () {
+                  return yield _this4.database.get(args.id);
+                }));
+              } else {
+                results = yield _this4.database.get(args.id);
+              }
+            }
 
-          if (results.deleted === undefined || results.deleted === false) {
-            if (args.skip_read_serialize !== true && args.skip_serialize !== true) {
-              results = yield _this4.do_serialize(results, "read", {}, args, (yield _this4.propsToBeRemoved(results)));
+            if (results.type !== undefined && results.type !== _this4.type) {
+              throw new Error(_this4.type + " does not exist type");
             }
 
-            if (args.skip_hooks !== true) {
-              yield _this4.run_hook(results, "get", "after");
+            if (results._type !== undefined && results._type !== _this4.type) {
+              throw new Error(_this4.type + " does not exist _type");
             }
 
-            return results;
-          } else {
-            throw new Error(_this4.type + " does not exist");
+            if (results.deleted === undefined || results.deleted === false) {
+              if (args.skip_read_serialize !== true && args.skip_serialize !== true) {
+                results = yield _this4.do_serialize(results, "read", {}, args, (yield _this4.propsToBeRemoved(results)));
+              }
+
+              if (args.skip_hooks !== true) {
+                yield _this4.run_hook(results, "get", "after");
+              }
+
+              return results;
+            } else {
+              throw new Error(_this4.type + " does not exist");
+            }
           }
+        });
+
+        return function doGet() {
+          return _ref2.apply(this, arguments);
+        };
+      }();
+
+      try {
+        if (p) {
+          var _args6;
+
+          return yield p.track(_this4.type + ".get", doGet, {
+            id: (_args6 = args) == null ? void 0 : _args6.id
+          });
         }
+
+        return yield doGet();
       } catch (e) {
         console.log(e.message, e);
         throw e;
@@ -735,53 +777,85 @@ class SpiceModel {
     var _this8 = this;
 
     return _asyncToGenerator(function* () {
-      try {
-        _this8.updated_at = new SDate().now();
-        var results = yield _this8.database.get(args.id);
-        var item_exist = yield _this8.exist(results);
+      var _this8$_ctx;
 
-        if (!item_exist) {
-          throw new Error(_this8.type + " does not exist. in update");
-        }
+      // Profiling: use track() for proper async context forking
+      var p = (_this8$_ctx = _this8[_ctx]) == null ? void 0 : _this8$_ctx.profiler;
 
-        delete results["id"];
+      var doUpdate =
+      /*#__PURE__*/
+      function () {
+        var _ref5 = _asyncToGenerator(function* () {
+          _this8.updated_at = new SDate().now();
+          var results = yield _this8.database.get(args.id);
+          var item_exist = yield _this8.exist(results);
 
-        _.defaults(_this8, results);
+          if (!item_exist) {
+            throw new Error(_this8.type + " does not exist. in update");
+          }
 
-        var cover_obj = {
-          old: results,
-          new: _this8,
-          id: args.id
-        };
-        var form;
+          delete results["id"];
 
-        if (args.skip_write_serialize != true && args.skip_serialize != true) {
-          cover_obj.new = yield _this8.do_serialize(_this8, "write", cover_obj.new, args);
-        }
+          _.defaults(_this8, results);
 
-        if (args.skip_hooks != true) {
-          yield _this8.run_hook(cover_obj, "update", "before", results);
-        }
+          var cover_obj = {
+            old: results,
+            new: _this8,
+            id: args.id
+          };
+          var form;
 
-        var db_data = cover_obj.new || _this8;
-        yield _this8.database.update(args.id, db_data, args._ttl);
+          if (args.skip_write_serialize != true && args.skip_serialize != true) {
+            cover_obj.new = yield _this8.do_serialize(_this8, "write", cover_obj.new, args);
+          }
 
-        _this8.setMonitor();
+          if (args.skip_hooks != true) {
+            yield _this8.run_hook(cover_obj, "update", "before", results);
+          }
 
-        if (args.skip_read_serialize != true && args.skip_serialize != true) {
-          cover_obj.new = yield _this8.do_serialize(cover_obj.new, "read", {}, args, (yield _this8.propsToBeRemoved(cover_obj.new)));
-        }
+          var db_data = cover_obj.new || _this8;
 
-        if (args.skip_hooks != true) {
-          yield _this8.run_hook(_extends({}, _this8, {
+          if (p) {
+            yield p.track(_this8.type + ".update.database",
+            /*#__PURE__*/
+            _asyncToGenerator(function* () {
+              yield _this8.database.update(args.id, db_data, args._ttl);
+            }));
+          } else {
+            yield _this8.database.update(args.id, db_data, args._ttl);
+          }
+
+          _this8.setMonitor();
+
+          if (args.skip_read_serialize != true && args.skip_serialize != true) {
+            cover_obj.new = yield _this8.do_serialize(cover_obj.new, "read", {}, args, (yield _this8.propsToBeRemoved(cover_obj.new)));
+          }
+
+          if (args.skip_hooks != true) {
+            yield _this8.run_hook(_extends({}, _this8, {
+              id: args.id
+            }), "update", "after", results);
+          }
+
+          _this8.id = args.id;
+          return _extends({}, cover_obj.new, {
             id: args.id
-          }), "update", "after", results);
+          });
+        });
+
+        return function doUpdate() {
+          return _ref5.apply(this, arguments);
+        };
+      }();
+
+      try {
+        if (p) {
+          return yield p.track(_this8.type + ".update", doUpdate, {
+            id: args == null ? void 0 : args.id
+          });
         }
 
-        _this8.id = args.id;
-        return _extends({}, cover_obj.new, {
-          id: args.id
-        });
+        return yield doUpdate();
       } catch (e) {
         console.log("Error on update", e, e.stack);
         throw e;
@@ -793,57 +867,88 @@ class SpiceModel {
     var _this9 = this;
 
     return _asyncToGenerator(function* () {
+      var _this9$_ctx;
+
       if (args === void 0) {
         args = {};
       }
 
-      try {
-        var form;
-        _this9.created_at = new SDate().now();
-        args = _.defaults(args, {
-          id_prefix: _this9.type
-        });
+      // Profiling: use track() for proper async context forking
+      var p = (_this9$_ctx = _this9[_ctx]) == null ? void 0 : _this9$_ctx.profiler;
+
+      var doCreate =
+      /*#__PURE__*/
+      function () {
+        var _ref7 = _asyncToGenerator(function* () {
+          var form;
+          _this9.created_at = new SDate().now();
+          args = _.defaults(args, {
+            id_prefix: _this9.type
+          });
 
-        if (args.body) {
-          form = _.defaults({}, args.body);
-          form.created_at = _this9.created_at;
-          form.updated_at = _this9.created_at;
-          delete form["bucket"];
-        }
+          if (args.body) {
+            form = _.defaults({}, args.body);
+            form.created_at = _this9.created_at;
+            form.updated_at = _this9.created_at;
+            delete form["bucket"];
+          }
 
-        var workingForm = form || _this9;
-        _this9.updated_at = new SDate().now();
-        var id = args.id_prefix + "-" + UUID.v4();
+          var workingForm = form || _this9;
+          _this9.updated_at = new SDate().now();
+          var id = args.id_prefix + "-" + UUID.v4();
 
-        if (args && args.id) {
-          id = args.id;
-        }
+          if (args && args.id) {
+            id = args.id;
+          }
 
-        if (args.skip_write_serialize != true && args.skip_serialize != true) {
-          workingForm = yield _this9.do_serialize(workingForm, "write", {}, args);
-        }
+          if (args.skip_write_serialize != true && args.skip_serialize != true) {
+            workingForm = yield _this9.do_serialize(workingForm, "write", {}, args);
+          }
 
-        if (args.skip_hooks != true) {
-          yield _this9.run_hook(workingForm, "create", "before");
-        }
+          if (args.skip_hooks != true) {
+            yield _this9.run_hook(workingForm, "create", "before");
+          }
 
-        var results = yield _this9.database.insert(id, workingForm, args._ttl);
+          var results;
 
-        _this9.setMonitor();
+          if (p) {
+            results = yield p.track(_this9.type + ".create.database",
+            /*#__PURE__*/
+            _asyncToGenerator(function* () {
+              return yield _this9.database.insert(id, workingForm, args._ttl);
+            }));
+          } else {
+            results = yield _this9.database.insert(id, workingForm, args._ttl);
+          }
 
-        if (args.skip_read_serialize != true && args.skip_serialize != true) {
-          results = yield _this9.do_serialize(results, "read", {}, args, (yield _this9.propsToBeRemoved(results)));
-        }
+          _this9.setMonitor();
 
-        if (args.skip_hooks != true) {
-          yield _this9.run_hook(_extends({}, results, {
+          if (args.skip_read_serialize != true && args.skip_serialize != true) {
+            results = yield _this9.do_serialize(results, "read", {}, args, (yield _this9.propsToBeRemoved(results)));
+          }
+
+          if (args.skip_hooks != true) {
+            yield _this9.run_hook(_extends({}, results, {
+              id
+            }), "create", "after");
+          }
+
+          return _extends({}, results, {
             id
-          }), "create", "after");
+          });
+        });
+
+        return function doCreate() {
+          return _ref7.apply(this, arguments);
+        };
+      }();
+
+      try {
+        if (p) {
+          return yield p.track(_this9.type + ".create", doCreate);
         }
 
-        return _extends({}, results, {
-          id
-        });
+        return yield doCreate();
       } catch (e) {
         console.log(e.stack);
         throw e;
@@ -876,36 +981,75 @@ class SpiceModel {
     var _this11 = this;
 
     return _asyncToGenerator(function* () {
-      var item_exist = yield _this11.exist(args.id);
+      var _this11$_ctx;
 
-      if (!item_exist) {
-        throw new Error(_this11.type + " does not exist.");
-      }
+      // Profiling: use track() for proper async context forking
+      var p = (_this11$_ctx = _this11[_ctx]) == null ? void 0 : _this11$_ctx.profiler;
 
-      var results = yield _this11.database.get(args.id);
+      var doDelete =
+      /*#__PURE__*/
+      function () {
+        var _ref9 = _asyncToGenerator(function* () {
+          var item_exist = yield _this11.exist(args.id);
 
-      try {
-        if (args.skip_hooks != true) {
-          yield _this11.run_hook(args, "delete", "before");
-        }
+          if (!item_exist) {
+            throw new Error(_this11.type + " does not exist.");
+          }
 
-        var delete_response = {};
+          var results = yield _this11.database.get(args.id);
 
-        if (args.hard) {
-          delete_response = yield _this11.database.delete(args.id);
+          if (args.skip_hooks != true) {
+            yield _this11.run_hook(args, "delete", "before");
+          }
 
-          _this11.setMonitor();
-        } else {
-          delete results["id"];
-          results.deleted = true;
-          delete_response = yield _this11.database.update(args.id, results);
-        }
+          var delete_response = {};
 
-        if (args.skip_hooks != true) {
-          yield _this11.run_hook(results, "delete", "after", results);
+          var dbOperation =
+          /*#__PURE__*/
+          function () {
+            var _ref10 = _asyncToGenerator(function* () {
+              if (args.hard) {
+                delete_response = yield _this11.database.delete(args.id);
+
+                _this11.setMonitor();
+              } else {
+                delete results["id"];
+                results.deleted = true;
+                delete_response = yield _this11.database.update(args.id, results);
+              }
+            });
+
+            return function dbOperation() {
+              return _ref10.apply(this, arguments);
+            };
+          }();
+
+          if (p) {
+            yield p.track(_this11.type + ".delete.database", dbOperation);
+          } else {
+            yield dbOperation();
+          }
+
+          if (args.skip_hooks != true) {
+            yield _this11.run_hook(results, "delete", "after", results);
+          }
+
+          return {};
+        });
+
+        return function doDelete() {
+          return _ref9.apply(this, arguments);
+        };
+      }();
+
+      try {
+        if (p) {
+          return yield p.track(_this11.type + ".delete", doDelete, {
+            id: args == null ? void 0 : args.id
+          });
         }
 
-        return {};
+        return yield doDelete();
       } catch (e) {
         console.log(e.stack);
         throw e;
@@ -1063,12 +1207,12 @@ class SpiceModel {
 
   createJoinSection(mappedNestings) {
     if (!mappedNestings || mappedNestings.length === 0) return "";
-    return mappedNestings.map((_ref2) => {
+    return mappedNestings.map((_ref11) => {
       var {
         alias,
         reference,
         is_array
-      } = _ref2;
+      } = _ref11;
       var keyspace = (0, _fix.fixCollection)(reference);
 
       if (is_array === true) {
@@ -1152,103 +1296,129 @@ class SpiceModel {
     var _this12 = this;
 
     return _asyncToGenerator(function* () {
+      var _this12$_ctx;
+
       if (args === void 0) {
         args = {};
       }
 
-      try {
-        var _args6, _args7, _args8;
+      // Profiling: use track() for proper async context forking
+      var p = (_this12$_ctx = _this12[_ctx]) == null ? void 0 : _this12$_ctx.profiler;
 
-        if (args.mapping_dept) _this12[_mapping_dept] = args.mapping_dept; // Find alias tokens from query/columns/sort
+      var doList =
+      /*#__PURE__*/
+      function () {
+        var _ref12 = _asyncToGenerator(function* () {
+          var _args7, _args8, _args9;
 
-        var nestings = [..._this12.extractNestings(((_args6 = args) == null ? void 0 : _args6.query) || "", _this12.type), ..._this12.extractNestings(((_args7 = args) == null ? void 0 : _args7.columns) || "", _this12.type), ..._this12.extractNestings(((_args8 = args) == null ? void 0 : _args8.sort) || "", _this12.type)]; // Decide which aliases we can join: only when map.type===MODEL AND reference is a STRING keyspace.
+          if (args.mapping_dept) _this12[_mapping_dept] = args.mapping_dept; // Find alias tokens from query/columns/sort
 
-        var mappedNestings = _.compact(_.uniq(nestings).map(alias => {
-          var prop = _this12.props[alias];
-          if (!(prop == null ? void 0 : prop.map) || prop.map.type !== _2.MapType.MODEL) return null;
-          var ref = prop.map.reference;
+          var nestings = [..._this12.extractNestings(((_args7 = args) == null ? void 0 : _args7.query) || "", _this12.type), ..._this12.extractNestings(((_args8 = args) == null ? void 0 : _args8.columns) || "", _this12.type), ..._this12.extractNestings(((_args9 = args) == null ? void 0 : _args9.sort) || "", _this12.type)]; // Decide which aliases we can join: only when map.type===MODEL AND reference is a STRING keyspace.
 
-          if (typeof ref !== "string") {
-            // reference is a class/function/array-of-classes → no SQL join; serializer will handle it
-            return null;
-          }
+          var mappedNestings = _.compact(_.uniq(nestings).map(alias => {
+            var prop = _this12.props[alias];
+            if (!(prop == null ? void 0 : prop.map) || prop.map.type !== _2.MapType.MODEL) return null;
+            var ref = prop.map.reference;
 
-          var is_array = prop.type === "array" || prop.type === Array || prop.type === _2.DataType.ARRAY;
-          return {
-            alias,
-            reference: ref.toLowerCase(),
-            // keyspace to join
-            is_array,
-            type: prop.type,
-            value_field: prop.map.value_field,
-            destination: prop.map.destination || alias
-          };
-        }));
-
-        var protectedAliases = mappedNestings.map(m => m.alias);
-        var arrayAliases = mappedNestings.filter(m => m.is_array).map(m => m.alias); // Columns: first prepare (prefix base table, rewrite array alias.field → ARRAY proj),
-        // then normalize names and add default aliases
+            if (typeof ref !== "string") {
+              // reference is a class/function/array-of-classes → no SQL join; serializer will handle it
+              return null;
+            }
 
-        args.columns = _this12.prepColumns(args.columns, protectedAliases, arrayAliases);
-        args.columns = _this12.fixColumnName(args.columns, protectedAliases); // Build JOIN/NEST from the mapped keyspaces
+            var is_array = prop.type === "array" || prop.type === Array || prop.type === _2.DataType.ARRAY;
+            return {
+              alias,
+              reference: ref.toLowerCase(),
+              // keyspace to join
+              is_array,
+              type: prop.type,
+              value_field: prop.map.value_field,
+              destination: prop.map.destination || alias
+            };
+          }));
+
+          var protectedAliases = mappedNestings.map(m => m.alias);
+          var arrayAliases = mappedNestings.filter(m => m.is_array).map(m => m.alias); // Columns: first prepare (prefix base table, rewrite array alias.field → ARRAY proj),
+          // then normalize names and add default aliases
+
+          args.columns = _this12.prepColumns(args.columns, protectedAliases, arrayAliases);
+          args.columns = _this12.fixColumnName(args.columns, protectedAliases); // Build JOIN/NEST from the mapped keyspaces
+
+          args._join = _this12.createJoinSection(mappedNestings); // WHERE
+
+          var query = "";
+          var deletedCondition = "(`" + _this12.type + "`.deleted = false OR `" + _this12.type + "`.deleted IS MISSING)";
+
+          if (args.is_full_text === "true" || args.is_custom_query === "true") {
+            query = args.query || "";
+          } else if (args.filters) {
+            query = _this12.makeQueryFromFilter(args.filters);
+          } else if (args.query) {
+            query = args.query + " AND " + deletedCondition;
+          } else {
+            query = deletedCondition;
+          }
 
-        args._join = _this12.createJoinSection(mappedNestings); // WHERE
+          if ((0, _Security.hasSQLInjection)(query)) return []; // LIMIT/OFFSET/SORT
 
-        var query = "";
-        var deletedCondition = "(`" + _this12.type + "`.deleted = false OR `" + _this12.type + "`.deleted IS MISSING)";
+          args.limit = Number(args.limit) || undefined;
+          args.offset = Number(args.offset) || 0;
+          args.sort = args.sort ? args.sort.split(",").map(item => item.includes(".") ? item : "`" + _this12.type + "`." + _this12.formatSortComponent(item)).join(",") : "`" + _this12.type + "`.created_at DESC";
 
-        if (args.is_full_text === "true" || args.is_custom_query === "true") {
-          query = args.query || "";
-        } else if (args.filters) {
-          query = _this12.makeQueryFromFilter(args.filters);
-        } else if (args.query) {
-          query = args.query + " AND " + deletedCondition;
-        } else {
-          query = deletedCondition;
-        }
+          if (args.skip_hooks !== true) {
+            yield _this12.run_hook(_this12, "list", "before");
+          }
 
-        if ((0, _Security.hasSQLInjection)(query)) return []; // LIMIT/OFFSET/SORT
+          var cacheKey = "list::" + _this12.type + "::" + args._join + "::" + query + "::" + args.limit + "::" + args.offset + "::" + args.sort + "::" + args.do_count + "::" + args.statement_consistent + "::" + args.columns + "::" + args.is_full_text + "::" + args.is_custom_query;
+          var results;
 
-        args.limit = Number(args.limit) || undefined;
-        args.offset = Number(args.offset) || 0;
-        args.sort = args.sort ? args.sort.split(",").map(item => item.includes(".") ? item : "`" + _this12.type + "`." + _this12.formatSortComponent(item)).join(",") : "`" + _this12.type + "`.created_at DESC";
+          if (_this12.shouldUseCache(_this12.type)) {
+            var cached = yield _this12.getCacheProviderObject(_this12.type).get(cacheKey);
+            results = cached == null ? void 0 : cached.value;
+            var isEmpty = (cached == null ? void 0 : cached.value) === undefined;
+            var refresh = yield _this12.shouldForceRefresh(cached);
 
-        if (args.skip_hooks !== true) {
-          yield _this12.run_hook(_this12, "list", "before");
-        }
+            if (isEmpty || refresh) {
+              results = yield _this12.fetchResults(args, query);
 
-        var cacheKey = "list::" + _this12.type + "::" + args._join + "::" + query + "::" + args.limit + "::" + args.offset + "::" + args.sort + "::" + args.do_count + "::" + args.statement_consistent + "::" + args.columns + "::" + args.is_full_text + "::" + args.is_custom_query;
-        var results;
+              _this12.getCacheProviderObject(_this12.type).set(cacheKey, {
+                value: results,
+                time: new Date().getTime()
+              }, _this12.getCacheConfig(_this12.type));
+            }
+          } else {
+            results = yield _this12.fetchResults(args, query);
+          } // Serializer still handles class-based refs and value_field
 
-        if (_this12.shouldUseCache(_this12.type)) {
-          var cached = yield _this12.getCacheProviderObject(_this12.type).get(cacheKey);
-          results = cached == null ? void 0 : cached.value;
-          var isEmpty = (cached == null ? void 0 : cached.value) === undefined;
-          var refresh = yield _this12.shouldForceRefresh(cached);
 
-          if (isEmpty || refresh) {
-            results = yield _this12.fetchResults(args, query);
+          if (args.skip_read_serialize !== true && args.skip_serialize !== true) {
+            results.data = yield _this12.do_serialize(results.data, "read", {}, args, (yield _this12.propsToBeRemoved(results.data)));
+          }
 
-            _this12.getCacheProviderObject(_this12.type).set(cacheKey, {
-              value: results,
-              time: new Date().getTime()
-            }, _this12.getCacheConfig(_this12.type));
+          if (args.skip_hooks !== true) {
+            yield _this12.run_hook(results.data, "list", "after");
           }
-        } else {
-          results = yield _this12.fetchResults(args, query);
-        } // Serializer still handles class-based refs and value_field
 
+          results.data = _this12.filterResultsByColumns(results.data, args.columns);
+          return results;
+        });
 
-        if (args.skip_read_serialize !== true && args.skip_serialize !== true) {
-          results.data = yield _this12.do_serialize(results.data, "read", {}, args, (yield _this12.propsToBeRemoved(results.data)));
-        }
+        return function doList() {
+          return _ref12.apply(this, arguments);
+        };
+      }();
 
-        if (args.skip_hooks !== true) {
-          yield _this12.run_hook(results.data, "list", "after");
+      try {
+        if (p) {
+          var _args10, _args11;
+
+          return yield p.track(_this12.type + ".list", doList, {
+            limit: (_args10 = args) == null ? void 0 : _args10.limit,
+            offset: (_args11 = args) == null ? void 0 : _args11.offset
+          });
         }
 
-        results.data = _this12.filterResultsByColumns(results.data, args.columns);
-        return results;
+        return yield doList();
       } catch (e) {
         console.log(e.stack);
         throw e;
@@ -1260,23 +1430,44 @@ class SpiceModel {
     var _this13 = this;
 
     return _asyncToGenerator(function* () {
-      if (args.is_custom_query === "true" && args.ids.length > 0) {
-        return yield _this13.database.query(query);
-      } else if (args.is_full_text === "true") {
-        return yield _this13.database.full_text_search(_this13.type, query || "", args.limit, args.offset, args._join);
-      } else {
-        var result = yield _this13.database.search(_this13.type, args.columns || "", query || "", args.limit, args.offset, args.sort, args.do_count, args.statement_consistent, args._join);
-        return result;
+      var _this13$_ctx;
+
+      // Profiling: use track() for proper async context forking
+      var p = (_this13$_ctx = _this13[_ctx]) == null ? void 0 : _this13$_ctx.profiler;
+
+      var doFetch =
+      /*#__PURE__*/
+      function () {
+        var _ref13 = _asyncToGenerator(function* () {
+          if (args.is_custom_query === "true" && args.ids.length > 0) {
+            return yield _this13.database.query(query);
+          } else if (args.is_full_text === "true") {
+            return yield _this13.database.full_text_search(_this13.type, query || "", args.limit, args.offset, args._join);
+          } else {
+            var result = yield _this13.database.search(_this13.type, args.columns || "", query || "", args.limit, args.offset, args.sort, args.do_count, args.statement_consistent, args._join);
+            return result;
+          }
+        });
+
+        return function doFetch() {
+          return _ref13.apply(this, arguments);
+        };
+      }();
+
+      if (p) {
+        return yield p.track(_this13.type + ".fetchResults", doFetch);
       }
+
+      return yield doFetch();
     })();
   }
 
-  addHook(_ref3) {
+  addHook(_ref14) {
     var {
       operation,
       when,
       execute
-    } = _ref3;
+    } = _ref14;
 
     this[_hooks][operation][when].push(execute);
   }
@@ -1501,11 +1692,11 @@ class SpiceModel {
     })();
   }
 
-  addModifier(_ref4) {
+  addModifier(_ref15) {
     var {
       when,
       execute
-    } = _ref4;
+    } = _ref15;
 
     if (this[_serializers][when]) {
       this[_serializers][when]["modifiers"].push(execute);
@@ -1601,84 +1792,107 @@ class SpiceModel {
     var _this18 = this;
 
     return _asyncToGenerator(function* () {
+      var _this18$_ctx;
+
       if (path_to_be_removed === void 0) {
         path_to_be_removed = [];
       }
 
-      try {
-        var _this18$_serializers, _this18$_serializers$;
+      // Profiling: use track() for proper async context forking
+      var p = (_this18$_ctx = _this18[_ctx]) == null ? void 0 : _this18$_ctx.profiler;
 
-        // Early exit if serialization should not run.
-        if (!_this18.shouldSerializerRun(args, type)) {
-          return data;
-        } // Add external modifiers only once.
+      var doSerialize =
+      /*#__PURE__*/
+      function () {
+        var _ref16 = _asyncToGenerator(function* () {
+          var _this18$_serializers, _this18$_serializers$;
 
+          // Early exit if serialization should not run.
+          if (!_this18.shouldSerializerRun(args, type)) {
+            return data;
+          } // Add external modifiers only once.
 
-        if (_this18.type && !_this18[_external_modifier_loaded]) {
-          _this18.addExternalModifiers(_this18.type);
 
-          _this18[_external_modifier_loaded] = true;
-        } // Cache the modifiers lookup for the specified type.
+          if (_this18.type && !_this18[_external_modifier_loaded]) {
+            _this18.addExternalModifiers(_this18.type);
 
+            _this18[_external_modifier_loaded] = true;
+          } // Cache the modifiers lookup for the specified type.
 
-        var modifiers = ((_this18$_serializers = _this18[_serializers]) == null ? void 0 : (_this18$_serializers$ = _this18$_serializers[type]) == null ? void 0 : _this18$_serializers$.modifiers) || [];
 
-        for (var modifier of modifiers) {
-          try {
-            data = yield modifier(data, old_data, _this18[_ctx], _this18.type);
-          } catch (error) {
-            console.error("Modifier error in do_serialize:", error.stack);
-          }
-        } // Ensure data is always an array for consistent processing.
+          var modifiers = ((_this18$_serializers = _this18[_serializers]) == null ? void 0 : (_this18$_serializers$ = _this18$_serializers[type]) == null ? void 0 : _this18$_serializers$.modifiers) || [];
 
+          for (var modifier of modifiers) {
+            try {
+              data = yield modifier(data, old_data, _this18[_ctx], _this18.type);
+            } catch (error) {
+              console.error("Modifier error in do_serialize:", error.stack);
+            }
+          } // Ensure data is always an array for consistent processing.
 
-        var originalIsArray = Array.isArray(data);
 
-        if (!originalIsArray) {
-          data = [data];
-        } // ⚡ OPTIMIZED: Use cached defaults metadata instead of computing every time
+          var originalIsArray = Array.isArray(data);
 
+          if (!originalIsArray) {
+            data = [data];
+          } // ⚡ OPTIMIZED: Use cached defaults metadata instead of computing every time
 
-        var {
-          staticDefaults,
-          dynamicDefaults,
-          hasDefaults
-        } = _this18.getDefaultsMetadata(type);
 
-        if (hasDefaults) {
-          data = data.map(item => {
-            // Apply static defaults first (fast - no function calls)
-            var result = _.defaults({}, item, staticDefaults); // Only compute dynamic defaults if there are any
+          var {
+            staticDefaults,
+            dynamicDefaults,
+            hasDefaults
+          } = _this18.getDefaultsMetadata(type);
 
+          if (hasDefaults) {
+            data = data.map(item => {
+              // Apply static defaults first (fast - no function calls)
+              var result = _.defaults({}, item, staticDefaults); // Only compute dynamic defaults if there are any
 
-            for (var {
-              key,
-              fn
-            } of dynamicDefaults) {
-              if (result[key] === undefined) {
-                result[key] = fn({
-                  old_data: data,
-                  new_data: old_data
-                });
+
+              for (var {
+                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.
+              return result;
+            });
+          } // If type is "read", clean the data by omitting certain props.
 
 
-        if (type === "read") {
-          // ⚡ OPTIMIZED: Use cached hidden props instead of computing every time
-          var hiddenProps = _this18.getHiddenProps(); // Combine default props to remove.
+          if (type === "read") {
+            // ⚡ OPTIMIZED: Use cached hidden props instead of computing every time
+            var hiddenProps = _this18.getHiddenProps(); // Combine default props to remove.
 
 
-          var propsToClean = ["deleted", "type", ...path_to_be_removed, ...hiddenProps];
-          data = data.map(item => _.omit(item, propsToClean));
-        } // Return in the original format (array or single object).
+            var propsToClean = ["deleted", "type", ...path_to_be_removed, ...hiddenProps];
+            data = data.map(item => _.omit(item, propsToClean));
+          } // Return in the original format (array or single object).
+
+
+          return originalIsArray ? data : data[0];
+        });
 
+        return function doSerialize() {
+          return _ref16.apply(this, arguments);
+        };
+      }();
+
+      try {
+        if (p) {
+          return yield p.track(_this18.type + ".do_serialize", doSerialize, {
+            type
+          });
+        }
 
-        return originalIsArray ? data : data[0];
+        return yield doSerialize();
       } catch (error) {
         console.error("Error in do_serialize:", error.stack);
         throw error;