eventmodeler 0.2.3 → 0.2.4

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

@@ -1,5 +1,6 @@
 import * as crypto from 'node:crypto';
 import { appendEvent } from '../../lib/file-loader.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 function parseJsonInput(input) {
     return JSON.parse(input);
 }
@@ -144,27 +145,12 @@ export function addScenario(model, filePath, sliceName, input) {
         process.exit(1);
     }
     // Find slice by name
-    const slices = [...model.slices.values()];
-    const sliceNameLower = sliceName.toLowerCase();
-    const slice = slices.find(s => s.name.toLowerCase() === sliceNameLower || s.name.toLowerCase().includes(sliceNameLower));
-    if (!slice) {
-        console.error(`Error: Slice not found: ${sliceName}`);
-        console.error('Available slices:');
-        for (const s of slices) {
-            console.error(`  - ${s.name}`);
-        }
-        process.exit(1);
-    }
+    const slice = findElementOrExit(model.slices, sliceName, 'slice');
     // Resolve event references in given
     const givenEvents = [];
     if (scenarioInput.given) {
         for (const g of scenarioInput.given) {
-            const event = findEventByName(model, g.event);
-            if (!event) {
-                console.error(`Error: Event not found in "given": ${g.event}`);
-                listAvailableEvents(model);
-                process.exit(1);
-            }
+            const event = findElementOrExit(model.events, g.event, 'event');
             givenEvents.push({
                 eventStickyId: event.id,
                 fieldValues: g.fieldValues,
@@ -174,12 +160,7 @@ export function addScenario(model, filePath, sliceName, input) {
     // Resolve command reference in when
     let whenCommand = null;
     if (scenarioInput.when) {
-        const command = findCommandByName(model, scenarioInput.when.command);
-        if (!command) {
-            console.error(`Error: Command not found in "when": ${scenarioInput.when.command}`);
-            listAvailableCommands(model);
-            process.exit(1);
-        }
+        const command = findElementOrExit(model.commands, scenarioInput.when.command, 'command');
         whenCommand = {
             commandStickyId: command.id,
             fieldValues: scenarioInput.when.fieldValues,
@@ -195,12 +176,7 @@ export function addScenario(model, filePath, sliceName, input) {
         then.expectedEvents = [];
         if (scenarioInput.then.events) {
             for (const e of scenarioInput.then.events) {
-                const event = findEventByName(model, e.event);
-                if (!event) {
-                    console.error(`Error: Event not found in "then.events": ${e.event}`);
-                    listAvailableEvents(model);
-                    process.exit(1);
-                }
+                const event = findElementOrExit(model.events, e.event, 'event');
                 then.expectedEvents.push({
                     eventStickyId: event.id,
                     fieldValues: e.fieldValues,
@@ -213,21 +189,11 @@ export function addScenario(model, filePath, sliceName, input) {
             console.error('Error: readModelAssertion requires a readModel name');
             process.exit(1);
         }
-        const readModel = findReadModelByName(model, scenarioInput.then.readModel);
-        if (!readModel) {
-            console.error(`Error: Read model not found: ${scenarioInput.then.readModel}`);
-            listAvailableReadModels(model);
-            process.exit(1);
-        }
+        const readModel = findElementOrExit(model.readModels, scenarioInput.then.readModel, 'read model');
         const assertionGivenEvents = [];
         if (scenarioInput.then.givenEvents) {
             for (const g of scenarioInput.then.givenEvents) {
-                const event = findEventByName(model, g.event);
-                if (!event) {
-                    console.error(`Error: Event not found in "then.givenEvents": ${g.event}`);
-                    listAvailableEvents(model);
-                    process.exit(1);
-                }
+                const event = findElementOrExit(model.events, g.event, 'event');
                 assertionGivenEvents.push({
                     eventStickyId: event.id,
                     fieldValues: g.fieldValues,
@@ -304,36 +270,3 @@ export function addScenario(model, filePath, sliceName, input) {
     });
     console.log(`Added scenario "${scenarioInput.name}" to slice "${slice.name}"`);
 }
-function findEventByName(model, name) {
-    const nameLower = name.toLowerCase();
-    const events = [...model.events.values()];
-    return events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
-}
-function findCommandByName(model, name) {
-    const nameLower = name.toLowerCase();
-    const commands = [...model.commands.values()];
-    return commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
-}
-function findReadModelByName(model, name) {
-    const nameLower = name.toLowerCase();
-    const readModels = [...model.readModels.values()];
-    return readModels.find(rm => rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower));
-}
-function listAvailableEvents(model) {
-    console.error('Available events:');
-    for (const e of model.events.values()) {
-        console.error(`  - ${e.name}`);
-    }
-}
-function listAvailableCommands(model) {
-    console.error('Available commands:');
-    for (const c of model.commands.values()) {
-        console.error(`  - ${c.name}`);
-    }
-}
-function listAvailableReadModels(model) {
-    console.error('Available read models:');
-    for (const rm of model.readModels.values()) {
-        console.error(`  - ${rm.name}`);
-    }
-}

package/dist/slices/create-automation-slice/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function createAutomationSlice(model: EventModel, filePath: string, xmlInput: string): void;

package/dist/slices/create-automation-slice/index.js

@@ -0,0 +1,217 @@
+import { appendEvent } from '../../lib/file-loader.js';
+import { AUTOMATION_SLICE, SLICE_GAP, calculateSlicePosition, validateSliceNameUnique, inferFieldMappings, parseFieldsFromXml, getSlicesToShift, fieldInputToField, } from '../../lib/slice-utils.js';
+function getAttr(attrs, name) {
+    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
+    return match ? match[1] : undefined;
+}
+function parseXmlInput(xml) {
+    // Parse <automation-slice name="..." after="..." before="...">
+    const sliceMatch = xml.match(/<automation-slice([^>]*)>/);
+    if (!sliceMatch) {
+        throw new Error('Invalid XML: missing <automation-slice> tag');
+    }
+    const sliceName = getAttr(sliceMatch[1], 'name');
+    if (!sliceName) {
+        throw new Error('Invalid XML: automation-slice must have a name attribute');
+    }
+    const after = getAttr(sliceMatch[1], 'after');
+    const before = getAttr(sliceMatch[1], 'before');
+    // Parse processor (no fields)
+    const processorMatch = xml.match(/<processor([^>]*?)(?:\/>|>([\s\S]*?)<\/processor>)/);
+    if (!processorMatch) {
+        throw new Error('Invalid XML: missing <processor> element');
+    }
+    const processorName = getAttr(processorMatch[1], 'name');
+    if (!processorName) {
+        throw new Error('Invalid XML: processor must have a name attribute');
+    }
+    // Parse command
+    const commandMatch = xml.match(/<command([^>]*)>([\s\S]*?)<\/command>/);
+    if (!commandMatch) {
+        throw new Error('Invalid XML: missing <command> element');
+    }
+    const commandName = getAttr(commandMatch[1], 'name');
+    if (!commandName) {
+        throw new Error('Invalid XML: command must have a name attribute');
+    }
+    const commandFields = parseFieldsFromXml(commandMatch[2]);
+    // Parse event
+    const eventMatch = xml.match(/<event([^>]*)>([\s\S]*?)<\/event>/);
+    if (!eventMatch) {
+        throw new Error('Invalid XML: missing <event> element');
+    }
+    const eventName = getAttr(eventMatch[1], 'name');
+    if (!eventName) {
+        throw new Error('Invalid XML: event must have a name attribute');
+    }
+    const eventFields = parseFieldsFromXml(eventMatch[2]);
+    return {
+        sliceName,
+        after,
+        before,
+        processor: { name: processorName },
+        command: { name: commandName, fields: commandFields },
+        event: { name: eventName, fields: eventFields },
+    };
+}
+export function createAutomationSlice(model, filePath, xmlInput) {
+    // Parse input
+    let input;
+    try {
+        input = parseXmlInput(xmlInput);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Validate slice name is unique
+    try {
+        validateSliceNameUnique(model, input.sliceName);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Calculate position
+    let slicePosition;
+    try {
+        slicePosition = calculateSlicePosition(model, AUTOMATION_SLICE.width, {
+            after: input.after,
+            before: input.before,
+        });
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Handle "before" positioning - shift existing slices
+    if (input.before) {
+        const shiftAmount = AUTOMATION_SLICE.width + SLICE_GAP;
+        const toShift = getSlicesToShift(model, slicePosition.x, shiftAmount);
+        for (const { sliceId, newX, currentY } of toShift) {
+            appendEvent(filePath, {
+                type: 'SliceMoved',
+                sliceId,
+                position: { x: newX, y: currentY },
+                timestamp: Date.now(),
+            });
+        }
+    }
+    // Generate IDs
+    const sliceId = crypto.randomUUID();
+    const processorId = crypto.randomUUID();
+    const commandId = crypto.randomUUID();
+    const eventId = crypto.randomUUID();
+    const processorToCommandFlowId = crypto.randomUUID();
+    const commandToEventFlowId = crypto.randomUUID();
+    // Convert field inputs to fields with IDs
+    const commandFields = input.command.fields.map(fieldInputToField);
+    const eventFields = input.event.fields.map(fieldInputToField);
+    // Infer field mappings (processor has no fields, so only command->event)
+    const commandToEventMappings = inferFieldMappings(commandFields, eventFields);
+    // Calculate absolute positions for components within the slice
+    const processorPosition = {
+        x: slicePosition.x + AUTOMATION_SLICE.processor.offsetX,
+        y: slicePosition.y + AUTOMATION_SLICE.processor.offsetY,
+    };
+    const commandPosition = {
+        x: slicePosition.x + AUTOMATION_SLICE.command.offsetX,
+        y: slicePosition.y + AUTOMATION_SLICE.command.offsetY,
+    };
+    const eventPosition = {
+        x: slicePosition.x + AUTOMATION_SLICE.event.offsetX,
+        y: slicePosition.y + AUTOMATION_SLICE.event.offsetY,
+    };
+    // Emit atomic events in sequence
+    // 1. Create the slice
+    appendEvent(filePath, {
+        type: 'SlicePlaced',
+        sliceId,
+        name: input.sliceName,
+        position: slicePosition,
+        size: { width: AUTOMATION_SLICE.width, height: AUTOMATION_SLICE.height },
+        timestamp: Date.now(),
+    });
+    // 2. Create the processor
+    appendEvent(filePath, {
+        type: 'ProcessorPlaced',
+        processorId,
+        name: input.processor.name,
+        position: processorPosition,
+        width: AUTOMATION_SLICE.processor.width,
+        height: AUTOMATION_SLICE.processor.height,
+        timestamp: Date.now(),
+    });
+    // 3. Create the command
+    appendEvent(filePath, {
+        type: 'CommandStickyPlaced',
+        commandStickyId: commandId,
+        name: input.command.name,
+        position: commandPosition,
+        width: AUTOMATION_SLICE.command.width,
+        height: AUTOMATION_SLICE.command.height,
+        timestamp: Date.now(),
+    });
+    // 4. Add command fields
+    for (const field of commandFields) {
+        appendEvent(filePath, {
+            type: 'CommandFieldAdded',
+            commandStickyId: commandId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 5. Create the event
+    appendEvent(filePath, {
+        type: 'EventStickyPlaced',
+        eventStickyId: eventId,
+        name: input.event.name,
+        position: eventPosition,
+        width: AUTOMATION_SLICE.event.width,
+        height: AUTOMATION_SLICE.event.height,
+        timestamp: Date.now(),
+    });
+    // 6. Add event fields
+    for (const field of eventFields) {
+        appendEvent(filePath, {
+            type: 'EventFieldAdded',
+            eventStickyId: eventId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 7. Create processor -> command flow
+    appendEvent(filePath, {
+        type: 'ProcessorToCommandFlowSpecified',
+        flowId: processorToCommandFlowId,
+        processorId,
+        commandStickyId: commandId,
+        sourceHandle: 'bottom-source',
+        targetHandle: 'top-target',
+        timestamp: Date.now(),
+    });
+    // 8. Create command -> event flow
+    appendEvent(filePath, {
+        type: 'CommandToEventFlowSpecified',
+        flowId: commandToEventFlowId,
+        commandStickyId: commandId,
+        eventStickyId: eventId,
+        sourceHandle: 'bottom-source',
+        targetHandle: 'top-target',
+        timestamp: Date.now(),
+    });
+    // 9. Add command -> event field mappings
+    if (commandToEventMappings.length > 0) {
+        appendEvent(filePath, {
+            type: 'FieldMappingSpecified',
+            flowId: commandToEventFlowId,
+            mappings: commandToEventMappings,
+            timestamp: Date.now(),
+        });
+    }
+    console.log(`Created automation slice "${input.sliceName}"`);
+    console.log(`  Processor: ${input.processor.name}`);
+    console.log(`  Command: ${input.command.name} (${commandFields.length} fields)`);
+    console.log(`  Event: ${input.event.name} (${eventFields.length} fields)`);
+    console.log(`  Command -> Event mappings: ${commandToEventMappings.length}`);
+}

package/dist/slices/create-flow/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function createFlow(model: EventModel, filePath: string, fromName: string, toName: string): void;

package/dist/slices/create-flow/index.js

@@ -0,0 +1,177 @@
+import { appendEvent } from '../../lib/file-loader.js';
+import { findElement } from '../../lib/element-lookup.js';
+function findSource(model, name) {
+    // Try events first
+    const eventResult = findElement(model.events, name);
+    if (eventResult.success) {
+        return { type: 'event', element: eventResult.element };
+    }
+    // Try read models
+    const readModelResult = findElement(model.readModels, name);
+    if (readModelResult.success) {
+        return { type: 'readModel', element: readModelResult.element };
+    }
+    return null;
+}
+function findTarget(model, name) {
+    // Try read models first
+    const readModelResult = findElement(model.readModels, name);
+    if (readModelResult.success) {
+        return { type: 'readModel', element: readModelResult.element };
+    }
+    // Try screens
+    const screenResult = findElement(model.screens, name);
+    if (screenResult.success) {
+        return { type: 'screen', element: screenResult.element };
+    }
+    // Try processors
+    const processorResult = findElement(model.processors, name);
+    if (processorResult.success) {
+        return { type: 'processor', element: processorResult.element };
+    }
+    return null;
+}
+function listAvailableSources(model) {
+    const sources = [];
+    for (const event of model.events.values()) {
+        sources.push(`  - Event: "${event.name}"`);
+    }
+    for (const rm of model.readModels.values()) {
+        sources.push(`  - ReadModel: "${rm.name}"`);
+    }
+    return sources;
+}
+function listAvailableTargets(model) {
+    const targets = [];
+    for (const rm of model.readModels.values()) {
+        targets.push(`  - ReadModel: "${rm.name}"`);
+    }
+    for (const screen of model.screens.values()) {
+        targets.push(`  - Screen: "${screen.name}"`);
+    }
+    for (const proc of model.processors.values()) {
+        targets.push(`  - Processor: "${proc.name}"`);
+    }
+    return targets;
+}
+function flowExists(model, sourceId, targetId) {
+    for (const flow of model.flows.values()) {
+        if (flow.sourceId === sourceId && flow.targetId === targetId) {
+            return true;
+        }
+    }
+    return false;
+}
+export function createFlow(model, filePath, fromName, toName) {
+    // Find source element
+    const source = findSource(model, fromName);
+    if (!source) {
+        console.error(`Error: Source not found: "${fromName}"`);
+        console.error('Valid sources are events or read models.');
+        const available = listAvailableSources(model);
+        if (available.length > 0) {
+            console.error('Available sources:');
+            available.forEach(s => console.error(s));
+        }
+        process.exit(1);
+    }
+    // Find target element
+    const target = findTarget(model, toName);
+    if (!target) {
+        console.error(`Error: Target not found: "${toName}"`);
+        console.error('Valid targets are read models, screens, or processors.');
+        const available = listAvailableTargets(model);
+        if (available.length > 0) {
+            console.error('Available targets:');
+            available.forEach(t => console.error(t));
+        }
+        process.exit(1);
+    }
+    // Validate the flow combination
+    const flowId = crypto.randomUUID();
+    let event;
+    if (source.type === 'event' && target.type === 'readModel') {
+        // Event → ReadModel (event top → read model bottom)
+        if (flowExists(model, source.element.id, target.element.id)) {
+            console.error(`Error: Flow already exists from "${source.element.name}" to "${target.element.name}"`);
+            process.exit(1);
+        }
+        event = {
+            type: 'EventToReadModelFlowSpecified',
+            flowId,
+            eventStickyId: source.element.id,
+            readModelStickyId: target.element.id,
+            sourceHandle: 'top-source',
+            targetHandle: 'bottom-target',
+            timestamp: Date.now(),
+        };
+        appendEvent(filePath, event);
+        console.log(`Created flow: Event "${source.element.name}" → ReadModel "${target.element.name}"`);
+    }
+    else if (source.type === 'readModel' && target.type === 'screen') {
+        // ReadModel → Screen (read model top → screen bottom)
+        if (flowExists(model, source.element.id, target.element.id)) {
+            console.error(`Error: Flow already exists from "${source.element.name}" to "${target.element.name}"`);
+            process.exit(1);
+        }
+        event = {
+            type: 'ReadModelToScreenFlowSpecified',
+            flowId,
+            readModelStickyId: source.element.id,
+            screenId: target.element.id,
+            sourceHandle: 'top-source',
+            targetHandle: 'bottom-target',
+            timestamp: Date.now(),
+        };
+        appendEvent(filePath, event);
+        console.log(`Created flow: ReadModel "${source.element.name}" → Screen "${target.element.name}"`);
+    }
+    else if (source.type === 'readModel' && target.type === 'processor') {
+        // ReadModel → Processor (read model top → processor bottom)
+        if (flowExists(model, source.element.id, target.element.id)) {
+            console.error(`Error: Flow already exists from "${source.element.name}" to "${target.element.name}"`);
+            process.exit(1);
+        }
+        event = {
+            type: 'ReadModelToProcessorFlowSpecified',
+            flowId,
+            readModelStickyId: source.element.id,
+            processorId: target.element.id,
+            sourceHandle: 'top-source',
+            targetHandle: 'bottom-target',
+            timestamp: Date.now(),
+        };
+        appendEvent(filePath, event);
+        console.log(`Created flow: ReadModel "${source.element.name}" → Processor "${target.element.name}"`);
+    }
+    else if (source.type === 'event' && target.type === 'screen') {
+        console.error('Error: Cannot create flow directly from Event to Screen.');
+        console.error('Events flow to ReadModels, which then flow to Screens.');
+        console.error('Create a ReadModel first, then:');
+        console.error(`  1. eventmodeler create flow --from "${source.element.name}" --to "<ReadModelName>"`);
+        console.error(`  2. eventmodeler create flow --from "<ReadModelName>" --to "${target.element.name}"`);
+        process.exit(1);
+    }
+    else if (source.type === 'event' && target.type === 'processor') {
+        console.error('Error: Cannot create flow directly from Event to Processor.');
+        console.error('Events flow to ReadModels, which then flow to Processors.');
+        console.error('Create a ReadModel first, then:');
+        console.error(`  1. eventmodeler create flow --from "${source.element.name}" --to "<ReadModelName>"`);
+        console.error(`  2. eventmodeler create flow --from "<ReadModelName>" --to "${target.element.name}"`);
+        process.exit(1);
+    }
+    else if (source.type === 'readModel' && target.type === 'readModel') {
+        console.error('Error: Cannot create flow from ReadModel to ReadModel.');
+        console.error('ReadModels receive data from Events and provide data to Screens or Processors.');
+        process.exit(1);
+    }
+    else {
+        console.error(`Error: Invalid flow combination: ${source.type} → ${target.type}`);
+        console.error('Valid combinations:');
+        console.error('  - Event → ReadModel');
+        console.error('  - ReadModel → Screen');
+        console.error('  - ReadModel → Processor');
+        process.exit(1);
+    }
+    console.log(`Use 'eventmodeler map fields --flow "${fromName}→${toName}"' to set field mappings.`);
+}

package/dist/slices/create-state-change-slice/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function createStateChangeSlice(model: EventModel, filePath: string, xmlInput: string): void;