eventmodeler 0.3.7 → 0.3.8

package/dist/projection.js

@@ -868,6 +868,7 @@ function applyEvent(model, event) {
                 height: event.height,
                 givenEvents: [],
                 whenCommand: null,
+                whenEvents: [],
                 then: { type: 'events', expectedEvents: [] },
             });
             break;
@@ -904,6 +905,12 @@ function applyEvent(model, event) {
                 scenario.whenCommand = event.whenCommand;
             break;
         }
+        case 'ScenarioWhenEventsUpdated': {
+            const scenario = model.scenarios.get(event.scenarioId);
+            if (scenario)
+                scenario.whenEvents = event.whenEvents;
+            break;
+        }
         case 'ScenarioThenUpdated': {
             const scenario = model.scenarios.get(event.scenarioId);
             if (scenario)

package/dist/slices/add-scenario/index.js

@@ -42,10 +42,11 @@ function parseXmlInput(input) {
             }
         }
     }
-    // Parse when command
+    // Parse when (can contain command or events)
     const whenContent = getContent(input, 'when');
     let when;
     if (whenContent) {
+        // Check for command
         const commandMatch = whenContent.match(/<command([^>]*?)(?:\/>|>([\s\S]*?)<\/command>)/);
         if (commandMatch) {
             const commandName = getAttr(commandMatch[1], 'name');
@@ -57,9 +58,29 @@ function parseXmlInput(input) {
                         fieldValues[fieldMatch[1]] = parseFieldValue(fieldMatch[2]);
                     }
                 }
-                when = { command: commandName, fieldValues: Object.keys(fieldValues).length > 0 ? fieldValues : undefined };
+                when = { command: commandName, commandFieldValues: Object.keys(fieldValues).length > 0 ? fieldValues : undefined };
             }
         }
+        // Check for events in when
+        const eventMatches = whenContent.matchAll(/<event([^>]*?)(?:\/>|>([\s\S]*?)<\/event>)/g);
+        const whenEvents = [];
+        for (const match of eventMatches) {
+            const eventName = getAttr(match[1], 'name');
+            if (eventName) {
+                const fieldValues = {};
+                if (match[2]) {
+                    const fieldMatches = match[2].matchAll(/<field name="([^"]*)"[^>]*>([^<]*)<\/field>/g);
+                    for (const fieldMatch of fieldMatches) {
+                        fieldValues[fieldMatch[1]] = parseFieldValue(fieldMatch[2]);
+                    }
+                }
+                whenEvents.push({ event: eventName, fieldValues: Object.keys(fieldValues).length > 0 ? fieldValues : undefined });
+            }
+        }
+        if (whenEvents.length > 0) {
+            when = when || {};
+            when.events = whenEvents;
+        }
     }
     // Parse then
     const thenMatch = input.match(/<then([^>]*)(?:\/>|>([\s\S]*?)<\/then>)/);
@@ -92,6 +113,20 @@ function parseXmlInput(input) {
             }
         }
     }
+    else if (thenType === 'command' && thenMatch[2]) {
+        const commandMatch = thenMatch[2].match(/<command([^>]*?)(?:\/>|>([\s\S]*?)<\/command>)/);
+        if (commandMatch) {
+            then.command = getAttr(commandMatch[1], 'name');
+            const fieldValues = {};
+            if (commandMatch[2]) {
+                const fieldMatches = commandMatch[2].matchAll(/<field name="([^"]*)"[^>]*>([^<]*)<\/field>/g);
+                for (const fieldMatch of fieldMatches) {
+                    fieldValues[fieldMatch[1]] = parseFieldValue(fieldMatch[2]);
+                }
+            }
+            then.commandFieldValues = Object.keys(fieldValues).length > 0 ? fieldValues : undefined;
+        }
+    }
     else if (thenType === 'readModelAssertion' && thenMatch[2]) {
         const rmMatch = thenMatch[2].match(/<read-model([^>]*?)(?:\/>|>([\s\S]*?)<\/read-model>)/);
         if (rmMatch) {
@@ -159,13 +194,24 @@ export function addScenario(model, filePath, sliceName, input) {
     }
     // Resolve command reference in when
     let whenCommand = null;
-    if (scenarioInput.when) {
+    if (scenarioInput.when?.command) {
         const command = findElementOrExit(model.commands, scenarioInput.when.command, 'command');
         whenCommand = {
             commandStickyId: command.id,
-            fieldValues: scenarioInput.when.fieldValues,
+            fieldValues: scenarioInput.when.commandFieldValues,
         };
     }
+    // Resolve event references in when
+    const whenEvents = [];
+    if (scenarioInput.when?.events) {
+        for (const e of scenarioInput.when.events) {
+            const event = findElementOrExit(excludeLinkedCopies(model.events), e.event, 'event');
+            whenEvents.push({
+                eventStickyId: event.id,
+                fieldValues: e.fieldValues,
+            });
+        }
+    }
     // Resolve then clause
     const then = { type: scenarioInput.then.type };
     if (scenarioInput.then.type === 'error') {
@@ -184,6 +230,17 @@ export function addScenario(model, filePath, sliceName, input) {
             }
         }
     }
+    else if (scenarioInput.then.type === 'command') {
+        if (!scenarioInput.then.command) {
+            console.error('Error: command then type requires a command name');
+            process.exit(1);
+        }
+        const command = findElementOrExit(model.commands, scenarioInput.then.command, 'command');
+        then.expectedCommand = {
+            commandStickyId: command.id,
+            fieldValues: scenarioInput.then.commandFieldValues,
+        };
+    }
     else if (scenarioInput.then.type === 'readModelAssertion') {
         if (!scenarioInput.then.readModel) {
             console.error('Error: readModelAssertion requires a readModel name');
@@ -266,6 +323,15 @@ export function addScenario(model, filePath, sliceName, input) {
             timestamp: Date.now(),
         });
     }
+    // Append when events update if provided
+    if (whenEvents.length > 0) {
+        appendEvent(filePath, {
+            type: 'ScenarioWhenEventsUpdated',
+            scenarioId,
+            whenEvents,
+            timestamp: Date.now(),
+        });
+    }
     // Append then update
     appendEvent(filePath, {
         type: 'ScenarioThenUpdated',

package/dist/slices/codegen-slice/index.js

@@ -249,6 +249,18 @@ function formatScenarioThen(model, then) {
             }),
         };
     }
+    if (then.type === 'command' && then.expectedCommand) {
+        const command = model.commands.get(then.expectedCommand.commandStickyId);
+        return {
+            type: 'command',
+            expectedCommand: {
+                commandId: then.expectedCommand.commandStickyId,
+                commandName: command?.name ?? 'UnknownCommand',
+                commandSchema: { fields: command?.fields.map(fieldToJson) ?? [] },
+                fieldValues: then.expectedCommand.fieldValues ?? {},
+            },
+        };
+    }
     if (then.type === 'readModelAssertion' && then.readModelAssertion) {
         const rm = model.readModels.get(then.readModelAssertion.readModelStickyId);
         return {
@@ -277,13 +289,24 @@ function formatScenarios(model, scenarios) {
                 fieldValues: ref.fieldValues ?? {},
             };
         }),
-        when: scenario.whenCommand
+        whenCommand: scenario.whenCommand
             ? {
                 commandId: scenario.whenCommand.commandStickyId,
                 commandName: model.commands.get(scenario.whenCommand.commandStickyId)?.name ?? 'UnknownCommand',
                 fieldValues: scenario.whenCommand.fieldValues ?? {},
             }
             : null,
+        whenEvents: scenario.whenEvents.map(ref => {
+            const event = model.events.get(ref.eventStickyId);
+            const originSlice = findSliceForNode(model, ref.eventStickyId);
+            return {
+                eventId: ref.eventStickyId,
+                eventName: event?.name ?? 'UnknownEvent',
+                originSlice: originSlice?.name ?? null,
+                eventSchema: { fields: event?.fields.map(fieldToJson) ?? [] },
+                fieldValues: ref.fieldValues ?? {},
+            };
+        }),
         then: formatScenarioThen(model, scenario.then),
     }));
 }

package/dist/types.d.ts

@@ -22,13 +22,14 @@ export interface ReadModelAssertion {
     givenEvents: EventReference[];
     expectedFieldValues: Record<string, unknown>;
 }
-export type ScenarioThenType = 'error' | 'events' | 'readModelAssertion';
+export type ScenarioThenType = 'error' | 'events' | 'readModelAssertion' | 'command';
 export interface ScenarioThen {
     type: ScenarioThenType;
     errorMessage?: string;
     errorType?: string;
     expectedEvents?: EventReference[];
     readModelAssertion?: ReadModelAssertion;
+    expectedCommand?: CommandReference;
 }
 export interface FieldMapping {
     sourceFieldId: string;
@@ -162,6 +163,7 @@ export interface Scenario {
     height: number;
     givenEvents: EventReference[];
     whenCommand: CommandReference | null;
+    whenEvents: EventReference[];
     then: ScenarioThen;
 }
 export type FlowType = 'CommandToEvent' | 'EventToReadModel' | 'ReadModelToScreen' | 'ReadModelToProcessor' | 'ScreenToCommand' | 'ProcessorToCommand';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eventmodeler",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "CLI tool for interacting with Event Model files - query, update, and export event models from the terminal",
   "type": "module",
   "bin": {