eventmodeler 0.2.1 → 0.2.4

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

@@ -1,11 +1,5 @@
-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';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 function formatFieldValues(values) {
     if (!values || Object.keys(values).length === 0)
         return '';
@@ -127,7 +121,7 @@ function formatSliceXml(model, slice) {
             model.processors.get(id)?.name ??
             id);
     }
-    let xml = `<slice name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
+    let xml = `<slice id="${slice.id}" name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
     xml += '  <components>\n';
     for (const screen of components.screens) {
         // Check if this is a linked copy
@@ -142,7 +136,7 @@ function formatSliceXml(model, slice) {
         // Check which actor this screen belongs to
         const actor = findActorForScreen(model, screen);
         const actorAttr = actor ? ` actor="${escapeXml(actor.name)}"` : '';
-        xml += `    <screen name="${escapeXml(screen.name)}"${copyAttr}${originAttr}${actorAttr}>\n`;
+        xml += `    <screen id="${screen.id}" name="${escapeXml(screen.name)}"${copyAttr}${originAttr}${actorAttr}>\n`;
         if (screen.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of screen.fields) {
@@ -153,7 +147,7 @@ function formatSliceXml(model, slice) {
         xml += '    </screen>\n';
     }
     for (const command of components.commands) {
-        xml += `    <command name="${escapeXml(command.name)}">\n`;
+        xml += `    <command id="${command.id}" name="${escapeXml(command.name)}">\n`;
         if (command.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of command.fields) {
@@ -184,7 +178,7 @@ function formatSliceXml(model, slice) {
         // Check which aggregate this event belongs to
         const aggregate = findAggregateForEvent(model, event);
         const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
-        xml += `    <event name="${escapeXml(event.name)}"${copyAttr}${originAttr}${aggregateAttr}>\n`;
+        xml += `    <event id="${event.id}" name="${escapeXml(event.name)}"${copyAttr}${originAttr}${aggregateAttr}>\n`;
         if (event.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of event.fields) {
@@ -215,7 +209,7 @@ function formatSliceXml(model, slice) {
                 originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
             }
         }
-        xml += `    <read-model name="${escapeXml(readModel.name)}"${copyAttr}${originAttr}>\n`;
+        xml += `    <read-model id="${readModel.id}" name="${escapeXml(readModel.name)}"${copyAttr}${originAttr}>\n`;
         if (readModel.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of readModel.fields) {
@@ -226,7 +220,7 @@ function formatSliceXml(model, slice) {
         xml += '    </read-model>\n';
     }
     for (const processor of components.processors) {
-        xml += `    <processor name="${escapeXml(processor.name)}">\n`;
+        xml += `    <processor id="${processor.id}" name="${escapeXml(processor.name)}">\n`;
         if (processor.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of processor.fields) {
@@ -306,17 +300,173 @@ function formatSliceXml(model, slice) {
     xml += '</slice>';
     return xml;
 }
-export function showSlice(model, name) {
-    const slices = [...model.slices.values()];
-    const nameLower = name.toLowerCase();
-    const slice = slices.find(s => s.name.toLowerCase() === nameLower || s.name.toLowerCase().includes(nameLower));
-    if (!slice) {
-        console.error(`Error: Slice not found: ${name}`);
-        console.error('Available slices:');
-        for (const s of slices) {
-            console.error(`  - ${s.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 = {
+        id: slice.id,
+        name: slice.name,
+        status: slice.status,
+        components: {
+            screens: components.screens.map(screen => {
+                const screenObj = {
+                    id: screen.id,
+                    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 => ({
+                id: cmd.id,
+                name: cmd.name,
+                fields: cmd.fields.map(fieldToJson)
+            })),
+            events: components.events.map(event => {
+                const eventObj = {
+                    id: event.id,
+                    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 = {
+                    id: rm.id,
+                    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 => ({
+                id: proc.id,
+                name: proc.name,
+                fields: proc.fields.map(fieldToJson)
+            }))
         }
-        process.exit(1);
+    };
+    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 slice = findElementOrExit(model.slices, name, 'slice');
+    if (format === 'json') {
+        outputJson(formatSliceJson(model, slice));
+        return;
     }
     console.log(formatSliceXml(model, slice));
 }

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

@@ -1,4 +1,5 @@
 import { appendEvent } from '../../lib/file-loader.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 function findFieldByName(fields, fieldName) {
     const nameLower = fieldName.toLowerCase();
     for (const field of fields) {
@@ -52,17 +53,7 @@ export function updateField(model, filePath, options, fieldName, updates) {
     }
 }
 function updateCommandField(model, filePath, commandName, fieldName, updates) {
-    const nameLower = commandName.toLowerCase();
-    const commands = [...model.commands.values()];
-    const command = commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
-    if (!command) {
-        console.error(`Error: Command not found: ${commandName}`);
-        console.error('Available commands:');
-        for (const c of commands) {
-            console.error(`  - ${c.name}`);
-        }
-        process.exit(1);
-    }
+    const command = findElementOrExit(model.commands, commandName, 'command');
     const field = findFieldByName(command.fields, fieldName);
     if (!field) {
         console.error(`Error: Field "${fieldName}" not found on command "${command.name}"`);
@@ -86,17 +77,7 @@ function updateCommandField(model, filePath, commandName, fieldName, updates) {
     logUpdates(updates);
 }
 function updateEventField(model, filePath, eventName, fieldName, updates) {
-    const nameLower = eventName.toLowerCase();
-    const events = [...model.events.values()];
-    const event = events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
-    if (!event) {
-        console.error(`Error: Event not found: ${eventName}`);
-        console.error('Available events:');
-        for (const e of events) {
-            console.error(`  - ${e.name}`);
-        }
-        process.exit(1);
-    }
+    const event = findElementOrExit(model.events, eventName, 'event');
     const field = findFieldByName(event.fields, fieldName);
     if (!field) {
         console.error(`Error: Field "${fieldName}" not found on event "${event.name}"`);
@@ -120,17 +101,7 @@ function updateEventField(model, filePath, eventName, fieldName, updates) {
     logUpdates(updates);
 }
 function updateReadModelField(model, filePath, readModelName, fieldName, updates) {
-    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}`);
-        }
-        process.exit(1);
-    }
+    const readModel = findElementOrExit(model.readModels, readModelName, 'read model');
     const field = findFieldByName(readModel.fields, fieldName);
     if (!field) {
         console.error(`Error: Field "${fieldName}" not found on read model "${readModel.name}"`);

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "eventmodeler",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "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": {