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

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

@@ -248,7 +248,7 @@ describe('spec.ts.ejs', () => {
     const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
 
     expect(specFile?.contents).toMatchInlineSnapshot(`
-      "import { describe, it } from 'vitest';
+      "import { describe, expect, it } from 'vitest';
       import { DeciderSpecification } from '@event-driven-io/emmett';
       import { decide } from './decide';
       import { evolve } from './evolve';
@@ -297,6 +297,41 @@ describe('spec.ts.ejs', () => {
             );
         });
       });
+
+      describe('field completeness', () => {
+        it('should include all required fields in ListingRemoved', () => {
+          const state = [
+            {
+              type: 'ListingCreated' as const,
+              data: {
+                propertyId: 'listing_123',
+                listedAt: new Date('2024-01-15T10:00:00Z'),
+                rating: 4.8,
+                metadata: { foo: 'bar' },
+              },
+            },
+          ].reduce((s, e) => evolve(s, e), initialState());
+          const result = decide(
+            {
+              type: 'RemoveListing',
+              data: {
+                propertyId: 'listing_123',
+              },
+              metadata: { now: new Date() },
+            },
+            state,
+          );
+          const evtArray = Array.isArray(result) ? result : [result];
+
+          expect(evtArray[0]).toMatchObject({
+            type: 'ListingRemoved',
+            data: expect.objectContaining({
+              propertyId: expect.any(String),
+              removedAt: expect.any(Date),
+            }),
+          });
+        });
+      });
       "
     `);
   });
@@ -443,7 +478,7 @@ describe('spec.ts.ejs', () => {
     const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
 
     expect(specFile?.contents).toMatchInlineSnapshot(`
-      "import { describe, it } from 'vitest';
+      "import { describe, expect, it } from 'vitest';
       import { DeciderSpecification } from '@event-driven-io/emmett';
       import { decide } from './decide';
       import { evolve } from './evolve';
@@ -521,6 +556,47 @@ describe('spec.ts.ejs', () => {
             );
         });
       });
+
+      describe('field completeness', () => {
+        it('should include all required fields in QuestionAnswered, QuestionnaireEditRejected', () => {
+          const state = initialState();
+          const result = decide(
+            {
+              type: 'AnswerQuestion',
+              data: {
+                questionnaireId: 'q-001',
+                participantId: 'participant-abc',
+                questionId: 'q1',
+                answer: 'Yes',
+              },
+              metadata: { now: new Date() },
+            },
+            state,
+          );
+          const evtArray = Array.isArray(result) ? result : [result];
+
+          expect(evtArray[0]).toMatchObject({
+            type: 'QuestionAnswered',
+            data: expect.objectContaining({
+              questionnaireId: expect.any(String),
+              participantId: expect.any(String),
+              questionId: expect.any(String),
+              answer: expect.any(Object),
+              savedAt: expect.any(Date),
+            }),
+          });
+
+          expect(evtArray[1]).toMatchObject({
+            type: 'QuestionnaireEditRejected',
+            data: expect.objectContaining({
+              questionnaireId: expect.any(String),
+              participantId: expect.any(String),
+              reason: expect.any(String),
+              attemptedAt: expect.any(Date),
+            }),
+          });
+        });
+      });
       "
     `);
   });
@@ -706,7 +782,7 @@ describe('spec.ts.ejs', () => {
     const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
 
     expect(specFile?.contents).toMatchInlineSnapshot(`
-      "import { describe, it } from 'vitest';
+      "import { describe, expect, it } from 'vitest';
       import { DeciderSpecification } from '@event-driven-io/emmett';
       import { decide } from './decide';
       import { evolve } from './evolve';
@@ -754,6 +830,40 @@ describe('spec.ts.ejs', () => {
             );
         });
       });
+
+      describe('field completeness', () => {
+        it('should include all required fields in StatsUpdated, WorkoutLogged', () => {
+          const state = initialState();
+          const result = decide(
+            {
+              type: 'SubmitWorkout',
+              data: {
+                workoutId: 'w1',
+                exercise: 'squat',
+              },
+              metadata: { now: new Date() },
+            },
+            state,
+          );
+          const evtArray = Array.isArray(result) ? result : [result];
+
+          expect(evtArray[0]).toMatchObject({
+            type: 'StatsUpdated',
+            data: expect.objectContaining({
+              workoutId: expect.any(String),
+              count: expect.any(Number),
+            }),
+          });
+
+          expect(evtArray[1]).toMatchObject({
+            type: 'WorkoutLogged',
+            data: expect.objectContaining({
+              workoutId: expect.any(String),
+              loggedAt: expect.any(Date),
+            }),
+          });
+        });
+      });
       "
     `);
   });
@@ -1215,14 +1325,19 @@ describe('spec.ts.ejs', () => {
     const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
     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(');
+    const contents = specFile?.contents ?? '';
+    // workoutId should NOT appear in the DeciderSpecification expectEvents block
+    const deciderSection = contents.split("describe('field completeness'")[0];
+    expect(deciderSection).not.toContain('workoutId:');
+    expect(contents).toContain("memberId: 'mem_001'");
+    expect(contents).toContain("date: '2024-01-15'");
+    expect(contents).toContain("exercises: ['bench press']");
+    expect(contents).toContain('const expectEvents');
+    expect(contents).toContain('events as Events[]');
+    expect(contents).toContain('.then(\n');
+    expect(contents).toContain('expectEvents(');
+    // workoutId is not traceable to any Given event, so uses expect.any()
+    expect(contents).toContain('workoutId: expect.any(String)');
   });
 
   it('should keep non-command fields whose key+value match a Given event', async () => {
@@ -1388,6 +1503,166 @@ describe('spec.ts.ejs', () => {
     expect(decideFile?.contents).not.toContain('`NotFoundError`');
   });
 
+  it('should exclude state-only-traceable fields from main test then block', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Exercise scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'Log exercise',
+              stream: 'exercise',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log exercise',
+                    rules: [
+                      {
+                        name: 'Should log exercise',
+                        examples: [
+                          {
+                            name: 'Exercise logged from draft',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'ExerciseDraft',
+                                docString: { id: 'e1', userId: 'u1' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'LogExercise',
+                                docString: { sets: 3, reps: 10 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'ExerciseLogged',
+                                docString: { id: 'e1', userId: 'u1', sets: 3, reps: 10 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'ExerciseDraft',
+          fields: [
+            { name: 'id', type: 'string', required: true },
+            { name: 'userId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'LogExercise',
+          fields: [
+            { name: 'sets', type: 'number', required: true },
+            { name: 'reps', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'ExerciseLogged',
+          source: 'internal',
+          fields: [
+            { name: 'id', type: 'string', required: true },
+            { name: 'userId', type: 'string', required: true },
+            { name: 'sets', type: 'number', required: true },
+            { name: 'reps', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
+
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+      "import { describe, expect, it } from 'vitest';
+      import { DeciderSpecification } from '@event-driven-io/emmett';
+      import { decide } from './decide';
+      import { evolve } from './evolve';
+      import { initialState, State } from './state';
+      import type { ExerciseLogged } from './events';
+      import type { LogExercise } from './commands';
+
+      describe('Should log exercise', () => {
+        type Events = ExerciseLogged;
+
+        const given = DeciderSpecification.for<LogExercise, Events, State>({
+          decide,
+          evolve,
+          initialState,
+        });
+
+        const expectEvents = (...events: Array<{ type: string; data: unknown }>) => events as Events[];
+
+        it('Exercise logged from draft', () => {
+          given([])
+            .when({
+              type: 'LogExercise',
+              data: {
+                sets: 3,
+                reps: 10,
+              },
+              metadata: { now: new Date() },
+            })
+
+            .then(
+              expectEvents({
+                type: 'ExerciseLogged',
+                data: {
+                  sets: 3,
+                  reps: 10,
+                },
+              }),
+            );
+        });
+      });
+
+      describe('field completeness', () => {
+        it('should include all required fields in ExerciseLogged', () => {
+          const state = initialState();
+          const result = decide(
+            {
+              type: 'LogExercise',
+              data: {
+                sets: 3,
+                reps: 10,
+              },
+              metadata: { now: new Date() },
+            },
+            state,
+          );
+          const evtArray = Array.isArray(result) ? result : [result];
+
+          expect(evtArray[0]).toMatchObject({
+            type: 'ExerciseLogged',
+            data: expect.objectContaining({
+              id: expect.any(String),
+              userId: expect.any(String),
+              sets: expect.any(Number),
+              reps: expect.any(Number),
+            }),
+          });
+        });
+      });
+      "
+    `);
+  });
+
   it('should omit state-based Given refs from given() array', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
@@ -2116,4 +2391,406 @@ describe('spec.ts.ejs', () => {
     expect(specFile?.contents).toContain('should emit OrderPlaced for PlaceOrder');
     expect(specFile?.contents).not.toContain('for valid');
   });
+
+  it('should generate field completeness assertion for nonCommandFields', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Booking scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'Request booking',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Request booking spec',
+                    rules: [
+                      {
+                        name: 'Booking can be requested',
+                        examples: [
+                          {
+                            name: 'Guest requests a booking',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'RequestBooking',
+                                docString: { listingId: 'l1', guestId: 'g1', nights: 3 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'BookingRequested',
+                                docString: {
+                                  listingId: 'l1',
+                                  guestId: 'g1',
+                                  nights: 3,
+                                  bookingId: 'b1',
+                                  totalPrice: 750,
+                                  status: 'pending',
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'RequestBooking',
+          fields: [
+            { name: 'listingId', type: 'string', required: true },
+            { name: 'guestId', type: 'string', required: true },
+            { name: 'nights', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'BookingRequested',
+          source: 'internal',
+          fields: [
+            { name: 'listingId', type: 'string', required: true },
+            { name: 'guestId', type: 'string', required: true },
+            { name: 'nights', type: 'number', required: true },
+            { name: 'bookingId', type: 'string', required: true },
+            { name: 'totalPrice', type: 'number', required: true },
+            { name: 'status', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
+    const contents = specFile?.contents ?? '';
+
+    // Should include expect in vitest import
+    expect(contents).toContain("import { describe, expect, it } from 'vitest'");
+
+    // Should generate field completeness block
+    expect(contents).toContain('expect.objectContaining');
+
+    // Command fields use expect.any(Constructor)
+    expect(contents).toContain('listingId: expect.any(String)');
+    expect(contents).toContain('guestId: expect.any(String)');
+    expect(contents).toContain('nights: expect.any(Number)');
+
+    // NonCommandFields without Given-event traceability use expect.any()
+    expect(contents).toContain('bookingId: expect.any(String)');
+    expect(contents).toContain('totalPrice: expect.any(Number)');
+    expect(contents).toContain('status: expect.any(String)');
+  });
+
+  it('should not generate field completeness block when all event fields are command fields', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Simple scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'Rename item',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Rename item spec',
+                    rules: [
+                      {
+                        name: 'Item can be renamed',
+                        examples: [
+                          {
+                            name: 'Rename succeeds',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'RenameItem',
+                                docString: { itemId: 'i1', newName: 'Widget' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'ItemRenamed',
+                                docString: { itemId: 'i1', newName: 'Widget' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'RenameItem',
+          fields: [
+            { name: 'itemId', type: 'string', required: true },
+            { name: 'newName', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'ItemRenamed',
+          source: 'internal',
+          fields: [
+            { name: 'itemId', type: 'string', required: true },
+            { name: 'newName', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
+    const contents = specFile?.contents ?? '';
+
+    // Should NOT generate field completeness block
+    expect(contents).not.toContain('expect.objectContaining');
+    expect(contents).not.toContain('expect.any');
+    // Should still use plain import without expect
+    expect(contents).toContain("import { describe, it } from 'vitest'");
+  });
+
+  it('should not duplicate field completeness assertions when multiple examples produce the same event type', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Booking scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'Book appointment',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Book appointment spec',
+                    rules: [
+                      {
+                        name: 'Appointment can be booked',
+                        examples: [
+                          {
+                            name: 'Successful booking',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'AppointmentDrafted',
+                                docString: { appointmentId: 'apt1', status: 'draft' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'BookAppointment',
+                                docString: { appointmentId: 'apt1', barberId: 'barb1' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'AppointmentBooked',
+                                docString: { appointmentId: 'apt1', barberId: 'barb1', status: 'booked' },
+                              },
+                            ],
+                          },
+                          {
+                            name: 'Draft already submitted',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'AppointmentDrafted',
+                                docString: { appointmentId: 'apt1', status: 'submitted' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'BookAppointment',
+                                docString: { appointmentId: 'apt1', barberId: 'barb1' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'AppointmentBooked',
+                                docString: { appointmentId: 'apt1', barberId: 'barb1', status: 'booked' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'BookAppointment',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'AppointmentBooked',
+          source: 'internal',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'barberId', type: 'string', required: true },
+            { name: 'status', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'AppointmentDrafted',
+          source: 'internal',
+          fields: [
+            { name: 'appointmentId', type: 'string', required: true },
+            { name: 'status', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
+
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+      "import { describe, expect, it } from 'vitest';
+      import { DeciderSpecification } from '@event-driven-io/emmett';
+      import { decide } from './decide';
+      import { evolve } from './evolve';
+      import { initialState, State } from './state';
+      import type { AppointmentBooked, AppointmentDrafted } from './events';
+      import type { BookAppointment } from './commands';
+
+      describe('Appointment can be booked', () => {
+        type Events = AppointmentBooked | AppointmentDrafted;
+
+        const given = DeciderSpecification.for<BookAppointment, Events, State>({
+          decide,
+          evolve,
+          initialState,
+        });
+
+        const expectEvents = (...events: Array<{ type: string; data: unknown }>) => events as Events[];
+
+        it('Successful booking', () => {
+          given([
+            {
+              type: 'AppointmentDrafted',
+              data: {
+                appointmentId: 'apt1',
+                status: 'draft',
+              },
+            },
+          ])
+            .when({
+              type: 'BookAppointment',
+              data: {
+                appointmentId: 'apt1',
+                barberId: 'barb1',
+              },
+              metadata: { now: new Date() },
+            })
+
+            .then(
+              expectEvents({
+                type: 'AppointmentBooked',
+                data: {
+                  appointmentId: 'apt1',
+                  barberId: 'barb1',
+                },
+              }),
+            );
+        });
+
+        it('Draft already submitted', () => {
+          given([
+            {
+              type: 'AppointmentDrafted',
+              data: {
+                appointmentId: 'apt1',
+                status: 'submitted',
+              },
+            },
+          ])
+            .when({
+              type: 'BookAppointment',
+              data: {
+                appointmentId: 'apt1',
+                barberId: 'barb1',
+              },
+              metadata: { now: new Date() },
+            })
+
+            .then(
+              expectEvents({
+                type: 'AppointmentBooked',
+                data: {
+                  appointmentId: 'apt1',
+                  barberId: 'barb1',
+                },
+              }),
+            );
+        });
+      });
+
+      describe('field completeness', () => {
+        it('should include all required fields in AppointmentBooked', () => {
+          const state = [
+            {
+              type: 'AppointmentDrafted' as const,
+              data: {
+                appointmentId: 'apt1',
+                status: 'draft',
+              },
+            },
+          ].reduce((s, e) => evolve(s, e), initialState());
+          const result = decide(
+            {
+              type: 'BookAppointment',
+              data: {
+                appointmentId: 'apt1',
+                barberId: 'barb1',
+              },
+              metadata: { now: new Date() },
+            },
+            state,
+          );
+          const evtArray = Array.isArray(result) ? result : [result];
+
+          expect(evtArray[0]).toMatchObject({
+            type: 'AppointmentBooked',
+            data: expect.objectContaining({
+              appointmentId: expect.any(String),
+              barberId: expect.any(String),
+              status: expect.any(String),
+            }),
+          });
+        });
+      });
+      "
+    `);
+  });
 });