eventmodeler 0.2.1 → 0.2.3

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

@@ -1,9 +1,62 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
+import { escapeXml, outputJson } from '../../lib/format.js';
+const INCOMING_FLOW_TYPES = {
+    command: ['ScreenToCommand', 'ProcessorToCommand'],
+    event: ['CommandToEvent'],
+    readModel: ['EventToReadModel'],
+    screen: ['ReadModelToScreen'],
+    processor: ['ReadModelToProcessor'],
+};
+function findElementByName(model, name) {
+    const nameLower = name.toLowerCase();
+    // Search commands
+    for (const cmd of model.commands.values()) {
+        if (cmd.name.toLowerCase() === nameLower || cmd.name.toLowerCase().includes(nameLower)) {
+            return { id: cmd.id, name: cmd.name, fields: cmd.fields, type: 'command' };
+        }
+    }
+    // Search events
+    for (const evt of model.events.values()) {
+        if (evt.name.toLowerCase() === nameLower || evt.name.toLowerCase().includes(nameLower)) {
+            return { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' };
+        }
+    }
+    // Search read models
+    for (const rm of model.readModels.values()) {
+        if (rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower)) {
+            return { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' };
+        }
+    }
+    // Search screens
+    for (const scr of model.screens.values()) {
+        if (scr.name.toLowerCase() === nameLower || scr.name.toLowerCase().includes(nameLower)) {
+            return { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' };
+        }
+    }
+    // Search processors
+    for (const proc of model.processors.values()) {
+        if (proc.name.toLowerCase() === nameLower || proc.name.toLowerCase().includes(nameLower)) {
+            return { id: proc.id, name: proc.name, fields: proc.fields, type: 'processor' };
+        }
+    }
+    return null;
+}
+function getSourceFields(model, sourceId) {
+    const cmd = model.commands.get(sourceId);
+    if (cmd)
+        return cmd.fields;
+    const evt = model.events.get(sourceId);
+    if (evt)
+        return evt.fields;
+    const rm = model.readModels.get(sourceId);
+    if (rm)
+        return rm.fields;
+    const scr = model.screens.get(sourceId);
+    if (scr)
+        return scr.fields;
+    const proc = model.processors.get(sourceId);
+    if (proc)
+        return proc.fields;
+    return [];
 }
 function flattenFields(fields, prefix = '') {
     const result = [];
@@ -104,40 +157,82 @@ function calculateFlowCompleteness(model, flow, targetFields, sourceFields) {
         })),
     };
 }
-export function showCompleteness(model, readModelName) {
-    // Find the read model
-    const nameLower = readModelName.toLowerCase();
-    const readModels = [...model.readModels.values()];
-    const readModel = readModels.find(rm => rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower));
-    if (!readModel) {
-        console.error(`Error: Read model not found: ${readModelName}`);
-        console.error('Available read models:');
-        for (const rm of readModels) {
-            console.error(`  - ${rm.name}`);
-        }
+export function showCompleteness(model, elementName, format) {
+    // Find the element by name (searches all element types)
+    const element = findElementByName(model, elementName);
+    if (!element) {
+        console.error(`Error: Element not found: ${elementName}`);
+        console.error('Search looked in: commands, events, read models, screens, processors');
         process.exit(1);
     }
-    // Find all flows into this read model (EventToReadModel flows)
-    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === readModel.id && f.flowType === 'EventToReadModel');
+    // Find all incoming flows for this element type
+    const validFlowTypes = INCOMING_FLOW_TYPES[element.type];
+    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === element.id && validFlowTypes.includes(f.flowType));
+    const elementTypeLabel = element.type === 'readModel' ? 'read-model' : element.type;
     if (incomingFlows.length === 0) {
-        console.log(`<completeness readModel="${escapeXml(readModel.name)}">`);
-        console.log('  <no-flows>No events flow into this read model</no-flows>');
-        console.log('</completeness>');
+        if (format === 'json') {
+            outputJson({
+                elementType: elementTypeLabel,
+                name: element.name,
+                message: `No flows into this ${elementTypeLabel}`
+            });
+        }
+        else {
+            console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}">`);
+            console.log(`  <no-flows>No flows into this ${elementTypeLabel}</no-flows>`);
+            console.log('</completeness>');
+        }
         return;
     }
     // Calculate completeness for each flow
     const completenessResults = [];
     for (const flow of incomingFlows) {
-        const sourceEvent = model.events.get(flow.sourceId);
-        if (!sourceEvent)
-            continue;
-        const result = calculateFlowCompleteness(model, flow, readModel.fields, sourceEvent.fields);
+        const sourceFields = getSourceFields(model, flow.sourceId);
+        if (sourceFields.length === 0 && element.fields.length > 0) {
+            // Source has no fields but target expects some - still calculate
+        }
+        const result = calculateFlowCompleteness(model, flow, element.fields, sourceFields);
         completenessResults.push(result);
     }
-    // Output XML
     const overallComplete = completenessResults.every(r => r.isComplete);
     const overallStatus = overallComplete ? 'complete' : 'incomplete';
-    console.log(`<completeness readModel="${escapeXml(readModel.name)}" status="${overallStatus}">`);
+    if (format === 'json') {
+        const flatTargetFields = flattenFields(element.fields);
+        outputJson({
+            elementType: elementTypeLabel,
+            name: element.name,
+            status: overallStatus,
+            flows: completenessResults.map(result => ({
+                flowId: result.flowId,
+                from: result.sourceName,
+                sourceType: result.sourceType,
+                status: result.isComplete ? 'complete' : 'incomplete',
+                ...(result.hasWarnings ? { hasWarnings: true } : {}),
+                targetFields: result.targetFields.map(f => ({
+                    name: f.fieldName,
+                    status: f.status,
+                    ...(f.sourceFieldName ? { source: f.sourceFieldName } : {})
+                })),
+                availableSourceFields: result.sourceFields.map(sf => ({
+                    id: sf.id,
+                    name: sf.name,
+                    type: sf.type,
+                    ...(sf.isList ? { isList: true } : {})
+                }))
+            })),
+            elementFields: flatTargetFields.map(({ id, path, field }) => ({
+                id,
+                name: path,
+                type: field.fieldType,
+                ...(field.isList ? { isList: true } : {}),
+                ...(field.isOptional ? { isOptional: true } : {}),
+                ...(field.isGenerated ? { isGenerated: true } : {})
+            }))
+        });
+        return;
+    }
+    // Output XML
+    console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}" status="${overallStatus}">`);
     for (const result of completenessResults) {
         const flowStatus = result.isComplete ? 'complete' : 'incomplete';
         const warningAttr = result.hasWarnings ? ' hasWarnings="true"' : '';
@@ -162,9 +257,9 @@ export function showCompleteness(model, readModelName) {
         console.log('    </available-source-fields>');
         console.log('  </flow>');
     }
-    // Also show the read model's fields with their IDs (needed for mapping)
-    console.log('  <read-model-fields>');
-    const flatTargetFields = flattenFields(readModel.fields);
+    // Also show the element's fields with their IDs (needed for mapping)
+    console.log(`  <${elementTypeLabel}-fields>`);
+    const flatTargetFields = flattenFields(element.fields);
     for (const { id, path, field } of flatTargetFields) {
         const attrs = [`id="${id}"`, `name="${escapeXml(path)}"`, `type="${field.fieldType}"`];
         if (field.isList)
@@ -175,6 +270,104 @@ export function showCompleteness(model, readModelName) {
             attrs.push('isGenerated="true"');
         console.log(`    <field ${attrs.join(' ')}/>`);
     }
-    console.log('  </read-model-fields>');
+    console.log(`  </${elementTypeLabel}-fields>`);
     console.log('</completeness>');
 }
+export function showModelCompleteness(model, format) {
+    const allFlows = [...model.flows.values()];
+    const incompleteFlows = [];
+    let completeCount = 0;
+    let totalCount = 0;
+    for (const flow of allFlows) {
+        // Get target element info
+        let targetName = 'Unknown';
+        let targetType = 'unknown';
+        let targetFields = [];
+        const targetCmd = model.commands.get(flow.targetId);
+        const targetEvt = model.events.get(flow.targetId);
+        const targetRm = model.readModels.get(flow.targetId);
+        const targetScr = model.screens.get(flow.targetId);
+        const targetProc = model.processors.get(flow.targetId);
+        if (targetCmd) {
+            targetName = targetCmd.name;
+            targetType = 'command';
+            targetFields = targetCmd.fields;
+        }
+        else if (targetEvt) {
+            targetName = targetEvt.name;
+            targetType = 'event';
+            targetFields = targetEvt.fields;
+        }
+        else if (targetRm) {
+            targetName = targetRm.name;
+            targetType = 'read-model';
+            targetFields = targetRm.fields;
+        }
+        else if (targetScr) {
+            targetName = targetScr.name;
+            targetType = 'screen';
+            targetFields = targetScr.fields;
+        }
+        else if (targetProc) {
+            targetName = targetProc.name;
+            targetType = 'processor';
+            targetFields = targetProc.fields;
+        }
+        // Get source fields
+        const sourceFields = getSourceFields(model, flow.sourceId);
+        // Calculate completeness
+        const result = calculateFlowCompleteness(model, flow, targetFields, sourceFields);
+        totalCount++;
+        if (result.isComplete) {
+            completeCount++;
+        }
+        else {
+            const unsatisfiedFields = result.targetFields
+                .filter(f => f.status === 'unsatisfied')
+                .map(f => f.fieldName);
+            incompleteFlows.push({
+                flow,
+                sourceName: result.sourceName,
+                targetName,
+                targetType,
+                unsatisfiedFields,
+            });
+        }
+    }
+    const incompleteCount = totalCount - completeCount;
+    if (format === 'json') {
+        outputJson({
+            summary: {
+                complete: completeCount,
+                incomplete: incompleteCount,
+                total: totalCount
+            },
+            incompleteFlows: incompleteFlows.map(item => ({
+                from: item.sourceName,
+                to: item.targetName,
+                targetType: item.targetType,
+                flowType: item.flow.flowType,
+                unsatisfiedFields: item.unsatisfiedFields
+            }))
+        });
+        return;
+    }
+    console.log('<model-completeness>');
+    console.log(`  <summary complete="${completeCount}" incomplete="${incompleteCount}" total="${totalCount}"/>`);
+    if (incompleteFlows.length > 0) {
+        console.log('  <incomplete-flows>');
+        for (const item of incompleteFlows) {
+            console.log(`    <flow from="${escapeXml(item.sourceName)}" to="${escapeXml(item.targetName)}" target-type="${item.targetType}" flow-type="${item.flow.flowType}">`);
+            if (item.unsatisfiedFields.length > 0) {
+                console.log('      <unsatisfied-fields>');
+                for (const fieldName of item.unsatisfiedFields) {
+                    console.log(`        <field name="${escapeXml(fieldName)}"/>`);
+                }
+                console.log('      </unsatisfied-fields>');
+            }
+            console.log('    </flow>');
+        }
+        console.log('  </incomplete-flows>');
+    }
+    console.log('</model-completeness>');
+}

package/dist/slices/show-event/index.d.ts

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

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

@@ -1,11 +1,4 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
+import { escapeXml, outputJson } from '../../lib/format.js';
 function formatFieldXml(field, indent) {
     const attrs = [
         `name="${escapeXml(field.name)}"`,
@@ -27,6 +20,22 @@ function formatFieldXml(field, indent) {
     }
     return `${indent}<field ${attrs.join(' ')}/>\n`;
 }
+function fieldToJson(field) {
+    const result = {
+        name: field.name,
+        type: field.fieldType
+    };
+    if (field.isList)
+        result.list = true;
+    if (field.isGenerated)
+        result.generated = true;
+    if (field.isOptional)
+        result.optional = true;
+    if (field.subfields && field.subfields.length > 0) {
+        result.subfields = field.subfields.map(fieldToJson);
+    }
+    return result;
+}
 // Find which aggregate an event belongs to (center point inside aggregate bounds)
 function findAggregateForEvent(model, event) {
     const centerX = event.position.x + event.width / 2;
@@ -78,7 +87,7 @@ function formatEventXml(model, event) {
     xml += '</event>';
     return xml;
 }
-export function showEvent(model, name) {
+export function showEvent(model, name, format) {
     const events = [...model.events.values()];
     const nameLower = name.toLowerCase();
     const event = events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
@@ -90,5 +99,28 @@ export function showEvent(model, name) {
         }
         process.exit(1);
     }
+    if (format === 'json') {
+        const aggregate = findAggregateForEvent(model, event);
+        const incomingFlows = [...model.flows.values()].filter(f => f.targetId === event.id);
+        const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === event.id);
+        const result = {
+            name: event.name,
+            fields: event.fields.map(fieldToJson)
+        };
+        if (aggregate)
+            result.aggregate = aggregate.name;
+        const producedBy = incomingFlows
+            .map(f => model.commands.get(f.sourceId)?.name)
+            .filter(Boolean);
+        if (producedBy.length > 0)
+            result.producedBy = producedBy;
+        const consumedBy = outgoingFlows
+            .map(f => model.readModels.get(f.targetId)?.name)
+            .filter(Boolean);
+        if (consumedBy.length > 0)
+            result.consumedBy = consumedBy;
+        outputJson(result);
+        return;
+    }
     console.log(formatEventXml(model, event));
 }

package/dist/slices/show-model-summary/index.d.ts

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

package/dist/slices/show-model-summary/index.js

@@ -1,12 +1,21 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-export function showModelSummary(model) {
+import { escapeXml, outputJson } from '../../lib/format.js';
+export function showModelSummary(model, format) {
+    if (format === 'json') {
+        outputJson({
+            name: model.name,
+            slices: model.slices.size,
+            commands: model.commands.size,
+            events: model.events.size,
+            readModels: model.readModels.size,
+            screens: model.screens.size,
+            processors: model.processors.size,
+            aggregates: model.aggregates.size,
+            actors: model.actors.size,
+            scenarios: model.scenarios.size,
+            flows: model.flows.size
+        });
+        return;
+    }
     console.log(`<model name="${escapeXml(model.name)}">`);
     console.log(`  <slices count="${model.slices.size}"/>`);
     console.log(`  <commands count="${model.commands.size}"/>`);

package/dist/slices/show-slice/index.d.ts

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

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

@@ -1,11 +1,4 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
+import { escapeXml, outputJson } from '../../lib/format.js';
 function formatFieldValues(values) {
     if (!values || Object.keys(values).length === 0)
         return '';
@@ -306,7 +299,163 @@ function formatSliceXml(model, slice) {
     xml += '</slice>';
     return xml;
 }
-export function showSlice(model, name) {
+function fieldToJson(field) {
+    const result = {
+        name: field.name,
+        type: field.fieldType
+    };
+    if (field.isList)
+        result.list = true;
+    if (field.isGenerated)
+        result.generated = true;
+    if (field.isOptional)
+        result.optional = true;
+    if (field.isUserInput)
+        result.userInput = true;
+    if (field.subfields && field.subfields.length > 0) {
+        result.subfields = field.subfields.map(fieldToJson);
+    }
+    return result;
+}
+function formatSliceJson(model, slice) {
+    const components = getSliceComponents(model, slice);
+    const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
+    const componentIds = new Set();
+    components.commands.forEach(c => componentIds.add(c.id));
+    components.events.forEach(e => componentIds.add(e.id));
+    components.readModels.forEach(rm => componentIds.add(rm.id));
+    components.screens.forEach(s => componentIds.add(s.id));
+    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));
+    function getName(id) {
+        return (model.commands.get(id)?.name ??
+            model.events.get(id)?.name ??
+            model.readModels.get(id)?.name ??
+            model.screens.get(id)?.name ??
+            model.processors.get(id)?.name ??
+            id);
+    }
+    const result = {
+        name: slice.name,
+        status: slice.status,
+        components: {
+            screens: components.screens.map(screen => {
+                const screenObj = {
+                    name: screen.name,
+                    fields: screen.fields.map(fieldToJson)
+                };
+                if (screen.originalNodeId) {
+                    screenObj.linkedCopy = true;
+                    const originSlice = findSliceForNode(model, screen.originalNodeId);
+                    if (originSlice)
+                        screenObj.originSlice = originSlice.name;
+                }
+                const actor = findActorForScreen(model, screen);
+                if (actor)
+                    screenObj.actor = actor.name;
+                return screenObj;
+            }),
+            commands: components.commands.map(cmd => ({
+                name: cmd.name,
+                fields: cmd.fields.map(fieldToJson)
+            })),
+            events: components.events.map(event => {
+                const eventObj = {
+                    name: event.name,
+                    fields: event.fields.map(fieldToJson)
+                };
+                if (event.originalNodeId) {
+                    eventObj.linkedCopy = true;
+                    const originSlice = findSliceForNode(model, event.originalNodeId);
+                    if (originSlice)
+                        eventObj.originSlice = originSlice.name;
+                }
+                const aggregate = findAggregateForEvent(model, event);
+                if (aggregate)
+                    eventObj.aggregate = aggregate.name;
+                return eventObj;
+            }),
+            readModels: components.readModels.map(rm => {
+                const rmObj = {
+                    name: rm.name,
+                    fields: rm.fields.map(fieldToJson)
+                };
+                if (rm.originalNodeId) {
+                    rmObj.linkedCopy = true;
+                    const originSlice = findSliceForNode(model, rm.originalNodeId);
+                    if (originSlice)
+                        rmObj.originSlice = originSlice.name;
+                }
+                return rmObj;
+            }),
+            processors: components.processors.map(proc => ({
+                name: proc.name,
+                fields: proc.fields.map(fieldToJson)
+            }))
+        }
+    };
+    if (internalFlows.length > 0) {
+        result.informationFlow = internalFlows.map(flow => ({
+            from: getName(flow.sourceId),
+            to: getName(flow.targetId)
+        }));
+    }
+    if (scenarios.length > 0) {
+        result.scenarios = scenarios.map(scenario => {
+            const scenarioObj = { name: scenario.name };
+            if (scenario.description)
+                scenarioObj.description = scenario.description;
+            if (scenario.givenEvents.length > 0) {
+                scenarioObj.given = scenario.givenEvents.map(given => {
+                    const evt = model.events.get(given.eventStickyId);
+                    return {
+                        eventType: evt?.name ?? 'UnknownEvent',
+                        ...(given.fieldValues && Object.keys(given.fieldValues).length > 0 ? { fieldValues: given.fieldValues } : {})
+                    };
+                });
+            }
+            if (scenario.whenCommand) {
+                const cmd = model.commands.get(scenario.whenCommand.commandStickyId);
+                scenarioObj.when = {
+                    commandType: cmd?.name ?? 'UnknownCommand',
+                    ...(scenario.whenCommand.fieldValues && Object.keys(scenario.whenCommand.fieldValues).length > 0 ? { fieldValues: scenario.whenCommand.fieldValues } : {})
+                };
+            }
+            if (scenario.then.type === 'error') {
+                scenarioObj.then = {
+                    type: 'error',
+                    ...(scenario.then.errorType ? { errorType: scenario.then.errorType } : {}),
+                    ...(scenario.then.errorMessage ? { errorMessage: scenario.then.errorMessage } : {})
+                };
+            }
+            else if (scenario.then.type === 'events' && scenario.then.expectedEvents) {
+                scenarioObj.then = {
+                    type: 'events',
+                    expectedEvents: scenario.then.expectedEvents.map(expected => {
+                        const evt = model.events.get(expected.eventStickyId);
+                        return {
+                            eventType: evt?.name ?? 'UnknownEvent',
+                            ...(expected.fieldValues && Object.keys(expected.fieldValues).length > 0 ? { fieldValues: expected.fieldValues } : {})
+                        };
+                    })
+                };
+            }
+            else if (scenario.then.type === 'readModelAssertion' && scenario.then.readModelAssertion) {
+                const assertion = scenario.then.readModelAssertion;
+                const rm = model.readModels.get(assertion.readModelStickyId);
+                scenarioObj.then = {
+                    type: 'readModelAssertion',
+                    readModelType: rm?.name ?? 'UnknownReadModel',
+                    expectedFieldValues: assertion.expectedFieldValues
+                };
+            }
+            return scenarioObj;
+        });
+    }
+    return result;
+}
+export function showSlice(model, name, format) {
     const slices = [...model.slices.values()];
     const nameLower = name.toLowerCase();
     const slice = slices.find(s => s.name.toLowerCase() === nameLower || s.name.toLowerCase().includes(nameLower));
@@ -318,5 +467,9 @@ export function showSlice(model, name) {
         }
         process.exit(1);
     }
+    if (format === 'json') {
+        outputJson(formatSliceJson(model, slice));
+        return;
+    }
     console.log(formatSliceXml(model, slice));
 }

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "eventmodeler",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "CLI tool for interacting with Event Model files - query, update, and export event models from the terminal",
   "type": "module",
   "bin": {
     "eventmodeler": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "scripts": {
     "build": "tsc",
@@ -27,7 +28,8 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/your-username/event-modeler"
+    "url": "https://github.com/theoema/event-modeler",
+    "directory": "cli"
   },
   "homepage": "https://www.eventmodeling.app",
   "engines": {