spice-js 2.7.18 → 2.7.19

package/build/models/SpiceModel.js

@@ -957,36 +957,47 @@ class SpiceModel {
       var col = (raw || "").trim();
       if (col === "" || col === "meta().id") return undefined;
       if (/^\s*ARRAY\s+/i.test(col) || /\w+\s*\(/.test(col)) return col;
+
+      // If the first segment is a mapped model property, always project the
+      // root mapped field (supports deep paths like dependents.passports.holder).
+      var deepMappedPathMatch = col.match(/^\s*`?(\w+)`?(?:\.`?\w+`?)+(?:\s+AS\s+`?([\w]+)`?)?\s*$/i);
+      if (deepMappedPathMatch) {
+        var _this$props$alias;
+        var alias = deepMappedPathMatch[1];
+        if (alias !== this.type && ((_this$props$alias = this.props[alias]) == null ? void 0 : _this$props$alias.map)) {
+          return q(this.type) + "." + q(alias);
+        }
+      }
       var m = col.match(/^\s*`?(\w+)`?\.`?(\w+)`?(?:\s+AS\s+`?([\w]+)`?)?\s*$/i);
       if (m) {
-        var alias = m[1];
+        var _alias = m[1];
         var field = m[2];
         var explicitAs = m[3];
 
         // If alias matches this.type, don't prepend again
-        if (alias === this.type) {
-          var _qualified = q(alias) + "." + q(field);
+        if (_alias === this.type) {
+          var _qualified = q(_alias) + "." + q(field);
           return explicitAs ? _qualified + " AS " + q(explicitAs) : _qualified;
         }
 
         // Check if alias has a map - if so, simplify to root column only (raw ID)
-        var prop = this.props[alias];
+        var prop = this.props[_alias];
         if (prop == null ? void 0 : prop.map) {
           // Return base table qualified root column, ignoring the .field part
-          return q(this.type) + "." + q(alias);
+          return q(this.type) + "." + q(_alias);
         }
-        if (arraySet.has(alias)) {
-          var proj = this.buildArrayProjection(alias, field);
-          if (explicitAs && explicitAs !== alias + "_" + field) {
+        if (arraySet.has(_alias)) {
+          var proj = this.buildArrayProjection(_alias, field);
+          if (explicitAs && explicitAs !== _alias + "_" + field) {
             proj = proj.replace(/AS\s+`[^`]+`$/i, "AS " + q(explicitAs));
           }
           return proj;
         }
-        if (protectedSet.has(alias)) {
-          var aliased = q(alias) + "." + (field.startsWith("`") ? field : q(field));
+        if (protectedSet.has(_alias)) {
+          var aliased = q(_alias) + "." + (field.startsWith("`") ? field : q(field));
           return explicitAs ? aliased + " AS " + q(explicitAs) : aliased;
         }
-        var qualified = q(this.type) + "." + q(alias) + "." + q(field);
+        var qualified = q(this.type) + "." + q(_alias) + "." + q(field);
         return explicitAs ? qualified + " AS " + q(explicitAs) : qualified;
       }
       var looksProtected = [...protectedSet].some(a => col === a || col === q(a) || col.startsWith(a + ".") || col.startsWith(q(a) + "."));
@@ -1032,9 +1043,14 @@ class SpiceModel {
         if (aliasMatch) {
           return aliasMatch[1].trim();
         }
-        // Otherwise, if a dot is present, take the part after the last dot
+        // Otherwise, for dot-notation, keep the first segment after removing
+        // the base model prefix (e.g. user.group.name -> group).
         if (col.includes(".")) {
-          return col.split(".").pop().trim();
+          var pathParts = col.split(".").map(part => part.trim()).filter(part => part !== "");
+          if (pathParts[0] === this.type && pathParts.length > 1) {
+            pathParts = pathParts.slice(1);
+          }
+          return pathParts[0];
         }
         return col;
       });
@@ -1262,7 +1278,7 @@ class SpiceModel {
 
           // Build JOIN/NEST from the mapped keyspaces
           args._join = _this10.createJoinSection(mappedNestings);
-          //console.log("args.columns", args);
+
           // WHERE
           var query = "";
           var deletedCondition = "(`" + _this10.type + "`.deleted = false OR `" + _this10.type + "`.deleted IS MISSING)";
@@ -1292,14 +1308,14 @@ class SpiceModel {
             var isEmpty = (cached == null ? void 0 : cached.value) === undefined;
             var refresh = yield _this10.shouldForceRefresh(cached);
             if (isEmpty || refresh) {
-              results = yield _this10.fetchResults(args, query);
+              results = yield _this10.fetchResults(args, query, mappedNestings);
               _this10.getCacheProviderObject(_this10.type).set(cacheKey, {
                 value: results,
                 time: new Date().getTime()
               }, _this10.getCacheConfig(_this10.type));
             }
           } else {
-            results = yield _this10.fetchResults(args, query);
+            results = yield _this10.fetchResults(args, query, mappedNestings);
           }
 
           // Serializer still handles class-based refs and value_field
@@ -1332,7 +1348,36 @@ class SpiceModel {
       }
     })();
   }
-  fetchResults(args, query) {
+  correctColumns(columns, mappedNestings) {
+    // Preserve normal columns and only rewrite mapped alias dot-paths
+    // to the root mapped field on the base resource.
+    if (!columns || typeof columns !== "string") return columns;
+    var mappedAliasSet = new Set((mappedNestings || []).map(m => m.alias));
+    var isMappedAlias = alias => {
+      var _this$props, _this$props$alias2;
+      return !!((_this$props = this.props) == null ? void 0 : (_this$props$alias2 = _this$props[alias]) == null ? void 0 : _this$props$alias2.map);
+    };
+    var normalized = columns.split(",").map(col => col.trim()).filter(col => col !== "").map(col => {
+      var cleanCol = col.replace(/`/g, "").trim();
+      var parts = cleanCol.split(".");
+      var firstSegment = parts[0];
+      var secondSegment = parts[1];
+      var mappedAlias = null;
+      if (isMappedAlias(firstSegment)) {
+        mappedAlias = firstSegment;
+      } else if (firstSegment === this.type && secondSegment && isMappedAlias(secondSegment)) {
+        mappedAlias = secondSegment;
+      } else if (mappedAliasSet.has(firstSegment)) {
+        mappedAlias = firstSegment;
+      }
+      if (mappedAlias) {
+        return "`" + this.type + "`.`" + mappedAlias + "`";
+      }
+      return col;
+    });
+    return _.join(_.uniq(_.compact(normalized)), ",");
+  }
+  fetchResults(args, query, mappedNestings) {
     var _this11 = this;
     return _asyncToGenerator(function* () {
       var _this11$_ctx;
@@ -1345,7 +1390,8 @@ class SpiceModel {
           } else if (args.is_full_text === "true") {
             return yield _this11.database.full_text_search(_this11.type, query || "", args.limit, args.offset, args._join);
           } else {
-            var result = yield _this11.database.search(_this11.type, args.columns || "", query || "", args.limit, args.offset, args.sort, args.do_count, args.statement_consistent, args._join);
+            var correctedColumns = _this11.correctColumns(args.columns, mappedNestings);
+            var result = yield _this11.database.search(_this11.type, correctedColumns || args.columns || "", query || "", args.limit, args.offset, args.sort, args.do_count, args.statement_consistent, args._join);
             return result;
           }
         });
@@ -1574,12 +1620,16 @@ class SpiceModel {
       if (isExempt || _this14[_level] + 1 < _this14[_mapping_dept]) {
         var ids = [];
         _.each(data, result => {
-          var value = [];
-          if (_.isArray(result[source_property])) {
-            value = result[source_property];
+          var value = result[source_property];
+
+          // Some list/select projections place fields under an empty-string key.
+          if ((value === undefined || _.isObject(value) && _.isEmpty(value)) && result[""] && result[""][source_property] !== undefined) {
+            value = result[""][source_property];
           }
-          if (_.isString(result[source_property])) {
-            value = [result[source_property]];
+          if (_.isString(value)) {
+            value = [value];
+          } else if (!_.isArray(value)) {
+            value = [];
           }
 
           // Extract IDs - handle both string IDs and objects with id property
@@ -1632,14 +1682,29 @@ class SpiceModel {
           if (returned_obj.status == "fulfilled") return returned_obj.value;
         })));
         _.each(data, result => {
+          var sourceValue = result[source_property];
+          var hasFallbackSource = result[""] && result[""][source_property] !== undefined;
           if (_.isString(result[store_property])) {
             result[store_property] = [result[store_property]];
           }
-          if (!_.has(result, source_property)) {
+          if (!_.has(result, source_property) && !hasFallbackSource) {
+            if (!_.isArray(result[store_property])) {
+              result[store_property] = [];
+            }
             result[source_property] = [];
             return;
           }
-          result[store_property] = _.map(result[source_property], item => {
+
+          // Match mapToObject behavior for projected rows that use result[""].
+          if ((sourceValue === undefined || _.isObject(sourceValue) && _.isEmpty(sourceValue)) && hasFallbackSource) {
+            sourceValue = result[""][source_property];
+          }
+          if (_.isString(sourceValue)) {
+            sourceValue = [sourceValue];
+          } else if (!_.isArray(sourceValue)) {
+            sourceValue = [];
+          }
+          result[store_property] = _.map(sourceValue, item => {
             // Get the ID to match - either a string ID or the id property of an object
             var itemId = _.isString(item) ? item : _.isObject(item) ? item.id : null;
             return _.find(returned_objects, p => p.id === itemId);

package/package.json

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

package/src/models/SpiceModel.js

@@ -690,6 +690,7 @@ export default class SpiceModel {
       _.remove(args.ids, (o) => o == undefined);
       let key = `multi-get::${this.type}::${_.join(args.ids, "|")}:${args.columns}`;
       let results = [];
+
       if (args.ids.length > 0) {
         if (this.shouldUseCache(this.type)) {
           let cached_results = await this.getCacheProviderObject(this.type).get(
@@ -1031,6 +1032,18 @@ export default class SpiceModel {
 
       if (/^\s*ARRAY\s+/i.test(col) || /\w+\s*\(/.test(col)) return col;
 
+      // If the first segment is a mapped model property, always project the
+      // root mapped field (supports deep paths like dependents.passports.holder).
+      const deepMappedPathMatch = col.match(
+        /^\s*`?(\w+)`?(?:\.`?\w+`?)+(?:\s+AS\s+`?([\w]+)`?)?\s*$/i,
+      );
+      if (deepMappedPathMatch) {
+        const alias = deepMappedPathMatch[1];
+        if (alias !== this.type && this.props[alias]?.map) {
+          return `${q(this.type)}.${q(alias)}`;
+        }
+      }
+
       const m = col.match(
         /^\s*`?(\w+)`?\.`?(\w+)`?(?:\s+AS\s+`?([\w]+)`?)?\s*$/i,
       );
@@ -1127,9 +1140,17 @@ export default class SpiceModel {
           if (aliasMatch) {
             return aliasMatch[1].trim();
           }
-          // Otherwise, if a dot is present, take the part after the last dot
+          // Otherwise, for dot-notation, keep the first segment after removing
+          // the base model prefix (e.g. user.group.name -> group).
           if (col.includes(".")) {
-            return col.split(".").pop().trim();
+            let pathParts = col
+              .split(".")
+              .map((part) => part.trim())
+              .filter((part) => part !== "");
+            if (pathParts[0] === this.type && pathParts.length > 1) {
+              pathParts = pathParts.slice(1);
+            }
+            return pathParts[0];
           }
           return col;
         });
@@ -1385,7 +1406,7 @@ export default class SpiceModel {
 
       // Build JOIN/NEST from the mapped keyspaces
       args._join = this.createJoinSection(mappedNestings);
-      //console.log("args.columns", args);
+
       // WHERE
       let query = "";
       const deletedCondition = `(\`${this.type}\`.deleted = false OR \`${this.type}\`.deleted IS MISSING)`;
@@ -1431,7 +1452,7 @@ export default class SpiceModel {
         const isEmpty = cached?.value === undefined;
         const refresh = await this.shouldForceRefresh(cached);
         if (isEmpty || refresh) {
-          results = await this.fetchResults(args, query);
+          results = await this.fetchResults(args, query, mappedNestings);
           this.getCacheProviderObject(this.type).set(
             cacheKey,
             { value: results, time: new Date().getTime() },
@@ -1439,7 +1460,7 @@ export default class SpiceModel {
           );
         }
       } else {
-        results = await this.fetchResults(args, query);
+        results = await this.fetchResults(args, query, mappedNestings);
       }
 
       // Serializer still handles class-based refs and value_field
@@ -1476,7 +1497,48 @@ export default class SpiceModel {
     }
   }
 
-  async fetchResults(args, query) {
+  correctColumns(columns, mappedNestings) {
+    // Preserve normal columns and only rewrite mapped alias dot-paths
+    // to the root mapped field on the base resource.
+    if (!columns || typeof columns !== "string") return columns;
+
+    const mappedAliasSet = new Set((mappedNestings || []).map((m) => m.alias));
+    const isMappedAlias = (alias) => !!this.props?.[alias]?.map;
+
+    const normalized = columns
+      .split(",")
+      .map((col) => col.trim())
+      .filter((col) => col !== "")
+      .map((col) => {
+        const cleanCol = col.replace(/`/g, "").trim();
+        const parts = cleanCol.split(".");
+        const firstSegment = parts[0];
+        const secondSegment = parts[1];
+
+        let mappedAlias = null;
+        if (isMappedAlias(firstSegment)) {
+          mappedAlias = firstSegment;
+        } else if (
+          firstSegment === this.type &&
+          secondSegment &&
+          isMappedAlias(secondSegment)
+        ) {
+          mappedAlias = secondSegment;
+        } else if (mappedAliasSet.has(firstSegment)) {
+          mappedAlias = firstSegment;
+        }
+
+        if (mappedAlias) {
+          return `\`${this.type}\`.\`${mappedAlias}\``;
+        }
+
+        return col;
+      });
+
+    return _.join(_.uniq(_.compact(normalized)), ",");
+  }
+
+  async fetchResults(args, query, mappedNestings) {
     // Profiling: use track() for proper async context forking
     const p = this[_ctx]?.profiler;
 
@@ -1492,9 +1554,13 @@ export default class SpiceModel {
           args._join,
         );
       } else {
+        let correctedColumns = this.correctColumns(
+          args.columns,
+          mappedNestings,
+        );
         let result = await this.database.search(
           this.type,
-          args.columns || "",
+          correctedColumns || args.columns || "",
           query || "",
           args.limit,
           args.offset,
@@ -1804,14 +1870,21 @@ export default class SpiceModel {
     if (isExempt || this[_level] + 1 < this[_mapping_dept]) {
       let ids = [];
       _.each(data, (result) => {
-        let value = [];
+        let value = result[source_property];
 
-        if (_.isArray(result[source_property])) {
-          value = result[source_property];
+        // Some list/select projections place fields under an empty-string key.
+        if (
+          (value === undefined || (_.isObject(value) && _.isEmpty(value))) &&
+          result[""] &&
+          result[""][source_property] !== undefined
+        ) {
+          value = result[""][source_property];
         }
 
-        if (_.isString(result[source_property])) {
-          value = [result[source_property]];
+        if (_.isString(value)) {
+          value = [value];
+        } else if (!_.isArray(value)) {
+          value = [];
         }
 
         // Extract IDs - handle both string IDs and objects with id property
@@ -1877,16 +1950,38 @@ export default class SpiceModel {
       );
 
       _.each(data, (result) => {
+        let sourceValue = result[source_property];
+        const hasFallbackSource =
+          result[""] && result[""][source_property] !== undefined;
+
         if (_.isString(result[store_property])) {
           result[store_property] = [result[store_property]];
         }
 
-        if (!_.has(result, source_property)) {
+        if (!_.has(result, source_property) && !hasFallbackSource) {
+          if (!_.isArray(result[store_property])) {
+            result[store_property] = [];
+          }
           result[source_property] = [];
           return;
         }
 
-        result[store_property] = _.map(result[source_property], (item) => {
+        // Match mapToObject behavior for projected rows that use result[""].
+        if (
+          (sourceValue === undefined ||
+            (_.isObject(sourceValue) && _.isEmpty(sourceValue))) &&
+          hasFallbackSource
+        ) {
+          sourceValue = result[""][source_property];
+        }
+
+        if (_.isString(sourceValue)) {
+          sourceValue = [sourceValue];
+        } else if (!_.isArray(sourceValue)) {
+          sourceValue = [];
+        }
+
+        result[store_property] = _.map(sourceValue, (item) => {
           // Get the ID to match - either a string ID or the id property of an object
           const itemId =
             _.isString(item) ? item
@@ -2028,6 +2123,7 @@ export default class SpiceModel {
                     if (!this.isFieldInColumns(i, columns)) {
                       return data;
                     }
+
                     return await this.mapToObjectArray(
                       data,
                       _.isString(properties[i].map.reference) ?

package/tests/models/SpiceModel.test.js

@@ -17,6 +17,7 @@
 const { createTestModel, seedDatabase, clearDatabase } = require('../helpers/modelFactory');
 const { expectValidIdsOnly, expectUniqueIds, expectNoEmptyIdCalls } = require('../helpers/assertions');
 const { emptyIdCases, sampleDbResults, relationshipData, duplicateIdData, generateLargeDataset } = require('../fixtures/testData');
+const SpiceModel = require('../../src/models/SpiceModel').default;
 
 describe('SpiceModel - Critical Fixes for Empty/Null Values', () => {
 
@@ -167,6 +168,104 @@ describe('SpiceModel - Critical Fixes for Empty/Null Values', () => {
       expect(result.name).toBe('Alice');
       expect(result.email).toBe('alice@example.com');
     });
+
+    test('should keep deep dot-notation under the first nested segment', () => {
+      const rows = [{
+        id: 'user-1',
+        first_name: '',
+        committee_votes: [
+          {
+            member: {
+              first_name: 'Ada',
+              last_name: 'Lovelace'
+            },
+            value: 'yes'
+          }
+        ]
+      }];
+
+      const [result] = model.filterResultsByColumns(
+        rows,
+        '`committee_votes`.`member`.`first_name`'
+      );
+
+      expect(result.first_name).toBeUndefined();
+      expect(result.committee_votes).toBeDefined();
+      expect(result.committee_votes[0].member.first_name).toBe('Ada');
+    });
+
+    test('should remove base model prefix before selecting nested segment', () => {
+      const rows = [{
+        id: 'user-1',
+        group: {
+          name: 'Admins'
+        }
+      }];
+
+      const [result] = model.filterResultsByColumns(
+        rows,
+        '`user`.`group`.`name`'
+      );
+
+      expect(result.group).toBeDefined();
+      expect(result.group.name).toBe('Admins');
+    });
+
+    test('should keep mixed scalar and mapped columns without empty select slots', () => {
+      const applicationModel = createTestModel({ type: 'application' });
+      const requestedColumns = 'meta().id,dependents,dd_assessment_notes,ceo_assessment_notes,first_name,title,last_name,project,`committee_votes`.`member`,`committee_votes`.`date_of_vote`,`committee_votes`.`vote`,`committee_votes`.`rejection_reasons`,`committee_votes`.`vote_justification`,`committee_votes`.`comments`,`committee_votes`.`application`,control_number,full_name,application_type,stage,committee_submission_date,votes_casted';
+
+      const corrected = applicationModel.correctColumns(
+        requestedColumns,
+        [{ alias: 'committee_votes' }]
+      );
+
+      const selectedColumns = corrected
+        .split(',')
+        .map((item) => item.trim());
+
+      expect(selectedColumns.every((item) => item !== '')).toBe(true);
+      expect(selectedColumns).toContain('dependents');
+      expect(selectedColumns).toContain('first_name');
+      expect(selectedColumns).toContain('`application`.`committee_votes`');
+      expect(selectedColumns).toContain('meta().id');
+    });
+
+    test('should collapse deep mapped paths even without mapped nestings', () => {
+      expect(
+        SpiceModel.prototype.correctColumns.call(
+          {
+            type: 'application',
+            props: {
+              dependents: {
+                map: {
+                  reference: 'dependent'
+                }
+              }
+            }
+          },
+          'dependents.passports.holder',
+          [],
+        )
+      ).toBe('`application`.`dependents`');
+
+      expect(
+        SpiceModel.prototype.correctColumns.call(
+          {
+            type: 'application',
+            props: {
+              dependents: {
+                map: {
+                  reference: 'dependent'
+                }
+              }
+            }
+          },
+          '`application`.`dependents`.`passports`.`holder`',
+          [],
+        )
+      ).toBe('`application`.`dependents`');
+    });
   });
 
   describe('Fix #4-6: mapToObject() - Strict Checks and Deduplication', () => {
@@ -258,6 +357,63 @@ describe('SpiceModel - Critical Fixes for Empty/Null Values', () => {
     });
   });
 
+  describe('Fix #8: mapToObjectArray() - Empty Key Projection Fallback', () => {
+    let model;
+
+    beforeEach(() => {
+      model = createTestModel({ type: 'user' });
+    });
+
+    afterEach(() => {
+      clearDatabase(model);
+    });
+
+    test('should map array relationships when source field is under empty-string key', async () => {
+      let capturedIds = [];
+      let capturedColumns = [];
+
+      class FakeRelatedModel {
+        async getMulti({ ids, columns }) {
+          capturedIds = ids;
+          capturedColumns = columns;
+          return [
+            { id: 'group-1', type: 'group', name: 'Admins' },
+            { id: 'group-2', type: 'group', name: 'Editors' }
+          ];
+        }
+      }
+
+      const sourceRows = [
+        {
+          id: 'user-1',
+          type: 'user',
+          '': {
+            groups: ['group-1', 'group-2']
+          }
+        }
+      ];
+
+      const mapped = await model.mapToObjectArray(
+        sourceRows,
+        FakeRelatedModel,
+        'groups',
+        'groups',
+        {},
+        {},
+        'read',
+        3,
+        0,
+        'groups.name'
+      );
+
+      expect(capturedIds).toEqual(['group-1', 'group-2']);
+      expect(capturedColumns).toEqual(['name']);
+      expect(mapped[0].groups).toHaveLength(2);
+      expect(mapped[0].groups[0].name).toBe('Admins');
+      expect(mapped[0].groups[1].name).toBe('Editors');
+    });
+  });
+
   describe('Fix #7: Strict Equality in ID Matching', () => {
     let model;