@auto-engineer/narrative 0.11.11

package/src/transformers/model-to-narrative/generators/compose.ts

@@ -0,0 +1,124 @@
+import ts from 'typescript';
+import { buildImports, ALL_FLOW_FUNCTION_NAMES } from './imports';
+import { buildTypeAliases } from './types';
+import { buildFlowStatements } from './flow';
+import { extractTypeIntegrationNames } from '../utils/integration-extractor';
+import { integrationNameToPascalCase } from '../utils/strings';
+import { analyzeCodeUsage } from '../analysis/usage';
+import { Model } from '../../../index';
+
+export function generateTypeScriptCode(schema: Model, opts: { flowImport: string; integrationImport: string }): string {
+  const f = ts.factory;
+  const messages = schema.messages ?? [];
+  const flows = schema.narratives ?? [];
+  const integrations = schema.integrations ?? [];
+
+  const allTypeIntegrationNames = extractTypeIntegrationNames(flows);
+  const allValueIntegrationNames = integrations.map((integration) => integrationNameToPascalCase(integration.name));
+
+  const allFlowFunctionNames = [...ALL_FLOW_FUNCTION_NAMES];
+  const preliminaryStatements = buildStatements(
+    ts,
+    opts,
+    messages,
+    allTypeIntegrationNames,
+    allValueIntegrationNames,
+    allFlowFunctionNames,
+    flows,
+  );
+  const preliminaryFile = f.createSourceFile(
+    preliminaryStatements,
+    f.createToken(ts.SyntaxKind.EndOfFileToken),
+    ts.NodeFlags.None,
+  );
+  const printer = ts.createPrinter({
+    newLine: ts.NewLineKind.LineFeed,
+    removeComments: false,
+    omitTrailingSemicolon: false,
+  });
+  const preliminaryCode = printer.printFile(preliminaryFile);
+
+  // Analyze which types and integrations are actually used
+  const allTypeNames = messages.map((msg) => msg.name);
+  const usageAnalysis = analyzeCodeUsage(
+    preliminaryCode,
+    allTypeNames,
+    allTypeIntegrationNames,
+    allValueIntegrationNames,
+    allFlowFunctionNames,
+  );
+
+  // Filter to only used types and integrations
+  // Type integrations should be filtered based on usedTypes, not usedIntegrations
+  const usedTypeIntegrationNames = allTypeIntegrationNames.filter((name) => usageAnalysis.usedTypes.has(name));
+  const usedValueIntegrationNames = allValueIntegrationNames.filter((name) => usageAnalysis.usedIntegrations.has(name));
+  const usedFlowFunctionNames = Array.from(usageAnalysis.usedFlowFunctions);
+
+  // Include messages that are either:
+  // 1. Used in flows, or
+  // 2. Present in model but not referenced in flows (standalone message definitions)
+  // Exclude types that are imported from integrations - don't generate local type definitions for them
+  const usedMessages = messages.filter((msg) => {
+    const isImportedFromIntegration = usedTypeIntegrationNames.includes(msg.name);
+    const isUsedInFlow = usageAnalysis.usedTypes.has(msg.name);
+    const hasEmptyFlowSlices = flows.length === 0 || flows.every((flow) => flow.slices.length === 0);
+
+    // Don't generate local definitions for types imported from integrations
+    if (isImportedFromIntegration) {
+      return false;
+    }
+
+    return isUsedInFlow || hasEmptyFlowSlices;
+  });
+
+  const statements = buildStatements(
+    ts,
+    opts,
+    usedMessages,
+    usedTypeIntegrationNames,
+    usedValueIntegrationNames,
+    usedFlowFunctionNames,
+    flows,
+  );
+
+  // Create source file and print
+  const file = f.createSourceFile(statements, f.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+
+  return printer.printFile(file);
+}
+
+function buildStatements(
+  ts: typeof import('typescript'),
+  opts: { flowImport: string; integrationImport: string },
+  messages: Model['messages'],
+  typeIntegrationNames: string[],
+  valueIntegrationNames: string[],
+  usedFlowFunctionNames: string[],
+  flows: Model['narratives'],
+): ts.Statement[] {
+  const statements: ts.Statement[] = [];
+
+  // imports
+  const imports = buildImports(ts, opts, messages, typeIntegrationNames, valueIntegrationNames, usedFlowFunctionNames);
+  if (imports.importFlowValues !== null) statements.push(imports.importFlowValues);
+  if (imports.importFlowTypes !== null) statements.push(imports.importFlowTypes);
+  if (imports.importIntegrationValues !== null) statements.push(imports.importIntegrationValues);
+  if (imports.importIntegrationTypes !== null) statements.push(imports.importIntegrationTypes);
+
+  // Type definitions
+  const adaptedMessages = messages.map((msg) => ({
+    type: msg.type,
+    name: msg.name,
+    fields: msg.fields.map((field) => ({
+      name: field.name,
+      type: field.type,
+      required: field.required,
+    })),
+  }));
+  statements.push(...buildTypeAliases(ts, adaptedMessages));
+  for (const flow of flows) {
+    statements.push(...buildFlowStatements(ts, flow as unknown as Parameters<typeof buildFlowStatements>[1], messages));
+  }
+
+  return statements;
+}

package/src/transformers/model-to-narrative/generators/flow.ts

@@ -0,0 +1,570 @@
+import type tsNS from 'typescript';
+import type { z } from 'zod';
+import { jsonToExpr } from '../ast/emit-helpers';
+import { buildConsolidatedGwtSpecBlock, type GWTBlock } from './gwt';
+import {
+  CommandSliceSchema,
+  QuerySliceSchema,
+  ReactSliceSchema,
+  ExperienceSliceSchema,
+  ExampleSchema,
+  NarrativeSchema,
+  DataSinkSchema,
+  DataSourceSchema,
+  DestinationSchema,
+  OriginSchema,
+} from '../../../schema';
+
+type CommandSlice = z.infer<typeof CommandSliceSchema>;
+type QuerySlice = z.infer<typeof QuerySliceSchema>;
+type ReactSlice = z.infer<typeof ReactSliceSchema>;
+type ExperienceSlice = z.infer<typeof ExperienceSliceSchema>;
+type Example = z.infer<typeof ExampleSchema>;
+type Narrative = z.infer<typeof NarrativeSchema>;
+type DataSinkItem = z.infer<typeof DataSinkSchema>;
+type DataSourceItem = z.infer<typeof DataSourceSchema>;
+type Destination = z.infer<typeof DestinationSchema>;
+type Origin = z.infer<typeof OriginSchema>;
+type Slice = CommandSlice | QuerySlice | ReactSlice | ExperienceSlice;
+
+function buildClientSpecs(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  specs: { name: string; rules: string[] },
+) {
+  const shouldCalls = specs.rules.map((txt) =>
+    f.createExpressionStatement(
+      f.createCallExpression(f.createIdentifier('should'), undefined, [f.createStringLiteral(txt)]),
+    ),
+  );
+
+  const arrowFunction = f.createArrowFunction(
+    undefined,
+    undefined,
+    [],
+    undefined,
+    f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+    f.createBlock(shouldCalls, true),
+  );
+
+  const args: tsNS.Expression[] = [];
+  if (specs.name && specs.name.trim() !== '') {
+    args.push(f.createStringLiteral(specs.name));
+  }
+  args.push(arrowFunction);
+
+  return f.createExpressionStatement(f.createCallExpression(f.createIdentifier('specs'), undefined, args));
+}
+
+function buildInitialChain(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  target: DataSinkItem['target'] | DataSourceItem['target'],
+): tsNS.Expression {
+  const op = target.type === 'Event' ? 'event' : target.type === 'Command' ? 'command' : 'state';
+  return f.createCallExpression(
+    f.createPropertyAccessExpression(
+      target.type === 'State'
+        ? f.createCallExpression(f.createIdentifier('source'), undefined, [])
+        : f.createCallExpression(f.createIdentifier('sink'), undefined, []),
+      ts.factory.createIdentifier(op),
+    ),
+    undefined,
+    [f.createStringLiteral(target.name)],
+  );
+}
+
+function addDestinationToChain(f: tsNS.NodeFactory, chain: tsNS.Expression, destination: Destination): tsNS.Expression {
+  switch (destination.type) {
+    case 'stream':
+      return f.createCallExpression(
+        f.createPropertyAccessExpression(chain, f.createIdentifier('toStream')),
+        undefined,
+        [f.createStringLiteral(destination.pattern)],
+      );
+    case 'database':
+      return f.createCallExpression(
+        f.createPropertyAccessExpression(chain, f.createIdentifier('toDatabase')),
+        undefined,
+        [f.createStringLiteral(destination.collection)],
+      );
+    case 'topic':
+      return f.createCallExpression(f.createPropertyAccessExpression(chain, f.createIdentifier('toTopic')), undefined, [
+        f.createStringLiteral(destination.name),
+      ]);
+    case 'integration': {
+      const [system] = destination.systems;
+      const args: tsNS.Expression[] = [f.createIdentifier(system)];
+      if (destination.message) {
+        args.push(f.createStringLiteral(destination.message.name));
+        args.push(f.createStringLiteral(destination.message.type));
+      }
+      return f.createCallExpression(
+        f.createPropertyAccessExpression(chain, f.createIdentifier('toIntegration')),
+        undefined,
+        args,
+      );
+    }
+    default:
+      return chain;
+  }
+}
+
+function buildStateCall(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  origin: Origin,
+  stateName: string,
+): tsNS.Expression {
+  const baseStateCall = f.createCallExpression(
+    f.createPropertyAccessExpression(
+      f.createCallExpression(f.createIdentifier('source'), undefined, []),
+      f.createIdentifier('state'),
+    ),
+    undefined,
+    [f.createStringLiteral(stateName)],
+  );
+
+  switch (origin.type) {
+    case 'integration': {
+      const [sys] = origin.systems;
+      return f.createCallExpression(
+        f.createPropertyAccessExpression(baseStateCall, f.createIdentifier('fromIntegration')),
+        undefined,
+        [f.createIdentifier(sys)],
+      );
+    }
+    case 'projection':
+      return f.createCallExpression(
+        f.createPropertyAccessExpression(baseStateCall, f.createIdentifier('fromProjection')),
+        undefined,
+        [f.createStringLiteral(origin.name), f.createStringLiteral(origin.idField)],
+      );
+    case 'database': {
+      const args: tsNS.Expression[] = [f.createStringLiteral(origin.collection)];
+      if (origin.query !== null && origin.query !== undefined) {
+        args.push(jsonToExpr(ts, f, origin.query));
+      }
+      return f.createCallExpression(
+        f.createPropertyAccessExpression(baseStateCall, f.createIdentifier('fromDatabase')),
+        undefined,
+        args,
+      );
+    }
+    case 'api': {
+      const args: tsNS.Expression[] = [f.createStringLiteral(origin.endpoint)];
+      if (origin.method !== null && origin.method !== undefined) {
+        args.push(f.createStringLiteral(origin.method));
+      }
+      return f.createCallExpression(
+        f.createPropertyAccessExpression(baseStateCall, f.createIdentifier('fromApi')),
+        undefined,
+        args,
+      );
+    }
+    case 'readModel':
+      return f.createCallExpression(
+        f.createPropertyAccessExpression(baseStateCall, f.createIdentifier('fromReadModel')),
+        undefined,
+        [f.createStringLiteral(origin.name)],
+      );
+    default:
+      return baseStateCall;
+  }
+}
+
+function buildOriginArgs(ts: typeof import('typescript'), f: tsNS.NodeFactory, origin: Origin): tsNS.Expression[] {
+  switch (origin.type) {
+    case 'projection':
+      return [f.createStringLiteral(origin.name), f.createStringLiteral(origin.idField)];
+    case 'integration': {
+      const [sys] = origin.systems;
+      return [f.createIdentifier(sys)];
+    }
+    case 'database': {
+      const args: tsNS.Expression[] = [f.createStringLiteral(origin.collection)];
+      if (origin.query !== null && origin.query !== undefined) {
+        args.push(jsonToExpr(ts, f, origin.query));
+      }
+      return args;
+    }
+    case 'api': {
+      const args: tsNS.Expression[] = [f.createStringLiteral(origin.endpoint)];
+      if (origin.method !== null && origin.method !== undefined) {
+        args.push(f.createStringLiteral(origin.method));
+      }
+      return args;
+    }
+    case 'readModel':
+      return [f.createStringLiteral(origin.name)];
+    default:
+      return [];
+  }
+}
+
+function getOriginMethodName(origin: Origin): string {
+  switch (origin.type) {
+    case 'projection':
+      return 'fromProjection';
+    case 'integration':
+      return 'fromIntegration';
+    case 'database':
+      return 'fromDatabase';
+    case 'api':
+      return 'fromApi';
+    case 'readModel':
+      return 'fromReadModel';
+    default:
+      return 'fromReadModel';
+  }
+}
+
+function buildSingleDataItem(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  it: DataSinkItem | DataSourceItem,
+): tsNS.Expression {
+  let chain = buildInitialChain(ts, f, it.target);
+
+  if ('destination' in it) {
+    const sinkItem = it;
+    chain = addDestinationToChain(f, chain, sinkItem.destination);
+
+    if (sinkItem._withState) {
+      const stateCall = buildStateCall(ts, f, sinkItem._withState.origin, sinkItem._withState.target.name);
+      chain = f.createCallExpression(
+        f.createPropertyAccessExpression(chain, f.createIdentifier('withState')),
+        undefined,
+        [stateCall],
+      );
+    }
+
+    if (sinkItem._additionalInstructions !== null && sinkItem._additionalInstructions !== undefined) {
+      chain = f.createCallExpression(
+        f.createPropertyAccessExpression(chain, f.createIdentifier('additionalInstructions')),
+        undefined,
+        [f.createStringLiteral(sinkItem._additionalInstructions)],
+      );
+    }
+  } else if ('origin' in it) {
+    const sourceItem = it;
+    chain = f.createCallExpression(
+      f.createPropertyAccessExpression(
+        f.createCallExpression(
+          f.createPropertyAccessExpression(
+            f.createCallExpression(f.createIdentifier('source'), undefined, []),
+            f.createIdentifier('state'),
+          ),
+          undefined,
+          [f.createStringLiteral(sourceItem.target.name)],
+        ),
+        f.createIdentifier(getOriginMethodName(sourceItem.origin)),
+      ),
+      undefined,
+      buildOriginArgs(ts, f, sourceItem.origin),
+    );
+  }
+
+  return chain;
+}
+
+function buildDataItems(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  items: Array<DataSinkItem | DataSourceItem>,
+) {
+  const calls = items.map((it) => buildSingleDataItem(ts, f, it));
+
+  return f.createExpressionStatement(
+    f.createCallExpression(f.createIdentifier('data'), undefined, [f.createArrayLiteralExpression(calls, false)]),
+  );
+}
+
+function addClientToChain(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  chain: tsNS.Expression,
+  slice: CommandSlice | QuerySlice | ReactSlice | ExperienceSlice,
+): tsNS.Expression {
+  if ('client' in slice && slice.client !== null && slice.client !== undefined && slice.client.specs) {
+    return f.createCallExpression(f.createPropertyAccessExpression(chain, f.createIdentifier('client')), undefined, [
+      f.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+        f.createBlock([buildClientSpecs(ts, f, slice.client.specs)], true),
+      ),
+    ]);
+  }
+  return chain;
+}
+
+function addRequestToChain(
+  f: tsNS.NodeFactory,
+  chain: tsNS.Expression,
+  slice: CommandSlice | QuerySlice | ReactSlice | ExperienceSlice,
+): tsNS.Expression {
+  if ('request' in slice && slice.request !== null && slice.request !== undefined) {
+    const gqlTpl = f.createNoSubstitutionTemplateLiteral(slice.request);
+    return f.createCallExpression(f.createPropertyAccessExpression(chain, f.createIdentifier('request')), undefined, [
+      f.createCallExpression(f.createIdentifier('gql'), undefined, [gqlTpl]),
+    ]);
+  }
+  return chain;
+}
+
+/**
+ * Convert schema example structure to GWT format expected by buildGwtSpecBlock
+ */
+function convertExampleToGWT(example: Example, _sliceType: 'command' | 'query' | 'react' | 'experience'): GWTBlock {
+  const gwtBlock: GWTBlock = {
+    then: [],
+  };
+
+  // Add description metadata
+  (gwtBlock as { description?: string }).description = example.description;
+
+  // Convert given
+  if (example.given) {
+    gwtBlock.given = example.given.map((given) => {
+      if ('stateRef' in given) {
+        return { eventRef: given.stateRef, exampleData: given.exampleData };
+      } else if ('eventRef' in given) {
+        return { eventRef: given.eventRef, exampleData: given.exampleData };
+      }
+      return given;
+    });
+  }
+
+  // Convert when
+  if (example.when !== null && example.when !== undefined) {
+    if (Array.isArray(example.when)) {
+      // Array of events for react slices
+      gwtBlock.when = example.when.map((when) => {
+        if ('eventRef' in when) {
+          return { eventRef: when.eventRef, exampleData: when.exampleData };
+        } else if ('commandRef' in when) {
+          return { commandRef: when.commandRef, exampleData: when.exampleData };
+        }
+        return when;
+      });
+    } else {
+      // Single object - could be command (command slices) or event (query slices)
+      if ('commandRef' in example.when) {
+        // Command for command slices
+        gwtBlock.when = {
+          commandRef: example.when.commandRef,
+          exampleData: example.when.exampleData,
+        };
+      } else if ('eventRef' in example.when) {
+        // Event for query slices
+        gwtBlock.when = {
+          eventRef: example.when.eventRef,
+          exampleData: example.when.exampleData,
+        };
+      }
+    }
+  }
+
+  // Convert then
+  gwtBlock.then = example.then.map((then) => {
+    if ('eventRef' in then) {
+      return { eventRef: then.eventRef, exampleData: then.exampleData };
+    } else if ('commandRef' in then) {
+      return { commandRef: then.commandRef, exampleData: then.exampleData };
+    } else if ('stateRef' in then) {
+      return { stateRef: then.stateRef, exampleData: then.exampleData };
+    } else {
+      // Error case - return as-is
+      return then;
+    }
+  });
+
+  return gwtBlock;
+}
+
+type RuleType = { id?: string; description: string; examples: Example[] };
+type RuleGroup = { rule: RuleType; examples: Example[] };
+
+function buildRuleGroups(rules: RuleType[]): Map<string, RuleGroup> {
+  const ruleGroups = new Map<string, RuleGroup>();
+
+  for (const rule of rules) {
+    const ruleId = rule.id ?? 'no-id';
+    const ruleKey = `${ruleId}:${rule.description}`;
+
+    if (ruleGroups.has(ruleKey)) {
+      const existingGroup = ruleGroups.get(ruleKey)!;
+      existingGroup.examples.push(...rule.examples);
+    } else {
+      ruleGroups.set(ruleKey, { rule, examples: [...rule.examples] });
+    }
+  }
+
+  return ruleGroups;
+}
+
+function buildConsolidatedRules(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  ruleGroups: Map<string, RuleGroup>,
+  sliceType: 'command' | 'query' | 'react' | 'experience',
+  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
+): tsNS.Statement[] {
+  const allRuleStatements: tsNS.Statement[] = [];
+
+  for (const { rule, examples } of ruleGroups.values()) {
+    const gwtBlocks = examples.map((example) => {
+      const gwtBlock = convertExampleToGWT(example, sliceType);
+      const extendedGwtBlock = gwtBlock as GWTBlock & {
+        ruleDescription?: string;
+        exampleDescription?: string;
+        ruleId?: string;
+      };
+
+      extendedGwtBlock.ruleDescription = rule.description;
+      extendedGwtBlock.exampleDescription = example.description;
+      extendedGwtBlock.ruleId = rule.id;
+
+      return extendedGwtBlock;
+    });
+
+    allRuleStatements.push(buildConsolidatedGwtSpecBlock(ts, f, rule, gwtBlocks, sliceType, messages));
+  }
+
+  return allRuleStatements;
+}
+
+function buildServerStatements(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  server: CommandSlice['server'] | QuerySlice['server'] | ReactSlice['server'],
+  sliceType: 'command' | 'query' | 'react' | 'experience',
+  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
+): tsNS.Statement[] {
+  const statements: tsNS.Statement[] = [];
+
+  if (server.data !== null && server.data !== undefined && server.data.length > 0) {
+    statements.push(buildDataItems(ts, f, server.data as Array<DataSinkItem | DataSourceItem>));
+  }
+
+  if (server.specs !== null && server.specs !== undefined) {
+    const ruleGroups = buildRuleGroups(server.specs.rules as RuleType[]);
+    const allRuleStatements = buildConsolidatedRules(ts, f, ruleGroups, sliceType, messages);
+
+    if (allRuleStatements.length > 0) {
+      const arrowFunction = f.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+        f.createBlock(allRuleStatements, true),
+      );
+
+      const args: tsNS.Expression[] = [];
+      if (server.specs.name && server.specs.name.trim() !== '') {
+        args.push(f.createStringLiteral(server.specs.name));
+      }
+      args.push(arrowFunction);
+
+      const specsStatement = f.createExpressionStatement(
+        f.createCallExpression(f.createIdentifier('specs'), undefined, args),
+      );
+      statements.push(specsStatement);
+    }
+  }
+
+  return statements;
+}
+
+function addServerToChain(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  chain: tsNS.Expression,
+  slice: CommandSlice | QuerySlice | ReactSlice | ExperienceSlice,
+  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
+): tsNS.Expression {
+  if ('server' in slice && slice.server !== null && slice.server !== undefined) {
+    const sliceType = slice.type as 'command' | 'query' | 'react' | 'experience';
+    const serverStatements = buildServerStatements(
+      ts,
+      f,
+      slice.server,
+      sliceType === 'experience' ? 'react' : sliceType,
+      messages,
+    );
+
+    return f.createCallExpression(f.createPropertyAccessExpression(chain, f.createIdentifier('server')), undefined, [
+      f.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+        f.createBlock(serverStatements, true),
+      ),
+    ]);
+  }
+  return chain;
+}
+
+function buildSlice(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  slice: CommandSlice | QuerySlice | ReactSlice | ExperienceSlice,
+  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
+): tsNS.Statement {
+  const sliceCtor =
+    slice.type === 'command'
+      ? 'command'
+      : slice.type === 'query'
+        ? 'query'
+        : slice.type === 'experience'
+          ? 'experience'
+          : 'react';
+
+  const args: tsNS.Expression[] = [f.createStringLiteral(slice.name)];
+  if (slice.id !== null && slice.id !== undefined) {
+    args.push(f.createStringLiteral(slice.id));
+  }
+
+  let chain: tsNS.Expression = f.createCallExpression(f.createIdentifier(sliceCtor), undefined, args);
+
+  chain = addClientToChain(ts, f, chain, slice);
+  chain = addRequestToChain(f, chain, slice);
+  chain = addServerToChain(ts, f, chain, slice, messages);
+
+  return f.createExpressionStatement(chain);
+}
+
+export function buildFlowStatements(
+  ts: typeof import('typescript'),
+  flow: Narrative,
+  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
+): tsNS.Statement[] {
+  const f = ts.factory;
+
+  const body = (flow.slices ?? []).map((sl: Slice) => buildSlice(ts, f, sl, messages));
+
+  const flowArgs: tsNS.Expression[] = [f.createStringLiteral(flow.name)];
+  if (flow.id !== null && flow.id !== undefined) {
+    flowArgs.push(f.createStringLiteral(flow.id));
+  }
+  flowArgs.push(
+    f.createArrowFunction(
+      undefined,
+      undefined,
+      [],
+      undefined,
+      f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+      f.createBlock(body, true),
+    ),
+  );
+
+  const flowExpr = f.createCallExpression(f.createIdentifier('narrative'), undefined, flowArgs);
+
+  return [f.createExpressionStatement(flowExpr)];
+}