@auto-engineer/narrative 0.13.0 → 0.13.1

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', () => {

package/src/id/addAutoIds.ts

@@ -1,5 +1,5 @@
 import { generateAutoId } from './generators';
-import { Model, Slice } from '../index';
+import { Model, Slice, Spec, Rule, Example } from '../index';
 
 function ensureId(item: { id?: string }): void {
   if (item.id === undefined || item.id === '') {
@@ -7,23 +7,40 @@ function ensureId(item: { id?: string }): void {
   }
 }
 
-function addRuleIds(rules: Array<unknown>): Array<unknown> {
+function processExamples(examples: Example[]): Example[] {
+  return examples.map((example) => {
+    const exampleCopy = { ...example };
+    ensureId(exampleCopy);
+    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) => ({
+    ...spec,
+    rules: processRules(spec.rules),
+  }));
+}
+
 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;
 }

package/src/id/hasAllIds.specs.ts

@@ -1,267 +1,169 @@
-import { describe, expect, it, beforeEach } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { hasAllIds, addAutoIds } from './index';
-import { getNarratives } from '../getNarratives';
-import { InMemoryFileStore, type IFileStore } from '@auto-engineer/file-store';
-import * as flowApi from '../narrative';
-import * as fluent from '../fluent-builder';
-import * as dataBuilders from '../data-narrative-builders';
-import * as typesApi from '../types';
-import gql from 'graphql-tag';
-
-const importMap = {
-  '../flow': flowApi,
-  '../fluent-builder': fluent,
-  '../data-flow-builders': dataBuilders,
-  '../types': typesApi,
-  'graphql-tag': gql,
-};
+import type { Model } from '../index';
 
 describe('hasAllIds', () => {
-  let vfs: IFileStore;
-  const root = '/test';
-
-  beforeEach(async () => {
-    vfs = new InMemoryFileStore();
-
-    const flowWithoutIds = `
-import { flow, specs, rule, example } from '../narrative';
-import { command } from '../fluent-builder';
-
-flow('Test Flow Without IDs', () => {
-  command('Test slice without ID')
-    .server(() => {
-      specs('Test specs', () => {
-        rule('Test rule without ID', () => {
-          example('Test example')
-            .when({ test: 'data' })
-            .then({ result: 'success' });
-        });
-      });
-    });
-});`;
-
-    const flowWithIds = `
-import { flow, specs, rule, example } from '../narrative';
-import { command } from '../fluent-builder';
-
-flow('Test Flow with IDs', 'FLOW-001', () => {
-  command('Test slice with ID', 'SLICE-001')
-    .server(() => {
-      specs('Test specs', () => {
-        rule('Test rule with ID', 'RULE-001', () => {
-          example('Test example')
-            .when({ test: 'data' })
-            .then({ result: 'success' });
-        });
-      });
-    });
-});`;
-
-    const multipleFlowsSameSource = `
-import { flow, specs, it } from '../narrative';
-import { experience } from '../fluent-builder';
-
-flow('Home Screen', 'aifPcU3hw', () => {
-  experience('Active Surveys Summary', 'slice1').client(() => {
-    specs(() => {
-      it('show active surveys summary');
-    });
-  });
-});
-
-flow('Create Survey', 'MPviTMrQC', () => {
-  experience('Create Survey Form', 'slice2').client(() => {
-    specs(() => {
-      it('allow entering survey title');
-    });
-  });
-});
-
-flow('Response Analytics', 'eME978Euk', () => {
-  experience('Response Rate Charts', 'slice3').client(() => {
-    specs(() => {
-      it('show daily response rate charts');
-    });
-  });
-});`;
-
-    const multipleFlowsIncomplete = `
-import { flow, specs, it } from '../narrative';
-import { experience } from '../fluent-builder';
-
-flow('Home Screen', 'aifPcU3hw', () => {
-  experience('Active Surveys Summary', 'slice1').client(() => {
-    specs(() => {
-      it('show active surveys summary');
-    });
-  });
-});
-
-flow('Create Survey', () => {
-  experience('Create Survey Form', 'slice2').client(() => {
-    specs(() => {
-      it('allow entering survey title');
-    });
-  });
-});
-
-flow('Response Analytics', 'eME978Euk', () => {
-  experience('Response Rate Charts', 'slice3').client(() => {
-    specs(() => {
-      it('show daily response rate charts');
-    });
-  });
-});`;
-
-    const multipleFlowsSliceMissing = `
-import { flow, specs, it } from '../narrative';
-import { experience } from '../fluent-builder';
-
-flow('Home Screen', 'aifPcU3hw', () => {
-  experience('Active Surveys Summary', 'slice1').client(() => {
-    specs(() => {
-      it('show active surveys summary');
-    });
-  });
-});
-
-flow('Create Survey', 'MPviTMrQC', () => {
-  experience('Create Survey Form').client(() => {
-    specs(() => {
-      it('allow entering survey title');
-    });
-  });
-});
-
-flow('Response Analytics', 'eME978Euk', () => {
-  experience('Response Rate Charts', 'slice3').client(() => {
-    specs(() => {
-      it('show daily response rate charts');
-    });
-  });
-});`;
-
-    const flowContent1 = new TextEncoder().encode(flowWithoutIds);
-    const flowContent2 = new TextEncoder().encode(flowWithIds);
-    const flowContent3 = new TextEncoder().encode(multipleFlowsSameSource);
-    const flowContent4 = new TextEncoder().encode(multipleFlowsIncomplete);
-    const flowContent5 = new TextEncoder().encode(multipleFlowsSliceMissing);
-    await vfs.write('/test/flow-without-ids.narrative.ts', flowContent1);
-    await vfs.write('/test/flow-with-ids.narrative.ts', flowContent2);
-    await vfs.write('/test/homepage.narrative.ts', flowContent3);
-    await vfs.write('/test/homepage-incomplete.narrative.ts', flowContent4);
-    await vfs.write('/test/homepage-slice-missing.narrative.ts', flowContent5);
-  });
-  it('should return false for models without IDs', async () => {
-    const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
-    const model = result.toModel();
-
-    const flowWithoutIds = model.narratives.find((f) => f.name === 'Test Flow Without IDs');
-    expect(flowWithoutIds).toBeDefined();
-
-    if (flowWithoutIds) {
-      const modelWithoutIds = { ...model, narratives: [flowWithoutIds] };
-      expect(hasAllIds(modelWithoutIds)).toBe(false);
-    }
-  });
-
-  it('should return true for models with complete IDs', async () => {
-    const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
-    const model = result.toModel();
-
+  const createModelWithoutIds = (): Model => ({
+    variant: 'specs',
+    narratives: [
+      {
+        name: 'Test Flow Without IDs',
+        slices: [
+          {
+            type: 'command',
+            name: 'Test slice without ID',
+            client: { specs: [] },
+            server: {
+              description: 'Test server',
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Test specs',
+                  rules: [
+                    {
+                      name: 'Test rule without ID',
+                      examples: [],
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ],
+    messages: [],
+    integrations: [],
+  });
+
+  const createModelWithIds = (): Model => ({
+    variant: 'specs',
+    narratives: [
+      {
+        name: 'Test Flow with IDs',
+        id: 'FLOW-001',
+        slices: [
+          {
+            type: 'command',
+            name: 'Test slice with ID',
+            id: 'SLICE-001',
+            client: { specs: [] },
+            server: {
+              description: 'Test server',
+              specs: [
+                {
+                  type: 'gherkin',
+                  feature: 'Test specs',
+                  rules: [
+                    {
+                      id: 'RULE-001',
+                      name: 'Test rule with ID',
+                      examples: [],
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ],
+    messages: [],
+    integrations: [],
+  });
+
+  const createMultipleFlowsModel = (includeAllIds: boolean, includeAllSliceIds: boolean): Model => ({
+    variant: 'specs',
+    narratives: [
+      {
+        name: 'Home Screen',
+        id: 'aifPcU3hw',
+        sourceFile: '/path/to/homepage.narrative.ts',
+        slices: [
+          {
+            name: 'Active Surveys Summary',
+            id: 'slice1',
+            type: 'experience',
+            client: { specs: [{ type: 'it', title: 'show active surveys summary' }] },
+          },
+        ],
+      },
+      {
+        name: 'Create Survey',
+        id: includeAllIds ? 'MPviTMrQC' : undefined,
+        sourceFile: '/path/to/homepage.narrative.ts',
+        slices: [
+          {
+            name: 'Create Survey Form',
+            id: includeAllSliceIds ? 'slice2' : undefined,
+            type: 'experience',
+            client: { specs: [{ type: 'it', title: 'allow entering survey title' }] },
+          },
+        ],
+      },
+      {
+        name: 'Response Analytics',
+        id: 'eME978Euk',
+        sourceFile: '/path/to/homepage.narrative.ts',
+        slices: [
+          {
+            name: 'Response Rate Charts',
+            id: 'slice3',
+            type: 'experience',
+            client: { specs: [{ type: 'it', title: 'show daily response rate charts' }] },
+          },
+        ],
+      },
+    ],
+    messages: [],
+    integrations: [],
+  });
+
+  it('should return false for models without IDs', () => {
+    const model = createModelWithoutIds();
+    expect(hasAllIds(model)).toBe(false);
+  });
+
+  it('should return true for models with complete IDs', () => {
+    const model = createModelWithoutIds();
     const modelWithIds = addAutoIds(model);
     expect(hasAllIds(modelWithIds)).toBe(true);
   });
 
-  it('should return true for flows that already have IDs', async () => {
-    const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
-    const model = result.toModel();
-
-    const testFlowWithIds = model.narratives.find((f) => f.name === 'Test Flow with IDs');
-    expect(testFlowWithIds).toBeDefined();
-
-    if (testFlowWithIds) {
-      const modelWithExistingIds = { ...model, narratives: [testFlowWithIds] };
-      expect(hasAllIds(modelWithExistingIds)).toBe(true);
-    }
+  it('should return true for flows that already have IDs', () => {
+    const model = createModelWithIds();
+    expect(hasAllIds(model)).toBe(true);
   });
 
-  it('should return false if any slice is missing an ID', async () => {
-    const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
-    const model = result.toModel();
-
-    const modelWithIds = addAutoIds(model);
-    expect(modelWithIds.narratives.length).toBeGreaterThan(0);
-    expect(modelWithIds.narratives[0].slices.length).toBeGreaterThan(0);
-
-    const modifiedModel = structuredClone(modelWithIds);
+  it('should return false if any slice is missing an ID', () => {
+    const model = createModelWithIds();
+    const modifiedModel = structuredClone(model);
     modifiedModel.narratives[0].slices[0].id = '';
     expect(hasAllIds(modifiedModel)).toBe(false);
   });
 
-  it('should return false if any rule is missing an ID', async () => {
-    const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
-    const model = result.toModel();
-
-    const modelWithIds = addAutoIds(model);
-
-    let found = false;
-    for (const flow of modelWithIds.narratives) {
-      for (const slice of flow.slices) {
-        if ('server' in slice && slice.server?.specs?.rules !== undefined && slice.server.specs.rules.length > 0) {
-          const modifiedModel = structuredClone(modelWithIds);
-          const modifiedFlow = modifiedModel.narratives.find((f) => f.name === flow.name);
-          const modifiedSlice = modifiedFlow?.slices.find((s) => s.name === slice.name);
-          if (modifiedSlice && 'server' in modifiedSlice && modifiedSlice.server?.specs?.rules !== undefined) {
-            modifiedSlice.server.specs.rules[0].id = '';
-            expect(hasAllIds(modifiedModel)).toBe(false);
-            found = true;
-            break;
-          }
-        }
-      }
-      if (found) break;
+  it('should return false if any rule is missing an ID', () => {
+    const model = createModelWithIds();
+    const modifiedModel = structuredClone(model);
+    const slice = modifiedModel.narratives[0].slices[0];
+    if ('server' in slice && slice.server?.specs !== undefined && Array.isArray(slice.server.specs)) {
+      slice.server.specs[0].rules[0].id = '';
     }
-
-    expect(found).toBe(true);
+    expect(hasAllIds(modifiedModel)).toBe(false);
   });
 
-  it('should return true when multiple flows with same sourceFile all have IDs', async () => {
-    const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
-    const model = result.toModel();
-
-    const homepageFlows = model.narratives.filter(
-      (f) => f.sourceFile !== undefined && f.sourceFile.includes('homepage.narrative.ts'),
-    );
-    expect(homepageFlows.length).toBe(3);
-
-    const homepageModel = { ...model, narratives: homepageFlows };
-    expect(hasAllIds(homepageModel)).toBe(true);
+  it('should return true when multiple flows with same sourceFile all have IDs', () => {
+    const model = createMultipleFlowsModel(true, true);
+    expect(hasAllIds(model)).toBe(true);
   });
 
-  it('should return false when any flow in multiple flows with same sourceFile is missing ID', async () => {
-    const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
-    const model = result.toModel();
-
-    const homepageFlows = model.narratives.filter(
-      (f) => f.sourceFile !== undefined && f.sourceFile.includes('homepage-incomplete.narrative.ts'),
-    );
-    expect(homepageFlows.length).toBe(3);
-
-    const homepageModel = { ...model, narratives: homepageFlows };
-    expect(hasAllIds(homepageModel)).toBe(false);
+  it('should return false when any flow in multiple flows with same sourceFile is missing ID', () => {
+    const model = createMultipleFlowsModel(false, true);
+    expect(hasAllIds(model)).toBe(false);
   });
 
-  it('should return false when any slice in multiple flows with same sourceFile is missing ID', async () => {
-    const result = await getNarratives({ vfs, root, pattern: /\.(narrative)\.(ts)$/, fastFsScan: true, importMap });
-    const model = result.toModel();
-
-    const homepageFlows = model.narratives.filter(
-      (f) => f.sourceFile !== undefined && f.sourceFile.includes('homepage-slice-missing.narrative.ts'),
-    );
-    expect(homepageFlows.length).toBe(3);
-
-    const homepageModel = { ...model, narratives: homepageFlows };
-    expect(hasAllIds(homepageModel)).toBe(false);
+  it('should return false when any slice in multiple flows with same sourceFile is missing ID', () => {
+    const model = createMultipleFlowsModel(true, false);
+    expect(hasAllIds(model)).toBe(false);
   });
 });

package/src/id/hasAllIds.ts

@@ -1,16 +1,23 @@
-import { Model, Slice } from '../index';
+import { Model, Slice, Spec, Rule } from '../index';
 
 function hasValidId(item: { id?: string }): boolean {
   return item.id !== undefined && item.id !== '';
 }
 
+function hasRuleIds(rules: Rule[]): boolean {
+  return rules.every((rule) => hasValidId(rule));
+}
+
+function hasSpecIds(specs: Spec[]): boolean {
+  return specs.every((spec) => hasRuleIds(spec.rules));
+}
+
 function hasServerSpecIds(slice: Slice): boolean {
-  if (!('server' in slice) || slice.server?.specs?.rules === undefined) return true;
-  return slice.server.specs.rules.every(hasValidId);
+  if (!('server' in slice) || slice.server?.specs === undefined || !Array.isArray(slice.server.specs)) return true;
+  return hasSpecIds(slice.server.specs);
 }
 
 function hasClientSpecIds(_slice: Slice): boolean {
-  // Client specs use string rules (no IDs needed), so always valid
   return true;
 }