@auto-engineer/server-generator-apollo-emmett 0.2.0 → 0.8.2

package/src/codegen/extract/commands.ts

@@ -1,7 +1,6 @@
 import { CommandExample, EventExample } from '@auto-engineer/flow';
 import { Message, MessageDefinition } from '../types';
 import { extractFieldsFromMessage } from './fields';
-import { ReactGwtSpec } from './messages';
 
 function createCommandMessage(
   commandRef: string,
@@ -23,9 +22,9 @@ function createCommandMessage(
 
 export function extractCommandsFromGwt(
   gwtSpecs: Array<{
-    given?: EventExample[];
-    when: CommandExample;
-    then: Array<EventExample | { errorType: string; message?: string }>;
+    given?: Array<EventExample | unknown>;
+    when: CommandExample | EventExample | unknown[];
+    then: Array<EventExample | unknown | { errorType: string; message?: string }>;
   }>,
   allMessages: MessageDefinition[],
 ): { commands: Message[]; commandSchemasByName: Record<string, Message> } {
@@ -34,8 +33,15 @@ export function extractCommandsFromGwt(
   const commands: Message[] = gwtSpecs
     .map((gwt): Message | undefined => {
       const cmd = gwt.when;
-      if (!cmd.commandRef) return undefined;
-
+      if (
+        Array.isArray(cmd) ||
+        typeof cmd !== 'object' ||
+        cmd === null ||
+        !('commandRef' in cmd) ||
+        typeof cmd.commandRef !== 'string' ||
+        !cmd.commandRef
+      )
+        return undefined;
       const command = createCommandMessage(cmd.commandRef, allMessages, 'when');
       if (command) {
         commandSchemasByName[cmd.commandRef] = command;
@@ -47,8 +53,42 @@ export function extractCommandsFromGwt(
   return { commands, commandSchemasByName };
 }
 
+function isValidCommandExample(commandExample: unknown): commandExample is { commandRef: string } {
+  return (
+    typeof commandExample === 'object' &&
+    commandExample !== null &&
+    'commandRef' in commandExample &&
+    typeof commandExample.commandRef === 'string' &&
+    !!commandExample.commandRef
+  );
+}
+
+function processCommandExample(
+  commandExample: unknown,
+  commands: Message[],
+  commandSchemasByName: Record<string, Message>,
+  allMessages: MessageDefinition[],
+): void {
+  if (!isValidCommandExample(commandExample)) {
+    return;
+  }
+
+  const commandRef = commandExample.commandRef;
+  if (!(commandRef in commandSchemasByName)) {
+    const command = createCommandMessage(commandRef, allMessages, 'then');
+    if (command) {
+      commands.push(command);
+      commandSchemasByName[commandRef] = command;
+    }
+  }
+}
+
 export function extractCommandsFromThen(
-  gwtSpecs: ReactGwtSpec[],
+  gwtSpecs: Array<{
+    given?: Array<EventExample | unknown>;
+    when: CommandExample | EventExample | unknown[];
+    then: Array<EventExample | unknown | { errorType: string; message?: string }>;
+  }>,
   allMessages: MessageDefinition[],
 ): { commands: Message[]; commandSchemasByName: Record<string, Message> } {
   const commands: Message[] = [];
@@ -60,18 +100,7 @@ export function extractCommandsFromThen(
     }
 
     for (const commandExample of gwt.then) {
-      if (!commandExample.commandRef) {
-        continue;
-      }
-
-      const commandRef = commandExample.commandRef;
-      if (!(commandRef in commandSchemasByName)) {
-        const command = createCommandMessage(commandRef, allMessages, 'then');
-        if (command) {
-          commands.push(command);
-          commandSchemasByName[commandRef] = command;
-        }
-      }
+      processCommandExample(commandExample, commands, commandSchemasByName, allMessages);
     }
   }
 

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

@@ -1,45 +1,82 @@
-import { CommandExample, DataSink, Slice } from '@auto-engineer/flow';
-import { CommandGwtSpec, QueryGwtSpec, ReactGwtSpec } from './messages';
+import { CommandExample, DataSink, Slice, type Example } from '@auto-engineer/flow';
 
 function resolveStreamId(stream: string, exampleData: Record<string, unknown>): string {
   return stream.replace(/\$\{([^}]+)\}/g, (_, key: string) => String(exampleData?.[key] ?? 'unknown'));
 }
 
-// eslint-disable-next-line complexity
-export function getStreamFromSink(slice: Slice): { streamPattern?: string; streamId?: string } {
-  let streamPattern: string | undefined;
-  let streamId: string | undefined;
-  const gwtSpecs =
-    slice.type === 'command'
-      ? (slice.server?.gwt as CommandGwtSpec[])
-      : slice.type === 'query'
-        ? (slice.server?.gwt as QueryGwtSpec[])
-        : slice.type === 'react'
-          ? (slice.server?.gwt as ReactGwtSpec[])
-          : [];
-  let exampleData: Record<string, unknown> = {};
+function extractExampleDataFromReact(firstSpec: { when: unknown }): Record<string, unknown> {
+  if (Array.isArray(firstSpec.when)) {
+    const firstWhen = firstSpec.when[0] as { exampleData?: Record<string, unknown> } | undefined;
+    return typeof firstWhen?.exampleData === 'object' && firstWhen.exampleData !== null ? firstWhen.exampleData : {};
+  }
+  return {};
+}
+
+function extractExampleDataFromCommand(firstSpec: { then: unknown }): Record<string, unknown> {
+  const then = firstSpec.then as (CommandExample | { errorType: string })[];
+  const firstExample = then.find((t): t is CommandExample => 'exampleData' in t);
+  return typeof firstExample?.exampleData === 'object' && firstExample.exampleData !== null
+    ? firstExample.exampleData
+    : {};
+}
+
+function extractExampleDataFromQuery(firstSpec: { when: unknown }): Record<string, unknown> {
+  if (Array.isArray(firstSpec.when)) {
+    const firstWhen = firstSpec.when[0] as { exampleData?: Record<string, unknown> } | undefined;
+    return typeof firstWhen?.exampleData === 'object' && firstWhen.exampleData !== null ? firstWhen.exampleData : {};
+  }
+  return {};
+}
+
+function extractExampleDataFromSpecs(
+  slice: Slice,
+  gwtSpecs: Array<{ given?: unknown; when: unknown; then: unknown }>,
+): Record<string, unknown> {
+  if (gwtSpecs.length === 0) {
+    return {};
+  }
+
+  const firstSpec = gwtSpecs[0];
   switch (slice.type) {
     case 'react':
-      exampleData = (gwtSpecs as ReactGwtSpec[])[0].when?.[0]?.exampleData ?? {};
-      break;
-    case 'command': {
-      const then = (gwtSpecs as CommandGwtSpec[])[0]?.then as (CommandExample | { errorType: string })[];
-      const firstExample = then.find((t): t is CommandExample => 'exampleData' in t);
-      exampleData = firstExample?.exampleData ?? {};
-      break;
-    }
+      return extractExampleDataFromReact(firstSpec);
+    case 'command':
+      return extractExampleDataFromCommand(firstSpec);
     case 'query':
-      exampleData = (gwtSpecs as QueryGwtSpec[])[0]?.given?.[0]?.exampleData ?? {};
-      break;
+      return extractExampleDataFromQuery(firstSpec);
+    default:
+      return {};
   }
-  const sink = (slice.server?.data ?? []).find((item) => (item as DataSink)?.destination?.type === 'stream') as
+}
+
+function findStreamSink(slice: Slice): DataSink | undefined {
+  return (slice.server?.data ?? []).find((item) => (item as DataSink)?.destination?.type === 'stream') as
     | DataSink
     | undefined;
+}
+
+export function getStreamFromSink(slice: Slice): { streamPattern?: string; streamId?: string } {
+  const specs = slice.server?.specs;
+  const rules = specs?.rules;
+  const gwtSpecs =
+    Array.isArray(rules) && rules.length > 0
+      ? rules.flatMap((rule) =>
+          rule.examples.map((example: Example) => ({
+            given: example.given,
+            when: example.when,
+            then: example.then,
+          })),
+        )
+      : [];
+
+  const exampleData = extractExampleDataFromSpecs(slice, gwtSpecs);
+  const sink = findStreamSink(slice);
+
   if (sink && sink.destination.type === 'stream' && 'pattern' in sink.destination) {
-    streamPattern = sink.destination.pattern;
-    if (streamPattern != null) {
-      streamId = resolveStreamId(streamPattern, exampleData);
-    }
+    const streamPattern = sink.destination.pattern;
+    const streamId = streamPattern ? resolveStreamId(streamPattern, exampleData) : undefined;
+    return { streamPattern, streamId };
   }
-  return { streamPattern, streamId };
+
+  return {};
 }

package/src/codegen/extract/gwt.ts

@@ -1,4 +1,4 @@
-import { Slice } from '@auto-engineer/flow';
+import { Slice, CommandExample, EventExample, StateExample } from '@auto-engineer/flow';
 import { GwtCondition } from '../types';
 
 export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtCondition & { failingFields?: string[] })[]> {
@@ -6,21 +6,50 @@ export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtConditi
     return {};
   }
 
-  const gwtSpecs = slice.server?.gwt ?? [];
+  const gwtSpecs = extractGwtSpecs(slice);
+  const mapping = buildCommandMapping(gwtSpecs);
+  return enhanceMapping(mapping);
+}
+
+function extractGwtSpecs(slice: Slice) {
+  const specs = slice.server?.specs;
+  const rules = specs?.rules;
+  return Array.isArray(rules) && rules.length > 0
+    ? rules.flatMap((rule) =>
+        rule.examples.map((example) => ({
+          given: example.given,
+          when: example.when,
+          then: example.then,
+        })),
+      )
+    : [];
+}
+
+function buildCommandMapping(gwtSpecs: Array<{ given: unknown; when: unknown; then: unknown }>) {
   const mapping: Record<string, GwtCondition[]> = {};
 
   for (const gwt of gwtSpecs) {
-    const command = gwt.when?.commandRef;
-    if (command) {
+    let command: string | undefined;
+    if (Array.isArray(gwt.when)) {
+      continue;
+    } else {
+      const whenCmd = gwt.when as { commandRef?: string } | undefined;
+      command = whenCmd?.commandRef;
+    }
+    if (typeof command === 'string' && command.length > 0) {
       mapping[command] = mapping[command] ?? [];
       mapping[command].push({
-        given: gwt.given,
-        when: gwt.when,
-        then: gwt.then,
+        given: gwt.given as Array<EventExample | StateExample> | undefined,
+        when: gwt.when as CommandExample | EventExample[],
+        then: gwt.then as Array<EventExample | StateExample | CommandExample | { errorType: string; message?: string }>,
       });
     }
   }
 
+  return mapping;
+}
+
+function enhanceMapping(mapping: Record<string, GwtCondition[]>) {
   const enhancedMapping: Record<string, (GwtCondition & { failingFields?: string[] })[]> = {};
 
   for (const command in mapping) {
@@ -40,7 +69,9 @@ function mergeGwtConditions(gwts: GwtCondition[]): GwtCondition[] {
   const map = new Map<string, GwtCondition[]>();
 
   for (const gwt of gwts) {
-    const key = JSON.stringify(gwt.when.exampleData);
+    // Handle both single command and array of events in when clause
+    const whenData = Array.isArray(gwt.when) ? gwt.when[0]?.exampleData : gwt.when.exampleData;
+    const key = JSON.stringify(whenData ?? {});
     const existing = map.get(key) ?? [];
     map.set(key, [...existing, gwt]);
   }
@@ -58,7 +89,8 @@ function mergeGwtConditions(gwts: GwtCondition[]): GwtCondition[] {
 
 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 ?? {};
+  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[] {
@@ -66,7 +98,10 @@ function findFailingFields(gwt: GwtCondition, successfulData: Record<string, unk
 
   if (!hasError) return [];
 
-  return Object.entries(gwt.when.exampleData)
+  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;

package/src/codegen/extract/messages.ts

@@ -67,7 +67,18 @@ function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[
     return EMPTY_EXTRACTED_MESSAGES;
   }
 
-  const gwtSpecs = slice.server?.gwt ?? [];
+  const specs = slice.server?.specs;
+  const rules = specs?.rules;
+  const gwtSpecs =
+    Array.isArray(rules) && rules.length > 0
+      ? rules.flatMap((rule) =>
+          rule.examples.map((example) => ({
+            given: example.given,
+            when: example.when,
+            then: example.then,
+          })),
+        )
+      : [];
   debugCommand('  Found %d GWT specs', gwtSpecs.length);
 
   const { commands, commandSchemasByName } = extractCommandsFromGwt(gwtSpecs, allMessages);
@@ -75,8 +86,11 @@ function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[
   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);
+    const givenEventsOnly = gwt.given?.filter((item): item is EventExample => 'eventRef' in item);
+    const givenEvents = extractEventsFromGiven(givenEventsOnly, allMessages);
+
+    const thenEventsOnly = gwt.then.filter((item): item is EventExample => 'eventRef' in item);
+    const thenEvents = extractEventsFromThen(thenEventsOnly, allMessages);
     debugCommand('    GWT: given=%d events, then=%d events', givenEvents.length, thenEvents.length);
     return [...givenEvents, ...thenEvents];
   });
@@ -101,13 +115,29 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
     return EMPTY_EXTRACTED_MESSAGES;
   }
 
-  const gwtSpecs = slice.server?.gwt ?? [];
+  const specs = slice.server?.specs;
+  const rules = specs?.rules;
+  const gwtSpecs =
+    Array.isArray(rules) && rules.length > 0
+      ? rules.flatMap((rule) =>
+          rule.examples.map((example) => ({
+            given: example.given,
+            when: example.when,
+            then: example.then,
+          })),
+        )
+      : [];
   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));
+  const events: Message[] = gwtSpecs.flatMap((gwt) => {
+    const eventsFromWhen = Array.isArray(gwt.when)
+      ? gwt.when.filter((item): item is EventExample => 'eventRef' in item)
+      : [];
+    return extractEventsFromGiven(eventsFromWhen, allMessages);
+  });
   debugQuery('  Extracted %d events from given', events.length);
 
   const states: Message[] = extractStatesFromTarget(slice, allMessages);
@@ -133,10 +163,22 @@ function extractMessagesForReact(slice: Slice, allMessages: MessageDefinition[])
     return EMPTY_EXTRACTED_MESSAGES;
   }
 
-  const gwtSpecs = slice.server?.gwt ?? [];
+  const specs = slice.server?.specs;
+  // Extract all examples from specs/rules structure
+  const rules = specs?.rules;
+  const gwtSpecs =
+    Array.isArray(rules) && rules.length > 0
+      ? rules.flatMap((rule) =>
+          rule.examples.map((example) => ({
+            given: example.given,
+            when: example.when,
+            then: example.then,
+          })),
+        )
+      : [];
   debugReact('  Found %d GWT specs', gwtSpecs.length);
 
-  const events = extractEventsFromWhen(gwtSpecs, allMessages);
+  const events = extractEventsFromWhen(gwtSpecs as ReactGwtSpec[], allMessages);
   debugReact('  Extracted %d events from when', events.length);
 
   const { commands, commandSchemasByName } = extractCommandsFromThen(gwtSpecs, allMessages);

package/src/codegen/extract/query.ts

@@ -10,9 +10,22 @@ export function buildQueryGwtMapping(slice: Slice): QueryGwtCondition[] {
     return [];
   }
 
-  const gwtSpecs = slice.server?.gwt ?? [];
+  const specs = slice.server?.specs;
+  const rules = specs?.rules;
+  const gwtSpecs =
+    Array.isArray(rules) && rules.length > 0
+      ? rules.flatMap((rule) =>
+          rule.examples.map((example) => ({
+            given: Array.isArray(example.when) ? example.when : [], // For query slices, when contains the given events
+            then: example.then,
+          })),
+        )
+      : [];
+
   return gwtSpecs.map((gwt) => ({
     given: gwt.given,
-    then: gwt.then,
+    then: gwt.then.filter(
+      (item): item is { stateRef: string; exampleData: Record<string, unknown> } => 'stateRef' in item,
+    ),
   }));
 }

package/src/codegen/scaffoldFromSchema.ts

@@ -272,8 +272,19 @@ function findEventSource(flows: Flow[], eventType: string): { flowName: string;
     for (const slice of flow.slices) {
       if (!['command', 'react'].includes(slice.type)) continue;
 
-      const gwt = slice.server?.gwt ?? [];
-      if (gwt.some((g) => g.then.some((t) => 'eventRef' in t && t.eventRef === eventType))) {
+      const specs = slice.server?.specs;
+      const rules = specs?.rules;
+      const gwtSpecs =
+        Array.isArray(rules) && rules.length > 0
+          ? rules.flatMap((rule) =>
+              rule.examples.map((example) => ({
+                given: example.given,
+                when: example.when,
+                then: example.then,
+              })),
+            )
+          : [];
+      if (gwtSpecs.some((g) => g.then.some((t) => 'eventRef' in t && t.eventRef === eventType))) {
         debugSlice('  Found event source in flow: %s, slice: %s', flow.name, slice.name);
         return { flowName: flow.name, sliceName: slice.name };
       }
@@ -304,8 +315,19 @@ function findCommandSource(flows: Flow[], commandType: string): { flowName: stri
     for (const slice of flow.slices) {
       if (slice.type !== 'command') continue;
 
-      const gwt = slice.server?.gwt ?? [];
-      if (gwt.some((g) => 'commandRef' in g.when && g.when.commandRef === commandType)) {
+      const specs = slice.server?.specs;
+      const rules = specs?.rules;
+      const gwtSpecs =
+        Array.isArray(rules) && rules.length > 0
+          ? rules.flatMap((rule) =>
+              rule.examples.map((example) => ({
+                given: example.given,
+                when: example.when,
+                then: example.then,
+              })),
+            )
+          : [];
+      if (gwtSpecs.some((g) => !Array.isArray(g.when) && 'commandRef' in g.when && g.when.commandRef === commandType)) {
         debugSlice('  Found command source in flow: %s, slice: %s', flow.name, slice.name);
         return { flowName: flow.name, sliceName: slice.name };
       }
@@ -339,7 +361,7 @@ async function generateFilesForSlice(
   debugSlice('    Commands: %d', extracted.commands.length);
   debugSlice('    Events: %d', extracted.events.length);
   debugSlice('    States: %d', extracted.states.length);
-  console.log(
+  debugSlice(
     '💡 Events for slice',
     slice.name,
     extracted.events.map((e) => e.type),
@@ -416,7 +438,6 @@ export async function writeScaffoldFilePlans(plans: FilePlan[]) {
     await fs.writeFile(outputPath, contents, 'utf8');
     writtenCount++;
     debugPlan('    File written successfully (%d/%d)', writtenCount, plans.length);
-    console.log(`✅ Created: ${outputPath}`);
   }
 
   debugPlan('All %d files written successfully', writtenCount);

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

@@ -19,26 +19,35 @@ describe('commands.ts.ejs', () => {
               },
               server: {
                 description: 'test',
-                gwt: [
-                  {
-                    when: {
-                      commandRef: 'CreateListing',
-                      exampleData: {
-                        propertyId: 'listing_123',
-                        title: 'nice apartment',
-                        pricePerNight: 250,
-                        maxGuests: 4,
-                        amenities: ['wifi', 'kitchen', 'parking'],
-                        available: true,
-                        tags: ['sea view', 'balcony'],
-                        rating: 4.8,
-                        metadata: { petsAllowed: true },
-                        listedAt: '2024-01-15T10:00:00Z',
-                      },
+                specs: {
+                  name: 'Create listing command',
+                  rules: [
+                    {
+                      description: 'Should accept valid listing data',
+                      examples: [
+                        {
+                          description: 'User creates listing with valid data',
+                          when: {
+                            commandRef: 'CreateListing',
+                            exampleData: {
+                              propertyId: 'listing_123',
+                              title: 'nice apartment',
+                              pricePerNight: 250,
+                              maxGuests: 4,
+                              amenities: ['wifi', 'kitchen', 'parking'],
+                              available: true,
+                              tags: ['sea view', 'balcony'],
+                              rating: 4.8,
+                              metadata: { petsAllowed: true },
+                              listedAt: '2024-01-15T10:00:00Z',
+                            },
+                          },
+                          then: [],
+                        },
+                      ],
                     },
-                    then: [],
-                  },
-                ],
+                  ],
+                },
               },
             },
           ],