@auto-engineer/server-generator-apollo-emmett 0.11.9 → 0.11.11

package/package.json

@@ -31,8 +31,8 @@
     "graphql-type-json": "^0.3.2",
     "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
-    "@auto-engineer/flow": "0.11.9",
-    "@auto-engineer/message-bus": "0.11.9"
+    "@auto-engineer/narrative": "0.11.11",
+    "@auto-engineer/message-bus": "0.11.11"
   },
   "publishConfig": {
     "access": "public"
@@ -43,9 +43,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "0.11.9"
+    "@auto-engineer/cli": "0.11.11"
   },
-  "version": "0.11.9",
+  "version": "0.11.11",
   "scripts": {
     "generate:server": "tsx src/cli/index.ts",
     "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 src/server.ts dist/src && cp -r src/utils dist/src && cp -r src/domain dist/src",

package/src/codegen/extract/commands.ts

@@ -1,4 +1,4 @@
-import { CommandExample, EventExample } from '@auto-engineer/flow';
+import { CommandExample, EventExample } from '@auto-engineer/narrative';
 import { Message, MessageDefinition } from '../types';
 import { extractFieldsFromMessage } from './fields';
 

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

@@ -1,4 +1,4 @@
-import { CommandExample, Slice, type Example } from '@auto-engineer/flow';
+import { CommandExample, Slice, type Example } from '@auto-engineer/narrative';
 
 function resolveStreamId(stream: string, exampleData: Record<string, unknown>): string {
   return stream.replace(/\$\{([^}]+)\}/g, (_, key: string) => String(exampleData?.[key] ?? 'unknown'));

package/src/codegen/extract/events.ts

@@ -1,4 +1,4 @@
-import { EventExample } from '@auto-engineer/flow';
+import { EventExample } from '@auto-engineer/narrative';
 import { Message, MessageDefinition } from '../types';
 import { extractFieldsFromMessage } from './fields';
 import { ReactGwtSpec } from './messages';

package/src/codegen/extract/gwt.ts

@@ -1,4 +1,4 @@
-import { Slice, CommandExample, EventExample, StateExample, Example } from '@auto-engineer/flow';
+import { Slice, CommandExample, EventExample, StateExample, Example } from '@auto-engineer/narrative';
 import { GwtCondition } from '../types';
 
 export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtCondition & { failingFields?: string[] })[]> {

package/src/codegen/extract/index.ts

@@ -6,3 +6,4 @@ export * from './messages';
 export * from './query';
 export * from './projection';
 export * from './imports';
+export * from './type-helpers';

package/src/codegen/extract/messages.ts

@@ -1,5 +1,5 @@
 import { extractCommandsFromGwt, extractCommandsFromThen } from './commands';
-import { CommandExample, ErrorExample, EventExample, Slice, StateExample } from '@auto-engineer/flow';
+import { CommandExample, ErrorExample, EventExample, Slice, StateExample } from '@auto-engineer/narrative';
 import { Message, MessageDefinition } from '../types';
 import { extractEventsFromGiven, extractEventsFromThen, extractEventsFromWhen } from './events';
 import { extractFieldsFromMessage } from './fields';

package/src/codegen/extract/projection.ts

@@ -1,4 +1,4 @@
-import { Slice } from '@auto-engineer/flow';
+import { Slice } from '@auto-engineer/narrative';
 
 interface ProjectionOrigin {
   type: 'projection';

package/src/codegen/extract/query.ts

@@ -1,4 +1,4 @@
-import { EventExample, Slice } from '@auto-engineer/flow';
+import { EventExample, Slice } from '@auto-engineer/narrative';
 
 interface QueryGwtCondition {
   description: string;

package/src/codegen/extract/states.ts

@@ -1,4 +1,4 @@
-import { Slice } from '@auto-engineer/flow';
+import { Slice } from '@auto-engineer/narrative';
 import { Message, MessageDefinition } from '../types';
 import { extractFieldsFromMessage } from './fields';
 

package/src/codegen/extract/type-helpers.ts

@@ -0,0 +1,102 @@
+export function isInlineObject(ts: string): boolean {
+  return /^\{[\s\S]*\}$/.test((ts ?? '').trim());
+}
+
+export function isInlineObjectArray(ts: string): boolean {
+  const t = (ts ?? '').trim();
+  return /^Array<\{[\s\S]*\}>$/.test(t) || /^\{[\s\S]*\}\[\]$/.test(t);
+}
+
+export function baseTs(ts: string): string {
+  return (ts ?? 'string').replace(/\s*\|\s*null\b/g, '').trim();
+}
+
+export function createIsEnumType(toTsFieldType: (ts: string) => string) {
+  return (tsType: string): boolean => {
+    const converted = toTsFieldType(tsType);
+    const base = converted
+      .replace(/\s*\|\s*null\b/g, '')
+      .replace(/\[\]$/, '')
+      .trim();
+    return (
+      /^[A-Z][a-zA-Z0-9]*$/.test(base) &&
+      ![
+        'String',
+        'Number',
+        'Boolean',
+        'Date',
+        'ID',
+        'Int',
+        'Float',
+        'GraphQLISODateTime',
+        'GraphQLJSON',
+        'JSON',
+      ].includes(base)
+    );
+  };
+}
+
+export function createFieldUsesDate(graphqlType: (ts: string) => string) {
+  return (ts: string): boolean => {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('GraphQLISODateTime')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*Date\b/.test(b);
+    return false;
+  };
+}
+
+export function createFieldUsesJSON(graphqlType: (ts: string) => string) {
+  return (ts: string): boolean => {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('GraphQLJSON') || gqlType.includes('JSON')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*(unknown|any|object)\b/.test(b);
+    return false;
+  };
+}
+
+export function createFieldUsesFloat(graphqlType: (ts: string) => string) {
+  return (ts: string): boolean => {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('Float')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) {
+      const inner = b.trim().startsWith('Array<')
+        ? b
+            .trim()
+            .replace(/^Array<\{/, '{')
+            .replace(/}>$/, '}')
+        : b.trim().replace(/\[\]$/, '');
+      const match = inner.match(/^\{([\s\S]*)\}$/);
+      const body = match ? match[1] : '';
+      const rawFields = body.split(/[,;]\s*/).filter(Boolean);
+      return rawFields.some((f) => {
+        const parts = f.split(':');
+        const type = parts.slice(1).join(':').trim();
+        return type.length > 0 && graphqlType(type).includes('Float');
+      });
+    }
+    return false;
+  };
+}
+
+export function extractEnumName(tsType: string, toTsFieldType: (ts: string) => string): string {
+  return toTsFieldType(tsType)
+    .replace(/\s*\|\s*null\b/g, '')
+    .replace(/\[\]$/, '')
+    .trim();
+}
+
+export function createCollectEnumNames(isEnumType: (tsType: string) => boolean, toTsFieldType: (ts: string) => string) {
+  return (fields: Array<{ type?: string; tsType?: string }>): string[] => {
+    const enumNames = new Set<string>();
+    for (const field of fields) {
+      const fieldType = field.type ?? field.tsType;
+      if (fieldType !== undefined && fieldType !== null && fieldType.length > 0 && isEnumType(fieldType)) {
+        enumNames.add(extractEnumName(fieldType, toTsFieldType));
+      }
+    }
+    return Array.from(enumNames).sort();
+  };
+}

package/src/codegen/scaffoldFromSchema.ts

@@ -6,7 +6,7 @@ import ejs from 'ejs';
 import { ensureDirExists, ensureDirPath, toKebabCase } from './utils/path';
 import { camelCase, pascalCase } from 'change-case';
 import prettier from 'prettier';
-import { Flow, Slice, Model } from '@auto-engineer/flow';
+import { Narrative, Slice, Model } from '@auto-engineer/narrative';
 import createDebug from 'debug';
 
 const debug = createDebug('auto:server-generator-apollo-emmett:scaffold');
@@ -25,6 +25,14 @@ import {
   getAllEventTypes,
   getLocalEvents,
   createEventUnionType,
+  isInlineObject as isInlineObjectHelper,
+  isInlineObjectArray as isInlineObjectArrayHelper,
+  baseTs,
+  createIsEnumType,
+  createFieldUsesDate,
+  createFieldUsesJSON,
+  createFieldUsesFloat,
+  createCollectEnumNames,
 } from './extract';
 
 function extractGwtSpecs(slice: Slice) {
@@ -61,12 +69,214 @@ const defaultFilesByType: Record<string, string[]> = {
   react: ['react.ts.ejs', 'react.specs.ts.ejs', 'register.ts.ejs'],
 };
 
+interface EnumDefinition {
+  name: string;
+  values: string[];
+  unionString: string;
+}
+
+interface EnumContext {
+  enums: EnumDefinition[];
+  unionToEnumName: Map<string, string>;
+}
+
+function isStringLiteralUnion(s: string): boolean {
+  return /^"[^"]+"(\s*\|\s*"[^"]+")+$/.test(s.trim()) || /^'[^']+'(\s*\|\s*'[^']+)+$/.test(s.trim());
+}
+
+function extractStringLiteralValues(unionString: string): string[] {
+  const doubleQuoted = unionString.match(/"([^"]+)"/g);
+  const singleQuoted = unionString.match(/'([^']+)'/g);
+  const matches = doubleQuoted ?? singleQuoted;
+  if (matches === null) return [];
+  return matches.map((m) => m.slice(1, -1));
+}
+
+function normalizeUnionString(values: string[]): string {
+  return values
+    .slice()
+    .sort()
+    .map((v) => `'${v}'`)
+    .join(' | ');
+}
+
+function generateEnumName(fieldName: string, existingNames: Set<string>): string {
+  const baseName = pascalCase(fieldName);
+  if (!existingNames.has(baseName)) {
+    return baseName;
+  }
+  let counter = 2;
+  while (existingNames.has(`${baseName}${counter}`)) {
+    counter++;
+  }
+  return `${baseName}${counter}`;
+}
+
+function processFieldForEnum(
+  field: { name: string; type: string },
+  messageName: string,
+  unionToEnumName: Map<string, string>,
+  existingEnumNames: Set<string>,
+): EnumDefinition | null {
+  const tsType = field.type;
+  debug('    Field: %s, type: %O', field.name, tsType);
+  if (tsType === null || tsType === undefined) return null;
+
+  const cleanType = tsType.replace(/\s*\|\s*null\b/g, '').trim();
+  const isUnion = isStringLiteralUnion(cleanType);
+  debug('      cleanType: %O, isStringLiteralUnion: %s', cleanType, isUnion);
+  if (!isUnion) return null;
+
+  const values = extractStringLiteralValues(cleanType);
+  debug('      extracted values: %O', values);
+  if (values.length === 0) return null;
+
+  const normalized = normalizeUnionString(values);
+
+  if (unionToEnumName.has(normalized)) {
+    debug('      already has enum for this union, skipping');
+    return null;
+  }
+
+  const enumName = generateEnumName(`${messageName}${pascalCase(field.name)}`, existingEnumNames);
+  existingEnumNames.add(enumName);
+  debug('      ✓ Creating enum: %s with values %O', enumName, values);
+
+  const enumDef: EnumDefinition = {
+    name: enumName,
+    values,
+    unionString: normalized,
+  };
+
+  unionToEnumName.set(normalized, enumName);
+  return enumDef;
+}
+
+function extractEnumsFromMessages(messages: MessageDefinition[]): EnumContext {
+  const unionToEnumName = new Map<string, string>();
+  const enums: EnumDefinition[] = [];
+  const existingEnumNames = new Set<string>();
+
+  debug('extractEnumsFromMessages: processing %d messages', messages.length);
+
+  for (const message of messages) {
+    debug('  Message: %s, has fields: %s', message.name, message.fields !== undefined && message.fields !== null);
+    if (message.fields === undefined || message.fields === null) continue;
+
+    for (const field of message.fields) {
+      const enumDef = processFieldForEnum(field, message.name, unionToEnumName, existingEnumNames);
+      if (enumDef !== null) {
+        enums.push(enumDef);
+      }
+    }
+  }
+
+  debug('extractEnumsFromMessages: found %d enums total', enums.length);
+  debug(
+    '  Enum names: %O',
+    enums.map((e) => e.name),
+  );
+  debug('  unionToEnumName map size: %d', unionToEnumName.size);
+  for (const [union, enumName] of unionToEnumName.entries()) {
+    debug('    "%s" -> %s', union, enumName);
+  }
+  return { enums, unionToEnumName };
+}
+
+function generateEnumTypeScript(enumDef: EnumDefinition): string {
+  const entries = enumDef.values.map((val) => {
+    const key = val.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+    return `  ${key} = '${val}',`;
+  });
+
+  return `export enum ${enumDef.name} {
+${entries.join('\n')}
+}
+
+registerEnumType(${enumDef.name}, {
+  name: '${enumDef.name}',
+});`;
+}
+
+async function appendEnumsToSharedTypes(baseDir: string, enums: EnumDefinition[]): Promise<void> {
+  if (enums.length === 0) return;
+
+  const sharedTypesPath = path.join(baseDir, 'shared', 'types.ts');
+
+  let existingContent = '';
+  try {
+    existingContent = await fs.readFile(sharedTypesPath, 'utf8');
+  } catch {
+    debug('Types file does not exist yet at %s, will create it', sharedTypesPath);
+  }
+
+  const enumsToAdd = enums.filter((e) => {
+    const enumPattern = new RegExp(`export\\s+enum\\s+${e.name}\\s*\\{`, 'm');
+    return !enumPattern.test(existingContent);
+  });
+
+  if (enumsToAdd.length === 0) {
+    debug('All enums already exist in %s, skipping', sharedTypesPath);
+    return;
+  }
+
+  debug('Adding %d new enums to %s', enumsToAdd.length, sharedTypesPath);
+
+  const hasRegisterEnumImport = existingContent.includes('registerEnumType');
+  const enumCode = enumsToAdd.map((e) => generateEnumTypeScript(e)).join('\n\n');
+
+  let newContent: string;
+  if (hasRegisterEnumImport) {
+    newContent = `${existingContent.trimEnd()}\n\n${enumCode}\n`;
+  } else {
+    const importMatch = existingContent.match(/^([\s\S]*?)(import.*from\s+['"]type-graphql['"];?\s*\n)/m);
+    if (importMatch !== null) {
+      const beforeImport = importMatch[1];
+      const typeGraphqlImport = importMatch[2];
+      const afterImport = existingContent.slice(beforeImport.length + typeGraphqlImport.length);
+
+      const updatedImport = typeGraphqlImport.replace(
+        /^import\s*\{([^}]*)\}\s*from\s*['"]type-graphql['"];?\s*$/m,
+        (_match: string, imports: string): string => {
+          const importsList = imports
+            .split(',')
+            .map((s) => s.trim())
+            .filter((item) => item.length > 0);
+          if (!importsList.includes('registerEnumType')) {
+            importsList.push('registerEnumType');
+          }
+          return `import { ${importsList.join(', ')} } from 'type-graphql';`;
+        },
+      );
+
+      newContent = `${beforeImport}${updatedImport}${afterImport.trimEnd()}\n\n${enumCode}\n`;
+    } else {
+      newContent = `import { registerEnumType } from 'type-graphql';\n\n${existingContent.trimEnd()}\n\n${enumCode}\n`;
+    }
+  }
+
+  const prettierConfig = await prettier.resolveConfig(sharedTypesPath);
+  const formatted = await prettier.format(newContent, {
+    ...prettierConfig,
+    parser: 'typescript',
+    filepath: sharedTypesPath,
+  });
+
+  await fs.mkdir(path.dirname(sharedTypesPath), { recursive: true });
+  await fs.writeFile(sharedTypesPath, formatted, 'utf8');
+  debug('Appended %d enums to %s', enums.length, sharedTypesPath);
+}
+
 export interface FilePlan {
   outputPath: string;
   contents: string;
 }
 
-async function renderTemplate(templatePath: string, data: Record<string, unknown>): Promise<string> {
+async function renderTemplate(
+  templatePath: string,
+  data: Record<string, unknown>,
+  unionToEnumName: Map<string, string> = new Map(),
+): Promise<string> {
   debugTemplate('Rendering template: %s', templatePath);
   debugTemplate('Data keys: %o', Object.keys(data));
 
@@ -78,14 +288,13 @@ async function renderTemplate(templatePath: string, data: Record<string, unknown
   });
   debugTemplate('Template compiled successfully');
 
-  const isInlineObject = (s: string) => /^\{[\s\S]*\}$/.test(s.trim());
-  const isStringLiteralUnion = (s: string) => /^"(?:[^"]+)"\s*(\|\s*"(?:[^"]+)")+$/.test(s.trim());
+  const isInlineObject = isInlineObjectHelper;
+  const isInlineObjectArray = isInlineObjectArrayHelper;
+
   const convertPrimitiveType = (base: string): string => {
-    // GraphQL-native scalars
     if (base === 'ID') return 'ID';
     if (base === 'Int') return 'Int';
     if (base === 'Float') return 'Float';
-    // TS primitives
     if (base === 'string') return 'String';
     if (base === 'number') return 'Float';
     if (base === 'boolean') return 'Boolean';
@@ -93,33 +302,58 @@ async function renderTemplate(templatePath: string, data: Record<string, unknown
     return 'String';
   };
 
+  const resolveEnumOrString = (base: string): string => {
+    if (!isStringLiteralUnion(base)) return 'String';
+    const values = extractStringLiteralValues(base);
+    const normalized = normalizeUnionString(values);
+    const enumName = unionToEnumName.get(normalized);
+    return enumName ?? 'String';
+  };
+
   const graphqlType = (rawTs: string): string => {
     const t = (rawTs ?? '').trim();
     if (!t) return 'String';
     const base = t.replace(/\s*\|\s*null\b/g, '').trim();
-    // arrays
+
     const arr1 = base.match(/^Array<(.*)>$/);
     const arr2 = base.match(/^(.*)\[\]$/);
-    if (arr1) return `[${graphqlType(arr1[1].trim())}]`;
-    if (arr2) return `[${graphqlType(arr2[1].trim())}]`;
-    // JSON
+    if (arr1 !== null) return `[${graphqlType(arr1[1].trim())}]`;
+    if (arr2 !== null) return `[${graphqlType(arr2[1].trim())}]`;
+
     if (base === 'unknown' || base === 'any') return 'GraphQLJSON';
     if (base === 'object') return 'JSON';
     if (isInlineObject(base)) return 'JSON';
-    if (isStringLiteralUnion(base)) return 'String';
+    if (isStringLiteralUnion(base)) return resolveEnumOrString(base);
+
     return convertPrimitiveType(base);
   };
 
   const toTsFieldType = (ts: string): string => {
     if (!ts) return 'string';
     const t = ts.trim();
-    const arr = t.match(/^Array<(.*)>$/);
-    if (arr) return `${arr[1].trim()}[]`;
+    const cleanType = t.replace(/\s*\|\s*null\b/g, '').trim();
+
+    const arr = cleanType.match(/^Array<(.*)>$/);
+    if (arr !== null) return `${toTsFieldType(arr[1].trim())}[]`;
+
+    if (isStringLiteralUnion(cleanType)) {
+      const values = extractStringLiteralValues(cleanType);
+      const normalized = normalizeUnionString(values);
+      const enumName = unionToEnumName.get(normalized);
+      if (enumName !== undefined) return enumName;
+    }
+
     return t;
   };
 
   const isNullable = (rawTs: string): boolean => /\|\s*null\b/.test(rawTs);
 
+  const isEnumType = createIsEnumType(toTsFieldType);
+  const fieldUsesDate = createFieldUsesDate(graphqlType);
+  const fieldUsesJSON = createFieldUsesJSON(graphqlType);
+  const fieldUsesFloat = createFieldUsesFloat(graphqlType);
+  const collectEnumNames = createCollectEnumNames(isEnumType, toTsFieldType);
+
   const result = await template({
     ...data,
     pascalCase,
@@ -132,6 +366,14 @@ async function renderTemplate(templatePath: string, data: Record<string, unknown
     formatDataObject,
     messages: data.messages,
     message: data.message,
+    isInlineObject,
+    isInlineObjectArray,
+    baseTs,
+    isEnumType,
+    fieldUsesDate,
+    fieldUsesJSON,
+    fieldUsesFloat,
+    collectEnumNames,
   });
 
   debugTemplate('Template rendered, output size: %d bytes', result.length);
@@ -188,6 +430,7 @@ async function generateFileForTemplate(
   slice: Slice,
   sliceDir: 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);
@@ -201,7 +444,7 @@ async function generateFileForTemplate(
   debugFiles('  Template path: %s', templatePath);
   debugFiles('  Output path: %s', outputPath);
 
-  const contents = await renderTemplate(templatePath, templateData);
+  const contents = await renderTemplate(templatePath, templateData, unionToEnumName);
   debugFiles('  Rendered content size: %d bytes', contents.length);
 
   debugFiles('  Formatting with Prettier...');
@@ -241,7 +484,7 @@ function extractUsedErrors(gwtMapping: Record<string, (GwtCondition & { failingF
 
 async function prepareTemplateData(
   slice: Slice,
-  flow: Flow,
+  flow: Narrative,
   commands: Message[],
   events: Message[],
   states: Message[],
@@ -313,7 +556,7 @@ async function prepareTemplateData(
 
 function annotateEventSources(
   events: Message[],
-  flows: Flow[],
+  flows: Narrative[],
   fallbackFlowName: string,
   fallbackSliceName: string,
 ): void {
@@ -339,7 +582,7 @@ function canSliceProduceEvent(slice: Slice): boolean {
   return ['command', 'react'].includes(slice.type) && 'server' in slice && Boolean(slice.server?.specs);
 }
 
-function findEventSource(flows: Flow[], eventType: string): { flowName: string; sliceName: string } | null {
+function findEventSource(flows: Narrative[], eventType: string): { flowName: string; sliceName: string } | null {
   debugSlice('Finding source for event: %s', eventType);
 
   for (const flow of flows) {
@@ -360,7 +603,7 @@ function findEventSource(flows: Flow[], eventType: string): { flowName: string;
 
 function annotateCommandSources(
   commands: Message[],
-  flows: Flow[],
+  flows: Narrative[],
   fallbackFlowName: string,
   fallbackSliceName: string,
 ): void {
@@ -373,7 +616,7 @@ function annotateCommandSources(
   }
 }
 
-function findCommandSource(flows: Flow[], commandType: string): { flowName: string; sliceName: string } | null {
+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) {
@@ -403,10 +646,11 @@ function findCommandSource(flows: Flow[], commandType: string): { flowName: stri
 
 async function generateFilesForSlice(
   slice: Slice,
-  flow: Flow,
+  flow: Narrative,
   sliceDir: string,
   messages: MessageDefinition[],
-  flows: Flow[],
+  flows: Narrative[],
+  unionToEnumName: Map<string, string>,
   integrations?: Model['integrations'],
 ): Promise<FilePlan[]> {
   debugSlice('Generating files for slice: %s (type: %s)', slice.name, slice.type);
@@ -447,14 +691,14 @@ async function generateFilesForSlice(
 
   debugSlice('  Generating %d files from templates', templates.length);
   const plans = await Promise.all(
-    templates.map((template) => generateFileForTemplate(template, slice, sliceDir, templateData)),
+    templates.map((template) => generateFileForTemplate(template, slice, sliceDir, templateData, unionToEnumName)),
   );
   debugSlice('  Generated %d file plans for slice: %s', plans.length, slice.name);
   return plans;
 }
 
 export async function generateScaffoldFilePlans(
-  flows: Flow[],
+  flows: Narrative[],
   messages: Model['messages'],
   integrations?: Model['integrations'],
   baseDir = 'src/domain/flows',
@@ -464,6 +708,12 @@ export async function generateScaffoldFilePlans(
   debug('  Number of messages: %d', messages?.length ?? 0);
   debug('  Base directory: %s', baseDir);
 
+  const { enums, unionToEnumName } = extractEnumsFromMessages(messages ?? []);
+  debug('  Extracted %d enums from messages', enums.length);
+
+  const domainBaseDir = baseDir.replace(/\/flows$/, '');
+  await appendEnumsToSharedTypes(domainBaseDir, enums);
+
   const allPlans: FilePlan[] = [];
 
   for (const flow of flows) {
@@ -476,7 +726,15 @@ export async function generateScaffoldFilePlans(
       debugFlow('  Processing slice: %s (type: %s)', slice.name, slice.type);
       const sliceDir = ensureDirPath(flowDir, toKebabCase(slice.name));
       debugFlow('    Slice directory: %s', sliceDir);
-      const plans = await generateFilesForSlice(slice, flow, sliceDir, messages, flows, integrations);
+      const plans = await generateFilesForSlice(
+        slice,
+        flow,
+        sliceDir,
+        messages ?? [],
+        flows,
+        unionToEnumName,
+        integrations,
+      );
       debugFlow('    Generated %d plans for slice', plans.length);
       allPlans.push(...plans);
     }
@@ -508,7 +766,7 @@ export async function writeScaffoldFilePlans(plans: FilePlan[]) {
 }
 
 export async function scaffoldFromSchema(
-  flows: Flow[],
+  flows: Narrative[],
   messages: Model['messages'],
   baseDir = 'src/domain/flows',
 ): Promise<void> {

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

@@ -1,12 +1,12 @@
 import { describe, it, expect } from 'vitest';
-import { Model as SpecsSchema } from '@auto-engineer/flow';
+import { Model as SpecsSchema } from '@auto-engineer/narrative';
 import { generateScaffoldFilePlans } from '../../scaffoldFromSchema';
 
 describe('commands.ts.ejs', () => {
   it('should generate correct command file', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
-      flows: [
+      narratives: [
         {
           name: 'Host creates a listing',
           slices: [
@@ -72,7 +72,7 @@ describe('commands.ts.ejs', () => {
       ],
     };
 
-    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
     const commandFile = plans.find((p) => p.outputPath.endsWith('commands.ts'));
 
     expect(commandFile?.contents).toMatchInlineSnapshot(`