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

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

@@ -117,6 +117,8 @@ describe('spec.ts.ejs', () => {
           initialState,
         });
 
+        const expectEvents = (...events: Array<{ type: string; data: unknown }>) => events as Events[];
+
         it('User creates listing with valid data', () => {
           given([])
             .when({
@@ -136,8 +138,8 @@ describe('spec.ts.ejs', () => {
               metadata: { now: new Date() },
             })
 
-            .then([
-              {
+            .then(
+              expectEvents({
                 type: 'ListingCreated',
                 data: {
                   propertyId: 'listing_123',
@@ -145,8 +147,8 @@ describe('spec.ts.ejs', () => {
                   rating: 4.8,
                   metadata: { foo: 'bar' },
                 },
-              },
-            ]);
+              }),
+            );
         });
       });
       "
@@ -263,6 +265,8 @@ describe('spec.ts.ejs', () => {
           initialState,
         });
 
+        const expectEvents = (...events: Array<{ type: string; data: unknown }>) => events as Events[];
+
         it('Existing listing can be removed', () => {
           given([
             {
@@ -283,15 +287,14 @@ describe('spec.ts.ejs', () => {
               metadata: { now: new Date() },
             })
 
-            .then([
-              {
+            .then(
+              expectEvents({
                 type: 'ListingRemoved',
                 data: {
                   propertyId: 'listing_123',
-                  removedAt: new Date('2024-01-16T10:00:00Z'),
                 },
-              },
-            ]);
+              }),
+            );
         });
       });
       "
@@ -457,6 +460,8 @@ describe('spec.ts.ejs', () => {
           initialState,
         });
 
+        const expectEvents = (...events: Array<{ type: string; data: unknown }>) => events as Events[];
+
         it('no questions have been answered yet', () => {
           given([])
             .when({
@@ -470,18 +475,17 @@ describe('spec.ts.ejs', () => {
               metadata: { now: new Date() },
             })
 
-            .then([
-              {
+            .then(
+              expectEvents({
                 type: 'QuestionAnswered',
                 data: {
                   questionnaireId: 'q-001',
                   participantId: 'participant-abc',
                   questionId: 'q1',
                   answer: 'Yes',
-                  savedAt: new Date('2030-01-01T09:05:00.000Z'),
                 },
-              },
-            ]);
+              }),
+            );
         });
 
         it('all questions have already been answered and submitted', () => {
@@ -506,17 +510,15 @@ describe('spec.ts.ejs', () => {
               metadata: { now: new Date() },
             })
 
-            .then([
-              {
+            .then(
+              expectEvents({
                 type: 'QuestionnaireEditRejected',
                 data: {
                   questionnaireId: 'q-001',
                   participantId: 'participant-abc',
-                  reason: 'Questionnaire already submitted',
-                  attemptedAt: new Date('2030-01-01T09:05:00.000Z'),
                 },
-              },
-            ]);
+              }),
+            );
         });
       });
       "
@@ -721,6 +723,8 @@ describe('spec.ts.ejs', () => {
           initialState,
         });
 
+        const expectEvents = (...events: Array<{ type: string; data: unknown }>) => events as Events[];
+
         it('Workout submitted updates stats', () => {
           given([])
             .when({
@@ -732,22 +736,22 @@ describe('spec.ts.ejs', () => {
               metadata: { now: new Date() },
             })
 
-            .then([
-              {
-                type: 'StatsUpdated',
-                data: {
-                  workoutId: 'w1',
-                  count: 1,
+            .then(
+              expectEvents(
+                {
+                  type: 'StatsUpdated',
+                  data: {
+                    workoutId: 'w1',
+                  },
                 },
-              },
-              {
-                type: 'WorkoutLogged',
-                data: {
-                  workoutId: 'w1',
-                  loggedAt: new Date('2024-01-01T00:00:00Z'),
+                {
+                  type: 'WorkoutLogged',
+                  data: {
+                    workoutId: 'w1',
+                  },
                 },
-              },
-            ]);
+              ),
+            );
         });
       });
       "
@@ -1128,4 +1132,259 @@ describe('spec.ts.ejs', () => {
     expect(specFile?.contents).not.toContain("new Date('2024-01-20')");
     expect(specFile?.contents).not.toContain("new Date('2024-06-30')");
   });
+
+  it('should omit non-command fields from Then assertions (Emmett subset matching)', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Fitness flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'Log workout',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log workout',
+                    rules: [
+                      {
+                        name: 'Should log workout',
+                        examples: [
+                          {
+                            name: 'Workout logged successfully',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: {
+                                  memberId: 'mem_001',
+                                  date: '2024-01-15',
+                                  exercises: ['bench press'],
+                                },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutLogged',
+                                docString: {
+                                  workoutId: 'wkt_456',
+                                  memberId: 'mem_001',
+                                  date: '2024-01-15',
+                                  exercises: ['bench press'],
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'LogWorkout',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+            { name: 'exercises', type: 'string[]', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'WorkoutLogged',
+          source: 'internal',
+          fields: [
+            { name: 'workoutId', type: 'string', required: true },
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+            { name: 'exercises', type: 'string[]', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
+
+    expect(specFile?.contents).not.toContain('workoutId:');
+    expect(specFile?.contents).toContain("memberId: 'mem_001'");
+    expect(specFile?.contents).toContain("date: '2024-01-15'");
+    expect(specFile?.contents).toContain("exercises: ['bench press']");
+    expect(specFile?.contents).toContain('const expectEvents');
+    expect(specFile?.contents).toContain('events as Events[]');
+    expect(specFile?.contents).toContain('.then(\n');
+    expect(specFile?.contents).toContain('expectEvents(');
+  });
+
+  it('should keep non-command fields whose key+value match a Given event', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Subscription flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'Renew subscription',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Renew subscription',
+                    rules: [
+                      {
+                        name: 'Should renew',
+                        examples: [
+                          {
+                            name: 'Renewal preserves total points from state',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'SubscriptionCreated',
+                                docString: { subId: 's1', totalPoints: 100 },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'RenewSubscription',
+                                docString: { subId: 's1' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'SubscriptionRenewed',
+                                docString: { subId: 's1', totalPoints: 100 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'RenewSubscription',
+          fields: [{ name: 'subId', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'SubscriptionCreated',
+          source: 'internal',
+          fields: [
+            { name: 'subId', type: 'string', required: true },
+            { name: 'totalPoints', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'SubscriptionRenewed',
+          source: 'internal',
+          fields: [
+            { name: 'subId', type: 'string', required: true },
+            { name: 'totalPoints', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
+
+    expect(specFile?.contents).toContain('totalPoints: 100');
+  });
+
+  it('should list non-command fields in decide scaffold comments', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Fitness flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'Log workout',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log workout',
+                    rules: [
+                      {
+                        name: 'Should log workout',
+                        examples: [
+                          {
+                            name: 'Workout logged successfully',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutLogged',
+                                docString: { workoutId: 'wkt_456', memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'LogWorkout',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'WorkoutLogged',
+          source: 'internal',
+          fields: [
+            { name: 'workoutId', type: 'string', required: true },
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const decideFile = plans.find((p) => p.outputPath.endsWith('decide.ts'));
+
+    expect(decideFile?.contents).toContain('REQUIRED: Your return value MUST include ALL fields');
+    expect(decideFile?.contents).toContain('Do NOT use');
+    expect(decideFile?.contents).toContain('Fields NOT in command input');
+    expect(decideFile?.contents).toContain('workoutId: string');
+    expect(decideFile?.contents).toContain('...command.data');
+    expect(decideFile?.contents).not.toContain('`NotFoundError`');
+  });
 });

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

@@ -97,8 +97,8 @@ 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
+      * - 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);
           }
@@ -230,8 +232,8 @@ 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
+      * - 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);
           }
@@ -383,8 +393,8 @@ 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
+      * - 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);
           }
@@ -581,8 +593,8 @@ describe('decide.ts.ejs', () => {
       * - Validate the command input fields
       * - 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/src/codegen/templates/command/decide.specs.ts.ejs

@@ -54,29 +54,50 @@ for (const [importPath, eventTypes] of testEventsByPath.entries()) {
 
 const uniqueEventTypes = Array.from(new Set(allEvents.map(e => e?.type).filter(Boolean))).sort();
 
-function findDerivedDateValue(eventResults, commandSchema, givenEvents) {
-    const commandFields = new Set(commandSchema?.fields?.map(f => f.name) || []);
+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 candidates = new Set();
+    const fieldsByDate = new Map();
     for (const e of eventResults) {
-        const data = e.exampleData || {};
-        for (const [key, val] of Object.entries(data)) {
+        for (const [key, val] of Object.entries(e.exampleData || {})) {
             if (
-                !commandFields.has(key) &&
+                !commandFieldNames.has(key) &&
                 typeof val === 'string' &&
                 /^\d{4}-\d{2}-\d{2}$/.test(val) &&
                 !givenValues.has(val)
             ) {
-                candidates.add(val);
+                if (!fieldsByDate.has(val)) fieldsByDate.set(val, []);
+                fieldsByDate.get(val).push(key);
             }
         }
     }
-    return candidates.size === 1 ? [...candidates][0] : null;
+    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';
@@ -99,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;
@@ -122,19 +146,28 @@ describe('<%= ruleDescription %>', () => {
       .when({
         type: '<%= example.commandRef %>',
         data: <%- formatDataObject(example.exampleData, schema) %>,
-<%  const derivedDate = findDerivedDateValue(eventResults, schema, gwt.given); -%>
+<%  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        ') %>
+      ));
 <% } %>
   });
 <% } %>