@auto-engineer/server-generator-nestjs 1.139.0 → 1.140.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @auto-engineer/server-generator-nestjs
 
+## 1.140.0
+
+### Minor Changes
+
+- [`2b1315d`](https://github.com/BeOnAuto/auto-engineer/commit/2b1315d27aa7fbb5137f098c174b7b1daebbb821) Thanks [@github-actions[bot]](https://github.com/github-actions%5Bbot%5D)! - - **react-gen**: domain-aware theming, flexible layouts, chain-of-thought color selection
+  - **global**: version packages
+
+### Patch Changes
+
+- [`26e5682`](https://github.com/BeOnAuto/auto-engineer/commit/26e56821d984838ba3720baca89c74fc012357c5) Thanks [@SamHatoum](https://github.com/SamHatoum)! - - Renamed core entity hierarchy: Journey→Narrative, Narrative→Scene, Slice→Moment for clearer domain language
+  - Updated DSL functions and schemas to match new naming (narrative(), scene(), moment())
+  - Server-generated directory structure now uses narrative-prefixed paths under domain/narratives
+  - Narratives are now required on Model and auto-populated by assembleSpecs
+- Updated dependencies [[`2b1315d`](https://github.com/BeOnAuto/auto-engineer/commit/2b1315d27aa7fbb5137f098c174b7b1daebbb821), [`26e5682`](https://github.com/BeOnAuto/auto-engineer/commit/26e56821d984838ba3720baca89c74fc012357c5)]:
+  - @auto-engineer/narrative@1.140.0
+
 ## 1.139.0
 
 ### Minor Changes

package/package.json

@@ -40,7 +40,7 @@
     "ts-node": "^10.9.2",
     "type-fest": "^4.41.0",
     "uuid": "^11.0.0",
-    "@auto-engineer/narrative": "1.139.0"
+    "@auto-engineer/narrative": "1.140.0"
   },
   "publishConfig": {
     "access": "public"
@@ -52,9 +52,9 @@
     "tsx": "^4.19.2",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@auto-engineer/cli": "1.139.0"
+    "@auto-engineer/cli": "1.140.0"
   },
-  "version": "1.139.0",
+  "version": "1.140.0",
   "scripts": {
     "generate:server": "tsx src/cli/index.ts",
     "-DISABLE-build": "tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/src/codegen/templates && mkdir -p dist/src/codegen && cp -r src/codegen/templates dist/src/codegen/templates && cp -r src/shared dist/src",

package/src/codegen/entity-consolidation.ts

@@ -1,4 +1,4 @@
-import type { Narrative } from '@auto-engineer/narrative';
+import type { Scene } from '@auto-engineer/narrative';
 import { camelCase, pascalCase } from 'change-case';
 import createDebug from 'debug';
 import { extractMessagesFromSpecs } from './extract/index.js';
@@ -28,8 +28,8 @@ function isEnumType(tsType: string): boolean {
   return /^"[^"]+"(\s*\|\s*"[^"]+")+$/.test(cleanType) || /^'[^']+'(\s*\|\s*'[^']+)+$/.test(cleanType);
 }
 
-function detectPrimaryKeyField(fields: EntityField[], flowName: string): string | null {
-  const idCandidates = [`${camelCase(flowName)}Id`, 'id', `${camelCase(flowName)}ID`, 'ID'];
+function detectPrimaryKeyField(fields: EntityField[], sceneName: string): string | null {
+  const idCandidates = [`${camelCase(sceneName)}Id`, 'id', `${camelCase(sceneName)}ID`, 'ID'];
 
   for (const candidate of idCandidates) {
     const field = fields.find((f) => f.name === candidate);
@@ -116,8 +116,8 @@ function processMessagesWithFields(
   }
 }
 
-function processCommandSlice(
-  slice: Narrative['slices'][0],
+function processCommandMoment(
+  slice: Scene['moments'][0],
   messages: MessageDefinition[],
   fieldMap: Map<string, EntityField>,
   unionToEnumName: Map<string, string>,
@@ -130,8 +130,8 @@ function processCommandSlice(
   processMessagesWithFields(extracted.events, 'Event', fieldMap, unionToEnumName, enumsUsed);
 }
 
-function processQuerySlice(
-  slice: Narrative['slices'][0],
+function processQueryMoment(
+  slice: Scene['moments'][0],
   messages: MessageDefinition[],
   fieldMap: Map<string, EntityField>,
   unionToEnumName: Map<string, string>,
@@ -143,28 +143,28 @@ function processQuerySlice(
   processMessagesWithFields(extracted.states, 'State', fieldMap, unionToEnumName, enumsUsed);
 }
 
-function collectFieldsFromSlices(
-  flow: Narrative,
+function collectFieldsFromMoments(
+  scene: Scene,
   messages: MessageDefinition[],
   fieldMap: Map<string, EntityField>,
   unionToEnumName: Map<string, string>,
   enumsUsed: Set<string>,
 ): void {
-  for (const slice of flow.slices) {
+  for (const slice of scene.moments) {
     if (slice.type === 'experience') continue;
 
     if (slice.type === 'command') {
-      processCommandSlice(slice, messages, fieldMap, unionToEnumName, enumsUsed);
+      processCommandMoment(slice, messages, fieldMap, unionToEnumName, enumsUsed);
     }
 
     if (slice.type === 'query') {
-      processQuerySlice(slice, messages, fieldMap, unionToEnumName, enumsUsed);
+      processQueryMoment(slice, messages, fieldMap, unionToEnumName, enumsUsed);
     }
   }
 }
 
-function markPrimaryKeyAndIndexes(fields: EntityField[], fieldMap: Map<string, EntityField>, flowName: string): void {
-  const primaryKeyField = detectPrimaryKeyField(fields, flowName);
+function markPrimaryKeyAndIndexes(fields: EntityField[], fieldMap: Map<string, EntityField>, sceneName: string): void {
+  const primaryKeyField = detectPrimaryKeyField(fields, sceneName);
   if (typeof primaryKeyField === 'string' && primaryKeyField.length > 0) {
     const field = fieldMap.get(primaryKeyField);
     if (field !== undefined) {
@@ -172,7 +172,7 @@ function markPrimaryKeyAndIndexes(fields: EntityField[], fieldMap: Map<string, E
       debug('  Detected primary key: %s', primaryKeyField);
     }
   } else {
-    debug('  WARNING: No primary key detected for flow: %s', flowName);
+    debug('  WARNING: No primary key detected for scene: %s', sceneName);
   }
 
   for (const field of fields) {
@@ -184,22 +184,22 @@ function markPrimaryKeyAndIndexes(fields: EntityField[], fieldMap: Map<string, E
 }
 
 export function consolidateEntityFields(
-  flow: Narrative,
+  scene: Scene,
   messages: MessageDefinition[],
   unionToEnumName: Map<string, string>,
 ): ConsolidatedEntity {
-  debug('Consolidating entity fields for flow: %s', flow.name);
+  debug('Consolidating entity fields for scene: %s', scene.name);
 
   const fieldMap = new Map<string, EntityField>();
   const enumsUsed = new Set<string>();
 
-  collectFieldsFromSlices(flow, messages, fieldMap, unionToEnumName, enumsUsed);
+  collectFieldsFromMoments(scene, messages, fieldMap, unionToEnumName, enumsUsed);
 
   const fields = Array.from(fieldMap.values());
-  markPrimaryKeyAndIndexes(fields, fieldMap, flow.name);
+  markPrimaryKeyAndIndexes(fields, fieldMap, scene.name);
 
-  const entityName = `${pascalCase(flow.name)}Entity`;
-  const tableName = `${camelCase(flow.name)}s`;
+  const entityName = `${pascalCase(scene.name)}Entity`;
+  const tableName = `${camelCase(scene.name)}s`;
 
   debug('Consolidated entity: %s with %d fields', entityName, fields.length);
   debug('  Enum imports: %o', Array.from(enumsUsed));

package/src/codegen/extract/data-sink.ts

@@ -1,5 +1,5 @@
-import type { Slice } from '@auto-engineer/narrative';
-import { extractGwtSpecsFromSlice, type GwtResult } from './step-converter';
+import type { Moment } from '@auto-engineer/narrative';
+import { extractGwtSpecsFromMoment, type GwtResult } from './step-converter';
 import type { CommandExample } from './step-types';
 
 function resolveStreamId(stream: string, exampleData: Record<string, unknown>): string {
@@ -30,7 +30,7 @@ function extractExampleDataFromQuery(firstSpec: GwtResult): Record<string, unkno
   return {};
 }
 
-function extractExampleDataFromSpecs(slice: Slice, gwtSpecs: GwtResult[]): Record<string, unknown> {
+function extractExampleDataFromSpecs(slice: Moment, gwtSpecs: GwtResult[]): Record<string, unknown> {
   if (gwtSpecs.length === 0) {
     return {};
   }
@@ -73,9 +73,9 @@ function processStreamSink(item: unknown, exampleData: Record<string, unknown>)
   return { streamPattern, streamId };
 }
 
-export function getStreamFromSink(slice: Slice): { streamPattern?: string; streamId?: string } {
+export function getStreamFromSink(slice: Moment): { streamPattern?: string; streamId?: string } {
   if (!('server' in slice)) return {};
-  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const gwtSpecs = extractGwtSpecsFromMoment(slice);
   const exampleData = extractExampleDataFromSpecs(slice, gwtSpecs);
   if (!('server' in slice) || slice.server == null || !('data' in slice.server) || !Array.isArray(slice.server.data)) {
     return {};

package/src/codegen/extract/events.ts

@@ -7,35 +7,35 @@ function createEventMessage(
   eventRef: string | undefined,
   source: 'given' | 'then' | 'when',
   allMessages: MessageDefinition[],
-  currentSliceName?: string,
-  currentFlowName?: string,
+  currentMomentName?: string,
+  currentSceneName?: string,
 ): Message | undefined {
   if (eventRef == null) return undefined;
   const fields = extractFieldsFromMessage(eventRef, 'event', allMessages);
   const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventRef);
-  const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
-  const sourceFlowName = metadata?.sourceFlowName ?? currentFlowName;
-  const sourceSliceName = metadata?.sourceSliceName ?? currentSliceName;
+  const metadata = messageDef?.metadata as { sourceSceneName?: string; sourceMomentName?: string } | undefined;
+  const sourceSceneName = metadata?.sourceSceneName ?? currentSceneName;
+  const sourceMomentName = metadata?.sourceMomentName ?? currentMomentName;
 
   return {
     type: eventRef,
     fields,
     source,
-    sourceFlowName,
-    sourceSliceName,
+    sourceSceneName,
+    sourceMomentName,
   };
 }
 
 export function extractEventsFromThen(
   thenItems: Array<EventExample | { errorType: string; message?: string }>,
   allMessages: MessageDefinition[],
-  currentSliceName?: string,
-  currentFlowName?: string,
+  currentMomentName?: string,
+  currentSceneName?: string,
 ): Message[] {
   return thenItems
     .map((then): Message | undefined => {
       if (!('eventRef' in then)) return undefined;
-      return createEventMessage(then.eventRef, 'then', allMessages, currentSliceName, currentFlowName);
+      return createEventMessage(then.eventRef, 'then', allMessages, currentMomentName, currentSceneName);
     })
     .filter((event): event is Message => event !== undefined);
 }
@@ -43,13 +43,13 @@ export function extractEventsFromThen(
 export function extractEventsFromGiven(
   givenEvents: EventExample[] | undefined,
   allMessages: MessageDefinition[],
-  currentSliceName?: string,
-  currentFlowName?: string,
+  currentMomentName?: string,
+  currentSceneName?: string,
 ): Message[] {
   if (!givenEvents) return [];
 
   return givenEvents
-    .map((given) => createEventMessage(given.eventRef, 'given', allMessages, currentSliceName, currentFlowName))
+    .map((given) => createEventMessage(given.eventRef, 'given', allMessages, currentMomentName, currentSceneName))
     .filter((event): event is Message => event !== undefined);
 }
 

package/src/codegen/extract/gwt.ts

@@ -1,14 +1,14 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 import type { GwtCondition } from '../types';
-import { extractGwtSpecsFromSlice, type GwtConditionWithRule } from './step-converter';
+import { extractGwtSpecsFromMoment, type GwtConditionWithRule } from './step-converter';
 import type { CommandExample, EventExample } from './step-types';
 
-export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtCondition & { failingFields?: string[] })[]> {
+export function buildCommandGwtMapping(slice: Moment): Record<string, (GwtCondition & { failingFields?: string[] })[]> {
   if (slice.type !== 'command') {
     return {};
   }
 
-  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const gwtSpecs = extractGwtSpecsFromMoment(slice);
   const mapping = buildCommandMapping(gwtSpecs);
   return enhanceMapping(mapping);
 }

package/src/codegen/extract/imports.ts

@@ -6,8 +6,8 @@ export interface ImportGroup {
   eventTypes: string[];
 }
 
-export interface CrossSliceImportContext {
-  currentSliceName: string;
+export interface CrossMomentImportContext {
+  currentMomentName: string;
   events: Message[];
 }
 
@@ -16,20 +16,20 @@ export interface CrossSliceImportContext {
  * Events from the current slice are imported from './events',
  * while cross-slice events are imported from '../other-slice/events'.
  */
-export function groupEventImports(context: CrossSliceImportContext): ImportGroup[] {
-  const { currentSliceName, events } = context;
+export function groupEventImports(context: CrossMomentImportContext): ImportGroup[] {
+  const { currentMomentName, events } = context;
   const importGroups = new Map<string, string[]>();
 
   for (const event of events) {
     if (!event.type) continue;
     let importPath: string;
-    const isFromCurrentSlice =
-      event.source === 'then' || event.sourceSliceName === currentSliceName || event.sourceSliceName == null;
+    const isFromCurrentMoment =
+      event.source === 'then' || event.sourceMomentName === currentMomentName || event.sourceMomentName == null;
 
-    if (isFromCurrentSlice) {
+    if (isFromCurrentMoment) {
       importPath = './events';
     } else {
-      importPath = `../${toKebabCase(event.sourceSliceName ?? currentSliceName)}/events`;
+      importPath = `../${toKebabCase(event.sourceMomentName ?? currentMomentName)}/events`;
     }
     if (!importGroups.has(importPath)) {
       importGroups.set(importPath, []);

package/src/codegen/extract/messages.ts

@@ -1,4 +1,4 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 import createDebug from 'debug';
 import type { Message, MessageDefinition } from '../types';
 import { extractCommandsFromGwt, extractCommandsFromThen } from './commands';
@@ -6,7 +6,7 @@ import { extractEventsFromGiven, extractEventsFromThen, extractEventsFromWhen }
 import { extractFieldsFromMessage } from './fields';
 import { extractProjectionIdField, extractProjectionSingleton } from './projection';
 import { extractStatesFromData, extractStatesFromTarget } from './states';
-import { extractGwtSpecsFromSlice, type GwtConditionWithRule } from './step-converter';
+import { extractGwtSpecsFromMoment, type GwtConditionWithRule } from './step-converter';
 import type { CommandExample, EventExample } from './step-types';
 
 const debug = createDebug('auto:server-generator-nestjs:extract:messages');
@@ -52,15 +52,15 @@ function deduplicateMessages<T extends Message>(messages: T[]): T[] {
   return result;
 }
 
-function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+function extractMessagesForCommand(slice: Moment, allMessages: MessageDefinition[]): ExtractedMessages {
   debugCommand('Extracting messages for command slice: %s', slice.name);
 
   if (slice.type !== 'command') {
-    debugCommand('  Slice type is not command, returning empty');
+    debugCommand('  Moment type is not command, returning empty');
     return EMPTY_EXTRACTED_MESSAGES;
   }
 
-  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const gwtSpecs = extractGwtSpecsFromMoment(slice);
   debugCommand('  Found %d GWT specs', gwtSpecs.length);
 
   const { commands, commandSchemasByName } = extractCommandsFromGwt(gwtSpecs, allMessages);
@@ -89,15 +89,15 @@ function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[
   return result;
 }
 
-function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+function extractMessagesForQuery(slice: Moment, allMessages: MessageDefinition[]): ExtractedMessages {
   debugQuery('Extracting messages for query slice: %s', slice.name);
 
   if (slice.type !== 'query') {
-    debugQuery('  Slice type is not query, returning empty');
+    debugQuery('  Moment type is not query, returning empty');
     return EMPTY_EXTRACTED_MESSAGES;
   }
 
-  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const gwtSpecs = extractGwtSpecsFromMoment(slice);
   debugQuery('  Found %d GWT specs', gwtSpecs.length);
 
   const projectionIdField = extractProjectionIdField(slice);
@@ -124,14 +124,14 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
       .map((eventExample: EventExample) => {
         const fields = extractFieldsFromMessage(eventExample.eventRef, 'event', allMessages);
         const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventExample.eventRef);
-        const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
+        const metadata = messageDef?.metadata as { sourceSceneName?: string; sourceMomentName?: string } | undefined;
 
         return {
           type: eventExample.eventRef,
           fields,
           source: 'when' as const,
-          sourceFlowName: metadata?.sourceFlowName,
-          sourceSliceName: metadata?.sourceSliceName,
+          sourceSceneName: metadata?.sourceSceneName,
+          sourceMomentName: metadata?.sourceMomentName,
         } as Message;
       })
       .filter((event): event is Message => event.type !== undefined);
@@ -156,15 +156,15 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
   return result;
 }
 
-function extractMessagesForReact(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+function extractMessagesForReact(slice: Moment, allMessages: MessageDefinition[]): ExtractedMessages {
   debugReact('Extracting messages for react slice: %s', slice.name);
 
   if (slice.type !== 'react') {
-    debugReact('  Slice type is not react, returning empty');
+    debugReact('  Moment type is not react, returning empty');
     return EMPTY_EXTRACTED_MESSAGES;
   }
 
-  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const gwtSpecs = extractGwtSpecsFromMoment(slice);
   debugReact('  Found %d GWT specs', gwtSpecs.length);
 
   const reactGwtSpecs: ReactGwtSpec[] = gwtSpecs.map((gwt) => ({
@@ -198,7 +198,7 @@ function extractMessagesForReact(slice: Slice, allMessages: MessageDefinition[])
   return result;
 }
 
-export function extractMessagesFromSpecs(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+export function extractMessagesFromSpecs(slice: Moment, allMessages: MessageDefinition[]): ExtractedMessages {
   debug('Extracting messages from slice: %s (type: %s)', slice.name, slice.type);
   debug('  Total message definitions available: %d', allMessages.length);
 
@@ -215,8 +215,8 @@ export function extractMessagesFromSpecs(slice: Slice, allMessages: MessageDefin
       result = extractMessagesForReact(slice, allMessages);
       break;
     default: {
-      const unknownSlice = slice as Slice;
-      debug('  Unknown slice type: %s, returning empty', unknownSlice.type);
+      const unknownMoment = slice as Moment;
+      debug('  Unknown slice type: %s, returning empty', unknownMoment.type);
       result = EMPTY_EXTRACTED_MESSAGES;
     }
   }

package/src/codegen/extract/projection.ts

@@ -1,4 +1,4 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 
 interface ProjectionOrigin {
   type: 'projection';
@@ -24,7 +24,7 @@ function isProjectionOrigin(origin: unknown): origin is ProjectionOrigin {
   return obj.type === 'projection';
 }
 
-function extractProjectionField<K extends keyof ProjectionOrigin>(slice: Slice, fieldName: K): string | undefined {
+function extractProjectionField<K extends keyof ProjectionOrigin>(slice: Moment, fieldName: K): string | undefined {
   if (!('server' in slice)) return undefined;
   const dataSource = slice.server?.data?.[0];
   if (!hasOrigin(dataSource)) return undefined;
@@ -40,15 +40,15 @@ function extractProjectionField<K extends keyof ProjectionOrigin>(slice: Slice,
   return undefined;
 }
 
-export function extractProjectionIdField(slice: Slice): string | undefined {
+export function extractProjectionIdField(slice: Moment): string | undefined {
   return extractProjectionField(slice, 'idField');
 }
 
-export function extractProjectionName(slice: Slice): string | undefined {
+export function extractProjectionName(slice: Moment): string | undefined {
   return extractProjectionField(slice, 'name');
 }
 
-export function extractProjectionSingleton(slice: Slice): boolean {
+export function extractProjectionSingleton(slice: Moment): boolean {
   if (!('server' in slice)) return false;
   const dataSource = slice.server?.data?.[0];
   if (!hasOrigin(dataSource)) return false;

package/src/codegen/extract/query.ts

@@ -1,5 +1,5 @@
-import type { Slice } from '@auto-engineer/narrative';
-import { extractGwtSpecsFromSlice } from './step-converter';
+import type { Moment } from '@auto-engineer/narrative';
+import { extractGwtSpecsFromMoment } from './step-converter';
 import type { EventExample, StateExample } from './step-types';
 
 interface QueryGwtCondition {
@@ -9,10 +9,10 @@ interface QueryGwtCondition {
   then: Array<{ stateRef: string; exampleData: Record<string, unknown> }>;
 }
 
-export function buildQueryGwtMapping(slice: Slice): QueryGwtCondition[] {
+export function buildQueryGwtMapping(slice: Moment): QueryGwtCondition[] {
   if (slice.type !== 'query') return [];
 
-  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const gwtSpecs = extractGwtSpecsFromMoment(slice);
 
   return gwtSpecs.map((gwt) => {
     const givenEvents = Array.isArray(gwt.given) ? gwt.given.filter((i): i is EventExample => 'eventRef' in i) : [];

package/src/codegen/extract/states.ts

@@ -1,4 +1,4 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 import type { Message, MessageDefinition } from '../types';
 import { extractFieldsFromMessage } from './fields';
 
@@ -16,7 +16,7 @@ function createStateMessage(stateName: string, allMessages: MessageDefinition[])
   };
 }
 
-function hasServerData(slice: Slice): slice is Slice & { server: { data: unknown[] } } {
+function hasServerData(slice: Moment): slice is Moment & { server: { data: unknown[] } } {
   return (
     'server' in slice &&
     Boolean(slice.server) &&
@@ -26,7 +26,7 @@ function hasServerData(slice: Slice): slice is Slice & { server: { data: unknown
   );
 }
 
-export function extractStatesFromTarget(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+export function extractStatesFromTarget(slice: Moment, allMessages: MessageDefinition[]): Message[] {
   if (!hasServerData(slice)) {
     return [];
   }
@@ -39,7 +39,7 @@ export function extractStatesFromTarget(slice: Slice, allMessages: MessageDefini
   return uniqueTargets.map((name) => createStateMessage(name, allMessages));
 }
 
-export function extractStatesFromData(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+export function extractStatesFromData(slice: Moment, allMessages: MessageDefinition[]): Message[] {
   if (!hasServerData(slice)) {
     return [];
   }

package/src/codegen/extract/step-converter.ts

@@ -1,19 +1,19 @@
-import type { Example, Slice, Spec } from '@auto-engineer/narrative';
+import type { Example, Moment, Spec } from '@auto-engineer/narrative';
 import {
   type CommandExample,
   type ErrorRef,
   type EventExample,
-  getSliceType,
+  getMomentType,
   isStepWithDocString,
   isStepWithError,
   type MajorKeyword,
+  type MomentType,
   resolveMajorKeyword,
-  type SliceType,
   type StateExample,
 } from './step-types';
 
-export type { CommandExample, ErrorRef, EventExample, SliceType, StateExample };
-export { getSliceType };
+export type { CommandExample, ErrorRef, EventExample, MomentType, StateExample };
+export { getMomentType };
 
 export interface GwtResult {
   given: EventExample[];
@@ -60,10 +60,10 @@ function parseSteps(example: Example): ParsedSteps {
   return { given, whenItems, thenItems, thenErrors };
 }
 
-function buildGwtResult(sliceType: SliceType, parsed: ParsedSteps, description: string): GwtResult {
+function buildGwtResult(momentType: MomentType, parsed: ParsedSteps, description: string): GwtResult {
   const { given, whenItems, thenItems, thenErrors } = parsed;
 
-  if (sliceType === 'command') {
+  if (momentType === 'command') {
     return {
       given,
       when: { commandRef: whenItems[0]?.text ?? '', exampleData: whenItems[0]?.exampleData ?? {} },
@@ -72,7 +72,7 @@ function buildGwtResult(sliceType: SliceType, parsed: ParsedSteps, description:
     };
   }
 
-  if (sliceType === 'react') {
+  if (momentType === 'react') {
     return {
       given,
       when: whenItems.map((w) => ({ eventRef: w.text, exampleData: w.exampleData })),
@@ -89,22 +89,22 @@ function buildGwtResult(sliceType: SliceType, parsed: ParsedSteps, description:
   };
 }
 
-export function stepsToGwt(example: Example, sliceType: SliceType): GwtResult {
+export function stepsToGwt(example: Example, momentType: MomentType): GwtResult {
   const parsed = parseSteps(example);
-  return buildGwtResult(sliceType, parsed, example.name);
+  return buildGwtResult(momentType, parsed, example.name);
 }
 
 export interface GwtConditionWithRule extends GwtResult {
   ruleDescription: string;
 }
 
-export function extractGwtFromSpecs(specs: Spec[], sliceType: SliceType): GwtConditionWithRule[] {
+export function extractGwtFromSpecs(specs: Spec[], momentType: MomentType): GwtConditionWithRule[] {
   const results: GwtConditionWithRule[] = [];
 
   for (const spec of specs) {
     for (const rule of spec.rules) {
       for (const example of rule.examples) {
-        const gwt = stepsToGwt(example, sliceType);
+        const gwt = stepsToGwt(example, momentType);
         results.push({
           ...gwt,
           ruleDescription: rule.name,
@@ -116,9 +116,9 @@ export function extractGwtFromSpecs(specs: Spec[], sliceType: SliceType): GwtCon
   return results;
 }
 
-export function extractGwtSpecsFromSlice(slice: Slice): GwtConditionWithRule[] {
+export function extractGwtSpecsFromMoment(slice: Moment): GwtConditionWithRule[] {
   if (!('server' in slice)) return [];
   const specs = slice.server?.specs;
   if (!Array.isArray(specs) || specs.length === 0) return [];
-  return extractGwtFromSpecs(specs, getSliceType(slice));
+  return extractGwtFromSpecs(specs, getMomentType(slice));
 }

package/src/codegen/extract/step-types.ts

@@ -1,4 +1,4 @@
-import type { Slice, Step, StepWithDocStringSchema, StepWithErrorSchema } from '@auto-engineer/narrative';
+import type { Moment, Step, StepWithDocStringSchema, StepWithErrorSchema } from '@auto-engineer/narrative';
 import type { z } from 'zod';
 
 export type StepWithDocString = z.infer<typeof StepWithDocStringSchema>;
@@ -9,9 +9,9 @@ export type MajorKeyword = Exclude<StepKeyword, 'And'>;
 
 export type ErrorType = StepWithError['error']['type'];
 
-export type SliceType = Extract<Slice['type'], 'command' | 'query' | 'react'>;
+export type MomentType = Extract<Moment['type'], 'command' | 'query' | 'react'>;
 
-export function getSliceType(slice: Slice): SliceType {
+export function getMomentType(slice: Moment): MomentType {
   if (slice.type === 'command' || slice.type === 'query' || slice.type === 'react') {
     return slice.type;
   }

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';
@@ -10,7 +10,7 @@ import { ensureDirExists, ensureDirPath, toKebabCase } from './utils/path.js';
 
 const debug = createDebug('auto:server-generator-nestjs:scaffold');
 
-import { parseSliceRequest } from '@auto-engineer/narrative';
+import { parseMomentRequest } from '@auto-engineer/narrative';
 import { type ConsolidatedEntity, consolidateEntityFields } from './entity-consolidation.js';
 import { getStreamFromSink } from './extract/data-sink.js';
 import {
@@ -153,10 +153,10 @@ registerEnumType(${enumDef.name}, {
 });`;
 }
 
-async function writeEnumsToEntitiesFolder(baseDir: string, flowName: string, enums: EnumDefinition[]): Promise<void> {
+async function writeEnumsToEntitiesFolder(baseDir: string, sceneName: string, enums: EnumDefinition[]): Promise<void> {
   if (enums.length === 0) return;
 
-  const entitiesDir = path.join(baseDir, toKebabCase(flowName), 'entities');
+  const entitiesDir = path.join(baseDir, toKebabCase(sceneName), 'entities');
   await ensureDirExists(entitiesDir);
 
   for (const enumDef of enums) {
@@ -287,8 +287,8 @@ async function renderTemplate(
 
 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> {
@@ -297,7 +297,7 @@ async function generateFileForTemplate(
   const fileName = templateFile
     .replace(/\.ts\.ejs$/, '.ts')
     .replace(/^(command|query|handler|resolver|input|type)\./, `${toKebabCase(slice.name)}.$1.`);
-  const outputPath = path.join(sliceDir, fileName);
+  const outputPath = path.join(momentDir, fileName);
 
   const contents = await renderTemplate(templatePath, templateData, unionToEnumName);
 
@@ -312,8 +312,8 @@ async function generateFileForTemplate(
 }
 
 async function prepareTemplateData(
-  slice: Slice,
-  flow: Narrative,
+  slice: Moment,
+  scene: Scene,
   commands: Message[],
   events: Message[],
   states: Message[],
@@ -329,18 +329,18 @@ async function prepareTemplateData(
   const projectionName = extractProjectionName(slice);
 
   const uniqueCommands = Array.from(new Map(commands.map((c) => [c.type, c])).values());
-  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, events });
+  const eventImportGroups = groupEventImports({ currentMomentName: slice.name, events });
   const allEventTypesArray = getAllEventTypes(events);
   const allEventTypes = createEventUnionType(events);
   const localEvents = getLocalEvents(events);
 
   return {
-    flowName: flow.name,
-    sliceName: slice.name,
+    sceneName: scene.name,
+    momentName: slice.name,
     slice,
     stream: { pattern: streamPattern, id: streamId },
     commands: filteredCommands,
@@ -353,7 +353,7 @@ async function prepareTemplateData(
     projectionSingleton,
     projectionName,
     projectionType: projectionName != null ? pascalCase(projectionName) : undefined,
-    parsedRequest: parseSliceRequest(slice),
+    parsedRequest: parseMomentRequest(slice),
     messages: allMessages,
     message:
       slice.type === 'query' && allMessages
@@ -367,10 +367,10 @@ async function prepareTemplateData(
   };
 }
 
-async function generateFilesForSlice(
-  slice: Slice,
-  flow: Narrative,
-  sliceDir: string,
+async function generateFilesForMoment(
+  slice: Moment,
+  scene: Scene,
+  momentDir: string,
   messages: MessageDefinition[],
   unionToEnumName: Map<string, string>,
   integrations?: Model['integrations'],
@@ -384,7 +384,7 @@ async function generateFilesForSlice(
 
   const templateData = await prepareTemplateData(
     slice,
-    flow,
+    scene,
     extracted.commands,
     extracted.events,
     extracted.states,
@@ -396,7 +396,7 @@ async function generateFilesForSlice(
   );
 
   const plans = await Promise.all(
-    templates.map((template) => generateFileForTemplate(template, slice, sliceDir, templateData, unionToEnumName)),
+    templates.map((template) => generateFileForTemplate(template, slice, momentDir, templateData, unionToEnumName)),
   );
   return plans;
 }
@@ -441,23 +441,23 @@ async function generateEntityFiles(
 }
 
 async function generateDomainModule(
-  flow: Narrative,
-  flowDir: string,
+  scene: Scene,
+  sceneDir: string,
   unionToEnumName: Map<string, string>,
 ): Promise<FilePlan> {
   const __dirname = dirname(fileURLToPath(import.meta.url));
   const moduleTemplatePath = path.join(__dirname, './templates/module/domain-module.ts.ejs');
 
-  const slices = flow.slices.filter((s) => s.type !== 'experience');
+  const slices = scene.moments.filter((s) => s.type !== 'experience');
   const templateData = {
-    flowName: flow.name,
+    sceneName: scene.name,
     slices,
     pascalCase,
     toKebabCase,
   };
 
   const contents = await renderTemplate(moduleTemplatePath, templateData, unionToEnumName);
-  const modulePath = path.join(flowDir, `${toKebabCase(flow.name)}.module.ts`);
+  const modulePath = path.join(sceneDir, `${toKebabCase(scene.name)}.module.ts`);
 
   const prettierConfig = await prettier.resolveConfig(modulePath);
   const formattedContents = await prettier.format(contents, {
@@ -470,7 +470,7 @@ async function generateDomainModule(
 }
 
 async function generateAppModule(
-  flows: Narrative[],
+  scenes: Scene[],
   baseDir: string,
   unionToEnumName: Map<string, string>,
 ): Promise<FilePlan> {
@@ -478,7 +478,7 @@ async function generateAppModule(
   const moduleTemplatePath = path.join(__dirname, './templates/module/app-module.ts.ejs');
 
   const templateData = {
-    flows,
+    scenes,
     pascalCase,
     toKebabCase,
   };
@@ -497,7 +497,7 @@ async function generateAppModule(
 }
 
 export async function generateScaffoldFilePlans(
-  flows: Narrative[],
+  scenes: Scene[],
   messages: Model['messages'],
   integrations?: Model['integrations'],
   baseDir = 'src/domain',
@@ -506,27 +506,34 @@ export async function generateScaffoldFilePlans(
 
   const allPlans: FilePlan[] = [];
 
-  for (const flow of flows) {
-    const flowDir = ensureDirPath(baseDir, toKebabCase(flow.name));
-    const entitiesDir = ensureDirPath(flowDir, 'entities');
+  for (const scene of scenes) {
+    const sceneDir = ensureDirPath(baseDir, toKebabCase(scene.name));
+    const entitiesDir = ensureDirPath(sceneDir, 'entities');
 
-    await writeEnumsToEntitiesFolder(baseDir, flow.name, enums);
+    await writeEnumsToEntitiesFolder(baseDir, scene.name, enums);
 
-    const entity = consolidateEntityFields(flow, messages ?? [], unionToEnumName);
+    const entity = consolidateEntityFields(scene, messages ?? [], unionToEnumName);
     const entityPlans = await generateEntityFiles(entity, entitiesDir, unionToEnumName);
     allPlans.push(...entityPlans);
 
-    for (const slice of flow.slices) {
-      const sliceDir = ensureDirPath(flowDir, toKebabCase(slice.name));
-      const plans = await generateFilesForSlice(slice, flow, sliceDir, messages ?? [], unionToEnumName, integrations);
+    for (const slice of scene.moments) {
+      const momentDir = ensureDirPath(sceneDir, toKebabCase(slice.name));
+      const plans = await generateFilesForMoment(
+        slice,
+        scene,
+        momentDir,
+        messages ?? [],
+        unionToEnumName,
+        integrations,
+      );
       allPlans.push(...plans);
     }
 
-    const modulePlan = await generateDomainModule(flow, flowDir, unionToEnumName);
+    const modulePlan = await generateDomainModule(scene, sceneDir, unionToEnumName);
     allPlans.push(modulePlan);
   }
 
-  const appModulePlan = await generateAppModule(flows, baseDir, unionToEnumName);
+  const appModulePlan = await generateAppModule(scenes, baseDir, unionToEnumName);
   allPlans.push(appModulePlan);
 
   return allPlans;
@@ -541,10 +548,10 @@ export async function writeScaffoldFilePlans(plans: FilePlan[]): Promise<void> {
 }
 
 export async function scaffoldFromSchema(
-  flows: Narrative[],
+  scenes: Scene[],
   messages: Model['messages'],
   baseDir = 'src/domain',
 ): Promise<void> {
-  const plans = await generateScaffoldFilePlans(flows, messages, undefined, baseDir);
+  const plans = await generateScaffoldFilePlans(scenes, messages, undefined, baseDir);
   await writeScaffoldFilePlans(plans);
 }

package/src/codegen/templates/command/handler.specs.ts.ejs

@@ -1,7 +1,7 @@
 <%
 const command = commands[0];
 if (!command) return '';
-const entityName = pascalCase(flowName) + 'Entity';
+const entityName = pascalCase(sceneName) + 'Entity';
 const enumList = collectEnumNames(command.fields);
 %>import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { Test, TestingModule } from '@nestjs/testing';

package/src/codegen/templates/command/handler.ts.ejs

@@ -1,7 +1,7 @@
 <%
 const command = commands[0];
 if (!command) return '';
-const entityName = pascalCase(flowName) + 'Entity';
+const entityName = pascalCase(sceneName) + 'Entity';
 const enumList = collectEnumNames(command.fields);
 %>import { CommandHandler, ICommandHandler } from '@nestjs/cqrs';
 import { InjectRepository } from '@mikro-orm/nestjs';

package/src/codegen/templates/module/app-module.ts.ejs

@@ -8,20 +8,20 @@ import { Migrator } from '@mikro-orm/migrations';
 import { join } from 'path';
 import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
 
-<% for (const flow of flows) { -%>
-import { <%= pascalCase(flow.name) %>Module } from './domain/<%= toKebabCase(flow.name) %>/<%= toKebabCase(flow.name) %>.module';
-import { <%= pascalCase(flow.name) %>Entity } from './domain/<%= toKebabCase(flow.name) %>/entities';
+<% for (const scene of scenes) { -%>
+import { <%= pascalCase(scene.name) %>Module } from './domain/<%= toKebabCase(scene.name) %>/<%= toKebabCase(scene.name) %>.module';
+import { <%= pascalCase(scene.name) %>Entity } from './domain/<%= toKebabCase(scene.name) %>/entities';
 <% } -%>
 
 const domainModules = [
-<% for (const flow of flows) { -%>
-  <%= pascalCase(flow.name) %>Module,
+<% for (const scene of scenes) { -%>
+  <%= pascalCase(scene.name) %>Module,
 <% } -%>
 ];
 
 const entities = [
-<% for (const flow of flows) { -%>
-  <%= pascalCase(flow.name) %>Entity,
+<% for (const scene of scenes) { -%>
+  <%= pascalCase(scene.name) %>Entity,
 <% } -%>
 ];
 

package/src/codegen/templates/module/domain-module.ts.ejs

@@ -1,6 +1,6 @@
 <%
-const moduleName = pascalCase(flowName) + 'Module';
-const entityName = pascalCase(flowName) + 'Entity';
+const moduleName = pascalCase(sceneName) + 'Module';
+const entityName = pascalCase(sceneName) + 'Entity';
 %>import { Module } from '@nestjs/common';
 import { CqrsModule } from '@nestjs/cqrs';
 import { MikroOrmModule } from '@mikro-orm/nestjs';

package/src/codegen/templates/query/handler.ts.ejs

@@ -1,5 +1,5 @@
 <%
-const entityName = pascalCase(flowName) + 'Entity';
+const entityName = pascalCase(sceneName) + 'Entity';
 const typeName = projectionType || pascalCase(sliceName) + 'State';
 const isSingleton = projectionSingleton === true;
 %>import { QueryHandler, IQueryHandler } from '@nestjs/cqrs';

package/src/codegen/types.ts

@@ -6,8 +6,8 @@ export interface Message {
   type: string;
   fields: Field[];
   source?: 'when' | 'given' | 'then';
-  sourceFlowName?: string;
-  sourceSliceName?: string;
+  sourceSceneName?: string;
+  sourceMomentName?: string;
 }
 
 export interface Field {

package/src/commands/generate-server.ts

@@ -55,18 +55,18 @@ export type ServerGenerationFailedEvent = Event<
   }
 >;
 
-export type SliceGeneratedEvent = Event<
-  'SliceGenerated',
+export type MomentGeneratedEvent = Event<
+  'MomentGenerated',
   {
-    flowName: string;
-    sliceName: string;
-    sliceType: string;
+    sceneName: string;
+    momentName: string;
+    momentType: string;
     schemaPath: string;
-    slicePath: string;
+    momentPath: string;
   }
 >;
 
-export type GenerateServerEvents = ServerGeneratedEvent | ServerGenerationFailedEvent | SliceGeneratedEvent;
+export type GenerateServerEvents = ServerGeneratedEvent | ServerGenerationFailedEvent | MomentGeneratedEvent;
 
 export const commandHandler = defineCommandHandler({
   name: 'GenerateServer',
@@ -74,7 +74,7 @@ export const commandHandler = defineCommandHandler({
   description: 'Generate server from model',
   category: 'generate',
   icon: 'server',
-  events: ['ServerGenerated', 'ServerGenerationFailed', 'SliceGenerated'],
+  events: ['ServerGenerated', 'ServerGenerationFailed', 'MomentGenerated'],
   fields: {
     model: {
       description: 'The model object',
@@ -132,9 +132,9 @@ async function generateAndWriteScaffold(spec: Model, serverDir: string): Promise
   const domainPath = join(serverDir, 'src', 'domain');
   debugScaffold('Generating scaffold file plans');
   debugScaffold('  Domain path: %s', domainPath);
-  debugScaffold('  Number of flows: %d', spec.narratives?.length || 0);
+  debugScaffold('  Number of scenes: %d', spec.scenes?.length || 0);
 
-  const filePlans = await generateScaffoldFilePlans(spec.narratives, spec.messages, spec.integrations, domainPath);
+  const filePlans = await generateScaffoldFilePlans(spec.scenes, spec.messages, spec.integrations, domainPath);
 
   debugScaffold('Generated %d file plans', filePlans.length);
   if (filePlans.length > 0) {
@@ -244,26 +244,26 @@ export async function handleGenerateServerCommandInternal(
 
     await generateAndWriteScaffold(spec, serverDir);
 
-    if (Array.isArray(spec.narratives) && spec.narratives.length > 0) {
-      for (const flow of spec.narratives) {
-        if (Array.isArray(flow.slices) && flow.slices.length > 0) {
-          for (const slice of flow.slices) {
+    if (Array.isArray(spec.scenes) && spec.scenes.length > 0) {
+      for (const scene of spec.scenes) {
+        if (Array.isArray(scene.moments) && scene.moments.length > 0) {
+          for (const slice of scene.moments) {
             if (slice.type === 'experience') continue;
-            const sliceEvent: SliceGeneratedEvent = {
-              type: 'SliceGenerated',
+            const sliceEvent: MomentGeneratedEvent = {
+              type: 'MomentGenerated',
               data: {
-                flowName: flow.name,
-                sliceName: slice.name,
-                sliceType: slice.type,
+                sceneName: scene.name,
+                momentName: slice.name,
+                momentType: slice.type,
                 schemaPath: deriveModelPath(command.data.destination),
-                slicePath: ensureDirPath('./server/src/domain', toKebabCase(flow.name), toKebabCase(slice.name)),
+                momentPath: ensureDirPath('./server/src/domain', toKebabCase(scene.name), toKebabCase(slice.name)),
               },
               timestamp: new Date(),
               requestId: command.requestId,
               correlationId: command.correlationId,
             };
             events.push(sliceEvent);
-            debug('SliceGenerated: %s.%s', flow.name, slice.name);
+            debug('MomentGenerated: %s.%s', scene.name, slice.name);
           }
         }
       }

package/src/index.ts

@@ -4,7 +4,7 @@ export const COMMANDS = [generateServerHandler];
 export type {
   GenerateServerCommand,
   GenerateServerEvents,
+  MomentGeneratedEvent,
   ServerGeneratedEvent,
   ServerGenerationFailedEvent,
-  SliceGeneratedEvent,
 } from './commands/generate-server.js';