eventmodeler 0.5.0 → 0.6.1

package/dist/formatters.d.ts

@@ -1,17 +0,0 @@
-import type { EventModel, Slice, CommandSticky, EventSticky, ReadModelSticky, Screen, Processor, Scenario, Flow } from './types.js';
-export declare function getSliceComponents(model: EventModel, slice: Slice): {
-    commands: CommandSticky[];
-    events: EventSticky[];
-    readModels: ReadModelSticky[];
-    screens: Screen[];
-    processors: Processor[];
-};
-export declare function getSliceScenarios(model: EventModel, sliceId: string): Scenario[];
-export declare function getRelevantFlows(model: EventModel, componentIds: Set<string>): Flow[];
-export declare function formatSliceXml(model: EventModel, slice: Slice): string;
-export declare function formatSlicesTable(slices: Slice[]): string;
-export declare function formatEventsTable(events: EventSticky[]): string;
-export declare function formatCommandsTable(commands: CommandSticky[]): string;
-export declare function formatModelSummary(model: EventModel): string;
-export declare function formatEventXml(model: EventModel, event: EventSticky): string;
-export declare function formatCommandXml(model: EventModel, command: CommandSticky): string;

package/dist/formatters.js

@@ -1,482 +0,0 @@
-// Helper to escape XML special characters
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-// Helper to format field values for display
-function formatFieldValues(values) {
-    if (!values || Object.keys(values).length === 0)
-        return '';
-    return Object.entries(values)
-        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-        .join(', ');
-}
-// Format a single field as XML
-function formatFieldXml(field, indent, sourceInfo) {
-    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 (sourceInfo)
-        attrs.push(`source="${escapeXml(sourceInfo)}"`);
-    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`;
-}
-// Get all components that belong to a slice (by position intersection)
-export function getSliceComponents(model, slice) {
-    const sliceBounds = {
-        left: slice.position.x,
-        right: slice.position.x + slice.size.width,
-        top: slice.position.y,
-        bottom: slice.position.y + slice.size.height,
-    };
-    function isInSlice(pos, width, height) {
-        const centerX = pos.x + width / 2;
-        const centerY = pos.y + height / 2;
-        return (centerX >= sliceBounds.left &&
-            centerX <= sliceBounds.right &&
-            centerY >= sliceBounds.top &&
-            centerY <= sliceBounds.bottom);
-    }
-    const commands = [];
-    const events = [];
-    const readModels = [];
-    const screens = [];
-    const processors = [];
-    for (const cmd of model.commands.values()) {
-        if (isInSlice(cmd.position, cmd.width, cmd.height)) {
-            commands.push(cmd);
-        }
-    }
-    for (const evt of model.events.values()) {
-        if (isInSlice(evt.position, evt.width, evt.height)) {
-            events.push(evt);
-        }
-    }
-    for (const rm of model.readModels.values()) {
-        if (isInSlice(rm.position, rm.width, rm.height)) {
-            readModels.push(rm);
-        }
-    }
-    for (const scr of model.screens.values()) {
-        if (isInSlice(scr.position, scr.width, scr.height)) {
-            screens.push(scr);
-        }
-    }
-    for (const proc of model.processors.values()) {
-        if (isInSlice(proc.position, proc.width, proc.height)) {
-            processors.push(proc);
-        }
-    }
-    return { commands, events, readModels, screens, processors };
-}
-// Get scenarios for a slice
-export function getSliceScenarios(model, sliceId) {
-    const scenarios = [];
-    for (const scenario of model.scenarios.values()) {
-        if (scenario.sliceId === sliceId) {
-            scenarios.push(scenario);
-        }
-    }
-    return scenarios;
-}
-// Get flows relevant to a set of components
-export function getRelevantFlows(model, componentIds) {
-    const flows = [];
-    for (const flow of model.flows.values()) {
-        if (componentIds.has(flow.sourceId) || componentIds.has(flow.targetId)) {
-            flows.push(flow);
-        }
-    }
-    return flows;
-}
-// Build information flow chains for a slice
-function buildInformationFlows(model, components, flows) {
-    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));
-    // Build adjacency for flows within the slice
-    const internalFlows = flows.filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId));
-    // Get component name by ID
-    function getName(id) {
-        const cmd = model.commands.get(id);
-        if (cmd)
-            return cmd.name;
-        const evt = model.events.get(id);
-        if (evt)
-            return evt.name;
-        const rm = model.readModels.get(id);
-        if (rm)
-            return rm.name;
-        const scr = model.screens.get(id);
-        if (scr)
-            return scr.name;
-        const proc = model.processors.get(id);
-        if (proc)
-            return proc.name;
-        return id;
-    }
-    // Simple representation of flows
-    const flowStrings = [];
-    for (const flow of internalFlows) {
-        flowStrings.push(`${getName(flow.sourceId)} → ${getName(flow.targetId)}`);
-    }
-    return flowStrings;
-}
-// Format a slice as XML
-export function formatSliceXml(model, slice) {
-    const components = getSliceComponents(model, slice);
-    const scenarios = getSliceScenarios(model, 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 = getRelevantFlows(model, componentIds);
-    const infoFlows = buildInformationFlows(model, components, flows);
-    let xml = `<slice name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
-    // Components section
-    xml += '  <components>\n';
-    // Screens
-    for (const screen of components.screens) {
-        xml += `    <screen name="${escapeXml(screen.name)}">\n`;
-        if (screen.fields.length > 0) {
-            xml += '      <fields>\n';
-            for (const field of screen.fields) {
-                const sourceInfo = field.isUserInput ? 'user-input' : undefined;
-                xml += formatFieldXml(field, '        ', sourceInfo);
-            }
-            xml += '      </fields>\n';
-        }
-        xml += '    </screen>\n';
-    }
-    // Commands
-    for (const command of components.commands) {
-        xml += `    <command name="${escapeXml(command.name)}">\n`;
-        if (command.fields.length > 0) {
-            xml += '      <fields>\n';
-            for (const field of command.fields) {
-                // Try to find source from incoming flows
-                const incomingFlow = flows.find(f => f.targetId === command.id);
-                let sourceInfo;
-                if (incomingFlow) {
-                    const sourceScreen = model.screens.get(incomingFlow.sourceId);
-                    const sourceProcessor = model.processors.get(incomingFlow.sourceId);
-                    if (sourceScreen) {
-                        const sourceField = sourceScreen.fields.find(f => f.name === field.name);
-                        if (sourceField) {
-                            sourceInfo = `${sourceScreen.name}.${field.name}`;
-                        }
-                    }
-                    else if (sourceProcessor) {
-                        const sourceField = sourceProcessor.fields.find(f => f.name === field.name);
-                        if (sourceField) {
-                            sourceInfo = `${sourceProcessor.name}.${field.name}`;
-                        }
-                    }
-                }
-                xml += formatFieldXml(field, '        ', sourceInfo);
-            }
-            xml += '      </fields>\n';
-        }
-        xml += '    </command>\n';
-    }
-    // Events
-    for (const event of components.events) {
-        xml += `    <event name="${escapeXml(event.name)}">\n`;
-        if (event.fields.length > 0) {
-            xml += '      <fields>\n';
-            for (const field of event.fields) {
-                // Try to find source from incoming flows
-                const incomingFlow = flows.find(f => f.targetId === event.id);
-                let sourceInfo;
-                if (field.isGenerated) {
-                    sourceInfo = 'generated';
-                }
-                else if (incomingFlow) {
-                    const sourceCommand = model.commands.get(incomingFlow.sourceId);
-                    if (sourceCommand) {
-                        const sourceField = sourceCommand.fields.find(f => f.name === field.name);
-                        if (sourceField) {
-                            sourceInfo = `${sourceCommand.name}.${field.name}`;
-                        }
-                    }
-                }
-                xml += formatFieldXml(field, '        ', sourceInfo);
-            }
-            xml += '      </fields>\n';
-        }
-        xml += '    </event>\n';
-    }
-    // Read Models
-    for (const readModel of components.readModels) {
-        xml += `    <read-model name="${escapeXml(readModel.name)}">\n`;
-        if (readModel.fields.length > 0) {
-            xml += '      <fields>\n';
-            for (const field of readModel.fields) {
-                xml += formatFieldXml(field, '        ');
-            }
-            xml += '      </fields>\n';
-        }
-        xml += '    </read-model>\n';
-    }
-    // Processors
-    for (const processor of components.processors) {
-        xml += `    <processor name="${escapeXml(processor.name)}">\n`;
-        if (processor.fields.length > 0) {
-            xml += '      <fields>\n';
-            for (const field of processor.fields) {
-                xml += formatFieldXml(field, '        ');
-            }
-            xml += '      </fields>\n';
-        }
-        xml += '    </processor>\n';
-    }
-    xml += '  </components>\n';
-    // Information flow section
-    if (infoFlows.length > 0) {
-        xml += '  <information-flow>\n';
-        for (const flow of infoFlows) {
-            xml += `    ${escapeXml(flow)}\n`;
-        }
-        xml += '  </information-flow>\n';
-    }
-    // Scenarios section
-    if (scenarios.length > 0) {
-        xml += '  <scenarios>\n';
-        for (const scenario of scenarios) {
-            xml += `    <scenario name="${escapeXml(scenario.name)}">\n`;
-            if (scenario.description) {
-                xml += `      <description>${escapeXml(scenario.description)}</description>\n`;
-            }
-            // Given events
-            if (scenario.givenEvents.length > 0) {
-                xml += '      <given>\n';
-                for (const givenEvent of scenario.givenEvents) {
-                    const evt = model.events.get(givenEvent.eventStickyId);
-                    const evtName = evt?.name ?? 'UnknownEvent';
-                    const fieldValuesStr = formatFieldValues(givenEvent.fieldValues);
-                    if (fieldValuesStr) {
-                        xml += `        <event type="${escapeXml(evtName)}">${escapeXml(fieldValuesStr)}</event>\n`;
-                    }
-                    else {
-                        xml += `        <event type="${escapeXml(evtName)}"/>\n`;
-                    }
-                }
-                xml += '      </given>\n';
-            }
-            // When command
-            if (scenario.whenCommand) {
-                const cmd = model.commands.get(scenario.whenCommand.commandStickyId);
-                const cmdName = cmd?.name ?? 'UnknownCommand';
-                const fieldValuesStr = formatFieldValues(scenario.whenCommand.fieldValues);
-                if (fieldValuesStr) {
-                    xml += `      <when>\n        <command type="${escapeXml(cmdName)}">${escapeXml(fieldValuesStr)}</command>\n      </when>\n`;
-                }
-                else {
-                    xml += `      <when>\n        <command type="${escapeXml(cmdName)}"/>\n      </when>\n`;
-                }
-            }
-            // Then
-            xml += '      <then>\n';
-            if (scenario.then.type === 'error') {
-                xml += `        <error`;
-                if (scenario.then.errorType) {
-                    xml += ` type="${escapeXml(scenario.then.errorType)}"`;
-                }
-                xml += `>${escapeXml(scenario.then.errorMessage ?? '')}</error>\n`;
-            }
-            else if (scenario.then.type === 'events' && scenario.then.expectedEvents) {
-                for (const expectedEvent of scenario.then.expectedEvents) {
-                    const evt = model.events.get(expectedEvent.eventStickyId);
-                    const evtName = evt?.name ?? 'UnknownEvent';
-                    const fieldValuesStr = formatFieldValues(expectedEvent.fieldValues);
-                    if (fieldValuesStr) {
-                        xml += `        <event type="${escapeXml(evtName)}">${escapeXml(fieldValuesStr)}</event>\n`;
-                    }
-                    else {
-                        xml += `        <event type="${escapeXml(evtName)}"/>\n`;
-                    }
-                }
-            }
-            else if (scenario.then.type === 'readModelAssertion' && scenario.then.readModelAssertion) {
-                const assertion = scenario.then.readModelAssertion;
-                const rm = model.readModels.get(assertion.readModelStickyId);
-                const rmName = rm?.name ?? 'UnknownReadModel';
-                xml += `        <read-model-assertion type="${escapeXml(rmName)}">\n`;
-                xml += `          <expected>${escapeXml(formatFieldValues(assertion.expectedFieldValues))}</expected>\n`;
-                xml += '        </read-model-assertion>\n';
-            }
-            xml += '      </then>\n';
-            xml += '    </scenario>\n';
-        }
-        xml += '  </scenarios>\n';
-    }
-    xml += '</slice>';
-    return xml;
-}
-// Format slices list as table
-export function formatSlicesTable(slices) {
-    if (slices.length === 0) {
-        return 'No slices found.';
-    }
-    // Sort by position (left to right)
-    const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
-    // Calculate column widths
-    const nameWidth = Math.max(4, ...sorted.map(s => s.name.length));
-    const statusWidth = 11; // 'in-progress' is longest
-    let output = '';
-    output += `${'NAME'.padEnd(nameWidth)}  ${'STATUS'.padEnd(statusWidth)}\n`;
-    output += `${'-'.repeat(nameWidth)}  ${'-'.repeat(statusWidth)}\n`;
-    for (const slice of sorted) {
-        const statusDisplay = slice.status === 'in-progress' ? 'in-progress' : slice.status;
-        output += `${slice.name.padEnd(nameWidth)}  ${statusDisplay.padEnd(statusWidth)}\n`;
-    }
-    return output;
-}
-// Format events list as table
-export function formatEventsTable(events) {
-    if (events.length === 0) {
-        return 'No events found.';
-    }
-    const sorted = [...events].sort((a, b) => a.name.localeCompare(b.name));
-    const nameWidth = Math.max(4, ...sorted.map(e => e.name.length));
-    const fieldsWidth = 6;
-    let output = '';
-    output += `${'NAME'.padEnd(nameWidth)}  ${'FIELDS'.padEnd(fieldsWidth)}\n`;
-    output += `${'-'.repeat(nameWidth)}  ${'-'.repeat(fieldsWidth)}\n`;
-    for (const evt of sorted) {
-        output += `${evt.name.padEnd(nameWidth)}  ${String(evt.fields.length).padEnd(fieldsWidth)}\n`;
-    }
-    return output;
-}
-// Format commands list as table
-export function formatCommandsTable(commands) {
-    if (commands.length === 0) {
-        return 'No commands found.';
-    }
-    const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
-    const nameWidth = Math.max(4, ...sorted.map(c => c.name.length));
-    const fieldsWidth = 6;
-    let output = '';
-    output += `${'NAME'.padEnd(nameWidth)}  ${'FIELDS'.padEnd(fieldsWidth)}\n`;
-    output += `${'-'.repeat(nameWidth)}  ${'-'.repeat(fieldsWidth)}\n`;
-    for (const cmd of sorted) {
-        output += `${cmd.name.padEnd(nameWidth)}  ${String(cmd.fields.length).padEnd(fieldsWidth)}\n`;
-    }
-    return output;
-}
-// Format model summary
-export function formatModelSummary(model) {
-    let output = `Event Model: ${model.name}\n`;
-    output += `${'='.repeat(model.name.length + 13)}\n\n`;
-    output += `Slices:      ${model.slices.size}\n`;
-    output += `Commands:    ${model.commands.size}\n`;
-    output += `Events:      ${model.events.size}\n`;
-    output += `Read Models: ${model.readModels.size}\n`;
-    output += `Screens:     ${model.screens.size}\n`;
-    output += `Processors:  ${model.processors.size}\n`;
-    output += `Scenarios:   ${model.scenarios.size}\n`;
-    output += `Flows:       ${model.flows.size}\n`;
-    return output;
-}
-// Format entity details as XML
-export function formatEventXml(model, event) {
-    let xml = `<event name="${escapeXml(event.name)}">\n`;
-    if (event.fields.length > 0) {
-        xml += '  <fields>\n';
-        for (const field of event.fields) {
-            xml += formatFieldXml(field, '    ');
-        }
-        xml += '  </fields>\n';
-    }
-    // Find incoming flows (what produces this event)
-    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === event.id);
-    // Find outgoing flows (what consumes this event)
-    const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === event.id);
-    if (incomingFlows.length > 0) {
-        xml += '  <produced-by>\n';
-        for (const flow of incomingFlows) {
-            const source = model.commands.get(flow.sourceId);
-            if (source) {
-                xml += `    <command name="${escapeXml(source.name)}"/>\n`;
-            }
-        }
-        xml += '  </produced-by>\n';
-    }
-    if (outgoingFlows.length > 0) {
-        xml += '  <consumed-by>\n';
-        for (const flow of outgoingFlows) {
-            const target = model.readModels.get(flow.targetId);
-            if (target) {
-                xml += `    <read-model name="${escapeXml(target.name)}"/>\n`;
-            }
-        }
-        xml += '  </consumed-by>\n';
-    }
-    xml += '</event>';
-    return xml;
-}
-export function formatCommandXml(model, command) {
-    let xml = `<command name="${escapeXml(command.name)}">\n`;
-    if (command.fields.length > 0) {
-        xml += '  <fields>\n';
-        for (const field of command.fields) {
-            xml += formatFieldXml(field, '    ');
-        }
-        xml += '  </fields>\n';
-    }
-    // Find incoming flows (what triggers this command)
-    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === command.id);
-    // Find outgoing flows (what events this command produces)
-    const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === command.id);
-    if (incomingFlows.length > 0) {
-        xml += '  <triggered-by>\n';
-        for (const flow of incomingFlows) {
-            const sourceScreen = model.screens.get(flow.sourceId);
-            const sourceProcessor = model.processors.get(flow.sourceId);
-            if (sourceScreen) {
-                xml += `    <screen name="${escapeXml(sourceScreen.name)}"/>\n`;
-            }
-            else if (sourceProcessor) {
-                xml += `    <processor name="${escapeXml(sourceProcessor.name)}"/>\n`;
-            }
-        }
-        xml += '  </triggered-by>\n';
-    }
-    if (outgoingFlows.length > 0) {
-        xml += '  <produces>\n';
-        for (const flow of outgoingFlows) {
-            const target = model.events.get(flow.targetId);
-            if (target) {
-                xml += `    <event name="${escapeXml(target.name)}"/>\n`;
-            }
-        }
-        xml += '  </produces>\n';
-    }
-    xml += '</command>';
-    return xml;
-}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/lib/auth.d.ts

@@ -1,24 +0,0 @@
-import { type AuthTokens } from './config.js';
-interface AuthResult {
-    success: boolean;
-    tokens?: AuthTokens;
-    error?: string;
-}
-/**
- * Starts the OAuth flow using Keycloak PKCE.
- * Opens browser and waits for the callback.
- */
-export declare function startAuthFlow(): Promise<AuthResult>;
-/**
- * Refresh the access token using the refresh token.
- */
-export declare function refreshAccessToken(): Promise<AuthResult>;
-/**
- * Get a valid access token, refreshing if needed.
- */
-export declare function getValidAccessToken(): Promise<string | null>;
-/**
- * Log out by clearing stored tokens.
- */
-export declare function logout(): void;
-export {};