spice-js 2.6.70 → 2.6.71

package/build/bootstrap/map.js

@@ -6,40 +6,28 @@ var _lodash = _interopRequireDefault(require("lodash"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+try {
+  var resources = ["models", "controllers", "schemas", "cache"];
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+  for (var resource of resources) {
+    var paths = _path.default.join(spice.root_path, resource);
 
-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); } }
+    spice[resource] = {};
 
-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); }); }; }
+    var files = require("fs").readdirSync(paths);
 
-try {
-  var resources = ["models", "controllers", "schemas", "cache"];
+    for (var file of files) {
+      var file_name = file.split(".")[0];
+
+      var imported = require(_path.default.join(paths, file));
+
+      var moduleDefault = imported.default || imported; // ⚡ Only store once, create both references to same object
 
-  _lodash.default.each(resources,
-  /*#__PURE__*/
-  function () {
-    var _ref = _asyncToGenerator(function* (resource) {
-      var paths = _path.default.join(spice.root_path, resource);
-
-      spice[resource] = {};
-
-      for (var file of require("fs").readdirSync(paths)) {
-        var file_name = file.split(".")[0];
-        spice[resource][file_name.toLowerCase()] = (yield Promise.resolve("" + _path.default.join(paths, file)).then(s => _interopRequireWildcard(require(s)))).default;
-        spice[resource][file_name] = (yield Promise.resolve("" + _path.default.join(paths, file)).then(s => _interopRequireWildcard(require(s)))).default;
-
-        if (resource == "models") {
-          new spice[resource][file_name]({});
-        }
-      }
-    });
-
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }());
+      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/build/bootstrap/routes.js

@@ -2,17 +2,53 @@
 
 var _path = _interopRequireDefault(require("path"));
 
+var _fs = _interopRequireDefault(require("fs"));
+
+var _util = require("util");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-spice.routers = {};
+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); }); }; }
+
+var readdir = (0, _util.promisify)(_fs.default.readdir);
+spice.routers = {}; // ⚡ OPTIMIZED: Async file operations for non-blocking route loading
+
+function loadRoutes() {
+  return _loadRoutes.apply(this, arguments);
+}
+
+function _loadRoutes() {
+  _loadRoutes = _asyncToGenerator(function* () {
+    var paths = _path.default.join(spice.root_path, 'routes');
+
+    try {
+      var files = yield readdir(paths);
+
+      for (var file of files) {
+        if (file !== 'index.js' && file.endsWith('.js')) {
+          try {
+            var router = require(_path.default.join(paths, file)); // Handle ESM default exports
+
 
-var paths = _path.default.join(spice.root_path, 'routes');
+            if (router.default) {
+              router = router.default;
+            }
 
-require('fs').readdirSync(paths).forEach(function (file) {
-  if (file != 'index.js') {
-    var router = require(_path.default.join(paths, file));
+            var routerName = file.split('.')[0];
+            spice.routers[routerName] = router;
+            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);
+    }
+  });
+  return _loadRoutes.apply(this, arguments);
+}
 
-    spice.routers[file.split('.')[0]] = router;
-    spice.app.use(spice.routers[file.split('.')[0]].routes()).use(spice.routers[file.split('.')[0]].allowedMethods());
-  }
-});
+module.exports = loadRoutes;

package/build/bootstrap/schema_extenders.js

@@ -4,22 +4,51 @@ var _path = _interopRequireDefault(require("path"));
 
 var _fs = _interopRequireDefault(require("fs"));
 
+var _util = require("util");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var paths = _path.default.join(spice.root_path, "schema_extenders");
+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); }); }; }
+
+var readdir = (0, _util.promisify)(_fs.default.readdir);
+spice.schema_extenders = {}; // ⚡ OPTIMIZED: Async file operations for non-blocking schema extender loading
+
+function loadSchemaExtenders() {
+  return _loadSchemaExtenders.apply(this, arguments);
+}
 
-spice.schema_extenders = {};
+function _loadSchemaExtenders() {
+  _loadSchemaExtenders = _asyncToGenerator(function* () {
+    var paths = _path.default.join(spice.root_path, "schema_extenders");
 
-if (_fs.default.existsSync(paths)) {
-  _fs.default.readdirSync(paths).forEach(function (file) {
-    if (_path.default.extname(file) === ".js" && file !== "index.js") {
+    if (_fs.default.existsSync(paths)) {
       try {
-        var extender = require(_path.default.join(paths, file));
+        var files = yield readdir(paths);
 
-        spice.schema_extenders[_path.default.basename(file, ".js")] = extender;
+        for (var file of files) {
+          if (_path.default.extname(file) === ".js" && file !== "index.js") {
+            try {
+              var extender = require(_path.default.join(paths, file)); // Handle ESM default exports
+
+
+              if (extender.default) {
+                extender = extender.default;
+              }
+
+              spice.schema_extenders[_path.default.basename(file, ".js")] = extender;
+            } catch (error) {
+              console.error("Failed to load schema extender " + file + ":", error.message);
+            }
+          }
+        }
       } catch (error) {
-        console.error("Failed to load " + file + ":", error);
+        console.error("Error loading schema extenders:", error);
       }
     }
   });
-}
+  return _loadSchemaExtenders.apply(this, arguments);
+}
+
+module.exports = loadSchemaExtenders;

package/build/bootstrap/validation.js

@@ -2,37 +2,50 @@
 
 var _path = _interopRequireDefault(require("path"));
 
+var _fs = _interopRequireDefault(require("fs"));
+
+var _util = require("util");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-/**
- * Created by chadfraser on 25/02/2017.
- */
-module.exports = function () {
-  return new Promise(function (resolve, reject) {
-    try {
-      var locations = [spice.module_root_path + '/val', spice.root_path + '/validators'];
+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); } }
 
-      var _loop = function _loop(i) {
-        var files = require('fs').readdirSync(i);
+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); }); }; }
 
-        files.forEach(function (file) {
-          if (file != 'index.js') {
-            file.split('.')[0];
+var readdir = (0, _util.promisify)(_fs.default.readdir); // ⚡ OPTIMIZED: Async file operations for non-blocking validator loading
 
-            require(_path.default.join(i, file));
+module.exports =
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  try {
+    var locations = [spice.module_root_path + '/val', spice.root_path + '/validators'];
 
-            console.log('Loading Validator', _path.default.join(i, file));
-          }
-        });
-      };
+    for (var location of locations) {
+      // Check if directory exists before trying to read it
+      if (_fs.default.existsSync(location)) {
+        try {
+          var files = yield readdir(location);
 
-      for (var i of locations) {
-        _loop(i);
-      }
+          for (var file of files) {
+            if (file !== 'index.js' && file.endsWith('.js')) {
+              try {
+                require(_path.default.join(location, file));
 
-      resolve({});
-    } catch (e) {
-      reject(e);
+                console.log('Loading Validator', _path.default.join(location, file));
+              } catch (validatorError) {
+                console.error("Failed to load validator " + file + ":", validatorError.message);
+              }
+            }
+          }
+        } catch (error) {
+          console.log("Error reading " + location + ":", error.message);
+        }
+      }
     }
-  });
-};
+
+    return {};
+  } catch (e) {
+    console.error('Error in validation bootstrap:', e);
+    throw e;
+  }
+});

package/build/index.js

@@ -175,22 +175,88 @@ class Spice {
         /* app._io.on("connection", (sock) => {
           console.log("Connection Up", sock);
         }); */
-
-
+        // ⚡ OPTIMIZED: Load routes and models first, then generate docs lazily
+
+
+        yield require("./loaders").load(); // ⚡ LAZY DOCS: Generate docs in background after startup to not block server
+
+        var docsCache = null;
+        var docsGenerating = false; // Generate docs asynchronously after startup
+
+        var generateDocsInBackground =
+        /*#__PURE__*/
+        function () {
+          var _ref = _asyncToGenerator(function* () {
+            if (docsCache || docsGenerating) return;
+            docsGenerating = true;
+
+            try {
+              console.log("Generating API documentation...");
+              docsCache = yield (0, _generator.default)();
+              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;
+            }
+          });
+
+          return function generateDocsInBackground() {
+            return _ref.apply(this, arguments);
+          };
+        }(); // Start generating docs in background (non-blocking)
+
+
+        setTimeout(generateDocsInBackground, 100); // Middleware to serve docs - will wait if still generating
+
+        app.use(
+        /*#__PURE__*/
+        function () {
+          var _ref2 = _asyncToGenerator(function* (ctx, next) {
+            if (ctx.path === "/docs/spec" || ctx.path === "/docs/spec.json") {
+              // Wait for docs to be generated if not ready
+              while (docsGenerating && !docsCache) {
+                yield new Promise(resolve => setTimeout(resolve, 100));
+              }
+
+              if (!docsCache) {
+                yield generateDocsInBackground();
+              }
+
+              ctx.body = docsCache;
+              return;
+            }
+
+            yield next();
+          });
+
+          return function (_x, _x2) {
+            return _ref2.apply(this, arguments);
+          };
+        }());
         app.use((0, _koa2SwaggerUi.koaSwagger)({
           hideTopbar: true,
           title: "Spice JS",
           routePrefix: "/docs",
-          // host at /swagger instead of default /docs
           swaggerOptions: {
-            spec: yield (0, _generator.default)(),
+            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
+
         }));
-        yield require("./loaders").load();
         return spice;
       } catch (e) {
         console.log(e.stack);

package/build/models/SpiceModel.js

@@ -52,6 +52,7 @@ if (!Promise.allSettled) {
 }
 
 class SpiceModel {
+  // ⚡ Static caches for performance optimization
   constructor(args) {
     if (args === void 0) {
       args = {};
@@ -1330,6 +1331,54 @@ class SpiceModel {
     }
 
     return true;
+  } // ⚡ OPTIMIZED: Cache defaults metadata per model type
+
+
+  getDefaultsMetadata(type) {
+    var cacheKey = this.type + "::" + type;
+
+    if (!SpiceModel._defaultsCache[cacheKey]) {
+      var staticDefaults = {};
+      var dynamicDefaults = []; // Pre-compute once per model type
+
+      for (var key in this.props) {
+        var _this$props$key, _this$props$key$defau;
+
+        var def = (_this$props$key = this.props[key]) == null ? void 0 : (_this$props$key$defau = _this$props$key.defaults) == null ? void 0 : _this$props$key$defau[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 => {
+        var _this$props$key2;
+
+        return (_this$props$key2 = this.props[key]) == null ? void 0 : _this$props$key2.hide;
+      });
+    }
+
+    return SpiceModel._hiddenPropsCache[this.type];
   }
 
   mapToObject(data, Class, source_property, store_property, property) {
@@ -1587,33 +1636,42 @@ class SpiceModel {
 
         if (!originalIsArray) {
           data = [data];
-        } // Compute the defaults from properties using reduce.
-
-
-        var defaults = Object.keys(_this18.props).reduce((acc, key) => {
-          var _this18$props$key, _this18$props$key$def;
-
-          var def = (_this18$props$key = _this18.props[key]) == null ? void 0 : (_this18$props$key$def = _this18$props$key.defaults) == null ? void 0 : _this18$props$key$def[type];
-
-          if (def !== undefined) {
-            acc[key] = _.isFunction(def) ? def({
-              old_data: data,
-              new_data: old_data
-            }) : def;
-          }
+        } // ⚡ OPTIMIZED: Use cached defaults metadata instead of computing every time
+
+
+        var {
+          staticDefaults,
+          dynamicDefaults,
+          hasDefaults
+        } = _this18.getDefaultsMetadata(type);
+
+        if (hasDefaults) {
+          data = data.map(item => {
+            // Apply static defaults first (fast - no function calls)
+            var result = _.defaults({}, item, staticDefaults); // Only compute dynamic defaults if there are any
+
+
+            for (var {
+              key,
+              fn
+            } of dynamicDefaults) {
+              if (result[key] === undefined) {
+                result[key] = fn({
+                  old_data: data,
+                  new_data: old_data
+                });
+              }
+            }
 
-          return acc;
-        }, {}); // Merge defaults into each object.
+            return result;
+          });
+        } // If type is "read", clean the data by omitting certain props.
 
-        data = data.map(item => _.defaults(item, defaults)); // If type is "read", clean the data by omitting certain props.
 
         if (type === "read") {
-          // Collect hidden properties from schema.
-          var hiddenProps = Object.keys(_this18.props).filter(key => {
-            var _this18$props$key2;
+          // ⚡ OPTIMIZED: Use cached hidden props instead of computing every time
+          var hiddenProps = _this18.getHiddenProps(); // Combine default props to remove.
 
-            return (_this18$props$key2 = _this18.props[key]) == null ? void 0 : _this18$props$key2.hide;
-          }); // Combine default props to remove.
 
           var propsToClean = ["deleted", "type", ...path_to_be_removed, ...hiddenProps];
           data = data.map(item => _.omit(item, propsToClean));
@@ -1630,4 +1688,6 @@ class SpiceModel {
 
 }
 
-exports.default = SpiceModel;
+exports.default = SpiceModel;
+SpiceModel._defaultsCache = {};
+SpiceModel._hiddenPropsCache = {};