@auto-engineer/server-generator-nestjs 0.11.16

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

@@ -0,0 +1,93 @@
+import type { Slice } from '@auto-engineer/narrative';
+import { extractGwtSpecsFromSlice, type GwtResult } from './step-converter';
+import type { CommandExample } from './step-types';
+
+function resolveStreamId(stream: string, exampleData: Record<string, unknown>): string {
+  return stream.replace(/\$\{([^}]+)\}/g, (_, key: string) => String(exampleData?.[key] ?? 'unknown'));
+}
+
+function extractExampleDataFromReact(firstSpec: GwtResult): Record<string, unknown> {
+  if (Array.isArray(firstSpec.when)) {
+    const firstWhen = firstSpec.when[0];
+    return typeof firstWhen?.exampleData === 'object' && firstWhen.exampleData !== null ? firstWhen.exampleData : {};
+  }
+  return {};
+}
+
+function extractExampleDataFromCommand(firstSpec: GwtResult): Record<string, unknown> {
+  const then = firstSpec.then;
+  const firstExample = then.find((t): t is CommandExample => 'exampleData' in t);
+  return typeof firstExample?.exampleData === 'object' && firstExample.exampleData !== null
+    ? firstExample.exampleData
+    : {};
+}
+
+function extractExampleDataFromQuery(firstSpec: GwtResult): Record<string, unknown> {
+  if (Array.isArray(firstSpec.when)) {
+    const firstWhen = firstSpec.when[0];
+    return typeof firstWhen?.exampleData === 'object' && firstWhen.exampleData !== null ? firstWhen.exampleData : {};
+  }
+  return {};
+}
+
+function extractExampleDataFromSpecs(slice: Slice, gwtSpecs: GwtResult[]): Record<string, unknown> {
+  if (gwtSpecs.length === 0) {
+    return {};
+  }
+
+  const firstSpec = gwtSpecs[0];
+  switch (slice.type) {
+    case 'react':
+      return extractExampleDataFromReact(firstSpec);
+    case 'command':
+      return extractExampleDataFromCommand(firstSpec);
+    case 'query':
+      return extractExampleDataFromQuery(firstSpec);
+    default:
+      return {};
+  }
+}
+
+function isValidStreamSink(item: unknown): item is { destination: { pattern: string } } {
+  return (
+    typeof item === 'object' &&
+    item !== null &&
+    'destination' in item &&
+    typeof item.destination === 'object' &&
+    item.destination !== null &&
+    'type' in item.destination &&
+    item.destination.type === 'stream' &&
+    'pattern' in item.destination &&
+    typeof item.destination.pattern === 'string'
+  );
+}
+
+function processStreamSink(item: unknown, exampleData: Record<string, unknown>) {
+  if (!isValidStreamSink(item)) {
+    return null;
+  }
+
+  const streamPattern = item.destination.pattern;
+  const streamId = streamPattern.length > 0 ? resolveStreamId(streamPattern, exampleData) : undefined;
+
+  return { streamPattern, streamId };
+}
+
+export function getStreamFromSink(slice: Slice): { streamPattern?: string; streamId?: string } {
+  if (!('server' in slice)) return {};
+  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const exampleData = extractExampleDataFromSpecs(slice, gwtSpecs);
+  if (!('server' in slice) || slice.server == null || !('data' in slice.server) || !Array.isArray(slice.server.data)) {
+    return {};
+  }
+  const serverData = slice.server.data;
+
+  for (const item of serverData) {
+    const result = processStreamSink(item, exampleData);
+    if (result) {
+      return result;
+    }
+  }
+
+  return {};
+}

package/src/codegen/extract/events.ts

@@ -0,0 +1,63 @@
+import type { Message, MessageDefinition } from '../types';
+import { extractFieldsFromMessage } from './fields';
+import type { ReactGwtSpec } from './messages';
+import type { EventExample } from './step-types';
+
+function createEventMessage(
+  eventRef: string | undefined,
+  source: 'given' | 'then' | 'when',
+  allMessages: MessageDefinition[],
+  currentSliceName?: string,
+  currentFlowName?: 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;
+
+  return {
+    type: eventRef,
+    fields,
+    source,
+    sourceFlowName,
+    sourceSliceName,
+  };
+}
+
+export function extractEventsFromThen(
+  thenItems: Array<EventExample | { errorType: string; message?: string }>,
+  allMessages: MessageDefinition[],
+  currentSliceName?: string,
+  currentFlowName?: string,
+): Message[] {
+  return thenItems
+    .map((then): Message | undefined => {
+      if (!('eventRef' in then)) return undefined;
+      return createEventMessage(then.eventRef, 'then', allMessages, currentSliceName, currentFlowName);
+    })
+    .filter((event): event is Message => event !== undefined);
+}
+
+export function extractEventsFromGiven(
+  givenEvents: EventExample[] | undefined,
+  allMessages: MessageDefinition[],
+  currentSliceName?: string,
+  currentFlowName?: string,
+): Message[] {
+  if (!givenEvents) return [];
+
+  return givenEvents
+    .map((given) => createEventMessage(given.eventRef, 'given', allMessages, currentSliceName, currentFlowName))
+    .filter((event): event is Message => event !== undefined);
+}
+
+export function extractEventsFromWhen(gwtSpecs: ReactGwtSpec[], allMessages: MessageDefinition[]): Message[] {
+  return gwtSpecs.flatMap((gwt) => {
+    if (!Array.isArray(gwt.when)) {
+      return [];
+    }
+    return gwt.when.flatMap((eventExample) => extractEventsFromGiven([eventExample], allMessages));
+  });
+}

package/src/codegen/extract/fields.ts

@@ -0,0 +1,17 @@
+import type { Field, MessageDefinition } from '../types';
+
+export function extractFieldsFromMessage(
+  messageName: string,
+  messageType: 'command' | 'event' | 'state',
+  allMessages: MessageDefinition[],
+): Field[] {
+  const messageDef = allMessages.find((m) => m.type === messageType && m.name === messageName);
+
+  return (
+    messageDef?.fields?.map((f) => ({
+      name: f.name,
+      tsType: f.type,
+      required: f.required ?? true,
+    })) ?? []
+  );
+}

package/src/codegen/extract/graphql.ts

@@ -0,0 +1,103 @@
+import { type OperationDefinitionNode, parse, print, type TypeNode } from 'graphql';
+
+export interface ParsedArg {
+  name: string;
+  tsType: string;
+  graphqlType: string;
+  nullable: boolean;
+}
+
+export interface ParsedGraphQlQuery {
+  queryName: string;
+  args: ParsedArg[];
+  returnType: string;
+  tsReturnType: string;
+}
+
+function getTypeName(typeNode: TypeNode): { graphqlType: string; nullable: boolean } {
+  if (typeNode.kind === 'NamedType') {
+    return { graphqlType: typeNode.name.value, nullable: true };
+  } else if (typeNode.kind === 'NonNullType') {
+    const inner = getTypeName(typeNode.type);
+    return { ...inner, nullable: false };
+  } else {
+    return getTypeName(typeNode.type);
+  }
+}
+
+function graphqlToTs(type: string): string {
+  switch (type) {
+    case 'String':
+      return 'string';
+    case 'Int':
+    case 'Float':
+    case 'Number':
+      return 'number';
+    case 'Boolean':
+      return 'boolean';
+    case 'Date':
+      return 'Date';
+    default:
+      return type;
+  }
+}
+
+function convertJsonAstToSdl(request: string): string {
+  // Handle JSON-serialized AST
+  if (request.startsWith('{') && request.includes('"kind"')) {
+    try {
+      const ast = JSON.parse(request) as unknown;
+      if (typeof ast === 'object' && ast !== null && 'kind' in ast && ast.kind === 'Document') {
+        // Convert AST to SDL string - cast is safe here as we've validated it's a Document
+        return print(ast as Parameters<typeof print>[0]);
+      }
+    } catch {
+      // If parsing fails, assume it's already a GraphQL string
+    }
+  }
+  return request;
+}
+
+export function parseGraphQlRequest(request: string): ParsedGraphQlQuery {
+  const sdlRequest = convertJsonAstToSdl(request);
+
+  const ast = parse(sdlRequest);
+  const op = ast.definitions.find(
+    (d): d is OperationDefinitionNode => d.kind === 'OperationDefinition' && d.operation === 'query',
+  );
+
+  if (!op) throw new Error('No query operation found');
+
+  const queryName = op.name?.value;
+  if (queryName == null) throw new Error('Query must have a name');
+
+  const args: ParsedArg[] = (op.variableDefinitions ?? []).map((def) => {
+    const varName = def.variable.name.value;
+    const { graphqlType, nullable } = getTypeName(def.type);
+    return {
+      name: varName,
+      graphqlType,
+      tsType: graphqlToTs(graphqlType),
+      nullable,
+    };
+  });
+
+  const field = op.selectionSet.selections[0];
+  if (field?.kind !== 'Field' || !field.name.value) {
+    throw new Error('Query selection must be a field');
+  }
+
+  const baseName = field.name.value;
+  const returnType = pascalCase(baseName) + 'View';
+
+  return {
+    queryName: baseName,
+    args,
+    returnType,
+    tsReturnType: `${returnType}[]`,
+  };
+}
+
+function pascalCase(input: string): string {
+  return input.replace(/(^\w|_\w)/g, (match) => match.replace('_', '').toUpperCase());
+}

package/src/codegen/extract/gwt.ts

@@ -0,0 +1,79 @@
+import type { Slice } from '@auto-engineer/narrative';
+import type { GwtCondition } from '../types';
+import { extractGwtSpecsFromSlice, type GwtConditionWithRule } from './step-converter';
+import type { CommandExample, EventExample } from './step-types';
+
+export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtCondition & { failingFields?: string[] })[]> {
+  if (slice.type !== 'command') {
+    return {};
+  }
+
+  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const mapping = buildCommandMapping(gwtSpecs);
+  return enhanceMapping(mapping);
+}
+
+function isCommandRef(when: CommandExample | EventExample[]): when is CommandExample {
+  return !Array.isArray(when) && 'commandRef' in when;
+}
+
+function buildCommandMapping(gwtSpecs: GwtConditionWithRule[]) {
+  const mapping: Record<string, GwtCondition[]> = {};
+
+  for (const gwt of gwtSpecs) {
+    if (!isCommandRef(gwt.when)) {
+      continue;
+    }
+    const command = gwt.when.commandRef;
+    if (typeof command === 'string' && command.length > 0) {
+      mapping[command] = mapping[command] ?? [];
+      mapping[command].push({
+        given: gwt.given,
+        when: gwt.when,
+        then: gwt.then,
+        description: gwt.description,
+        ruleDescription: gwt.ruleDescription,
+      });
+    }
+  }
+
+  return mapping;
+}
+
+function enhanceMapping(mapping: Record<string, GwtCondition[]>) {
+  const enhancedMapping: Record<string, (GwtCondition & { failingFields?: string[] })[]> = {};
+
+  for (const command in mapping) {
+    const conditions = mapping[command];
+    const successfulData = findSuccessfulExampleData(conditions);
+
+    enhancedMapping[command] = conditions.map((gwt) => ({
+      ...gwt,
+      failingFields: findFailingFields(gwt, successfulData),
+    }));
+  }
+
+  return enhancedMapping;
+}
+
+function findSuccessfulExampleData(gwts: GwtCondition[]): Record<string, unknown> {
+  const successful = gwts.find((gwt) => gwt.then.some((t) => typeof t === 'object' && t !== null && 'eventRef' in t));
+  const whenData = Array.isArray(successful?.when) ? successful?.when[0]?.exampleData : successful?.when?.exampleData;
+  return typeof whenData === 'object' && whenData !== null ? whenData : {};
+}
+
+function findFailingFields(gwt: GwtCondition, successfulData: Record<string, unknown>): string[] {
+  const hasError = gwt.then.some((t) => typeof t === 'object' && t !== null && 'errorType' in t);
+
+  if (!hasError) return [];
+
+  const whenData = Array.isArray(gwt.when) ? gwt.when[0]?.exampleData : gwt.when?.exampleData;
+  if (typeof whenData !== 'object' || whenData === null) return [];
+
+  return Object.entries(whenData)
+    .filter(([key, val]) => {
+      const successVal = successfulData[key];
+      return val === '' && successVal !== '' && successVal !== undefined;
+    })
+    .map(([key]) => key);
+}

package/src/codegen/extract/imports.ts

@@ -0,0 +1,71 @@
+import type { Message } from '../types';
+import { toKebabCase } from '../utils/path';
+
+export interface ImportGroup {
+  importPath: string;
+  eventTypes: string[];
+}
+
+export interface CrossSliceImportContext {
+  currentSliceName: string;
+  events: Message[];
+}
+
+/**
+ * Groups events by their import paths, handling cross-slice imports correctly.
+ * 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;
+  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;
+
+    if (isFromCurrentSlice) {
+      importPath = './events';
+    } else {
+      importPath = `../${toKebabCase(event.sourceSliceName ?? currentSliceName)}/events`;
+    }
+    if (!importGroups.has(importPath)) {
+      importGroups.set(importPath, []);
+    }
+    const eventTypes = importGroups.get(importPath)!;
+    if (!eventTypes.includes(event.type)) {
+      eventTypes.push(event.type);
+    }
+  }
+  return Array.from(importGroups.entries()).map(([importPath, eventTypes]) => ({
+    importPath,
+    eventTypes: eventTypes.sort(),
+  }));
+}
+
+/**
+ * Filters events to only include those from the current slice (source === 'then').
+ * Used for generating local event definitions.
+ */
+export function getLocalEvents(events: Message[]): Message[] {
+  return events.filter((event) => event.source === 'then');
+}
+
+/**
+ * Extracts all unique event types from a list of events.
+ */
+export function getAllEventTypes(events: Message[]): string[] {
+  const eventTypes = events.map((event) => event.type).filter((type): type is string => Boolean(type));
+
+  return Array.from(new Set(eventTypes)).sort();
+}
+
+/**
+ * Creates a TypeScript union type string from event types.
+ */
+export function createEventUnionType(events: Message[]): string {
+  const eventTypes = getAllEventTypes(events);
+  return eventTypes.length > 0 ? eventTypes.join(' | ') : 'never';
+}

package/src/codegen/extract/index.ts

@@ -0,0 +1,9 @@
+export * from './commands';
+export * from './events';
+export * from './gwt';
+export * from './imports';
+export * from './messages';
+export * from './projection';
+export * from './query';
+export * from './states';
+export * from './type-helpers';

package/src/codegen/extract/messages.ts

@@ -0,0 +1,232 @@
+import type { Slice } from '@auto-engineer/narrative';
+import createDebug from 'debug';
+import type { Message, MessageDefinition } from '../types';
+import { extractCommandsFromGwt, extractCommandsFromThen } from './commands';
+import { extractEventsFromGiven, extractEventsFromThen, extractEventsFromWhen } from './events';
+import { extractFieldsFromMessage } from './fields';
+import { extractProjectionIdField, extractProjectionSingleton } from './projection';
+import { extractStatesFromData, extractStatesFromTarget } from './states';
+import { extractGwtSpecsFromSlice, type GwtConditionWithRule } from './step-converter';
+import type { CommandExample, EventExample } from './step-types';
+
+const debug = createDebug('auto:server-generator-nestjs:extract:messages');
+const debugCommand = createDebug('auto:server-generator-nestjs:extract:messages:command');
+const debugQuery = createDebug('auto:server-generator-nestjs:extract:messages:query');
+const debugReact = createDebug('auto:server-generator-nestjs:extract:messages:react');
+const debugDedupe = createDebug('auto:server-generator-nestjs:extract:messages:dedupe');
+
+export interface ExtractedMessages {
+  commands: Message[];
+  events: Message[];
+  states: Message[];
+  commandSchemasByName: Record<string, Message>;
+  projectionIdField?: string;
+  projectionSingleton?: boolean;
+}
+
+export interface ReactGwtSpec {
+  when?: EventExample[];
+  then: CommandExample[];
+}
+
+const EMPTY_EXTRACTED_MESSAGES: ExtractedMessages = {
+  commands: [],
+  events: [],
+  states: [],
+  commandSchemasByName: {},
+};
+
+function deduplicateMessages<T extends Message>(messages: T[]): T[] {
+  debugDedupe('Deduplicating %d messages', messages.length);
+  const uniqueMap = new Map<string, T>();
+  for (const message of messages) {
+    if (!uniqueMap.has(message.type)) {
+      uniqueMap.set(message.type, message);
+      debugDedupe('  Added unique message: %s', message.type);
+    } else {
+      debugDedupe('  Skipped duplicate message: %s', message.type);
+    }
+  }
+  const result = Array.from(uniqueMap.values());
+  debugDedupe('Result: %d unique messages from %d total', result.length, messages.length);
+  return result;
+}
+
+function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+  debugCommand('Extracting messages for command slice: %s', slice.name);
+
+  if (slice.type !== 'command') {
+    debugCommand('  Slice type is not command, returning empty');
+    return EMPTY_EXTRACTED_MESSAGES;
+  }
+
+  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  debugCommand('  Found %d GWT specs', gwtSpecs.length);
+
+  const { commands, commandSchemasByName } = extractCommandsFromGwt(gwtSpecs, allMessages);
+  debugCommand('  Extracted %d commands', commands.length);
+  debugCommand('  Command schemas: %o', Object.keys(commandSchemasByName));
+
+  const events: Message[] = gwtSpecs.flatMap((gwt: GwtConditionWithRule): Message[] => {
+    const givenEventsOnly = gwt.given?.filter((item): item is EventExample => 'eventRef' in item);
+    const givenEvents = extractEventsFromGiven(givenEventsOnly, allMessages, slice.name);
+
+    const thenEventsOnly = gwt.then.filter((item): item is EventExample => 'eventRef' in item);
+    const thenEvents = extractEventsFromThen(thenEventsOnly, allMessages, slice.name);
+    debugCommand('    GWT: given=%d events, then=%d events', givenEvents.length, thenEvents.length);
+    return [...givenEvents, ...thenEvents];
+  });
+  debugCommand('  Total events extracted: %d', events.length);
+
+  const result = {
+    commands,
+    events: deduplicateMessages(events),
+    states: [],
+    commandSchemasByName,
+  };
+
+  debugCommand('  Final result: %d commands, %d events', result.commands.length, result.events.length);
+  return result;
+}
+
+function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+  debugQuery('Extracting messages for query slice: %s', slice.name);
+
+  if (slice.type !== 'query') {
+    debugQuery('  Slice type is not query, returning empty');
+    return EMPTY_EXTRACTED_MESSAGES;
+  }
+
+  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  debugQuery('  Found %d GWT specs', gwtSpecs.length);
+
+  const projectionIdField = extractProjectionIdField(slice);
+  debugQuery('  Projection ID field: %s', projectionIdField ?? 'none');
+
+  const projectionSingleton = extractProjectionSingleton(slice);
+  debugQuery('  Projection singleton: %s', projectionSingleton);
+
+  const events: Message[] = gwtSpecs.flatMap((gwt: GwtConditionWithRule) => {
+    const eventsFromGiven = Array.isArray(gwt.given)
+      ? gwt.given.filter((item): item is EventExample => 'eventRef' in item)
+      : [];
+    let eventsFromWhen: EventExample[] = [];
+    if (Array.isArray(gwt.when)) {
+      eventsFromWhen = gwt.when.filter((item): item is EventExample => 'eventRef' in item);
+    } else if (gwt.when != null && typeof gwt.when === 'object' && 'eventRef' in gwt.when) {
+      const whenItem = gwt.when as EventExample;
+      if (whenItem.eventRef && whenItem.eventRef.trim() !== '') {
+        eventsFromWhen = [whenItem];
+      }
+    }
+    const givenEvents = extractEventsFromGiven(eventsFromGiven, allMessages);
+    const whenEvents = eventsFromWhen
+      .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;
+
+        return {
+          type: eventExample.eventRef,
+          fields,
+          source: 'when' as const,
+          sourceFlowName: metadata?.sourceFlowName,
+          sourceSliceName: metadata?.sourceSliceName,
+        } as Message;
+      })
+      .filter((event): event is Message => event.type !== undefined);
+
+    return [...givenEvents, ...whenEvents];
+  });
+  debugQuery('  Extracted %d events total', events.length);
+
+  const states: Message[] = extractStatesFromTarget(slice, allMessages);
+  debugQuery('  Extracted %d states from target', states.length);
+
+  const result = {
+    commands: [],
+    events: deduplicateMessages(events),
+    states,
+    commandSchemasByName: {},
+    projectionIdField,
+    projectionSingleton,
+  };
+
+  debugQuery('  Final result: %d events, %d states', result.events.length, result.states.length);
+  return result;
+}
+
+function extractMessagesForReact(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+  debugReact('Extracting messages for react slice: %s', slice.name);
+
+  if (slice.type !== 'react') {
+    debugReact('  Slice type is not react, returning empty');
+    return EMPTY_EXTRACTED_MESSAGES;
+  }
+
+  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  debugReact('  Found %d GWT specs', gwtSpecs.length);
+
+  const reactGwtSpecs: ReactGwtSpec[] = gwtSpecs.map((gwt) => ({
+    when: Array.isArray(gwt.when) ? gwt.when : undefined,
+    then: gwt.then.filter((t): t is CommandExample => 'commandRef' in t),
+  }));
+
+  const events = extractEventsFromWhen(reactGwtSpecs, allMessages);
+  debugReact('  Extracted %d events from when', events.length);
+
+  const { commands, commandSchemasByName } = extractCommandsFromThen(gwtSpecs, allMessages);
+  debugReact('  Extracted %d commands from then', commands.length);
+  debugReact('  Command schemas: %o', Object.keys(commandSchemasByName));
+
+  const states = extractStatesFromData(slice, allMessages);
+  debugReact('  Extracted %d states from data', states.length);
+
+  const result = {
+    commands,
+    events: deduplicateMessages(events),
+    states,
+    commandSchemasByName,
+  };
+
+  debugReact(
+    '  Final result: %d commands, %d events, %d states',
+    result.commands.length,
+    result.events.length,
+    result.states.length,
+  );
+  return result;
+}
+
+export function extractMessagesFromSpecs(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+  debug('Extracting messages from slice: %s (type: %s)', slice.name, slice.type);
+  debug('  Total message definitions available: %d', allMessages.length);
+
+  let result: ExtractedMessages;
+
+  switch (slice.type) {
+    case 'command':
+      result = extractMessagesForCommand(slice, allMessages);
+      break;
+    case 'query':
+      result = extractMessagesForQuery(slice, allMessages);
+      break;
+    case 'react':
+      result = extractMessagesForReact(slice, allMessages);
+      break;
+    default: {
+      const unknownSlice = slice as Slice;
+      debug('  Unknown slice type: %s, returning empty', unknownSlice.type);
+      result = EMPTY_EXTRACTED_MESSAGES;
+    }
+  }
+
+  debug(
+    '  Extraction complete: %d commands, %d events, %d states',
+    result.commands.length,
+    result.events.length,
+    result.states.length,
+  );
+
+  return result;
+}