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

package/src/codegen/findEventSource.specs.ts

@@ -1,13 +1,13 @@
-import type { Narrative } from '@auto-engineer/narrative';
+import type { Scene } from '@auto-engineer/narrative';
 import { describe, expect, it } from 'vitest';
 import { findEventSource } from './scaffoldFromSchema';
 
 describe('findEventSource', () => {
   it('should find event in command slice GWT then steps', () => {
-    const flows: Narrative[] = [
+    const scenes: Scene[] = [
       {
-        name: 'order flow',
-        slices: [
+        name: 'order scene',
+        moments: [
           {
             type: 'command',
             name: 'place order',
@@ -39,17 +39,17 @@ describe('findEventSource', () => {
       },
     ];
 
-    expect(findEventSource(flows, 'OrderPlaced')).toEqual({
-      flowName: 'order flow',
-      sliceName: 'place order',
+    expect(findEventSource(scenes, 'OrderPlaced')).toEqual({
+      sceneName: 'order scene',
+      momentName: 'place order',
     });
   });
 
   it('should find event produced by react data target', () => {
-    const flows: Narrative[] = [
+    const scenes: Scene[] = [
       {
-        name: 'booking flow',
-        slices: [
+        name: 'booking scene',
+        moments: [
           {
             type: 'react',
             name: 'notify barber of new booking',
@@ -89,17 +89,17 @@ describe('findEventSource', () => {
       },
     ];
 
-    expect(findEventSource(flows, 'BarberNotified')).toEqual({
-      flowName: 'booking flow',
-      sliceName: 'notify barber of new booking',
+    expect(findEventSource(scenes, 'BarberNotified')).toEqual({
+      sceneName: 'booking scene',
+      momentName: 'notify barber of new booking',
     });
   });
 
   it('should find event in command slice data.items when not in GWT specs', () => {
-    const flows: Narrative[] = [
+    const scenes: Scene[] = [
       {
-        name: 'workout flow',
-        slices: [
+        name: 'workout scene',
+        moments: [
           {
             type: 'command',
             name: 'submit workout log',
@@ -143,17 +143,17 @@ describe('findEventSource', () => {
       },
     ];
 
-    expect(findEventSource(flows, 'PointsEarned')).toEqual({
-      flowName: 'workout flow',
-      sliceName: 'submit workout log',
+    expect(findEventSource(scenes, 'PointsEarned')).toEqual({
+      sceneName: 'workout scene',
+      momentName: 'submit workout log',
     });
   });
 
   it('should return null when event is not found anywhere', () => {
-    const flows: Narrative[] = [
+    const scenes: Scene[] = [
       {
-        name: 'empty flow',
-        slices: [
+        name: 'empty scene',
+        moments: [
           {
             type: 'query',
             name: 'some query',
@@ -166,6 +166,6 @@ describe('findEventSource', () => {
       },
     ];
 
-    expect(findEventSource(flows, 'NonExistentEvent')).toEqual(null);
+    expect(findEventSource(scenes, 'NonExistentEvent')).toEqual(null);
   });
 });

package/src/codegen/scaffoldErrors.specs.ts

@@ -20,7 +20,7 @@ describe('TemplateRenderError', () => {
 });
 
 describe('ScaffoldError', () => {
-  it('captures flow/slice/type and chains cause', () => {
+  it('captures scene/slice/type and chains cause', () => {
     const templateError = new TemplateRenderError('evolve.ts.ejs', new Error('bad data'));
     const error = new ScaffoldError('Checkout', 'PlaceOrder', 'command', templateError);
 
@@ -28,9 +28,9 @@ describe('ScaffoldError', () => {
       expect.objectContaining({
         name: 'ScaffoldError',
         message: 'Scaffold failed for Checkout/PlaceOrder (command)',
-        flowName: 'Checkout',
-        sliceName: 'PlaceOrder',
-        sliceType: 'command',
+        sceneName: 'Checkout',
+        momentName: 'PlaceOrder',
+        momentType: 'command',
         cause: templateError,
       }),
     );

package/src/codegen/scaffoldFromSchema.filter.specs.ts

@@ -1,10 +1,10 @@
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import type { CommandSlice, Message, Narrative } from '@auto-engineer/narrative';
+import type { CommandMoment, Message, Scene } from '@auto-engineer/narrative';
 import { describe, expect, it } from 'vitest';
 import { generateScaffoldFilePlans } from './scaffoldFromSchema';
 
-const makeSlice = (name: string): CommandSlice => ({
+const makeMoment = (name: string): CommandMoment => ({
   name,
   type: 'command',
   client: { specs: [] },
@@ -40,14 +40,14 @@ const messages: Message[] = [
   { name: 'RemoveTodoDone', type: 'event', fields: [{ name: 'id', type: 'string', required: true }] },
 ];
 
-const flows: Narrative[] = [
+const scenes: Scene[] = [
   {
     name: 'Todo',
-    slices: [makeSlice('AddTodo'), makeSlice('RemoveTodo')],
+    moments: [makeMoment('AddTodo'), makeMoment('RemoveTodo')],
   },
 ];
 
-const makeSliceWithCommand = (name: string, commandName: string): CommandSlice => ({
+const makeMomentWithCommand = (name: string, commandName: string): CommandMoment => ({
   name,
   type: 'command',
   client: { specs: [] },
@@ -76,55 +76,55 @@ const makeSliceWithCommand = (name: string, commandName: string): CommandSlice =
   },
 });
 
-describe('generateScaffoldFilePlans with affectedSliceIds filter', () => {
+describe('generateScaffoldFilePlans with affectedMomentIds filter', () => {
   const baseDir = join(tmpdir(), `scaffold-filter-test-${Date.now()}`);
 
-  it('generates plans for all slices when no filter is provided', async () => {
-    const { plans } = await generateScaffoldFilePlans(flows, messages, undefined, baseDir);
-    const sliceDirs = new Set(plans.map((p) => p.outputPath.split('/').slice(-3, -1).join('/')));
-    expect(sliceDirs.has('todo/add-todo')).toBe(true);
-    expect(sliceDirs.has('todo/remove-todo')).toBe(true);
+  it('generates plans for all moments when no filter is provided', async () => {
+    const { plans } = await generateScaffoldFilePlans(scenes, messages, undefined, baseDir);
+    const momentDirs = new Set(plans.map((p) => p.outputPath.split('/').slice(-3, -1).join('/')));
+    expect(momentDirs.has('todo/add-todo')).toBe(true);
+    expect(momentDirs.has('todo/remove-todo')).toBe(true);
   });
 
-  it('generates plans only for affected slices when filter is provided', async () => {
-    const affectedSliceIds = new Set(['todo/add-todo']);
-    const { plans } = await generateScaffoldFilePlans(flows, messages, undefined, baseDir, affectedSliceIds);
-    const sliceDirs = new Set(plans.map((p) => p.outputPath.split('/').slice(-3, -1).join('/')));
-    expect(sliceDirs.has('todo/add-todo')).toBe(true);
-    expect(sliceDirs.has('todo/remove-todo')).toBe(false);
+  it('generates plans only for affected moments when filter is provided', async () => {
+    const affectedMomentIds = new Set(['todo/add-todo']);
+    const { plans } = await generateScaffoldFilePlans(scenes, messages, undefined, baseDir, affectedMomentIds);
+    const momentDirs = new Set(plans.map((p) => p.outputPath.split('/').slice(-3, -1).join('/')));
+    expect(momentDirs.has('todo/add-todo')).toBe(true);
+    expect(momentDirs.has('todo/remove-todo')).toBe(false);
   });
 });
 
 describe('generateScaffoldFilePlans with duplicate command handlers', () => {
   const baseDir = join(tmpdir(), `scaffold-duplicate-test-${Date.now()}`);
 
-  it('skips register.ts for slices with duplicate command handlers across flows', async () => {
+  it('skips register.ts for moments with duplicate command handlers across scenes', async () => {
     const duplicateMessages: Message[] = [
       { name: 'DoAction', type: 'command', fields: [{ name: 'id', type: 'string', required: true }] },
       { name: 'DoActionDone', type: 'event', fields: [{ name: 'id', type: 'string', required: true }] },
     ];
 
-    const duplicateFlows: Narrative[] = [
-      { name: 'FlowA', slices: [makeSliceWithCommand('HandleAction', 'DoAction')] },
-      { name: 'FlowB', slices: [makeSliceWithCommand('ProcessAction', 'DoAction')] },
+    const duplicateScenes: Scene[] = [
+      { name: 'FlowA', moments: [makeMomentWithCommand('HandleAction', 'DoAction')] },
+      { name: 'FlowB', moments: [makeMomentWithCommand('ProcessAction', 'DoAction')] },
     ];
 
-    const result = await generateScaffoldFilePlans(duplicateFlows, duplicateMessages, undefined, baseDir);
+    const result = await generateScaffoldFilePlans(duplicateScenes, duplicateMessages, undefined, baseDir);
 
-    const flowAFiles = result.plans.filter((p) => p.outputPath.includes('flow-a/handle-action'));
-    const flowBFiles = result.plans.filter((p) => p.outputPath.includes('flow-b/process-action'));
+    const sceneAFiles = result.plans.filter((p) => p.outputPath.includes('flow-a/handle-action'));
+    const sceneBFiles = result.plans.filter((p) => p.outputPath.includes('flow-b/process-action'));
 
-    const flowAHasRegister = flowAFiles.some((p) => p.outputPath.endsWith('register.ts'));
-    const flowBHasRegister = flowBFiles.some((p) => p.outputPath.endsWith('register.ts'));
+    const sceneAHasRegister = sceneAFiles.some((p) => p.outputPath.endsWith('register.ts'));
+    const sceneBHasRegister = sceneBFiles.some((p) => p.outputPath.endsWith('register.ts'));
 
-    expect(flowAHasRegister).toBe(true);
-    expect(flowBHasRegister).toBe(false);
+    expect(sceneAHasRegister).toBe(true);
+    expect(sceneBHasRegister).toBe(false);
 
     expect(result.duplicateCommands).toEqual([
       {
         command: 'DoAction',
-        existingFlow: 'FlowA',
-        existingSlice: 'HandleAction',
+        existingScene: 'FlowA',
+        existingMoment: 'HandleAction',
       },
     ]);
   });
@@ -146,7 +146,7 @@ describe('generateScaffoldFilePlans with invalid field names', () => {
       { name: 'AddTodoDone', type: 'event', fields: [{ name: 'id', type: 'string', required: true }] },
     ];
 
-    const singleFlow: Narrative[] = [{ name: 'Todo', slices: [makeSlice('AddTodo')] }];
+    const singleFlow: Scene[] = [{ name: 'Todo', moments: [makeMoment('AddTodo')] }];
 
     const result = await generateScaffoldFilePlans(singleFlow, messagesWithInvalid, undefined, baseDir);
 
@@ -179,7 +179,7 @@ describe('generateScaffoldFilePlans with malformed map types', () => {
       { name: 'LogWorkoutDone', type: 'event', fields: [{ name: 'id', type: 'string', required: true }] },
     ];
 
-    const singleFlow: Narrative[] = [{ name: 'Workout', slices: [makeSlice('LogWorkout')] }];
+    const singleFlow: Scene[] = [{ name: 'Workout', moments: [makeMoment('LogWorkout')] }];
 
     const result = await generateScaffoldFilePlans(singleFlow, messagesWithMalformedType, undefined, baseDir);