spice-js 2.6.70 → 2.6.72

package/package.json

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

package/src/bootstrap/map.js

@@ -1,23 +1,28 @@
 import path from "path";
 import _ from "lodash";
+
 try {
   let resources = ["models", "controllers", "schemas", "cache"];
-  _.each(resources, async function (resource) {
+
+  for (const resource of resources) {
     let paths = path.join(spice.root_path, resource);
     spice[resource] = {};
-    for (let file of require("fs").readdirSync(paths)) {
+
+    const files = require("fs").readdirSync(paths);
+
+    for (let file of files) {
       let file_name = file.split(".")[0];
-      spice[resource][file_name.toLowerCase()] = (
-        await import(path.join(paths, file))
-      ).default;
-      spice[resource][file_name] = (
-        await import(path.join(paths, file))
-      ).default;
-      if (resource == "models") {
-        new spice[resource][file_name]({});
-      }
+      const imported = require(path.join(paths, file));
+      const moduleDefault = imported.default || imported;
+
+      // ⚡ Only store once, create both references to same object
+      spice[resource][file_name] = moduleDefault;
+      spice[resource][file_name.toLowerCase()] = moduleDefault;
+
+      // ⚡ REMOVED: No longer instantiating models at startup
+      // Models will be instantiated when needed via `new spice.models[name]({})`
     }
-  });
+  }
 } catch (error) {
   console.log("Error Happened", error);
 }

package/src/bootstrap/routes.js

@@ -1,16 +1,42 @@
 import path from 'path';
+import fs from 'fs';
+import { promisify } from 'util';
 
+const readdir = promisify(fs.readdir);
 
-spice.routers = {}
+spice.routers = {};
 
-let paths = path.join(spice.root_path, 'routes');
-require('fs').readdirSync(paths).forEach(function (file) {
-  if (file != 'index.js') {
-    let router = require(path.join(paths, file));
-    spice.routers[file.split('.')[0]] = router;
+// ⚡ OPTIMIZED: Async file operations for non-blocking route loading
+async function loadRoutes() {
+  let paths = path.join(spice.root_path, 'routes');
+  
+  try {
+    const files = await readdir(paths);
+    
+    for (const file of files) {
+      if (file !== 'index.js' && file.endsWith('.js')) {
+        try {
+          let router = require(path.join(paths, file));
+          
+          // Handle ESM default exports
+          if (router.default) {
+            router = router.default;
+          }
+          
+          const routerName = file.split('.')[0];
+          spice.routers[routerName] = router;
 
-    spice.app
-      .use(spice.routers[file.split('.')[0]].routes())
-      .use(spice.routers[file.split('.')[0]].allowedMethods());
+          spice.app
+            .use(spice.routers[routerName].routes())
+            .use(spice.routers[routerName].allowedMethods());
+        } catch (routeError) {
+          console.error(`Failed to load route ${file}:`, routeError.message);
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Error loading routes:', error);
   }
-});
+}
+
+module.exports = loadRoutes;

package/src/bootstrap/schema_extenders.js

@@ -1,16 +1,39 @@
 import path from "path";
 import fs from "fs";
-let paths = path.join(spice.root_path, "schema_extenders");
+import { promisify } from "util";
+
+const readdir = promisify(fs.readdir);
+
 spice.schema_extenders = {};
-if (fs.existsSync(paths)) {
-  fs.readdirSync(paths).forEach(function (file) {
-    if (path.extname(file) === ".js" && file !== "index.js") {
-      try {
-        let extender = require(path.join(paths, file));
-        spice.schema_extenders[path.basename(file, ".js")] = extender;
-      } catch (error) {
-        console.error(`Failed to load ${file}:`, error);
+
+// ⚡ OPTIMIZED: Async file operations for non-blocking schema extender loading
+async function loadSchemaExtenders() {
+  let paths = path.join(spice.root_path, "schema_extenders");
+  
+  if (fs.existsSync(paths)) {
+    try {
+      const files = await readdir(paths);
+      
+      for (const file of files) {
+        if (path.extname(file) === ".js" && file !== "index.js") {
+          try {
+            let extender = require(path.join(paths, file));
+            
+            // Handle ESM default exports
+            if (extender.default) {
+              extender = extender.default;
+            }
+            
+            spice.schema_extenders[path.basename(file, ".js")] = extender;
+          } catch (error) {
+            console.error(`Failed to load schema extender ${file}:`, error.message);
+          }
+        }
       }
+    } catch (error) {
+      console.error("Error loading schema extenders:", error);
     }
-  });
+  }
 }
+
+module.exports = loadSchemaExtenders;

package/src/bootstrap/validation.js

@@ -2,25 +2,44 @@
  * Created by chadfraser on 25/02/2017.
  */
 import path from 'path';
-module.exports = function () {
-    return new Promise(function (resolve, reject) {
-        try {
-            let locations = [spice.module_root_path + '/val', spice.root_path + '/validators']
-           
-            for (let i of locations) {
-                let files = require('fs').readdirSync(i);
-                files.forEach(function (file) {
-                    if (file != 'index.js') {
-                        file.split('.')[0];
-                        require(path.join(i, file));
-                        console.log('Loading Validator', path.join(i, file));
+import fs from 'fs';
+import { promisify } from 'util';
+
+const readdir = promisify(fs.readdir);
+
+// ⚡ OPTIMIZED: Async file operations for non-blocking validator loading
+module.exports = async function () {
+    try {
+        let locations = [
+            spice.module_root_path + '/val', 
+            spice.root_path + '/validators'
+        ];
+       
+        for (let location of locations) {
+            // Check if directory exists before trying to read it
+            if (fs.existsSync(location)) {
+                try {
+                    const files = await readdir(location);
+                    
+                    for (const file of files) {
+                        if (file !== 'index.js' && file.endsWith('.js')) {
+                            try {
+                                require(path.join(location, file));
+                                console.log('Loading Validator', path.join(location, file));
+                            } catch (validatorError) {
+                                console.error(`Failed to load validator ${file}:`, validatorError.message);
+                            }
+                        }
                     }
-                });
+                } catch (error) {
+                    console.log(`Error reading ${location}:`, error.message);
+                }
             }
-            resolve({})
-
-        } catch (e) {
-            reject(e);
         }
-    });
-}
+        
+        return {};
+    } catch (e) {
+        console.error('Error in validation bootstrap:', e);
+        throw e;
+    }
+};

package/src/index.js

@@ -96,21 +96,68 @@ 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;
+        docsGenerating = true;
+        try {
+          console.log("Generating API documentation...");
+          docsCache = await docGen();
+          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: {} 
+          };
+        } 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));
+          }
+          if (!docsCache) {
+            await generateDocsInBackground();
+          }
+          ctx.body = docsCache;
+          return;
+        }
+        await next();
+      });
+      
       app.use(
         koaSwagger({
           hideTopbar: true,
           title: "Spice JS",
-          routePrefix: "/docs", // host at /swagger instead of default /docs
+          routePrefix: "/docs",
           swaggerOptions: {
-            spec: await docGen(),
+            url: "/docs/spec", // Load spec from endpoint instead of inline
             deepLinking: true,
             displayRequestDuration: true,
             jsonEditor: true,
           },
-          exposeSpec: true,
+          exposeSpec: false, // We handle spec serving ourselves
         })
       );
-      await require("./loaders").load();
 
       return spice;
     } catch (e) {