@auto-engineer/server-generator-apollo-emmett 1.139.0 → 1.140.0

package/src/commands/generate-server.specs.ts

@@ -2,20 +2,20 @@ import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import * as path from 'node:path';
 import { join } from 'node:path';
-import type { CommandSlice, Model, Narrative, QuerySlice } from '@auto-engineer/narrative';
+import type { CommandMoment, Model, QueryMoment, Scene } from '@auto-engineer/narrative';
 import fs from 'fs-extra';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { ScaffoldError, TemplateRenderError } from '../codegen/scaffoldFromSchema';
 import type { GenerateServerCommand, GenerateServerEvents, GenerationState } from './generate-server';
 import {
   cleanServerDir,
+  createMomentGeneratedEvent,
   createServerFailureEvent,
-  createSliceGeneratedEvent,
   deriveModelPath,
-  emitSliceGeneratedForAffected,
-  emitSliceGeneratedForAll,
-  emitSliceGenerationFailedForDuplicates,
-  emitSliceGenerationFailedForFieldIssues,
+  emitMomentGeneratedForAffected,
+  emitMomentGeneratedForAll,
+  emitMomentGenerationFailedForDuplicates,
+  emitMomentGenerationFailedForFieldIssues,
   saveGenerationState,
   writeBiomeConfig,
   writeHealthResolver,
@@ -29,7 +29,7 @@ const makeCommand = (): GenerateServerCommand => ({
   correlationId: 'cor-1',
 });
 
-const makeSlice = (name: string): CommandSlice => ({
+const makeMoment = (name: string): CommandMoment => ({
   name,
   type: 'command',
   client: { specs: [] },
@@ -38,14 +38,15 @@ const makeSlice = (name: string): CommandSlice => ({
 
 const makeModel = (): Model => ({
   variant: 'specs',
-  narratives: [
+  scenes: [
     {
       name: 'Todo',
-      slices: [makeSlice('AddTodo'), makeSlice('RemoveTodo')],
+      moments: [makeMoment('AddTodo'), makeMoment('RemoveTodo')],
     },
   ],
   messages: [],
   modules: [],
+  narratives: [],
 });
 
 describe('cleanServerDir', () => {
@@ -100,29 +101,29 @@ describe('cleanServerDir', () => {
   });
 });
 
-describe('createSliceGeneratedEvent', () => {
-  it('builds SliceGenerated event from flow, slice, and command', () => {
-    const flow: Narrative = {
+describe('createMomentGeneratedEvent', () => {
+  it('builds MomentGenerated event from scene, slice, and command', () => {
+    const scene: Scene = {
       name: 'PropertyListing',
-      slices: [],
+      moments: [],
     };
-    const slice: CommandSlice = {
+    const slice: CommandMoment = {
       name: 'CreateListing',
       type: 'command',
       client: { specs: [] },
       server: { description: 'Create a listing', specs: [] },
     };
 
-    const event = createSliceGeneratedEvent(flow, slice, makeCommand());
+    const event = createMomentGeneratedEvent(scene, slice, makeCommand());
 
     expect(event).toEqual({
-      type: 'SliceGenerated',
+      type: 'MomentGenerated',
       data: {
-        flowName: 'PropertyListing',
-        sliceName: 'CreateListing',
-        sliceType: 'command',
+        sceneName: 'PropertyListing',
+        momentName: 'CreateListing',
+        momentType: 'command',
         schemaPath: path.join(path.resolve('.'), '.context', 'schema.json'),
-        slicePath: 'server/src/domain/flows/property-listing/create-listing',
+        momentPath: 'server/src/domain/narratives/property-listing/create-listing',
       },
       timestamp: expect.any(Date),
       requestId: 'req-1',
@@ -131,52 +132,53 @@ describe('createSliceGeneratedEvent', () => {
   });
 });
 
-describe('emitSliceGeneratedForAll', () => {
-  it('emits SliceGenerated for every non-experience slice', () => {
+describe('emitMomentGeneratedForAll', () => {
+  it('emits MomentGenerated for every non-experience slice', () => {
     const events: GenerateServerEvents[] = [];
-    emitSliceGeneratedForAll(makeModel(), makeCommand(), events);
+    emitMomentGeneratedForAll(makeModel(), makeCommand(), events);
 
     expect(events).toEqual([
-      expect.objectContaining({ type: 'SliceGenerated', data: expect.objectContaining({ sliceName: 'AddTodo' }) }),
-      expect.objectContaining({ type: 'SliceGenerated', data: expect.objectContaining({ sliceName: 'RemoveTodo' }) }),
+      expect.objectContaining({ type: 'MomentGenerated', data: expect.objectContaining({ momentName: 'AddTodo' }) }),
+      expect.objectContaining({ type: 'MomentGenerated', data: expect.objectContaining({ momentName: 'RemoveTodo' }) }),
     ]);
   });
 
   it('skips experience slices', () => {
     const model: Model = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Todo',
-          slices: [makeSlice('AddTodo'), { name: 'ViewTodos', type: 'experience', client: { specs: [] } }],
+          moments: [makeMoment('AddTodo'), { name: 'ViewTodos', type: 'experience', client: { specs: [] } }],
         },
       ],
       messages: [],
       modules: [],
+      narratives: [],
     };
     const events: GenerateServerEvents[] = [];
-    emitSliceGeneratedForAll(model, makeCommand(), events);
+    emitMomentGeneratedForAll(model, makeCommand(), events);
 
     expect(events).toEqual([
-      expect.objectContaining({ type: 'SliceGenerated', data: expect.objectContaining({ sliceName: 'AddTodo' }) }),
+      expect.objectContaining({ type: 'MomentGenerated', data: expect.objectContaining({ momentName: 'AddTodo' }) }),
     ]);
   });
 });
 
-describe('emitSliceGeneratedForAffected', () => {
-  it('emits SliceGenerated only for affected slice IDs', () => {
+describe('emitMomentGeneratedForAffected', () => {
+  it('emits MomentGenerated only for affected slice IDs', () => {
     const events: GenerateServerEvents[] = [];
     const affectedIds = new Set(['todo/add-todo']);
-    emitSliceGeneratedForAffected(makeModel(), affectedIds, makeCommand(), events);
+    emitMomentGeneratedForAffected(makeModel(), affectedIds, makeCommand(), events);
 
     expect(events).toEqual([
-      expect.objectContaining({ type: 'SliceGenerated', data: expect.objectContaining({ sliceName: 'AddTodo' }) }),
+      expect.objectContaining({ type: 'MomentGenerated', data: expect.objectContaining({ momentName: 'AddTodo' }) }),
     ]);
   });
 
   it('emits nothing when no slices are affected', () => {
     const events: GenerateServerEvents[] = [];
-    emitSliceGeneratedForAffected(makeModel(), new Set(), makeCommand(), events);
+    emitMomentGeneratedForAffected(makeModel(), new Set(), makeCommand(), events);
 
     expect(events).toEqual([]);
   });
@@ -247,10 +249,10 @@ describe('writeHealthResolver', () => {
     await rm(dir, { recursive: true, force: true });
   });
 
-  it('creates health resolver at domain/flows/health/query.resolver.ts', async () => {
+  it('creates health resolver at domain/narratives/health/query.resolver.ts', async () => {
     await writeHealthResolver(dir);
 
-    const content = await readFile(join(dir, 'src', 'domain', 'flows', 'health', 'query.resolver.ts'), 'utf8');
+    const content = await readFile(join(dir, 'src', 'domain', 'narratives', 'health', 'query.resolver.ts'), 'utf8');
     expect(content).toContain('HealthResolver');
     expect(content).toContain("return 'ok'");
     expect(content).toContain('@Query(() => String)');
@@ -288,8 +290,8 @@ describe('writeBiomeConfig', () => {
   });
 });
 
-describe('emitSliceGenerationFailedForFieldIssues', () => {
-  it('emits SliceGenerationFailed for command slice referencing message via gherkin step', () => {
+describe('emitMomentGenerationFailedForFieldIssues', () => {
+  it('emits MomentGenerationFailed for command slice referencing message via gherkin step', () => {
     const fieldIssues = [
       {
         messageName: 'AddTodo',
@@ -298,10 +300,10 @@ describe('emitSliceGenerationFailedForFieldIssues', () => {
     ];
     const spec: Model = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Todo',
-          slices: [
+          moments: [
             {
               name: 'AddTodo',
               type: 'command',
@@ -326,7 +328,7 @@ describe('emitSliceGenerationFailedForFieldIssues', () => {
                   },
                 ],
               },
-            } satisfies CommandSlice,
+            } satisfies CommandMoment,
           ],
         },
       ],
@@ -335,15 +337,15 @@ describe('emitSliceGenerationFailedForFieldIssues', () => {
     };
     const events: GenerateServerEvents[] = [];
 
-    emitSliceGenerationFailedForFieldIssues(fieldIssues, spec, makeCommand(), events);
+    emitMomentGenerationFailedForFieldIssues(fieldIssues, spec, makeCommand(), events);
 
     expect(events).toEqual([
       {
-        type: 'SliceGenerationFailed',
+        type: 'MomentGenerationFailed',
         data: {
-          flowName: 'Todo',
-          sliceName: 'AddTodo',
-          sliceType: 'command',
+          sceneName: 'Todo',
+          momentName: 'AddTodo',
+          momentType: 'command',
           error: "Field '...' was skipped from 'AddTodo' — not a valid TypeScript identifier",
           model: spec,
         },
@@ -354,7 +356,7 @@ describe('emitSliceGenerationFailedForFieldIssues', () => {
     ]);
   });
 
-  it('emits SliceGenerationFailed for query slice referencing message via data target', () => {
+  it('emits MomentGenerationFailed for query slice referencing message via data target', () => {
     const fieldIssues = [
       {
         messageName: 'TodoState',
@@ -363,10 +365,10 @@ describe('emitSliceGenerationFailedForFieldIssues', () => {
     ];
     const spec: Model = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Todo',
-          slices: [
+          moments: [
             {
               name: 'ViewTodos',
               type: 'query',
@@ -383,7 +385,7 @@ describe('emitSliceGenerationFailedForFieldIssues', () => {
                 },
                 specs: [],
               },
-            } satisfies QuerySlice,
+            } satisfies QueryMoment,
           ],
         },
       ],
@@ -392,15 +394,15 @@ describe('emitSliceGenerationFailedForFieldIssues', () => {
     };
     const events: GenerateServerEvents[] = [];
 
-    emitSliceGenerationFailedForFieldIssues(fieldIssues, spec, makeCommand(), events);
+    emitMomentGenerationFailedForFieldIssues(fieldIssues, spec, makeCommand(), events);
 
     expect(events).toEqual([
       {
-        type: 'SliceGenerationFailed',
+        type: 'MomentGenerationFailed',
         data: {
-          flowName: 'Todo',
-          sliceName: 'ViewTodos',
-          sliceType: 'query',
+          sceneName: 'Todo',
+          momentName: 'ViewTodos',
+          momentType: 'query',
           error: "Field '...' was skipped from 'TodoState' — not a valid TypeScript identifier",
           model: spec,
         },
@@ -412,14 +414,14 @@ describe('emitSliceGenerationFailedForFieldIssues', () => {
   });
 });
 
-describe('emitSliceGenerationFailedForDuplicates', () => {
-  it('emits SliceGenerationFailed for duplicate command in a different flow/slice', () => {
+describe('emitMomentGenerationFailedForDuplicates', () => {
+  it('emits MomentGenerationFailed for duplicate command in a different scene/slice', () => {
     const model: Model = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Checkout',
-          slices: [
+          moments: [
             {
               name: 'PlaceOrder',
               type: 'command',
@@ -444,12 +446,12 @@ describe('emitSliceGenerationFailedForDuplicates', () => {
                   },
                 ],
               },
-            } satisfies CommandSlice,
+            } satisfies CommandMoment,
           ],
         },
         {
           name: 'Returns',
-          slices: [
+          moments: [
             {
               name: 'ReturnItem',
               type: 'command',
@@ -474,25 +476,25 @@ describe('emitSliceGenerationFailedForDuplicates', () => {
                   },
                 ],
               },
-            } satisfies CommandSlice,
+            } satisfies CommandMoment,
           ],
         },
       ],
       messages: [],
       modules: [],
     };
-    const duplicates = [{ command: 'PlaceOrder', existingFlow: 'Checkout', existingSlice: 'PlaceOrder' }];
+    const duplicates = [{ command: 'PlaceOrder', existingScene: 'Checkout', existingMoment: 'PlaceOrder' }];
     const events: GenerateServerEvents[] = [];
 
-    emitSliceGenerationFailedForDuplicates(duplicates, model, makeCommand(), events);
+    emitMomentGenerationFailedForDuplicates(duplicates, model, makeCommand(), events);
 
     expect(events).toEqual([
       {
-        type: 'SliceGenerationFailed',
+        type: 'MomentGenerationFailed',
         data: {
-          flowName: 'Returns',
-          sliceName: 'ReturnItem',
-          sliceType: 'command',
+          sceneName: 'Returns',
+          momentName: 'ReturnItem',
+          momentType: 'command',
           error: "Duplicate command handler: 'PlaceOrder' is already registered in Checkout/PlaceOrder",
           model,
         },
@@ -505,7 +507,7 @@ describe('emitSliceGenerationFailedForDuplicates', () => {
 });
 
 describe('createServerFailureEvent', () => {
-  it('extracts flow/slice/type and template from ScaffoldError wrapping TemplateRenderError', () => {
+  it('extracts scene/slice/type and template from ScaffoldError wrapping TemplateRenderError', () => {
     const rootCause = new TypeError('Cannot read properties of undefined');
     const templateErr = new TemplateRenderError('decide.ts.ejs', rootCause);
     const scaffoldErr = new ScaffoldError('Checkout', 'PlaceOrder', 'command', templateErr);
@@ -519,9 +521,9 @@ describe('createServerFailureEvent', () => {
         destination: '.',
         error: expect.stringContaining('[template=decide.ts.ejs]'),
         model: makeModel(),
-        flowName: 'Checkout',
-        sliceName: 'PlaceOrder',
-        sliceType: 'command',
+        sceneName: 'Checkout',
+        momentName: 'PlaceOrder',
+        momentType: 'command',
       },
       timestamp: expect.any(Date),
       requestId: 'req-1',
@@ -530,7 +532,7 @@ describe('createServerFailureEvent', () => {
     expect(event.data.error).toContain('Cannot read properties of undefined');
   });
 
-  it('returns undefined flow/slice/type for plain Error', () => {
+  it('returns undefined scene/slice/type for plain Error', () => {
     const plainError = new Error('something went wrong');
 
     const event = createServerFailureEvent(makeCommand(), plainError);
@@ -542,9 +544,9 @@ describe('createServerFailureEvent', () => {
         destination: '.',
         error: expect.stringContaining('something went wrong'),
         model: makeModel(),
-        flowName: undefined,
-        sliceName: undefined,
-        sliceType: undefined,
+        sceneName: undefined,
+        momentName: undefined,
+        momentType: undefined,
       },
       timestamp: expect.any(Date),
       requestId: 'req-1',
@@ -562,9 +564,9 @@ describe('createServerFailureEvent', () => {
         destination: '.',
         error: 'Unknown error occurred',
         model: makeModel(),
-        flowName: undefined,
-        sliceName: undefined,
-        sliceType: undefined,
+        sceneName: undefined,
+        momentName: undefined,
+        momentType: undefined,
       },
       timestamp: expect.any(Date),
       requestId: 'req-1',