@auto-engineer/server-generator-apollo-emmett 1.146.0 → 1.148.0

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

@@ -1388,6 +1388,668 @@ describe('spec.ts.ejs', () => {
     expect(decideFile?.contents).not.toContain('`NotFoundError`');
   });
 
+  it('should omit state-based Given refs from given() array', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Fitness scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'Log workout',
+              stream: 'workout',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log workout',
+                    rules: [
+                      {
+                        name: 'Should log workout',
+                        examples: [
+                          {
+                            name: 'Workout logged from draft state',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'WorkoutDraft',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutLogged',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'WorkoutDraft',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+          ],
+        },
+        {
+          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: 'memberId', type: 'string', required: true },
+            { name: 'date', 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 ?? '';
+
+    expect(contents).toContain('given([])');
+    expect(contents).not.toContain('WorkoutDraft');
+  });
+
+  it('should keep event Given refs and omit state Given refs when mixed', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Fitness scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'Log workout',
+              stream: 'workout',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log workout',
+                    rules: [
+                      {
+                        name: 'Should log workout',
+                        examples: [
+                          {
+                            name: 'Workout logged with prior event and draft state',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'OrderPlaced',
+                                docString: { orderId: 'o1' },
+                              },
+                              {
+                                keyword: 'Given',
+                                text: 'WorkoutDraft',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutLogged',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'event',
+          name: 'OrderPlaced',
+          source: 'internal',
+          fields: [{ name: 'orderId', type: 'string', required: true }],
+        },
+        {
+          type: 'state',
+          name: 'WorkoutDraft',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+          ],
+        },
+        {
+          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: 'memberId', type: 'string', required: true },
+            { name: 'date', 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 ?? '';
+
+    expect(contents).toContain("type: 'OrderPlaced'");
+    expect(contents).not.toContain('WorkoutDraft');
+  });
+
+  it('should generate "directly emit" instructions in decide.ts when Given has only state refs', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Fitness scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'Log workout',
+              stream: 'workout',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log workout',
+                    rules: [
+                      {
+                        name: 'Should log workout',
+                        examples: [
+                          {
+                            name: 'Workout logged from draft state',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'WorkoutDraft',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutLogged',
+                                docString: { memberId: 'mem_001', date: '2024-01-15' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'WorkoutDraft',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+          ],
+        },
+        {
+          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: 'memberId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const decideFile = plans.find((p) => p.outputPath.endsWith('decide.ts'));
+    const contents = decideFile?.contents ?? '';
+
+    expect(contents).toContain('can directly emit');
+    expect(contents).not.toContain('requires evaluating prior state');
+    expect(contents).not.toContain('Inspect the current domain');
+    expect(contents).not.toContain('If State is a discriminated union');
+  });
+
+  it('should generate state-narrowing instructions in decide.ts when Given has event refs', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Guest removes a listing',
+          moments: [
+            {
+              type: 'command',
+              name: 'Remove listing',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Remove listing spec',
+                    rules: [
+                      {
+                        name: 'Should remove existing listing',
+                        examples: [
+                          {
+                            name: 'Existing listing can be removed',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'ListingCreated',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                  listedAt: '2024-01-15T10:00:00Z',
+                                  rating: 4.8,
+                                  metadata: { foo: 'bar' },
+                                },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'RemoveListing',
+                                docString: { propertyId: 'listing_123' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'ListingRemoved',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                  removedAt: '2024-01-16T10:00:00Z',
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'RemoveListing',
+          fields: [{ name: 'propertyId', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'ListingCreated',
+          source: 'internal',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'listedAt', type: 'Date', required: true },
+            { name: 'rating', type: 'number', required: true },
+            { name: 'metadata', type: 'object', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'ListingRemoved',
+          source: 'internal',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'removedAt', type: 'Date', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const decideFile = plans.find((p) => p.outputPath.endsWith('decide.ts'));
+    const contents = decideFile?.contents ?? '';
+
+    expect(contents).toContain('requires evaluating prior state');
+    expect(contents).toContain('Inspect the current domain');
+    expect(contents).toContain('If State is a discriminated union');
+    expect(contents).not.toContain('can directly emit');
+  });
+
+  it('should include "do not narrow state" instruction when Given has only state refs', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Profile scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'Update profile',
+              stream: 'profile',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Update profile',
+                    rules: [
+                      {
+                        name: 'Should update profile',
+                        examples: [
+                          {
+                            name: 'Profile updated from created state',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'CreatedProfile',
+                                docString: { userId: 'u1', status: 'created' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'UpdateProfile',
+                                docString: { userId: 'u1', displayName: 'Alice' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'ProfileUpdated',
+                                docString: { userId: 'u1', displayName: 'Alice' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'CreatedProfile',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'status', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'UpdateProfile',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'displayName', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'ProfileUpdated',
+          source: 'internal',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'displayName', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const decideFile = plans.find((p) => p.outputPath.endsWith('decide.ts'));
+    const contents = decideFile?.contents ?? '';
+
+    expect(contents).toContain('Do not narrow or guard on _state');
+    expect(contents).not.toContain('Inspect the current domain');
+    expect(contents).not.toContain('If State is a discriminated union');
+  });
+
+  it('should generate date and untested-field instructions for nonCommandFields with state-only Given', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Session scene',
+          moments: [
+            {
+              type: 'command',
+              name: 'Complete session',
+              stream: 'session',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Complete session',
+                    rules: [
+                      {
+                        name: 'Should complete session',
+                        examples: [
+                          {
+                            name: 'Session completed',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'ActiveSession',
+                                docString: { sessionId: 's1', status: 'active' },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'CompleteSession',
+                                docString: { sessionId: 's1', duration: 30 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'SessionCompleted',
+                                docString: {
+                                  sessionId: 's1',
+                                  userId: 'u1',
+                                  date: '2024-01-01',
+                                  type: 'workout',
+                                  duration: 30,
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'state',
+          name: 'ActiveSession',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'status', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'CompleteSession',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'duration', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'SessionCompleted',
+          source: 'internal',
+          fields: [
+            { name: 'sessionId', type: 'string', required: true },
+            { name: 'userId', type: 'string', required: true },
+            { name: 'date', type: 'string', required: true },
+            { name: 'type', type: 'string', required: true },
+            { name: 'duration', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const decideFile = plans.find((p) => p.outputPath.endsWith('decide.ts'));
+    const contents = decideFile?.contents ?? '';
+
+    expect(contents).toContain('date: string — derive from command.metadata?.now');
+    expect(contents).toContain('userId: string — not asserted by test');
+    expect(contents).toContain('type: string — not asserted by test');
+  });
+
+  it('should keep generic _state instruction for nonCommandFields when Given has event refs', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      scenes: [
+        {
+          name: 'Host removes a listing',
+          moments: [
+            {
+              type: 'command',
+              name: 'Remove listing',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Remove listing command',
+                    rules: [
+                      {
+                        name: 'Should remove existing listing',
+                        examples: [
+                          {
+                            name: 'Existing listing can be removed',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'ListingCreated',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                  listedAt: '2024-01-15T10:00:00Z',
+                                },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'RemoveListing',
+                                docString: { propertyId: 'listing_123' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'ListingRemoved',
+                                docString: {
+                                  propertyId: 'listing_123',
+                                  removedAt: '2024-01-16',
+                                  removedBy: 'host_abc',
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'RemoveListing',
+          fields: [{ name: 'propertyId', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'ListingCreated',
+          source: 'internal',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'listedAt', type: 'Date', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'ListingRemoved',
+          source: 'internal',
+          fields: [
+            { name: 'propertyId', type: 'string', required: true },
+            { name: 'removedAt', type: 'string', required: true },
+            { name: 'removedBy', type: 'string', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.scenes, spec.messages, undefined, 'src/domain/narratives');
+    const decideFile = plans.find((p) => p.outputPath.endsWith('decide.ts'));
+    const contents = decideFile?.contents ?? '';
+
+    expect(contents).toContain('removedAt: string — derive from command.metadata?.now');
+    expect(contents).toContain('removedBy: string — derive from _state');
+    expect(contents).not.toContain('Do not narrow');
+  });
+
   it('should not include "valid" qualifier in fallback test description', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',