eventmodeler 0.4.0 → 0.4.2

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.4.0",
+  "version": "0.4.2",
   "description": "CLI tool for interacting with Event Model files - query, update, and export event models from the terminal",
   "type": "module",
   "bin": {