eventmodeler 0.3.10 → 0.4.1

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

@@ -0,0 +1,196 @@
+import { escapeXml, outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
+// Resolve event name from ID
+function getEventName(model, eventId) {
+    const event = model.events.get(eventId);
+    return event?.name ?? eventId;
+}
+// Resolve command name from ID
+function getCommandName(model, commandId) {
+    const command = model.commands.get(commandId);
+    return command?.name ?? commandId;
+}
+// Format event reference for XML
+function formatEventRefXml(model, ref, indent) {
+    const name = getEventName(model, ref.eventStickyId);
+    if (ref.fieldValues && Object.keys(ref.fieldValues).length > 0) {
+        let xml = `${indent}<event name="${escapeXml(name)}">\n`;
+        xml += `${indent}  <field-values>\n`;
+        for (const [key, value] of Object.entries(ref.fieldValues)) {
+            xml += `${indent}    <field name="${escapeXml(key)}" value="${escapeXml(String(value))}"/>\n`;
+        }
+        xml += `${indent}  </field-values>\n`;
+        xml += `${indent}</event>\n`;
+        return xml;
+    }
+    return `${indent}<event name="${escapeXml(name)}"/>\n`;
+}
+// Format command reference for XML
+function formatCommandRefXml(model, ref, indent) {
+    const name = getCommandName(model, ref.commandStickyId);
+    if (ref.fieldValues && Object.keys(ref.fieldValues).length > 0) {
+        let xml = `${indent}<command name="${escapeXml(name)}">\n`;
+        xml += `${indent}  <field-values>\n`;
+        for (const [key, value] of Object.entries(ref.fieldValues)) {
+            xml += `${indent}    <field name="${escapeXml(key)}" value="${escapeXml(String(value))}"/>\n`;
+        }
+        xml += `${indent}  </field-values>\n`;
+        xml += `${indent}</command>\n`;
+        return xml;
+    }
+    return `${indent}<command name="${escapeXml(name)}"/>\n`;
+}
+// Format event reference for JSON
+function eventRefToJson(model, ref) {
+    const result = {
+        name: getEventName(model, ref.eventStickyId)
+    };
+    if (ref.fieldValues && Object.keys(ref.fieldValues).length > 0) {
+        result.fieldValues = ref.fieldValues;
+    }
+    return result;
+}
+// Format command reference for JSON
+function commandRefToJson(model, ref) {
+    const result = {
+        name: getCommandName(model, ref.commandStickyId)
+    };
+    if (ref.fieldValues && Object.keys(ref.fieldValues).length > 0) {
+        result.fieldValues = ref.fieldValues;
+    }
+    return result;
+}
+export function showScenario(model, name, format) {
+    const scenario = findElementOrExit(model.scenarios, name, 'scenario');
+    // Find the slice this scenario belongs to
+    const slice = model.slices.get(scenario.sliceId);
+    const sliceName = slice?.name ?? scenario.sliceId;
+    if (format === 'json') {
+        const result = {
+            id: scenario.id,
+            name: scenario.name,
+            slice: sliceName
+        };
+        if (scenario.description) {
+            result.description = scenario.description;
+        }
+        // Given
+        if (scenario.givenEvents.length > 0) {
+            result.given = {
+                type: 'events',
+                events: scenario.givenEvents.map(ref => eventRefToJson(model, ref))
+            };
+        }
+        // When
+        if (scenario.whenCommand) {
+            result.when = {
+                type: 'command',
+                command: commandRefToJson(model, scenario.whenCommand)
+            };
+        }
+        else if (scenario.whenEvents.length > 0) {
+            result.when = {
+                type: 'events',
+                events: scenario.whenEvents.map(ref => eventRefToJson(model, ref))
+            };
+        }
+        // Then
+        const thenResult = { type: scenario.then.type };
+        switch (scenario.then.type) {
+            case 'events':
+                if (scenario.then.expectedEvents) {
+                    thenResult.events = scenario.then.expectedEvents.map(ref => eventRefToJson(model, ref));
+                }
+                break;
+            case 'error':
+                if (scenario.then.errorMessage)
+                    thenResult.errorMessage = scenario.then.errorMessage;
+                if (scenario.then.errorType)
+                    thenResult.errorType = scenario.then.errorType;
+                break;
+            case 'command':
+                if (scenario.then.expectedCommand) {
+                    thenResult.command = commandRefToJson(model, scenario.then.expectedCommand);
+                }
+                break;
+            case 'readModelAssertion':
+                if (scenario.then.readModelAssertion) {
+                    const rm = model.readModels.get(scenario.then.readModelAssertion.readModelStickyId);
+                    thenResult.readModel = rm?.name ?? scenario.then.readModelAssertion.readModelStickyId;
+                    thenResult.expectedFieldValues = scenario.then.readModelAssertion.expectedFieldValues;
+                }
+                break;
+        }
+        result.then = thenResult;
+        outputJson(result);
+        return;
+    }
+    // XML output
+    console.log(`<scenario id="${scenario.id}" name="${escapeXml(scenario.name)}" slice="${escapeXml(sliceName)}">`);
+    if (scenario.description) {
+        console.log(`  <description>${escapeXml(scenario.description)}</description>`);
+    }
+    // Given
+    if (scenario.givenEvents.length > 0) {
+        console.log('  <given type="events">');
+        for (const ref of scenario.givenEvents) {
+            process.stdout.write(formatEventRefXml(model, ref, '    '));
+        }
+        console.log('  </given>');
+    }
+    // When
+    if (scenario.whenCommand) {
+        console.log('  <when type="command">');
+        process.stdout.write(formatCommandRefXml(model, scenario.whenCommand, '    '));
+        console.log('  </when>');
+    }
+    else if (scenario.whenEvents.length > 0) {
+        console.log('  <when type="events">');
+        for (const ref of scenario.whenEvents) {
+            process.stdout.write(formatEventRefXml(model, ref, '    '));
+        }
+        console.log('  </when>');
+    }
+    // Then
+    console.log(`  <then type="${scenario.then.type}">`);
+    switch (scenario.then.type) {
+        case 'events':
+            if (scenario.then.expectedEvents) {
+                for (const ref of scenario.then.expectedEvents) {
+                    process.stdout.write(formatEventRefXml(model, ref, '    '));
+                }
+            }
+            break;
+        case 'error':
+            if (scenario.then.errorMessage) {
+                console.log(`    <error-message>${escapeXml(scenario.then.errorMessage)}</error-message>`);
+            }
+            if (scenario.then.errorType) {
+                console.log(`    <error-type>${escapeXml(scenario.then.errorType)}</error-type>`);
+            }
+            break;
+        case 'command':
+            if (scenario.then.expectedCommand) {
+                process.stdout.write(formatCommandRefXml(model, scenario.then.expectedCommand, '    '));
+            }
+            break;
+        case 'readModelAssertion':
+            if (scenario.then.readModelAssertion) {
+                const rm = model.readModels.get(scenario.then.readModelAssertion.readModelStickyId);
+                const rmName = rm?.name ?? scenario.then.readModelAssertion.readModelStickyId;
+                console.log(`    <read-model name="${escapeXml(rmName)}">`);
+                console.log('      <expected-field-values>');
+                for (const [key, value] of Object.entries(scenario.then.readModelAssertion.expectedFieldValues)) {
+                    console.log(`        <field name="${escapeXml(key)}" value="${escapeXml(String(value))}"/>`);
+                }
+                console.log('      </expected-field-values>');
+                console.log('    </read-model>');
+            }
+            break;
+        case 'noCommand':
+            console.log('    <!-- No command expected -->');
+            break;
+    }
+    console.log('  </then>');
+    console.log('</scenario>');
+}

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

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

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

@@ -0,0 +1,139 @@
+import { escapeXml, outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
+function formatFieldXml(field, indent) {
+    const attrs = [
+        `name="${escapeXml(field.name)}"`,
+        `type="${field.fieldType}"`,
+    ];
+    if (field.isList)
+        attrs.push('list="true"');
+    if (field.isGenerated)
+        attrs.push('generated="true"');
+    if (field.isOptional)
+        attrs.push('optional="true"');
+    if (field.isUserInput)
+        attrs.push('user-input="true"');
+    if (field.subfields && field.subfields.length > 0) {
+        let xml = `${indent}<field ${attrs.join(' ')}>\n`;
+        for (const subfield of field.subfields) {
+            xml += formatFieldXml(subfield, indent + '  ');
+        }
+        xml += `${indent}</field>\n`;
+        return xml;
+    }
+    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.isUserInput)
+        result.userInput = true;
+    if (field.subfields && field.subfields.length > 0) {
+        result.subfields = field.subfields.map(fieldToJson);
+    }
+    return result;
+}
+// Find which slice contains a screen
+function findSliceForScreen(model, screen) {
+    for (const slice of model.slices.values()) {
+        const centerX = screen.position.x + screen.width / 2;
+        const centerY = screen.position.y + screen.height / 2;
+        if (centerX >= slice.position.x &&
+            centerX <= slice.position.x + slice.size.width &&
+            centerY >= slice.position.y &&
+            centerY <= slice.position.y + slice.size.height) {
+            return slice.name;
+        }
+    }
+    return null;
+}
+// Find which actor contains a screen
+function findActorForScreen(model, screen) {
+    const centerX = screen.position.x + screen.width / 2;
+    const centerY = screen.position.y + screen.height / 2;
+    for (const actor of model.actors.values()) {
+        const bounds = {
+            left: actor.position.x,
+            right: actor.position.x + actor.size.width,
+            top: actor.position.y,
+            bottom: actor.position.y + actor.size.height,
+        };
+        if (centerX >= bounds.left && centerX <= bounds.right &&
+            centerY >= bounds.top && centerY <= bounds.bottom) {
+            return actor;
+        }
+    }
+    return null;
+}
+export function showScreen(model, name, format) {
+    // Filter out linked copies
+    const originalScreens = new Map([...model.screens.entries()].filter(([_, s]) => !s.originalNodeId));
+    const screen = findElementOrExit(originalScreens, name, 'screen');
+    const slice = findSliceForScreen(model, screen);
+    const actor = findActorForScreen(model, screen);
+    // Find incoming flows (ReadModel → Screen)
+    const incomingFlows = [...model.flows.values()].filter(f => f.flowType === 'ReadModelToScreen' && f.targetId === screen.id);
+    // Find outgoing flows (Screen → Command)
+    const outgoingFlows = [...model.flows.values()].filter(f => f.flowType === 'ScreenToCommand' && f.sourceId === screen.id);
+    if (format === 'json') {
+        const result = {
+            id: screen.id,
+            name: screen.name,
+            fields: screen.fields.map(fieldToJson)
+        };
+        if (slice)
+            result.slice = slice;
+        if (actor)
+            result.actor = actor.name;
+        if (incomingFlows.length > 0) {
+            result.displaysFrom = incomingFlows.map(flow => {
+                const rm = model.readModels.get(flow.sourceId);
+                return rm?.name ?? flow.sourceId;
+            });
+        }
+        if (outgoingFlows.length > 0) {
+            result.triggersCommands = outgoingFlows.map(flow => {
+                const cmd = model.commands.get(flow.targetId);
+                return cmd?.name ?? flow.targetId;
+            });
+        }
+        outputJson(result);
+        return;
+    }
+    // XML output
+    const sliceAttr = slice ? ` slice="${escapeXml(slice)}"` : '';
+    const actorAttr = actor ? ` actor="${escapeXml(actor.name)}"` : '';
+    console.log(`<screen id="${screen.id}" name="${escapeXml(screen.name)}"${sliceAttr}${actorAttr}>`);
+    if (screen.fields.length > 0) {
+        console.log('  <fields>');
+        for (const field of screen.fields) {
+            process.stdout.write(formatFieldXml(field, '    '));
+        }
+        console.log('  </fields>');
+    }
+    if (incomingFlows.length > 0) {
+        console.log('  <displays-from>');
+        for (const flow of incomingFlows) {
+            const rm = model.readModels.get(flow.sourceId);
+            console.log(`    <read-model name="${escapeXml(rm?.name ?? flow.sourceId)}"/>`);
+        }
+        console.log('  </displays-from>');
+    }
+    if (outgoingFlows.length > 0) {
+        console.log('  <triggers-commands>');
+        for (const flow of outgoingFlows) {
+            const cmd = model.commands.get(flow.targetId);
+            console.log(`    <command name="${escapeXml(cmd?.name ?? flow.targetId)}"/>`);
+        }
+        console.log('  </triggers-commands>');
+    }
+    console.log('</screen>');
+}

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

@@ -75,10 +75,12 @@ function updateCommandField(model, filePath, commandName, fieldName, updates) {
     const updatedField = createUpdatedField(field, updates);
     appendEvent(filePath, {
         type: 'CommandFieldAdjusted',
-        commandStickyId: command.id,
-        fieldId: field.id,
-        field: updatedField,
-        timestamp: Date.now(),
+        data: {
+            commandStickyId: command.id,
+            fieldId: field.id,
+            field: updatedField,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Updated field "${field.name}" on command "${command.name}"`);
     logUpdates(updates);
@@ -100,10 +102,12 @@ function updateEventField(model, filePath, eventName, fieldName, updates) {
     const updatedField = createUpdatedField(field, updates);
     appendEvent(filePath, {
         type: 'EventFieldAdjusted',
-        eventStickyId: event.id,
-        fieldId: field.id,
-        field: updatedField,
-        timestamp: Date.now(),
+        data: {
+            eventStickyId: event.id,
+            fieldId: field.id,
+            field: updatedField,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Updated field "${field.name}" on event "${event.name}"`);
     logUpdates(updates);
@@ -125,10 +129,12 @@ function updateReadModelField(model, filePath, readModelName, fieldName, updates
     const updatedField = createUpdatedField(field, updates);
     appendEvent(filePath, {
         type: 'ReadModelFieldAdjusted',
-        readModelStickyId: readModel.id,
-        fieldId: field.id,
-        field: updatedField,
-        timestamp: Date.now(),
+        data: {
+            readModelStickyId: readModel.id,
+            fieldId: field.id,
+            field: updatedField,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Updated field "${field.name}" on read model "${readModel.name}"`);
     logUpdates(updates);
@@ -150,10 +156,12 @@ function updateScreenField(model, filePath, screenName, fieldName, updates) {
     const updatedField = createUpdatedField(field, updates);
     appendEvent(filePath, {
         type: 'ScreenFieldAdjusted',
-        screenId: screen.id,
-        fieldId: field.id,
-        field: updatedField,
-        timestamp: Date.now(),
+        data: {
+            screenId: screen.id,
+            fieldId: field.id,
+            field: updatedField,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Updated field "${field.name}" on screen "${screen.name}"`);
     logUpdates(updates);
@@ -174,10 +182,12 @@ function updateProcessorField(model, filePath, processorName, fieldName, updates
     const updatedField = createUpdatedField(field, updates);
     appendEvent(filePath, {
         type: 'ProcessorFieldAdjusted',
-        processorId: processor.id,
-        fieldId: field.id,
-        field: updatedField,
-        timestamp: Date.now(),
+        data: {
+            processorId: processor.id,
+            fieldId: field.id,
+            field: updatedField,
+            timestamp: Date.now(),
+        },
     });
     console.log(`Updated field "${field.name}" on processor "${processor.name}"`);
     logUpdates(updates);

package/dist/slices/whoami/index.d.ts

@@ -0,0 +1,2 @@
+import type { OutputFormat } from '../../lib/format.js';
+export declare function whoami(format: OutputFormat): void;

package/dist/slices/whoami/index.js

@@ -0,0 +1,35 @@
+import { isAuthenticated, getAuthTokens, getBackendUrl, getKeycloakUrl } from '../../lib/config.js';
+import { outputJson, escapeXml } from '../../lib/format.js';
+export function whoami(format) {
+    const tokens = getAuthTokens();
+    const backendUrl = getBackendUrl();
+    const keycloakUrl = getKeycloakUrl();
+    if (!tokens) {
+        if (format === 'json') {
+            outputJson({ authenticated: false, backendUrl, keycloakUrl });
+        }
+        else {
+            console.log(`<auth authenticated="false" backendUrl="${escapeXml(backendUrl)}" keycloakUrl="${escapeXml(keycloakUrl)}"/>`);
+        }
+        return;
+    }
+    const isValid = isAuthenticated();
+    if (format === 'json') {
+        outputJson({
+            authenticated: isValid,
+            email: tokens.email,
+            userId: tokens.userId,
+            backendUrl,
+            keycloakUrl,
+            expiresAt: new Date(tokens.expiresAt).toISOString(),
+        });
+    }
+    else {
+        if (isValid) {
+            console.log(`<auth authenticated="true" email="${escapeXml(tokens.email)}" backendUrl="${escapeXml(backendUrl)}"/>`);
+        }
+        else {
+            console.log(`<auth authenticated="false" email="${escapeXml(tokens.email)}" backendUrl="${escapeXml(backendUrl)}" reason="token_expired"/>`);
+        }
+    }
+}

package/dist/types.d.ts

@@ -191,6 +191,5 @@ export interface EventModel {
 }
 export interface RawEvent {
     type: string;
-    timestamp: number;
-    [key: string]: unknown;
+    data: Record<string, unknown>;
 }

package/package.json

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