@auto-engineer/server-generator-apollo-emmett 0.1.1

package/src/codegen/extract/gwt.ts

@@ -0,0 +1,75 @@
+import { Slice } from '@auto-engineer/flow';
+import { GwtCondition } from '../types';
+
+export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtCondition & { failingFields?: string[] })[]> {
+  if (slice.type !== 'command') {
+    return {};
+  }
+
+  const gwtSpecs = slice.server?.gwt ?? [];
+  const mapping: Record<string, GwtCondition[]> = {};
+
+  for (const gwt of gwtSpecs) {
+    const command = gwt.when?.commandRef;
+    if (command) {
+      mapping[command] = mapping[command] ?? [];
+      mapping[command].push({
+        given: gwt.given,
+        when: gwt.when,
+        then: gwt.then,
+      });
+    }
+  }
+
+  const enhancedMapping: Record<string, (GwtCondition & { failingFields?: string[] })[]> = {};
+
+  for (const command in mapping) {
+    const merged = mergeGwtConditions(mapping[command]);
+    const successfulData = findSuccessfulExampleData(merged);
+
+    enhancedMapping[command] = merged.map((gwt) => ({
+      ...gwt,
+      failingFields: findFailingFields(gwt, successfulData),
+    }));
+  }
+
+  return enhancedMapping;
+}
+
+function mergeGwtConditions(gwts: GwtCondition[]): GwtCondition[] {
+  const map = new Map<string, GwtCondition[]>();
+
+  for (const gwt of gwts) {
+    const key = JSON.stringify(gwt.when.exampleData);
+    const existing = map.get(key) ?? [];
+    map.set(key, [...existing, gwt]);
+  }
+
+  return Array.from(map.values()).map((conditions) => {
+    const first = conditions[0];
+    const combinedThen = conditions.flatMap((g) => g.then);
+    return {
+      given: conditions.flatMap((g) => g.given ?? []),
+      when: first.when,
+      then: combinedThen,
+    };
+  });
+}
+
+function findSuccessfulExampleData(gwts: GwtCondition[]): Record<string, unknown> {
+  const successful = gwts.find((gwt) => gwt.then.some((t) => typeof t === 'object' && t !== null && 'eventRef' in t));
+  return successful?.when.exampleData ?? {};
+}
+
+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 [];
+
+  return Object.entries(gwt.when.exampleData)
+    .filter(([key, val]) => {
+      const successVal = successfulData[key];
+      return val === '' && successVal !== '' && successVal !== undefined;
+    })
+    .map(([key]) => key);
+}

package/src/codegen/extract/index.ts

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

package/src/codegen/extract/messages.ts

@@ -0,0 +1,196 @@
+import { extractCommandsFromGwt, extractCommandsFromThen } from './commands';
+import { CommandExample, ErrorExample, EventExample, Slice, StateExample } from '@auto-engineer/flow';
+import { Message, MessageDefinition } from '../types';
+import { extractEventsFromGiven, extractEventsFromThen, extractEventsFromWhen } from './events';
+import { extractProjectionIdField } from './projection';
+import { extractStatesFromData, extractStatesFromTarget } from './states';
+import createDebug from 'debug';
+
+const debug = createDebug('emmett:extract:messages');
+const debugCommand = createDebug('emmett:extract:messages:command');
+const debugQuery = createDebug('emmett:extract:messages:query');
+const debugReact = createDebug('emmett:extract:messages:react');
+const debugDedupe = createDebug('emmett:extract:messages:dedupe');
+
+export interface ExtractedMessages {
+  commands: Message[];
+  events: Message[];
+  states: Message[];
+  commandSchemasByName: Record<string, Message>;
+  projectionIdField?: string;
+}
+
+export interface ReactGwtSpec {
+  when: EventExample[];
+  then: CommandExample[];
+}
+
+export interface CommandGwtSpec {
+  given?: EventExample[];
+  when: CommandExample;
+  then: Array<EventExample | ErrorExample>;
+}
+
+export interface QueryGwtSpec {
+  given: EventExample[];
+  then: StateExample[];
+}
+
+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 = slice.server?.gwt ?? [];
+  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): Message[] => {
+    const givenEvents = extractEventsFromGiven(gwt.given, allMessages);
+    const thenEvents = extractEventsFromThen(gwt.then, allMessages);
+    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 = slice.server?.gwt ?? [];
+  debugQuery('  Found %d GWT specs', gwtSpecs.length);
+
+  const projectionIdField = extractProjectionIdField(slice);
+  debugQuery('  Projection ID field: %s', projectionIdField ?? 'none');
+
+  const events: Message[] = gwtSpecs.flatMap((gwt) => extractEventsFromGiven(gwt.given, allMessages));
+  debugQuery('  Extracted %d events from given', 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,
+  };
+
+  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 = slice.server?.gwt ?? [];
+  debugReact('  Found %d GWT specs', gwtSpecs.length);
+
+  const events = extractEventsFromWhen(gwtSpecs, 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;
+}

package/src/codegen/extract/projection.ts

@@ -0,0 +1,47 @@
+import { Slice } from '@auto-engineer/flow';
+
+interface ProjectionOrigin {
+  type: 'projection';
+  idField?: string;
+  name?: string;
+}
+
+interface HasOrigin {
+  origin: unknown;
+}
+
+function hasOrigin(dataSource: unknown): dataSource is HasOrigin {
+  return typeof dataSource === 'object' && dataSource !== null && 'origin' in dataSource;
+}
+
+function isProjectionOrigin(origin: unknown): origin is ProjectionOrigin {
+  if (typeof origin !== 'object' || origin === null) {
+    return false;
+  }
+
+  const obj = origin as Record<string, unknown>;
+  return obj.type === 'projection';
+}
+
+function extractProjectionField<K extends keyof ProjectionOrigin>(slice: Slice, fieldName: K): string | undefined {
+  const dataSource = slice.server?.data?.[0];
+  if (!hasOrigin(dataSource)) return undefined;
+
+  const origin = dataSource.origin;
+  if (isProjectionOrigin(origin)) {
+    const value = origin[fieldName];
+    if (typeof value === 'string') {
+      return value;
+    }
+  }
+
+  return undefined;
+}
+
+export function extractProjectionIdField(slice: Slice): string | undefined {
+  return extractProjectionField(slice, 'idField');
+}
+
+export function extractProjectionName(slice: Slice): string | undefined {
+  return extractProjectionField(slice, 'name');
+}

package/src/codegen/extract/query.ts

@@ -0,0 +1,18 @@
+import { EventExample, Slice } from '@auto-engineer/flow';
+
+interface QueryGwtCondition {
+  given: EventExample[];
+  then: Array<{ stateRef: string; exampleData: Record<string, unknown> }>;
+}
+
+export function buildQueryGwtMapping(slice: Slice): QueryGwtCondition[] {
+  if (slice.type !== 'query') {
+    return [];
+  }
+
+  const gwtSpecs = slice.server?.gwt ?? [];
+  return gwtSpecs.map((gwt) => ({
+    given: gwt.given,
+    then: gwt.then,
+  }));
+}

package/src/codegen/extract/states.ts

@@ -0,0 +1,45 @@
+import { Slice } from '@auto-engineer/flow';
+import { Message, MessageDefinition } from '../types';
+import { extractFieldsFromMessage } from './fields';
+
+function createStateMessage(stateName: string, allMessages: MessageDefinition[]): Message {
+  return {
+    type: stateName,
+    fields: extractFieldsFromMessage(stateName, 'state', allMessages),
+  };
+}
+
+export function extractStatesFromTarget(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+  const targets = slice.server?.data?.map((d) => d.target?.name).filter(Boolean) as string[];
+  const uniqueTargets = Array.from(new Set(targets));
+
+  return uniqueTargets.map((name) => createStateMessage(name, allMessages));
+}
+
+export function extractStatesFromData(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+  if (!slice.server?.data) {
+    return [];
+  }
+
+  const states: Message[] = [];
+  const seenStates = new Set<string>();
+
+  for (const dataItem of slice.server.data) {
+    if (!('origin' in dataItem) || !dataItem.target?.name) {
+      continue;
+    }
+
+    const stateName = dataItem.target.name;
+    if (seenStates.has(stateName)) {
+      continue;
+    }
+
+    const fields = extractFieldsFromMessage(stateName, 'state', allMessages);
+    if (fields.length > 0) {
+      states.push(createStateMessage(stateName, allMessages));
+      seenStates.add(stateName);
+    }
+  }
+
+  return states;
+}

package/src/codegen/scaffoldFromSchema.integration.specs.ts

@@ -0,0 +1,71 @@
+import { describe, it } from 'vitest';
+import { execa } from 'execa';
+import * as path from 'path';
+import { mkdir, readdir, rm } from 'fs/promises';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+async function findTestFiles(dir: string): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const testFiles: string[] = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      testFiles.push(...(await findTestFiles(fullPath)));
+    } else if (entry.name.endsWith('.specs.ts')) {
+      testFiles.push(fullPath);
+    }
+  }
+  return testFiles;
+}
+
+describe.skip('generateServer integration test', { timeout: 20000 }, () => {
+  it('should scaffold a working server with valid TS and passing tests', async () => {
+    const tmpDir = path.resolve(__dirname, '../../.tmp/server-test-output');
+    const specPath = path.resolve(__dirname, './test-data/specVariant1.json');
+
+    await rm(tmpDir, { recursive: true, force: true });
+    await mkdir(tmpDir, { recursive: true });
+
+    await execa('pnpm', ['generate:server', specPath, tmpDir], {
+      cwd: path.resolve(__dirname, '../../'),
+    });
+
+    const serverDir = path.join(tmpDir, 'server');
+    const tsconfigPath = path.join(serverDir, 'tsconfig.json');
+    const testFiles = await findTestFiles(serverDir);
+
+    if (testFiles.length === 0) {
+      throw new Error(`❌ No test files found in: ${serverDir}`);
+    }
+
+    const typecheck = await execa('npx', ['tsc', '--noEmit', '-p', tsconfigPath], {
+      cwd: serverDir,
+      reject: false,
+    });
+    if (typecheck.exitCode !== 0) {
+      console.error('❌ TypeScript errors:\n', typecheck.stderr || typecheck.stdout);
+      throw new Error('❌ TypeScript type-check failed');
+    }
+
+    const testResult = await execa('npx', ['vitest', 'run', '--dir', serverDir], {
+      reject: false,
+    });
+    const output = testResult.stdout + '\n' + testResult.stderr;
+
+    const notYetImplementedMatches = output.match(/Not yet implemented: \w+/g) ?? [];
+    const otherFailures = output.includes('FAIL') && !output.includes('Not yet implemented') ? output : '';
+
+    if (testResult.exitCode !== 0 && otherFailures) {
+      throw new Error(`❌ Unexpected test failures:\n${otherFailures}`);
+    }
+
+    if (notYetImplementedMatches.length > 0) {
+      console.warn(`ℹ️ Ignored test files awaiting implementation:\n${notYetImplementedMatches.join('\n')}`);
+    }
+
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+});