spice-js 2.7.17 → 2.7.19

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;