eventmodeler 0.2.9 → 0.3.0

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

@@ -68,13 +68,13 @@ function createFieldFromInput(input) {
 }
 export function addField(model, filePath, options, input) {
     // 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);
     }
     // Parse input
@@ -90,6 +90,11 @@ export function addField(model, filePath, options, input) {
     if (!validFieldTypes.includes(fieldInput.type)) {
         console.error(`Error: Invalid field type: ${fieldInput.type}`);
         console.error(`Valid types: ${validFieldTypes.join(', ')}`);
+        const typeLower = fieldInput.type.toLowerCase();
+        if (typeLower === 'list' || typeLower === 'array') {
+            console.error(`\nHint: To make a field a list/array, use isList="true" with a valid type:`);
+            console.error(`  <field name="items" type="String" isList="true"/>`);
+        }
         process.exit(1);
     }
     // Find entity and add field
@@ -102,6 +107,12 @@ export function addField(model, filePath, options, input) {
     else if (options.readModel) {
         addFieldToReadModel(model, filePath, options.readModel, fieldInput);
     }
+    else if (options.screen) {
+        addFieldToScreen(model, filePath, options.screen, fieldInput);
+    }
+    else if (options.processor) {
+        addFieldToProcessor(model, filePath, options.processor, fieldInput);
+    }
 }
 function addFieldToCommand(model, filePath, commandName, fieldInput) {
     const command = findElementOrExit(model.commands, commandName, 'command');
@@ -151,3 +162,35 @@ function addFieldToReadModel(model, filePath, readModelName, fieldInput) {
     });
     console.log(`Added field "${field.name}" to read model "${readModel.name}"`);
 }
+function addFieldToScreen(model, filePath, screenName, fieldInput) {
+    const screen = findElementOrExit(model.screens, screenName, 'screen');
+    // Check for duplicate field name
+    if (screen.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
+        console.error(`Error: Field "${fieldInput.name}" already exists on screen "${screen.name}"`);
+        process.exit(1);
+    }
+    const field = createFieldFromInput(fieldInput);
+    appendEvent(filePath, {
+        type: 'ScreenFieldAdded',
+        screenId: screen.id,
+        field,
+        timestamp: Date.now(),
+    });
+    console.log(`Added field "${field.name}" to screen "${screen.name}"`);
+}
+function addFieldToProcessor(model, filePath, processorName, fieldInput) {
+    const processor = findElementOrExit(model.processors, processorName, 'processor');
+    // Check for duplicate field name
+    if (processor.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
+        console.error(`Error: Field "${fieldInput.name}" already exists on processor "${processor.name}"`);
+        process.exit(1);
+    }
+    const field = createFieldFromInput(fieldInput);
+    appendEvent(filePath, {
+        type: 'ProcessorFieldAdded',
+        processorId: processor.id,
+        field,
+        timestamp: Date.now(),
+    });
+    console.log(`Added field "${field.name}" to processor "${processor.name}"`);
+}

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

@@ -1,5 +1,6 @@
 import { outputJson } from '../../lib/format.js';
 import { findElementOrExit } from '../../lib/element-lookup.js';
+import { findChapterForSlice, getChapterHierarchy } from '../../lib/chapter-utils.js';
 // Get components inside a slice by checking if center point is within bounds
 function getSliceComponents(model, slice) {
     const bounds = {
@@ -71,18 +72,6 @@ function findActorForScreen(model, screen) {
     }
     return undefined;
 }
-// Find which chapter contains a slice (based on horizontal center)
-function findChapterForSlice(model, slice) {
-    const sliceCenterX = slice.position.x + slice.size.width / 2;
-    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) {
-            return chapter;
-        }
-    }
-    return null;
-}
 // Convert Field to JSON-friendly format
 function fieldToJson(field) {
     const result = {
@@ -351,7 +340,7 @@ export function codegenSlice(model, sliceName) {
             id: slice.id,
             name: slice.name,
         },
-        ...(chapter && { chapter: { id: chapter.id, name: chapter.name } }),
+        ...(chapter && { chapter: getChapterHierarchy(model, chapter) }),
         elements: {
             readModels: components.readModels.map(rm => ({
                 id: rm.id,

package/dist/slices/list-slices/index.d.ts

@@ -1,3 +1,3 @@
 import type { EventModel } from '../../types.js';
 import { type OutputFormat } from '../../lib/format.js';
-export declare function listSlices(model: EventModel, format: OutputFormat): void;
+export declare function listSlices(model: EventModel, format: OutputFormat, chapterName?: string): void;

package/dist/slices/list-slices/index.js

@@ -1,9 +1,24 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
-export function listSlices(model, format) {
-    const slices = [...model.slices.values()];
+import { findElementOrExit } from '../../lib/element-lookup.js';
+function getSlicesUnderChapter(model, chapter) {
+    const chapterLeft = chapter.position.x;
+    const chapterRight = chapter.position.x + chapter.size.width;
+    return [...model.slices.values()].filter(slice => {
+        const sliceCenterX = slice.position.x + slice.size.width / 2;
+        return sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight;
+    });
+}
+export function listSlices(model, format, chapterName) {
+    let slices = [...model.slices.values()];
+    // Filter by chapter if specified
+    if (chapterName) {
+        const chapter = findElementOrExit(model.chapters, chapterName, 'chapter');
+        slices = getSlicesUnderChapter(model, chapter);
+    }
     const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
     if (format === 'json') {
         outputJson({
+            ...(chapterName && { chapter: chapterName }),
             slices: sorted.map(s => ({ id: s.id, name: s.name, status: s.status }))
         });
         return;

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

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

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

@@ -2,13 +2,13 @@ import { appendEvent } from '../../lib/file-loader.js';
 import { findElementOrExit } from '../../lib/element-lookup.js';
 export function removeField(model, filePath, options, fieldName) {
     // 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) {
@@ -20,6 +20,12 @@ export function removeField(model, filePath, options, fieldName) {
     else if (options.readModel) {
         removeFieldFromReadModel(model, filePath, options.readModel, fieldName);
     }
+    else if (options.screen) {
+        removeFieldFromScreen(model, filePath, options.screen, fieldName);
+    }
+    else if (options.processor) {
+        removeFieldFromProcessor(model, filePath, options.processor, fieldName);
+    }
 }
 function removeFieldFromCommand(model, filePath, commandName, fieldName) {
     const command = findElementOrExit(model.commands, commandName, 'command');
@@ -96,3 +102,53 @@ function removeFieldFromReadModel(model, filePath, readModelName, fieldName) {
     });
     console.log(`Removed field "${field.name}" from read model "${readModel.name}"`);
 }
+function removeFieldFromScreen(model, filePath, screenName, fieldName) {
+    const screen = findElementOrExit(model.screens, screenName, 'screen');
+    const fieldNameLower = fieldName.toLowerCase();
+    const field = screen.fields.find(f => f.name.toLowerCase() === fieldNameLower);
+    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} (${f.fieldType})`);
+            }
+        }
+        else {
+            console.error('This screen has no fields.');
+        }
+        process.exit(1);
+    }
+    appendEvent(filePath, {
+        type: 'ScreenFieldRemoved',
+        screenId: screen.id,
+        fieldId: field.id,
+        timestamp: Date.now(),
+    });
+    console.log(`Removed field "${field.name}" from screen "${screen.name}"`);
+}
+function removeFieldFromProcessor(model, filePath, processorName, fieldName) {
+    const processor = findElementOrExit(model.processors, processorName, 'processor');
+    const fieldNameLower = fieldName.toLowerCase();
+    const field = processor.fields.find(f => f.name.toLowerCase() === fieldNameLower);
+    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} (${f.fieldType})`);
+            }
+        }
+        else {
+            console.error('This processor has no fields.');
+        }
+        process.exit(1);
+    }
+    appendEvent(filePath, {
+        type: 'ProcessorFieldRemoved',
+        processorId: processor.id,
+        fieldId: field.id,
+        timestamp: Date.now(),
+    });
+    console.log(`Removed field "${field.name}" from processor "${processor.name}"`);
+}

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

@@ -1,5 +1,7 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
 import { findElementOrExit } from '../../lib/element-lookup.js';
+import { getChapterHierarchy, findChapterForSlice } from '../../lib/chapter-utils.js';
+import { findSliceToSliceFlows, findChapterInboundFlows, findChapterOutboundFlows, } from '../../lib/flow-utils.js';
 function getSlicesUnderChapter(model, chapter) {
     // A slice is "under" a chapter if its horizontal center falls within the chapter's x range
     const chapterLeft = chapter.position.x;
@@ -9,18 +11,149 @@ function getSlicesUnderChapter(model, chapter) {
         return sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight;
     }).sort((a, b) => a.position.x - b.position.x);
 }
+function formatSliceFlowXml(sliceFlow) {
+    let xml = `    <slice-flow from="${escapeXml(sliceFlow.fromSlice.name)}" to="${escapeXml(sliceFlow.toSlice.name)}">\n`;
+    for (const flow of sliceFlow.flows) {
+        xml += `      <via type="${flow.flowType}">\n`;
+        xml += `        <source element="${escapeXml(flow.source.name)}" type="${flow.source.type}"/>\n`;
+        xml += `        <target element="${escapeXml(flow.target.name)}" type="${flow.target.type}"/>\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 += '      </via>\n';
+    }
+    xml += '    </slice-flow>\n';
+    return xml;
+}
+function formatExternalFlowXml(flow, direction, model) {
+    let xml = `      <flow ${direction === 'inbound' ? `to-slice="${escapeXml(flow.targetSlice?.name ?? 'unknown')}"` : `from-slice="${escapeXml(flow.sourceSlice?.name ?? 'unknown')}"`} type="${flow.flowType}">\n`;
+    // For inbound: source is external, for outbound: target is external
+    if (direction === 'inbound') {
+        // Find the chapter of the external source
+        const sourceSlice = flow.sourceSlice;
+        let chapterInfo = '';
+        if (sourceSlice) {
+            const sourceSliceObj = model.slices.get(sourceSlice.id);
+            if (sourceSliceObj) {
+                const sourceChapter = findChapterForSlice(model, sourceSliceObj);
+                if (sourceChapter) {
+                    chapterInfo = ` chapter="${escapeXml(sourceChapter.name)}"`;
+                }
+            }
+        }
+        xml += `        <from external="true"${chapterInfo}>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
+        xml += `        <to>${escapeXml(flow.target.name)} (${flow.target.type})</to>\n`;
+    }
+    else {
+        xml += `        <from>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
+        // Find the chapter of the external target
+        const targetSlice = flow.targetSlice;
+        let chapterInfo = '';
+        if (targetSlice) {
+            const targetSliceObj = model.slices.get(targetSlice.id);
+            if (targetSliceObj) {
+                const targetChapter = findChapterForSlice(model, targetSliceObj);
+                if (targetChapter) {
+                    chapterInfo = ` chapter="${escapeXml(targetChapter.name)}"`;
+                }
+            }
+        }
+        xml += `        <to external="true"${chapterInfo}>${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';
+    return xml;
+}
 export function showChapter(model, name, format) {
     const chapter = findElementOrExit(model.chapters, name, 'chapter');
     const slices = getSlicesUnderChapter(model, chapter);
+    // Get flow information
+    const sliceToSliceFlows = findSliceToSliceFlows(model, slices);
+    const chapterInboundFlows = findChapterInboundFlows(model, slices);
+    const chapterOutboundFlows = findChapterOutboundFlows(model, slices);
     if (format === 'json') {
-        outputJson({
+        const result = {
             id: chapter.id,
             name: chapter.name,
+            parent: chapter ? getChapterHierarchy(model, chapter).parent : undefined,
             slices: slices.map(s => ({ id: s.id, name: s.name, status: s.status }))
-        });
+        };
+        // Add flow graph if there are slice-to-slice flows
+        if (sliceToSliceFlows.length > 0) {
+            result.flowGraph = sliceToSliceFlows.map(sf => ({
+                from: sf.fromSlice.name,
+                to: sf.toSlice.name,
+                flows: sf.flows.map(f => ({
+                    type: f.flowType,
+                    source: { element: f.source.name, type: f.source.type },
+                    target: { element: f.target.name, type: f.target.type },
+                    ...(f.fieldMappings.length > 0 && {
+                        mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
+                    })
+                }))
+            }));
+        }
+        // Add external dependencies
+        if (chapterInboundFlows.length > 0 || chapterOutboundFlows.length > 0) {
+            result.externalDependencies = {
+                ...(chapterInboundFlows.length > 0 && {
+                    inbound: chapterInboundFlows.map(f => {
+                        const sourceSliceObj = f.sourceSlice ? model.slices.get(f.sourceSlice.id) : null;
+                        const sourceChapter = sourceSliceObj ? findChapterForSlice(model, sourceSliceObj) : null;
+                        return {
+                            toSlice: f.targetSlice?.name,
+                            type: f.flowType,
+                            from: {
+                                element: f.source.name,
+                                type: f.source.type,
+                                slice: f.sourceSlice?.name,
+                                chapter: sourceChapter?.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 }))
+                            })
+                        };
+                    })
+                }),
+                ...(chapterOutboundFlows.length > 0 && {
+                    outbound: chapterOutboundFlows.map(f => {
+                        const targetSliceObj = f.targetSlice ? model.slices.get(f.targetSlice.id) : null;
+                        const targetChapter = targetSliceObj ? findChapterForSlice(model, targetSliceObj) : null;
+                        return {
+                            fromSlice: f.sourceSlice?.name,
+                            type: f.flowType,
+                            from: { element: f.source.name, type: f.source.type },
+                            to: {
+                                element: f.target.name,
+                                type: f.target.type,
+                                slice: f.targetSlice?.name,
+                                chapter: targetChapter?.name
+                            },
+                            ...(f.fieldMappings.length > 0 && {
+                                mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
+                            })
+                        };
+                    })
+                })
+            };
+        }
+        outputJson(result);
         return;
     }
+    // XML format
     console.log(`<chapter id="${chapter.id}" name="${escapeXml(chapter.name)}">`);
+    // Slices section
     if (slices.length === 0) {
         console.log('  <slices/>');
     }
@@ -31,5 +164,32 @@ export function showChapter(model, name, format) {
         }
         console.log('  </slices>');
     }
+    // Flow graph section
+    if (sliceToSliceFlows.length > 0) {
+        console.log('  <flow-graph>');
+        for (const sliceFlow of sliceToSliceFlows) {
+            process.stdout.write(formatSliceFlowXml(sliceFlow));
+        }
+        console.log('  </flow-graph>');
+    }
+    // External dependencies section
+    if (chapterInboundFlows.length > 0 || chapterOutboundFlows.length > 0) {
+        console.log('  <external-dependencies>');
+        if (chapterInboundFlows.length > 0) {
+            console.log('    <inbound>');
+            for (const flow of chapterInboundFlows) {
+                process.stdout.write(formatExternalFlowXml(flow, 'inbound', model));
+            }
+            console.log('    </inbound>');
+        }
+        if (chapterOutboundFlows.length > 0) {
+            console.log('    <outbound>');
+            for (const flow of chapterOutboundFlows) {
+                process.stdout.write(formatExternalFlowXml(flow, 'outbound', model));
+            }
+            console.log('    </outbound>');
+        }
+        console.log('  </external-dependencies>');
+    }
     console.log('</chapter>');
 }