spice-js 2.6.70 → 2.6.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-js",
-  "version": "2.6.70",
+  "version": "2.6.71",
   "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) {

package/src/models/SpiceModel.js

@@ -42,6 +42,10 @@ if (!Promise.allSettled) {
     );
 }
 export default class SpiceModel {
+  // ⚡ Static caches for performance optimization
+  static _defaultsCache = {};
+  static _hiddenPropsCache = {};
+  
   constructor(args = {}) {
     try {
       var dbtype =
@@ -1257,6 +1261,46 @@ export default class SpiceModel {
     return true;
   }
 
+  // ⚡ OPTIMIZED: Cache defaults metadata per model type
+  getDefaultsMetadata(type) {
+    const cacheKey = `${this.type}::${type}`;
+    
+    if (!SpiceModel._defaultsCache[cacheKey]) {
+      const staticDefaults = {};
+      const dynamicDefaults = [];
+      
+      // Pre-compute once per model type
+      for (const key in this.props) {
+        const def = this.props[key]?.defaults?.[type];
+        if (def !== undefined) {
+          if (_.isFunction(def)) {
+            dynamicDefaults.push({ key, fn: def });
+          } else {
+            staticDefaults[key] = def;
+          }
+        }
+      }
+      
+      SpiceModel._defaultsCache[cacheKey] = {
+        staticDefaults,
+        dynamicDefaults,
+        hasDefaults: Object.keys(staticDefaults).length > 0 || dynamicDefaults.length > 0
+      };
+    }
+    
+    return SpiceModel._defaultsCache[cacheKey];
+  }
+
+  // ⚡ OPTIMIZED: Cache hidden props per model type
+  getHiddenProps() {
+    if (!SpiceModel._hiddenPropsCache[this.type]) {
+      SpiceModel._hiddenPropsCache[this.type] = Object.keys(this.props).filter(
+        (key) => this.props[key]?.hide
+      );
+    }
+    return SpiceModel._hiddenPropsCache[this.type];
+  }
+
   async mapToObject(data, Class, source_property, store_property, property) {
     let original_is_array = _.isArray(data);
     if (!original_is_array) {
@@ -1486,26 +1530,29 @@ export default class SpiceModel {
         data = [data];
       }
 
-      // Compute the defaults from properties using reduce.
-      const defaults = Object.keys(this.props).reduce((acc, key) => {
-        const def = this.props[key]?.defaults?.[type];
-        if (def !== undefined) {
-          acc[key] = _.isFunction(def)
-            ? def({ old_data: data, new_data: old_data })
-            : def;
-        }
-        return acc;
-      }, {});
-
-      // Merge defaults into each object.
-      data = data.map((item) => _.defaults(item, defaults));
+      // ⚡ OPTIMIZED: Use cached defaults metadata instead of computing every time
+      const { staticDefaults, dynamicDefaults, hasDefaults } = this.getDefaultsMetadata(type);
+      
+      if (hasDefaults) {
+        data = data.map((item) => {
+          // Apply static defaults first (fast - no function calls)
+          const result = _.defaults({}, item, staticDefaults);
+          
+          // Only compute dynamic defaults if there are any
+          for (const { key, fn } of dynamicDefaults) {
+            if (result[key] === undefined) {
+              result[key] = fn({ old_data: data, new_data: old_data });
+            }
+          }
+          
+          return result;
+        });
+      }
 
       // If type is "read", clean the data by omitting certain props.
       if (type === "read") {
-        // Collect hidden properties from schema.
-        const hiddenProps = Object.keys(this.props).filter(
-          (key) => this.props[key]?.hide
-        );
+        // ⚡ OPTIMIZED: Use cached hidden props instead of computing every time
+        const hiddenProps = this.getHiddenProps();
         // Combine default props to remove.
         const propsToClean = [
           "deleted",