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

package/src/codegen/templates/query/projection.specs.ts.ejs

@@ -1,71 +1,193 @@
 <%_
+const targetName = slice?.server?.data?.[0]?.target?.name || 'UnknownState';
+const TargetType = pascalCase(targetName);
+const projName = projectionName || "UnknownProjection";
 const idField = projectionIdField ?? 'id';
-const projectionType = states[0]?.type ?? 'UnknownState';
-const projectionCollection = projectionName ?? 'unknown-collection';
-const testCases = queryGwtMapping ?? [];
-const eventTypes = Array.from(new Set(events.map(e => e.type)));
+const uniqueEventTypes = allEventTypesArray;
+
+const ruleGroups = new Map();
+const rules = slice?.server?.specs?.rules || [];
+for (const rule of rules) {
+    const ruleDescription = rule.description || `${flowName} | ${sliceName}`;
+    if (!ruleGroups.has(ruleDescription)) {
+        ruleGroups.set(ruleDescription, []);
+    }
+
+    for (const example of rule.examples || []) {
+        ruleGroups.get(ruleDescription).push({
+            description: example.description || 'should handle events correctly',
+            given: example.given || [],
+            when: example.when || [],
+            then: example.then || []
+        });
+    }
+}
 _%>
 
 import { describe, it, beforeEach, expect } from 'vitest';
-import {
-InMemoryProjectionSpec,
-} from '@event-driven-io/emmett';
+import { InMemoryProjectionSpec } from '@event-driven-io/emmett';
 import { projection } from './projection';
-import type { <%= eventTypes.join(', ') %> } from '../<%= toKebabCase(events[0]?.sourceSliceName || 'unknown') %>/events';
-import { <%= projectionType %> } from './state';
-
-<% if (eventTypes.length > 0) { -%>
-    type ProjectionEvent = <%= eventTypes.join(' | ') %>;
-<% } else { -%>
-    type ProjectionEvent = never;
+<% for (const group of eventImportGroups) { -%>
+import type { <%= group.eventTypes.join(', ') %> } from '<%= group.importPath %>';
 <% } -%>
+import { <%= TargetType %> } from './state';
 
-describe('<%= projectionName %> Projection', () => {
-let given: InMemoryProjectionSpec<ProjectionEvent>;
+type ProjectionEvent = <%= uniqueEventTypes.length ? uniqueEventTypes.join(' | ') : 'never' %>;
 
-    beforeEach(() => {
+<% for (const [ruleDescription, ruleTests] of ruleGroups.entries()) { %>
+describe('<%= ruleDescription %>', () => {
+  let given: InMemoryProjectionSpec<ProjectionEvent>;
+
+  beforeEach(() => {
     given = InMemoryProjectionSpec.for({ projection });
-    });
+  });
 
-    <%_ for (const [index, gwt] of testCases.entries()) {
-        const isRemoval = gwt.then[0]?.exampleData && Object.keys(gwt.then[0].exampleData).length === 0;
-        const expectedIdValue = JSON.stringify(gwt.then[0]?.exampleData?.[idField] ?? 'unknown-id');
-    _%>
-    it('<%= isRemoval ? 'removes' : 'creates or updates' %> <%= projectionType %> document - case <%= index + 1 %>', () =>
-    given([
-    <%_ for (const event of gwt.given) { _%>
-        {
-        type: '<%= event.eventRef %>',
+<% for (const testCase of ruleTests) {
+  const givenEvents = Array.isArray(testCase.given) ? testCase.given : [];
+  const whenEvents = Array.isArray(testCase.when) ? testCase.when : (testCase.when ? [testCase.when] : []);
+  const thenStates = Array.isArray(testCase.then) ? testCase.then : [];
+  const allTestEvents = [...givenEvents, ...whenEvents].filter(e => e.eventRef && e.eventRef !== '');
+
+  if (thenStates.length > 0) {
+    const expectedState = thenStates.find(t => t.stateRef === targetName);
+    if (!expectedState) continue;
+
+    const description = testCase.description || 'should handle events correctly';
+_%>
+
+  it('<%= description %>', () =>
+    given([<% if (givenEvents.length > 0) {
+      for (const evt of givenEvents) {
+        if (!evt.eventRef || evt.eventRef === '') continue;
+        const eventMessage = messages.find(m => m.name === evt.eventRef);
+        const streamNameValue = slice.stream ? `'${slice.stream}'` : "'test-stream'";
+_%>
+      {
+        type: '<%= evt.eventRef %>',
         data: {
-        <%_ for (const [key, val] of Object.entries(event.exampleData || {})) { _%>
-            <%= key %>: <%- formatTsValue(val, (events.find(e => e.type === event.eventRef)?.fields.find(f => f.name === key)?.tsType || 'string')) %>,
-        <%_ } _%>
+<% const dataKeys = Object.keys(evt.exampleData || {});
+   for (let i = 0; i < dataKeys.length; i++) {
+     const key = dataKeys[i];
+     const value = evt.exampleData[key];
+     const isLast = i === dataKeys.length - 1;
+     const field = eventMessage?.fields?.find(f => f.name === key);
+     const tsType = field?.tsType || field?.type || 'string';
+
+     let formattedValue;
+     if (value === null || value === undefined) {
+       formattedValue = 'null';
+     } else if (tsType === 'string' || tsType === 'ID') {
+       formattedValue = `'${value}'`;
+     } else if (tsType === 'number' || tsType === 'boolean') {
+       formattedValue = String(value);
+     } else if (tsType === 'Date') {
+       formattedValue = `new Date('${value}')`;
+     } else if (Array.isArray(value)) {
+       formattedValue = JSON.stringify(value);
+     } else {
+       formattedValue = `'${value}'`;
+     }
+-%>
+          <%= key %>: <%= formattedValue %><%= isLast ? '' : ',' %>
+<% } -%>
         },
         metadata: {
-        streamName: 'ignored-stream',
-        streamPosition: 1n,
-        globalPosition: 1n,
-        },
+          streamName: <%= streamNameValue %>,
+          streamPosition: 1n,
+          globalPosition: 1n,
         },
-    <%_ } _%>
-    ])
-    .when([])
-    .then(async (state) => {
-    const document = await state.database
-    .collection<<%= projectionType %>>('<%= projectionCollection %>')
-    .findOne((doc) => doc.<%= idField %> === <%- expectedIdValue %>);
+      },<% } } -%>])
+      .when([<% if (whenEvents.length > 0) {
+        for (const evt of whenEvents) {
+          if (!evt.eventRef || evt.eventRef === '') continue;
+          const eventMessage = messages.find(m => m.name === evt.eventRef);
+          const streamNameValue = slice.stream ? `'${slice.stream}'` : "'test-stream'";
+_%>
+        {
+          type: '<%= evt.eventRef %>',
+          data: {
+<% const dataKeys = Object.keys(evt.exampleData || {});
+   for (let i = 0; i < dataKeys.length; i++) {
+     const key = dataKeys[i];
+     const value = evt.exampleData[key];
+     const isLast = i === dataKeys.length - 1;
+     const field = eventMessage?.fields?.find(f => f.name === key);
+     const tsType = field?.tsType || field?.type || 'string';
 
-    <%_ if (isRemoval) { _%>
-    expect(document).toBeNull();
-    <%_ } else { _%>
-        const expected: <%= projectionType %> = {
-        <%_ for (const [key, val] of Object.entries(gwt.then[0].exampleData || {})) { _%>
-            <%= key %>: <%- formatTsValue(val, (states[0]?.fields.find(f => f.name === key)?.tsType || 'string')) %>,
-        <%_ } _%>
+     let formattedValue;
+     if (value === null || value === undefined) {
+       formattedValue = 'null';
+     } else if (tsType === 'string' || tsType === 'ID') {
+       formattedValue = `'${value}'`;
+     } else if (tsType === 'number' || tsType === 'boolean') {
+       formattedValue = String(value);
+     } else if (tsType === 'Date') {
+       formattedValue = `new Date('${value}')`;
+     } else if (Array.isArray(value)) {
+       formattedValue = JSON.stringify(value);
+     } else {
+       formattedValue = `'${value}'`;
+     }
+-%>
+            <%= key %>: <%= formattedValue %><%= isLast ? '' : ',' %>
+<% } -%>
+          },
+          metadata: {
+            streamName: <%= streamNameValue %>,
+            streamPosition: <%= givenEvents.length + whenEvents.indexOf(evt) + 1 %>n,
+            globalPosition: <%= givenEvents.length + whenEvents.indexOf(evt) + 1 %>n,
+          },
+        },<% } } -%>])
+      .then(async (state) => {
+        const document = await state.database
+          .collection<<%= TargetType %>>('<%= projName %>')
+          .findOne((doc) => <%
+const idField = projectionIdField ?? 'id';
+if (idField.includes('-')) {
+    // Handle composite keys
+    const parts = idField.split('-');
+    const conditions = parts.map(part => {
+        const value = expectedState.exampleData?.[part];
+        const valueStr = typeof value === 'string' ? `'${value}'` : value || "'test-value'";
+        return `doc.${part} === ${valueStr}`;
+    }).join(' && ');
+%><%= conditions %><%
+} else {
+    const value = expectedState.exampleData?.[idField];
+    const valueStr = typeof value === 'string' ? `'${value}'` : value || "'test-id'";
+%>doc.<%= idField %> === <%= valueStr %><%
+}
+%>);
+
+        const expected: <%= TargetType %> = {
+<% const stateKeys = Object.keys(expectedState.exampleData || {});
+   for (let i = 0; i < stateKeys.length; i++) {
+     const key = stateKeys[i];
+     const value = expectedState.exampleData[key];
+     const isLast = i === stateKeys.length - 1;
+     const stateMessage = messages.find(m => m.name === targetName);
+     const field = stateMessage?.fields?.find(f => f.name === key);
+     const tsType = field?.tsType || field?.type || 'string';
+
+     let formattedValue;
+     if (value === null || value === undefined) {
+       formattedValue = 'null';
+     } else if (tsType === 'string' || tsType === 'ID') {
+       formattedValue = `'${value}'`;
+     } else if (tsType === 'number' || tsType === 'boolean') {
+       formattedValue = String(value);
+     } else if (Array.isArray(value)) {
+       formattedValue = JSON.stringify(value);
+     } else {
+       formattedValue = `'${value}'`;
+     }
+-%>
+          <%= key %>: <%= formattedValue %><%= isLast ? '' : ',' %>
+<% } -%>
         };
 
         expect(document).toMatchObject(expected);
-    <%_ } _%>
-    }));
-    <%_ } _%>
-    });
+      }));
+<% } } %>
+});
+<% } -%>

package/src/codegen/templates/query/projection.ts.ejs

@@ -4,28 +4,15 @@ type ReadEvent,
 type InMemoryReadEventMetadata,
 } from '@event-driven-io/emmett';
 import type { <%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %> } from './state';<%
-if (events.length > 0) {
-    const importGroups = new Map();
-    for (const event of events) {
-        const fromSameFlow = event.sourceFlowName === flowName;
-        const basePath = fromSameFlow
-                ? `../${toKebabCase(event.sourceSliceName ?? 'unknown')}/events`
-                : `../${toKebabCase(event.sourceFlowName ?? 'unknown')}/${toKebabCase(event.sourceSliceName ?? 'unknown')}/events`;
-
-        if (!importGroups.has(basePath)) {
-            importGroups.set(basePath, []);
-        }
-        importGroups.get(basePath).push(event.type);
-    }
-
-        for (const [importPath, typeNames] of importGroups.entries()) {
+if (eventImportGroups.length > 0) {
+    for (const group of eventImportGroups) {
 %>
-    import type { <%= typeNames.join(', ') %> } from '<%= importPath %>';
+import type { <%= group.eventTypes.join(', ') %> } from '<%= group.importPath %>';
 <%
-}
+    }
 } -%>
 
-type AllEvents = <%= events.length > 0 ? events.map(e => e.type).join(' | ') : 'never' %>;
+type AllEvents = <%= allEventTypes %>;
 
 export const projection = inMemorySingleStreamProjection<
 <%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %>,
@@ -33,7 +20,19 @@ AllEvents
 >({
 collectionName: '<%= pascalCase(slice.server?.data?.[0]?.origin?.name || "unknown-collection") %>',
 canHandle: [<%- events.map(e => `'${e.type}'`).join(', ') %>],
-getDocumentId: (event) => event.data.<%= slice.server?.data?.[0]?.origin?.idField ?? 'id' %>,
+getDocumentId: (event) => <%
+const idField = slice.server?.data?.[0]?.origin?.idField ?? 'id';
+// Check if idField contains hyphen-separated composite keys
+if (idField.includes('-')) {
+    const parts = idField.split('-');
+    const template = parts.map((part, index) =>
+        index === 0 ? `\${event.data.${part}}` : `-\${event.data.${part}}`
+    ).join('');
+%>`<%= template %>`<%
+} else {
+%>event.data.<%= idField %><%
+}
+%>,
 evolve: (
 document: <%= pascalCase(slice.server?.data?.[0]?.target?.name || 'UnknownState') %> | null,
 event: ReadEvent<AllEvents, InMemoryReadEventMetadata>
@@ -42,9 +41,11 @@ switch (event.type) {
 <% for (const event of events) {
     const targetName = slice.server?.data?.[0]?.target?.name;
     const queryGwt = slice.type === 'query'
-            ? queryGwtMapping.find(gwt =>
-                    gwt.given.some(g => g.eventRef === event.type)
-            )
+            ? queryGwtMapping.find(gwt => {
+                    const inGiven = gwt.given && gwt.given.some(g => g.eventRef === event.type);
+                    const inWhen = gwt.when.some(g => g.eventRef === event.type);
+                    return inGiven || inWhen;
+            })
             : undefined;
     const example = slice.type === 'query'
             ? queryGwt?.then.find(t => t.stateRef === targetName)?.exampleData
@@ -94,19 +95,19 @@ case '<%= event.type %>': {
 
         let placeholder = 'undefined';
         if (type === 'string' || type === 'ID') {
-            placeholder = "''";
+            placeholder = "/* TODO: map from event.data */ ''";
         } else if (type === 'number') {
-            placeholder = '0';
+            placeholder = '/* TODO: map from event.data */ 0';
         } else if (type === 'boolean') {
-            placeholder = 'false';
+            placeholder = '/* TODO: map from event.data */ false';
         } else if (type === 'Date') {
-            placeholder = 'new Date()';
+            placeholder = '/* TODO: map from event.data */ new Date()';
         } else if (type.startsWith('Array<')) {
-            placeholder = '[]';
+            placeholder = '/* TODO: map from event.data */ []';
         } else {
-            placeholder = '{} as any';
+            placeholder = '/* TODO: map from event.data */ undefined as any';
         }
-    %>          <%= field %>: /* TODO: map from event.data */ <%- placeholder %><%= isLast ? '' : ',' %>
+    %>        <%= field %>: <%- placeholder %><%= isLast ? '' : ',' %>
     <% } -%>
     };
 <% } -%>

package/src/codegen/templates/react/react.specs.specs.ts

@@ -173,14 +173,17 @@ describe('react.specs.ts.ejs (react slice)', () => {
       import type { BookingRequested } from '../guest-submits-booking-request/events';
       import type { NotifyHost } from '../send-notification-to-host/commands';
 
-      describe('ManageBookings | SendNotificationToHost', () => {
+      type ReactorEvent = BookingRequested;
+      type ReactorCommand = NotifyHost;
+
+      describe('Should send host notification on booking request', () => {
         let eventStore: InMemoryEventStore;
-        let given: ReactorSpecification<BookingRequested, NotifyHost, ReactorContext>;
+        let given: ReactorSpecification<ReactorEvent, ReactorCommand, ReactorContext>;
         let messageBus: CommandSender;
 
         beforeEach(() => {
           eventStore = getInMemoryEventStore({});
-          given = ReactorSpecification.for<BookingRequested, NotifyHost, ReactorContext>(
+          given = ReactorSpecification.for<ReactorEvent, ReactorCommand, ReactorContext>(
             () => react({ eventStore, commandSender: messageBus }),
             (commandSender) => {
               messageBus = commandSender;
@@ -193,7 +196,7 @@ describe('react.specs.ts.ejs (react slice)', () => {
           );
         });
 
-        it('should send NotifyHost when BookingRequested is received', async () => {
+        it('Booking request triggers host notification', async () => {
           await given([])
             .when({
               type: 'BookingRequested',

package/src/codegen/templates/react/react.specs.ts.ejs

@@ -1,88 +1,139 @@
 <%
-// Extract all examples from specs/rules structure
-const specs = slice.server?.specs;
-const gwtList = specs?.rules?.flatMap(rule => 
-  rule.examples.map(example => ({
-    given: example.given,
-    when: example.when,
-    then: example.then
-  }))
-) ?? [];
-const firstGwt = gwtList[0];
-const firstWhen = Array.isArray(firstGwt?.when) ? firstGwt.when[0] : firstGwt?.when;
-const firstThen = Array.isArray(firstGwt?.then) ? firstGwt.then[0] : firstGwt?.then;
+const ruleGroups = new Map();
+const rules = slice.server?.specs?.rules || [];
 
-const eventType = firstWhen?.eventRef;
-const commandType = firstThen?.commandRef;
+const allUsedEvents = new Set();
+const allUsedCommands = new Set();
 
-const event = events.find(e => e.type === eventType);
-const command = commands.find(c => c.type === commandType);
+for (const rule of rules) {
+    const ruleDescription = rule.description || `${flowName} | ${sliceName}`;
+    if (!ruleGroups.has(ruleDescription)) {
+        ruleGroups.set(ruleDescription, []);
+    }
 
-const eventImportPath = toKebabCase(event?.sourceSliceName ?? 'unknown');
-const commandImportPath = toKebabCase(command?.sourceSliceName ?? 'unknown');
+    for (const example of rule.examples || []) {
+        ruleGroups.get(ruleDescription).push({
+            description: example.description || 'should react correctly',
+            given: example.given || [],
+            when: example.when || [],
+            then: example.then || []
+        });
+
+        const whenEvents = Array.isArray(example.when) ? example.when : (example.when ? [example.when] : []);
+        for (const evt of whenEvents) {
+            if (evt.eventRef) allUsedEvents.add(evt.eventRef);
+        }
+
+        const thenCommands = Array.isArray(example.then) ? example.then : (example.then ? [example.then] : []);
+        for (const cmd of thenCommands) {
+            if (cmd.commandRef) allUsedCommands.add(cmd.commandRef);
+        }
+    }
+}
+
+const eventImportGroups = new Map();
+const commandImportGroups = new Map();
+
+for (const eventType of allUsedEvents) {
+    const event = events.find(e => e.type === eventType);
+    if (event) {
+        const importPath = event.sourceSliceName ? `../${toKebabCase(event.sourceSliceName)}/events` : './events';
+        if (!eventImportGroups.has(importPath)) {
+            eventImportGroups.set(importPath, []);
+        }
+        eventImportGroups.get(importPath).push(pascalCase(eventType));
+    }
+}
+
+for (const commandType of allUsedCommands) {
+    const command = commands.find(c => c.type === commandType);
+    if (command) {
+        const importPath = command.sourceSliceName ? `../${toKebabCase(command.sourceSliceName)}/commands` : './commands';
+        if (!commandImportGroups.has(importPath)) {
+            commandImportGroups.set(importPath, []);
+        }
+        commandImportGroups.get(importPath).push(pascalCase(commandType));
+    }
+}
+
+const allEventTypes = Array.from(allUsedEvents).map(e => pascalCase(e)).sort();
+const allCommandTypes = Array.from(allUsedCommands).map(c => pascalCase(c)).sort();
 %>
 import { describe, it, beforeEach } from 'vitest';
 import 'reflect-metadata';
 import {
-getInMemoryEventStore,
-type InMemoryEventStore,
-type CommandSender,
+  getInMemoryEventStore,
+  type InMemoryEventStore,
+  type CommandSender,
 } from '@event-driven-io/emmett';
 import { type ReactorContext, ReactorSpecification } from '../../../shared';
 import { react } from './react';
-import type { <%= pascalCase(eventType) %> } from '../<%= eventImportPath %>/events';
-import type { <%= pascalCase(commandType) %> } from '../<%= commandImportPath %>/commands';
+<% for (const [importPath, typeNames] of eventImportGroups.entries()) { -%>
+import type { <%= typeNames.sort().join(', ') %> } from '<%= importPath %>';
+<% } -%>
+<% for (const [importPath, typeNames] of commandImportGroups.entries()) { -%>
+import type { <%= typeNames.sort().join(', ') %> } from '<%= importPath %>';
+<% } -%>
 
-describe('<%= pascalCase(flowName) %> | <%= pascalCase(slice.name) %>', () => {
-let eventStore: InMemoryEventStore;
-let given: ReactorSpecification<<%= pascalCase(eventType) %>, <%= pascalCase(commandType) %>, ReactorContext>;
-let messageBus: CommandSender;
+type ReactorEvent = <%= allEventTypes.length ? allEventTypes.join(' | ') : 'never' %>;
+type ReactorCommand = <%= allCommandTypes.length ? allCommandTypes.join(' | ') : 'never' %>;
 
-beforeEach(() => {
-eventStore = getInMemoryEventStore({});
-given = ReactorSpecification.for<<%= pascalCase(eventType) %>, <%= pascalCase(commandType) %>, ReactorContext>(
-() => react({ eventStore, commandSender: messageBus }),
-(commandSender) => {
-messageBus = commandSender;
-return {
-eventStore,
-commandSender,
-database: eventStore.database,
-};
-}
-);
-});
+<% for (const [ruleDescription, ruleTests] of ruleGroups.entries()) { %>
+describe('<%= ruleDescription %>', () => {
+  let eventStore: InMemoryEventStore;
+  let given: ReactorSpecification<ReactorEvent, ReactorCommand, ReactorContext>;
+  let messageBus: CommandSender;
+
+  beforeEach(() => {
+    eventStore = getInMemoryEventStore({});
+    given = ReactorSpecification.for<ReactorEvent, ReactorCommand, ReactorContext>(
+      () => react({ eventStore, commandSender: messageBus }),
+      (commandSender) => {
+        messageBus = commandSender;
+        return {
+          eventStore,
+          commandSender,
+          database: eventStore.database,
+        };
+      }
+    );
+  });
 
-<% for (const example of gwtList) {
-    const exampleEvent = Array.isArray(example.when) ? example.when[0] : example.when;
-    const commands = example.then;
-    const description = `should send ${commands.map(c => c.commandRef).join(', ')} when ${exampleEvent.eventRef} is received`;
+<% for (const testCase of ruleTests) {
+    const whenEvents = Array.isArray(testCase.when) ? testCase.when : (testCase.when ? [testCase.when] : []);
+    const thenCommands = Array.isArray(testCase.then) ? testCase.then : (testCase.then ? [testCase.then] : []);
+
+    if (whenEvents.length > 0 && thenCommands.length > 0) {
+        const exampleEvent = whenEvents[0];
+        const description = testCase.description ||
+            `should send ${thenCommands.map(c => c.commandRef).join(', ')} when ${exampleEvent.eventRef} is received`;
 %>
-it('<%= description %>', async () => {
-await given([])
-.when({
-type: '<%= exampleEvent.eventRef %>',
-data: <%- formatDataObject(exampleEvent.exampleData, events.find(e => e.type === exampleEvent.eventRef)) %>
-})
-<% if (commands.length === 1) {
-    const commandSchema = commands[0];
+  it('<%= description %>', async () => {
+    await given([])
+      .when({
+        type: '<%= exampleEvent.eventRef %>',
+        data: <%- formatDataObject(exampleEvent.exampleData, events.find(e => e.type === exampleEvent.eventRef)) %>
+      })
+<% if (thenCommands.length === 1) {
+    const commandSchema = thenCommands[0];
 %>
-.then({
-type: '<%= commandSchema.commandRef %>',
-kind: 'Command',
-data: <%- formatDataObject(commandSchema.exampleData, messages.find(m => m.name === commandSchema.commandRef && m.type === 'command')) %>
-});
+      .then({
+        type: '<%= commandSchema.commandRef %>',
+        kind: 'Command',
+        data: <%- formatDataObject(commandSchema.exampleData, messages.find(m => m.name === commandSchema.commandRef && m.type === 'command')) %>
+      });
 <% } else { %>
-    .then([
-    <% for (const cmd of commands) { %>
+      .then([
+<% for (const cmd of thenCommands) { %>
         {
-        type: '<%= cmd.commandRef %>',
-        kind: 'Command',
-        data: <%- formatDataObject(cmd.exampleData, messages.find(m => m.name === cmd.commandRef && m.type === 'command')) %>
+          type: '<%= cmd.commandRef %>',
+          kind: 'Command',
+          data: <%- formatDataObject(cmd.exampleData, messages.find(m => m.name === cmd.commandRef && m.type === 'command')) %>
         },
-    <% } %>
-    ]);
 <% } %>
-});
+      ]);
 <% } %>
-});
+  });
+<% } } %>
+});
+<% } -%>

package/src/codegen/types.ts

@@ -32,4 +32,6 @@ export interface GwtCondition {
   given?: Array<EventExample | StateExample>;
   when: CommandExample | EventExample[];
   then: Array<EventExample | StateExample | CommandExample | { errorType: string; message?: string }>;
+  description?: string;
+  ruleDescription?: string;
 }

package/dist/src/codegen/scaffoldFromSchema.query-slice-register.specs.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=scaffoldFromSchema.query-slice-register.specs.d.ts.map

package/dist/src/codegen/scaffoldFromSchema.query-slice-register.specs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scaffoldFromSchema.query-slice-register.specs.d.ts","sourceRoot":"","sources":["../../../src/codegen/scaffoldFromSchema.query-slice-register.specs.ts"],"names":[],"mappings":""}