@auto-engineer/server-generator-apollo-emmett 1.150.0 → 1.152.0

package/dist/src/codegen/templates/command/decide.specs.ts.ejs

@@ -54,8 +54,33 @@ for (const [importPath, eventTypes] of testEventsByPath.entries()) {
 
 const uniqueEventTypes = Array.from(new Set(allEvents.map(e => e?.type).filter(Boolean))).sort();
 
+const successScenarios = [];
+const seenCommandEvents = new Set();
+for (const commandName in gwtMapping) {
+    const cases = gwtMapping[commandName];
+    const schema = commandSchemasByName[commandName];
+    const cmdFieldNames = new Set(schema?.fields?.map(f => f.name) || []);
+    for (const gwt of cases) {
+        const eventResults = gwt.then.filter(t => 'eventRef' in t);
+        const errorResult = gwt.then.find(t => 'errorType' in t);
+        if (errorResult) continue;
+        const givenEventRefs = (gwt.given || []).filter(g => events.some(ev => ev.type === g.eventRef));
+        for (const e of eventResults) {
+            const dedupeKey = `${commandName}::${e.eventRef}`;
+            if (seenCommandEvents.has(dedupeKey)) continue;
+            seenCommandEvents.add(dedupeKey);
+            const evtSchema = events.find(evt => evt.type === e.eventRef);
+            const evtFields = evtSchema?.fields || [];
+            const nonCmdFields = evtFields.filter(f => !cmdFieldNames.has(f.name));
+            if (nonCmdFields.length > 0) {
+                successScenarios.push({ commandName, gwt, eventRef: e.eventRef, evtSchema, nonCmdFields, cmdFieldNames, thenExampleData: e.exampleData || {}, givenEventRefs });
+            }
+        }
+    }
+}
+const hasFieldCompletenessTests = successScenarios.length > 0;
 _%>
-import { describe, it } from 'vitest';
+import { describe, <% if (hasFieldCompletenessTests) { %>expect, <% } %>it } from 'vitest';
 import { DeciderSpecification } from '@event-driven-io/emmett';
 import { decide } from './decide';
 import { evolve } from './evolve';
@@ -108,8 +133,8 @@ describe('<%= escapeJsString(ruleDescription) %>', () => {
 -%>
         data: <%- formatDataObject(filteredCmdData, schema) %>,
 <%
-    const { date: derivedDate, fields: derivedDateFieldNames } = findDerivedDateInfo(eventResults, commandFieldNames, gwt.given);
-    const keepFieldNames = buildKeepFieldNames(eventResults, commandFieldNames, derivedDateFieldNames, gwt.given);
+    const { date: derivedDate, fields: derivedDateFieldNames } = findDerivedDateInfo(eventResults, commandFieldNames, givenEvents);
+    const keepFieldNames = buildKeepFieldNames(eventResults, commandFieldNames, derivedDateFieldNames, givenEvents);
 -%>
         metadata: { now: <%= derivedDate ? `new Date('${derivedDate}')` : 'new Date()' %> },
       })
@@ -133,4 +158,66 @@ describe('<%= escapeJsString(ruleDescription) %>', () => {
   });
 <% } %>
 });
+<% } %>
+<% if (hasFieldCompletenessTests) {
+  const scenariosByCommand = new Map();
+  for (const s of successScenarios) {
+    if (!scenariosByCommand.has(s.commandName)) scenariosByCommand.set(s.commandName, []);
+    scenariosByCommand.get(s.commandName).push(s);
+  }
+%>
+describe('field completeness', () => {
+<% for (const [cmdName, scenarios] of scenariosByCommand.entries()) {
+    const firstScenario = scenarios[0];
+    const gwt = firstScenario.gwt;
+    const schema = commandSchemasByName[cmdName];
+    const givenEvents = (gwt.given || []).filter(g => events.some(e => e.type === g.eventRef));
+    const example = gwt.when;
+    const cmdFieldNames = firstScenario.cmdFieldNames;
+    const filteredCmdData = Object.fromEntries(
+      Object.entries(example.exampleData || {}).filter(([key]) => cmdFieldNames.has(key))
+    );
+%>
+  it('should include all required fields in <%= scenarios.map(s => s.eventRef).join(', ') %>', () => {
+<%_ if (givenEvents.length) { _%>
+    const state = [
+      <%- givenEvents.map(g => `{
+        type: '${g.eventRef}' as const,
+        data: ${formatDataObject(g.exampleData, events.find(e => e.type === g.eventRef))}
+      }`).join(',\n      ') %>
+    ].reduce((s, e) => evolve(s, e), initialState());
+<%_ } else { _%>
+    const state = initialState();
+<%_ } _%>
+    const result = decide(
+      { type: '<%= example.commandRef %>', data: <%- formatDataObject(filteredCmdData, schema) %>, metadata: { now: new Date() } },
+      state,
+    );
+    const evtArray = Array.isArray(result) ? result : [result];
+<% for (let i = 0; i < scenarios.length; i++) {
+    const s = scenarios[i];
+    const allFields = s.evtSchema?.fields || [];
+%>
+    expect(evtArray[<%= i %>]).toMatchObject({
+      type: '<%= s.eventRef %>',
+      data: expect.objectContaining({
+<% for (const f of allFields) {
+    const isCommandField = s.cmdFieldNames.has(f.name);
+    const modelValue = s.thenExampleData[f.name];
+    const isTraceableToGivenEvent = modelValue !== undefined
+        && isKeyTraceable(f.name, modelValue, s.givenEventRefs);
+    const hasModelValue = !isCommandField && isTraceableToGivenEvent;
+-%>
+<% if (hasModelValue) { -%>
+        <%= f.name %>: <%- formatTsValue(modelValue, f.tsType ?? f.type ?? 'string') %>,
+<% } else { -%>
+        <%= f.name %>: expect.any(<%= jsConstructorForType(f.tsType ?? f.type ?? 'string') %>),
+<% } -%>
+<% } -%>
+      }),
+    });
+<% } %>
+  });
+<% } %>
+});
 <% } %>

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

@@ -1202,7 +1202,8 @@ describe('projection.specs.ts.ejs', () => {
                 .collection<WorkoutHistory>('WorkoutHistoryProjection')
                 .findOne((doc) => doc.memberId === 'mem_001');
 
-              const expected = {
+              const expected: WorkoutHistory = {
+                memberId: 'mem_001',
                 totalCalories: 250,
               };
 
@@ -1213,7 +1214,7 @@ describe('projection.specs.ts.ejs', () => {
     `);
   });
 
-  it('should exclude query arg fields that differ from projection-computed values', async () => {
+  it('should include all Then fields in query action assertions', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
       scenes: [
@@ -1417,11 +1418,13 @@ describe('projection.specs.ts.ejs', () => {
                 .collection<FartHistory>('FartHistoryProjection')
                 .findOne((doc) => doc.userId === 'usr_123');
 
-              const expected = {
+              const expected: FartHistory = {
+                userId: 'usr_123',
                 farts: [
                   { fartId: 'fart_456', intensity: 7 },
                   { fartId: 'fart_789', intensity: 9 },
                 ],
+                minIntensity: 6,
               };
 
               expect(document).toMatchObject(expected);

package/dist/src/codegen/templates/query/projection.specs.ts.ejs

@@ -282,15 +282,10 @@ if (isCompositeKey) {
 
 <%
    const stateKeys = Object.keys(expectedState.exampleData || {});
-   const queryArgs = isQueryActionTest
-     ? (testCase.when?.args
-       || (Array.isArray(testCase.when) && testCase.when[0]?.exampleData)
-       || {})
-     : {};
-   const queryArgKeys = new Set(Object.keys(queryArgs));
-   const assertionKeys = stateKeys.filter(k => !queryArgKeys.has(k));
+   const assertionKeys = stateKeys;
    const stateMessage = messages.find(m => m.name === targetName);
-   const isPartial = assertionKeys.length < stateKeys.length;
+   const stateFieldSet = new Set((stateMessage?.fields || []).map(f => f.name));
+   const isPartial = assertionKeys.length !== stateFieldSet.size || assertionKeys.some(k => !stateFieldSet.has(k));
 -%>
         const expected<%= isPartial ? '' : `: ${TargetType}` %> = {
 <% for (let i = 0; i < assertionKeys.length; i++) {

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

@@ -1478,4 +1478,67 @@ describe('query.resolver.ts.ejs', () => {
     expect(resolverFile?.contents).toContain('item.numBedrooms < minBedrooms');
     expect(resolverFile?.contents).toContain('item.pricePerNight > maxPrice');
   });
+
+  it('should generate Date-aware comparison for Date-typed filter fields', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'booking-scene',
+          moments: [
+            {
+              type: 'query',
+              name: 'search-bookings',
+              request: `
+                query SearchBookings($checkIn: String) {
+                  searchBookings(checkIn: $checkIn) {
+                    bookingId
+                    checkIn
+                    guestName
+                  }
+                }
+              `,
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      origin: {
+                        type: 'projection',
+                        idField: 'bookingId',
+                        name: 'BookingsProjection',
+                      },
+                      target: {
+                        type: 'State',
+                        name: 'BookingView',
+                      },
+                    },
+                  ],
+                },
+                specs: [],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'BookingView',
+          fields: [
+            { name: 'bookingId', type: 'string', required: true },
+            { name: 'checkIn', type: 'Date', required: true },
+            { name: 'guestName', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const resolverFile = plans.find((p) => p.outputPath.endsWith('query.resolver.ts'));
+
+    expect(resolverFile?.contents).toContain('new Date(item.checkIn).getTime()');
+    expect(resolverFile?.contents).toContain('new Date(checkIn).getTime()');
+  });
 });

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

@@ -195,9 +195,15 @@ return model.<%= isIdLookup ? 'findOne' : 'find' %>((<%= hasMatchingArgs ? 'item
             const mapping = argFieldMap[arg.name];
             const mappedField = mapping ? mapping.field : (stateFieldNames.has(arg.name) ? arg.name : null);
             const op = mapping ? negatedOp[mapping.operator] : '!==';
-            if (mappedField) { %>
+            if (mappedField) {
+              const stateField = messageFields.find(f => f.name === mappedField);
+              const isDateField = stateField && fieldUsesDate(stateField.type ?? 'string');
+              if (isDateField) { %>
+    if (<%= arg.name %> !== undefined && new Date(item.<%= mappedField %>).getTime() <%= op %> new Date(<%= arg.name %>).getTime()) return false;
+<%            } else { %>
     if (<%= arg.name %> !== undefined && item.<%= mappedField %> <%= op %> <%= arg.name %>) return false;
-<%          } else { %>
+<%            }
+            } else { %>
     // NOTE: '<%= arg.name %>' has no matching field on the state type — add custom filter logic if needed.
 <%          }
         }

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

@@ -119,18 +119,32 @@ describe('<%= escapeJsString(ruleDescription) %>', () => {
     const givenStates = testCase.given.filter(g =>
       messages.some(m => m.type === 'state' && m.name === g.eventRef)
     );
+    const targetCommand = thenCommands[0]?.commandRef;
+    const matchedPair = eventCommandPairs.find(p => p.commandType === targetCommand);
+    const pairStreamPattern = matchedPair?.streamPattern;
     for (const gs of givenStates) {
       const stateSchema = states.find(s => s.type === gs.eventRef);
-      const eventDef = messages.find(m => m.name === exampleEvent.eventRef);
-      const linkingField = findPrimitiveLinkingField(stateSchema?.fields || [], eventDef?.fields || []);
-      if (linkingField) {
-        const linkingValue = gs.exampleData[linkingField];
+      if (pairStreamPattern) {
+        const resolvedStream = pairStreamPattern.replace(/\$\{([^}]+)\}/g, (_, key) =>
+          String(exampleEvent.exampleData?.[key] ?? gs.exampleData?.[key] ?? 'unknown')
+        );
+-%>
+    await eventStore.appendToStream('<%= resolvedStream %>', [{
+      type: '<%= gs.eventRef %>Initialized',
+      data: <%- formatDataObject(gs.exampleData, stateSchema) %>
+    }]);
+<%    } else {
+        const eventDef = messages.find(m => m.name === exampleEvent.eventRef);
+        const linkingField = findPrimitiveLinkingField(stateSchema?.fields || [], eventDef?.fields || []);
+        if (linkingField) {
+          const linkingValue = gs.exampleData[linkingField];
 -%>
     await eventStore.appendToStream('<%= gs.eventRef %>-<%= linkingValue %>', [{
       type: '<%= gs.eventRef %>Initialized',
       data: <%- formatDataObject(gs.exampleData, stateSchema) %>
     }]);
-<%    }
+<%      }
+      }
     }
 -%>
 <%

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

@@ -22,6 +22,7 @@ const uniqueEventTypeNames = [...new Set(allEventTypeNames)];
 const eventUnion = uniqueEventTypeNames.join(' | ');
 
 const willHaveAnyAggregateStream = eventCommandPairs.some(pair => {
+  if (pair.streamPattern) return true;
   const eventDef = messages.find(m => m.name === pair.eventType);
   return states.some(state =>
     findPrimitiveLinkingField(state.fields, eventDef?.fields || []) !== undefined
@@ -84,18 +85,43 @@ eachMessage: async (event): Promise<MessageHandlerResult> => {
 <% } -%>
 <% 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);
+    if (pair.streamPattern) {
+      hasAggregateStream = true;
+      const streamExpr = pair.streamPattern.replace(/\$\{([^}]+)\}/g, (_, key) => '${event.data.' + key + '}');
+      const varName = camelCase(states[0].type);
+      for (const state of states) {
         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 stateUsedByCommand = commandFields.some(f =>
+        !eventFieldSet.has(f.name) && states.some(s => s.fields.some(sf => sf.name === f.name))
+      );
+      const varPrefix = stateUsedByCommand ? '' : '_';
+-%>
+
+    const { state: <%= varPrefix %><%= varName %> } = await eventStore.aggregateStream(
+      `<%= streamExpr %>`,
+      {
+        evolve: (currentState: Record<string, unknown>, evt: { type: string; data: Record<string, unknown> }) => ({ ...currentState, ...evt.data }),
+        initialState: (): Record<string, unknown> => ({}),
+      },
+    );
+    // <%= states[0].type %> fields: <%= states.flatMap(s => s.fields).map(f => f.name).join(', ') %>
+
+<%  } else {
+      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: <%= varPrefix %><%= varName %> } = await eventStore.aggregateStream(
@@ -107,7 +133,8 @@ eachMessage: async (event): Promise<MessageHandlerResult> => {
     );
     // <%= state.type %> fields: <%= state.fields.map(f => f.name).join(', ') %>
 
-<%      }
+<%        }
+      }
     }
     if (!hasAggregateStream) {
 -%>
@@ -155,17 +182,41 @@ eachMessage: async (event): Promise<MessageHandlerResult> => {
       // 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);
+      if (pair.streamPattern) {
+        const streamExpr = pair.streamPattern.replace(/\$\{([^}]+)\}/g, (_, key) => '${event.data.' + key + '}');
+        const varName = camelCase(states[0].type);
+        for (const state of states) {
           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 stateUsedByCommand = commandFields.some(f =>
+          !eventFieldSet.has(f.name) && states.some(s => s.fields.some(sf => sf.name === f.name))
+        );
+        const varPrefix = stateUsedByCommand ? '' : '_';
+-%>
+
+      const { state: <%= varPrefix %><%= varName %> } = await eventStore.aggregateStream(
+        `<%= streamExpr %>`,
+        {
+          evolve: (currentState: Record<string, unknown>, evt: { type: string; data: Record<string, unknown> }) => ({ ...currentState, ...evt.data }),
+          initialState: (): Record<string, unknown> => ({}),
+        },
+      );
+      // <%= states[0].type %> fields: <%= states.flatMap(s => s.fields).map(f => f.name).join(', ') %>
+
+<%    } else {
+        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(
@@ -177,7 +228,8 @@ eachMessage: async (event): Promise<MessageHandlerResult> => {
       );
       // <%= state.type %> fields: <%= state.fields.map(f => f.name).join(', ') %>
 
-<%        }
+<%          }
+        }
       }
     }
 -%>

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

@@ -1008,4 +1008,143 @@ export type BarberNotified = Event<
       "
     `);
   });
+
+  it('should use target command stream pattern for aggregateStream when destination exists', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'booking scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'accept booking',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'BookingAccepted' },
+                      destination: {
+                        type: 'stream',
+                        pattern: 'bookings-${bookingId}',
+                      },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Accept booking',
+                    rules: [
+                      {
+                        name: 'Should accept',
+                        examples: [
+                          {
+                            name: 'Booking accepted',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'AcceptBooking',
+                                docString: { bookingId: 'b1', hostId: 'h1' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'BookingAccepted',
+                                docString: { bookingId: 'b1', hostId: 'h1' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'notify guest of acceptance',
+              server: {
+                description: 'Notifies guest when booking accepted',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Notify guest reaction',
+                    rules: [
+                      {
+                        name: 'Should notify guest',
+                        examples: [
+                          {
+                            name: 'Guest notified',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'BookingState',
+                                docString: { bookingId: 'b1', guestEmail: 'guest@test.com' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'BookingAccepted',
+                                docString: { bookingId: 'b1', hostId: 'h1' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'AcceptBooking',
+                                docString: { bookingId: 'b1', hostId: 'h1' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'AcceptBooking',
+          fields: [
+            { name: 'bookingId', type: 'string', required: true },
+            { name: 'hostId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'BookingAccepted',
+          source: 'internal',
+          fields: [
+            { name: 'bookingId', type: 'string', required: true },
+            { name: 'hostId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'BookingState',
+          fields: [
+            { name: 'bookingId', type: 'string', required: true },
+            { name: 'guestEmail', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const reactFile = plans.find((p) => p.outputPath.endsWith('notify-guest-of-acceptance/react.ts'));
+
+    expect(reactFile?.contents).toContain('`bookings-${event.data.bookingId}`');
+    expect(reactFile?.contents).toContain('aggregateStream');
+    expect(reactFile?.contents).not.toContain('BookingState-${event.data');
+
+    const specFile = plans.find((p) => p.outputPath.endsWith('notify-guest-of-acceptance/react.specs.ts'));
+
+    expect(specFile?.contents).toContain("'bookings-b1'");
+    expect(specFile?.contents).not.toContain('BookingState-');
+  });
 });

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

@@ -59,17 +59,41 @@ async (event: <%= pascalCase(pair.eventType) %>) => {
     // 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);
+    if (pair.streamPattern) {
+      const streamExpr = pair.streamPattern.replace(/\$\{([^}]+)\}/g, (_, key) => '${event.data.' + key + '}');
+      const varName = camelCase(states[0].type);
+      for (const state of states) {
         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 stateUsedByCommand = commandFields.some(f =>
+        !eventFieldSet.has(f.name) && states.some(s => s.fields.some(sf => sf.name === f.name))
+      );
+      const varPrefix = stateUsedByCommand ? '' : '_';
+-%>
+
+    const { state: <%= varPrefix %><%= varName %> } = await eventStore.aggregateStream(
+      `<%= streamExpr %>`,
+      {
+        evolve: (currentState: Record<string, unknown>, evt: { type: string; data: Record<string, unknown> }) => ({ ...currentState, ...evt.data }),
+        initialState: (): Record<string, unknown> => ({}),
+      },
+    );
+    // <%= states[0].type %> fields: <%= states.flatMap(s => s.fields).map(f => f.name).join(', ') %>
+
+<%  } else {
+      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(
@@ -81,7 +105,8 @@ async (event: <%= pascalCase(pair.eventType) %>) => {
     );
     // <%= state.type %> fields: <%= state.fields.map(f => f.name).join(', ') %>
 
-<%      }
+<%        }
+      }
     }
   }
 -%>