eventmodeler 0.2.9 → 0.3.0

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

@@ -1,5 +1,7 @@
 import { escapeXml, escapeXmlText, outputJson } from '../../lib/format.js';
 import { findElementOrExit } from '../../lib/element-lookup.js';
+import { findChapterForSlice, getChapterHierarchy } from '../../lib/chapter-utils.js';
+import { getInboundFlows, getOutboundFlows, getFlowsForElement, } from '../../lib/flow-utils.js';
 function formatFieldValues(values) {
     if (!values || Object.keys(values).length === 0)
         return '';
@@ -102,9 +104,91 @@ function findActorForScreen(model, screen) {
     }
     return null;
 }
+function formatChapterXml(hierarchy, indent) {
+    let xml = `${indent}<chapter id="${hierarchy.id}" name="${escapeXml(hierarchy.name)}"`;
+    if (hierarchy.parent) {
+        xml += '>\n';
+        xml += formatChapterXml(hierarchy.parent, indent + '  ');
+        xml += `${indent}</chapter>\n`;
+    }
+    else {
+        xml += '/>\n';
+    }
+    return xml;
+}
+// Format inline flow annotations for a component
+function formatFlowAnnotationsXml(elementId, incoming, outgoing, componentIds, indent) {
+    let xml = '';
+    // Flows coming into this element
+    const flowsFrom = incoming.map(f => {
+        const external = !componentIds.has(f.source.id);
+        return external
+            ? `${escapeXml(f.source.name)} (${f.source.type}) [external]`
+            : `${escapeXml(f.source.name)} (${f.source.type})`;
+    });
+    if (flowsFrom.length > 0) {
+        xml += `${indent}<flows-from>${flowsFrom.join(', ')}</flows-from>\n`;
+    }
+    // Flows going out of this element
+    const flowsTo = outgoing.map(f => {
+        const external = !componentIds.has(f.target.id);
+        return external
+            ? `${escapeXml(f.target.name)} (${f.target.type}) [external]`
+            : `${escapeXml(f.target.name)} (${f.target.type})`;
+    });
+    if (flowsTo.length > 0) {
+        xml += `${indent}<flows-to>${flowsTo.join(', ')}</flows-to>\n`;
+    }
+    return xml;
+}
+// Format inbound flows section
+function formatInboundFlowsXml(flows) {
+    if (flows.length === 0)
+        return '';
+    let xml = '  <inbound-flows>\n';
+    for (const flow of flows) {
+        xml += `    <flow type="${flow.flowType}">\n`;
+        const sourceSliceInfo = flow.sourceSlice ? ` slice="${escapeXml(flow.sourceSlice.name)}"` : '';
+        xml += `      <from${sourceSliceInfo}>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
+        xml += `      <to>${escapeXml(flow.target.name)} (${flow.target.type})</to>\n`;
+        if (flow.fieldMappings.length > 0) {
+            xml += '      <mappings>\n';
+            for (const mapping of flow.fieldMappings) {
+                xml += `        <map from="${escapeXml(mapping.from)}" to="${escapeXml(mapping.to)}"/>\n`;
+            }
+            xml += '      </mappings>\n';
+        }
+        xml += '    </flow>\n';
+    }
+    xml += '  </inbound-flows>\n';
+    return xml;
+}
+// Format outbound flows section
+function formatOutboundFlowsXml(flows) {
+    if (flows.length === 0)
+        return '';
+    let xml = '  <outbound-flows>\n';
+    for (const flow of flows) {
+        xml += `    <flow type="${flow.flowType}">\n`;
+        xml += `      <from>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
+        const targetSliceInfo = flow.targetSlice ? ` slice="${escapeXml(flow.targetSlice.name)}"` : '';
+        xml += `      <to${targetSliceInfo}>${escapeXml(flow.target.name)} (${flow.target.type})</to>\n`;
+        if (flow.fieldMappings.length > 0) {
+            xml += '      <mappings>\n';
+            for (const mapping of flow.fieldMappings) {
+                xml += `        <map from="${escapeXml(mapping.from)}" to="${escapeXml(mapping.to)}"/>\n`;
+            }
+            xml += '      </mappings>\n';
+        }
+        xml += '    </flow>\n';
+    }
+    xml += '  </outbound-flows>\n';
+    return xml;
+}
 function formatSliceXml(model, slice) {
     const components = getSliceComponents(model, slice);
     const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
+    const chapter = findChapterForSlice(model, slice);
     const componentIds = new Set();
     components.commands.forEach(c => componentIds.add(c.id));
     components.events.forEach(e => componentIds.add(e.id));
@@ -113,6 +197,9 @@ function formatSliceXml(model, slice) {
     components.processors.forEach(p => componentIds.add(p.id));
     const flows = [...model.flows.values()].filter(f => componentIds.has(f.sourceId) || componentIds.has(f.targetId));
     const internalFlows = flows.filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId));
+    // Get inbound and outbound flows for the slice
+    const inboundFlows = getInboundFlows(model, slice);
+    const outboundFlows = getOutboundFlows(model, slice);
     function getName(id) {
         return (model.commands.get(id)?.name ??
             model.events.get(id)?.name ??
@@ -122,6 +209,9 @@ function formatSliceXml(model, slice) {
             id);
     }
     let xml = `<slice id="${slice.id}" name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
+    if (chapter) {
+        xml += formatChapterXml(getChapterHierarchy(model, chapter), '  ');
+    }
     xml += '  <components>\n';
     for (const screen of components.screens) {
         // Check if this is a linked copy
@@ -137,6 +227,9 @@ function formatSliceXml(model, slice) {
         const actor = findActorForScreen(model, screen);
         const actorAttr = actor ? ` actor="${escapeXml(actor.name)}"` : '';
         xml += `    <screen id="${screen.id}" name="${escapeXml(screen.name)}"${copyAttr}${originAttr}${actorAttr}>\n`;
+        // Add flow annotations
+        const screenFlows = getFlowsForElement(model, screen.id);
+        xml += formatFlowAnnotationsXml(screen.id, screenFlows.incoming, screenFlows.outgoing, componentIds, '      ');
         if (screen.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of screen.fields) {
@@ -148,6 +241,9 @@ function formatSliceXml(model, slice) {
     }
     for (const command of components.commands) {
         xml += `    <command id="${command.id}" name="${escapeXml(command.name)}">\n`;
+        // Add flow annotations
+        const commandFlows = getFlowsForElement(model, command.id);
+        xml += formatFlowAnnotationsXml(command.id, commandFlows.incoming, commandFlows.outgoing, componentIds, '      ');
         if (command.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of command.fields) {
@@ -179,6 +275,9 @@ function formatSliceXml(model, slice) {
         const aggregate = findAggregateForEvent(model, event);
         const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
         xml += `    <event id="${event.id}" name="${escapeXml(event.name)}"${copyAttr}${originAttr}${aggregateAttr}>\n`;
+        // Add flow annotations
+        const eventFlows = getFlowsForElement(model, event.id);
+        xml += formatFlowAnnotationsXml(event.id, eventFlows.incoming, eventFlows.outgoing, componentIds, '      ');
         if (event.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of event.fields) {
@@ -210,6 +309,9 @@ function formatSliceXml(model, slice) {
             }
         }
         xml += `    <read-model id="${readModel.id}" name="${escapeXml(readModel.name)}"${copyAttr}${originAttr}>\n`;
+        // Add flow annotations
+        const rmFlows = getFlowsForElement(model, readModel.id);
+        xml += formatFlowAnnotationsXml(readModel.id, rmFlows.incoming, rmFlows.outgoing, componentIds, '      ');
         if (readModel.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of readModel.fields) {
@@ -221,6 +323,9 @@ function formatSliceXml(model, slice) {
     }
     for (const processor of components.processors) {
         xml += `    <processor id="${processor.id}" name="${escapeXml(processor.name)}">\n`;
+        // Add flow annotations
+        const procFlows = getFlowsForElement(model, processor.id);
+        xml += formatFlowAnnotationsXml(processor.id, procFlows.incoming, procFlows.outgoing, componentIds, '      ');
         if (processor.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of processor.fields) {
@@ -297,6 +402,9 @@ function formatSliceXml(model, slice) {
         }
         xml += '  </scenarios>\n';
     }
+    // Add inbound and outbound flows sections
+    xml += formatInboundFlowsXml(inboundFlows);
+    xml += formatOutboundFlowsXml(outboundFlows);
     xml += '</slice>';
     return xml;
 }
@@ -321,6 +429,7 @@ function fieldToJson(field) {
 function formatSliceJson(model, slice) {
     const components = getSliceComponents(model, slice);
     const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
+    const chapter = findChapterForSlice(model, slice);
     const componentIds = new Set();
     components.commands.forEach(c => componentIds.add(c.id));
     components.events.forEach(e => componentIds.add(e.id));
@@ -329,6 +438,9 @@ function formatSliceJson(model, slice) {
     components.processors.forEach(p => componentIds.add(p.id));
     const flows = [...model.flows.values()].filter(f => componentIds.has(f.sourceId) || componentIds.has(f.targetId));
     const internalFlows = flows.filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId));
+    // Get inbound and outbound flows for the slice
+    const inboundFlows = getInboundFlows(model, slice);
+    const outboundFlows = getOutboundFlows(model, slice);
     function getName(id) {
         return (model.commands.get(id)?.name ??
             model.events.get(id)?.name ??
@@ -341,6 +453,7 @@ function formatSliceJson(model, slice) {
         id: slice.id,
         name: slice.name,
         status: slice.status,
+        ...(chapter && { chapter: getChapterHierarchy(model, chapter) }),
         components: {
             screens: components.screens.map(screen => {
                 const screenObj = {
@@ -357,13 +470,47 @@ function formatSliceJson(model, slice) {
                 const actor = findActorForScreen(model, screen);
                 if (actor)
                     screenObj.actor = actor.name;
+                // Add flow annotations
+                const screenFlows = getFlowsForElement(model, screen.id);
+                if (screenFlows.incoming.length > 0) {
+                    screenObj.flowsFrom = screenFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (screenFlows.outgoing.length > 0) {
+                    screenObj.flowsTo = screenFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
                 return screenObj;
             }),
-            commands: components.commands.map(cmd => ({
-                id: cmd.id,
-                name: cmd.name,
-                fields: cmd.fields.map(fieldToJson)
-            })),
+            commands: components.commands.map(cmd => {
+                const cmdObj = {
+                    id: cmd.id,
+                    name: cmd.name,
+                    fields: cmd.fields.map(fieldToJson)
+                };
+                const cmdFlows = getFlowsForElement(model, cmd.id);
+                if (cmdFlows.incoming.length > 0) {
+                    cmdObj.flowsFrom = cmdFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (cmdFlows.outgoing.length > 0) {
+                    cmdObj.flowsTo = cmdFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
+                return cmdObj;
+            }),
             events: components.events.map(event => {
                 const eventObj = {
                     id: event.id,
@@ -379,6 +526,22 @@ function formatSliceJson(model, slice) {
                 const aggregate = findAggregateForEvent(model, event);
                 if (aggregate)
                     eventObj.aggregate = aggregate.name;
+                // Add flow annotations
+                const eventFlows = getFlowsForElement(model, event.id);
+                if (eventFlows.incoming.length > 0) {
+                    eventObj.flowsFrom = eventFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (eventFlows.outgoing.length > 0) {
+                    eventObj.flowsTo = eventFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
                 return eventObj;
             }),
             readModels: components.readModels.map(rm => {
@@ -393,13 +556,47 @@ function formatSliceJson(model, slice) {
                     if (originSlice)
                         rmObj.originSlice = originSlice.name;
                 }
+                // Add flow annotations
+                const rmFlows = getFlowsForElement(model, rm.id);
+                if (rmFlows.incoming.length > 0) {
+                    rmObj.flowsFrom = rmFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (rmFlows.outgoing.length > 0) {
+                    rmObj.flowsTo = rmFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
                 return rmObj;
             }),
-            processors: components.processors.map(proc => ({
-                id: proc.id,
-                name: proc.name,
-                fields: proc.fields.map(fieldToJson)
-            }))
+            processors: components.processors.map(proc => {
+                const procObj = {
+                    id: proc.id,
+                    name: proc.name,
+                    fields: proc.fields.map(fieldToJson)
+                };
+                const procFlows = getFlowsForElement(model, proc.id);
+                if (procFlows.incoming.length > 0) {
+                    procObj.flowsFrom = procFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (procFlows.outgoing.length > 0) {
+                    procObj.flowsTo = procFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
+                return procObj;
+            })
         }
     };
     if (internalFlows.length > 0) {
@@ -460,6 +657,41 @@ function formatSliceJson(model, slice) {
             return scenarioObj;
         });
     }
+    // Add inbound and outbound flows
+    if (inboundFlows.length > 0) {
+        result.inboundFlows = inboundFlows.map(f => ({
+            type: f.flowType,
+            from: {
+                element: f.source.name,
+                type: f.source.type,
+                ...(f.sourceSlice && { slice: f.sourceSlice.name })
+            },
+            to: {
+                element: f.target.name,
+                type: f.target.type
+            },
+            ...(f.fieldMappings.length > 0 && {
+                mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
+            })
+        }));
+    }
+    if (outboundFlows.length > 0) {
+        result.outboundFlows = outboundFlows.map(f => ({
+            type: f.flowType,
+            from: {
+                element: f.source.name,
+                type: f.source.type
+            },
+            to: {
+                element: f.target.name,
+                type: f.target.type,
+                ...(f.targetSlice && { slice: f.targetSlice.name })
+            },
+            ...(f.fieldMappings.length > 0 && {
+                mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
+            })
+        }));
+    }
     return result;
 }
 export function showSlice(model, name, format) {

package/dist/slices/update-field/index.d.ts

@@ -8,5 +8,7 @@ export declare function updateField(model: EventModel, filePath: string, options
     command?: string;
     event?: string;
     readModel?: string;
+    screen?: string;
+    processor?: string;
 }, fieldName: string, updates: UpdateOptions): void;
 export {};

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

@@ -33,13 +33,13 @@ function createUpdatedField(original, updates) {
 }
 export function updateField(model, filePath, options, fieldName, updates) {
     // Determine which entity type
-    const entityCount = [options.command, options.event, options.readModel].filter(Boolean).length;
+    const entityCount = [options.command, options.event, options.readModel, options.screen, options.processor].filter(Boolean).length;
     if (entityCount === 0) {
-        console.error('Error: Must specify one of --command, --event, or --read-model');
+        console.error('Error: Must specify one of --command, --event, --read-model, --screen, or --processor');
         process.exit(1);
     }
     if (entityCount > 1) {
-        console.error('Error: Can only specify one of --command, --event, or --read-model');
+        console.error('Error: Can only specify one of --command, --event, --read-model, --screen, or --processor');
         process.exit(1);
     }
     if (options.command) {
@@ -51,6 +51,12 @@ export function updateField(model, filePath, options, fieldName, updates) {
     else if (options.readModel) {
         updateReadModelField(model, filePath, options.readModel, fieldName, updates);
     }
+    else if (options.screen) {
+        updateScreenField(model, filePath, options.screen, fieldName, updates);
+    }
+    else if (options.processor) {
+        updateProcessorField(model, filePath, options.processor, fieldName, updates);
+    }
 }
 function updateCommandField(model, filePath, commandName, fieldName, updates) {
     const command = findElementOrExit(model.commands, commandName, 'command');
@@ -124,6 +130,54 @@ function updateReadModelField(model, filePath, readModelName, fieldName, updates
     console.log(`Updated field "${field.name}" on read model "${readModel.name}"`);
     logUpdates(updates);
 }
+function updateScreenField(model, filePath, screenName, fieldName, updates) {
+    const screen = findElementOrExit(model.screens, screenName, 'screen');
+    const field = findFieldByName(screen.fields, fieldName);
+    if (!field) {
+        console.error(`Error: Field "${fieldName}" not found on screen "${screen.name}"`);
+        if (screen.fields.length > 0) {
+            console.error('Available fields:');
+            for (const f of screen.fields) {
+                console.error(`  - ${f.name}`);
+            }
+        }
+        process.exit(1);
+    }
+    const updatedField = createUpdatedField(field, updates);
+    appendEvent(filePath, {
+        type: 'ScreenFieldAdjusted',
+        screenId: screen.id,
+        fieldId: field.id,
+        field: updatedField,
+        timestamp: Date.now(),
+    });
+    console.log(`Updated field "${field.name}" on screen "${screen.name}"`);
+    logUpdates(updates);
+}
+function updateProcessorField(model, filePath, processorName, fieldName, updates) {
+    const processor = findElementOrExit(model.processors, processorName, 'processor');
+    const field = findFieldByName(processor.fields, fieldName);
+    if (!field) {
+        console.error(`Error: Field "${fieldName}" not found on processor "${processor.name}"`);
+        if (processor.fields.length > 0) {
+            console.error('Available fields:');
+            for (const f of processor.fields) {
+                console.error(`  - ${f.name}`);
+            }
+        }
+        process.exit(1);
+    }
+    const updatedField = createUpdatedField(field, updates);
+    appendEvent(filePath, {
+        type: 'ProcessorFieldAdjusted',
+        processorId: processor.id,
+        fieldId: field.id,
+        field: updatedField,
+        timestamp: Date.now(),
+    });
+    console.log(`Updated field "${field.name}" on processor "${processor.name}"`);
+    logUpdates(updates);
+}
 function logUpdates(updates) {
     if (updates.optional !== undefined) {
         console.log(`  isOptional: ${updates.optional}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eventmodeler",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "CLI tool for interacting with Event Model files - query, update, and export event models from the terminal",
   "type": "module",
   "bin": {