spice-js 2.7.1 → 2.7.3

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,
+};