eventmodeler 0.3.10 → 0.4.1

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

@@ -126,9 +126,11 @@ function addFieldToCommand(model, filePath, commandName, fieldInput) {
     const field = createFieldFromInput(fieldInput);
     appendEvent(filePath, {
         type: 'CommandFieldAdded',
-        commandStickyId: command.id,
-        field,
-        timestamp: Date.now(),
+        data: {
+            commandStickyId: command.id,
+            field,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Added field "${field.name}" to command "${command.name}"`);
 }
@@ -143,9 +145,11 @@ function addFieldToEvent(model, filePath, eventName, fieldInput) {
     const field = createFieldFromInput(fieldInput);
     appendEvent(filePath, {
         type: 'EventFieldAdded',
-        eventStickyId: event.id,
-        field,
-        timestamp: Date.now(),
+        data: {
+            eventStickyId: event.id,
+            field,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Added field "${field.name}" to event "${event.name}"`);
 }
@@ -160,9 +164,11 @@ function addFieldToReadModel(model, filePath, readModelName, fieldInput) {
     const field = createFieldFromInput(fieldInput);
     appendEvent(filePath, {
         type: 'ReadModelFieldAdded',
-        readModelStickyId: readModel.id,
-        field,
-        timestamp: Date.now(),
+        data: {
+            readModelStickyId: readModel.id,
+            field,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Added field "${field.name}" to read model "${readModel.name}"`);
 }
@@ -177,9 +183,11 @@ function addFieldToScreen(model, filePath, screenName, fieldInput) {
     const field = createFieldFromInput(fieldInput);
     appendEvent(filePath, {
         type: 'ScreenFieldAdded',
-        screenId: screen.id,
-        field,
-        timestamp: Date.now(),
+        data: {
+            screenId: screen.id,
+            field,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Added field "${field.name}" to screen "${screen.name}"`);
 }
@@ -193,9 +201,11 @@ function addFieldToProcessor(model, filePath, processorName, fieldInput) {
     const field = createFieldFromInput(fieldInput);
     appendEvent(filePath, {
         type: 'ProcessorFieldAdded',
-        processorId: processor.id,
-        field,
-        timestamp: Date.now(),
+        data: {
+            processorId: processor.id,
+            field,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Added field "${field.name}" to processor "${processor.name}"`);
 }

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

@@ -288,56 +288,68 @@ export function addScenario(model, filePath, sliceName, input) {
     // Append ScenarioCreated event
     appendEvent(filePath, {
         type: 'ScenarioCreated',
-        scenarioId,
-        sliceId: slice.id,
-        name: scenarioInput.name,
-        position,
-        width: 200,
-        height: 80,
-        timestamp: Date.now(),
+        data: {
+            scenarioId,
+            sliceId: slice.id,
+            name: scenarioInput.name,
+            position,
+            width: 200,
+            height: 80,
+            timestamp: Date.now(),
+        },
     });
     // Append description update if provided
     if (scenarioInput.description) {
         appendEvent(filePath, {
             type: 'ScenarioDescriptionUpdated',
-            scenarioId,
-            description: scenarioInput.description,
-            timestamp: Date.now(),
+            data: {
+                scenarioId,
+                description: scenarioInput.description,
+                timestamp: Date.now(),
+            },
         });
     }
     // Append given events update if provided
     if (givenEvents.length > 0) {
         appendEvent(filePath, {
             type: 'ScenarioGivenEventsUpdated',
-            scenarioId,
-            givenEvents,
-            timestamp: Date.now(),
+            data: {
+                scenarioId,
+                givenEvents,
+                timestamp: Date.now(),
+            },
         });
     }
     // Append when command update if provided
     if (whenCommand) {
         appendEvent(filePath, {
             type: 'ScenarioWhenCommandUpdated',
-            scenarioId,
-            whenCommand,
-            timestamp: Date.now(),
+            data: {
+                scenarioId,
+                whenCommand,
+                timestamp: Date.now(),
+            },
         });
     }
     // Append when events update if provided
     if (whenEvents.length > 0) {
         appendEvent(filePath, {
             type: 'ScenarioWhenEventsUpdated',
-            scenarioId,
-            whenEvents,
-            timestamp: Date.now(),
+            data: {
+                scenarioId,
+                whenEvents,
+                timestamp: Date.now(),
+            },
         });
     }
     // Append then update
     appendEvent(filePath, {
         type: 'ScenarioThenUpdated',
-        scenarioId,
-        then,
-        timestamp: Date.now(),
+        data: {
+            scenarioId,
+            then,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Added scenario "${scenarioInput.name}" to slice "${slice.name}"`);
 }

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

@@ -14,11 +14,13 @@ function getSliceComponents(model, slice) {
         const centerY = pos.y + height / 2;
         return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
     }
+    // Only include canonical elements - linked copies are UI-only conveniences
+    // and should not appear as slice contents in codegen output
     return {
         commands: [...model.commands.values()].filter(c => isInSlice(c.position, c.width, c.height)),
-        events: [...model.events.values()].filter(e => isInSlice(e.position, e.width, e.height)),
-        readModels: [...model.readModels.values()].filter(rm => isInSlice(rm.position, rm.width, rm.height)),
-        screens: [...model.screens.values()].filter(s => isInSlice(s.position, s.width, s.height)),
+        events: [...model.events.values()].filter(e => !e.originalNodeId && isInSlice(e.position, e.width, e.height)),
+        readModels: [...model.readModels.values()].filter(rm => !rm.originalNodeId && isInSlice(rm.position, rm.width, rm.height)),
+        screens: [...model.screens.values()].filter(s => !s.originalNodeId && isInSlice(s.position, s.width, s.height)),
         processors: [...model.processors.values()].filter(p => isInSlice(p.position, p.width, p.height)),
     };
 }

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

@@ -102,9 +102,11 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         for (const { sliceId, newX, currentY } of toShift) {
             appendEvent(filePath, {
                 type: 'SliceMoved',
-                sliceId,
-                position: { x: newX, y: currentY },
-                timestamp: Date.now(),
+                data: {
+                    sliceId,
+                    position: { x: newX, y: currentY },
+                    timestamp: Date.now(),
+                },
             });
         }
     }
@@ -145,125 +147,151 @@ export function createAutomationSlice(model, filePath, xmlInput) {
     // 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(),
+        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',
-        readModelStickyId: readModelId,
-        name: input.readModel.name,
-        position: readModelPosition,
-        width: AUTOMATION_SLICE.readModel.width,
-        height: AUTOMATION_SLICE.readModel.height,
-        timestamp: Date.now(),
+        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',
-            readModelStickyId: readModelId,
-            field,
-            timestamp: Date.now(),
+            data: {
+                readModelStickyId: readModelId,
+                field,
+                timestamp: Date.now(),
+            },
         });
     }
     // 4. 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(),
+        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',
-        commandStickyId: commandId,
-        name: input.command.name,
-        position: commandPosition,
-        width: AUTOMATION_SLICE.command.width,
-        height: AUTOMATION_SLICE.command.height,
-        timestamp: Date.now(),
+        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',
-            commandStickyId: commandId,
-            field,
-            timestamp: Date.now(),
+            data: {
+                commandStickyId: commandId,
+                field,
+                timestamp: Date.now(),
+            },
         });
     }
     // 7. 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(),
+        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',
-            eventStickyId: eventId,
-            field,
-            timestamp: Date.now(),
+            data: {
+                eventStickyId: eventId,
+                field,
+                timestamp: Date.now(),
+            },
         });
     }
     // 9. Create read model -> processor flow
     appendEvent(filePath, {
         type: 'ReadModelToProcessorFlowSpecified',
-        flowId: readModelToProcessorFlowId,
-        readModelStickyId: readModelId,
-        processorId,
-        sourceHandle: 'top-source',
-        targetHandle: 'bottom-target',
-        timestamp: Date.now(),
+        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',
-            flowId: readModelToProcessorFlowId,
-            mappings: readModelToCommandMappings,
-            timestamp: Date.now(),
+            data: {
+                flowId: readModelToProcessorFlowId,
+                mappings: readModelToCommandMappings,
+                timestamp: Date.now(),
+            },
         });
     }
     // 11. Create processor -> command flow
     appendEvent(filePath, {
         type: 'ProcessorToCommandFlowSpecified',
-        flowId: processorToCommandFlowId,
-        processorId,
-        commandStickyId: commandId,
-        sourceHandle: 'bottom-source',
-        targetHandle: 'top-target',
-        timestamp: Date.now(),
+        data: {
+            flowId: processorToCommandFlowId,
+            processorId,
+            commandStickyId: commandId,
+            sourceHandle: 'bottom-source',
+            targetHandle: 'top-target',
+            timestamp: Date.now(),
+        },
     });
     // 12. Create command -> event flow
     appendEvent(filePath, {
         type: 'CommandToEventFlowSpecified',
-        flowId: commandToEventFlowId,
-        commandStickyId: commandId,
-        eventStickyId: eventId,
-        sourceHandle: 'bottom-source',
-        targetHandle: 'top-target',
-        timestamp: Date.now(),
+        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',
-            flowId: commandToEventFlowId,
-            mappings: commandToEventMappings,
-            timestamp: Date.now(),
+            data: {
+                flowId: commandToEventFlowId,
+                mappings: commandToEventMappings,
+                timestamp: Date.now(),
+            },
         });
     }
     console.log(`Created automation slice "${input.sliceName}"`);

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

@@ -98,12 +98,14 @@ export function createFlow(model, filePath, fromName, toName) {
         }
         event = {
             type: 'EventToReadModelFlowSpecified',
-            flowId,
-            eventStickyId: source.element.id,
-            readModelStickyId: target.element.id,
-            sourceHandle: 'top-source',
-            targetHandle: 'bottom-target',
-            timestamp: Date.now(),
+            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}"`);
@@ -116,12 +118,14 @@ export function createFlow(model, filePath, fromName, toName) {
         }
         event = {
             type: 'ReadModelToScreenFlowSpecified',
-            flowId,
-            readModelStickyId: source.element.id,
-            screenId: target.element.id,
-            sourceHandle: 'top-source',
-            targetHandle: 'bottom-target',
-            timestamp: Date.now(),
+            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}"`);
@@ -134,12 +138,14 @@ export function createFlow(model, filePath, fromName, toName) {
         }
         event = {
             type: 'ReadModelToProcessorFlowSpecified',
-            flowId,
-            readModelStickyId: source.element.id,
-            processorId: target.element.id,
-            sourceHandle: 'top-source',
-            targetHandle: 'bottom-target',
-            timestamp: Date.now(),
+            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}"`);