@auto-engineer/narrative 0.13.0 → 0.13.2

package/src/id/addAutoIds.specs.ts

@@ -15,20 +15,23 @@ describe('addAutoIds', () => {
             client: { specs: [] },
             server: {
               description: 'Test server',
-              specs: {
-                name: 'Test Specs',
-                rules: [
-                  {
-                    description: 'Test rule without ID',
-                    examples: [],
-                  },
-                  {
-                    id: 'EXISTING-RULE-001',
-                    description: 'Test rule with existing ID',
-                    examples: [],
-                  },
-                ],
-              },
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Test Specs',
+                  rules: [
+                    {
+                      name: 'Test rule without ID',
+                      examples: [],
+                    },
+                    {
+                      id: 'EXISTING-RULE-001',
+                      name: 'Test rule with existing ID',
+                      examples: [],
+                    },
+                  ],
+                },
+              ],
             },
           },
           {
@@ -38,10 +41,13 @@ describe('addAutoIds', () => {
             client: { specs: [] },
             server: {
               description: 'Test server',
-              specs: {
-                name: 'Test Specs',
-                rules: [],
-              },
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Test Specs',
+                  rules: [],
+                },
+              ],
             },
           },
         ],
@@ -54,16 +60,18 @@ describe('addAutoIds', () => {
             type: 'react',
             name: 'React Slice',
             server: {
-              description: 'React server',
-              specs: {
-                name: 'React Specs',
-                rules: [
-                  {
-                    description: 'React rule',
-                    examples: [],
-                  },
-                ],
-              },
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'React Specs',
+                  rules: [
+                    {
+                      name: 'React rule',
+                      examples: [],
+                    },
+                  ],
+                },
+              ],
             },
           },
         ],
@@ -86,13 +94,13 @@ describe('addAutoIds', () => {
     const slice0 = result.narratives[0].slices[0];
     const slice1 = result.narratives[1].slices[0];
 
-    if ('server' in slice0 && slice0.server?.specs?.rules != null) {
-      expect(slice0.server.specs.rules[0].id).toMatch(AUTO_ID_REGEX);
-      expect(slice0.server.specs.rules[1].id).toBe('EXISTING-RULE-001');
+    if ('server' in slice0 && slice0.server?.specs != null && Array.isArray(slice0.server.specs)) {
+      expect(slice0.server.specs[0].rules[0].id).toMatch(AUTO_ID_REGEX);
+      expect(slice0.server.specs[0].rules[1].id).toBe('EXISTING-RULE-001');
     }
 
-    if ('server' in slice1 && slice1.server?.specs?.rules != null) {
-      expect(slice1.server.specs.rules[0].id).toMatch(AUTO_ID_REGEX);
+    if ('server' in slice1 && slice1.server?.specs != null && Array.isArray(slice1.server.specs)) {
+      expect(slice1.server.specs[0].rules[0].id).toMatch(AUTO_ID_REGEX);
     }
   });
 
@@ -106,10 +114,11 @@ describe('addAutoIds', () => {
     expect(originalSlice.id).toBeUndefined();
     if (
       'server' in originalSlice &&
-      originalSlice.server?.specs?.rules !== undefined &&
-      originalSlice.server.specs.rules.length > 0
+      originalSlice.server?.specs !== undefined &&
+      Array.isArray(originalSlice.server.specs) &&
+      originalSlice.server.specs.length > 0
     ) {
-      expect(originalSlice.server.specs.rules[0].id).toBeUndefined();
+      expect(originalSlice.server.specs[0].rules[0].id).toBeUndefined();
     }
   });
 
@@ -120,8 +129,8 @@ describe('addAutoIds', () => {
     expect(result.narratives[0].slices[1].id).toBe('EXISTING-SLICE-001');
 
     const testSlice = result.narratives[0].slices[0];
-    if ('server' in testSlice && testSlice.server?.specs?.rules != null) {
-      expect(testSlice.server.specs.rules[1].id).toBe('EXISTING-RULE-001');
+    if ('server' in testSlice && testSlice.server?.specs != null && Array.isArray(testSlice.server.specs)) {
+      expect(testSlice.server.specs[0].rules[1].id).toBe('EXISTING-RULE-001');
     }
   });
 
@@ -138,10 +147,13 @@ describe('addAutoIds', () => {
               client: { specs: [] },
               server: {
                 description: 'Simple server',
-                specs: {
-                  name: 'Simple specs',
-                  rules: [],
-                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Simple specs',
+                    rules: [],
+                  },
+                ],
               },
             },
           ],
@@ -199,14 +211,9 @@ describe('addAutoIds', () => {
 
     const result = addAutoIds(modelWithExperienceSlice);
 
-    // Flow should get an auto ID
     expect(result.narratives[0].id).toMatch(AUTO_ID_REGEX);
-
-    // Experience slices should get auto IDs where missing
     expect(result.narratives[0].slices[0].id).toMatch(AUTO_ID_REGEX);
     expect(result.narratives[0].slices[1].id).toBe('EXISTING-EXPERIENCE-SLICE-001');
-
-    // Experience slices only have client specs (no server specs to test)
   });
 
   it('should assign unique IDs to multiple flows with same sourceFile', () => {
@@ -279,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 } 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,30 +7,74 @@ function ensureId(item: { id?: string }): void {
   }
 }
 
-function addRuleIds(rules: Array<unknown>): Array<unknown> {
+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;
+  });
+}
+
+function processRules(rules: Rule[]): Rule[] {
   return rules.map((rule) => {
-    if (typeof rule === 'object' && rule !== null && 'description' in rule) {
-      const ruleCopy = { ...rule } as { id?: string };
-      ensureId(ruleCopy);
-      return ruleCopy;
-    }
-    return rule;
+    const ruleCopy = { ...rule };
+    ensureId(ruleCopy);
+    ruleCopy.examples = processExamples(rule.examples);
+    return ruleCopy;
+  });
+}
+
+function processSpecs(specs: Spec[]): Spec[] {
+  return specs.map((spec) => {
+    const specCopy = { ...spec };
+    ensureId(specCopy);
+    specCopy.rules = processRules(spec.rules);
+    return specCopy;
   });
 }
 
 function processServerSpecs(slice: Slice): Slice {
-  if (!('server' in slice) || slice.server?.specs?.rules === undefined) return slice;
+  if (!('server' in slice) || slice.server?.specs === undefined || !Array.isArray(slice.server.specs)) return slice;
 
   const modifiedSlice = structuredClone(slice);
-  if ('server' in modifiedSlice && modifiedSlice.server?.specs?.rules !== undefined) {
-    (modifiedSlice.server.specs as { rules: unknown[] }).rules = addRuleIds(modifiedSlice.server.specs.rules);
+  if (
+    'server' in modifiedSlice &&
+    modifiedSlice.server?.specs !== undefined &&
+    Array.isArray(modifiedSlice.server.specs)
+  ) {
+    modifiedSlice.server.specs = processSpecs(modifiedSlice.server.specs);
   }
   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 {