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

package/package.json

@@ -11,8 +11,10 @@
   },
   "dependencies": {
     "@event-driven-io/emmett": "^0.38.2",
+    "@event-driven-io/emmett-sqlite": "^0.38.5",
     "apollo-server": "^3.13.0",
     "apollo-server-express": "^3.13.0",
+    "better-sqlite3": "^12.4.1",
     "change-case": "^5.4.4",
     "ejs": "^3.1.10",
     "execa": "^9.6.0",
@@ -23,13 +25,14 @@
     "graphql-scalars": "^1.24.2",
     "prettier": "^3.6.1",
     "reflect-metadata": "^0.2.2",
+    "sqlite3": "^5.1.7",
     "type-fest": "^4.41.0",
     "type-graphql": "^2.0.0-rc.2",
     "graphql-type-json": "^0.3.2",
-    "uuid": "^10.0.0",
+    "uuid": "^11.0.0",
     "web-streams-polyfill": "^4.1.0",
-    "@auto-engineer/message-bus": "0.10.4",
-    "@auto-engineer/flow": "0.10.4"
+    "@auto-engineer/flow": "0.11.0",
+    "@auto-engineer/message-bus": "0.11.0"
   },
   "publishConfig": {
     "access": "public"
@@ -37,9 +40,9 @@
   "devDependencies": {
     "@types/ejs": "^3.1.5",
     "@types/fs-extra": "^11.0.4",
-    "@auto-engineer/cli": "0.10.4"
+    "@auto-engineer/cli": "0.11.0"
   },
-  "version": "0.10.4",
+  "version": "0.11.0",
   "scripts": {
     "generate:server": "tsx src/cli/index.ts",
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/src/codegen/templates && mkdir -p dist/src/codegen && cp -r src/codegen/templates dist/src/codegen/templates && cp src/server.ts dist/src && cp -r src/utils dist/src && cp -r src/domain dist/src",

package/src/codegen/extract/events.ts

@@ -7,20 +7,35 @@ function createEventMessage(
   eventRef: string | undefined,
   source: 'given' | 'then' | 'when',
   allMessages: MessageDefinition[],
+  currentSliceName?: string,
+  currentFlowName?: string,
 ): Message | undefined {
   if (eventRef == null) return undefined;
   const fields = extractFieldsFromMessage(eventRef, 'event', allMessages);
-  return { type: eventRef, fields, source };
+  const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventRef);
+  const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
+  const sourceFlowName = metadata?.sourceFlowName ?? currentFlowName;
+  const sourceSliceName = metadata?.sourceSliceName ?? currentSliceName;
+
+  return {
+    type: eventRef,
+    fields,
+    source,
+    sourceFlowName,
+    sourceSliceName,
+  };
 }
 
 export function extractEventsFromThen(
   thenItems: Array<EventExample | { errorType: string; message?: string }>,
   allMessages: MessageDefinition[],
+  currentSliceName?: string,
+  currentFlowName?: string,
 ): Message[] {
   return thenItems
     .map((then): Message | undefined => {
       if (!('eventRef' in then)) return undefined;
-      return createEventMessage(then.eventRef, 'then', allMessages);
+      return createEventMessage(then.eventRef, 'then', allMessages, currentSliceName, currentFlowName);
     })
     .filter((event): event is Message => event !== undefined);
 }
@@ -28,11 +43,13 @@ export function extractEventsFromThen(
 export function extractEventsFromGiven(
   givenEvents: EventExample[] | undefined,
   allMessages: MessageDefinition[],
+  currentSliceName?: string,
+  currentFlowName?: string,
 ): Message[] {
   if (!givenEvents) return [];
 
   return givenEvents
-    .map((given) => createEventMessage(given.eventRef, 'given', allMessages))
+    .map((given) => createEventMessage(given.eventRef, 'given', allMessages, currentSliceName, currentFlowName))
     .filter((event): event is Message => event !== undefined);
 }
 

package/src/codegen/extract/gwt.ts

@@ -21,12 +21,16 @@ function extractGwtSpecs(slice: Slice) {
           given: example.given,
           when: example.when,
           then: example.then,
+          description: example.description,
+          ruleDescription: rule.description,
         })),
       )
     : [];
 }
 
-function buildCommandMapping(gwtSpecs: Array<{ given: unknown; when: unknown; then: unknown }>) {
+function buildCommandMapping(
+  gwtSpecs: Array<{ given: unknown; when: unknown; then: unknown; description?: string; ruleDescription?: string }>,
+) {
   const mapping: Record<string, GwtCondition[]> = {};
 
   for (const gwt of gwtSpecs) {
@@ -43,6 +47,8 @@ function buildCommandMapping(gwtSpecs: Array<{ given: unknown; when: unknown; th
         given: gwt.given as Array<EventExample | StateExample> | undefined,
         when: gwt.when as CommandExample | EventExample[],
         then: gwt.then as Array<EventExample | StateExample | CommandExample | { errorType: string; message?: string }>,
+        description: gwt.description,
+        ruleDescription: gwt.ruleDescription,
       });
     }
   }
@@ -54,10 +60,10 @@ function enhanceMapping(mapping: Record<string, GwtCondition[]>) {
   const enhancedMapping: Record<string, (GwtCondition & { failingFields?: string[] })[]> = {};
 
   for (const command in mapping) {
-    const merged = mergeGwtConditions(mapping[command]);
-    const successfulData = findSuccessfulExampleData(merged);
+    const conditions = mapping[command];
+    const successfulData = findSuccessfulExampleData(conditions);
 
-    enhancedMapping[command] = merged.map((gwt) => ({
+    enhancedMapping[command] = conditions.map((gwt) => ({
       ...gwt,
       failingFields: findFailingFields(gwt, successfulData),
     }));
@@ -66,28 +72,6 @@ function enhanceMapping(mapping: Record<string, GwtCondition[]>) {
   return enhancedMapping;
 }
 
-function mergeGwtConditions(gwts: GwtCondition[]): GwtCondition[] {
-  const map = new Map<string, GwtCondition[]>();
-
-  for (const gwt of gwts) {
-    // Handle both single command and array of events in when clause
-    const whenData = Array.isArray(gwt.when) ? gwt.when[0]?.exampleData : gwt.when.exampleData;
-    const key = JSON.stringify(whenData ?? {});
-    const existing = map.get(key) ?? [];
-    map.set(key, [...existing, gwt]);
-  }
-
-  return Array.from(map.values()).map((conditions) => {
-    const first = conditions[0];
-    const combinedThen = conditions.flatMap((g) => g.then);
-    return {
-      given: conditions.flatMap((g) => g.given ?? []),
-      when: first.when,
-      then: combinedThen,
-    };
-  });
-}
-
 function findSuccessfulExampleData(gwts: GwtCondition[]): Record<string, unknown> {
   const successful = gwts.find((gwt) => gwt.then.some((t) => typeof t === 'object' && t !== null && 'eventRef' in t));
   const whenData = Array.isArray(successful?.when) ? successful?.when[0]?.exampleData : successful?.when?.exampleData;

package/src/codegen/extract/imports.ts

@@ -0,0 +1,71 @@
+import { toKebabCase } from '../utils/path';
+import { Message } from '../types';
+
+export interface ImportGroup {
+  importPath: string;
+  eventTypes: string[];
+}
+
+export interface CrossSliceImportContext {
+  currentSliceName: string;
+  events: Message[];
+}
+
+/**
+ * Groups events by their import paths, handling cross-slice imports correctly.
+ * Events from the current slice are imported from './events',
+ * while cross-slice events are imported from '../other-slice/events'.
+ */
+export function groupEventImports(context: CrossSliceImportContext): ImportGroup[] {
+  const { currentSliceName, events } = context;
+  const importGroups = new Map<string, string[]>();
+
+  for (const event of events) {
+    if (!event.type) continue;
+    let importPath: string;
+    const isFromCurrentSlice =
+      event.source === 'then' || event.sourceSliceName === currentSliceName || event.sourceSliceName == null;
+
+    if (isFromCurrentSlice) {
+      importPath = './events';
+    } else {
+      importPath = `../${toKebabCase(event.sourceSliceName ?? currentSliceName)}/events`;
+    }
+    if (!importGroups.has(importPath)) {
+      importGroups.set(importPath, []);
+    }
+    const eventTypes = importGroups.get(importPath)!;
+    if (!eventTypes.includes(event.type)) {
+      eventTypes.push(event.type);
+    }
+  }
+  return Array.from(importGroups.entries()).map(([importPath, eventTypes]) => ({
+    importPath,
+    eventTypes: eventTypes.sort(),
+  }));
+}
+
+/**
+ * Filters events to only include those from the current slice (source === 'then').
+ * Used for generating local event definitions.
+ */
+export function getLocalEvents(events: Message[]): Message[] {
+  return events.filter((event) => event.source === 'then');
+}
+
+/**
+ * Extracts all unique event types from a list of events.
+ */
+export function getAllEventTypes(events: Message[]): string[] {
+  const eventTypes = events.map((event) => event.type).filter((type): type is string => Boolean(type));
+
+  return Array.from(new Set(eventTypes)).sort();
+}
+
+/**
+ * Creates a TypeScript union type string from event types.
+ */
+export function createEventUnionType(events: Message[]): string {
+  const eventTypes = getAllEventTypes(events);
+  return eventTypes.length > 0 ? eventTypes.join(' | ') : 'never';
+}

package/src/codegen/extract/index.ts

@@ -5,3 +5,4 @@ export * from './states';
 export * from './messages';
 export * from './query';
 export * from './projection';
+export * from './imports';

package/src/codegen/extract/messages.ts

@@ -2,6 +2,7 @@ import { extractCommandsFromGwt, extractCommandsFromThen } from './commands';
 import { CommandExample, ErrorExample, EventExample, Slice, StateExample } from '@auto-engineer/flow';
 import { Message, MessageDefinition } from '../types';
 import { extractEventsFromGiven, extractEventsFromThen, extractEventsFromWhen } from './events';
+import { extractFieldsFromMessage } from './fields';
 import { extractProjectionIdField } from './projection';
 import { extractStatesFromData, extractStatesFromTarget } from './states';
 import createDebug from 'debug';
@@ -87,10 +88,10 @@ function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[
 
   const events: Message[] = gwtSpecs.flatMap((gwt): Message[] => {
     const givenEventsOnly = gwt.given?.filter((item): item is EventExample => 'eventRef' in item);
-    const givenEvents = extractEventsFromGiven(givenEventsOnly, allMessages);
+    const givenEvents = extractEventsFromGiven(givenEventsOnly, allMessages, slice.name);
 
     const thenEventsOnly = gwt.then.filter((item): item is EventExample => 'eventRef' in item);
-    const thenEvents = extractEventsFromThen(thenEventsOnly, allMessages);
+    const thenEvents = extractEventsFromThen(thenEventsOnly, allMessages, slice.name);
     debugCommand('    GWT: given=%d events, then=%d events', givenEvents.length, thenEvents.length);
     return [...givenEvents, ...thenEvents];
   });
@@ -133,12 +134,39 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
   debugQuery('  Projection ID field: %s', projectionIdField ?? 'none');
 
   const events: Message[] = gwtSpecs.flatMap((gwt) => {
-    const eventsFromWhen = Array.isArray(gwt.when)
-      ? gwt.when.filter((item): item is EventExample => 'eventRef' in item)
+    const eventsFromGiven = Array.isArray(gwt.given)
+      ? gwt.given.filter((item): item is EventExample => 'eventRef' in item)
       : [];
-    return extractEventsFromGiven(eventsFromWhen, allMessages);
+    let eventsFromWhen: EventExample[] = [];
+    if (Array.isArray(gwt.when)) {
+      eventsFromWhen = gwt.when.filter((item): item is EventExample => 'eventRef' in item);
+    } else if (gwt.when != null && typeof gwt.when === 'object' && 'eventRef' in gwt.when) {
+      // when is a single object, convert to array
+      const whenItem = gwt.when as EventExample;
+      if (whenItem.eventRef && whenItem.eventRef.trim() !== '') {
+        eventsFromWhen = [whenItem];
+      }
+    }
+    const givenEvents = extractEventsFromGiven(eventsFromGiven, allMessages);
+    const whenEvents = eventsFromWhen
+      .map((eventExample) => {
+        const fields = extractFieldsFromMessage(eventExample.eventRef, 'event', allMessages);
+        const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventExample.eventRef);
+        const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
+
+        return {
+          type: eventExample.eventRef,
+          fields,
+          source: 'when' as const, // Mark as 'when' source for query events
+          sourceFlowName: metadata?.sourceFlowName,
+          sourceSliceName: metadata?.sourceSliceName,
+        } as Message;
+      })
+      .filter((event): event is Message => event.type !== undefined);
+
+    return [...givenEvents, ...whenEvents];
   });
-  debugQuery('  Extracted %d events from given', events.length);
+  debugQuery('  Extracted %d events total', events.length);
 
   const states: Message[] = extractStatesFromTarget(slice, allMessages);
   debugQuery('  Extracted %d states from target', states.length);
@@ -164,7 +192,6 @@ function extractMessagesForReact(slice: Slice, allMessages: MessageDefinition[])
   }
 
   const specs = slice.server?.specs;
-  // Extract all examples from specs/rules structure
   const rules = specs?.rules;
   const gwtSpecs =
     Array.isArray(rules) && rules.length > 0

package/src/codegen/extract/query.ts

@@ -1,31 +1,29 @@
 import { EventExample, Slice } from '@auto-engineer/flow';
 
 interface QueryGwtCondition {
-  given: EventExample[];
+  description: string;
+  given?: EventExample[];
+  when: EventExample[];
   then: Array<{ stateRef: string; exampleData: Record<string, unknown> }>;
 }
 
 export function buildQueryGwtMapping(slice: Slice): QueryGwtCondition[] {
-  if (slice.type !== 'query') {
-    return [];
-  }
+  if (slice.type !== 'query') return [];
 
   const specs = slice.server?.specs;
   const rules = specs?.rules;
-  const gwtSpecs =
-    Array.isArray(rules) && rules.length > 0
-      ? rules.flatMap((rule) =>
-          rule.examples.map((example) => ({
-            given: Array.isArray(example.when) ? example.when : [], // For query slices, when contains the given events
-            then: example.then,
-          })),
-        )
-      : [];
 
-  return gwtSpecs.map((gwt) => ({
-    given: gwt.given.filter((item): item is EventExample => 'eventRef' in item),
-    then: gwt.then.filter(
-      (item): item is { stateRef: string; exampleData: Record<string, unknown> } => 'stateRef' in item,
-    ),
-  }));
+  const examples = Array.isArray(rules) && rules.length > 0 ? rules.flatMap((rule) => rule.examples) : [];
+
+  return examples.map((ex) => {
+    const givenEvents = Array.isArray(ex.given) ? ex.given.filter((i): i is EventExample => 'eventRef' in i) : [];
+    const whenEvents = Array.isArray(ex.when) ? ex.when.filter((i): i is EventExample => 'eventRef' in i) : [];
+
+    return {
+      description: ex.description,
+      given: givenEvents.length > 0 ? givenEvents : undefined,
+      when: whenEvents,
+      then: ex.then.filter((i): i is { stateRef: string; exampleData: Record<string, unknown> } => 'stateRef' in i),
+    };
+  });
 }

package/src/codegen/scaffoldFromSchema.ts

@@ -21,6 +21,10 @@ import {
   buildQueryGwtMapping,
   extractMessagesFromSpecs,
   extractProjectionName,
+  groupEventImports,
+  getAllEventTypes,
+  getLocalEvents,
+  createEventUnionType,
 } from './extract';
 
 function extractGwtSpecs(slice: Slice) {
@@ -273,6 +277,11 @@ async function prepareTemplateData(
   const filteredCommands =
     allowedForSlice.size > 0 ? uniqueCommands.filter((c) => allowedForSlice.has(c.type)) : uniqueCommands;
 
+  const eventImportGroups = groupEventImports({ currentSliceName: slice.name, events });
+  const allEventTypesArray = getAllEventTypes(events);
+  const allEventTypes = createEventUnionType(events);
+  const localEvents = getLocalEvents(events);
+
   return {
     flowName: flow.name,
     sliceName: slice.name,
@@ -295,6 +304,10 @@ async function prepareTemplateData(
         ? allMessages.find((m) => m.name === slice.server?.data?.[0]?.target?.name)
         : undefined,
     integrations,
+    eventImportGroups,
+    allEventTypes,
+    allEventTypesArray,
+    localEvents,
   };
 }
 

package/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'),
+                },
+              },
+            ]);
+        });
+      });
+      "
+    `);
+  });
 });