@auto-engineer/server-generator-apollo-emmett 1.123.0 → 1.125.0

package/dist/src/codegen/templates/query/query.resolver.specs.ts

@@ -99,8 +99,8 @@ describe('query.resolver.ts.ejs', () => {
         async searchProperties(
           @Ctx() ctx: GraphQLContext,
           @Arg('location', () => String, { nullable: true }) location?: string,
-          @Arg('maxPrice', () => Float, { nullable: true }) maxPrice?: number,
-          @Arg('minGuests', () => Float, { nullable: true }) minGuests?: number,
+          @Arg('maxPrice', () => Float, { nullable: true }) _maxPrice?: number,
+          @Arg('minGuests', () => Float, { nullable: true }) _minGuests?: number,
         ): Promise<AvailableListings[]> {
           const model = new ReadModel<AvailableListings>(ctx.database, 'AvailablePropertiesProjection');
 
@@ -193,7 +193,6 @@ describe('query.resolver.ts.ejs', () => {
 
     expect(resolverFile?.contents).toMatchInlineSnapshot(`
       "import { Query, Resolver, Arg, Ctx, ObjectType, Field, ID, Float } from 'type-graphql';
-      import { GraphQLJSON } from 'graphql-type-json';
       import { type GraphQLContext, ReadModel } from '../../../shared';
 
       @ObjectType()
@@ -923,7 +922,7 @@ describe('query.resolver.ts.ejs', () => {
         @Query(() => [RecipeMatchesRecipes])
         async recipeMatches(
           @Ctx() ctx: GraphQLContext,
-          @Arg('pantryId', () => ID, { nullable: true }) pantryId?: string,
+          @Arg('pantryId', () => ID, { nullable: true }) _pantryId?: string,
         ): Promise<RecipeMatchesRecipes[]> {
           const model = new ReadModel<RecipeMatchesRecipes>(ctx.database, 'RecipeMatchesProjection');
 
@@ -934,7 +933,7 @@ describe('query.resolver.ts.ejs', () => {
           // The scaffolded code below uses find() returning an array.
           // If this query should return a single item, switch to findOne().
 
-          return model.find((item) => {
+          return model.find((_item) => {
             // NOTE: 'pantryId' has no matching field on the state type — add custom filter logic if needed.
 
             return true;
@@ -1165,7 +1164,7 @@ describe('query.resolver.ts.ejs', () => {
         @Query(() => [RecipeMatchesRecipes])
         async recipeMatches(
           @Ctx() ctx: GraphQLContext,
-          @Arg('pantryId', () => ID, { nullable: true }) pantryId?: string,
+          @Arg('pantryId', () => ID, { nullable: true }) _pantryId?: string,
         ): Promise<RecipeMatchesRecipes[]> {
           const model = new ReadModel<RecipeMatchesRecipes>(ctx.database, 'RecipeMatchesProjection');
 
@@ -1176,7 +1175,7 @@ describe('query.resolver.ts.ejs', () => {
           // The scaffolded code below uses find() returning an array.
           // If this query should return a single item, switch to findOne().
 
-          return model.find((item) => {
+          return model.find((_item) => {
             // NOTE: 'pantryId' has no matching field on the state type — add custom filter logic if needed.
 
             return true;
@@ -1246,9 +1245,9 @@ describe('query.resolver.ts.ejs', () => {
 
     expect(resolverFile?.contents).toContain("import { GraphQLJSON } from 'graphql-type-json';");
     expect(resolverFile?.contents).toContain(
-      "@Arg('filter', () => GraphQLJSON, { nullable: true }) filter?: Record<string, unknown>",
+      "@Arg('filter', () => GraphQLJSON, { nullable: true }) _filter?: Record<string, unknown>",
     );
-    expect(resolverFile?.contents).toContain("@Arg('limit', () => Float, { nullable: true }) limit?: number");
+    expect(resolverFile?.contents).toContain("@Arg('limit', () => Float, { nullable: true }) _limit?: number");
     expect(resolverFile?.contents).not.toContain('ListWorkoutsFilterInput');
   });
 });

package/dist/src/codegen/templates/query/query.resolver.ts.ejs

@@ -36,6 +36,12 @@ for (const field of messageFields) {
 }
 const hasArgs = parsedRequest?.args?.length > 0;
 
+const stateFieldNames = new Set(messageFields.map(f => f.name));
+const usedArgNames = isSingleton
+  ? new Set()
+  : new Set((parsedRequest?.args ?? []).filter(a => stateFieldNames.has(a.name)).map(a => a.name));
+const hasMatchingArgs = usedArgNames.size > 0;
+
 const resolveArgTypes = (arg) => {
     const isCustom = !KNOWN_GQL_SCALARS.has(arg.graphqlType);
     return {
@@ -118,7 +124,7 @@ async <%= queryName %>(
 <%   for (let i = 0; i < parsedRequest.args.length; i++) {
     const arg = parsedRequest.args[i];
     const { gqlType, tsType } = resolveArgTypes(arg);
-%>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
+%>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= usedArgNames.has(arg.name) ? arg.name : '_' + arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
 <%   } } %>
 ): Promise<<%= viewType %>> {
   const result = await ctx.database.collection<<%= viewType %>>('<%= collectionName %>').findOne();
@@ -160,7 +166,7 @@ async <%= queryName %>(
 <%   for (let i = 0; i < parsedRequest.args.length; i++) {
     const arg = parsedRequest.args[i];
     const { gqlType, tsType } = resolveArgTypes(arg);
-%>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
+%>    @Arg('<%= arg.name %>', () => <%= gqlType %>, { nullable: true }) <%= usedArgNames.has(arg.name) ? arg.name : '_' + arg.name %>?: <%= tsType %><%= i < parsedRequest.args.length - 1 ? ',' : '' %>
 <%   } } %>
 ): Promise<<%= viewType %>[]> {
 const model = new ReadModel<<%= viewType %>>(ctx.database, '<%= collectionName %>');
@@ -172,7 +178,7 @@ const model = new ReadModel<<%= viewType %>>(ctx.database, '<%= collectionName %
 // The scaffolded code below uses find() returning an array.
 // If this query should return a single item, switch to findOne().
 
-return model.find((<%= hasArgs ? 'item' : '_item' %>) => {
+return model.find((<%= hasMatchingArgs ? 'item' : '_item' %>) => {
 <% if (parsedRequest?.args?.length) {
         const stateFieldNames = new Set(messageFields.map(f => f.name));
         for (const arg of parsedRequest.args) {

package/dist/src/codegen/templates/react/react.specs.specs.ts

@@ -217,7 +217,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
               },
             })
 
-            .then({
+            .thenSends({
               type: 'NotifyHost',
               kind: 'Command',
               data: {
@@ -457,7 +457,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
     expect(specFile?.contents).toContain('type ReactorCommand = SendNotification;');
     expect(specFile?.contents).not.toContain('MilestoneNotified');
     expect(specFile?.contents).toContain("type: 'SendNotification'");
-    expect(specFile?.contents).toContain('.then({');
+    expect(specFile?.contents).toContain('.thenSends({');
   });
 
   it('should seed event store with Given state data via appendToStream', async () => {
@@ -637,7 +637,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
               },
             })
 
-            .then({
+            .thenSends({
               type: 'NotifyBarber',
               kind: 'Command',
               data: {

package/dist/src/codegen/templates/react/react.specs.ts

@@ -233,7 +233,7 @@ describe('handle.ts.ejs (react slice)', () => {
     const handleFile = plans.find((p) => p.outputPath.endsWith('react.ts'));
 
     expect(handleFile?.contents).toMatchInlineSnapshot(`
-      "import { inMemoryReactor, type MessageHandlerResult, IllegalStateError } from '@event-driven-io/emmett';
+      "import { inMemoryReactor, type MessageHandlerResult } from '@event-driven-io/emmett';
       import type { BookingRequested } from '../guest-submits-booking-request/events';
       import type { ReactorContext } from '../../../shared';
 
@@ -244,7 +244,7 @@ describe('handle.ts.ejs (react slice)', () => {
           connectionOptions: {
             database,
           },
-          eachMessage: async (event, context): Promise<MessageHandlerResult> => {
+          eachMessage: async (event): Promise<MessageHandlerResult> => {
             /**
              * ## IMPLEMENTATION INSTRUCTIONS ##
              *

package/dist/src/codegen/templates/react/react.specs.ts.ejs

@@ -162,13 +162,13 @@ describe('<%= ruleDescription %>', () => {
 <% if (thenCommands.length === 1) {
     const commandSchema = thenCommands[0];
 %>
-      .then({
+      .thenSends({
         type: '<%= commandSchema.commandRef %>',
         kind: 'Command',
         data: <%- formatDataObject(commandSchema.exampleData, commands.find(c => c.type === commandSchema.commandRef)) %>
       });
 <% } else { %>
-      .then([
+      .thenSends([
 <% for (const cmd of thenCommands) { %>
         {
           type: '<%= cmd.commandRef %>',

package/dist/src/codegen/templates/react/react.ts.ejs

@@ -1,51 +1,50 @@
 <%
-const specs = slice.server?.specs;
-const firstExample = specs?.rules?.flatMap(rule => rule.examples)[0] ?? null;
-const gwt = firstExample ? {
-  given: firstExample.given,
-  when: firstExample.when,
-  then: firstExample.then
-} : null;
-const when = Array.isArray(gwt?.when) ? gwt.when[0] : gwt?.when;
-const then = Array.isArray(gwt?.then) ? gwt.then[0] : gwt?.then;
+if (!eventCommandPairs || eventCommandPairs.length === 0) {
+  throw new Error(`react.ts.ejs: slice "${slice.name}" has no event→command pairs — check specs`);
+}
 
-const eventType = when?.eventRef;
-const commandType = then?.commandRef;
-if (!eventType) throw new Error(
-  `react.ts.ejs: slice "${slice.name}" has no event in .when() — check specs`
-);
-if (!commandType) throw new Error(
-  `react.ts.ejs: slice "${slice.name}" has no command in .then() — check specs`
-);
-const event = events.find(e => e.type === eventType);
-const isCrossFlow = event?.sourceFlowName && event.sourceFlowName !== flowName;
-const eventImportBase = isCrossFlow
-  ? `../../${toKebabCase(event.sourceFlowName)}/${toKebabCase(event.sourceSliceName)}`
-  : event?.sourceSliceName ? `../${toKebabCase(event.sourceSliceName)}` : '.';
+const importGroups = new Map();
+for (const pair of eventCommandPairs) {
+  const event = events.find(e => e.type === pair.eventType);
+  const isCrossFlow = event?.sourceFlowName && event.sourceFlowName !== flowName;
+  const importBase = isCrossFlow
+    ? `../../${toKebabCase(event.sourceFlowName)}/${toKebabCase(event.sourceSliceName)}`
+    : event?.sourceSliceName ? `../${toKebabCase(event.sourceSliceName)}` : '.';
+  if (!importGroups.has(importBase)) importGroups.set(importBase, []);
+  const typeName = pascalCase(pair.eventType);
+  if (!importGroups.get(importBase).includes(typeName)) {
+    importGroups.get(importBase).push(typeName);
+  }
+}
+
+const allEventTypeNames = eventCommandPairs.map(p => pascalCase(p.eventType));
+const uniqueEventTypeNames = [...new Set(allEventTypeNames)];
+const eventUnion = uniqueEventTypeNames.join(' | ');
+
+const willHaveAnyAggregateStream = eventCommandPairs.some(pair => {
+  const eventDef = messages.find(m => m.name === pair.eventType);
+  return states.some(state =>
+    findPrimitiveLinkingField(state.fields, eventDef?.fields || []) !== undefined
+  );
+});
 -%>
 import {
 inMemoryReactor,
 type MessageHandlerResult,
-IllegalStateError,
 } from '@event-driven-io/emmett';
-import type { <%= pascalCase(eventType) %> } from '<%= eventImportBase %>/events';
+<% for (const [importBase, types] of importGroups) { -%>
+import type { <%= types.join(', ') %> } from '<%= importBase %>/events';
+<% } -%>
 import type { ReactorContext } from '../../../shared';
 
 export const react = ({ eventStore, commandSender, database }: ReactorContext) =>
-inMemoryReactor<<%= pascalCase(eventType) %>>({
+inMemoryReactor<<%= eventUnion %>>({
 processorId: '<%= toKebabCase(flowName) %>-<%= toKebabCase(slice.name) %>',
-canHandle: ['<%= eventType %>'],
+canHandle: [<%= eventCommandPairs.map(p => `'${p.eventType}'`).join(', ') %>],
 connectionOptions: {
 database,
 },
-eachMessage: async (event, context): Promise<MessageHandlerResult> => {
-<%
-const eventDef = messages.find(m => m.name === eventType);
-const commandDef = messages.find(m => m.name === commandType && m.type === 'command');
-const willHaveAggregateStream = states.some(state =>
-  findPrimitiveLinkingField(state.fields, eventDef?.fields || []) !== undefined
-);
--%>
+eachMessage: async (event): Promise<MessageHandlerResult> => {
     /**
     * ## IMPLEMENTATION INSTRUCTIONS ##
     *
@@ -57,7 +56,7 @@ const willHaveAggregateStream = states.some(state =>
     *   NEVER hardcode values copied from test assertions.
     *
     * Preserve all import paths above — they are generated from the model.
-<% if (willHaveAggregateStream) { -%>
+<% if (willHaveAnyAggregateStream) { -%>
     * Do NOT modify or remove aggregateStream calls — they load required state.
 <% } -%>
     *
@@ -69,31 +68,38 @@ const willHaveAggregateStream = states.some(state =>
     *
     * Add business logic (validation, conditional sends) as needed.
     */
-<%
-const commandFields = (commandDef?.fields || []);
-const eventFieldSet = new Set((eventDef?.fields || []).map(f => f.name));
-const stateFieldSources = {};
+<% if (eventCommandPairs.length === 1) {
+  const pair = eventCommandPairs[0];
+  const eventDef = messages.find(m => m.name === pair.eventType);
+  const commandDef = messages.find(m => m.name === pair.commandType && m.type === 'command');
+  const commandFields = (commandDef?.fields || []);
+  const eventFieldSet = new Set((eventDef?.fields || []).map(f => f.name));
+  const stateFieldSources = {};
 -%>
 <% if (eventDef?.fields?.length) { %>
-    // Event (<%= eventType %>) fields: <%= eventDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
+    // Event (<%= pair.eventType %>) fields: <%= eventDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
 <% } -%>
 <% if (commandDef?.fields?.length) { %>
-    // Command (<%= commandType %>) fields: <%= commandDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
+    // Command (<%= pair.commandType %>) fields: <%= commandDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
 <% } -%>
 <% if (states.length > 0) {
-  let hasAggregateStream = false;
-  for (const state of states) {
-    const linkingField = findPrimitiveLinkingField(state.fields, eventDef?.fields || []);
-    if (linkingField) {
-      hasAggregateStream = true;
-      const varName = camelCase(state.type);
-      for (const f of state.fields) {
-        if (!stateFieldSources[f.name]) stateFieldSources[f.name] = varName;
-      }
+    let hasAggregateStream = false;
+    for (const state of states) {
+      const linkingField = findPrimitiveLinkingField(state.fields, eventDef?.fields || []);
+      if (linkingField) {
+        hasAggregateStream = true;
+        const varName = camelCase(state.type);
+        for (const f of state.fields) {
+          if (!stateFieldSources[f.name]) stateFieldSources[f.name] = varName;
+        }
+        const stateUsedByCommand = commandFields.some(f =>
+          !eventFieldSet.has(f.name) && state.fields.some(sf => sf.name === f.name)
+        );
+        const varPrefix = stateUsedByCommand ? '' : '_';
 -%>
 
-    const { state: <%= varName %> } = await eventStore.aggregateStream(
-      '<%= state.type %>-' + event.data.<%= linkingField %>,
+    const { state: <%= varPrefix %><%= varName %> } = await eventStore.aggregateStream(
+      `<%= state.type %>-${event.data.<%= linkingField %>}`,
       {
         evolve: (currentState: Record<string, unknown>, evt: { type: string; data: Record<string, unknown> }) => ({ ...currentState, ...evt.data }),
         initialState: (): Record<string, unknown> => ({}),
@@ -101,35 +107,103 @@ const stateFieldSources = {};
     );
     // <%= state.type %> fields: <%= state.fields.map(f => f.name).join(', ') %>
 
-<%    }
-  }
-  if (!hasAggregateStream) {
+<%      }
+    }
+    if (!hasAggregateStream) {
 -%>
 
-<%  }
-} else {
+<%    }
+  } else {
 -%>
 
 <% } -%>
     await commandSender.send({
-      type: '<%= commandType %>',
+      type: '<%= pair.commandType %>',
       kind: 'Command',
       data: {
 <% for (const field of commandFields) {
-    const fieldName = field.name;
-    if (eventFieldSet.has(fieldName)) {
+      const fieldName = field.name;
+      if (eventFieldSet.has(fieldName)) {
 -%>
         <%= fieldName %>: event.data.<%= fieldName %>,
-<%  } else if (stateFieldSources[fieldName]) { -%>
+<%    } else if (stateFieldSources[fieldName]) { -%>
         <%= fieldName %>: <%= stateFieldSources[fieldName] %>.<%= fieldName %>,
-<%  } else { -%>
+<%    } else { -%>
         <%= fieldName %>: undefined, // TODO: source unknown
-<%  }
-  }
+<%    }
+    }
 -%>
       },
     });
 
     return;
+<% } else {
+  for (let pairIdx = 0; pairIdx < eventCommandPairs.length; pairIdx++) {
+    const pair = eventCommandPairs[pairIdx];
+    const eventDef = messages.find(m => m.name === pair.eventType);
+    const commandDef = messages.find(m => m.name === pair.commandType && m.type === 'command');
+    const commandFields = (commandDef?.fields || []);
+    const eventFieldSet = new Set((eventDef?.fields || []).map(f => f.name));
+    const stateFieldSources = {};
+    const condition = pairIdx === 0 ? 'if' : '} else if';
+-%>
+    <%= condition %> (event.type === '<%= pair.eventType %>') {
+<% if (eventDef?.fields?.length) { %>
+      // Event (<%= pair.eventType %>) fields: <%= eventDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
+<% } -%>
+<% if (commandDef?.fields?.length) { %>
+      // Command (<%= pair.commandType %>) fields: <%= commandDef.fields.map(f => f.name + ': ' + (f.tsType || f.type)).join(', ') %>
+<% } -%>
+<% if (states.length > 0) {
+      for (const state of states) {
+        const linkingField = findPrimitiveLinkingField(state.fields, eventDef?.fields || []);
+        if (linkingField) {
+          const varName = camelCase(state.type);
+          for (const f of state.fields) {
+            if (!stateFieldSources[f.name]) stateFieldSources[f.name] = varName;
+          }
+          const stateUsedByCommand = commandFields.some(f =>
+            !eventFieldSet.has(f.name) && state.fields.some(sf => sf.name === f.name)
+          );
+          const varPrefix = stateUsedByCommand ? '' : '_';
+-%>
+
+      const { state: <%= varPrefix %><%= varName %> } = await eventStore.aggregateStream(
+        `<%= state.type %>-${event.data.<%= linkingField %>}`,
+        {
+          evolve: (currentState: Record<string, unknown>, evt: { type: string; data: Record<string, unknown> }) => ({ ...currentState, ...evt.data }),
+          initialState: (): Record<string, unknown> => ({}),
+        },
+      );
+      // <%= state.type %> fields: <%= state.fields.map(f => f.name).join(', ') %>
+
+<%        }
+      }
+    }
+-%>
+      await commandSender.send({
+        type: '<%= pair.commandType %>',
+        kind: 'Command',
+        data: {
+<% for (const field of commandFields) {
+        const fieldName = field.name;
+        if (eventFieldSet.has(fieldName)) {
+-%>
+          <%= fieldName %>: event.data.<%= fieldName %>,
+<%      } else if (stateFieldSources[fieldName]) { -%>
+          <%= fieldName %>: <%= stateFieldSources[fieldName] %>.<%= fieldName %>,
+<%      } else { -%>
+          <%= fieldName %>: undefined, // TODO: source unknown
+<%      }
+      }
+-%>
+        },
+      });
+<%  }
+-%>
+    }
+
+    return;
+<% } -%>
     },
     });