@auto-engineer/narrative 0.21.0 → 0.22.0

package/package.json

@@ -23,9 +23,9 @@
     "typescript": "^5.9.2",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.3",
-    "@auto-engineer/file-store": "0.21.0",
-    "@auto-engineer/id": "0.21.0",
-    "@auto-engineer/message-bus": "0.21.0"
+    "@auto-engineer/id": "0.22.0",
+    "@auto-engineer/message-bus": "0.22.0",
+    "@auto-engineer/file-store": "0.22.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -35,7 +35,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.21.0",
+  "version": "0.22.0",
   "scripts": {
     "build": "tsx scripts/build.ts",
     "test": "vitest run --reporter=dot",

package/src/getNarratives.specs.ts

@@ -4,7 +4,7 @@ import { InMemoryFileStore } from '@auto-engineer/file-store';
 import { NodeFileStore } from '@auto-engineer/file-store/node';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { getNarratives } from './getNarratives';
-import { type DataSource, type Example, type Model, modelToNarrative, type Narrative, type QuerySlice } from './index';
+import { type Example, type Model, modelToNarrative, type Narrative, type QuerySlice } from './index';
 import { modelSchema } from './schema';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -112,12 +112,12 @@ describe('getNarratives', (_mode) => {
         /query items\(\$itemId: String!\) {\s+items\(itemId: \$itemId\) {\s+id\s+description\s+}/,
       );
 
-      const data = viewItemSlice?.server?.data as DataSource[] | undefined;
-      if (!data || !Array.isArray(data)) throw new Error('No data found in view items slice');
+      const data = viewItemSlice?.server?.data;
+      if (!data || !Array.isArray(data.items)) throw new Error('No data found in view items slice');
 
-      expect(data).toHaveLength(1);
-      expect(data[0].target).toMatchObject({ type: 'State', name: 'items' });
-      expect(data[0].origin).toMatchObject({ name: 'ItemsProjection', type: 'projection' });
+      expect(data.items).toHaveLength(1);
+      expect(data.items[0].target).toMatchObject({ type: 'State', name: 'items' });
+      expect(data.items[0].origin).toMatchObject({ name: 'ItemsProjection', type: 'projection' });
 
       const specs = viewItemSlice?.server?.specs;
       if (specs == null || specs.length === 0 || specs[0].feature === '')
@@ -224,7 +224,7 @@ describe('getNarratives', (_mode) => {
       f.slices.some((s) => {
         if (s.type === 'command' || s.type === 'query') {
           return (
-            s.server.data?.some(
+            s.server.data?.items?.some(
               (d) =>
                 ('destination' in d && d.destination?.type === 'integration') ||
                 ('origin' in d && d.origin?.type === 'integration'),
@@ -1494,17 +1494,17 @@ flow('Projection Test', () => {
 
     if (summarySlice?.type !== 'query') return;
 
-    const data = summarySlice.server.data as DataSource[] | undefined;
+    const data = summarySlice.server.data;
     expect(data).toBeDefined();
-    expect(data).toHaveLength(1);
+    expect(data?.items).toHaveLength(1);
 
-    expect(data?.[0].origin).toMatchObject({
+    expect(data?.items?.[0].origin).toMatchObject({
       type: 'projection',
       name: 'TodoSummary',
       singleton: true,
     });
 
-    expect(data?.[0].origin).not.toHaveProperty('idField');
+    expect(data?.items?.[0].origin).not.toHaveProperty('idField');
   });
 
   it('should generate correct origin for regular projection with single idField', async () => {
@@ -1546,17 +1546,17 @@ flow('Projection Test', () => {
 
     if (todoSlice?.type !== 'query') return;
 
-    const data = todoSlice.server.data as DataSource[] | undefined;
+    const data = todoSlice.server.data;
     expect(data).toBeDefined();
-    expect(data).toHaveLength(1);
+    expect(data?.items).toHaveLength(1);
 
-    expect(data?.[0].origin).toMatchObject({
+    expect(data?.items?.[0].origin).toMatchObject({
       type: 'projection',
       name: 'Todos',
       idField: 'todoId',
     });
 
-    expect(data?.[0].origin).not.toHaveProperty('singleton');
+    expect(data?.items?.[0].origin).not.toHaveProperty('singleton');
   });
 
   it('should generate correct origin for composite projection with multiple idFields', async () => {
@@ -1598,17 +1598,17 @@ flow('Projection Test', () => {
 
     if (userProjectSlice?.type !== 'query') return;
 
-    const data = userProjectSlice.server.data as DataSource[] | undefined;
+    const data = userProjectSlice.server.data;
     expect(data).toBeDefined();
-    expect(data).toHaveLength(1);
+    expect(data?.items).toHaveLength(1);
 
-    expect(data?.[0].origin).toMatchObject({
+    expect(data?.items?.[0].origin).toMatchObject({
       type: 'projection',
       name: 'UserProjects',
       idField: ['userId', 'projectId'],
     });
 
-    expect(data?.[0].origin).not.toHaveProperty('singleton');
+    expect(data?.items?.[0].origin).not.toHaveProperty('singleton');
   });
 
   it('should validate all three projection patterns together', async () => {
@@ -1684,8 +1684,8 @@ flow('All Projection Patterns', () => {
 
     const summarySlice = projectionFlow.slices.find((s) => s.name === 'views summary');
     if (summarySlice?.type === 'query') {
-      const data = summarySlice.server.data as DataSource[] | undefined;
-      expect(data?.[0].origin).toMatchObject({
+      const data = summarySlice.server.data;
+      expect(data?.items?.[0].origin).toMatchObject({
         type: 'projection',
         name: 'TodoSummary',
         singleton: true,
@@ -1694,8 +1694,8 @@ flow('All Projection Patterns', () => {
 
     const todoSlice = projectionFlow.slices.find((s) => s.name === 'views todo');
     if (todoSlice?.type === 'query') {
-      const data = todoSlice.server.data as DataSource[] | undefined;
-      expect(data?.[0].origin).toMatchObject({
+      const data = todoSlice.server.data;
+      expect(data?.items?.[0].origin).toMatchObject({
         type: 'projection',
         name: 'Todos',
         idField: 'todoId',
@@ -1704,8 +1704,8 @@ flow('All Projection Patterns', () => {
 
     const userProjectSlice = projectionFlow.slices.find((s) => s.name === 'views user project todos');
     if (userProjectSlice?.type === 'query') {
-      const data = userProjectSlice.server.data as DataSource[] | undefined;
-      expect(data?.[0].origin).toMatchObject({
+      const data = userProjectSlice.server.data;
+      expect(data?.items?.[0].origin).toMatchObject({
         type: 'projection',
         name: 'UserProjectTodos',
         idField: ['userId', 'projectId'],
@@ -1770,15 +1770,15 @@ flow('Data Item IDs', () => {
     const commandSlice = dataIdsFlow.slices.find((s) => s.name === 'places order');
     if (commandSlice?.type === 'command') {
       const sinkData = commandSlice.server.data;
-      expect(sinkData).toHaveLength(1);
-      expect(sinkData?.[0].id).toBe('SINK-001');
+      expect(sinkData?.items).toHaveLength(1);
+      expect(sinkData?.items?.[0].id).toBe('SINK-001');
     }
 
     const querySlice = dataIdsFlow.slices.find((s) => s.name === 'views order status');
     if (querySlice?.type === 'query') {
-      const sourceData = querySlice.server.data as DataSource[] | undefined;
-      expect(sourceData).toHaveLength(1);
-      expect(sourceData?.[0].id).toBe('SOURCE-001');
+      const sourceData = querySlice.server.data;
+      expect(sourceData?.items).toHaveLength(1);
+      expect(sourceData?.items?.[0].id).toBe('SOURCE-001');
     }
   });
 });

package/src/id/addAutoIds.specs.ts

@@ -688,12 +688,14 @@ describe('addAutoIds', () => {
                 server: {
                   description: 'Test server',
                   specs: [],
-                  data: [
-                    {
-                      target: { type: 'Event', name: 'TestEvent' },
-                      destination: { type: 'stream', pattern: 'test-stream' },
-                    },
-                  ],
+                  data: {
+                    items: [
+                      {
+                        target: { type: 'Event', name: 'TestEvent' },
+                        destination: { type: 'stream', pattern: 'test-stream' },
+                      },
+                    ],
+                  },
                 },
               },
             ],
@@ -708,7 +710,8 @@ describe('addAutoIds', () => {
       const slice = result.narratives[0].slices[0];
 
       if ('server' in slice && slice.server?.data) {
-        expect(slice.server.data[0].id).toMatch(AUTO_ID_REGEX);
+        expect(slice.server.data.id).toMatch(AUTO_ID_REGEX);
+        expect(slice.server.data.items[0].id).toMatch(AUTO_ID_REGEX);
       }
     });
 
@@ -728,12 +731,14 @@ describe('addAutoIds', () => {
                 server: {
                   description: 'Test server',
                   specs: [],
-                  data: [
-                    {
-                      target: { type: 'State', name: 'TestState' },
-                      origin: { type: 'projection', name: 'TestProjection' },
-                    },
-                  ],
+                  data: {
+                    items: [
+                      {
+                        target: { type: 'State', name: 'TestState' },
+                        origin: { type: 'projection', name: 'TestProjection' },
+                      },
+                    ],
+                  },
                 },
               },
             ],
@@ -748,7 +753,8 @@ describe('addAutoIds', () => {
       const slice = result.narratives[0].slices[0];
 
       if ('server' in slice && slice.server?.data) {
-        expect(slice.server.data[0].id).toMatch(AUTO_ID_REGEX);
+        expect(slice.server.data.id).toMatch(AUTO_ID_REGEX);
+        expect(slice.server.data.items[0].id).toMatch(AUTO_ID_REGEX);
       }
     });
 
@@ -768,17 +774,19 @@ describe('addAutoIds', () => {
                 server: {
                   description: 'Test server',
                   specs: [],
-                  data: [
-                    {
-                      id: 'SINK-001',
-                      target: { type: 'Command', name: 'TestCommand' },
-                      destination: { type: 'stream', pattern: 'test-stream' },
-                      _withState: {
-                        target: { type: 'State', name: 'TestState' },
-                        origin: { type: 'projection', name: 'TestProjection' },
+                  data: {
+                    items: [
+                      {
+                        id: 'SINK-001',
+                        target: { type: 'Command', name: 'TestCommand' },
+                        destination: { type: 'stream', pattern: 'test-stream' },
+                        _withState: {
+                          target: { type: 'State', name: 'TestState' },
+                          origin: { type: 'projection', name: 'TestProjection' },
+                        },
                       },
-                    },
-                  ],
+                    ],
+                  },
                 },
               },
             ],
@@ -793,7 +801,7 @@ describe('addAutoIds', () => {
       const slice = result.narratives[0].slices[0];
 
       if ('server' in slice && slice.server?.data) {
-        const sink = slice.server.data[0];
+        const sink = slice.server.data.items[0];
         expect(sink.id).toBe('SINK-001');
         if ('destination' in sink && sink._withState) {
           expect(sink._withState.id).toMatch(AUTO_ID_REGEX);
@@ -815,18 +823,21 @@ describe('addAutoIds', () => {
                 id: 'SLICE-001',
                 server: {
                   specs: [],
-                  data: [
-                    {
-                      id: 'EXISTING-SINK-001',
-                      target: { type: 'Event', name: 'TestEvent' },
-                      destination: { type: 'stream', pattern: 'test-stream' },
-                    },
-                    {
-                      id: 'EXISTING-SOURCE-001',
-                      target: { type: 'State', name: 'TestState' },
-                      origin: { type: 'projection', name: 'TestProjection' },
-                    },
-                  ],
+                  data: {
+                    id: 'EXISTING-DATA-001',
+                    items: [
+                      {
+                        id: 'EXISTING-SINK-001',
+                        target: { type: 'Event', name: 'TestEvent' },
+                        destination: { type: 'stream', pattern: 'test-stream' },
+                      },
+                      {
+                        id: 'EXISTING-SOURCE-001',
+                        target: { type: 'State', name: 'TestState' },
+                        origin: { type: 'projection', name: 'TestProjection' },
+                      },
+                    ],
+                  },
                 },
               },
             ],
@@ -841,8 +852,9 @@ describe('addAutoIds', () => {
       const slice = result.narratives[0].slices[0];
 
       if ('server' in slice && slice.server?.data) {
-        expect(slice.server.data[0].id).toBe('EXISTING-SINK-001');
-        expect(slice.server.data[1].id).toBe('EXISTING-SOURCE-001');
+        expect(slice.server.data.id).toBe('EXISTING-DATA-001');
+        expect(slice.server.data.items[0].id).toBe('EXISTING-SINK-001');
+        expect(slice.server.data.items[1].id).toBe('EXISTING-SOURCE-001');
       }
     });
 
@@ -862,12 +874,14 @@ describe('addAutoIds', () => {
                 server: {
                   description: 'Test server',
                   specs: [],
-                  data: [
-                    {
-                      target: { type: 'Event', name: 'TestEvent' },
-                      destination: { type: 'stream', pattern: 'test-stream' },
-                    },
-                  ],
+                  data: {
+                    items: [
+                      {
+                        target: { type: 'Event', name: 'TestEvent' },
+                        destination: { type: 'stream', pattern: 'test-stream' },
+                      },
+                    ],
+                  },
                 },
               },
             ],
@@ -882,7 +896,8 @@ describe('addAutoIds', () => {
       addAutoIds(model);
 
       if ('server' in originalSlice && originalSlice.server?.data) {
-        expect(originalSlice.server.data[0].id).toBeUndefined();
+        expect(originalSlice.server.data.id).toBeUndefined();
+        expect(originalSlice.server.data.items[0].id).toBeUndefined();
       }
     });
 
@@ -900,20 +915,22 @@ describe('addAutoIds', () => {
                 id: 'SLICE-001',
                 server: {
                   specs: [],
-                  data: [
-                    {
-                      target: { type: 'Event', name: 'Event1' },
-                      destination: { type: 'stream', pattern: 'stream1' },
-                    },
-                    {
-                      target: { type: 'Event', name: 'Event2' },
-                      destination: { type: 'stream', pattern: 'stream2' },
-                    },
-                    {
-                      target: { type: 'State', name: 'State1' },
-                      origin: { type: 'projection', name: 'Proj1' },
-                    },
-                  ],
+                  data: {
+                    items: [
+                      {
+                        target: { type: 'Event', name: 'Event1' },
+                        destination: { type: 'stream', pattern: 'stream1' },
+                      },
+                      {
+                        target: { type: 'Event', name: 'Event2' },
+                        destination: { type: 'stream', pattern: 'stream2' },
+                      },
+                      {
+                        target: { type: 'State', name: 'State1' },
+                        origin: { type: 'projection', name: 'Proj1' },
+                      },
+                    ],
+                  },
                 },
               },
             ],
@@ -928,7 +945,8 @@ describe('addAutoIds', () => {
       const slice = result.narratives[0].slices[0];
 
       if ('server' in slice && slice.server?.data) {
-        const ids = slice.server.data.map((d) => d.id);
+        expect(slice.server.data.id).toMatch(AUTO_ID_REGEX);
+        const ids = slice.server.data.items.map((d) => d.id);
         expect(ids[0]).toMatch(AUTO_ID_REGEX);
         expect(ids[1]).toMatch(AUTO_ID_REGEX);
         expect(ids[2]).toMatch(AUTO_ID_REGEX);

package/src/id/addAutoIds.ts

@@ -78,19 +78,25 @@ function processClientSpecs(slice: Slice): Slice {
 }
 
 function processDataItems(slice: Slice): Slice {
-  if (!('server' in slice) || !slice.server?.data || !Array.isArray(slice.server.data)) return slice;
+  if (!('server' in slice) || !slice.server?.data) return slice;
 
   const modifiedSlice = structuredClone(slice);
-  if ('server' in modifiedSlice && modifiedSlice.server?.data && Array.isArray(modifiedSlice.server.data)) {
-    modifiedSlice.server.data = modifiedSlice.server.data.map((item) => {
-      const itemCopy = { ...item };
-      ensureId(itemCopy);
-      if ('destination' in itemCopy && itemCopy._withState) {
-        itemCopy._withState = { ...itemCopy._withState };
-        ensureId(itemCopy._withState);
-      }
-      return itemCopy;
-    });
+  if ('server' in modifiedSlice && modifiedSlice.server?.data) {
+    // Ensure the data wrapper has an ID
+    ensureId(modifiedSlice.server.data);
+
+    // Process items array if it exists
+    if (Array.isArray(modifiedSlice.server.data.items)) {
+      modifiedSlice.server.data.items = modifiedSlice.server.data.items.map((item) => {
+        const itemCopy = { ...item };
+        ensureId(itemCopy);
+        if ('destination' in itemCopy && itemCopy._withState) {
+          itemCopy._withState = { ...itemCopy._withState };
+          ensureId(itemCopy._withState);
+        }
+        return itemCopy;
+      });
+    }
   }
   return modifiedSlice;
 }

package/src/id/hasAllIds.specs.ts

@@ -452,7 +452,7 @@ describe('hasAllIds', () => {
   });
 
   describe('data item ID validation', () => {
-    it('should return false when data sink is missing an ID', () => {
+    it('should return false when data wrapper is missing an ID', () => {
       const model: Model = {
         variant: 'specs',
         narratives: [
@@ -468,13 +468,52 @@ describe('hasAllIds', () => {
                 server: {
                   description: 'Test server',
                   specs: [],
-                  data: [
-                    {
-                      __type: 'sink',
-                      target: { type: 'Event', name: 'TestEvent' },
-                      destination: { type: 'stream', pattern: 'test-stream' },
-                    },
-                  ],
+                  data: {
+                    items: [
+                      {
+                        id: 'SINK-001',
+                        target: { type: 'Event', name: 'TestEvent' },
+                        destination: { type: 'stream', pattern: 'test-stream' },
+                      },
+                    ],
+                  },
+                },
+              },
+            ],
+          },
+        ],
+        messages: [],
+        integrations: [],
+        modules: [],
+      };
+      expect(hasAllIds(model)).toBe(false);
+    });
+
+    it('should return false when data sink item is missing an ID', () => {
+      const model: Model = {
+        variant: 'specs',
+        narratives: [
+          {
+            name: 'Test Flow',
+            id: 'FLOW-001',
+            slices: [
+              {
+                type: 'command',
+                name: 'Test slice',
+                id: 'SLICE-001',
+                client: { specs: [] },
+                server: {
+                  description: 'Test server',
+                  specs: [],
+                  data: {
+                    id: 'DATA-001',
+                    items: [
+                      {
+                        target: { type: 'Event', name: 'TestEvent' },
+                        destination: { type: 'stream', pattern: 'test-stream' },
+                      },
+                    ],
+                  },
                 },
               },
             ],
@@ -487,7 +526,7 @@ describe('hasAllIds', () => {
       expect(hasAllIds(model)).toBe(false);
     });
 
-    it('should return false when data source is missing an ID', () => {
+    it('should return false when data source item is missing an ID', () => {
       const model: Model = {
         variant: 'specs',
         narratives: [
@@ -503,13 +542,15 @@ describe('hasAllIds', () => {
                 server: {
                   description: 'Test server',
                   specs: [],
-                  data: [
-                    {
-                      __type: 'source',
-                      target: { type: 'State', name: 'TestState' },
-                      origin: { type: 'projection', name: 'TestProjection' },
-                    },
-                  ],
+                  data: {
+                    id: 'DATA-001',
+                    items: [
+                      {
+                        target: { type: 'State', name: 'TestState' },
+                        origin: { type: 'projection', name: 'TestProjection' },
+                      },
+                    ],
+                  },
                 },
               },
             ],
@@ -538,18 +579,20 @@ describe('hasAllIds', () => {
                 server: {
                   description: 'Test server',
                   specs: [],
-                  data: [
-                    {
-                      __type: 'sink',
-                      id: 'SINK-001',
-                      target: { type: 'Command', name: 'TestCommand' },
-                      destination: { type: 'stream', pattern: 'test-stream' },
-                      _withState: {
-                        target: { type: 'State', name: 'TestState' },
-                        origin: { type: 'projection', name: 'TestProjection' },
+                  data: {
+                    id: 'DATA-001',
+                    items: [
+                      {
+                        id: 'SINK-001',
+                        target: { type: 'Command', name: 'TestCommand' },
+                        destination: { type: 'stream', pattern: 'test-stream' },
+                        _withState: {
+                          target: { type: 'State', name: 'TestState' },
+                          origin: { type: 'projection', name: 'TestProjection' },
+                        },
                       },
-                    },
-                  ],
+                    ],
+                  },
                 },
               },
             ],
@@ -578,20 +621,21 @@ describe('hasAllIds', () => {
                 server: {
                   description: 'Test server',
                   specs: [],
-                  data: [
-                    {
-                      __type: 'sink',
-                      id: 'SINK-001',
-                      target: { type: 'Event', name: 'TestEvent' },
-                      destination: { type: 'stream', pattern: 'test-stream' },
-                    },
-                    {
-                      __type: 'source',
-                      id: 'SOURCE-001',
-                      target: { type: 'State', name: 'TestState' },
-                      origin: { type: 'projection', name: 'TestProjection' },
-                    },
-                  ],
+                  data: {
+                    id: 'DATA-001',
+                    items: [
+                      {
+                        id: 'SINK-001',
+                        target: { type: 'Event', name: 'TestEvent' },
+                        destination: { type: 'stream', pattern: 'test-stream' },
+                      },
+                      {
+                        id: 'SOURCE-001',
+                        target: { type: 'State', name: 'TestState' },
+                        origin: { type: 'projection', name: 'TestProjection' },
+                      },
+                    ],
+                  },
                 },
               },
             ],
@@ -620,19 +664,21 @@ describe('hasAllIds', () => {
                 server: {
                   description: 'Test server',
                   specs: [],
-                  data: [
-                    {
-                      __type: 'sink',
-                      id: 'SINK-001',
-                      target: { type: 'Command', name: 'TestCommand' },
-                      destination: { type: 'stream', pattern: 'test-stream' },
-                      _withState: {
-                        id: 'SOURCE-001',
-                        target: { type: 'State', name: 'TestState' },
-                        origin: { type: 'projection', name: 'TestProjection' },
+                  data: {
+                    id: 'DATA-001',
+                    items: [
+                      {
+                        id: 'SINK-001',
+                        target: { type: 'Command', name: 'TestCommand' },
+                        destination: { type: 'stream', pattern: 'test-stream' },
+                        _withState: {
+                          id: 'SOURCE-001',
+                          target: { type: 'State', name: 'TestState' },
+                          origin: { type: 'projection', name: 'TestProjection' },
+                        },
                       },
-                    },
-                  ],
+                    ],
+                  },
                 },
               },
             ],
@@ -645,7 +691,7 @@ describe('hasAllIds', () => {
       expect(hasAllIds(model)).toBe(true);
     });
 
-    it('should return true when slice has no data array', () => {
+    it('should return true when slice has no data', () => {
       const model: Model = {
         variant: 'specs',
         narratives: [