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

package/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/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/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/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/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/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/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'}`,
     };
     }
     };