eventmodeler 0.2.1 → 0.2.4

package/dist/lib/slice-utils.d.ts

@@ -0,0 +1,83 @@
+import type { EventModel, Field, FieldMapping, Slice } from '../types.js';
+export declare const STATE_CHANGE_SLICE: {
+    width: number;
+    height: number;
+    screen: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    command: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    event: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+};
+export declare const AUTOMATION_SLICE: {
+    width: number;
+    height: number;
+    processor: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    command: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    event: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+};
+export declare const STATE_VIEW_SLICE: {
+    width: number;
+    height: number;
+    readModel: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+};
+export declare const SLICE_GAP = 20;
+export interface PositionReference {
+    after?: string;
+    before?: string;
+}
+export declare function findSliceByName(model: EventModel, name: string): Slice | undefined;
+export declare function validateSliceNameUnique(model: EventModel, name: string): void;
+export declare function calculateSlicePosition(model: EventModel, sliceWidth: number, ref: PositionReference): {
+    x: number;
+    y: number;
+};
+export declare function getSlicesToShift(model: EventModel, insertX: number, shiftAmount: number): Array<{
+    sliceId: string;
+    newX: number;
+    currentY: number;
+}>;
+export declare function inferFieldMappings(sourceFields: Field[], targetFields: Field[]): FieldMapping[];
+export interface FieldInput {
+    name: string;
+    type: string;
+    isList?: boolean;
+    isGenerated?: boolean;
+    isOptional?: boolean;
+    isUserInput?: boolean;
+    subfields?: FieldInput[];
+}
+export declare function parseFieldsFromXml(xml: string): FieldInput[];
+export declare function fieldInputToField(input: FieldInput): Field;

package/dist/lib/slice-utils.js

@@ -0,0 +1,135 @@
+// Fixed dimensions from requirements
+export const STATE_CHANGE_SLICE = {
+    width: 560,
+    height: 1000,
+    screen: { width: 180, height: 120, offsetX: 40, offsetY: 120 },
+    command: { width: 160, height: 100, offsetX: 180, offsetY: 460 },
+    event: { width: 160, height: 100, offsetX: 360, offsetY: 860 },
+};
+export const AUTOMATION_SLICE = {
+    width: 560,
+    height: 1000,
+    processor: { width: 120, height: 120, offsetX: 40, offsetY: 120 },
+    command: { width: 160, height: 100, offsetX: 180, offsetY: 460 },
+    event: { width: 160, height: 100, offsetX: 360, offsetY: 860 },
+};
+export const STATE_VIEW_SLICE = {
+    width: 380,
+    height: 1000,
+    readModel: { width: 160, height: 100, offsetX: 110, offsetY: 460 },
+};
+export const SLICE_GAP = 20;
+export function findSliceByName(model, name) {
+    const nameLower = name.toLowerCase();
+    return [...model.slices.values()].find(s => s.name.toLowerCase() === nameLower || s.name.toLowerCase().includes(nameLower));
+}
+export function validateSliceNameUnique(model, name) {
+    const existing = findSliceByName(model, name);
+    if (existing && existing.name.toLowerCase() === name.toLowerCase()) {
+        throw new Error(`Slice "${name}" already exists`);
+    }
+}
+export function calculateSlicePosition(model, sliceWidth, ref) {
+    const slices = [...model.slices.values()];
+    if (slices.length === 0) {
+        return { x: 0, y: 0 };
+    }
+    if (ref.after) {
+        const refSlice = findSliceByName(model, ref.after);
+        if (!refSlice) {
+            const available = slices.map(s => s.name).join(', ');
+            throw new Error(`Slice "${ref.after}" not found. Available: ${available}`);
+        }
+        return {
+            x: refSlice.position.x + refSlice.size.width + SLICE_GAP,
+            y: refSlice.position.y
+        };
+    }
+    if (ref.before) {
+        const refSlice = findSliceByName(model, ref.before);
+        if (!refSlice) {
+            const available = slices.map(s => s.name).join(', ');
+            throw new Error(`Slice "${ref.before}" not found. Available: ${available}`);
+        }
+        return {
+            x: refSlice.position.x,
+            y: refSlice.position.y
+        };
+    }
+    // Default: append to end (right of rightmost slice)
+    const rightmost = slices.reduce((max, s) => Math.max(max, s.position.x + s.size.width), 0);
+    const avgY = slices.reduce((sum, s) => sum + s.position.y, 0) / slices.length;
+    return {
+        x: rightmost + SLICE_GAP,
+        y: avgY
+    };
+}
+export function getSlicesToShift(model, insertX, shiftAmount) {
+    return [...model.slices.values()]
+        .filter(s => s.position.x >= insertX)
+        .map(s => ({
+        sliceId: s.id,
+        newX: s.position.x + shiftAmount,
+        currentY: s.position.y
+    }));
+}
+export function inferFieldMappings(sourceFields, targetFields) {
+    const mappings = [];
+    for (const targetField of targetFields) {
+        // Skip generated fields - they have no source
+        if (targetField.isGenerated)
+            continue;
+        // Find source field with matching name (case-insensitive)
+        const sourceField = sourceFields.find(sf => sf.name.toLowerCase() === targetField.name.toLowerCase());
+        if (sourceField) {
+            mappings.push({
+                sourceFieldId: sourceField.id,
+                targetFieldId: targetField.id
+            });
+        }
+    }
+    return mappings;
+}
+function getAttr(attrs, name) {
+    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
+    return match ? match[1] : undefined;
+}
+export function parseFieldsFromXml(xml) {
+    const fields = [];
+    // Match top-level field elements only (not nested inside other fields)
+    const fieldMatches = xml.matchAll(/<field([^>]*?)(?:\/>|>([\s\S]*?)<\/field>)/g);
+    for (const match of fieldMatches) {
+        const attrs = match[1];
+        const content = match[2];
+        const name = getAttr(attrs, 'name');
+        const type = getAttr(attrs, 'type');
+        if (!name || !type)
+            continue;
+        const field = {
+            name,
+            type,
+            isList: getAttr(attrs, 'list') === 'true',
+            isGenerated: getAttr(attrs, 'generated') === 'true',
+            isOptional: getAttr(attrs, 'optional') === 'true',
+            isUserInput: getAttr(attrs, 'user-input') === 'true',
+        };
+        // Parse nested subfields for Custom type
+        if (type === 'Custom' && content) {
+            field.subfields = parseFieldsFromXml(content);
+        }
+        fields.push(field);
+    }
+    return fields;
+}
+export function fieldInputToField(input) {
+    return {
+        id: crypto.randomUUID(),
+        name: input.name,
+        fieldType: input.type,
+        isList: input.isList ?? false,
+        isGenerated: input.isGenerated ?? false,
+        isOptional: input.isOptional,
+        isUserInput: input.isUserInput,
+        subfields: input.subfields?.map(fieldInputToField),
+    };
+}

package/dist/projection.js

@@ -824,6 +824,157 @@ function applyEvent(model, event) {
         case 'ScreenDesignUpdated':
             // Screen designs are visual-only, not relevant for CLI
             break;
+        // Compound slice placement events - place entire slices atomically
+        case 'StateChangeSlicePlaced': {
+            // Create slice
+            model.slices.set(event.sliceId, {
+                id: event.sliceId,
+                name: event.sliceName,
+                status: 'created',
+                position: event.slicePosition,
+                size: event.sliceSize,
+                nodeIds: [event.screenId, event.commandId, event.eventId],
+            });
+            // Create screen
+            model.screens.set(event.screenId, {
+                id: event.screenId,
+                name: event.screenName,
+                fields: event.screenFields,
+                position: event.screenPosition,
+                width: event.screenSize.width,
+                height: event.screenSize.height,
+            });
+            // Create command
+            model.commands.set(event.commandId, {
+                id: event.commandId,
+                name: event.commandName,
+                fields: event.commandFields,
+                position: event.commandPosition,
+                width: event.commandSize.width,
+                height: event.commandSize.height,
+            });
+            // Create event
+            model.events.set(event.eventId, {
+                id: event.eventId,
+                name: event.eventName,
+                fields: event.eventFields,
+                position: event.eventPosition,
+                width: event.eventSize.width,
+                height: event.eventSize.height,
+            });
+            // Create screen->command flow
+            model.flows.set(event.screenToCommandFlowId, {
+                id: event.screenToCommandFlowId,
+                flowType: 'ScreenToCommand',
+                sourceId: event.screenId,
+                targetId: event.commandId,
+                fieldMappings: event.screenToCommandMappings,
+            });
+            // Create command->event flow
+            model.flows.set(event.commandToEventFlowId, {
+                id: event.commandToEventFlowId,
+                flowType: 'CommandToEvent',
+                sourceId: event.commandId,
+                targetId: event.eventId,
+                fieldMappings: event.commandToEventMappings,
+            });
+            break;
+        }
+        case 'AutomationSlicePlaced': {
+            // Create slice
+            model.slices.set(event.sliceId, {
+                id: event.sliceId,
+                name: event.sliceName,
+                status: 'created',
+                position: event.slicePosition,
+                size: event.sliceSize,
+                nodeIds: [event.processorId, event.commandId, event.eventId],
+            });
+            // Create processor
+            model.processors.set(event.processorId, {
+                id: event.processorId,
+                name: event.processorName,
+                fields: [],
+                position: event.processorPosition,
+                width: event.processorSize.width,
+                height: event.processorSize.height,
+            });
+            // Create command
+            model.commands.set(event.commandId, {
+                id: event.commandId,
+                name: event.commandName,
+                fields: event.commandFields,
+                position: event.commandPosition,
+                width: event.commandSize.width,
+                height: event.commandSize.height,
+            });
+            // Create event
+            model.events.set(event.eventId, {
+                id: event.eventId,
+                name: event.eventName,
+                fields: event.eventFields,
+                position: event.eventPosition,
+                width: event.eventSize.width,
+                height: event.eventSize.height,
+            });
+            // Create processor->command flow
+            model.flows.set(event.processorToCommandFlowId, {
+                id: event.processorToCommandFlowId,
+                flowType: 'ProcessorToCommand',
+                sourceId: event.processorId,
+                targetId: event.commandId,
+                fieldMappings: [],
+            });
+            // Create command->event flow
+            model.flows.set(event.commandToEventFlowId, {
+                id: event.commandToEventFlowId,
+                flowType: 'CommandToEvent',
+                sourceId: event.commandId,
+                targetId: event.eventId,
+                fieldMappings: event.commandToEventMappings,
+            });
+            break;
+        }
+        case 'StateViewSlicePlaced': {
+            // Create slice
+            model.slices.set(event.sliceId, {
+                id: event.sliceId,
+                name: event.sliceName,
+                status: 'created',
+                position: event.slicePosition,
+                size: event.sliceSize,
+                nodeIds: [event.readModelId],
+            });
+            // Create read model
+            model.readModels.set(event.readModelId, {
+                id: event.readModelId,
+                name: event.readModelName,
+                fields: event.readModelFields,
+                position: event.readModelPosition,
+                width: event.readModelSize.width,
+                height: event.readModelSize.height,
+            });
+            break;
+        }
+    }
+}
+// Merge propagated fields with existing fields:
+// - If a field with the same name exists, update its subfields
+// - If it doesn't exist, add as new field
+function mergeFieldsInto(existingFields, propagatedFields) {
+    for (const propagatedField of propagatedFields) {
+        const existingIdx = existingFields.findIndex(f => f.name === propagatedField.name);
+        if (existingIdx !== -1) {
+            // Field exists - update its subfields
+            existingFields[existingIdx] = {
+                ...existingFields[existingIdx],
+                subfields: propagatedField.subfields,
+            };
+        }
+        else {
+            // New field - add it
+            existingFields.push(propagatedField);
+        }
     }
 }
 function handleFieldPropagation(model, event) {
@@ -831,52 +982,27 @@ function handleFieldPropagation(model, event) {
     // Determine target based on event type
     if ('eventStickyId' in event) {
         const evt = model.events.get(event.eventStickyId);
-        if (evt) {
-            for (const field of fields) {
-                if (!evt.fields.some(f => f.name === field.name)) {
-                    evt.fields.push(field);
-                }
-            }
-        }
+        if (evt)
+            mergeFieldsInto(evt.fields, fields);
     }
     else if ('commandStickyId' in event) {
         const cmd = model.commands.get(event.commandStickyId);
-        if (cmd) {
-            for (const field of fields) {
-                if (!cmd.fields.some(f => f.name === field.name)) {
-                    cmd.fields.push(field);
-                }
-            }
-        }
+        if (cmd)
+            mergeFieldsInto(cmd.fields, fields);
     }
     else if ('readModelStickyId' in event) {
         const rm = model.readModels.get(event.readModelStickyId);
-        if (rm) {
-            for (const field of fields) {
-                if (!rm.fields.some(f => f.name === field.name)) {
-                    rm.fields.push(field);
-                }
-            }
-        }
+        if (rm)
+            mergeFieldsInto(rm.fields, fields);
     }
     else if ('screenId' in event) {
         const scr = model.screens.get(event.screenId);
-        if (scr) {
-            for (const field of fields) {
-                if (!scr.fields.some(f => f.name === field.name)) {
-                    scr.fields.push(field);
-                }
-            }
-        }
+        if (scr)
+            mergeFieldsInto(scr.fields, fields);
     }
     else if ('processorId' in event) {
         const proc = model.processors.get(event.processorId);
-        if (proc) {
-            for (const field of fields) {
-                if (!proc.fields.some(f => f.name === field.name)) {
-                    proc.fields.push(field);
-                }
-            }
-        }
+        if (proc)
+            mergeFieldsInto(proc.fields, fields);
     }
 }

package/dist/slices/add-field/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';
 const validFieldTypes = ['UUID', 'Boolean', 'Double', 'Decimal', 'Date', 'DateTime', 'Long', 'Int', 'String', 'Custom'];
 function parseJsonInput(input) {
     return JSON.parse(input);
@@ -103,17 +104,7 @@ export function addField(model, filePath, options, input) {
     }
 }
 function addFieldToCommand(model, filePath, commandName, fieldInput) {
-    const nameLower = commandName.toLowerCase();
-    const commands = [...model.commands.values()];
-    const command = commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
-    if (!command) {
-        console.error(`Error: Command not found: ${commandName}`);
-        console.error('Available commands:');
-        for (const c of commands) {
-            console.error(`  - ${c.name}`);
-        }
-        process.exit(1);
-    }
+    const command = findElementOrExit(model.commands, commandName, 'command');
     // Check for duplicate field name
     if (command.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
         console.error(`Error: Field "${fieldInput.name}" already exists on command "${command.name}"`);
@@ -129,17 +120,7 @@ function addFieldToCommand(model, filePath, commandName, fieldInput) {
     console.log(`Added field "${field.name}" to command "${command.name}"`);
 }
 function addFieldToEvent(model, filePath, eventName, fieldInput) {
-    const nameLower = eventName.toLowerCase();
-    const events = [...model.events.values()];
-    const event = events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
-    if (!event) {
-        console.error(`Error: Event not found: ${eventName}`);
-        console.error('Available events:');
-        for (const e of events) {
-            console.error(`  - ${e.name}`);
-        }
-        process.exit(1);
-    }
+    const event = findElementOrExit(model.events, eventName, 'event');
     // Check for duplicate field name
     if (event.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
         console.error(`Error: Field "${fieldInput.name}" already exists on event "${event.name}"`);
@@ -155,17 +136,7 @@ function addFieldToEvent(model, filePath, eventName, fieldInput) {
     console.log(`Added field "${field.name}" to event "${event.name}"`);
 }
 function addFieldToReadModel(model, filePath, readModelName, fieldInput) {
-    const nameLower = readModelName.toLowerCase();
-    const readModels = [...model.readModels.values()];
-    const readModel = readModels.find(rm => rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower));
-    if (!readModel) {
-        console.error(`Error: Read model not found: ${readModelName}`);
-        console.error('Available read models:');
-        for (const rm of readModels) {
-            console.error(`  - ${rm.name}`);
-        }
-        process.exit(1);
-    }
+    const readModel = findElementOrExit(model.readModels, readModelName, 'read model');
     // Check for duplicate field name
     if (readModel.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
         console.error(`Error: Field "${fieldInput.name}" already exists on read model "${readModel.name}"`);

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;