@auto-engineer/server-generator-apollo-emmett 1.45.3 → 1.46.0

package/ketchup-plan.md

@@ -1,7 +1,10 @@
-# Ketchup Plan: Skip react/register templates for react slices with empty examples
+# Ketchup Plan: Referenced message type fields fail GraphQL schema generation
 
 ## TODO
 
 ## DONE
 
-- [x] Burst 1: Skip react.ts.ejs and register.ts.ejs when react slice has no examples
+- [x] Burst 1: Add `resolveReferencedMessageTypes` helper + tests (a50d7d73)
+- [x] Burst 2: Wire into `prepareTemplateData` + fix `graphqlType()` + fix `isEnumType` regression (93edcc4a)
+- [x] Burst 3: Update query resolver template + test (e6a06086)
+- [x] Burst 4: Update mutation resolver template + test (75e3ed80)

package/package.json

@@ -32,8 +32,8 @@
     "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
     "zod": "^3.22.4",
-    "@auto-engineer/narrative": "1.45.3",
-    "@auto-engineer/message-bus": "1.45.3"
+    "@auto-engineer/narrative": "1.46.0",
+    "@auto-engineer/message-bus": "1.46.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.45.3"
+    "@auto-engineer/cli": "1.46.0"
   },
-  "version": "1.45.3",
+  "version": "1.46.0",
   "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/resolveReferencedMessageTypes.specs.ts

@@ -0,0 +1,235 @@
+import { describe, expect, it } from 'vitest';
+import { resolveReferencedMessageTypes } from './scaffoldFromSchema';
+import type { MessageDefinition } from './types';
+
+function buildMessagesByName(messages: MessageDefinition[]): Map<string, MessageDefinition> {
+  return new Map(messages.map((m) => [m.name, m]));
+}
+
+describe('resolveReferencedMessageTypes', () => {
+  it('resolves a direct message type reference', () => {
+    const messages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'Ingredient',
+        fields: [
+          { name: 'name', type: 'string' },
+          { name: 'quantity', type: 'number' },
+        ],
+      },
+    ];
+
+    const result = resolveReferencedMessageTypes([{ name: 'item', type: 'Ingredient' }], buildMessagesByName(messages));
+
+    expect(result).toEqual([
+      {
+        name: 'Ingredient',
+        fields: [
+          { name: 'name', type: 'string' },
+          { name: 'quantity', type: 'number' },
+        ],
+      },
+    ]);
+  });
+
+  it('resolves Array<Type> references', () => {
+    const messages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'Ingredient',
+        fields: [
+          { name: 'name', type: 'string' },
+          { name: 'amount', type: 'number' },
+        ],
+      },
+    ];
+
+    const result = resolveReferencedMessageTypes(
+      [{ name: 'ingredients', type: 'Array<Ingredient>' }],
+      buildMessagesByName(messages),
+    );
+
+    expect(result).toEqual([
+      {
+        name: 'Ingredient',
+        fields: [
+          { name: 'name', type: 'string' },
+          { name: 'amount', type: 'number' },
+        ],
+      },
+    ]);
+  });
+
+  it('resolves Type[] references', () => {
+    const messages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'Tag',
+        fields: [{ name: 'label', type: 'string' }],
+      },
+    ];
+
+    const result = resolveReferencedMessageTypes([{ name: 'tags', type: 'Tag[]' }], buildMessagesByName(messages));
+
+    expect(result).toEqual([
+      {
+        name: 'Tag',
+        fields: [{ name: 'label', type: 'string' }],
+      },
+    ]);
+  });
+
+  it('resolves nested references in depth-first order', () => {
+    const messages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'Supplier',
+        fields: [{ name: 'companyName', type: 'string' }],
+      },
+      {
+        type: 'state',
+        name: 'Ingredient',
+        fields: [
+          { name: 'name', type: 'string' },
+          { name: 'supplier', type: 'Supplier' },
+        ],
+      },
+    ];
+
+    const result = resolveReferencedMessageTypes(
+      [{ name: 'ingredients', type: 'Array<Ingredient>' }],
+      buildMessagesByName(messages),
+    );
+
+    expect(result).toEqual([
+      {
+        name: 'Supplier',
+        fields: [{ name: 'companyName', type: 'string' }],
+      },
+      {
+        name: 'Ingredient',
+        fields: [
+          { name: 'name', type: 'string' },
+          { name: 'supplier', type: 'Supplier' },
+        ],
+      },
+    ]);
+  });
+
+  it('handles circular references without infinite loop', () => {
+    const messages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'Node',
+        fields: [
+          { name: 'value', type: 'string' },
+          { name: 'children', type: 'Array<Node>' },
+        ],
+      },
+    ];
+
+    const result = resolveReferencedMessageTypes([{ name: 'root', type: 'Node' }], buildMessagesByName(messages));
+
+    expect(result).toEqual([
+      {
+        name: 'Node',
+        fields: [
+          { name: 'value', type: 'string' },
+          { name: 'children', type: 'Array<Node>' },
+        ],
+      },
+    ]);
+  });
+
+  it('does not include primitives as referenced types', () => {
+    const messages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'Item',
+        fields: [{ name: 'label', type: 'string' }],
+      },
+    ];
+
+    const result = resolveReferencedMessageTypes(
+      [
+        { name: 'name', type: 'string' },
+        { name: 'count', type: 'number' },
+        { name: 'active', type: 'boolean' },
+        { name: 'created', type: 'Date' },
+        { name: 'tags', type: 'Array<string>' },
+      ],
+      buildMessagesByName(messages),
+    );
+
+    expect(result).toEqual([]);
+  });
+
+  it('deduplicates types referenced by multiple fields', () => {
+    const messages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'Ingredient',
+        fields: [{ name: 'name', type: 'string' }],
+      },
+    ];
+
+    const result = resolveReferencedMessageTypes(
+      [
+        { name: 'required', type: 'Array<Ingredient>' },
+        { name: 'optional', type: 'Array<Ingredient>' },
+      ],
+      buildMessagesByName(messages),
+    );
+
+    expect(result).toEqual([
+      {
+        name: 'Ingredient',
+        fields: [{ name: 'name', type: 'string' }],
+      },
+    ]);
+  });
+
+  it('handles nullable type references', () => {
+    const messages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'Address',
+        fields: [{ name: 'street', type: 'string' }],
+      },
+    ];
+
+    const result = resolveReferencedMessageTypes(
+      [{ name: 'address', type: 'Address | null' }],
+      buildMessagesByName(messages),
+    );
+
+    expect(result).toEqual([
+      {
+        name: 'Address',
+        fields: [{ name: 'street', type: 'string' }],
+      },
+    ]);
+  });
+
+  it('handles fields using tsType instead of type', () => {
+    const messages: MessageDefinition[] = [
+      {
+        type: 'state',
+        name: 'LineItem',
+        fields: [{ name: 'sku', type: 'string' }],
+      },
+    ];
+
+    const result = resolveReferencedMessageTypes(
+      [{ name: 'items', tsType: 'Array<LineItem>' }],
+      buildMessagesByName(messages),
+    );
+
+    expect(result).toEqual([
+      {
+        name: 'LineItem',
+        fields: [{ name: 'sku', type: 'string' }],
+      },
+    ]);
+  });
+});

package/src/codegen/scaffoldFromSchema.ts

@@ -281,6 +281,12 @@ async function renderTemplate(
   const isInlineObject = isInlineObjectHelper;
   const isInlineObjectArray = isInlineObjectArrayHelper;
 
+  const messageNames = new Set(
+    (Array.isArray(data.messages) ? data.messages : [])
+      .filter((m): m is MessageDefinition => m != null && typeof m === 'object' && 'name' in m)
+      .map((m) => m.name),
+  );
+
   const convertPrimitiveType = (base: string): string => {
     if (base === 'ID') return 'ID';
     if (base === 'Int') return 'Int';
@@ -314,6 +320,7 @@ async function renderTemplate(
     if (base === 'object') return 'GraphQLJSON';
     if (isInlineObject(base)) return 'GraphQLJSON';
     if (isStringLiteralUnion(base)) return resolveEnumOrString(base);
+    if (messageNames.has(base)) return base;
 
     return convertPrimitiveType(base);
   };
@@ -338,12 +345,44 @@ async function renderTemplate(
 
   const isNullable = (rawTs: string): boolean => /\|\s*null\b/.test(rawTs);
 
-  const isEnumType = createIsEnumType(toTsFieldType);
+  const rawIsEnumType = createIsEnumType(toTsFieldType);
+  const isEnumType = (tsType: string): boolean => {
+    if (!rawIsEnumType(tsType)) return false;
+    const baseName = toTsFieldType(tsType)
+      .replace(/\s*\|\s*null\b/g, '')
+      .replace(/\[\]$/, '')
+      .trim();
+    return !messageNames.has(baseName);
+  };
   const fieldUsesDate = createFieldUsesDate(graphqlType);
   const fieldUsesJSON = createFieldUsesJSON(graphqlType);
   const fieldUsesFloat = createFieldUsesFloat(graphqlType);
   const collectEnumNames = createCollectEnumNames(isEnumType, toTsFieldType);
 
+  const isReferencedMessageType = (ts: string): boolean => {
+    const base = (ts ?? '')
+      .trim()
+      .replace(/\s*\|\s*null\b/g, '')
+      .trim();
+    return messageNames.has(base);
+  };
+  const isReferencedMessageTypeArray = (ts: string): boolean => {
+    const base = (ts ?? '')
+      .trim()
+      .replace(/\s*\|\s*null\b/g, '')
+      .trim();
+    const m = base.match(/^Array<(.+)>$/) ?? base.match(/^(.+)\[\]$/);
+    return m !== null && messageNames.has(m[1].trim());
+  };
+  const extractReferencedTypeName = (ts: string): string => {
+    const base = (ts ?? '')
+      .trim()
+      .replace(/\s*\|\s*null\b/g, '')
+      .trim();
+    const m = base.match(/^Array<(.+)>$/) ?? base.match(/^(.+)\[\]$/);
+    return m !== null ? m[1].trim() : base;
+  };
+
   const result = await template({
     ...data,
     pascalCase,
@@ -365,6 +404,11 @@ async function renderTemplate(
     fieldUsesJSON,
     fieldUsesFloat,
     collectEnumNames,
+    messageNames,
+    isReferencedMessageType,
+    isReferencedMessageTypeArray,
+    extractReferencedTypeName,
+    referencedTypes: data.referencedTypes,
   });
 
   debugTemplate('Template rendered, output size: %d bytes', result.length);
@@ -455,6 +499,34 @@ async function generateFileForTemplate(
   return plan;
 }
 
+export function resolveReferencedMessageTypes(
+  fields: Array<{ name: string; type?: string; tsType?: string }>,
+  messagesByName: Map<string, MessageDefinition>,
+  visited?: Set<string>,
+): Array<{ name: string; fields: MessageDefinition['fields'] }> {
+  const seen = visited ?? new Set<string>();
+  const results: Array<{ name: string; fields: MessageDefinition['fields'] }> = [];
+
+  for (const field of fields) {
+    const raw = field.type ?? field.tsType ?? 'string';
+    const stripped = raw.replace(/\s*\|\s*null\b/g, '').trim();
+    const arr1 = stripped.match(/^Array<(.+)>$/);
+    const arr2 = stripped.match(/^(.+)\[\]$/);
+    const base = arr1 ? arr1[1].trim() : arr2 ? arr2[1].trim() : stripped;
+
+    if (!messagesByName.has(base) || seen.has(base)) continue;
+    seen.add(base);
+
+    const msg = messagesByName.get(base)!;
+    const childFields = (msg.fields ?? []).map((f) => ({ name: f.name, type: f.type }));
+    const nested = resolveReferencedMessageTypes(childFields, messagesByName, seen);
+    results.push(...nested);
+    results.push({ name: msg.name, fields: msg.fields });
+  }
+
+  return results;
+}
+
 function extractUsedErrors(gwtMapping: Record<string, (GwtCondition & { failingFields?: string[] })[]>): string[] {
   debug('Extracting used errors from GWT mapping');
   const usedErrors = new Set<string>();
@@ -520,6 +592,15 @@ async function prepareTemplateData(
   const allEventTypes = createEventUnionType(events);
   const localEvents = getLocalEvents(events);
 
+  const messagesByName = new Map((allMessages ?? []).map((m) => [m.name, m]));
+  const targetName = 'server' in slice ? slice.server?.data?.items?.[0]?.target?.name : undefined;
+  const queryMessage = targetName != null ? allMessages?.find((m) => m.name === targetName) : undefined;
+  const commandFields = filteredCommands.flatMap((c) => c.fields ?? []);
+  const referencedTypes = resolveReferencedMessageTypes(
+    [...(queryMessage?.fields ?? []), ...commandFields],
+    messagesByName,
+  );
+
   return {
     flowName: flow.name,
     sliceName: slice.name,
@@ -547,6 +628,7 @@ async function prepareTemplateData(
     allEventTypes,
     allEventTypesArray,
     localEvents,
+    referencedTypes,
   };
 }
 

package/src/codegen/templates/command/mutation.resolver.specs.ts

@@ -440,4 +440,113 @@ export class AddItemsToCartResolver {
     );
     expect(mutationFile?.contents).toContain('@Field(() => Float)');
   });
+
+  it('should generate @InputType classes for referenced message types with Input suffix', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Shopping',
+          slices: [
+            {
+              type: 'command',
+              name: 'Place order',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: '',
+                    rules: [
+                      {
+                        name: 'place order',
+                        examples: [
+                          {
+                            name: 'happy path',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'PlaceOrder',
+                                docString: {
+                                  orderId: 'o-1',
+                                  items: [{ sku: 'abc', quantity: 2 }],
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'CartItem',
+          fields: [
+            { name: 'sku', type: 'string' },
+            { name: 'quantity', type: 'number' },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'PlaceOrder',
+          fields: [
+            { name: 'orderId', type: 'string', required: true },
+            { name: 'items', type: 'Array<CartItem>', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const mutationFile = plans.find(
+      (p) => p.outputPath.endsWith('mutation.resolver.ts') && p.contents.includes('export class PlaceOrderResolver'),
+    );
+
+    expect(mutationFile?.contents).toMatchInlineSnapshot(`
+      "import { Mutation, Resolver, Arg, Ctx, Field, InputType, Float } from 'type-graphql';
+      import { type GraphQLContext, sendCommand, MutationResponse } from '../../../shared';
+
+      @InputType()
+      export class CartItemInput {
+        @Field(() => String)
+        sku!: string;
+
+        @Field(() => Float)
+        quantity!: number;
+      }
+
+      @InputType()
+      export class PlaceOrderInput {
+        @Field(() => String)
+        orderId!: string;
+
+        @Field(() => [CartItemInput])
+        items!: CartItemInput[];
+      }
+
+      @Resolver()
+      export class PlaceOrderResolver {
+        @Mutation(() => MutationResponse)
+        async placeOrder(
+          @Arg('input', () => PlaceOrderInput) input: PlaceOrderInput,
+          @Ctx() ctx: GraphQLContext,
+        ): Promise<MutationResponse> {
+          return await sendCommand(ctx.messageBus, {
+            type: 'PlaceOrder',
+            kind: 'Command',
+            data: { ...input },
+          });
+        }
+      }
+      "
+    `);
+  });
 });

package/src/codegen/templates/command/mutation.resolver.ts.ejs

@@ -1,9 +1,10 @@
 <%
 const cmd = commands[0];
-const usesDate = cmd.fields.some(f => fieldUsesDate(f.type ?? f.tsType));
-const usesJSON = cmd.fields.some(f => fieldUsesJSON(f.type ?? f.tsType));
-const usesFloat = cmd.fields.some(f => fieldUsesFloat(f.type ?? f.tsType));
-const enumList = collectEnumNames(cmd.fields);
+const refFields = (referencedTypes ?? []).flatMap(rt => rt.fields ?? []);
+const usesDate = [...cmd.fields, ...refFields].some(f => fieldUsesDate(f.type ?? f.tsType));
+const usesJSON = [...cmd.fields, ...refFields].some(f => fieldUsesJSON(f.type ?? f.tsType));
+const usesFloat = [...cmd.fields, ...refFields].some(f => fieldUsesFloat(f.type ?? f.tsType));
+const enumList = collectEnumNames([...cmd.fields, ...refFields]);
 
 const embeddedInputs = [];
 for (const f of cmd.fields) {
@@ -35,6 +36,23 @@ export class <%= typeName %> {
 <% } %>
 }
 <% } %>
+<% for (const ref of (referencedTypes ?? [])) {
+    const parsedRefFields = (ref.fields ?? []).map(f => ({
+        name: f.name,
+        tsType: f.type ?? 'string',
+        gqlType: graphqlType(f.type ?? 'string'),
+        nullable: isNullable(f.type ?? 'string'),
+    }));
+%>
+
+@InputType()
+export class <%= ref.name %>Input {
+<% for (const f of parsedRefFields) { %>
+    @Field(() => <%= f.gqlType %><%= f.nullable ? ', { nullable: true }' : '' %>)
+    <%= f.name %><%= f.nullable ? '?' : '!' %>: <%= toTsFieldType(f.tsType) %>;
+<% } %>
+}
+<% } %>
 
 @InputType()
 export class <%= pascalCase(cmd.type) %>Input {
@@ -49,6 +67,12 @@ if (isInlineObjectArray(tsType)) { %>
 <% } else if (isInlineObject(tsType)) { %>
     @Field(() => <%= nestedName %><%= (field.required === false || isNullable(tsType)) ? ', { nullable: true }' : '' %>)
     <%= field.name %><%= field.required === false ? '?' : '!' %>: <%= nestedName %>;
+<% } else if (isReferencedMessageTypeArray(tsType)) { %>
+    @Field(() => [<%= extractReferencedTypeName(tsType) %>Input]<%= (field.required === false || isNullable(tsType)) ? ', { nullable: true }' : '' %>)
+    <%= field.name %><%= field.required === false ? '?' : '!' %>: <%= extractReferencedTypeName(tsType) %>Input[];
+<% } else if (isReferencedMessageType(tsType)) { %>
+    @Field(() => <%= extractReferencedTypeName(tsType) %>Input<%= (field.required === false || isNullable(tsType)) ? ', { nullable: true }' : '' %>)
+    <%= field.name %><%= field.required === false ? '?' : '!' %>: <%= extractReferencedTypeName(tsType) %>Input;
 <% } else { %>
     @Field(() => <%= gqlType %><%= (field.required === false || isNullable(tsType)) ? ', { nullable: true }' : '' %>)
     <%= field.name %><%= field.required === false ? '?' : '!' %>: <%= toTsFieldType(tsType) %>;