@auto-engineer/server-generator-apollo-emmett 0.10.4 → 0.10.5

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

@@ -99,16 +99,20 @@ describe('spec.ts.ejs', () => {
           import { DeciderSpecification } from '@event-driven-io/emmett';
           import { decide } from './decide';
           import { evolve } from './evolve';
-          import { initialState } from './state';
+          import { initialState, State } from './state';
+          import type { ListingCreated } from './events';
+          import type { CreateListing } from './commands';
 
-          describe('Host creates a listing | Create listing', () => {
-            const given = DeciderSpecification.for({
+          describe('Should create listing successfully', () => {
+            type Events = ListingCreated;
+
+            const given = DeciderSpecification.for<CreateListing, Events, State>({
               decide,
               evolve,
               initialState,
             });
 
-            it('should emit ListingCreated for valid CreateListing', () => {
+            it('User creates listing with valid data', () => {
               given([])
                 .when({
                   type: 'CreateListing',
@@ -237,16 +241,20 @@ describe('spec.ts.ejs', () => {
       import { DeciderSpecification } from '@event-driven-io/emmett';
       import { decide } from './decide';
       import { evolve } from './evolve';
-      import { initialState } from './state';
+      import { initialState, State } from './state';
+      import type { ListingCreated, ListingRemoved } from './events';
+      import type { RemoveListing } from './commands';
+
+      describe('Should remove existing listing', () => {
+        type Events = ListingCreated | ListingRemoved;
 
-      describe('Guest removes a listing | Remove listing', () => {
-        const given = DeciderSpecification.for({
+        const given = DeciderSpecification.for<RemoveListing, Events, State>({
           decide,
           evolve,
           initialState,
         });
 
-        it('should emit ListingRemoved for valid RemoveListing', () => {
+        it('Existing listing can be removed', () => {
           given([
             {
               type: 'ListingCreated',
@@ -280,4 +288,223 @@ describe('spec.ts.ejs', () => {
       "
     `);
   });
+
+  it('should generate separate tests for multiple examples with different scenarios', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      flows: [
+        {
+          name: 'Questionnaires',
+          slices: [
+            {
+              type: 'command',
+              name: 'submits a questionnaire answer',
+              client: { description: '' },
+              server: {
+                description: '',
+                specs: {
+                  name: 'Answer question spec',
+                  rules: [
+                    {
+                      description: 'answers are allowed while the questionnaire has not been submitted',
+                      examples: [
+                        {
+                          description: 'no questions have been answered yet',
+                          when: {
+                            commandRef: 'AnswerQuestion',
+                            exampleData: {
+                              questionnaireId: 'q-001',
+                              participantId: 'participant-abc',
+                              questionId: 'q1',
+                              answer: 'Yes',
+                            },
+                          },
+                          then: [
+                            {
+                              eventRef: 'QuestionAnswered',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                participantId: 'participant-abc',
+                                questionId: 'q1',
+                                answer: 'Yes',
+                                savedAt: '2030-01-01T09:05:00.000Z',
+                              },
+                            },
+                          ],
+                        },
+                        {
+                          description: 'all questions have already been answered and submitted',
+                          given: [
+                            {
+                              eventRef: 'QuestionnaireSubmitted',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                participantId: 'participant-abc',
+                                submittedAt: '2030-01-01T09:00:00.000Z',
+                              },
+                            },
+                          ],
+                          when: {
+                            commandRef: 'AnswerQuestion',
+                            exampleData: {
+                              questionnaireId: 'q-001',
+                              participantId: 'participant-abc',
+                              questionId: 'q1',
+                              answer: 'Yes',
+                            },
+                          },
+                          then: [
+                            {
+                              eventRef: 'QuestionnaireEditRejected',
+                              exampleData: {
+                                questionnaireId: 'q-001',
+                                participantId: 'participant-abc',
+                                reason: 'Questionnaire already submitted',
+                                attemptedAt: '2030-01-01T09:05:00.000Z',
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'AnswerQuestion',
+          fields: [
+            { name: 'questionnaireId', type: 'string', required: true },
+            { name: 'participantId', type: 'string', required: true },
+            { name: 'questionId', type: 'string', required: true },
+            { name: 'answer', type: 'unknown', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'QuestionAnswered',
+          source: 'internal',
+          fields: [
+            { name: 'questionnaireId', type: 'string', required: true },
+            { name: 'participantId', type: 'string', required: true },
+            { name: 'questionId', type: 'string', required: true },
+            { name: 'answer', type: 'unknown', required: true },
+            { name: 'savedAt', type: 'Date', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'QuestionnaireSubmitted',
+          source: 'internal',
+          fields: [
+            { name: 'questionnaireId', type: 'string', required: true },
+            { name: 'participantId', type: 'string', required: true },
+            { name: 'submittedAt', type: 'Date', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'QuestionnaireEditRejected',
+          source: 'internal',
+          fields: [
+            { name: 'questionnaireId', type: 'string', required: true },
+            { name: 'participantId', type: 'string', required: true },
+            { name: 'reason', type: 'string', required: true },
+            { name: 'attemptedAt', type: 'Date', required: true },
+          ],
+        },
+      ],
+    };
+
+    const plans = await generateScaffoldFilePlans(spec.flows, spec.messages, undefined, 'src/domain/flows');
+    const specFile = plans.find((p) => p.outputPath.endsWith('specs.ts'));
+
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+      "import { describe, 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 { QuestionAnswered, QuestionnaireEditRejected, QuestionnaireSubmitted } from './events';
+      import type { AnswerQuestion } from './commands';
+
+      describe('answers are allowed while the questionnaire has not been submitted', () => {
+        type Events = QuestionAnswered | QuestionnaireEditRejected | QuestionnaireSubmitted;
+
+        const given = DeciderSpecification.for<AnswerQuestion, Events, State>({
+          decide,
+          evolve,
+          initialState,
+        });
+
+        it('no questions have been answered yet', () => {
+          given([])
+            .when({
+              type: 'AnswerQuestion',
+              data: {
+                questionnaireId: 'q-001',
+                participantId: 'participant-abc',
+                questionId: 'q1',
+                answer: 'Yes',
+              },
+              metadata: { now: new Date() },
+            })
+
+            .then([
+              {
+                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', () => {
+          given([
+            {
+              type: 'QuestionnaireSubmitted',
+              data: {
+                questionnaireId: 'q-001',
+                participantId: 'participant-abc',
+                submittedAt: new Date('2030-01-01T09:00:00.000Z'),
+              },
+            },
+          ])
+            .when({
+              type: 'AnswerQuestion',
+              data: {
+                questionnaireId: 'q-001',
+                participantId: 'participant-abc',
+                questionId: 'q1',
+                answer: 'Yes',
+              },
+              metadata: { now: new Date() },
+            })
+
+            .then([
+              {
+                type: 'QuestionnaireEditRejected',
+                data: {
+                  questionnaireId: 'q-001',
+                  participantId: 'participant-abc',
+                  reason: 'Questionnaire already submitted',
+                  attemptedAt: new Date('2030-01-01T09:05:00.000Z'),
+                },
+              },
+            ]);
+        });
+      });
+      "
+    `);
+  });
 });

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

@@ -81,7 +81,7 @@ describe('decide.ts.ejs', () => {
       import type { CreateListing } from './commands';
       import type { ListingCreated } from './events';
 
-      export const decide = (command: CreateListing, state: State): ListingCreated => {
+      export const decide = (command: CreateListing, _state: State): ListingCreated => {
         switch (command.type) {
           case 'CreateListing': {
             /**
@@ -106,7 +106,7 @@ describe('decide.ts.ejs', () => {
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
           default:
-            throw new IllegalStateError('Unexpected command type: ' + command.type);
+            throw new IllegalStateError(\`Unexpected command type: \${String(command.type)}\`);
         }
       };
       "
@@ -206,7 +206,7 @@ describe('decide.ts.ejs', () => {
       import type { RemoveListing } from './commands';
       import type { ListingRemoved } from './events';
 
-      export const decide = (command: RemoveListing, state: State): ListingRemoved => {
+      export const decide = (command: RemoveListing, _state: State): ListingRemoved => {
         switch (command.type) {
           case 'RemoveListing': {
             /**
@@ -231,7 +231,7 @@ describe('decide.ts.ejs', () => {
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
           default:
-            throw new IllegalStateError('Unexpected command type: ' + command.type);
+            throw new IllegalStateError(\`Unexpected command type: \${String(command.type)}\`);
         }
       };
       "
@@ -346,7 +346,7 @@ describe('decide.ts.ejs', () => {
       import type { CreateListing } from './commands';
       import type { ListingCreated } from './events';
 
-      export const decide = (command: CreateListing, state: State): ListingCreated => {
+      export const decide = (command: CreateListing, _state: State): ListingCreated => {
         switch (command.type) {
           case 'CreateListing': {
             /**
@@ -375,7 +375,7 @@ describe('decide.ts.ejs', () => {
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
           default:
-            throw new IllegalStateError('Unexpected command type: ' + command.type);
+            throw new IllegalStateError(\`Unexpected command type: \${String(command.type)}\`);
         }
       };
       "
@@ -532,7 +532,7 @@ describe('decide.ts.ejs', () => {
       import type { ItemsSuggested } from './events';
       import type { Products } from '@auto-engineer/product-catalogue-integration';
 
-      export const decide = (command: SuggestItems, state: State, products?: Products): ItemsSuggested => {
+      export const decide = (command: SuggestItems, _state: State, products?: Products): ItemsSuggested => {
         switch (command.type) {
           case 'SuggestItems': {
             /**
@@ -566,7 +566,7 @@ describe('decide.ts.ejs', () => {
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
           default:
-            throw new IllegalStateError('Unexpected command type: ' + command.type);
+            throw new IllegalStateError(\`Unexpected command type: \${String(command.type)}\`);
         }
       };
       "

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

@@ -1,51 +1,116 @@
+<%
+const allEvents = [];
+const ruleGroups = new Map();
+for (const commandName in gwtMapping) {
+    const cases = gwtMapping[commandName];
+    for (const gwt of cases) {
+        const ruleDescription = gwt.ruleDescription || `${flowName} | ${sliceName}`;
+        if (!ruleGroups.has(ruleDescription)) {
+            ruleGroups.set(ruleDescription, []);
+        }
+        ruleGroups.get(ruleDescription).push({ commandName, gwt });
+        if (gwt.given && gwt.given.length) {
+            for (const g of gwt.given) {
+                if (g.eventRef) {
+                    const event = events.find(e => e.type === g.eventRef);
+                    if (event) allEvents.push(event);
+                }
+            }
+        }
+        if (gwt.then) {
+            for (const t of gwt.then) {
+                if (t.eventRef) {
+                    const event = events.find(e => e.type === t.eventRef);
+                    if (event) allEvents.push(event);
+                }
+            }
+        }
+    }
+}
+
+const testEventImportGroups = [];
+const testEventsByPath = new Map();
+
+for (const event of allEvents) {
+    if (!event.type) continue;
+    const importGroup = eventImportGroups.find(group =>
+        group.eventTypes.includes(event.type)
+    );
+
+    if (importGroup) {
+        const path = importGroup.importPath;
+        if (!testEventsByPath.has(path)) {
+            testEventsByPath.set(path, []);
+        }
+        if (!testEventsByPath.get(path).includes(event.type)) {
+            testEventsByPath.get(path).push(event.type);
+        }
+    }
+}
+
+for (const [importPath, eventTypes] of testEventsByPath.entries()) {
+    testEventImportGroups.push({ importPath, eventTypes: eventTypes.sort() });
+}
+
+const uniqueEventTypes = Array.from(new Set(allEvents.map(e => e?.type).filter(Boolean))).sort();
+_%>
 import { describe, it } from 'vitest';
 import { DeciderSpecification } from '@event-driven-io/emmett';
 import { decide } from './decide';
 import { evolve } from './evolve';
-import { initialState } from './state';
+import { initialState, State } from './state';
+<% for (const group of testEventImportGroups) { -%>
+import type { <%= group.eventTypes.join(', ') %> } from '<%= group.importPath %>';
+<% } -%>
+import type { <%= Object.keys(commandSchemasByName).join(', ') %> } from './commands';
+<% for (const [ruleDescription, ruleGwts] of ruleGroups.entries()) { %>
+describe('<%= ruleDescription %>', () => {
 
-describe('<%= flowName %> | <%= sliceName %>', () => {
-const given = DeciderSpecification.for({
-decide,
-evolve,
-initialState,
-});
+  type Events = <%= uniqueEventTypes.length > 0 ? uniqueEventTypes.join(' | ') : 'never' %>;
 
-<% for (const commandName in gwtMapping) {
-    const cases = gwtMapping[commandName];
+  const given = DeciderSpecification.for<<%= Object.keys(commandSchemasByName).length === 1 ? Object.keys(commandSchemasByName)[0] : `(${Object.keys(commandSchemasByName).join(' | ')})` %>, Events, State>({
+    decide,
+    evolve,
+    initialState,
+  });
+
+<% for (const { commandName, gwt } of ruleGwts) {
     const schema = commandSchemasByName[commandName];
-        for (const [i, gwt] of cases.entries()) {
     const example = gwt.when;
     const eventResults = gwt.then.filter(t => 'eventRef' in t);
     const errorResult = gwt.then.find(t => 'errorType' in t);
-    const testName = errorResult
+
+    const testDescription = gwt.description ||
+        (errorResult
             ? `should throw ${errorResult.errorType} when ${gwt.failingFields?.join(', ') || 'invalid input'}`
-            : `should emit ${eventResults.map(e => e.eventRef).join(', ')} for valid ${commandName}`;
+            : `should emit ${eventResults.map(e => e.eventRef).join(', ')} for valid ${commandName}`);
 %>
-it('<%- testName %>', () => {
-given([
+  it('<%= testDescription %>', () => {
+    given([
 <%_ if (gwt.given && gwt.given.length) { _%>
-    <%- gwt.given.map(g => `{
+      <%- gwt.given.map(g => `{
         type: '${g.eventRef}',
         data: ${formatDataObject(g.exampleData, events.find(e => e.type === g.eventRef))}
       }`).join(',\n      ') %>
 <%_ } _%>
-])
-.when({
-type: '<%= example.commandRef %>',
-data: <%- formatDataObject(example.exampleData, schema) %>,
-metadata: { now: new Date() }
-})
+    ])
+      .when({
+        type: '<%= example.commandRef %>',
+        data: <%- formatDataObject(example.exampleData, schema) %>,
+        metadata: { now: new Date() },
+      })
 <% if (errorResult) { %>
-    .thenThrows((err) => err instanceof <%= errorResult.errorType %> && err.message === '<%= errorResult.message || '' %>');
+      .thenThrows((err) => err instanceof <%= errorResult.errorType %> && err.message === '<%= errorResult.message || '' %>');
 <% } else { %>
-    .then([
-    <%- eventResults.map(e => `{
-        type: '${e.eventRef}',
-        data: ${formatDataObject(e.exampleData, events.find(evt => evt.type === e.eventRef))}
-      }`).join(',\n      ') %>
-    ]);
+
+      .then([
+        <%- eventResults.map(e => `{
+          type: '${e.eventRef}',
+          data: ${formatDataObject(e.exampleData, events.find(evt => evt.type === e.eventRef))}
+        }`).join(',\n        ') %>
+      ]);
+<% } %>
+  });
 <% } %>
 });
-<% }} %>
-});
+<% } %>

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

@@ -45,7 +45,7 @@ function formatFieldDocLine(field) {
 
 export const decide = (
 command: <%= Object.keys(gwtMapping).map(pascalCase).join(' | ') %>,
-state: State<%= integrationReturnType ? `,\n  ${camelCase(integrationReturnType)}?: ${integrationReturnType}` : '' %>
+_state: State<%= integrationReturnType ? `,\n  ${camelCase(integrationReturnType)}?: ${integrationReturnType}` : '' %>
 ): <%= uniqueEventTypes.length === 0
         ? 'never'
         : uniqueEventTypes.length === 1
@@ -102,6 +102,6 @@ throw new IllegalStateError('Not yet implemented: ' + command.type);
 }
 <% } -%>
 default:
-throw new IllegalStateError('Unexpected command type: ' + command.type);
+throw new IllegalStateError(`Unexpected command type: ${String(command.type)}`);
 }
 };

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

@@ -1,7 +1,7 @@
-<% if (events.length) { -%>
+<% if (localEvents.length) { -%>
     import type { Event } from '@event-driven-io/emmett';
 
-    <% for (const event of events) { -%>
+    <% for (const event of localEvents) { -%>
         export type <%= pascalCase(event.type) %> = Event<
         '<%= event.type %>',
         {

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

@@ -1,8 +1,8 @@
 <% if (events.length) { -%>
     import type { State } from './state';
-    <% events.forEach(event => { -%>
-        import type { <%= pascalCase(event.type) %> } from './events';
-    <% }); -%>
+    <% for (const group of eventImportGroups) { -%>
+        import type { <%= group.eventTypes.map(name => pascalCase(name)).join(', ') %> } from '<%= group.importPath %>';
+    <% } -%>
 
     /**
     * ## IMPLEMENTATION INSTRUCTIONS ##

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

@@ -117,11 +117,11 @@ describe('generateScaffoldFilePlans', () => {
 
         try {
           await handler(eventStore, streamId, (state) => decide(command, state));
-          return; // success (returns void)
-        } catch (error: any) {
+          return undefined; // success
+        } catch (error: unknown) {
           return {
             type: 'SKIP',
-            reason: \`Command failed: \${error?.message ?? 'Unknown'}\`,
+            reason: \`Command failed: \${error instanceof Error ? error.message : 'Unknown'}\`,
           };
         }
       };
@@ -315,11 +315,11 @@ describe('generateScaffoldFilePlans', () => {
             // TODO: add products as a parameter to decide once implemented above
             decide(command, state /* products */),
           );
-          return; // success (returns void)
-        } catch (error: any) {
+          return undefined; // success
+        } catch (error: unknown) {
           return {
             type: 'SKIP',
-            reason: \`Command failed: \${error?.message ?? 'Unknown'}\`,
+            reason: \`Command failed: \${error instanceof Error ? error.message : 'Unknown'}\`,
           };
         }
       };

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

@@ -101,11 +101,11 @@ command: <%= commands.map(c => pascalCase(c.type)).join(' | ') %>
             ? `      // TODO: add ${resultVarName} as a parameter to decide once implemented above\n      decide(command, state, /* ${resultVarName} */)`
             : `      decide(command, state)` %>
     );
-    return; // success (returns void)
-    } catch (error: any) {
+    return undefined; // success
+    } catch (error: unknown) {
     return {
     type: 'SKIP',
-    reason: `Command failed: ${error?.message ?? 'Unknown'}`,
+    reason: `Command failed: ${error instanceof Error ? error.message : 'Unknown'}`,
     };
     }
     };