eventmodeler 0.1.0

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

@@ -0,0 +1,43 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function getSlicesUnderChapter(model, chapter) {
+    // A slice is "under" a chapter if its horizontal center falls within the chapter's x range
+    const chapterLeft = chapter.position.x;
+    const chapterRight = chapter.position.x + chapter.size.width;
+    return [...model.slices.values()].filter(slice => {
+        const sliceCenterX = slice.position.x + slice.size.width / 2;
+        return sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight;
+    }).sort((a, b) => a.position.x - b.position.x);
+}
+export function showChapter(model, name) {
+    const chapters = [...model.chapters.values()];
+    const nameLower = name.toLowerCase();
+    const chapter = chapters.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
+    if (!chapter) {
+        console.error(`Error: Chapter not found: ${name}`);
+        console.error('Available chapters:');
+        for (const c of chapters) {
+            console.error(`  - ${c.name}`);
+        }
+        process.exit(1);
+    }
+    const slices = getSlicesUnderChapter(model, chapter);
+    console.log(`<chapter name="${escapeXml(chapter.name)}">`);
+    if (slices.length === 0) {
+        console.log('  <slices/>');
+    }
+    else {
+        console.log('  <slices>');
+        for (const slice of slices) {
+            console.log(`    <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
+        }
+        console.log('  </slices>');
+    }
+    console.log('</chapter>');
+}

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

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

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

@@ -0,0 +1,78 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+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.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 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';
+    }
+    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === command.id);
+    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 screen = model.screens.get(flow.sourceId);
+            const processor = model.processors.get(flow.sourceId);
+            if (screen)
+                xml += `    <screen name="${escapeXml(screen.name)}"/>\n`;
+            if (processor)
+                xml += `    <processor name="${escapeXml(processor.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;
+}
+export function showCommand(model, name) {
+    const commands = [...model.commands.values()];
+    const nameLower = name.toLowerCase();
+    const command = commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
+    if (!command) {
+        console.error(`Error: Command not found: ${name}`);
+        console.error('Available commands:');
+        for (const c of commands) {
+            console.error(`  - ${c.name}`);
+        }
+        process.exit(1);
+    }
+    console.log(formatCommandXml(model, command));
+}

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

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

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

@@ -0,0 +1,75 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+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.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 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';
+    }
+    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === event.id);
+    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 showEvent(model, name) {
+    const events = [...model.events.values()];
+    const nameLower = name.toLowerCase();
+    const event = events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
+    if (!event) {
+        console.error(`Error: Event not found: ${name}`);
+        console.error('Available events:');
+        for (const e of events) {
+            console.error(`  - ${e.name}`);
+        }
+        process.exit(1);
+    }
+    console.log(formatEventXml(model, event));
+}

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

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

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

@@ -0,0 +1,20 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+export function showModelSummary(model) {
+    console.log(`<model name="${escapeXml(model.name)}">`);
+    console.log(`  <slices count="${model.slices.size}"/>`);
+    console.log(`  <commands count="${model.commands.size}"/>`);
+    console.log(`  <events count="${model.events.size}"/>`);
+    console.log(`  <read-models count="${model.readModels.size}"/>`);
+    console.log(`  <screens count="${model.screens.size}"/>`);
+    console.log(`  <processors count="${model.processors.size}"/>`);
+    console.log(`  <scenarios count="${model.scenarios.size}"/>`);
+    console.log(`  <flows count="${model.flows.size}"/>`);
+    console.log('</model>');
+}

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

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

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

@@ -0,0 +1,239 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function formatFieldValues(values) {
+    if (!values || Object.keys(values).length === 0)
+        return '';
+    return Object.entries(values)
+        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+        .join(', ');
+}
+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`;
+}
+function getSliceComponents(model, slice) {
+    const bounds = {
+        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 >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
+    }
+    return {
+        commands: [...model.commands.values()].filter(c => isInSlice(c.position, c.width, c.height)),
+        events: [...model.events.values()].filter(e => isInSlice(e.position, e.width, e.height)),
+        readModels: [...model.readModels.values()].filter(rm => isInSlice(rm.position, rm.width, rm.height)),
+        screens: [...model.screens.values()].filter(s => isInSlice(s.position, s.width, s.height)),
+        processors: [...model.processors.values()].filter(p => isInSlice(p.position, p.width, p.height)),
+    };
+}
+function formatSliceXml(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);
+    }
+    let xml = `<slice name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
+    xml += '  <components>\n';
+    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) {
+                xml += formatFieldXml(field, '        ', field.isUserInput ? 'user-input' : undefined);
+            }
+            xml += '      </fields>\n';
+        }
+        xml += '    </screen>\n';
+    }
+    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) {
+                const incomingFlow = flows.find(f => f.targetId === command.id);
+                let sourceInfo;
+                if (incomingFlow) {
+                    const source = model.screens.get(incomingFlow.sourceId) ?? model.processors.get(incomingFlow.sourceId);
+                    if (source?.fields.some(f => f.name === field.name)) {
+                        sourceInfo = `${source.name}.${field.name}`;
+                    }
+                }
+                xml += formatFieldXml(field, '        ', sourceInfo);
+            }
+            xml += '      </fields>\n';
+        }
+        xml += '    </command>\n';
+    }
+    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) {
+                const incomingFlow = flows.find(f => f.targetId === event.id);
+                let sourceInfo;
+                if (field.isGenerated) {
+                    sourceInfo = 'generated';
+                }
+                else if (incomingFlow) {
+                    const source = model.commands.get(incomingFlow.sourceId);
+                    if (source?.fields.some(f => f.name === field.name)) {
+                        sourceInfo = `${source.name}.${field.name}`;
+                    }
+                }
+                xml += formatFieldXml(field, '        ', sourceInfo);
+            }
+            xml += '      </fields>\n';
+        }
+        xml += '    </event>\n';
+    }
+    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';
+    }
+    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';
+    if (internalFlows.length > 0) {
+        xml += '  <information-flow>\n';
+        for (const flow of internalFlows) {
+            xml += `    ${escapeXml(getName(flow.sourceId))} → ${escapeXml(getName(flow.targetId))}\n`;
+        }
+        xml += '  </information-flow>\n';
+    }
+    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`;
+            }
+            if (scenario.givenEvents.length > 0) {
+                xml += '      <given>\n';
+                for (const given of scenario.givenEvents) {
+                    const evt = model.events.get(given.eventStickyId);
+                    const name = evt?.name ?? 'UnknownEvent';
+                    const values = formatFieldValues(given.fieldValues);
+                    xml += values
+                        ? `        <event type="${escapeXml(name)}">${escapeXml(values)}</event>\n`
+                        : `        <event type="${escapeXml(name)}"/>\n`;
+                }
+                xml += '      </given>\n';
+            }
+            if (scenario.whenCommand) {
+                const cmd = model.commands.get(scenario.whenCommand.commandStickyId);
+                const name = cmd?.name ?? 'UnknownCommand';
+                const values = formatFieldValues(scenario.whenCommand.fieldValues);
+                xml += '      <when>\n';
+                xml += values
+                    ? `        <command type="${escapeXml(name)}">${escapeXml(values)}</command>\n`
+                    : `        <command type="${escapeXml(name)}"/>\n`;
+                xml += '      </when>\n';
+            }
+            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 expected of scenario.then.expectedEvents) {
+                    const evt = model.events.get(expected.eventStickyId);
+                    const name = evt?.name ?? 'UnknownEvent';
+                    const values = formatFieldValues(expected.fieldValues);
+                    xml += values
+                        ? `        <event type="${escapeXml(name)}">${escapeXml(values)}</event>\n`
+                        : `        <event type="${escapeXml(name)}"/>\n`;
+                }
+            }
+            else if (scenario.then.type === 'readModelAssertion' && scenario.then.readModelAssertion) {
+                const assertion = scenario.then.readModelAssertion;
+                const rm = model.readModels.get(assertion.readModelStickyId);
+                const name = rm?.name ?? 'UnknownReadModel';
+                xml += `        <read-model-assertion type="${escapeXml(name)}">\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;
+}
+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}`);
+        }
+        process.exit(1);
+    }
+    console.log(formatSliceXml(model, slice));
+}

package/dist/types.d.ts

@@ -0,0 +1,161 @@
+export interface Field {
+    id: string;
+    name: string;
+    fieldType: 'UUID' | 'Boolean' | 'Double' | 'Decimal' | 'Date' | 'DateTime' | 'Long' | 'Int' | 'String' | 'Custom';
+    isList: boolean;
+    isGenerated: boolean;
+    isOptional?: boolean;
+    isUserInput?: boolean;
+    subfields?: Field[];
+}
+export type SliceStatus = 'created' | 'in-progress' | 'blocked' | 'done';
+export interface EventReference {
+    eventStickyId: string;
+    fieldValues?: Record<string, unknown>;
+}
+export interface CommandReference {
+    commandStickyId: string;
+    fieldValues?: Record<string, unknown>;
+}
+export interface ReadModelAssertion {
+    readModelStickyId: string;
+    givenEvents: EventReference[];
+    expectedFieldValues: Record<string, unknown>;
+}
+export type ScenarioThenType = 'error' | 'events' | 'readModelAssertion';
+export interface ScenarioThen {
+    type: ScenarioThenType;
+    errorMessage?: string;
+    errorType?: string;
+    expectedEvents?: EventReference[];
+    readModelAssertion?: ReadModelAssertion;
+}
+export interface FieldMapping {
+    sourceFieldId: string;
+    targetFieldId: string;
+}
+export interface CommandSticky {
+    id: string;
+    name: string;
+    fields: Field[];
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+}
+export interface EventSticky {
+    id: string;
+    name: string;
+    fields: Field[];
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    canonicalId?: string;
+}
+export interface ReadModelSticky {
+    id: string;
+    name: string;
+    fields: Field[];
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    canonicalId?: string;
+}
+export interface Screen {
+    id: string;
+    name: string;
+    fields: Field[];
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    canonicalId?: string;
+}
+export interface Processor {
+    id: string;
+    name: string;
+    fields: Field[];
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+}
+export interface Slice {
+    id: string;
+    name: string;
+    status: SliceStatus;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    nodeIds: string[];
+}
+export interface Chapter {
+    id: string;
+    name: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+}
+export interface Scenario {
+    id: string;
+    sliceId: string;
+    name: string;
+    description: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    givenEvents: EventReference[];
+    whenCommand: CommandReference | null;
+    then: ScenarioThen;
+}
+export type FlowType = 'CommandToEvent' | 'EventToReadModel' | 'ReadModelToScreen' | 'ReadModelToProcessor' | 'ScreenToCommand' | 'ProcessorToCommand';
+export interface Flow {
+    id: string;
+    flowType: FlowType;
+    sourceId: string;
+    targetId: string;
+    fieldMappings: FieldMapping[];
+}
+export interface EventModel {
+    modelId: string;
+    name: string;
+    commands: Map<string, CommandSticky>;
+    events: Map<string, EventSticky>;
+    readModels: Map<string, ReadModelSticky>;
+    screens: Map<string, Screen>;
+    processors: Map<string, Processor>;
+    slices: Map<string, Slice>;
+    chapters: Map<string, Chapter>;
+    scenarios: Map<string, Scenario>;
+    flows: Map<string, Flow>;
+}
+export interface RawEvent {
+    type: string;
+    timestamp: number;
+    [key: string]: unknown;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "eventmodeler",
+  "version": "0.1.0",
+  "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"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "event-modeling",
+    "event-sourcing",
+    "cqrs",
+    "ddd",
+    "domain-driven-design",
+    "cli",
+    "eventmodel"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/event-modeler"
+  },
+  "homepage": "https://www.eventmodeling.app",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.3"
+  }
+}