eventmodeler 0.2.9 → 0.3.0

package/dist/index.js

@@ -54,17 +54,19 @@ USAGE:
   eventmodeler <command> [options]   Run a CLI command
 
 COMMANDS:
-  list slices                    List all slices with their status
+  list slices [--chapter <name>] List all slices (optionally filtered by chapter)
   list events                    List all events
   list commands                  List all commands
   list chapters                  List all chapters
   list aggregates                List all aggregates
   list actors                    List all actors
 
-  show slice <name>              Show detailed XML view of a slice
+  show slice <name>              Show slice with components, flow annotations, and
+                                 inbound/outbound dependencies
   show event <name>              Show detailed XML view of an event
   show command <name>            Show detailed XML view of a command
-  show chapter <name>            Show chapter with its slices
+  show chapter <name>            Show chapter with slices, flow graph, and
+                                 external dependencies
   show completeness <name>       Show field mapping completeness for any element
   show model-completeness        Show completeness of all flows in the model
   show aggregate-completeness <name>
@@ -78,18 +80,18 @@ COMMANDS:
 
   add scenario --slice <name> --json|--xml <data>
                                  Add a scenario to a slice
-  add field --command|--event|--read-model <name> --json|--xml <data>
+  add field --command|--event|--read-model|--screen|--processor <name> --json|--xml <data>
                                  Add a field to an entity
 
   remove scenario <name> [--slice <name>]
                                  Remove a scenario by name
-  remove field --command|--event|--read-model <name> --field <name>
+  remove field --command|--event|--read-model|--screen|--processor <name> --field <name>
                                  Remove a field from an entity
 
   map fields --flow <source→target> --json|--xml <mappings>
                                  Set field mappings on a flow
 
-  update field --command|--event|--read-model <name> --field <name> [--optional true|false] [--generated true|false]
+  update field --command|--event|--read-model|--screen|--processor <name> --field <name> [--optional true|false] [--generated true|false]
                                  Update field properties
 
   create state-change-slice --xml <data>
@@ -134,6 +136,7 @@ EXAMPLES:
 async function main() {
     let fileArg = null;
     let formatArg = null;
+    let chapterArg = null;
     const filteredArgs = [];
     for (let i = 0; i < args.length; i++) {
         if (args[i] === '-f' || args[i] === '--file') {
@@ -142,6 +145,9 @@ async function main() {
         else if (args[i] === '--format') {
             formatArg = args[++i];
         }
+        else if (args[i] === '--chapter') {
+            chapterArg = args[++i];
+        }
         else if (args[i] === '-h' || args[i] === '--help') {
             printHelp();
             process.exit(0);
@@ -183,7 +189,7 @@ async function main() {
         case 'list':
             switch (subcommand) {
                 case 'slices':
-                    listSlices(model, format);
+                    listSlices(model, format, chapterArg ?? undefined);
                     break;
                 case 'events':
                     listEvents(model, format);
@@ -326,15 +332,17 @@ async function main() {
                     const commandArg = getNamedArg(filteredArgs, '--command');
                     const eventArg = getNamedArg(filteredArgs, '--event');
                     const readModelArg = getNamedArg(filteredArgs, '--read-model');
+                    const screenArg = getNamedArg(filteredArgs, '--screen');
+                    const processorArg = getNamedArg(filteredArgs, '--processor');
                     const jsonArg = getNamedArg(filteredArgs, '--json');
                     const xmlArg = getNamedArg(filteredArgs, '--xml');
                     const inputData = jsonArg ?? xmlArg;
                     if (!inputData) {
                         console.error('Error: --json or --xml is required');
-                        console.error('Usage: eventmodeler add field --command|--event|--read-model <name> --json|--xml <data>');
+                        console.error('Usage: eventmodeler add field --command|--event|--read-model|--screen|--processor <name> --json|--xml <data>');
                         process.exit(1);
                     }
-                    addField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg }, inputData);
+                    addField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, inputData);
                     break;
                 }
                 default:
@@ -359,13 +367,15 @@ async function main() {
                     const commandArg = getNamedArg(filteredArgs, '--command');
                     const eventArg = getNamedArg(filteredArgs, '--event');
                     const readModelArg = getNamedArg(filteredArgs, '--read-model');
+                    const screenArg = getNamedArg(filteredArgs, '--screen');
+                    const processorArg = getNamedArg(filteredArgs, '--processor');
                     const fieldArg = getNamedArg(filteredArgs, '--field');
                     if (!fieldArg) {
                         console.error('Error: --field is required');
-                        console.error('Usage: eventmodeler remove field --command|--event|--read-model <name> --field <field-name>');
+                        console.error('Usage: eventmodeler remove field --command|--event|--read-model|--screen|--processor <name> --field <field-name>');
                         process.exit(1);
                     }
-                    removeField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg }, fieldArg);
+                    removeField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, fieldArg);
                     break;
                 }
                 default:
@@ -406,13 +416,15 @@ async function main() {
                     const commandArg = getNamedArg(filteredArgs, '--command');
                     const eventArg = getNamedArg(filteredArgs, '--event');
                     const readModelArg = getNamedArg(filteredArgs, '--read-model');
+                    const screenArg = getNamedArg(filteredArgs, '--screen');
+                    const processorArg = getNamedArg(filteredArgs, '--processor');
                     const fieldArg = getNamedArg(filteredArgs, '--field');
                     const optionalArg = getNamedArg(filteredArgs, '--optional');
                     const generatedArg = getNamedArg(filteredArgs, '--generated');
                     const typeArg = getNamedArg(filteredArgs, '--type');
                     if (!fieldArg) {
                         console.error('Error: --field is required');
-                        console.error('Usage: eventmodeler update field --command|--event|--read-model <name> --field <field-name> [--optional true|false] [--generated true|false]');
+                        console.error('Usage: eventmodeler update field --command|--event|--read-model|--screen|--processor <name> --field <field-name> [--optional true|false] [--generated true|false]');
                         process.exit(1);
                     }
                     const updates = {};
@@ -429,7 +441,7 @@ async function main() {
                         console.error('Error: Must specify at least one update (--optional, --generated, or --type)');
                         process.exit(1);
                     }
-                    updateField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg }, fieldArg, updates);
+                    updateField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, fieldArg, updates);
                     break;
                 }
                 default:

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

@@ -0,0 +1,13 @@
+import type { Chapter, EventModel, Slice } from '../types.js';
+export interface ChapterWithHierarchy {
+    id: string;
+    name: string;
+    parent?: ChapterWithHierarchy;
+}
+export declare function findParentChapter(model: EventModel, chapter: Chapter): Chapter | null;
+export declare function getChapterHierarchy(model: EventModel, chapter: Chapter): ChapterWithHierarchy;
+export declare function hierarchyToArray(hierarchy: ChapterWithHierarchy): Array<{
+    id: string;
+    name: string;
+}>;
+export declare function findChapterForSlice(model: EventModel, slice: Slice): Chapter | null;

package/dist/lib/chapter-utils.js

@@ -0,0 +1,71 @@
+// Check if two chapters have X-overlap
+function hasXOverlap(parent, child) {
+    const parentLeft = parent.position.x;
+    const parentRight = parent.position.x + parent.size.width;
+    const childLeft = child.position.x;
+    const childRight = child.position.x + child.size.width;
+    return childLeft < parentRight && childRight > parentLeft;
+}
+// Find the immediate parent of a chapter (nearest chapter above with X-overlap)
+export function findParentChapter(model, chapter) {
+    let bestParent = null;
+    let bestParentY = -Infinity;
+    for (const candidate of model.chapters.values()) {
+        if (candidate.id === chapter.id)
+            continue;
+        // Parent must be above (lower y value)
+        if (candidate.position.y >= chapter.position.y)
+            continue;
+        // Must have X-overlap
+        if (!hasXOverlap(candidate, chapter))
+            continue;
+        // Take the closest parent (highest y value that's still above)
+        if (candidate.position.y > bestParentY) {
+            bestParent = candidate;
+            bestParentY = candidate.position.y;
+        }
+    }
+    return bestParent;
+}
+// Build full hierarchy for a chapter (from root to this chapter)
+export function getChapterHierarchy(model, chapter) {
+    const parent = findParentChapter(model, chapter);
+    const result = {
+        id: chapter.id,
+        name: chapter.name,
+    };
+    if (parent) {
+        result.parent = getChapterHierarchy(model, parent);
+    }
+    return result;
+}
+// Convert hierarchy to array (root first)
+export function hierarchyToArray(hierarchy) {
+    const result = [];
+    function collect(h) {
+        if (h.parent)
+            collect(h.parent);
+        result.push({ id: h.id, name: h.name });
+    }
+    collect(hierarchy);
+    return result;
+}
+// Find which chapter contains a slice (based on horizontal center)
+// Returns the deepest (highest y-value) chapter that contains the slice
+export function findChapterForSlice(model, slice) {
+    const sliceCenterX = slice.position.x + slice.size.width / 2;
+    let bestChapter = null;
+    let bestY = -Infinity;
+    for (const chapter of model.chapters.values()) {
+        const chapterLeft = chapter.position.x;
+        const chapterRight = chapter.position.x + chapter.size.width;
+        if (sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight) {
+            // Take the deepest (highest y) chapter
+            if (chapter.position.y > bestY) {
+                bestChapter = chapter;
+                bestY = chapter.position.y;
+            }
+        }
+    }
+    return bestChapter;
+}

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

@@ -0,0 +1,52 @@
+import type { EventModel, Slice } from '../types.js';
+export type ElementType = 'screen' | 'command' | 'event' | 'read-model' | 'processor';
+export interface ElementInfo {
+    id: string;
+    name: string;
+    type: ElementType;
+}
+export interface FieldMappingInfo {
+    from: string;
+    to: string;
+}
+export interface FlowInfo {
+    flowId: string;
+    flowType: string;
+    source: ElementInfo;
+    target: ElementInfo;
+    fieldMappings: FieldMappingInfo[];
+}
+export interface SliceFlowInfo extends FlowInfo {
+    sourceSlice?: {
+        id: string;
+        name: string;
+    };
+    targetSlice?: {
+        id: string;
+        name: string;
+    };
+}
+export declare function getElementInfo(model: EventModel, id: string): ElementInfo | null;
+export declare function getSliceComponentIds(model: EventModel, slice: Slice): Set<string>;
+export declare function findSliceForComponent(model: EventModel, componentId: string): Slice | null;
+export declare function getInboundFlows(model: EventModel, slice: Slice): SliceFlowInfo[];
+export declare function getOutboundFlows(model: EventModel, slice: Slice): SliceFlowInfo[];
+export declare function getInternalFlows(model: EventModel, slice: Slice): FlowInfo[];
+export declare function getFlowsForElement(model: EventModel, elementId: string): {
+    incoming: FlowInfo[];
+    outgoing: FlowInfo[];
+};
+export interface SliceToSliceFlow {
+    fromSlice: {
+        id: string;
+        name: string;
+    };
+    toSlice: {
+        id: string;
+        name: string;
+    };
+    flows: SliceFlowInfo[];
+}
+export declare function findSliceToSliceFlows(model: EventModel, slices: Slice[]): SliceToSliceFlow[];
+export declare function findChapterInboundFlows(model: EventModel, slices: Slice[]): SliceFlowInfo[];
+export declare function findChapterOutboundFlows(model: EventModel, slices: Slice[]): SliceFlowInfo[];

package/dist/lib/flow-utils.js

@@ -0,0 +1,305 @@
+// Get element info (name and type) by ID
+export function getElementInfo(model, id) {
+    const screen = model.screens.get(id);
+    if (screen)
+        return { id, name: screen.name, type: 'screen' };
+    const command = model.commands.get(id);
+    if (command)
+        return { id, name: command.name, type: 'command' };
+    const event = model.events.get(id);
+    if (event)
+        return { id, name: event.name, type: 'event' };
+    const readModel = model.readModels.get(id);
+    if (readModel)
+        return { id, name: readModel.name, type: 'read-model' };
+    const processor = model.processors.get(id);
+    if (processor)
+        return { id, name: processor.name, type: 'processor' };
+    return null;
+}
+// Get fields for an element
+function getElementFields(model, id) {
+    return (model.screens.get(id)?.fields ??
+        model.commands.get(id)?.fields ??
+        model.events.get(id)?.fields ??
+        model.readModels.get(id)?.fields ??
+        model.processors.get(id)?.fields ??
+        []);
+}
+// Find a field by ID in a fields array (recursive for subfields)
+function findFieldById(fields, fieldId) {
+    for (const field of fields) {
+        if (field.id === fieldId)
+            return field;
+        if (field.subfields) {
+            const found = findFieldById(field.subfields, fieldId);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+// Enrich field mappings with field names
+function enrichFieldMappings(model, flow) {
+    const sourceFields = getElementFields(model, flow.sourceId);
+    const targetFields = getElementFields(model, flow.targetId);
+    return flow.fieldMappings.map(mapping => {
+        const sourceField = findFieldById(sourceFields, mapping.sourceFieldId);
+        const targetField = findFieldById(targetFields, mapping.targetFieldId);
+        return {
+            from: sourceField?.name ?? 'unknown',
+            to: targetField?.name ?? 'unknown',
+        };
+    });
+}
+// Check if an element's center point is within a slice's bounds
+function isElementInSlice(slice, position, width, height) {
+    const centerX = position.x + width / 2;
+    const centerY = position.y + height / 2;
+    return (centerX >= slice.position.x &&
+        centerX <= slice.position.x + slice.size.width &&
+        centerY >= slice.position.y &&
+        centerY <= slice.position.y + slice.size.height);
+}
+// Get all component IDs in a slice
+export function getSliceComponentIds(model, slice) {
+    const ids = new Set();
+    for (const screen of model.screens.values()) {
+        if (isElementInSlice(slice, screen.position, screen.width, screen.height)) {
+            ids.add(screen.id);
+        }
+    }
+    for (const command of model.commands.values()) {
+        if (isElementInSlice(slice, command.position, command.width, command.height)) {
+            ids.add(command.id);
+        }
+    }
+    for (const event of model.events.values()) {
+        if (isElementInSlice(slice, event.position, event.width, event.height)) {
+            ids.add(event.id);
+        }
+    }
+    for (const readModel of model.readModels.values()) {
+        if (isElementInSlice(slice, readModel.position, readModel.width, readModel.height)) {
+            ids.add(readModel.id);
+        }
+    }
+    for (const processor of model.processors.values()) {
+        if (isElementInSlice(slice, processor.position, processor.width, processor.height)) {
+            ids.add(processor.id);
+        }
+    }
+    return ids;
+}
+// Find which slice contains a component
+export function findSliceForComponent(model, componentId) {
+    // Get element position and size
+    let position = null;
+    let width = 0;
+    let height = 0;
+    const screen = model.screens.get(componentId);
+    if (screen) {
+        position = screen.position;
+        width = screen.width;
+        height = screen.height;
+    }
+    const command = model.commands.get(componentId);
+    if (command) {
+        position = command.position;
+        width = command.width;
+        height = command.height;
+    }
+    const event = model.events.get(componentId);
+    if (event) {
+        position = event.position;
+        width = event.width;
+        height = event.height;
+    }
+    const readModel = model.readModels.get(componentId);
+    if (readModel) {
+        position = readModel.position;
+        width = readModel.width;
+        height = readModel.height;
+    }
+    const processor = model.processors.get(componentId);
+    if (processor) {
+        position = processor.position;
+        width = processor.width;
+        height = processor.height;
+    }
+    if (!position)
+        return null;
+    for (const slice of model.slices.values()) {
+        if (isElementInSlice(slice, position, width, height)) {
+            return slice;
+        }
+    }
+    return null;
+}
+// Build FlowInfo from a Flow
+function buildFlowInfo(model, flow) {
+    const source = getElementInfo(model, flow.sourceId);
+    const target = getElementInfo(model, flow.targetId);
+    if (!source || !target)
+        return null;
+    return {
+        flowId: flow.id,
+        flowType: flow.flowType,
+        source,
+        target,
+        fieldMappings: enrichFieldMappings(model, flow),
+    };
+}
+// Build SliceFlowInfo from a Flow (includes slice info for source/target)
+function buildSliceFlowInfo(model, flow) {
+    const base = buildFlowInfo(model, flow);
+    if (!base)
+        return null;
+    const sourceSlice = findSliceForComponent(model, flow.sourceId);
+    const targetSlice = findSliceForComponent(model, flow.targetId);
+    return {
+        ...base,
+        sourceSlice: sourceSlice ? { id: sourceSlice.id, name: sourceSlice.name } : undefined,
+        targetSlice: targetSlice ? { id: targetSlice.id, name: targetSlice.name } : undefined,
+    };
+}
+// Get flows entering a slice (target in slice, source outside)
+export function getInboundFlows(model, slice) {
+    const componentIds = getSliceComponentIds(model, slice);
+    const flows = [];
+    for (const flow of model.flows.values()) {
+        if (componentIds.has(flow.targetId) && !componentIds.has(flow.sourceId)) {
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}
+// Get flows leaving a slice (source in slice, target outside)
+export function getOutboundFlows(model, slice) {
+    const componentIds = getSliceComponentIds(model, slice);
+    const flows = [];
+    for (const flow of model.flows.values()) {
+        if (componentIds.has(flow.sourceId) && !componentIds.has(flow.targetId)) {
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}
+// Get flows within a slice (both source and target in slice)
+export function getInternalFlows(model, slice) {
+    const componentIds = getSliceComponentIds(model, slice);
+    const flows = [];
+    for (const flow of model.flows.values()) {
+        if (componentIds.has(flow.sourceId) && componentIds.has(flow.targetId)) {
+            const flowInfo = buildFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}
+// Get all flows for a specific element (both directions)
+export function getFlowsForElement(model, elementId) {
+    const incoming = [];
+    const outgoing = [];
+    for (const flow of model.flows.values()) {
+        if (flow.targetId === elementId) {
+            const flowInfo = buildFlowInfo(model, flow);
+            if (flowInfo)
+                incoming.push(flowInfo);
+        }
+        if (flow.sourceId === elementId) {
+            const flowInfo = buildFlowInfo(model, flow);
+            if (flowInfo)
+                outgoing.push(flowInfo);
+        }
+    }
+    return { incoming, outgoing };
+}
+export function findSliceToSliceFlows(model, slices) {
+    const sliceMap = new Map(slices.map(s => [s.id, s]));
+    const sliceComponentMap = new Map();
+    // Build component ID sets for each slice
+    for (const slice of slices) {
+        sliceComponentMap.set(slice.id, getSliceComponentIds(model, slice));
+    }
+    // Group flows by slice pair
+    const flowsBySlicePair = new Map();
+    for (const flow of model.flows.values()) {
+        let sourceSliceId = null;
+        let targetSliceId = null;
+        // Find which slice contains source and target
+        for (const [sliceId, componentIds] of sliceComponentMap.entries()) {
+            if (componentIds.has(flow.sourceId))
+                sourceSliceId = sliceId;
+            if (componentIds.has(flow.targetId))
+                targetSliceId = sliceId;
+        }
+        // Only include flows between different slices in our set
+        if (sourceSliceId && targetSliceId && sourceSliceId !== targetSliceId) {
+            const key = `${sourceSliceId}:${targetSliceId}`;
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo) {
+                if (!flowsBySlicePair.has(key)) {
+                    flowsBySlicePair.set(key, []);
+                }
+                flowsBySlicePair.get(key).push(flowInfo);
+            }
+        }
+    }
+    // Convert to result format
+    const result = [];
+    for (const [key, flows] of flowsBySlicePair.entries()) {
+        const [fromId, toId] = key.split(':');
+        const fromSlice = sliceMap.get(fromId);
+        const toSlice = sliceMap.get(toId);
+        if (fromSlice && toSlice) {
+            result.push({
+                fromSlice: { id: fromSlice.id, name: fromSlice.name },
+                toSlice: { id: toSlice.id, name: toSlice.name },
+                flows,
+            });
+        }
+    }
+    return result;
+}
+// Find flows entering a chapter (target in chapter slices, source outside)
+export function findChapterInboundFlows(model, slices) {
+    const chapterComponentIds = new Set();
+    for (const slice of slices) {
+        for (const id of getSliceComponentIds(model, slice)) {
+            chapterComponentIds.add(id);
+        }
+    }
+    const flows = [];
+    for (const flow of model.flows.values()) {
+        if (chapterComponentIds.has(flow.targetId) && !chapterComponentIds.has(flow.sourceId)) {
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}
+// Find flows leaving a chapter (source in chapter slices, target outside)
+export function findChapterOutboundFlows(model, slices) {
+    const chapterComponentIds = new Set();
+    for (const slice of slices) {
+        for (const id of getSliceComponentIds(model, slice)) {
+            chapterComponentIds.add(id);
+        }
+    }
+    const flows = [];
+    for (const flow of model.flows.values()) {
+        if (chapterComponentIds.has(flow.sourceId) && !chapterComponentIds.has(flow.targetId)) {
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}

package/dist/lib/slice-utils.js

@@ -91,6 +91,17 @@ export function inferFieldMappings(sourceFields, targetFields) {
     }
     return mappings;
 }
+const VALID_FIELD_TYPES = ['UUID', 'Boolean', 'Double', 'Decimal', 'Date', 'DateTime', 'Long', 'Int', 'String', 'Custom'];
+function validateFieldType(type, fieldName) {
+    if (!VALID_FIELD_TYPES.includes(type)) {
+        const typeLower = type.toLowerCase();
+        let hint = '';
+        if (typeLower === 'list' || typeLower === 'array') {
+            hint = `\n\nHint: To make a field a list/array, use isList="true" with a valid type:\n  <field name="${fieldName}" type="String" isList="true"/>`;
+        }
+        throw new Error(`Invalid field type "${type}" for field "${fieldName}". Valid types: ${VALID_FIELD_TYPES.join(', ')}${hint}`);
+    }
+}
 function getAttr(attrs, name) {
     const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
     return match ? match[1] : undefined;
@@ -106,13 +117,15 @@ export function parseFieldsFromXml(xml) {
         const type = getAttr(attrs, 'type');
         if (!name || !type)
             continue;
+        // Validate the field type
+        validateFieldType(type, name);
         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',
+            isList: getAttr(attrs, 'isList') === 'true',
+            isGenerated: getAttr(attrs, 'isGenerated') === 'true',
+            isOptional: getAttr(attrs, 'isOptional') === 'true',
+            isUserInput: getAttr(attrs, 'isUserInput') === 'true',
         };
         // Parse nested subfields for Custom type
         if (type === 'Custom' && content) {

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

@@ -3,4 +3,6 @@ export declare function addField(model: EventModel, filePath: string, options: {
     command?: string;
     event?: string;
     readModel?: string;
+    screen?: string;
+    processor?: string;
 }, input: string): void;