spice-js 2.7.0 → 2.7.2

package/build/index.js

@@ -1,7 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.default = exports.status = exports.addTask = exports.MapType = exports.SpiceCache = exports.MailFile = exports.AI = exports.Storage = exports.LocalStorage = exports.DebugStorage = exports.MailDebug = exports.DataType = exports.Mail = exports.RestHelper = exports.Serializer = exports.Crypt = exports.SpiceModel = exports.ResourceLifecycleTriggered = exports.SocketEventDriver = exports.SpiceEventDriver = exports.EventDebugger = exports.Event = void 0;
+exports.default = exports.status = exports.addTask = exports.MapType = exports.SpiceCache = exports.MailFile = exports.AI = exports.Storage = exports.LocalStorage = exports.DebugStorage = exports.MailDebug = exports.DataType = exports.Mail = exports.ResourceReloader = exports.RestHelper = exports.Serializer = exports.Crypt = exports.SpiceModel = exports.ResourceLifecycleTriggered = exports.SocketEventDriver = exports.SpiceEventDriver = exports.EventDebugger = exports.Event = void 0;
 
 var _Event = _interopRequireDefault(require("./events/Event"));
 
@@ -39,6 +39,10 @@ var _RestHelper = _interopRequireDefault(require("./utility/RestHelper"));
 
 exports.RestHelper = _RestHelper.default;
 
+var _ResourceReloader = _interopRequireDefault(require("./utility/ResourceReloader"));
+
+exports.ResourceReloader = _ResourceReloader.default;
+
 var _Status = _interopRequireDefault(require("./utility/Status"));
 
 var _Mail = _interopRequireDefault(require("./mail/Mail"));

package/build/models/SpiceModel.js

@@ -1924,52 +1924,24 @@ class SpiceModel {
           var requestedColumns = _this18.parseRequestedColumns(args == null ? void 0 : args.columns); // 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) || []; // ⚡ OPTIMIZED: Separate field-specific modifiers (can run in parallel) from generic ones (serial)
-
-          var fieldModifiers = [];
-          var genericModifiers = [];
+          var modifiers = ((_this18$_serializers = _this18[_serializers]) == null ? void 0 : (_this18$_serializers$ = _this18$_serializers[type]) == null ? void 0 : _this18$_serializers$.modifiers) || []; // Run modifiers serially
 
           for (var modifier of modifiers) {
-            // Skip field-specific modifiers if columns specified and neither source nor destination field is requested
+            // Skip field-specific modifiers if columns specified and field is not requested
             if (requestedColumns && modifier.field && !requestedColumns.has(modifier.field) && !(modifier.sourceField && requestedColumns.has(modifier.sourceField))) {
               continue;
-            } // Field modifiers have a .field property and .execute function - they can run in parallel
-
-
-            if (modifier.field && typeof modifier.execute === "function") {
-              fieldModifiers.push(modifier);
-            } else {
-              genericModifiers.push(modifier);
             }
-          } // Run generic modifiers serially first (they may transform the data structure)
 
-
-          for (var _modifier of genericModifiers) {
             try {
-              var executeFn = typeof _modifier === "function" ? _modifier : _modifier.execute;
+              // Handle both function modifiers and object modifiers with .execute
+              var executeFn = typeof modifier === "function" ? modifier : modifier.execute;
               var result = yield executeFn(data, old_data, _this18[_ctx], _this18.type); // Only assign if modifier returned a value to prevent data corruption
 
               if (result !== undefined) {
                 data = result;
               }
             } catch (error) {
-              console.error("Modifier error in do_serialize (generic):", error.stack);
-            }
-          } // Run field-specific modifiers SERIALLY to allow proper deduplication
-          // of nested relation lookups (parallel execution causes duplicate fetches
-          // when related entities have circular references like user fields)
-
-
-          for (var _modifier2 of fieldModifiers) {
-            try {
-              var _result = yield _modifier2.execute(data, old_data, _this18[_ctx], _this18.type); // Only assign if modifier returned a value to prevent data corruption
-
-
-              if (_result !== undefined) {
-                data = _result;
-              }
-            } catch (error) {
-              console.error("Modifier error for field " + _modifier2.field + ":", error.stack);
+              console.error("Modifier error in do_serialize:", error.stack);
             }
           } // Ensure data is always an array for consistent processing.
 

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.0",
+  "version": "2.7.2",
   "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

@@ -1727,12 +1727,9 @@ export default class SpiceModel {
       // Cache the modifiers lookup for the specified type.
       const modifiers = this[_serializers]?.[type]?.modifiers || [];
 
-      // ⚡ OPTIMIZED: Separate field-specific modifiers (can run in parallel) from generic ones (serial)
-      const fieldModifiers = [];
-      const genericModifiers = [];
-
+      // Run modifiers serially
       for (const modifier of modifiers) {
-        // Skip field-specific modifiers if columns specified and neither source nor destination field is requested
+        // Skip field-specific modifiers if columns specified and field is not requested
         if (
           requestedColumns &&
           modifier.field &&
@@ -1742,17 +1739,8 @@ export default class SpiceModel {
           continue;
         }
 
-        // Field modifiers have a .field property and .execute function - they can run in parallel
-        if (modifier.field && typeof modifier.execute === "function") {
-          fieldModifiers.push(modifier);
-        } else {
-          genericModifiers.push(modifier);
-        }
-      }
-
-      // Run generic modifiers serially first (they may transform the data structure)
-      for (const modifier of genericModifiers) {
         try {
+          // Handle both function modifiers and object modifiers with .execute
           const executeFn =
             typeof modifier === "function" ? modifier : modifier.execute;
           const result = await executeFn(data, old_data, this[_ctx], this.type);
@@ -1761,33 +1749,7 @@ export default class SpiceModel {
             data = result;
           }
         } catch (error) {
-          console.error(
-            "Modifier error in do_serialize (generic):",
-            error.stack
-          );
-        }
-      }
-
-      // Run field-specific modifiers SERIALLY to allow proper deduplication
-      // of nested relation lookups (parallel execution causes duplicate fetches
-      // when related entities have circular references like user fields)
-      for (const modifier of fieldModifiers) {
-        try {
-          const result = await modifier.execute(
-            data,
-            old_data,
-            this[_ctx],
-            this.type
-          );
-          // Only assign if modifier returned a value to prevent data corruption
-          if (result !== undefined) {
-            data = result;
-          }
-        } catch (error) {
-          console.error(
-            `Modifier error for field ${modifier.field}:`,
-            error.stack
-          );
+          console.error("Modifier error in do_serialize:", error.stack);
         }
       }
 

package/src/utility/ResourceReloader.js

@@ -0,0 +1,333 @@
+import path from "path";
+import fs from "fs";
+
+/**
+ * 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
+  const 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
+ */
+export async function reloadSchema(resourceName) {
+  try {
+    const schemaPath = path.join(
+      spice.root_path,
+      "schemas",
+      `${resourceName}.js`
+    );
+
+    if (!fs.existsSync(schemaPath)) {
+      return { success: false, error: `Schema file not found: ${schemaPath}` };
+    }
+
+    clearRequireCache(schemaPath);
+    const imported = require(schemaPath);
+    const 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}`,
+    };
+  }
+}
+
+/**
+ * Reload a model into memory
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status and message
+ */
+export async function reloadModel(resourceName) {
+  try {
+    const modelPath = path.join(
+      spice.root_path,
+      "models",
+      `${resourceName}.js`
+    );
+
+    if (!fs.existsSync(modelPath)) {
+      return { success: false, error: `Model file not found: ${modelPath}` };
+    }
+
+    clearRequireCache(modelPath);
+    const imported = require(modelPath);
+    const 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}`,
+    };
+  }
+}
+
+/**
+ * Reload a controller into memory
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status and message
+ */
+export async function reloadController(resourceName) {
+  try {
+    const controllerPath = path.join(
+      spice.root_path,
+      "controllers",
+      `${resourceName}.js`
+    );
+
+    if (!fs.existsSync(controllerPath)) {
+      return {
+        success: false,
+        error: `Controller file not found: ${controllerPath}`,
+      };
+    }
+
+    clearRequireCache(controllerPath);
+    const imported = require(controllerPath);
+    const 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}`,
+    };
+  }
+}
+
+/**
+ * Reload a cache into memory
+ * @param {string} resourceName - The resource name (e.g., "User", "Product")
+ * @returns {object} Result with success status and message
+ */
+export async function reloadCache(resourceName) {
+  try {
+    const cachePath = path.join(spice.root_path, "cache", `${resourceName}.js`);
+
+    if (!fs.existsSync(cachePath)) {
+      return { success: false, error: `Cache file not found: ${cachePath}` };
+    }
+
+    clearRequireCache(cachePath);
+    const imported = require(cachePath);
+    const 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}`,
+    };
+  }
+}
+
+/**
+ * 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
+ */
+export async function registerRoute(resourceName) {
+  try {
+    const routePath = path.join(
+      spice.root_path,
+      "routes",
+      `${resourceName}.js`
+    );
+
+    if (!fs.existsSync(routePath)) {
+      return { success: false, error: `Route file not found: ${routePath}` };
+    }
+
+    clearRequireCache(routePath);
+    let 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}`,
+    };
+  }
+}
+
+/**
+ * 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
+ */
+export async function reloadResource(resourceName) {
+  const results = {
+    success: true,
+    messages: [],
+    errors: [],
+  };
+
+  // Reload in order: schema first (dependencies might rely on it)
+  const operations = [
+    { name: "schema", fn: reloadSchema },
+    { name: "model", fn: reloadModel },
+    { name: "controller", fn: reloadController },
+    { name: "cache", fn: reloadCache },
+    { name: "route", fn: registerRoute },
+  ];
+
+  for (const op of operations) {
+    const result = await 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;
+}
+
+/**
+ * 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
+ */
+export function removeResourceFromMemory(resourceName) {
+  const 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
+  const resourceTypes = ["schemas", "models", "controllers", "cache", "routes"];
+  for (const type of resourceTypes) {
+    const filePath = path.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.",
+  };
+}
+
+export default {
+  reloadSchema,
+  reloadModel,
+  reloadController,
+  reloadCache,
+  registerRoute,
+  reloadResource,
+  removeResourceFromMemory,
+};