spice-js 2.7.1 → 2.7.3

package/build/utility/ResourceReloader.js

@@ -0,0 +1,426 @@
+"use strict";
+
+exports.__esModule = true;
+exports.reloadSchema = reloadSchema;
+exports.reloadModel = reloadModel;
+exports.reloadController = reloadController;
+exports.reloadCache = reloadCache;
+exports.registerRoute = registerRoute;
+exports.reloadResource = reloadResource;
+exports.removeResourceFromMemory = removeResourceFromMemory;
+exports.default = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+/**
+ * ResourceReloader - Utility for dynamically reloading resources at runtime
+ * without requiring a full application restart.
+ *
+ * This enables zero-downtime updates for:
+ * - Schema updates
+ * - Resource creation
+ * - Resource deletion (removes from memory, routes orphaned until restart)
+ */
+
+/**
+ * Clear the Node.js require cache for a specific file path
+ * @param {string} filePath - The full path to the file
+ */
+function clearRequireCache(filePath) {
+  // Resolve the file path to handle different require formats
+  var resolvedPath = require.resolve(filePath);
+
+  if (require.cache[resolvedPath]) {
+    delete require.cache[resolvedPath];
+    return true;
+  }
+
+  return false;
+}
+/**
+ * Reload a schema into memory
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status and message
+ */
+
+
+function reloadSchema(_x) {
+  return _reloadSchema.apply(this, arguments);
+}
+/**
+ * Reload a model into memory
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status and message
+ */
+
+
+function _reloadSchema() {
+  _reloadSchema = _asyncToGenerator(function* (resourceName) {
+    try {
+      var schemaPath = _path.default.join(spice.root_path, "schemas", resourceName + ".js");
+
+      if (!_fs.default.existsSync(schemaPath)) {
+        return {
+          success: false,
+          error: "Schema file not found: " + schemaPath
+        };
+      }
+
+      clearRequireCache(schemaPath);
+
+      var imported = require(schemaPath);
+
+      var schema = imported.default || imported; // Store with both original and lowercase keys
+
+      spice.schemas[resourceName] = schema;
+      spice.schemas[resourceName.toLowerCase()] = schema;
+      return {
+        success: true,
+        message: "Schema " + resourceName + " reloaded"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: "Failed to reload schema: " + error.message
+      };
+    }
+  });
+  return _reloadSchema.apply(this, arguments);
+}
+
+function reloadModel(_x2) {
+  return _reloadModel.apply(this, arguments);
+}
+/**
+ * Reload a controller into memory
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status and message
+ */
+
+
+function _reloadModel() {
+  _reloadModel = _asyncToGenerator(function* (resourceName) {
+    try {
+      var modelPath = _path.default.join(spice.root_path, "models", resourceName + ".js");
+
+      if (!_fs.default.existsSync(modelPath)) {
+        return {
+          success: false,
+          error: "Model file not found: " + modelPath
+        };
+      }
+
+      clearRequireCache(modelPath);
+
+      var imported = require(modelPath);
+
+      var model = imported.default || imported; // Store with both original and lowercase keys
+
+      spice.models[resourceName] = model;
+      spice.models[resourceName.toLowerCase()] = model;
+      return {
+        success: true,
+        message: "Model " + resourceName + " reloaded"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: "Failed to reload model: " + error.message
+      };
+    }
+  });
+  return _reloadModel.apply(this, arguments);
+}
+
+function reloadController(_x3) {
+  return _reloadController.apply(this, arguments);
+}
+/**
+ * Reload a cache into memory
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status and message
+ */
+
+
+function _reloadController() {
+  _reloadController = _asyncToGenerator(function* (resourceName) {
+    try {
+      var controllerPath = _path.default.join(spice.root_path, "controllers", resourceName + ".js");
+
+      if (!_fs.default.existsSync(controllerPath)) {
+        return {
+          success: false,
+          error: "Controller file not found: " + controllerPath
+        };
+      }
+
+      clearRequireCache(controllerPath);
+
+      var imported = require(controllerPath);
+
+      var controller = imported.default || imported; // Store with both original and lowercase keys
+
+      spice.controllers[resourceName] = controller;
+      spice.controllers[resourceName.toLowerCase()] = controller;
+      return {
+        success: true,
+        message: "Controller " + resourceName + " reloaded"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: "Failed to reload controller: " + error.message
+      };
+    }
+  });
+  return _reloadController.apply(this, arguments);
+}
+
+function reloadCache(_x4) {
+  return _reloadCache.apply(this, arguments);
+}
+/**
+ * Register a new route with the Koa app
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status and message
+ */
+
+
+function _reloadCache() {
+  _reloadCache = _asyncToGenerator(function* (resourceName) {
+    try {
+      var cachePath = _path.default.join(spice.root_path, "cache", resourceName + ".js");
+
+      if (!_fs.default.existsSync(cachePath)) {
+        return {
+          success: false,
+          error: "Cache file not found: " + cachePath
+        };
+      }
+
+      clearRequireCache(cachePath);
+
+      var imported = require(cachePath);
+
+      var cache = imported.default || imported; // Store with both original and lowercase keys
+
+      spice.cache[resourceName] = cache;
+      spice.cache[resourceName.toLowerCase()] = cache;
+      return {
+        success: true,
+        message: "Cache " + resourceName + " reloaded"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: "Failed to reload cache: " + error.message
+      };
+    }
+  });
+  return _reloadCache.apply(this, arguments);
+}
+
+function registerRoute(_x5) {
+  return _registerRoute.apply(this, arguments);
+}
+/**
+ * Reload all components of a resource (schema, model, controller, cache, route)
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status, messages, and any errors
+ */
+
+
+function _registerRoute() {
+  _registerRoute = _asyncToGenerator(function* (resourceName) {
+    try {
+      var routePath = _path.default.join(spice.root_path, "routes", resourceName + ".js");
+
+      if (!_fs.default.existsSync(routePath)) {
+        return {
+          success: false,
+          error: "Route file not found: " + routePath
+        };
+      }
+
+      clearRequireCache(routePath);
+
+      var router = require(routePath); // Handle ESM default exports
+
+
+      if (router.default) {
+        router = router.default;
+      } // Store the router
+
+
+      spice.routers[resourceName] = router;
+      spice.routers[resourceName.toLowerCase()] = router; // Register with Koa app
+
+      spice.app.use(router.routes()).use(router.allowedMethods());
+      return {
+        success: true,
+        message: "Route " + resourceName + " registered"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: "Failed to register route: " + error.message
+      };
+    }
+  });
+  return _registerRoute.apply(this, arguments);
+}
+
+function reloadResource(_x6) {
+  return _reloadResource.apply(this, arguments);
+}
+/**
+ * Remove a resource from memory
+ * This removes the resource from spice.models, spice.controllers, spice.schemas, spice.cache
+ * Note: Routes cannot be unregistered from Koa, they will remain orphaned until restart
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status and message
+ */
+
+
+function _reloadResource() {
+  _reloadResource = _asyncToGenerator(function* (resourceName) {
+    var results = {
+      success: true,
+      messages: [],
+      errors: []
+    }; // Reload in order: schema first (dependencies might rely on it)
+
+    var operations = [{
+      name: "schema",
+      fn: reloadSchema
+    }, {
+      name: "model",
+      fn: reloadModel
+    }, {
+      name: "controller",
+      fn: reloadController
+    }, {
+      name: "cache",
+      fn: reloadCache
+    }, {
+      name: "route",
+      fn: registerRoute
+    }];
+
+    for (var op of operations) {
+      var result = yield op.fn(resourceName);
+
+      if (result.success) {
+        results.messages.push(result.message);
+      } else {
+        results.errors.push(op.name + ": " + result.error); // Continue anyway - some resources might not have all components
+      }
+    } // Consider success if at least some components loaded
+
+
+    results.success = results.messages.length > 0;
+    return results;
+  });
+  return _reloadResource.apply(this, arguments);
+}
+
+function removeResourceFromMemory(resourceName) {
+  var removed = []; // Remove from schemas
+
+  if (spice.schemas) {
+    if (spice.schemas[resourceName]) {
+      delete spice.schemas[resourceName];
+      removed.push("schema");
+    }
+
+    if (spice.schemas[resourceName.toLowerCase()]) {
+      delete spice.schemas[resourceName.toLowerCase()];
+    }
+  } // Remove from models
+
+
+  if (spice.models) {
+    if (spice.models[resourceName]) {
+      delete spice.models[resourceName];
+      removed.push("model");
+    }
+
+    if (spice.models[resourceName.toLowerCase()]) {
+      delete spice.models[resourceName.toLowerCase()];
+    }
+  } // Remove from controllers
+
+
+  if (spice.controllers) {
+    if (spice.controllers[resourceName]) {
+      delete spice.controllers[resourceName];
+      removed.push("controller");
+    }
+
+    if (spice.controllers[resourceName.toLowerCase()]) {
+      delete spice.controllers[resourceName.toLowerCase()];
+    }
+  } // Remove from cache
+
+
+  if (spice.cache) {
+    if (spice.cache[resourceName]) {
+      delete spice.cache[resourceName];
+      removed.push("cache");
+    }
+
+    if (spice.cache[resourceName.toLowerCase()]) {
+      delete spice.cache[resourceName.toLowerCase()];
+    }
+  } // Remove from routers (the route middleware remains in Koa but won't have backing)
+
+
+  if (spice.routers) {
+    if (spice.routers[resourceName]) {
+      delete spice.routers[resourceName];
+      removed.push("router");
+    }
+
+    if (spice.routers[resourceName.toLowerCase()]) {
+      delete spice.routers[resourceName.toLowerCase()];
+    }
+  } // Also clear from Node.js require cache to prevent stale imports
+
+
+  var resourceTypes = ["schemas", "models", "controllers", "cache", "routes"];
+
+  for (var type of resourceTypes) {
+    var filePath = _path.default.join(spice.root_path, type, resourceName + ".js");
+
+    try {
+      clearRequireCache(filePath);
+    } catch (e) {// File might not exist, that's ok
+    }
+  }
+
+  return {
+    success: true,
+    message: "Resource " + resourceName + " removed from memory",
+    removed,
+    note: "Routes remain in Koa middleware stack but will fail without backing controller/model. Full cleanup on restart."
+  };
+}
+
+var _default = {
+  reloadSchema,
+  reloadModel,
+  reloadController,
+  reloadCache,
+  registerRoute,
+  reloadResource,
+  removeResourceFromMemory
+};
+exports.default = _default;

package/package.json

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

package/src/index.js

@@ -24,6 +24,8 @@ export { default as Crypt } from "./utility/Crypt";
 export { default as Serializer } from "./utility/Serializer";
 
 export { default as RestHelper } from "./utility/RestHelper";
+
+export { default as ResourceReloader } from "./utility/ResourceReloader";
 import Status from "./utility/Status";
 export { default as Mail } from "./mail/Mail";
 export { default as DataType } from "./utility/DataType";
@@ -80,9 +82,9 @@ export default class Spice {
 
       spice.addModifier = function (resource, modifier) {
         spice.mofifiers[resource.toLowerCase()] =
-          spice.mofifiers[resource] == undefined
-            ? [modifier]
-            : [...spice.mofifiers[resource], modifier];
+          spice.mofifiers[resource] == undefined ?
+            [modifier]
+          : [...spice.mofifiers[resource], modifier];
       };
 
       spice.getModifiers = function (resource) {
@@ -96,14 +98,14 @@ export default class Spice {
       /* app._io.on("connection", (sock) => {
         console.log("Connection Up", sock);
       }); */
-      
+
       // ⚡ OPTIMIZED: Load routes and models first, then generate docs lazily
       await require("./loaders").load();
-      
+
       // ⚡ LAZY DOCS: Generate docs in background after startup to not block server
       let docsCache = null;
       let docsGenerating = false;
-      
+
       // Generate docs asynchronously after startup
       const generateDocsInBackground = async () => {
         if (docsCache || docsGenerating) return;
@@ -114,26 +116,26 @@ export default class Spice {
           console.log("API documentation generated successfully");
         } catch (error) {
           console.error("Error generating docs:", error);
-          docsCache = { 
-            swagger: "2.0", 
-            info: { title: "API Docs", version: "1.0.0" }, 
-            paths: {}, 
-            definitions: {} 
+          docsCache = {
+            swagger: "2.0",
+            info: { title: "API Docs", version: "1.0.0" },
+            paths: {},
+            definitions: {},
           };
         } finally {
           docsGenerating = false;
         }
       };
-      
+
       // Start generating docs in background (non-blocking)
       setTimeout(generateDocsInBackground, 100);
-      
+
       // Middleware to serve docs - will wait if still generating
       app.use(async (ctx, next) => {
         if (ctx.path === "/docs/spec" || ctx.path === "/docs/spec.json") {
           // Wait for docs to be generated if not ready
           while (docsGenerating && !docsCache) {
-            await new Promise(resolve => setTimeout(resolve, 100));
+            await new Promise((resolve) => setTimeout(resolve, 100));
           }
           if (!docsCache) {
             await generateDocsInBackground();
@@ -143,7 +145,7 @@ export default class Spice {
         }
         await next();
       });
-      
+
       app.use(
         koaSwagger({
           hideTopbar: true,

package/src/models/SpiceModel.js

@@ -606,7 +606,10 @@ export default class SpiceModel {
   }
 
   async getMulti(args) {
-    try {
+    // ⚡ Profiling: use track() for proper async context forking
+    const p = this[_ctx]?.profiler;
+
+    const doGetMulti = async () => {
       if (!args) {
         args = {};
       }
@@ -653,6 +656,15 @@ export default class SpiceModel {
       }
 
       return results;
+    };
+
+    try {
+      if (p) {
+        return await p.track(`${this.type}.getMulti`, doGetMulti, {
+          ids_count: args?.ids?.length || 0,
+        });
+      }
+      return await doGetMulti();
     } catch (e) {
       console.warn(e.stack);
       throw e;
@@ -1445,6 +1457,9 @@ export default class SpiceModel {
   }
 
   async mapToObject(data, Class, source_property, store_property, property) {
+    // ⚡ Get profiler for proper async context forking
+    const p = this[_ctx]?.profiler;
+
     let original_is_array = _.isArray(data);
     if (!original_is_array) {
       data = Array.of(data);
@@ -1469,21 +1484,36 @@ export default class SpiceModel {
           `${this[_current_path]}.${source_property}`
         : source_property;
 
-      var returned_all = await Promise.allSettled(
-        _.map(classes, (obj) => {
-          return new obj({
-            ...this[_args],
-            skip_cache: this[_skip_cache],
-            _level: this[_level] + 1,
-            mapping_dept: this[_mapping_dept],
-            mapping_dept_exempt: this[_mapping_dept_exempt],
-            _current_path: childPath,
-          }).getMulti({
-            skip_hooks: true,
-            ids: ids,
-          });
-        })
-      );
+      // ⚡ Wrap in profiler track() to ensure proper async context for child operations
+      const fetchRelated = async () => {
+        return await Promise.allSettled(
+          _.map(classes, (obj) => {
+            return new obj({
+              ...this[_args],
+              skip_cache: this[_skip_cache],
+              _level: this[_level] + 1,
+              mapping_dept: this[_mapping_dept],
+              mapping_dept_exempt: this[_mapping_dept_exempt],
+              _current_path: childPath,
+            }).getMulti({
+              skip_hooks: true,
+              ids: ids,
+            });
+          })
+        );
+      };
+
+      var returned_all;
+      if (p && ids.length > 0) {
+        returned_all = await p.track(
+          `${this.type}.map.${source_property}`,
+          fetchRelated,
+          { ids_count: ids.length }
+        );
+      } else {
+        returned_all = await fetchRelated();
+      }
+
       let ug = _.flatten(
         _.compact(
           _.map(returned_all, (returned_obj) => {
@@ -1511,6 +1541,9 @@ export default class SpiceModel {
     store_property,
     property
   ) {
+    // ⚡ Get profiler for proper async context forking
+    const p = this[_ctx]?.profiler;
+
     let original_is_array = _.isArray(data);
     if (!original_is_array) {
       data = Array.of(data);
@@ -1540,21 +1573,36 @@ export default class SpiceModel {
         : source_property;
 
       let classes = _.compact(_.isArray(Class) ? Class : [Class]);
-      var returned_all = await Promise.allSettled(
-        _.map(classes, (obj) => {
-          return new obj({
-            ...this[_args],
-            skip_cache: this[_skip_cache],
-            _level: this[_level] + 1,
-            mapping_dept: this[_mapping_dept],
-            mapping_dept_exempt: this[_mapping_dept_exempt],
-            _current_path: childPath,
-          }).getMulti({
-            skip_hooks: true,
-            ids: ids,
-          });
-        })
-      );
+
+      // ⚡ Wrap in profiler track() to ensure proper async context for child operations
+      const fetchRelated = async () => {
+        return await Promise.allSettled(
+          _.map(classes, (obj) => {
+            return new obj({
+              ...this[_args],
+              skip_cache: this[_skip_cache],
+              _level: this[_level] + 1,
+              mapping_dept: this[_mapping_dept],
+              mapping_dept_exempt: this[_mapping_dept_exempt],
+              _current_path: childPath,
+            }).getMulti({
+              skip_hooks: true,
+              ids: ids,
+            });
+          })
+        );
+      };
+
+      var returned_all;
+      if (p && ids.length > 0) {
+        returned_all = await p.track(
+          `${this.type}.mapArray.${source_property}`,
+          fetchRelated,
+          { ids_count: ids.length }
+        );
+      } else {
+        returned_all = await fetchRelated();
+      }
 
       var returned_objects = _.flatten(
         _.compact(
@@ -1564,9 +1612,6 @@ export default class SpiceModel {
         )
       );
 
-      /* let returned_objects = await new Class().getMulti({
-      ids: ids,
-    }); */
       _.each(data, (result) => {
         if (_.isString(result[store_property])) {
           result[store_property] = [result[store_property]];