spice-js 2.7.1 → 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/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.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/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,
+};