eventmodeler 0.1.0

package/dist/projection.js

@@ -0,0 +1,781 @@
+export function createEmptyModel() {
+    return {
+        modelId: '',
+        name: '',
+        commands: new Map(),
+        events: new Map(),
+        readModels: new Map(),
+        screens: new Map(),
+        processors: new Map(),
+        slices: new Map(),
+        chapters: new Map(),
+        scenarios: new Map(),
+        flows: new Map(),
+    };
+}
+export function projectEvents(rawEvents) {
+    const model = createEmptyModel();
+    for (const event of rawEvents) {
+        applyEvent(model, event);
+    }
+    return model;
+}
+function applyEvent(model, event) {
+    switch (event.type) {
+        // Model creation
+        case 'EventModelCreated':
+            model.modelId = event.modelId;
+            model.name = event.name;
+            break;
+        // Command sticky events
+        case 'CommandStickyPlaced':
+            model.commands.set(event.commandStickyId, {
+                id: event.commandStickyId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            break;
+        case 'CommandStickyMoved': {
+            const cmd = model.commands.get(event.commandStickyId);
+            if (cmd)
+                cmd.position = event.position;
+            break;
+        }
+        case 'CommandStickyRemoved':
+            model.commands.delete(event.commandStickyId);
+            break;
+        case 'CommandRenamed': {
+            const cmd = model.commands.get(event.commandStickyId);
+            if (cmd)
+                cmd.name = event.name;
+            break;
+        }
+        case 'CommandFieldAdded': {
+            const cmd = model.commands.get(event.commandStickyId);
+            if (cmd)
+                cmd.fields.push(event.field);
+            break;
+        }
+        case 'CommandFieldRemoved': {
+            const cmd = model.commands.get(event.commandStickyId);
+            if (cmd)
+                cmd.fields = cmd.fields.filter(f => f.id !== event.fieldId);
+            break;
+        }
+        case 'CommandFieldAdjusted': {
+            const cmd = model.commands.get(event.commandStickyId);
+            if (cmd) {
+                const idx = cmd.fields.findIndex(f => f.id === event.fieldId);
+                if (idx !== -1) {
+                    cmd.fields[idx] = { ...event.field, id: event.fieldId };
+                }
+            }
+            break;
+        }
+        case 'CommandStickyDuplicated':
+            model.commands.set(event.commandStickyId, {
+                id: event.commandStickyId,
+                name: event.name,
+                fields: event.fields,
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            break;
+        // Event sticky events
+        case 'EventStickyPlaced':
+            model.events.set(event.eventStickyId, {
+                id: event.eventStickyId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            break;
+        case 'EventStickyMoved': {
+            const evt = model.events.get(event.eventStickyId);
+            if (evt)
+                evt.position = event.position;
+            break;
+        }
+        case 'EventStickyRemoved':
+            model.events.delete(event.eventStickyId);
+            break;
+        case 'EventRenamed': {
+            const evt = model.events.get(event.eventStickyId);
+            if (evt)
+                evt.name = event.name;
+            break;
+        }
+        case 'EventFieldAdded': {
+            const evt = model.events.get(event.eventStickyId);
+            if (evt)
+                evt.fields.push(event.field);
+            break;
+        }
+        case 'EventFieldRemoved': {
+            const evt = model.events.get(event.eventStickyId);
+            if (evt)
+                evt.fields = evt.fields.filter(f => f.id !== event.fieldId);
+            break;
+        }
+        case 'EventFieldAdjusted': {
+            const evt = model.events.get(event.eventStickyId);
+            if (evt) {
+                const idx = evt.fields.findIndex(f => f.id === event.fieldId);
+                if (idx !== -1) {
+                    evt.fields[idx] = { ...event.field, id: event.fieldId };
+                }
+            }
+            break;
+        }
+        case 'EventStickyLinkedCopyCreated': {
+            const source = model.events.get(event.sourceEventStickyId);
+            model.events.set(event.eventStickyId, {
+                id: event.eventStickyId,
+                name: source?.name ?? '',
+                fields: source?.fields ? [...source.fields] : [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+                canonicalId: event.canonicalId,
+            });
+            // Also set canonical on source if not already set
+            if (source && !source.canonicalId) {
+                source.canonicalId = event.canonicalId;
+            }
+            break;
+        }
+        case 'EventStickyCanonicalGroupRemoved': {
+            const canonicalId = event.canonicalId;
+            for (const [id, evt] of model.events) {
+                if (evt.canonicalId === canonicalId) {
+                    model.events.delete(id);
+                }
+            }
+            break;
+        }
+        // Read model sticky events
+        case 'ReadModelStickyPlaced':
+            model.readModels.set(event.readModelStickyId, {
+                id: event.readModelStickyId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            break;
+        case 'ReadModelStickyMoved': {
+            const rm = model.readModels.get(event.readModelStickyId);
+            if (rm)
+                rm.position = event.position;
+            break;
+        }
+        case 'ReadModelStickyRemoved':
+            model.readModels.delete(event.readModelStickyId);
+            break;
+        case 'ReadModelRenamed': {
+            const rm = model.readModels.get(event.readModelStickyId);
+            if (rm)
+                rm.name = event.name;
+            break;
+        }
+        case 'ReadModelFieldAdded': {
+            const rm = model.readModels.get(event.readModelStickyId);
+            if (rm)
+                rm.fields.push(event.field);
+            break;
+        }
+        case 'ReadModelFieldRemoved': {
+            const rm = model.readModels.get(event.readModelStickyId);
+            if (rm)
+                rm.fields = rm.fields.filter(f => f.id !== event.fieldId);
+            break;
+        }
+        case 'ReadModelFieldAdjusted': {
+            const rm = model.readModels.get(event.readModelStickyId);
+            if (rm) {
+                const idx = rm.fields.findIndex(f => f.id === event.fieldId);
+                if (idx !== -1) {
+                    rm.fields[idx] = { ...event.field, id: event.fieldId };
+                }
+            }
+            break;
+        }
+        case 'ReadModelStickyLinkedCopyCreated': {
+            const source = model.readModels.get(event.sourceReadModelStickyId);
+            model.readModels.set(event.readModelStickyId, {
+                id: event.readModelStickyId,
+                name: source?.name ?? '',
+                fields: source?.fields ? [...source.fields] : [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+                canonicalId: event.canonicalId,
+            });
+            if (source && !source.canonicalId) {
+                source.canonicalId = event.canonicalId;
+            }
+            break;
+        }
+        case 'ReadModelStickyCanonicalGroupRemoved': {
+            const canonicalId = event.canonicalId;
+            for (const [id, rm] of model.readModels) {
+                if (rm.canonicalId === canonicalId) {
+                    model.readModels.delete(id);
+                }
+            }
+            break;
+        }
+        // Screen events
+        case 'ScreenPlaced':
+            model.screens.set(event.screenId, {
+                id: event.screenId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            break;
+        case 'ScreenMoved': {
+            const scr = model.screens.get(event.screenId);
+            if (scr)
+                scr.position = event.position;
+            break;
+        }
+        case 'ScreenRemoved':
+            model.screens.delete(event.screenId);
+            break;
+        case 'ScreenRenamed': {
+            const scr = model.screens.get(event.screenId);
+            if (scr)
+                scr.name = event.name;
+            break;
+        }
+        case 'ScreenFieldAdded': {
+            const scr = model.screens.get(event.screenId);
+            if (scr)
+                scr.fields.push(event.field);
+            break;
+        }
+        case 'ScreenFieldRemoved': {
+            const scr = model.screens.get(event.screenId);
+            if (scr)
+                scr.fields = scr.fields.filter(f => f.id !== event.fieldId);
+            break;
+        }
+        case 'ScreenFieldAdjusted': {
+            const scr = model.screens.get(event.screenId);
+            if (scr) {
+                const idx = scr.fields.findIndex(f => f.id === event.fieldId);
+                if (idx !== -1) {
+                    scr.fields[idx] = { ...event.field, id: event.fieldId };
+                }
+            }
+            break;
+        }
+        case 'ScreenLinkedCopyCreated': {
+            const source = model.screens.get(event.sourceScreenId);
+            model.screens.set(event.screenId, {
+                id: event.screenId,
+                name: source?.name ?? '',
+                fields: source?.fields ? [...source.fields] : [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+                canonicalId: event.canonicalId,
+            });
+            if (source && !source.canonicalId) {
+                source.canonicalId = event.canonicalId;
+            }
+            break;
+        }
+        case 'ScreenCanonicalGroupRemoved': {
+            const canonicalId = event.canonicalId;
+            for (const [id, scr] of model.screens) {
+                if (scr.canonicalId === canonicalId) {
+                    model.screens.delete(id);
+                }
+            }
+            break;
+        }
+        // Processor events
+        case 'ProcessorPlaced':
+            model.processors.set(event.processorId, {
+                id: event.processorId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            break;
+        case 'ProcessorMoved': {
+            const proc = model.processors.get(event.processorId);
+            if (proc)
+                proc.position = event.position;
+            break;
+        }
+        case 'ProcessorRemoved':
+            model.processors.delete(event.processorId);
+            break;
+        case 'ProcessorRenamed': {
+            const proc = model.processors.get(event.processorId);
+            if (proc)
+                proc.name = event.name;
+            break;
+        }
+        case 'ProcessorFieldAdded': {
+            const proc = model.processors.get(event.processorId);
+            if (proc)
+                proc.fields.push(event.field);
+            break;
+        }
+        case 'ProcessorFieldRemoved': {
+            const proc = model.processors.get(event.processorId);
+            if (proc)
+                proc.fields = proc.fields.filter(f => f.id !== event.fieldId);
+            break;
+        }
+        case 'ProcessorFieldAdjusted': {
+            const proc = model.processors.get(event.processorId);
+            if (proc) {
+                const idx = proc.fields.findIndex(f => f.id === event.fieldId);
+                if (idx !== -1) {
+                    proc.fields[idx] = { ...event.field, id: event.fieldId };
+                }
+            }
+            break;
+        }
+        case 'ProcessorDuplicated':
+            model.processors.set(event.processorId, {
+                id: event.processorId,
+                name: event.name,
+                fields: event.fields,
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            break;
+        // Slice events
+        case 'SlicePlaced':
+            model.slices.set(event.sliceId, {
+                id: event.sliceId,
+                name: event.name,
+                status: 'created',
+                position: event.position,
+                size: event.size,
+                nodeIds: [],
+            });
+            break;
+        case 'NodesGroupedIntoSlice':
+            model.slices.set(event.sliceId, {
+                id: event.sliceId,
+                name: event.name,
+                status: 'created',
+                position: event.position,
+                size: event.size,
+                nodeIds: event.nodeIds,
+            });
+            break;
+        case 'SliceMoved': {
+            const slice = model.slices.get(event.sliceId);
+            if (slice)
+                slice.position = event.position;
+            break;
+        }
+        case 'SliceResized': {
+            const slice = model.slices.get(event.sliceId);
+            if (slice) {
+                slice.position = event.position;
+                slice.size = event.size;
+            }
+            break;
+        }
+        case 'SliceRemoved':
+            model.slices.delete(event.sliceId);
+            break;
+        case 'SliceRenamed': {
+            const slice = model.slices.get(event.sliceId);
+            if (slice)
+                slice.name = event.name;
+            break;
+        }
+        case 'SliceMarkedAsCreated': {
+            const slice = model.slices.get(event.sliceId);
+            if (slice)
+                slice.status = 'created';
+            break;
+        }
+        case 'SliceMarkedAsInProgress': {
+            const slice = model.slices.get(event.sliceId);
+            if (slice)
+                slice.status = 'in-progress';
+            break;
+        }
+        case 'SliceMarkedAsBlocked': {
+            const slice = model.slices.get(event.sliceId);
+            if (slice)
+                slice.status = 'blocked';
+            break;
+        }
+        case 'SliceMarkedAsDone': {
+            const slice = model.slices.get(event.sliceId);
+            if (slice)
+                slice.status = 'done';
+            break;
+        }
+        case 'SlicesWidthEqualized': {
+            const width = event.width;
+            for (const sliceId of event.sliceIds) {
+                const slice = model.slices.get(sliceId);
+                if (slice)
+                    slice.size.width = width;
+            }
+            break;
+        }
+        case 'SlicesHeightEqualized': {
+            const height = event.height;
+            const y = event.y;
+            for (const sliceId of event.sliceIds) {
+                const slice = model.slices.get(sliceId);
+                if (slice) {
+                    slice.size.height = height;
+                    slice.position.y = y;
+                }
+            }
+            break;
+        }
+        case 'SliceDuplicated':
+            model.slices.set(event.sliceId, {
+                id: event.sliceId,
+                name: event.name,
+                status: event.status,
+                position: event.position,
+                size: event.size,
+                nodeIds: [],
+            });
+            break;
+        // Chapter events
+        case 'ChapterPlaced':
+            model.chapters.set(event.chapterId, {
+                id: event.chapterId,
+                name: event.name,
+                position: event.position,
+                size: event.size,
+            });
+            break;
+        case 'ChapterMoved': {
+            const chapter = model.chapters.get(event.chapterId);
+            if (chapter)
+                chapter.position = event.position;
+            break;
+        }
+        case 'ChapterResized': {
+            const chapter = model.chapters.get(event.chapterId);
+            if (chapter) {
+                chapter.position = event.position;
+                chapter.size = event.size;
+            }
+            break;
+        }
+        case 'ChapterRemoved':
+            model.chapters.delete(event.chapterId);
+            break;
+        case 'ChapterRenamed': {
+            const chapter = model.chapters.get(event.chapterId);
+            if (chapter)
+                chapter.name = event.name;
+            break;
+        }
+        // Flow events
+        case 'CommandToEventFlowSpecified':
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'CommandToEvent',
+                sourceId: event.commandStickyId,
+                targetId: event.eventStickyId,
+                fieldMappings: [],
+            });
+            break;
+        case 'EventToReadModelFlowSpecified':
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'EventToReadModel',
+                sourceId: event.eventStickyId,
+                targetId: event.readModelStickyId,
+                fieldMappings: [],
+            });
+            break;
+        case 'ReadModelToScreenFlowSpecified':
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'ReadModelToScreen',
+                sourceId: event.readModelStickyId,
+                targetId: event.screenId,
+                fieldMappings: [],
+            });
+            break;
+        case 'ReadModelToProcessorFlowSpecified':
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'ReadModelToProcessor',
+                sourceId: event.readModelStickyId,
+                targetId: event.processorId,
+                fieldMappings: [],
+            });
+            break;
+        case 'ScreenToCommandFlowSpecified':
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'ScreenToCommand',
+                sourceId: event.screenId,
+                targetId: event.commandStickyId,
+                fieldMappings: [],
+            });
+            break;
+        case 'ProcessorToCommandFlowSpecified':
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'ProcessorToCommand',
+                sourceId: event.processorId,
+                targetId: event.commandStickyId,
+                fieldMappings: [],
+            });
+            break;
+        case 'FlowRemoved':
+            model.flows.delete(event.flowId);
+            break;
+        case 'FieldMappingSpecified': {
+            const flow = model.flows.get(event.flowId);
+            if (flow)
+                flow.fieldMappings = event.mappings;
+            break;
+        }
+        case 'FieldMappingCleared': {
+            const flow = model.flows.get(event.flowId);
+            if (flow)
+                flow.fieldMappings = [];
+            break;
+        }
+        // Quick place events - create node and flow atomically
+        case 'CommandQuickPlacedFromScreen':
+            model.commands.set(event.commandStickyId, {
+                id: event.commandStickyId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'ScreenToCommand',
+                sourceId: event.screenId,
+                targetId: event.commandStickyId,
+                fieldMappings: [],
+            });
+            break;
+        case 'EventQuickPlacedFromCommand':
+            model.events.set(event.eventStickyId, {
+                id: event.eventStickyId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'CommandToEvent',
+                sourceId: event.commandStickyId,
+                targetId: event.eventStickyId,
+                fieldMappings: [],
+            });
+            break;
+        case 'ReadModelQuickPlacedFromEvent':
+            model.readModels.set(event.readModelStickyId, {
+                id: event.readModelStickyId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'EventToReadModel',
+                sourceId: event.eventStickyId,
+                targetId: event.readModelStickyId,
+                fieldMappings: [],
+            });
+            break;
+        case 'ScreenQuickPlacedFromReadModel':
+            model.screens.set(event.screenId, {
+                id: event.screenId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'ReadModelToScreen',
+                sourceId: event.readModelStickyId,
+                targetId: event.screenId,
+                fieldMappings: [],
+            });
+            break;
+        case 'CommandQuickPlacedFromProcessor':
+            model.commands.set(event.commandStickyId, {
+                id: event.commandStickyId,
+                name: event.name,
+                fields: [],
+                position: event.position,
+                width: event.width,
+                height: event.height,
+            });
+            model.flows.set(event.flowId, {
+                id: event.flowId,
+                flowType: 'ProcessorToCommand',
+                sourceId: event.processorId,
+                targetId: event.commandStickyId,
+                fieldMappings: [],
+            });
+            break;
+        // Field propagation events
+        case 'FieldsPropagatedFromCommandToEvent':
+        case 'FieldsPropagatedFromEventToCommand':
+        case 'FieldsPropagatedFromEventToReadModel':
+        case 'FieldsPropagatedFromReadModelToEvent':
+        case 'FieldsPropagatedFromReadModelToScreen':
+        case 'FieldsPropagatedFromScreenToReadModel':
+        case 'FieldsPropagatedFromReadModelToProcessor':
+        case 'FieldsPropagatedFromProcessorToReadModel':
+        case 'FieldsPropagatedFromScreenToCommand':
+        case 'FieldsPropagatedFromCommandToScreen':
+        case 'FieldsPropagatedFromProcessorToCommand':
+        case 'FieldsPropagatedFromCommandToProcessor':
+            handleFieldPropagation(model, event);
+            break;
+        // Scenario events
+        case 'ScenarioCreated':
+            model.scenarios.set(event.scenarioId, {
+                id: event.scenarioId,
+                sliceId: event.sliceId,
+                name: event.name,
+                description: '',
+                position: event.position,
+                width: event.width,
+                height: event.height,
+                givenEvents: [],
+                whenCommand: null,
+                then: { type: 'events', expectedEvents: [] },
+            });
+            break;
+        case 'ScenarioMoved': {
+            const scenario = model.scenarios.get(event.scenarioId);
+            if (scenario)
+                scenario.position = event.position;
+            break;
+        }
+        case 'ScenarioRemoved':
+            model.scenarios.delete(event.scenarioId);
+            break;
+        case 'ScenarioRenamed': {
+            const scenario = model.scenarios.get(event.scenarioId);
+            if (scenario)
+                scenario.name = event.name;
+            break;
+        }
+        case 'ScenarioDescriptionUpdated': {
+            const scenario = model.scenarios.get(event.scenarioId);
+            if (scenario)
+                scenario.description = event.description;
+            break;
+        }
+        case 'ScenarioGivenEventsUpdated': {
+            const scenario = model.scenarios.get(event.scenarioId);
+            if (scenario)
+                scenario.givenEvents = event.givenEvents;
+            break;
+        }
+        case 'ScenarioWhenCommandUpdated': {
+            const scenario = model.scenarios.get(event.scenarioId);
+            if (scenario)
+                scenario.whenCommand = event.whenCommand;
+            break;
+        }
+        case 'ScenarioThenUpdated': {
+            const scenario = model.scenarios.get(event.scenarioId);
+            if (scenario)
+                scenario.then = event.then;
+            break;
+        }
+        // Ignore visual-only events
+        case 'ScreenDesignUpdated':
+            // Screen designs are visual-only, not relevant for CLI
+            break;
+    }
+}
+function handleFieldPropagation(model, event) {
+    const fields = event.fields;
+    // 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);
+                }
+            }
+        }
+    }
+    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);
+                }
+            }
+        }
+    }
+    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);
+                }
+            }
+        }
+    }
+    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);
+                }
+            }
+        }
+    }
+    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);
+                }
+            }
+        }
+    }
+}