@auto-engineer/narrative 0.13.1 → 0.13.2

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.13.1",
-    "@auto-engineer/message-bus": "0.13.1",
-    "@auto-engineer/id": "0.13.1"
+    "@auto-engineer/file-store": "0.13.2",
+    "@auto-engineer/id": "0.13.2",
+    "@auto-engineer/message-bus": "0.13.2"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -33,12 +33,12 @@
     "eslint-plugin-sort-keys-fix": "^1.1.2",
     "fake-indexeddb": "^6.0.0",
     "tsx": "^4.20.3",
-    "@auto-engineer/cli": "0.13.1"
+    "@auto-engineer/cli": "0.13.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.13.1",
+  "version": "0.13.2",
   "scripts": {
     "build": "tsx scripts/build.ts",
     "test": "vitest run --reporter=dot",

package/src/id/addAutoIds.specs.ts

@@ -286,4 +286,374 @@ describe('addAutoIds', () => {
     expect(result.narratives[1].sourceFile).toBe('/path/to/homepage.narrative.ts');
     expect(result.narratives[2].sourceFile).toBe('/path/to/homepage.narrative.ts');
   });
+
+  it('should assign IDs to specs', () => {
+    const modelWithSpecs: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Test Flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'Test Command',
+              client: { specs: [] },
+              server: {
+                description: 'Test server',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Test Feature',
+                    rules: [],
+                  },
+                  {
+                    id: 'EXISTING-SPEC-001',
+                    type: 'gherkin',
+                    feature: 'Existing Feature',
+                    rules: [],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [],
+      integrations: [],
+    };
+
+    const result = addAutoIds(modelWithSpecs);
+    const slice = result.narratives[0].slices[0];
+
+    if ('server' in slice && slice.server?.specs != null && Array.isArray(slice.server.specs)) {
+      expect(slice.server.specs[0].id).toMatch(AUTO_ID_REGEX);
+      expect(slice.server.specs[1].id).toBe('EXISTING-SPEC-001');
+    }
+  });
+
+  it('should assign IDs to steps', () => {
+    const modelWithSteps: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Test Flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'Test Command',
+              client: { specs: [] },
+              server: {
+                description: 'Test server',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Test Feature',
+                    rules: [
+                      {
+                        name: 'Test Rule',
+                        examples: [
+                          {
+                            name: 'Test Example',
+                            steps: [
+                              { keyword: 'Given', text: 'TestState', docString: { value: 'test' } },
+                              { keyword: 'When', text: 'TestCommand' },
+                              { id: 'EXISTING-STEP-001', keyword: 'Then', text: 'TestEvent' },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [],
+      integrations: [],
+    };
+
+    const result = addAutoIds(modelWithSteps);
+    const slice = result.narratives[0].slices[0];
+
+    if ('server' in slice && slice.server?.specs != null && Array.isArray(slice.server.specs)) {
+      const steps = slice.server.specs[0].rules[0].examples[0].steps;
+      expect(steps[0].id).toMatch(AUTO_ID_REGEX);
+      expect(steps[1].id).toMatch(AUTO_ID_REGEX);
+      expect(steps[2].id).toBe('EXISTING-STEP-001');
+    }
+  });
+
+  it('should preserve existing example IDs', () => {
+    const modelWithExistingExampleId: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Test Flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'Test Command',
+              client: { specs: [] },
+              server: {
+                description: 'Test server',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Test Feature',
+                    rules: [
+                      {
+                        name: 'Test Rule',
+                        examples: [
+                          {
+                            name: 'Example without id',
+                            steps: [{ keyword: 'Given', text: 'TestState' }],
+                          },
+                          {
+                            id: 'EXISTING-EXAMPLE-001',
+                            name: 'Example with existing id',
+                            steps: [{ keyword: 'Given', text: 'TestState' }],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [],
+      integrations: [],
+    };
+
+    const result = addAutoIds(modelWithExistingExampleId);
+    const slice = result.narratives[0].slices[0];
+
+    if ('server' in slice && slice.server?.specs != null && Array.isArray(slice.server.specs)) {
+      const examples = slice.server.specs[0].rules[0].examples;
+      expect(examples[0].id).toMatch(AUTO_ID_REGEX);
+      expect(examples[1].id).toBe('EXISTING-EXAMPLE-001');
+    }
+  });
+
+  it('should assign IDs to steps with errors', () => {
+    const modelWithErrorSteps: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Test Flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'Test Command',
+              client: { specs: [] },
+              server: {
+                description: 'Test server',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Test Feature',
+                    rules: [
+                      {
+                        name: 'Error Rule',
+                        examples: [
+                          {
+                            name: 'Error Example',
+                            steps: [
+                              { keyword: 'Given', text: 'TestState' },
+                              { keyword: 'When', text: 'InvalidCommand' },
+                              { keyword: 'Then', error: { type: 'ValidationError', message: 'Invalid input' } },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [],
+      integrations: [],
+    };
+
+    const result = addAutoIds(modelWithErrorSteps);
+    const slice = result.narratives[0].slices[0];
+
+    if ('server' in slice && slice.server?.specs != null && Array.isArray(slice.server.specs)) {
+      const steps = slice.server.specs[0].rules[0].examples[0].steps;
+      expect(steps[0].id).toMatch(AUTO_ID_REGEX);
+      expect(steps[1].id).toMatch(AUTO_ID_REGEX);
+      expect(steps[2].id).toMatch(AUTO_ID_REGEX);
+    }
+  });
+
+  it('should assign IDs to client it specs', () => {
+    const modelWithClientSpecs: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Test Flow',
+          slices: [
+            {
+              type: 'experience',
+              name: 'Test Experience',
+              client: {
+                specs: [
+                  { type: 'it', title: 'first test' },
+                  { type: 'it', id: 'EXISTING-IT-001', title: 'second test with id' },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [],
+      integrations: [],
+    };
+
+    const result = addAutoIds(modelWithClientSpecs);
+    const slice = result.narratives[0].slices[0];
+
+    if ('client' in slice && slice.client?.specs != null) {
+      expect(slice.client.specs[0].id).toMatch(AUTO_ID_REGEX);
+      expect(slice.client.specs[1].id).toBe('EXISTING-IT-001');
+    }
+  });
+
+  it('should assign IDs to client describe specs', () => {
+    const modelWithDescribe: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Test Flow',
+          slices: [
+            {
+              type: 'experience',
+              name: 'Test Experience',
+              client: {
+                specs: [
+                  {
+                    type: 'describe',
+                    title: 'describe without id',
+                    children: [{ type: 'it', title: 'nested it' }],
+                  },
+                  {
+                    type: 'describe',
+                    id: 'EXISTING-DESC-001',
+                    title: 'describe with id',
+                    children: [],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [],
+      integrations: [],
+    };
+
+    const result = addAutoIds(modelWithDescribe);
+    const slice = result.narratives[0].slices[0];
+
+    if ('client' in slice && slice.client?.specs != null) {
+      expect(slice.client.specs[0].id).toMatch(AUTO_ID_REGEX);
+      expect(slice.client.specs[1].id).toBe('EXISTING-DESC-001');
+    }
+  });
+
+  it('should assign IDs to nested client specs', () => {
+    const modelWithNestedSpecs: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Test Flow',
+          slices: [
+            {
+              type: 'experience',
+              name: 'Test Experience',
+              client: {
+                specs: [
+                  {
+                    type: 'describe',
+                    title: 'outer describe',
+                    children: [
+                      { type: 'it', title: 'outer it' },
+                      {
+                        type: 'describe',
+                        title: 'inner describe',
+                        children: [
+                          { type: 'it', title: 'inner it 1' },
+                          { type: 'it', title: 'inner it 2' },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [],
+      integrations: [],
+    };
+
+    const result = addAutoIds(modelWithNestedSpecs);
+    const slice = result.narratives[0].slices[0];
+
+    if ('client' in slice && slice.client?.specs != null) {
+      const outerDescribe = slice.client.specs[0];
+      expect(outerDescribe.id).toMatch(AUTO_ID_REGEX);
+
+      if (outerDescribe.type === 'describe' && outerDescribe.children) {
+        expect(outerDescribe.children[0].id).toMatch(AUTO_ID_REGEX);
+
+        const innerDescribe = outerDescribe.children[1];
+        expect(innerDescribe.id).toMatch(AUTO_ID_REGEX);
+
+        if (innerDescribe.type === 'describe' && innerDescribe.children) {
+          expect(innerDescribe.children[0].id).toMatch(AUTO_ID_REGEX);
+          expect(innerDescribe.children[1].id).toMatch(AUTO_ID_REGEX);
+
+          expect(innerDescribe.children[0].id).not.toBe(innerDescribe.children[1].id);
+        }
+      }
+    }
+  });
+
+  it('should not mutate original client specs', () => {
+    const modelWithClientSpecs: Model = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Test Flow',
+          slices: [
+            {
+              type: 'experience',
+              name: 'Test Experience',
+              client: {
+                specs: [{ type: 'it', title: 'test' }],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [],
+      integrations: [],
+    };
+
+    const originalSpec = modelWithClientSpecs.narratives[0].slices[0];
+    addAutoIds(modelWithClientSpecs);
+
+    if ('client' in originalSpec && originalSpec.client?.specs != null) {
+      expect(originalSpec.client.specs[0].id).toBeUndefined();
+    }
+  });
 });

package/src/id/addAutoIds.ts

@@ -1,5 +1,5 @@
 import { generateAutoId } from './generators';
-import { Model, Slice, Spec, Rule, Example } from '../index';
+import { Model, Slice, Spec, Rule, Example, Step, ClientSpecNode } from '../index';
 
 function ensureId(item: { id?: string }): void {
   if (item.id === undefined || item.id === '') {
@@ -7,10 +7,19 @@ function ensureId(item: { id?: string }): void {
   }
 }
 
+function processSteps(steps: Step[]): Step[] {
+  return steps.map((step) => {
+    const stepCopy = { ...step };
+    ensureId(stepCopy);
+    return stepCopy;
+  });
+}
+
 function processExamples(examples: Example[]): Example[] {
   return examples.map((example) => {
     const exampleCopy = { ...example };
     ensureId(exampleCopy);
+    exampleCopy.steps = processSteps(example.steps);
     return exampleCopy;
   });
 }
@@ -25,10 +34,12 @@ function processRules(rules: Rule[]): Rule[] {
 }
 
 function processSpecs(specs: Spec[]): Spec[] {
-  return specs.map((spec) => ({
-    ...spec,
-    rules: processRules(spec.rules),
-  }));
+  return specs.map((spec) => {
+    const specCopy = { ...spec };
+    ensureId(specCopy);
+    specCopy.rules = processRules(spec.rules);
+    return specCopy;
+  });
 }
 
 function processServerSpecs(slice: Slice): Slice {
@@ -45,9 +56,25 @@ function processServerSpecs(slice: Slice): Slice {
   return modifiedSlice;
 }
 
+function processClientSpecNodes(nodes: ClientSpecNode[]): ClientSpecNode[] {
+  return nodes.map((node) => {
+    const nodeCopy = { ...node };
+    ensureId(nodeCopy);
+    if (nodeCopy.type === 'describe' && nodeCopy.children) {
+      nodeCopy.children = processClientSpecNodes(nodeCopy.children);
+    }
+    return nodeCopy;
+  });
+}
+
 function processClientSpecs(slice: Slice): Slice {
-  // Client specs use string rules (no IDs needed), so nothing to process
-  return slice;
+  if (!('client' in slice) || slice.client?.specs === undefined || !Array.isArray(slice.client.specs)) return slice;
+
+  const modifiedSlice = structuredClone(slice);
+  if ('client' in modifiedSlice && modifiedSlice.client?.specs !== undefined) {
+    modifiedSlice.client.specs = processClientSpecNodes(modifiedSlice.client.specs);
+  }
+  return modifiedSlice;
 }
 
 function processSlice(slice: Slice): Slice {