@auto-engineer/server-generator-apollo-emmett 1.87.0 → 1.89.0

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

@@ -96,9 +96,9 @@ describe('decide.ts.ejs', () => {
       *
       * You should:
       * - Validate the command input fields
-      * - Inspect the current domain \`state\` to determine if the command is allowed
-      * - 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
+      * - Inspect the current domain \`_state\` to determine if the command is allowed
+      * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
+      *   ⚠️ Error constructors: IllegalStateError takes a string message
       * - If valid, return one or more events with the correct structure
       *
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
@@ -107,10 +107,12 @@ describe('decide.ts.ejs', () => {
       *   - Should create listing with valid data
       */
 
+            // All event fields come from command input — use ...command.data to pass them through.
+
             // return {
             //   type: 'ListingCreated',
             //   data: { ...command.data },
-            // } as ListingCreated;
+            // };
 
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
@@ -229,9 +231,9 @@ describe('decide.ts.ejs', () => {
       *
       * You should:
       * - Validate the command input fields
-      * - Inspect the current domain \`state\` to determine if the command is allowed
-      * - 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
+      * - Inspect the current domain \`_state\` to determine if the command is allowed
+      * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
+      *   ⚠️ Error constructors: IllegalStateError takes a string message
       * - If valid, return one or more events with the correct structure
       *
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
@@ -240,10 +242,18 @@ describe('decide.ts.ejs', () => {
       *   - Should remove existing listing
       */
 
+            // ⚠️ 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 ListingRemoved' to silence missing fields.
+            //
+            // Fields from command input → use ...command.data or command.data.<fieldName>
+            // Fields NOT in command input → produce dynamically (never hardcode):
+            //   removedAt: Date — derive from _state, generate at runtime (e.g., crypto.randomUUID()), or compute from command.data
+
             // return {
             //   type: 'ListingRemoved',
-            //   data: { ...command.data },
-            // } as ListingRemoved;
+            //   data: { ...command.data, /* + dynamically produce: removedAt */ },
+            // };
 
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
@@ -382,9 +392,9 @@ describe('decide.ts.ejs', () => {
       *
       * You should:
       * - Validate the command input fields
-      * - Inspect the current domain \`state\` to determine if the command is allowed
-      * - 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
+      * - Inspect the current domain \`_state\` to determine if the command is allowed
+      * - If invalid, throw one of the following domain errors: \`IllegalStateError\`, \`ValidationError\`
+      *   ⚠️ Error constructors: IllegalStateError takes a string message, ValidationError takes a string message
       * - If valid, return one or more events with the correct structure
       *
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
@@ -397,10 +407,12 @@ describe('decide.ts.ejs', () => {
               throw new ValidationError('Title must not be empty');
             }
 
+            // All event fields come from command input — use ...command.data to pass them through.
+
             // return {
             //   type: 'ListingCreated',
             //   data: { ...command.data },
-            // } as ListingCreated;
+            // };
 
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
@@ -579,10 +591,10 @@ describe('decide.ts.ejs', () => {
       *
       * You should:
       * - Validate the command input fields
-      * - Inspect the current domain \`state\` to determine if the command is allowed
+      * - Inspect the current domain \`_state\` to determine if the command is allowed
           * - Use \`products\` (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\`
+      *   ⚠️ Error constructors: IllegalStateError takes a string message
       * - If valid, return one or more events with the correct structure
       *
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
@@ -599,10 +611,18 @@ describe('decide.ts.ejs', () => {
       *   - Should suggest items successfully
       */
 
+            // ⚠️ 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 ItemsSuggested' to silence missing fields.
+            //
+            // Fields from command input → use ...command.data or command.data.<fieldName>
+            // Fields NOT in command input → produce dynamically (never hardcode):
+            //   items: Array<object> — derive from _state, generate at runtime (e.g., crypto.randomUUID()), or compute from command.data
+
             // return {
             //   type: 'ItemsSuggested',
-            //   data: { ...command.data },
-            // } as ItemsSuggested;
+            //   data: { ...command.data, /* + dynamically produce: items */ },
+            // };
 
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }

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

@@ -53,6 +53,52 @@ for (const [importPath, eventTypes] of testEventsByPath.entries()) {
 }
 
 const uniqueEventTypes = Array.from(new Set(allEvents.map(e => e?.type).filter(Boolean))).sort();
+
+function findDerivedDateInfo(eventResults, commandFieldNames, givenEvents) {
+    const givenValues = new Set();
+    for (const g of givenEvents || []) {
+        for (const val of Object.values(g.exampleData || {})) {
+            if (typeof val === 'string') givenValues.add(val);
+        }
+    }
+    const fieldsByDate = new Map();
+    for (const e of eventResults) {
+        for (const [key, val] of Object.entries(e.exampleData || {})) {
+            if (
+                !commandFieldNames.has(key) &&
+                typeof val === 'string' &&
+                /^\d{4}-\d{2}-\d{2}$/.test(val) &&
+                !givenValues.has(val)
+            ) {
+                if (!fieldsByDate.has(val)) fieldsByDate.set(val, []);
+                fieldsByDate.get(val).push(key);
+            }
+        }
+    }
+    if (fieldsByDate.size !== 1) return { date: null, fields: [] };
+    const [date, fields] = [...fieldsByDate.entries()][0];
+    return { date, fields };
+}
+
+function isKeyTraceable(key, value, givenEvents) {
+    if (value === null || value === undefined || typeof value === 'object') return false;
+    for (const g of givenEvents || []) {
+        if ((g.exampleData || {})[key] === value) return true;
+    }
+    return false;
+}
+
+function buildKeepFieldNames(eventResults, commandFieldNames, derivedDateFieldNames, givenEvents) {
+    const keep = new Set([...commandFieldNames, ...derivedDateFieldNames]);
+    for (const e of eventResults) {
+        for (const [key, value] of Object.entries(e.exampleData || {})) {
+            if (!keep.has(key) && isKeyTraceable(key, value, givenEvents)) {
+                keep.add(key);
+            }
+        }
+    }
+    return keep;
+}
 _%>
 import { describe, it } from 'vitest';
 import { DeciderSpecification } from '@event-driven-io/emmett';
@@ -74,6 +120,9 @@ describe('<%= ruleDescription %>', () => {
     initialState,
   });
 
+  const expectEvents = (...events: Array<{ type: string; data: unknown }>) =>
+    events as Events[];
+
 <% for (const { commandName, gwt } of ruleGwts) {
     const schema = commandSchemasByName[commandName];
     const example = gwt.when;
@@ -97,18 +146,28 @@ describe('<%= ruleDescription %>', () => {
       .when({
         type: '<%= example.commandRef %>',
         data: <%- formatDataObject(example.exampleData, schema) %>,
-        metadata: { now: new Date() },
+<%  const commandFieldNames = new Set(schema?.fields?.map(f => f.name) || []);
+    const { date: derivedDate, fields: derivedDateFieldNames } = findDerivedDateInfo(eventResults, commandFieldNames, gwt.given);
+    const keepFieldNames = buildKeepFieldNames(eventResults, commandFieldNames, derivedDateFieldNames, gwt.given);
+-%>
+        metadata: { now: <%= derivedDate ? `new Date('${derivedDate}')` : 'new Date()' %> },
       })
 <% if (errorResult) { %>
       .thenThrows((err) => err instanceof <%= errorResult.errorType %> && err.message === '<%= errorResult.message || '' %>');
 <% } else { %>
 
-      .then([
-        <%- eventResults.map(e => `{
+      .then(expectEvents(
+        <%- eventResults.map(e => {
+          const evtSchema = events.find(evt => evt.type === e.eventRef);
+          const filteredData = Object.fromEntries(
+              Object.entries(e.exampleData || {}).filter(([key]) => keepFieldNames.has(key))
+          );
+          return `{
           type: '${e.eventRef}',
-          data: ${formatDataObject(e.exampleData, events.find(evt => evt.type === e.eventRef))}
-        }`).join(',\n        ') %>
-      ]);
+          data: ${formatDataObject(filteredData, evtSchema)}
+        }`;
+        }).join(',\n        ') %>
+      ));
 <% } %>
   });
 <% } %>

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

@@ -60,12 +60,12 @@ case '<%= command %>': {
 *
 * You should:
 * - Validate the command input fields
-* - Inspect the current domain `state` to determine if the command is allowed
+* - Inspect the current domain `_state` to determine if the command is allowed
 <% 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> {