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

package/src/codegen/scaffoldFromSchema.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import type { Model, Narrative, Slice } from '@auto-engineer/narrative';
+import type { Model, Moment, Scene } from '@auto-engineer/narrative';
 import { camelCase, pascalCase } from 'change-case';
 import createDebug from 'debug';
 import ejs from 'ejs';
@@ -11,8 +11,8 @@ import { ensureDirExists, ensureDirPath, toKebabCase } from './utils/path';
 const debug = createDebug('auto:server-generator-apollo-emmett:scaffold');
 const debugTemplate = createDebug('auto:server-generator-apollo-emmett:scaffold:template');
 const debugFiles = createDebug('auto:server-generator-apollo-emmett:scaffold:files');
-const debugFlow = createDebug('auto:server-generator-apollo-emmett:scaffold:flow');
-const debugSlice = createDebug('auto:server-generator-apollo-emmett:scaffold:slice');
+const debugScene = createDebug('auto:server-generator-apollo-emmett:scaffold:flow');
+const debugMoment = createDebug('auto:server-generator-apollo-emmett:scaffold:moment');
 const debugPlan = createDebug('auto:server-generator-apollo-emmett:scaffold:plan');
 const debugFormat = createDebug('auto:server-generator-apollo-emmett:scaffold:format');
 
@@ -20,7 +20,7 @@ import {
   isInlineObject,
   isInlineObjectArray,
   parseInlineObjectFields,
-  parseSliceRequest,
+  parseMomentRequest,
 } from '@auto-engineer/narrative';
 import {
   baseTs,
@@ -45,8 +45,8 @@ import {
 import { getStreamFromSink } from './extract/data-sink';
 import { buildEventIdFieldMap } from './extract/projection';
 import { buildArgToStateFieldMap } from './extract/query';
-import { normalizeSliceForTemplate } from './extract/slice-normalizer';
-import { extractGwtSpecsFromSlice, type GwtResult } from './extract/step-converter';
+import { normalizeMomentForTemplate } from './extract/slice-normalizer';
+import { extractGwtSpecsFromMoment, type GwtResult } from './extract/step-converter';
 import type { GwtCondition, Message, MessageDefinition } from './types';
 
 export class TemplateRenderError extends Error {
@@ -60,16 +60,16 @@ export class TemplateRenderError extends Error {
 }
 
 export class ScaffoldError extends Error {
-  readonly flowName: string;
-  readonly sliceName: string;
-  readonly sliceType: string;
+  readonly sceneName: string;
+  readonly momentName: string;
+  readonly momentType: string;
 
-  constructor(flowName: string, sliceName: string, sliceType: string, cause: unknown) {
-    super(`Scaffold failed for ${flowName}/${sliceName} (${sliceType})`, { cause });
+  constructor(sceneName: string, momentName: string, momentType: string, cause: unknown) {
+    super(`Scaffold failed for ${sceneName}/${momentName} (${momentType})`, { cause });
     this.name = 'ScaffoldError';
-    this.flowName = flowName;
-    this.sliceName = sliceName;
-    this.sliceType = sliceType;
+    this.sceneName = sceneName;
+    this.momentName = momentName;
+    this.momentType = momentType;
   }
 }
 
@@ -269,8 +269,8 @@ export interface FilePlan {
 
 export interface DuplicateCommandInfo {
   command: string;
-  existingFlow: string;
-  existingSlice: string;
+  existingScene: string;
+  existingMoment: string;
 }
 
 export interface FieldIssue {
@@ -537,19 +537,19 @@ function formatDataObject(exampleData: Record<string, unknown>, schema: Message
 
 async function generateFileForTemplate(
   templateFile: string,
-  slice: Slice,
-  sliceDir: string,
+  slice: Moment,
+  momentDir: string,
   templateData: Record<string, unknown>,
   unionToEnumName: Map<string, string> = new Map(),
 ): Promise<FilePlan> {
   debugFiles('Generating file from template: %s', templateFile);
-  debugFiles('  Slice type: %s', slice.type);
-  debugFiles('  Slice directory: %s', sliceDir);
+  debugFiles('  Moment type: %s', slice.type);
+  debugFiles('  Moment directory: %s', momentDir);
 
   const __dirname = dirname(fileURLToPath(import.meta.url));
   const templatePath = path.join(__dirname, './templates', slice.type, templateFile);
   const fileName = templateFile.replace(/\.ts\.ejs$/, '.ts');
-  const outputPath = path.join(sliceDir, fileName);
+  const outputPath = path.join(momentDir, fileName);
 
   debugFiles('  Template path: %s', templatePath);
   debugFiles('  Output path: %s', outputPath);
@@ -627,8 +627,8 @@ function extractUsedErrors(gwtMapping: Record<string, (GwtCondition & { failingF
 }
 
 async function prepareTemplateData(
-  slice: Slice,
-  flow: Narrative,
+  slice: Moment,
+  scene: Scene,
   commands: Message[],
   events: Message[],
   states: Message[],
@@ -637,9 +637,9 @@ async function prepareTemplateData(
   projectionSingleton: boolean | undefined,
   allMessages?: MessageDefinition[],
   integrations?: Model['integrations'],
-  flows?: Narrative[],
+  scenes?: Scene[],
 ): Promise<Record<string, unknown>> {
-  debug('Preparing template data for slice: %s (flow: %s)', slice.name, flow.name);
+  debug('Preparing template data for moment: %s (scene: %s)', slice.name, scene.name);
   debug('  Commands: %d', commands.length);
   debug('  Events: %d', events.length);
   debug('  States: %d', states.length);
@@ -662,11 +662,11 @@ async function prepareTemplateData(
   const uniqueCommands = Array.from(new Map(commands.map((c) => [c.type, c])).values());
   debug('  Unique commands: %d', uniqueCommands.length);
 
-  const allowedForSlice = new Set(Object.keys(gwtMapping));
+  const allowedForMoment = new Set(Object.keys(gwtMapping));
   const filteredCommands =
-    allowedForSlice.size > 0 ? uniqueCommands.filter((c) => allowedForSlice.has(c.type)) : uniqueCommands;
+    allowedForMoment.size > 0 ? uniqueCommands.filter((c) => allowedForMoment.has(c.type)) : uniqueCommands;
 
-  const eventImportGroups = groupEventImports({ currentSliceName: slice.name, currentFlowName: flow.name, events });
+  const eventImportGroups = groupEventImports({ currentMomentName: slice.name, currentSceneName: scene.name, events });
   const allEventTypesArray = getAllEventTypes(events);
   const allEventTypes = createEventUnionType(events);
   const selfImportedTypes = new Set(
@@ -683,9 +683,9 @@ async function prepareTemplateData(
     messagesByName,
   );
 
-  const normalizedSlice = normalizeSliceForTemplate(slice, allMessages);
+  const normalizedMoment = normalizeMomentForTemplate(slice, allMessages);
 
-  const normalizedRules = normalizedSlice.server?.specs?.rules ?? [];
+  const normalizedRules = normalizedMoment.server?.specs?.rules ?? [];
   const eventCommandPairs: Array<{ eventType: string; commandType: string }> = [];
   const seenPairKeys = new Set<string>();
   for (const rule of normalizedRules) {
@@ -703,16 +703,16 @@ async function prepareTemplateData(
   }
 
   const eventIdFieldMap =
-    slice.type === 'query' && flows ? buildEventIdFieldMap(events, flows, findEventSource) : undefined;
+    slice.type === 'query' && scenes ? buildEventIdFieldMap(events, scenes, findEventSource) : undefined;
 
   const stateFieldNames = new Set((queryMessage?.fields ?? []).map((f) => f.name));
   const argToStateFieldMap =
     slice.type === 'query' ? buildArgToStateFieldMap(queryGwtMapping, stateFieldNames, slice.mappings) : undefined;
 
   return {
-    flowName: flow.name,
-    sliceName: slice.name,
-    slice: normalizedSlice,
+    sceneName: scene.name,
+    momentName: slice.name,
+    slice: normalizedMoment,
     stream: { pattern: streamPattern, id: streamId },
     commands: filteredCommands,
     events,
@@ -724,7 +724,7 @@ async function prepareTemplateData(
     projectionIdField,
     projectionSingleton,
     projectionName,
-    parsedRequest: parseSliceRequest(slice),
+    parsedRequest: parseMomentRequest(slice),
     messages: allMessages,
     message:
       slice.type === 'query' && allMessages
@@ -744,17 +744,17 @@ async function prepareTemplateData(
 
 function annotateEventSources(
   events: Message[],
-  flows: Narrative[],
+  scenes: Scene[],
   fallbackFlowName: string,
-  fallbackSliceName: string,
-  sliceType: string,
+  fallbackMomentName: string,
+  momentType: string,
 ): void {
   debug('Annotating event sources for %d events', events.length);
   for (const event of events) {
-    const match = findEventSource(flows, event.type);
-    event.sourceFlowName = match?.flowName ?? fallbackFlowName;
-    event.sourceSliceName = match?.sliceName ?? (sliceType === 'react' ? undefined : fallbackSliceName);
-    debug('  Event %s: flow=%s, slice=%s', event.type, event.sourceFlowName, event.sourceSliceName);
+    const match = findEventSource(scenes, event.type);
+    event.sourceSceneName = match?.sceneName ?? fallbackFlowName;
+    event.sourceMomentName = match?.momentName ?? (momentType === 'react' ? undefined : fallbackMomentName);
+    debug('  Event %s: scene=%s, slice=%s', event.type, event.sourceSceneName, event.sourceMomentName);
   }
 }
 
@@ -762,113 +762,113 @@ function hasEventInGwtSpecs(gwtSpecs: GwtResult[], eventType: string): boolean {
   return gwtSpecs.some((g) => g.then.some((t) => 'eventRef' in t && t.eventRef === eventType));
 }
 
-function canSliceProduceEvent(slice: Slice): boolean {
+function canMomentProduceEvent(slice: Moment): boolean {
   return ['command', 'react'].includes(slice.type) && 'server' in slice && Boolean(slice.server?.specs);
 }
 
-export function findEventSource(flows: Narrative[], eventType: string): { flowName: string; sliceName: string } | null {
-  debugSlice('Finding source for event: %s', eventType);
+export function findEventSource(scenes: Scene[], eventType: string): { sceneName: string; momentName: string } | null {
+  debugMoment('Finding source for event: %s', eventType);
 
-  for (const flow of flows) {
-    for (const slice of flow.slices) {
-      if (canSliceProduceEvent(slice)) {
-        const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  for (const scene of scenes) {
+    for (const slice of scene.moments) {
+      if (canMomentProduceEvent(slice)) {
+        const gwtSpecs = extractGwtSpecsFromMoment(slice);
         if (hasEventInGwtSpecs(gwtSpecs, eventType)) {
-          debugSlice('  Found event source in flow: %s, slice: %s', flow.name, slice.name);
-          return { flowName: flow.name, sliceName: slice.name };
+          debugMoment('  Found event source in scene: %s, slice: %s', scene.name, slice.name);
+          return { sceneName: scene.name, momentName: slice.name };
         }
       }
       if ('server' in slice && slice.server?.data?.items) {
         for (const item of slice.server.data.items) {
           if (item.target.type === 'Event' && item.target.name === eventType) {
-            debugSlice('  Found event source in data target: flow=%s, slice=%s', flow.name, slice.name);
-            return { flowName: flow.name, sliceName: slice.name };
+            debugMoment('  Found event source in data target: scene=%s, slice=%s', scene.name, slice.name);
+            return { sceneName: scene.name, momentName: slice.name };
           }
         }
       }
     }
   }
 
-  debugSlice('  No source found for event: %s', eventType);
+  debugMoment('  No source found for event: %s', eventType);
   return null;
 }
 
 function annotateCommandSources(
   commands: Message[],
-  flows: Narrative[],
+  scenes: Scene[],
   fallbackFlowName: string,
-  fallbackSliceName: string,
-  sliceType: string,
+  fallbackMomentName: string,
+  momentType: string,
 ): void {
   debug('Annotating command sources for %d commands', commands.length);
   for (const command of commands) {
-    const match = findCommandSource(flows, command.type);
-    command.sourceFlowName = match?.flowName ?? fallbackFlowName;
-    command.sourceSliceName = match?.sliceName ?? (sliceType === 'react' ? undefined : fallbackSliceName);
-    debug('  Command %s: flow=%s, slice=%s', command.type, command.sourceFlowName, command.sourceSliceName);
+    const match = findCommandSource(scenes, command.type);
+    command.sourceSceneName = match?.sceneName ?? fallbackFlowName;
+    command.sourceMomentName = match?.momentName ?? (momentType === 'react' ? undefined : fallbackMomentName);
+    debug('  Command %s: scene=%s, slice=%s', command.type, command.sourceSceneName, command.sourceMomentName);
   }
 }
 
-function findCommandSource(flows: Narrative[], commandType: string): { flowName: string; sliceName: string } | null {
-  debugSlice('Finding source for command: %s', commandType);
-  for (const flow of flows) {
-    for (const slice of flow.slices) {
+function findCommandSource(scenes: Scene[], commandType: string): { sceneName: string; momentName: string } | null {
+  debugMoment('Finding source for command: %s', commandType);
+  for (const scene of scenes) {
+    for (const slice of scene.moments) {
       if (slice.type !== 'command') continue;
 
-      const gwtSpecs = extractGwtSpecsFromSlice(slice);
+      const gwtSpecs = extractGwtSpecsFromMoment(slice);
       if (gwtSpecs.some((g) => !Array.isArray(g.when) && 'commandRef' in g.when && g.when.commandRef === commandType)) {
-        debugSlice('  Found command source in flow: %s, slice: %s', flow.name, slice.name);
-        return { flowName: flow.name, sliceName: slice.name };
+        debugMoment('  Found command source in scene: %s, slice: %s', scene.name, slice.name);
+        return { sceneName: scene.name, momentName: slice.name };
       }
     }
   }
-  debugSlice('  No source found for command: %s', commandType);
+  debugMoment('  No source found for command: %s', commandType);
   return null;
 }
 
-async function generateFilesForSlice(
-  slice: Slice,
-  flow: Narrative,
-  sliceDir: string,
+async function generateFilesForMoment(
+  slice: Moment,
+  scene: Scene,
+  momentDir: string,
   messages: MessageDefinition[],
-  flows: Narrative[],
+  scenes: Scene[],
   unionToEnumName: Map<string, string>,
   integrations?: Model['integrations'],
-  registeredCommands?: Map<string, { flowName: string; sliceName: string }>,
+  registeredCommands?: Map<string, { sceneName: string; momentName: string }>,
 ): Promise<{ plans: FilePlan[]; duplicateCommands: DuplicateCommandInfo[] }> {
-  debugSlice('Generating files for slice: %s (type: %s)', slice.name, slice.type);
-  debugSlice('  Flow: %s', flow.name);
-  debugSlice('  Output directory: %s', sliceDir);
+  debugMoment('Generating files for moment: %s (type: %s)', slice.name, slice.type);
+  debugMoment('  Scene: %s', scene.name);
+  debugMoment('  Output directory: %s', momentDir);
 
   const duplicateCommands: DuplicateCommandInfo[] = [];
 
   const templates = defaultFilesByType[slice.type];
   if (!templates?.length) {
-    debugSlice('  No templates found for slice type: %s', slice.type);
+    debugMoment('  No templates found for moment type: %s', slice.type);
     return { plans: [], duplicateCommands };
   }
-  debugSlice('  Found %d templates for slice type', templates.length);
+  debugMoment('  Found %d templates for moment type', templates.length);
 
   if (
     slice.type === 'react' &&
     !slice.server?.specs?.some((spec) => spec.rules?.some((rule) => rule.examples?.length > 0))
   ) {
-    debugSlice('  Skipping react slice with no examples: %s', slice.name);
+    debugMoment('  Skipping react slice with no examples: %s', slice.name);
     return { plans: [], duplicateCommands };
   }
 
   const extracted = extractMessagesFromSpecs(slice, messages);
-  debugSlice('  Extracted messages:');
-  debugSlice('    Commands: %d', extracted.commands.length);
-  debugSlice('    Events: %d', extracted.events.length);
-  debugSlice('    States: %d', extracted.states.length);
-  debugSlice(
-    '💡 Events for slice',
+  debugMoment('  Extracted messages:');
+  debugMoment('    Commands: %d', extracted.commands.length);
+  debugMoment('    Events: %d', extracted.events.length);
+  debugMoment('    States: %d', extracted.states.length);
+  debugMoment(
+    '💡 Events for moment',
     slice.name,
     extracted.events.map((e) => e.type),
   );
-  annotateEventSources(extracted.events, flows, flow.name, slice.name, slice.type);
-  annotateCommandSources(extracted.commands, flows, flow.name, slice.name, slice.type);
+  annotateEventSources(extracted.events, scenes, scene.name, slice.name, slice.type);
+  annotateCommandSources(extracted.commands, scenes, scene.name, slice.name, slice.type);
 
   let filteredTemplates = templates;
 
@@ -880,33 +880,33 @@ async function generateFilesForSlice(
       for (const ct of commandTypes) {
         const existing = registeredCommands.get(ct);
         if (existing) {
-          debugSlice(
+          debugMoment(
             '  Duplicate command handler detected: %s (already in %s/%s)',
             ct,
-            existing.flowName,
-            existing.sliceName,
+            existing.sceneName,
+            existing.momentName,
           );
           duplicateCommands.push({
             command: ct,
-            existingFlow: existing.flowName,
-            existingSlice: existing.sliceName,
+            existingScene: existing.sceneName,
+            existingMoment: existing.momentName,
           });
         }
       }
       filteredTemplates = templates.filter((t) => t !== 'register.ts.ejs');
-      debugSlice('  Filtered out register.ts.ejs for duplicate command slice');
+      debugMoment('  Filtered out register.ts.ejs for duplicate command moment');
     }
 
     for (const ct of commandTypes) {
       if (!registeredCommands.has(ct)) {
-        registeredCommands.set(ct, { flowName: flow.name, sliceName: slice.name });
+        registeredCommands.set(ct, { sceneName: scene.name, momentName: slice.name });
       }
     }
   }
 
   const templateData = await prepareTemplateData(
     slice,
-    flow,
+    scene,
     extracted.commands,
     extracted.events,
     extracted.states,
@@ -915,28 +915,29 @@ async function generateFilesForSlice(
     extracted.projectionSingleton,
     messages,
     integrations,
-    flows,
+    scenes,
   );
 
-  debugSlice('  Generating %d files from templates', filteredTemplates.length);
+  debugMoment('  Generating %d files from templates', filteredTemplates.length);
   const plans = await Promise.all(
     filteredTemplates.map((template) =>
-      generateFileForTemplate(template, slice, sliceDir, templateData, unionToEnumName),
+      generateFileForTemplate(template, slice, momentDir, templateData, unionToEnumName),
     ),
   );
-  debugSlice('  Generated %d file plans for slice: %s', plans.length, slice.name);
+  debugMoment('  Generated %d file plans for moment: %s', plans.length, slice.name);
   return { plans, duplicateCommands };
 }
 
 export async function generateScaffoldFilePlans(
-  flows: Narrative[],
+  scenes: Scene[],
   messages: Model['messages'],
   integrations?: Model['integrations'],
-  baseDir = 'src/domain/flows',
-  affectedSliceIds?: Set<string>,
+  baseDir = 'src/domain/narratives',
+  affectedMomentIds?: Set<string>,
+  narratives?: Model['narratives'],
 ): Promise<ScaffoldResult> {
   debug('Generating scaffold file plans');
-  debug('  Number of flows: %d', flows.length);
+  debug('  Number of scenes: %d', scenes.length);
   debug('  Number of messages: %d', messages?.length ?? 0);
   debug('  Base directory: %s', baseDir);
 
@@ -969,46 +970,59 @@ export async function generateScaffoldFilePlans(
   const { enums, unionToEnumName } = extractEnumsFromMessages(sanitizedMessages);
   debug('  Extracted %d enums from messages', enums.length);
 
-  const domainBaseDir = baseDir.replace(/\/flows$/, '');
+  const domainBaseDir = baseDir.replace(/\/scenes$/, '');
   await writeSharedTypes(domainBaseDir, enums);
 
   const allPlans: FilePlan[] = [];
   const allDuplicateCommands: DuplicateCommandInfo[] = [];
-  const registeredCommands = new Map<string, { flowName: string; sliceName: string }>();
-
-  for (const flow of flows) {
-    debugFlow('Processing flow: %s', flow.name);
-    const flowDir = ensureDirPath(baseDir, toKebabCase(flow.name));
-    debugFlow('  Flow directory: %s', flowDir);
-    debugFlow('  Number of slices: %d', flow.slices.length);
-
-    for (const slice of flow.slices) {
-      if (affectedSliceIds) {
-        const sliceId = `${toKebabCase(flow.name)}/${toKebabCase(slice.name)}`;
-        if (!affectedSliceIds.has(sliceId)) continue;
+  const registeredCommands = new Map<string, { sceneName: string; momentName: string }>();
+
+  const sceneToNarrative = new Map<string, string>();
+  if (narratives) {
+    for (const narrative of narratives) {
+      for (const sceneId of narrative.sceneIds) {
+        sceneToNarrative.set(sceneId, narrative.name);
+      }
+    }
+  }
+
+  for (const scene of scenes) {
+    debugScene('Processing scene: %s', scene.name);
+    const narrativeName = scene.id ? sceneToNarrative.get(scene.id) : undefined;
+    const sceneDirName = narrativeName
+      ? `${toKebabCase(narrativeName)}_${toKebabCase(scene.name)}`
+      : toKebabCase(scene.name);
+    const sceneDir = ensureDirPath(baseDir, sceneDirName);
+    debugScene('  Scene directory: %s', sceneDir);
+    debugScene('  Number of moments: %d', scene.moments.length);
+
+    for (const slice of scene.moments) {
+      if (affectedMomentIds) {
+        const sliceId = `${toKebabCase(scene.name)}/${toKebabCase(slice.name)}`;
+        if (!affectedMomentIds.has(sliceId)) continue;
       }
-      debugFlow('  Processing slice: %s (type: %s)', slice.name, slice.type);
-      const sliceDir = ensureDirPath(flowDir, toKebabCase(slice.name));
-      debugFlow('    Slice directory: %s', sliceDir);
+      debugScene('  Processing slice: %s (type: %s)', slice.name, slice.type);
+      const momentDir = ensureDirPath(sceneDir, toKebabCase(slice.name));
+      debugScene('    Moment directory: %s', momentDir);
       try {
-        const { plans, duplicateCommands } = await generateFilesForSlice(
+        const { plans, duplicateCommands } = await generateFilesForMoment(
           slice,
-          flow,
-          sliceDir,
+          scene,
+          momentDir,
           sanitizedMessages,
-          flows,
+          scenes,
           unionToEnumName,
           integrations,
           registeredCommands,
         );
-        debugFlow('    Generated %d plans for slice', plans.length);
+        debugScene('    Generated %d plans for moment', plans.length);
         allPlans.push(...plans);
         allDuplicateCommands.push(...duplicateCommands);
       } catch (error) {
-        throw new ScaffoldError(flow.name, slice.name, slice.type, error);
+        throw new ScaffoldError(scene.name, slice.name, slice.type, error);
       }
     }
-    debugFlow('  Completed flow: %s', flow.name);
+    debugScene('  Completed scene: %s', scene.name);
   }
 
   debug('Total file plans generated: %d', allPlans.length);
@@ -1036,16 +1050,16 @@ export async function writeScaffoldFilePlans(plans: FilePlan[]) {
 }
 
 export async function scaffoldFromSchema(
-  flows: Narrative[],
+  scenes: Scene[],
   messages: Model['messages'],
-  baseDir = 'src/domain/flows',
+  baseDir = 'src/domain/narratives',
 ): Promise<void> {
   debug('Starting scaffold from schema');
-  debug('  Flows: %d', flows.length);
+  debug('  Scenes: %d', scenes.length);
   debug('  Messages: %d', messages?.length ?? 0);
   debug('  Base directory: %s', baseDir);
 
-  const { plans } = await generateScaffoldFilePlans(flows, messages, undefined, baseDir);
+  const { plans } = await generateScaffoldFilePlans(scenes, messages, undefined, baseDir);
   debug('Generated %d file plans, writing to disk...', plans.length);
 
   await writeScaffoldFilePlans(plans);

package/src/codegen/templates/command/commands.specs.ts

@@ -6,10 +6,10 @@ describe('commands.ts.ejs', () => {
   it('should generate correct command file', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      narratives: [
+      scenes: [
         {
           name: 'Host creates a listing',
-          slices: [
+          moments: [
             {
               type: 'command',
               name: 'Create listing',
@@ -77,7 +77,7 @@ describe('commands.ts.ejs', () => {
       ],
     };
 
-    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
     const commandFile = plans.find((p) => p.outputPath.endsWith('commands.ts'));
 
     expect(commandFile?.contents).toMatchInlineSnapshot(`