eventmodeler 0.5.0 → 0.6.0

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

@@ -1,304 +0,0 @@
-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 read-model
-    const readModelMatch = xml.match(/<read-model([^>]*)>([\s\S]*?)<\/read-model>/);
-    if (!readModelMatch) {
-        throw new Error('Invalid XML: missing <read-model> element');
-    }
-    const readModelName = getAttr(readModelMatch[1], 'name');
-    if (!readModelName) {
-        throw new Error('Invalid XML: read-model must have a name attribute');
-    }
-    const readModelFields = parseFieldsFromXml(readModelMatch[2]);
-    // 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,
-        readModel: { name: readModelName, fields: readModelFields },
-        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',
-                data: {
-                    sliceId,
-                    position: { x: newX, y: currentY },
-                    timestamp: Date.now(),
-                },
-            });
-        }
-    }
-    // Generate IDs
-    const sliceId = crypto.randomUUID();
-    const readModelId = crypto.randomUUID();
-    const processorId = crypto.randomUUID();
-    const commandId = crypto.randomUUID();
-    const eventId = crypto.randomUUID();
-    const readModelToProcessorFlowId = crypto.randomUUID();
-    const processorToCommandFlowId = crypto.randomUUID();
-    const commandToEventFlowId = crypto.randomUUID();
-    // Convert field inputs to fields with IDs
-    const readModelFields = input.readModel.fields.map(fieldInputToField);
-    const commandFields = input.command.fields.map(fieldInputToField);
-    const eventFields = input.event.fields.map(fieldInputToField);
-    // Infer field mappings
-    const readModelToCommandMappings = inferFieldMappings(readModelFields, commandFields);
-    const commandToEventMappings = inferFieldMappings(commandFields, eventFields);
-    // Calculate absolute positions for components within the slice
-    const readModelPosition = {
-        x: slicePosition.x + AUTOMATION_SLICE.readModel.offsetX,
-        y: slicePosition.y + AUTOMATION_SLICE.readModel.offsetY,
-    };
-    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',
-        data: {
-            sliceId,
-            name: input.sliceName,
-            position: slicePosition,
-            size: { width: AUTOMATION_SLICE.width, height: AUTOMATION_SLICE.height },
-            timestamp: Date.now(),
-        },
-    });
-    // 2. Create the read model
-    appendEvent(filePath, {
-        type: 'ReadModelStickyPlaced',
-        data: {
-            readModelStickyId: readModelId,
-            name: input.readModel.name,
-            position: readModelPosition,
-            width: AUTOMATION_SLICE.readModel.width,
-            height: AUTOMATION_SLICE.readModel.height,
-            timestamp: Date.now(),
-        },
-    });
-    // 3. Add read model fields
-    for (const field of readModelFields) {
-        appendEvent(filePath, {
-            type: 'ReadModelFieldAdded',
-            data: {
-                readModelStickyId: readModelId,
-                field,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // 4. Create the processor
-    appendEvent(filePath, {
-        type: 'ProcessorPlaced',
-        data: {
-            processorId,
-            name: input.processor.name,
-            position: processorPosition,
-            width: AUTOMATION_SLICE.processor.width,
-            height: AUTOMATION_SLICE.processor.height,
-            timestamp: Date.now(),
-        },
-    });
-    // 5. Create the command
-    appendEvent(filePath, {
-        type: 'CommandStickyPlaced',
-        data: {
-            commandStickyId: commandId,
-            name: input.command.name,
-            position: commandPosition,
-            width: AUTOMATION_SLICE.command.width,
-            height: AUTOMATION_SLICE.command.height,
-            timestamp: Date.now(),
-        },
-    });
-    // 6. Add command fields
-    for (const field of commandFields) {
-        appendEvent(filePath, {
-            type: 'CommandFieldAdded',
-            data: {
-                commandStickyId: commandId,
-                field,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // 7. Create the event
-    appendEvent(filePath, {
-        type: 'EventStickyPlaced',
-        data: {
-            eventStickyId: eventId,
-            name: input.event.name,
-            position: eventPosition,
-            width: AUTOMATION_SLICE.event.width,
-            height: AUTOMATION_SLICE.event.height,
-            timestamp: Date.now(),
-        },
-    });
-    // 8. Add event fields
-    for (const field of eventFields) {
-        appendEvent(filePath, {
-            type: 'EventFieldAdded',
-            data: {
-                eventStickyId: eventId,
-                field,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // 9. Create read model -> processor flow
-    appendEvent(filePath, {
-        type: 'ReadModelToProcessorFlowSpecified',
-        data: {
-            flowId: readModelToProcessorFlowId,
-            readModelStickyId: readModelId,
-            processorId,
-            sourceHandle: 'top-source',
-            targetHandle: 'bottom-target',
-            timestamp: Date.now(),
-        },
-    });
-    // 10. Add read model -> command field mappings
-    if (readModelToCommandMappings.length > 0) {
-        appendEvent(filePath, {
-            type: 'FieldMappingSpecified',
-            data: {
-                flowId: readModelToProcessorFlowId,
-                mappings: readModelToCommandMappings,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // 11. Create processor -> command flow
-    appendEvent(filePath, {
-        type: 'ProcessorToCommandFlowSpecified',
-        data: {
-            flowId: processorToCommandFlowId,
-            processorId,
-            commandStickyId: commandId,
-            sourceHandle: 'bottom-source',
-            targetHandle: 'top-target',
-            timestamp: Date.now(),
-        },
-    });
-    // 12. Create command -> event flow
-    appendEvent(filePath, {
-        type: 'CommandToEventFlowSpecified',
-        data: {
-            flowId: commandToEventFlowId,
-            commandStickyId: commandId,
-            eventStickyId: eventId,
-            sourceHandle: 'bottom-source',
-            targetHandle: 'top-target',
-            timestamp: Date.now(),
-        },
-    });
-    // 13. Add command -> event field mappings
-    if (commandToEventMappings.length > 0) {
-        appendEvent(filePath, {
-            type: 'FieldMappingSpecified',
-            data: {
-                flowId: commandToEventFlowId,
-                mappings: commandToEventMappings,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    console.log(`Created automation slice "${input.sliceName}"`);
-    console.log(`  ReadModel: ${input.readModel.name} (${readModelFields.length} fields)`);
-    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(`  ReadModel -> Command mappings: ${readModelToCommandMappings.length}`);
-    console.log(`  Command -> Event mappings: ${commandToEventMappings.length}`);
-}

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

@@ -1,2 +0,0 @@
-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

@@ -1,183 +0,0 @@
-import { appendEvent } from '../../lib/file-loader.js';
-import { findElement, excludeLinkedCopies } from '../../lib/element-lookup.js';
-function findSource(model, name) {
-    // Try events first (exclude linked copies - they share identity with canonical original)
-    const eventResult = findElement(excludeLinkedCopies(model.events), name);
-    if (eventResult.success) {
-        return { type: 'event', element: eventResult.element };
-    }
-    // Try read models (exclude linked copies)
-    const readModelResult = findElement(excludeLinkedCopies(model.readModels), name);
-    if (readModelResult.success) {
-        return { type: 'readModel', element: readModelResult.element };
-    }
-    return null;
-}
-function findTarget(model, name) {
-    // Try read models first (exclude linked copies)
-    const readModelResult = findElement(excludeLinkedCopies(model.readModels), name);
-    if (readModelResult.success) {
-        return { type: 'readModel', element: readModelResult.element };
-    }
-    // Try screens (exclude linked copies)
-    const screenResult = findElement(excludeLinkedCopies(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',
-            data: {
-                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',
-            data: {
-                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',
-            data: {
-                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

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