spice-js 2.7.36 → 2.7.39

package/build/index.js

@@ -189,6 +189,10 @@ class Spice {
         return spice;
       } catch (e) {
         console.log(e.stack);
+        // A failed init leaves no usable application (no config, no database,
+        // no routes). Surface it so the host process can exit instead of
+        // listening on a port with nothing behind it.
+        throw e;
       }
     })();
   }

package/build/loaders/index.js

@@ -25,11 +25,22 @@ function _load() {
           console.log('APP Bootstrap directory', app_bootstrap_path); */
       console.log("Loading Ordered Files", ordered_modules);
       for (var file of ordered_modules) {
-        var mod = require(_path.default.join(bootstrap_path, file));
-        if (_lodash.default.isFunction(mod)) {
-          yield mod();
+        try {
+          var mod = require(_path.default.join(bootstrap_path, file));
+          if (_lodash.default.isFunction(mod)) {
+            yield mod();
+          }
+          console.log("loaded", file);
+        } catch (e) {
+          // The ordered modules are the foundation: database, models, logger.
+          // Nothing loaded after them can work without them, so swallowing the
+          // error here produced a half-booted process (no routes, no models,
+          // no retry) that still looked alive. Mark it and let init() rethrow
+          // so the host application can exit and be restarted.
+          console.log("Failed to load core module \"" + file + "\"");
+          e.spice_core_module = file;
+          throw e;
         }
-        console.log("loaded", file);
       }
       var paths = [bootstrap_path, app_bootstrap_path];
       for (var loadder_path of paths) {
@@ -52,6 +63,9 @@ function _load() {
       }
     } catch (e) {
       console.log(e.stack);
+      if (e.spice_core_module) {
+        throw e;
+      }
     }
   });
   return _load.apply(this, arguments);

package/build/models/SpiceModel.js

@@ -6,6 +6,7 @@ var _2 = require("..");
 var _ResourceLifecycleTriggered = _interopRequireDefault(require("../events/events/ResourceLifecycleTriggered"));
 var _Security = require("../utility/Security");
 var _fix = require("../utility/fix");
+var _propertyDefaults = require("../utility/propertyDefaults");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) { ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } } return n; }, _extends.apply(null, arguments); }
 function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
@@ -922,7 +923,7 @@ class SpiceModel {
           };
           var form;
           if (args.skip_write_serialize != true && args.skip_serialize != true) {
-            cover_obj.new = yield _this8.do_serialize(_this8, "write", cover_obj.new, args);
+            cover_obj.new = yield _this8.do_serialize(_this8, "write", cover_obj.old, args);
           }
           if (args.skip_hooks != true) {
             yield _this8.run_hook(cover_obj, "update", "before", results);
@@ -2200,29 +2201,14 @@ class SpiceModel {
           if (!originalIsArray) {
             data = [data];
           }
-
-          // Compute the defaults from properties using reduce.
-          var defaults = Object.keys(_this16.props).reduce((acc, key) => {
-            var _this16$props$key, _this16$props$key$def;
-            var def = (_this16$props$key = _this16.props[key]) == null ? void 0 : (_this16$props$key$def = _this16$props$key.defaults) == null ? void 0 : _this16$props$key$def[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));
+          data = yield (0, _propertyDefaults.applyPropertyDefaults)(data, _this16.props, type, old_data, _this16[_ctx]);
 
           // If type is "read", clean the data by omitting certain props.
           if (type === "read") {
             // Collect hidden properties from schema.
             var hiddenProps = Object.keys(_this16.props).filter(key => {
-              var _this16$props$key2;
-              return (_this16$props$key2 = _this16.props[key]) == null ? void 0 : _this16$props$key2.hide;
+              var _this16$props$key;
+              return (_this16$props$key = _this16.props[key]) == null ? void 0 : _this16$props$key.hide;
             });
             // Combine default props to remove.
             var propsToClean = ["deleted", "type", "collection", ...path_to_be_removed, ...hiddenProps];

package/build/utility/propertyDefaults.js

@@ -0,0 +1,110 @@
+"use strict";
+
+exports.__esModule = true;
+exports.applyPropertyDefaults = applyPropertyDefaults;
+exports.createPropertyDefaultFunctionContext = createPropertyDefaultFunctionContext;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _sonoverDate = _interopRequireDefault(require("sonover-date"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+// sonover-date is Spice.js' declared date dependency and exposes its Moment instance.
+var moment = new _sonoverDate.default().moment;
+function createPropertyDefaultFunctionContext(_temp) {
+  var {
+    record,
+    oldData,
+    user,
+    setting,
+    ctx
+  } = _temp === void 0 ? {} : _temp;
+  var runtime = global.spice;
+  var _util = {
+    moment,
+    _: _lodash.default,
+    user,
+    spice: runtime
+  };
+  return {
+    old_data: oldData,
+    new_data: record,
+    user,
+    setting,
+    ctx,
+    moment,
+    _: _lodash.default,
+    spice: runtime,
+    _util
+  };
+}
+
+/** Apply schema defaults after mapping, without replacing supplied values. */
+function applyPropertyDefaults(_x, _x2, _x3, _x4, _x5) {
+  return _applyPropertyDefaults.apply(this, arguments);
+}
+function _applyPropertyDefaults() {
+  _applyPropertyDefaults = _asyncToGenerator(function* (data, props, type, oldData, ctx) {
+    // Compute native defaults before merging, as the original serializer did.
+    var nativeDefaults = new Map();
+    for (var [key, property] of Object.entries(props)) {
+      var _property$defaults;
+      var value = property == null ? void 0 : (_property$defaults = property.defaults) == null ? void 0 : _property$defaults[type];
+      if (typeof value === "function") {
+        nativeDefaults.set(key, yield value({
+          old_data: data,
+          new_data: oldData
+        }));
+      }
+    }
+    // Match lodash.defaults' handling of null/undefined records in the previous serializer.
+    data = data.map(item => _lodash.default.defaults(item));
+    var _loop = function* _loop(_key, _property) {
+      var _property$defaults2;
+      var value = _property == null ? void 0 : (_property$defaults2 = _property.defaults) == null ? void 0 : _property$defaults2[type];
+      if (value === undefined) return "continue";
+
+      // Native schema functions retain their existing batch argument contract.
+      if (typeof value === "function") {
+        var result = nativeDefaults.get(_key);
+        for (var item of data) {
+          if (item[_key] === undefined) item[_key] = _lodash.default.cloneDeep(result);
+        }
+        return "continue";
+      }
+
+      // Only explicitly configured functions are executable. Literal strings stay literal.
+      if (_property["default_type_" + type] === "function") {
+        var missing = data.some(item => item[_key] === undefined);
+        if (!missing) return "continue";
+        if (typeof value !== "string") {
+          throw new TypeError("Default function for " + _key + " must be a function string.");
+        }
+        var fn = eval("(" + value + ")");
+        if (typeof fn !== "function") {
+          throw new TypeError("Default function for " + _key + " must evaluate to a function.");
+        }
+        for (var [index, _item] of data.entries()) {
+          var _ctx$state;
+          if (_item[_key] !== undefined) continue;
+          _item[_key] = yield fn(_item, createPropertyDefaultFunctionContext({
+            record: _item,
+            oldData: Array.isArray(oldData) ? oldData[index] : oldData,
+            user: ctx == null ? void 0 : (_ctx$state = ctx.state) == null ? void 0 : _ctx$state.user,
+            setting: type,
+            ctx
+          }));
+        }
+        return "continue";
+      }
+      for (var _item2 of data) {
+        if (_item2[_key] === undefined) _item2[_key] = _lodash.default.cloneDeep(value);
+      }
+    };
+    for (var [_key, _property] of Object.entries(props)) {
+      var _ret = yield* _loop(_key, _property);
+      if (_ret === "continue") continue;
+    }
+    return data;
+  });
+  return _applyPropertyDefaults.apply(this, arguments);
+}

package/documentation/PROPERTY_DEFAULTS.md

@@ -0,0 +1,44 @@
+# Property defaults during serialization
+
+`SpiceModel.do_serialize` calls `applyPropertyDefaults` after mapping, before hidden fields are removed on reads. The helper processes `defaults.read` or `defaults.write` according to the serialization mode.
+
+Literal defaults apply only to undefined fields. Existing values, including null, false, zero and empty strings, are preserved. Objects and arrays are cloned per record.
+
+A schema administrator can configure a serialized function:
+
+```js
+stage: {
+  type: "string",
+  default_type_write: "function",
+  defaults: {
+    write: 'async (record, { old_data, user }) => record.urgent ? "priority" : "review"'
+  }
+}
+```
+
+Only strings with `default_type_read` / `default_type_write` equal to `function` are evaluated. Untagged strings, including function-looking text, remain literal. Configured functions run once per record missing that field and are awaited. Their arguments are:
+
+- `record`: the current mapped record.
+- `context.old_data`: the prior record (corresponding index for batch input).
+- `context.new_data`: the current record.
+- `context.user`: `ctx.state.user`, when present.
+- `context.setting`: `read` or `write`.
+- `context.ctx`: the request context, when present.
+- `context._`: Lodash.
+- `context.moment`: Moment.
+- `context.spice`: the server runtime, including registered models, schemas, and services.
+- `context._util`: the workflow-style helper object `{ _, moment, user, spice }`.
+
+During an update, `old_data` is the stored record before changes and `new_data`
+is the current record after submitted changes have been merged. The first
+`record` argument and `new_data` are the same object. During create,
+`old_data` is empty. A default function runs only when its own property is
+undefined; use a hook or modifier when a field must be recomputed on every update.
+
+Invalid function source or execution errors propagate through serialization, preventing function text from being persisted as a value. Functions are trusted schema code, with the same server privileges as other schema logic.
+
+Native JavaScript schema functions retain the existing batch contract: `fn({ old_data: currentRecords, new_data: priorData })`. These historical argument names are preserved for compatibility. Native functions are evaluated before defaults are merged, and async results are now awaited.
+
+Frontend Read Default functions also run in new-record forms. Use synchronous functions and the shared `(record, { user, setting, _, moment, _util })` arguments for those. `spice`, `ctx`, `old_data`, and `new_data` are server-only.
+
+Run `npm test -- --runInBand tests/utility/propertyDefaults.test.js` for serialization integration and default-function regressions. The application must consume this updated Spice.js version for editor-authored server function defaults to work.

package/package.json

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

package/src/index.js

@@ -166,6 +166,10 @@ export default class Spice {
       return spice;
     } catch (e) {
       console.log(e.stack);
+      // A failed init leaves no usable application (no config, no database,
+      // no routes). Surface it so the host process can exit instead of
+      // listening on a port with nothing behind it.
+      throw e;
     }
   }
 }

package/src/loaders/index.js

@@ -26,11 +26,22 @@ export async function load() {
         console.log('APP Bootstrap directory', app_bootstrap_path); */
     console.log("Loading Ordered Files", ordered_modules);
     for (let file of ordered_modules) {
-      let mod = require(path.join(bootstrap_path, file));
-      if (_.isFunction(mod)) {
-        await mod();
+      try {
+        let mod = require(path.join(bootstrap_path, file));
+        if (_.isFunction(mod)) {
+          await mod();
+        }
+        console.log("loaded", file);
+      } catch (e) {
+        // The ordered modules are the foundation: database, models, logger.
+        // Nothing loaded after them can work without them, so swallowing the
+        // error here produced a half-booted process (no routes, no models,
+        // no retry) that still looked alive. Mark it and let init() rethrow
+        // so the host application can exit and be restarted.
+        console.log(`Failed to load core module "${file}"`);
+        e.spice_core_module = file;
+        throw e;
       }
-      console.log("loaded", file);
     }
 
     let paths = [bootstrap_path, app_bootstrap_path];
@@ -60,6 +71,9 @@ export async function load() {
     }
   } catch (e) {
     console.log(e.stack);
+    if (e.spice_core_module) {
+      throw e;
+    }
   }
 }
 //load();

package/src/models/SpiceModel.js

@@ -6,6 +6,7 @@ var regeneratorRuntime = require("regenerator-runtime");
 import ResourceLifecycleTriggered from "../events/events/ResourceLifecycleTriggered";
 import { hasSQLInjection } from "../utility/Security";
 import { fixCollection } from "../utility/fix";
+import { applyPropertyDefaults } from "../utility/propertyDefaults";
 
 var SDate = require("sonover-date"),
   UUID = require("uuid"),
@@ -1024,7 +1025,7 @@ export default class SpiceModel {
         cover_obj.new = await this.do_serialize(
           this,
           "write",
-          cover_obj.new,
+          cover_obj.old,
           args,
         );
       }
@@ -2567,20 +2568,7 @@ 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));
+      data = await applyPropertyDefaults(data, this.props, type, old_data, this[_ctx]);
 
       // If type is "read", clean the data by omitting certain props.
       if (type === "read") {

package/src/utility/propertyDefaults.js

@@ -0,0 +1,86 @@
+import _ from "lodash";
+import SonoverDate from "sonover-date";
+
+// sonover-date is Spice.js' declared date dependency and exposes its Moment instance.
+const moment = new SonoverDate().moment;
+
+export function createPropertyDefaultFunctionContext({
+  record,
+  oldData,
+  user,
+  setting,
+  ctx,
+} = {}) {
+  const runtime = global.spice;
+  const _util = { moment, _, user, spice: runtime };
+  return {
+    old_data: oldData,
+    new_data: record,
+    user,
+    setting,
+    ctx,
+    moment,
+    _,
+    spice: runtime,
+    _util,
+  };
+}
+
+/** Apply schema defaults after mapping, without replacing supplied values. */
+export async function applyPropertyDefaults(data, props, type, oldData, ctx) {
+  // Compute native defaults before merging, as the original serializer did.
+  const nativeDefaults = new Map();
+  for (const [key, property] of Object.entries(props)) {
+    const value = property?.defaults?.[type];
+    if (typeof value === "function") {
+      nativeDefaults.set(key, await value({ old_data: data, new_data: oldData }));
+    }
+  }
+  // Match lodash.defaults' handling of null/undefined records in the previous serializer.
+  data = data.map((item) => _.defaults(item));
+  for (const [key, property] of Object.entries(props)) {
+    const value = property?.defaults?.[type];
+    if (value === undefined) continue;
+
+    // Native schema functions retain their existing batch argument contract.
+    if (typeof value === "function") {
+      const result = nativeDefaults.get(key);
+      for (const item of data) {
+        if (item[key] === undefined) item[key] = _.cloneDeep(result);
+      }
+      continue;
+    }
+
+    // Only explicitly configured functions are executable. Literal strings stay literal.
+    if (property[`default_type_${type}`] === "function") {
+      const missing = data.some((item) => item[key] === undefined);
+      if (!missing) continue;
+      if (typeof value !== "string") {
+        throw new TypeError(`Default function for ${key} must be a function string.`);
+      }
+      const fn = eval(`(${value})`);
+      if (typeof fn !== "function") {
+        throw new TypeError(`Default function for ${key} must evaluate to a function.`);
+      }
+      for (const [index, item] of data.entries()) {
+        if (item[key] !== undefined) continue;
+        item[key] = await fn(
+          item,
+          createPropertyDefaultFunctionContext({
+            record: item,
+            oldData: Array.isArray(oldData) ? oldData[index] : oldData,
+            user: ctx?.state?.user,
+            setting: type,
+            ctx,
+          }),
+        );
+      }
+      continue;
+    }
+
+    for (const item of data) {
+      if (item[key] === undefined) item[key] = _.cloneDeep(value);
+    }
+  }
+  return data;
+}

package/tests/utility/propertyDefaults.test.js

@@ -0,0 +1,157 @@
+const {
+  applyPropertyDefaults,
+  createPropertyDefaultFunctionContext,
+} = require('../../src/utility/propertyDefaults');
+const { createTestModel, seedDatabase } = require('../helpers/modelFactory');
+
+describe('property defaults', () => {
+  test('retains serialization of empty records', async () => {
+    const result = await applyPropertyDefaults([null, undefined], {
+      stage: { defaults: { write: 'review' } },
+    }, 'write');
+    expect(result).toEqual([{ stage: 'review' }, { stage: 'review' }]);
+  });
+
+  test('direct lookup values and falsy defaults survive write serialization', async () => {
+    const model = createTestModel({ props: {
+      stage: { type: 'string', default_type_write: 'property_value', defaults: { write: 'stage-review' } },
+      count: { type: 'number', defaults: { write: 0 } },
+      enabled: { type: 'boolean', defaults: { write: false } },
+      text: { type: 'string', defaults: { write: '' } },
+    } });
+    const result = await model.do_serialize({}, 'write', {}, {});
+    expect(result).toEqual({ stage: 'stage-review', count: 0, enabled: false, text: '' });
+  });
+
+  test.each(['read', 'write'])('evaluates saved %s function strings per missing record', async (type) => {
+    const model = createTestModel({ props: {
+      stage: { type: 'string', [`default_type_${type}`]: 'function', defaults: {
+        [type]: 'async (record) => record.urgent ? "priority" : "review"',
+      } },
+    } });
+    const result = await model.do_serialize([
+      { urgent: true }, { urgent: false }, { stage: 'done' }, { stage: null },
+    ], type, {}, {});
+    expect(result.map((record) => record.stage)).toEqual(['priority', 'review', 'done', null]);
+  });
+
+  test('passes record, old data and context to configured write functions', async () => {
+    const oldData = [{ stage: 'old-a' }, { stage: 'old-b' }];
+    const props = { stage: { default_type_write: 'function', defaults: {
+      write: '(record, { old_data, user, setting }) => `${old_data.stage}-${user.id}-${setting}`',
+    } } };
+    const result = await applyPropertyDefaults([{}, {}], props, 'write', oldData, { state: { user: { id: 'u1' } } });
+    expect(result.map((record) => record.stage)).toEqual(['old-a-u1-write', 'old-b-u1-write']);
+  });
+
+  test('update functions receive the stored record as old_data and merged changes as new_data', async () => {
+    const model = createTestModel({
+      type: 'ticket',
+      args: { status: 'approved' },
+      props: {
+        status: { type: 'string' },
+        status_change: {
+          type: 'object',
+          default_type_write: 'function',
+          defaults: {
+            write: `(record, { old_data, new_data }) => ({
+              from: old_data.status,
+              to: new_data.status,
+              sameNewRecord: record === new_data,
+            })`,
+          },
+        },
+      },
+    });
+    seedDatabase(model, { id: 'ticket-1', status: 'pending' });
+    jest.spyOn(model, 'setMonitor').mockImplementation(() => {});
+
+    const result = await model.update({
+      id: 'ticket-1',
+      skip_hooks: true,
+      skip_read_serialize: true,
+    });
+
+    expect(result.status_change).toEqual({
+      from: 'pending',
+      to: 'approved',
+      sameNewRecord: true,
+    });
+  });
+
+  test('provides lodash, moment and the workflow-style utility context', async () => {
+    const props = { due: { default_type_write: 'function', defaults: {
+      write: `(record, { _, moment, _util, spice }) => ({
+        owner: _.get(record, "owner.id"),
+        date: moment("2026-09-06").add(2, "days").format("YYYY-MM-DD"),
+        sameLodash: _util._ === _,
+        sameMoment: _util.moment === moment,
+        user: _util.user.id,
+        sameSpice: _util.spice === spice,
+      })`,
+    } } };
+    const result = await applyPropertyDefaults(
+      [{ owner: { id: 'u2' } }],
+      props,
+      'write',
+      {},
+      { state: { user: { id: 'u1' } } },
+    );
+    expect(result[0].due).toEqual({
+      owner: 'u2',
+      date: '2026-09-08',
+      sameLodash: true,
+      sameMoment: true,
+      user: 'u1',
+      sameSpice: true,
+    });
+  });
+
+  test('exposes direct and _util helper aliases from the same context', () => {
+    const context = createPropertyDefaultFunctionContext({ user: { id: 'u1' } });
+    expect(context._util._).toBe(context._);
+    expect(context._util.moment).toBe(context.moment);
+    expect(context._util.user).toBe(context.user);
+    expect(context._util.spice).toBe(context.spice);
+  });
+
+  test('never executes literal strings that look like functions', async () => {
+    const code = '() => { throw new Error("must not run"); }';
+    const result = await applyPropertyDefaults([{}], { stage: { defaults: { write: code } } }, 'write');
+    expect(result[0].stage).toBe(code);
+  });
+
+  test('retains the native schema function batch contract', async () => {
+    const records = [{}, { stage: false }];
+    const oldData = { previous: true };
+    const native = jest.fn(async () => 'review');
+    await applyPropertyDefaults(records, { stage: { defaults: { write: native } } }, 'write', oldData);
+    expect(native).toHaveBeenCalledTimes(1);
+    expect(native).toHaveBeenCalledWith({ old_data: records, new_data: oldData });
+    expect(records).toEqual([{ stage: 'review' }, { stage: false }]);
+  });
+
+  test('does not run configured functions when the value is supplied', async () => {
+    const records = [{ stage: '' }, { stage: 0 }, { stage: false }, { stage: null }];
+    await applyPropertyDefaults(records, { stage: { default_type_write: 'function', defaults: {
+      write: '() => { throw new Error("must not run"); }',
+    } } }, 'write');
+    expect(records.map((record) => record.stage)).toEqual(['', 0, false, null]);
+  });
+
+  test('rejects invalid functions instead of saving their source as a default', async () => {
+    for (const write of ['not valid javascript', '42', { code: '' }]) {
+      await expect(applyPropertyDefaults([{}], { stage: {
+        default_type_write: 'function', defaults: { write },
+      } }, 'write')).rejects.toThrow();
+    }
+  });
+
+  test('clones array and object defaults for each record', async () => {
+    const value = { data: [] };
+    const result = await applyPropertyDefaults([{}, {}], { details: { defaults: { write: value } } }, 'write');
+    result[0].details.data.push('one');
+    expect(result[1].details).toEqual({ data: [] });
+    expect(value).toEqual({ data: [] });
+  });
+});