spice-js 2.7.29 → 2.7.31

package/tests/models/SpiceModel.mapping-depth.test.js

@@ -0,0 +1,320 @@
+const { createTestModel, seedDatabase } = require('../helpers/modelFactory');
+
+describe('SpiceModel type-specific mapping depth', () => {
+  function createRelatedModel(records, capture) {
+    return class RelatedModel {
+      constructor(args) {
+        capture.constructorArgs.push(args);
+      }
+
+      async getMulti(args) {
+        const { ids } = args;
+        capture.getMultiArgs.push(args);
+        capture.getMultiIds.push(ids);
+        return records.filter((record) => ids.includes(record.id));
+      }
+    };
+  }
+
+  function createMappedModel(args = {}) {
+    const scalarCapture = {
+      constructorArgs: [],
+      getMultiArgs: [],
+      getMultiIds: [],
+    };
+    const arrayCapture = {
+      constructorArgs: [],
+      getMultiArgs: [],
+      getMultiIds: [],
+    };
+    const ScalarModel = createRelatedModel(
+      [{ id: 'group-1', name: 'Administrators' }],
+      scalarCapture
+    );
+    const ArrayModel = createRelatedModel(
+      [
+        { id: 'child-1', name: 'First' },
+        { id: 'child-2', name: 'Second' }
+      ],
+      arrayCapture
+    );
+    const model = createTestModel({
+      type: 'parent',
+      args,
+      props: {
+        group: {
+          type: 'string',
+          map: { type: 'model', reference: ScalarModel }
+        },
+        children: {
+          type: 'array',
+          map: { type: 'model', reference: ArrayModel }
+        }
+      }
+    });
+    seedDatabase(model, {
+      id: 'parent-1',
+      type: 'parent',
+      group: 'group-1',
+      children: ['child-1', 'child-2']
+    });
+    return { model, scalarCapture, arrayCapture };
+  }
+
+  function createConcurrencyModel(mappingConcurrency, extraArgs = {}) {
+    const stats = { active: 0, maxActive: 0 };
+    class RelatedModel {
+      async getMulti({ ids }) {
+        stats.active += 1;
+        stats.maxActive = Math.max(stats.maxActive, stats.active);
+        await new Promise((resolve) => setImmediate(resolve));
+        stats.active -= 1;
+        return ids.map((id) => ({ id, name: id }));
+      }
+    }
+
+    const props = {};
+    const record = { id: 'parent-concurrent', type: 'parent' };
+    for (let index = 1; index <= 3; index += 1) {
+      const field = `relationship_${index}`;
+      props[field] = {
+        type: 'string',
+        map: { type: 'model', reference: RelatedModel }
+      };
+      record[field] = `related-${index}`;
+    }
+
+    const model = createTestModel({
+      type: 'parent',
+      args: {
+        ...extraArgs,
+        ...(mappingConcurrency ? { mapping_concurrency: mappingConcurrency } : {})
+      },
+      props
+    });
+    seedDatabase(model, record);
+    return { model, stats };
+  }
+
+  test('uses scalar depth 1 and array depth 3 from the request profile', async () => {
+    const ctx = {
+      state: {
+        read_profile: {
+          mapping_dept_scalar: 1,
+          mapping_dept_array: 3
+        }
+      }
+    };
+    const { model, scalarCapture, arrayCapture } = createMappedModel({ ctx });
+
+    const result = await model.get({ id: 'parent-1' });
+
+    expect(result.group).toBe('group-1');
+    expect(result.children).toEqual([
+      expect.objectContaining({ id: 'child-1', name: 'First' }),
+      expect.objectContaining({ id: 'child-2', name: 'Second' })
+    ]);
+    expect(scalarCapture.getMultiIds).toEqual([]);
+    expect(arrayCapture.getMultiIds).toEqual([['child-1', 'child-2']]);
+  });
+
+  test('keeps legacy mapping_dept behavior for both relationship types', async () => {
+    const { model, scalarCapture, arrayCapture } = createMappedModel({
+      mapping_dept: 1
+    });
+
+    const result = await model.get({ id: 'parent-1' });
+
+    expect(result.group).toBe('group-1');
+    expect(result.children).toEqual(['child-1', 'child-2']);
+    expect(scalarCapture.getMultiIds).toEqual([]);
+    expect(arrayCapture.getMultiIds).toEqual([]);
+  });
+
+  test('explicit read arguments override the request profile independently', async () => {
+    const ctx = {
+      state: {
+        read_profile: {
+          mapping_dept_scalar: 1,
+          mapping_dept_array: 1
+        }
+      }
+    };
+    const { model } = createMappedModel({ ctx });
+
+    const result = await model.get({
+      id: 'parent-1',
+      mapping_dept_scalar: 3,
+      mapping_dept_array: 3
+    });
+
+    expect(result.group).toEqual(
+      expect.objectContaining({ id: 'group-1', name: 'Administrators' })
+    );
+    expect(result.children).toHaveLength(2);
+  });
+
+  test('mapping depth exemptions continue to expand scalar paths', async () => {
+    const { model, scalarCapture } = createMappedModel({
+      mapping_dept_scalar: 1,
+      mapping_dept_array: 3,
+      mapping_dept_exempt: ['group']
+    });
+
+    const result = await model.get({ id: 'parent-1' });
+
+    expect(result.group).toEqual(
+      expect.objectContaining({ id: 'group-1', name: 'Administrators' })
+    );
+    expect(scalarCapture.getMultiIds).toEqual([['group-1']]);
+  });
+
+  test('propagates both depths to related model instances', async () => {
+    const { model, arrayCapture } = createMappedModel({
+      mapping_dept_scalar: 1,
+      mapping_dept_array: 3,
+      mapping_concurrency: 6
+    });
+
+    await model.getMulti({ ids: ['parent-1'] });
+
+    expect(arrayCapture.constructorArgs[0]).toEqual(
+      expect.objectContaining({
+        mapping_dept_scalar: 1,
+        mapping_dept_array: 3,
+        mapping_concurrency: 6,
+        _level: 1
+      })
+    );
+  });
+
+  test('runs independent relationship maps with bounded concurrency', async () => {
+    const { model, stats } = createConcurrencyModel(2);
+
+    const result = await model.get({ id: 'parent-concurrent' });
+
+    expect(stats.maxActive).toBe(2);
+    expect(result.relationship_1).toEqual(
+      expect.objectContaining({ id: 'related-1' })
+    );
+    expect(result.relationship_3).toEqual(
+      expect.objectContaining({ id: 'related-3' })
+    );
+  });
+
+  test('keeps relationship maps sequential when concurrency is not enabled', async () => {
+    const { model, stats } = createConcurrencyModel();
+
+    await model.get({ id: 'parent-concurrent' });
+
+    expect(stats.maxActive).toBe(1);
+  });
+
+  test('keeps nested relationship maps sequential to avoid recursive slot use', async () => {
+    const { model, stats } = createConcurrencyModel(2, { _level: 1 });
+
+    await model.get({ id: 'parent-concurrent' });
+
+    expect(stats.maxActive).toBe(1);
+  });
+
+  test('profiles concurrent groups and mapping slot pressure', async () => {
+    const calls = [];
+    const profiler = {
+      track: jest.fn(async (name, execute, metadata) => {
+        calls.push({ name, metadata });
+        return await execute();
+      })
+    };
+    const { model } = createConcurrencyModel(2, { ctx: { profiler } });
+
+    await model.get({ id: 'parent-concurrent' });
+
+    expect(calls).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: 'parent.map.concurrent',
+          metadata: expect.objectContaining({
+            map_count: 3,
+            request_limit: 2
+          })
+        }),
+        expect.objectContaining({
+          name: 'parent.map.concurrent.relationship_1',
+          metadata: expect.objectContaining({
+            request_limit: 2,
+            active_request_mappings: expect.any(Number),
+            active_global_mappings: expect.any(Number),
+            request_queue_wait_ms: expect.any(Number),
+            global_queue_wait_ms: expect.any(Number)
+          })
+        })
+      ])
+    );
+  });
+
+  test('skips serialization for mapped child reads when requested by the profile', async () => {
+    const ctx = {
+      state: {
+        read_profile: {
+          mapping_dept_scalar: 2,
+          mapping_dept_array: 3,
+          skip_mapped_serialization: true
+        }
+      }
+    };
+    const { model, scalarCapture, arrayCapture } = createMappedModel({ ctx });
+
+    const result = await model.get({ id: 'parent-1' });
+
+    expect(result.group).toEqual(
+      expect.objectContaining({ id: 'group-1', name: 'Administrators' })
+    );
+    expect(result.children).toHaveLength(2);
+    expect(scalarCapture.getMultiArgs[0]).toEqual(
+      expect.objectContaining({ skip_hooks: true, skip_read_serialize: true })
+    );
+    expect(arrayCapture.getMultiArgs[0]).toEqual(
+      expect.objectContaining({ skip_hooks: true, skip_read_serialize: true })
+    );
+  });
+
+  test('does not apply the request read profile to write serialization', async () => {
+    const capture = { constructorArgs: [], getMultiArgs: [], getMultiIds: [] };
+    const RelatedModel = createRelatedModel(
+      [{ id: 'group-1', name: 'Administrators' }],
+      capture
+    );
+    const model = createTestModel({
+      type: 'parent',
+      args: {
+        ctx: {
+          state: {
+            read_profile: {
+              mapping_dept_scalar: 1,
+              mapping_dept_array: 1
+            }
+          }
+        }
+      },
+      props: {
+        group: {
+          type: 'string',
+          map: { type: 'model', reference: RelatedModel, when: 'write' }
+        }
+      }
+    });
+
+    const result = await model.do_serialize(
+      { id: 'parent-1', group: 'group-1' },
+      'write',
+      {},
+      {}
+    );
+
+    expect(result.group).toEqual(
+      expect.objectContaining({ id: 'group-1', name: 'Administrators' })
+    );
+    expect(capture.getMultiIds).toEqual([['group-1']]);
+  });
+});