@auto-engineer/server-generator-apollo-emmett 1.88.0 → 1.90.0

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

@@ -64,8 +64,8 @@ case '<%= command %>': {
 <% if (integrationReturnType) { -%>
     * - Use `<%= camelCase(integrationReturnType) %>` (integration result) to enrich or filter the output
 <% } -%>
-* - If invalid, throw one of the following domain errors: `NotFoundError`, `ValidationError`, or `IllegalStateError`
-*   ⚠️ Error constructors: NotFoundError takes { id, type, message? }, while IllegalStateError/ValidationError take string
+* - If invalid, throw one of the following domain errors: `IllegalStateError`<% if (usedErrors.includes('ValidationError')) { %>, `ValidationError`<% } %><% if (usedErrors.includes('NotFoundError')) { %>, `NotFoundError`<% } %>
+*   ⚠️ Error constructors: IllegalStateError takes a string message<% if (usedErrors.includes('ValidationError')) { %>, ValidationError takes a string message<% } %><% if (usedErrors.includes('NotFoundError')) { %>, NotFoundError takes { id, type, message? }<% } %>
 * - If valid, return one or more events with the correct structure
 *
 * ⚠️ Only read from inputs — never mutate them. `evolve.ts` handles state updates.
@@ -95,10 +95,38 @@ throw new <%= error.errorType %>('<%- error.message ?? 'Validation failed' %>');
 }
 <% } } -%>
 
+<%
+const cmdFieldSet = new Set((commandSchemasByName?.[command]?.fields || []).map(f => f.name));
+const nonCommandFields = [];
+for (const scenario of scenarios) {
+    for (const t of scenario.then.filter(t => 'eventRef' in t)) {
+        const eventMsg = (messages || []).find(m => m.name === t.eventRef && m.type === 'event');
+        for (const f of (eventMsg?.fields || [])) {
+            if (!cmdFieldSet.has(f.name) && !nonCommandFields.some(e => e.name === f.name)) {
+                nonCommandFields.push(f);
+            }
+        }
+    }
+}
+-%>
+<% if (nonCommandFields.length > 0) { -%>
+// ⚠️ REQUIRED: Your return value MUST include ALL fields defined in the event type.
+// Tests use partial matching and may not check every field — passing tests does NOT mean all fields are present.
+// Do NOT use 'as <%= fallbackEventTypes[0] ? pascalCase(fallbackEventTypes[0]) : 'EventType' %>' to silence missing fields.
+//
+// Fields from command input → use ...command.data or command.data.<fieldName>
+// Fields NOT in command input → produce dynamically (never hardcode):
+<% for (const f of nonCommandFields) { -%>
+//   <%= f.name %>: <%= f.type || f.tsType %> — derive from _state, generate at runtime (e.g., crypto.randomUUID()), or compute from command.data
+<% } -%>
+<% } else { -%>
+// All event fields come from command input — use ...command.data to pass them through.
+<% } -%>
+
 // return {
 //   type: '<%= fallbackEventTypes[0] ?? 'TODO_EVENT_TYPE' %>',
-//   data: { ...command.data },
-// } as <%= fallbackEventTypes[0] ? pascalCase(fallbackEventTypes[0]) : 'TODO_EVENT_TYPE' %>;
+//   data: { ...command.data<%= nonCommandFields.length > 0 ? `, /* + dynamically produce: ${nonCommandFields.map(f => f.name).join(', ')} */` : '' %> },
+// };
 
 throw new IllegalStateError('Not yet implemented: ' + command.type);
 }

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

@@ -150,7 +150,7 @@ describe('mutation.resolver.ts.ejs', () => {
                 specs: [],
               },
               request:
-                'mutation AnswerQuestion($input: AnswerQuestionInput!) {\\n  answerQuestion(input: $input) {\\n    success\\n  }\\n}',
+                'mutation AnswerQuestion($input: AnswerQuestionInput!) {\n  answerQuestion(input: $input) {\n    success\n  }\n}',
               server: {
                 description: '',
                 data: {
@@ -549,4 +549,75 @@ export class AddItemsToCartResolver {
       "
     `);
   });
+
+  it('uses parsedRequest operationName when it differs from camelCase(cmd.type)', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Questionnaires',
+          slices: [
+            {
+              name: 'submit answer',
+              type: 'command',
+              client: { specs: [] },
+              request:
+                'mutation SubmitAnswer($input: SubmitAnswerInput!) {\n  submitQuestionnaireAnswer(input: $input) {\n    success\n  }\n}',
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'AnswerSubmitted' },
+                      destination: { type: 'stream', pattern: 'questionnaire-participantId' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: '',
+                    rules: [
+                      {
+                        name: 'submit answer',
+                        examples: [
+                          {
+                            name: 'happy path',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'SubmitAnswer',
+                                docString: { participantId: 'p-1', answer: 'Yes' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'SubmitAnswer',
+          fields: [
+            { name: 'participantId', type: 'string', required: true },
+            { name: 'answer', type: 'string', 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 SubmitAnswerResolver'),
+    );
+
+    expect(mutationFile?.contents).toContain('async submitQuestionnaireAnswer(');
+  });
 });

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

@@ -82,7 +82,7 @@ if (isInlineObjectArray(tsType)) { %>
 @Resolver()
 export class <%= pascalCase(cmd.type) %>Resolver {
 @Mutation(() => MutationResponse)
-async <%= camelCase(cmd.type) %>(
+async <%= parsedRequest?.operationName ?? camelCase(cmd.type) %>(
 @Arg('input', () => <%= pascalCase(cmd.type) %>Input) input: <%= pascalCase(cmd.type) %>Input,
 @Ctx() ctx: GraphQLContext,
 ): Promise<MutationResponse> {

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

@@ -1567,6 +1567,11 @@ describe('projection.specs.ts.ejs', () => {
             case 'WorkoutRecorded': {
               /**
       * ## IMPLEMENTATION INSTRUCTIONS ##
+      *
+      * Derive ALL field values from event.data or existing document state.
+      * NEVER hardcode constant values — every output field must trace to an input.
+      * Preserve all import paths above — they are generated from the model.
+      *
           * Implement how this event updates the projection.
           *
           * **Internal State Pattern (extends, never replaces the imported type):**
@@ -2094,6 +2099,125 @@ describe('projection.specs.ts.ejs', () => {
     expect(specFile?.contents).not.toContain('"[{\\"appointmentId\\"');
   });
 
+  it('should serialize array values correctly when event field is missing from schema', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'fitness-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'update-leaderboard',
+              stream: 'leaderboard-${week}',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Update leaderboard',
+                    rules: [
+                      {
+                        name: 'Should update leaderboard',
+                        examples: [
+                          {
+                            name: 'Leaderboard updated',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'UpdateLeaderboard',
+                                docString: { week: 'week-1' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'LeaderboardUpdated',
+                                docString: { week: 'week-1', rankings: [{ memberId: 'm1', points: 100 }] },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'query',
+              name: 'view-leaderboard',
+              stream: 'leaderboard',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'State', name: 'LeaderboardStats' },
+                      origin: { type: 'projection', name: 'LeaderboardProjection', idField: 'week' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'View leaderboard',
+                    rules: [
+                      {
+                        name: 'Should show leaderboard',
+                        examples: [
+                          {
+                            name: 'Shows rankings after update',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LeaderboardUpdated',
+                                docString: { week: 'week-1', rankings: [{ memberId: 'm1', points: 100 }] },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'LeaderboardStats',
+                                docString: { week: 'week-1', rankings: [{ memberId: 'm1', points: 100 }] },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'UpdateLeaderboard',
+          fields: [{ name: 'week', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'LeaderboardUpdated',
+          source: 'internal',
+          fields: [{ name: 'week', type: 'string', required: true }],
+        },
+        {
+          type: 'state',
+          name: 'LeaderboardStats',
+          fields: [{ name: 'week', type: 'string', required: true }],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const specFile = plans.find((p) => p.outputPath.endsWith('view-leaderboard/projection.specs.ts'));
+
+    expect(specFile?.contents).not.toContain('[object Object]');
+    expect(specFile?.contents).toContain('week');
+  });
+
   it('should resolve idField value from Given/When events when not in Then state data', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',

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

@@ -239,6 +239,11 @@ describe('projection.ts.ejs', () => {
             case 'ListingCreated': {
               /**
       * ## IMPLEMENTATION INSTRUCTIONS ##
+      *
+      * Derive ALL field values from event.data or existing document state.
+      * NEVER hardcode constant values — every output field must trace to an input.
+      * Preserve all import paths above — they are generated from the model.
+      *
           * Implement how this event updates the projection.
           *
           * **Internal State Pattern (extends, never replaces the imported type):**
@@ -273,6 +278,11 @@ describe('projection.ts.ejs', () => {
             case 'ListingRemoved': {
               /**
       * ## IMPLEMENTATION INSTRUCTIONS ##
+      *
+      * Derive ALL field values from event.data or existing document state.
+      * NEVER hardcode constant values — every output field must trace to an input.
+      * Preserve all import paths above — they are generated from the model.
+      *
           * This event might indicate removal of a AvailableListings.
           *
           * - If the intent is to **remove the document**, return \`null\`.
@@ -568,6 +578,11 @@ describe('projection.ts.ejs', () => {
             case 'TodoAdded': {
               /**
       * ## IMPLEMENTATION INSTRUCTIONS ##
+      *
+      * Derive ALL field values from event.data or existing document state.
+      * NEVER hardcode constant values — every output field must trace to an input.
+      * Preserve all import paths above — they are generated from the model.
+      *
           * **SINGLETON AGGREGATION PATTERN**
           *
           * This projection maintains ONE document aggregating data from MANY entities.
@@ -784,6 +799,11 @@ describe('projection.ts.ejs', () => {
             case 'UserJoinedProject': {
               /**
       * ## IMPLEMENTATION INSTRUCTIONS ##
+      *
+      * Derive ALL field values from event.data or existing document state.
+      * NEVER hardcode constant values — every output field must trace to an input.
+      * Preserve all import paths above — they are generated from the model.
+      *
           * **COMPOSITE KEY PROJECTION**
           *
           * This projection uses a composite key: userId + projectId

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

@@ -35,7 +35,7 @@ function isQueryAction(whenText, queryName) {
 
 function formatSpecValue(value, tsType) {
     if (value === null || value === undefined) return 'null';
-    if (tsType === 'string' || tsType === 'ID') return `'${value}'`;
+    if ((tsType === 'string' || tsType === 'ID') && typeof value === 'string') return `'${value}'`;
     if (tsType === 'number' || tsType === 'boolean') return String(value);
     if (tsType === 'Date') return `new Date('${value}')`;
     if (Array.isArray(value)) {
@@ -60,6 +60,10 @@ function formatSpecValue(value, tsType) {
             });
             return `{ ${entries.join(', ')} }`;
         }
+        const entries = Object.entries(value).map(([k, v]) =>
+            `${k}: ${formatSpecValue(v, typeof v)}`
+        );
+        return `{ ${entries.join(', ')} }`;
     }
     if (typeof value === 'string' && (tsType.includes('[]') || tsType.startsWith('Array<'))) {
         try {

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

@@ -120,6 +120,11 @@ switch (event.type) {
 case '<%= event.type %>': {
 /**
 * ## IMPLEMENTATION INSTRUCTIONS ##
+*
+* Derive ALL field values from event.data or existing document state.
+* NEVER hardcode constant values — every output field must trace to an input.
+* Preserve all import paths above — they are generated from the model.
+*
 <% if (isSingleton) { -%>
     * **SINGLETON AGGREGATION PATTERN**
     *

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

@@ -2,7 +2,7 @@
 const target = slice?.server?.data?.items?.[0]?.target;
 const projection = slice?.server?.data?.items?.[0]?.origin;
 const isSingleton = projection?.singleton === true;
-const queryName = parsedRequest?.queryName ?? camelCase(sliceName);
+const queryName = parsedRequest?.operationName ?? camelCase(sliceName);
 const viewType = target?.name ? pascalCase(target.name) : 'UnknownView';
 const collectionName = projectionName || 'unknown-collection';
 const message = messages?.find(m => m.name === viewType);

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

@@ -369,6 +369,121 @@ describe('react.specs.ts.ejs (react slice)', () => {
     expect(specFile?.contents).not.toContain('tipAmount: "5.00"');
   });
 
+  it('should exclude event And-steps from ReactorCommand type and then assertions', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'notification flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'earn points',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Earn points',
+                    rules: [
+                      {
+                        name: 'Should earn',
+                        examples: [
+                          {
+                            name: 'Points earned',
+                            steps: [
+                              { keyword: 'When', text: 'EarnPoints', docString: { memberId: 'm1', amount: 10 } },
+                              { keyword: 'Then', text: 'PointsEarned', docString: { memberId: 'm1', amount: 10 } },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'react',
+              name: 'notify milestone',
+              server: {
+                description: 'Notifies on milestone',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Command', name: 'SendNotification' },
+                      destination: { type: 'stream', pattern: 'notif-${memberId}' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Milestone notification',
+                    rules: [
+                      {
+                        name: 'Should notify',
+                        examples: [
+                          {
+                            name: 'Milestone reached',
+                            steps: [
+                              { keyword: 'When', text: 'PointsEarned', docString: { memberId: 'm1', amount: 10 } },
+                              { keyword: 'Then', text: 'MilestoneNotified', docString: { memberId: 'm1' } },
+                              { keyword: 'And', text: 'SendNotification', docString: { memberId: 'm1' } },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'EarnPoints',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'amount', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'PointsEarned',
+          source: 'internal',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'amount', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'SendNotification',
+          fields: [{ name: 'memberId', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'MilestoneNotified',
+          source: 'internal',
+          fields: [{ name: 'memberId', type: 'string', required: true }],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const specFile = plans.find((p) => p.outputPath.endsWith('notify-milestone/react.specs.ts'));
+
+    expect(specFile?.contents).toContain('type ReactorCommand = SendNotification;');
+    expect(specFile?.contents).not.toContain('MilestoneNotified');
+    expect(specFile?.contents).toContain("type: 'SendNotification'");
+    expect(specFile?.contents).toContain('.then({');
+  });
+
   it('should seed event store with Given state data via appendToStream', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',

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

@@ -248,8 +248,15 @@ describe('handle.ts.ejs (react slice)', () => {
             /**
              * ## IMPLEMENTATION INSTRUCTIONS ##
              *
-             * - Review the generated send call below and adjust if needed.
-             * - Add business logic (validation, conditional sends) as required.
+             * Complete the command send below. Field sources are pre-classified:
+             * - \`event.data.<field>\` → already wired from the triggering event.
+             * - \`<stateVar>.<field>\` → already wired from loaded aggregate state.
+             * - \`undefined, // TODO: source unknown\` → MUST be dynamically derived:
+             *   compute from event.data, loaded state, or runtime logic.
+             *   NEVER hardcode values copied from test assertions.
+             *
+             * Preserve all import paths above — they are generated from the model.
+             * Add business logic (validation, conditional sends) as needed.
              */
 
             // Event (BookingRequested) fields: bookingId: string, hostId: string, message: string

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

@@ -122,9 +122,7 @@ describe('<%= ruleDescription %>', () => {
     for (const gs of givenStates) {
       const stateSchema = states.find(s => s.type === gs.eventRef);
       const eventDef = messages.find(m => m.name === exampleEvent.eventRef);
-      const stateFieldNames = (stateSchema?.fields || []).map(f => f.name);
-      const eventFieldNames = (eventDef?.fields || []).map(f => f.name);
-      const linkingField = stateFieldNames.find(f => eventFieldNames.includes(f));
+      const linkingField = findPrimitiveLinkingField(stateSchema?.fields || [], eventDef?.fields || []);
       if (linkingField) {
         const linkingValue = gs.exampleData[linkingField];
 -%>

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

@@ -39,15 +39,30 @@ 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
+);
+-%>
     /**
     * ## IMPLEMENTATION INSTRUCTIONS ##
     *
-    * - Review the generated send call below and adjust if needed.
-    * - Add business logic (validation, conditional sends) as required.
+    * Complete the command send below. Field sources are pre-classified:
+    * - `event.data.<field>` → already wired from the triggering event.
+    * - `<stateVar>.<field>` → already wired from loaded aggregate state.
+    * - `undefined, // TODO: source unknown` → MUST be dynamically derived:
+    *   compute from event.data, loaded state, or runtime logic.
+    *   NEVER hardcode values copied from test assertions.
+    *
+    * Preserve all import paths above — they are generated from the model.
+<% if (willHaveAggregateStream) { -%>
+    * Do NOT modify or remove aggregateStream calls — they load required state.
+<% } -%>
+    * Add business logic (validation, conditional sends) as needed.
     */
 <%
-const eventDef = messages.find(m => m.name === eventType);
-const commandDef = messages.find(m => m.name === commandType && m.type === 'command');
 const commandFields = (commandDef?.fields || []);
 const eventFieldSet = new Set((eventDef?.fields || []).map(f => f.name));
 const stateFieldSources = {};
@@ -61,9 +76,7 @@ const stateFieldSources = {};
 <% if (states.length > 0) {
   let hasAggregateStream = false;
   for (const state of states) {
-    const stateFieldNames = state.fields.map(f => f.name);
-    const eventFieldNames = (eventDef?.fields || []).map(f => f.name);
-    const linkingField = stateFieldNames.find(f => eventFieldNames.includes(f));
+    const linkingField = findPrimitiveLinkingField(state.fields, eventDef?.fields || []);
     if (linkingField) {
       hasAggregateStream = true;
       const varName = camelCase(state.type);
@@ -75,8 +88,8 @@ const stateFieldSources = {};
     const { state: <%= varName %> } = await eventStore.aggregateStream(
       '<%= state.type %>-' + event.data.<%= linkingField %>,
       {
-        evolve: (currentState, evt) => ({ ...currentState, ...evt.data }),
-        initialState: () => ({}),
+        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(', ') %>