eventmodeler 0.5.0 → 0.6.1

package/dist/slices/diff/index.js

@@ -1,293 +0,0 @@
-import { execSync } from 'node:child_process';
-import * as fs from 'node:fs';
-import { loadModel, loadModelFromContent } from '../../lib/file-loader.js';
-import { diffModels } from '../../lib/diff/model-differ.js';
-import { escapeXml, outputJson } from '../../lib/format.js';
-function formatFieldChangeXml(change, indent) {
-    const typeAttr = change.changeType;
-    const pathAttr = escapeXml(change.fieldPath);
-    if (change.changeType === 'added') {
-        const fieldType = change.newValue?.fieldType ?? 'unknown';
-        return `${indent}<field-${typeAttr} path="${pathAttr}" type="${fieldType}"/>`;
-    }
-    else if (change.changeType === 'removed') {
-        const fieldType = change.oldValue?.fieldType ?? 'unknown';
-        return `${indent}<field-${typeAttr} path="${pathAttr}" type="${fieldType}"/>`;
-    }
-    else {
-        const oldType = change.oldValue?.fieldType ?? 'unknown';
-        const newType = change.newValue?.fieldType ?? 'unknown';
-        return `${indent}<field-${typeAttr} path="${pathAttr}" old-type="${oldType}" new-type="${newType}"/>`;
-    }
-}
-function formatEntityChangeXml(change) {
-    const lines = [];
-    const typeAttr = escapeXml(change.entityType);
-    const nameAttr = escapeXml(change.entityName);
-    const idAttr = escapeXml(change.entityId);
-    if (change.changeType === 'added') {
-        lines.push(`    <added type="${typeAttr}" name="${nameAttr}" id="${idAttr}"/>`);
-    }
-    else if (change.changeType === 'removed') {
-        lines.push(`    <removed type="${typeAttr}" name="${nameAttr}" id="${idAttr}"/>`);
-    }
-    else {
-        const hasChanges = (change.propertyChanges && change.propertyChanges.length > 0) ||
-            (change.fieldChanges && change.fieldChanges.length > 0);
-        if (hasChanges) {
-            lines.push(`    <modified type="${typeAttr}" name="${nameAttr}" id="${idAttr}">`);
-            if (change.propertyChanges) {
-                for (const prop of change.propertyChanges) {
-                    const propName = escapeXml(prop.property);
-                    const oldVal = escapeXml(String(prop.oldValue ?? ''));
-                    const newVal = escapeXml(String(prop.newValue ?? ''));
-                    lines.push(`      <property-changed name="${propName}" old="${oldVal}" new="${newVal}"/>`);
-                }
-            }
-            if (change.fieldChanges) {
-                lines.push('      <field-changes>');
-                for (const fieldChange of change.fieldChanges) {
-                    lines.push(formatFieldChangeXml(fieldChange, '        '));
-                }
-                lines.push('      </field-changes>');
-            }
-            lines.push('    </modified>');
-        }
-        else {
-            lines.push(`    <modified type="${typeAttr}" name="${nameAttr}" id="${idAttr}"/>`);
-        }
-    }
-    return lines.join('\n');
-}
-function formatFlowChangeXml(change) {
-    const typeAttr = escapeXml(change.flowType);
-    const sourceAttr = escapeXml(change.sourceName ?? '');
-    const targetAttr = escapeXml(change.targetName ?? '');
-    if (change.changeType === 'added') {
-        return `    <flow-added type="${typeAttr}" source="${sourceAttr}" target="${targetAttr}"/>`;
-    }
-    else if (change.changeType === 'removed') {
-        return `    <flow-removed type="${typeAttr}" source="${sourceAttr}" target="${targetAttr}"/>`;
-    }
-    else {
-        const mappingCount = change.mappingChanges?.length ?? 0;
-        return `    <flow-modified type="${typeAttr}" source="${sourceAttr}" target="${targetAttr}" mapping-changes="${mappingCount}"/>`;
-    }
-}
-function formatDiffXml(result) {
-    const lines = [];
-    lines.push('<diff>');
-    lines.push(`  <summary added="${result.summary.added}" removed="${result.summary.removed}" modified="${result.summary.modified}"/>`);
-    if (result.entityChanges.length > 0) {
-        lines.push('  <entity-changes>');
-        for (const change of result.entityChanges) {
-            lines.push(formatEntityChangeXml(change));
-        }
-        lines.push('  </entity-changes>');
-    }
-    if (result.flowChanges.length > 0) {
-        lines.push('  <flow-changes>');
-        for (const change of result.flowChanges) {
-            lines.push(formatFlowChangeXml(change));
-        }
-        lines.push('  </flow-changes>');
-    }
-    lines.push('</diff>');
-    return lines.join('\n');
-}
-function formatDiffJson(result) {
-    return {
-        summary: result.summary,
-        entityChanges: result.entityChanges.map((c) => ({
-            type: c.entityType,
-            id: c.entityId,
-            name: c.entityName,
-            change: c.changeType,
-            propertyChanges: c.propertyChanges,
-            fieldChanges: c.fieldChanges?.map((f) => ({
-                path: f.fieldPath,
-                change: f.changeType,
-                oldType: f.oldValue?.fieldType,
-                newType: f.newValue?.fieldType,
-            })),
-        })),
-        flowChanges: result.flowChanges.map((c) => ({
-            id: c.flowId,
-            type: c.flowType,
-            change: c.changeType,
-            source: c.sourceName,
-            target: c.targetName,
-            mappingChanges: c.mappingChanges?.length,
-        })),
-    };
-}
-function formatEntityType(type) {
-    const typeNames = {
-        command: 'Command',
-        event: 'Event',
-        readModel: 'Read Model',
-        screen: 'Screen',
-        processor: 'Processor',
-        slice: 'Slice',
-        chapter: 'Chapter',
-        aggregate: 'Aggregate',
-        actor: 'Actor',
-        scenario: 'Scenario',
-        flow: 'Flow',
-    };
-    return typeNames[type] ?? type;
-}
-function formatDiffText(result) {
-    const lines = [];
-    const { added, removed, modified } = result.summary;
-    const total = added + removed + modified;
-    if (total === 0) {
-        return 'No changes detected.';
-    }
-    lines.push(`${total} change${total === 1 ? '' : 's'}: ${added} added, ${removed} removed, ${modified} modified\n`);
-    // Group changes by type
-    const addedChanges = result.entityChanges.filter((c) => c.changeType === 'added');
-    const removedChanges = result.entityChanges.filter((c) => c.changeType === 'removed');
-    const modifiedChanges = result.entityChanges.filter((c) => c.changeType === 'modified');
-    if (addedChanges.length > 0) {
-        lines.push('Added:');
-        for (const change of addedChanges) {
-            lines.push(`  + ${formatEntityType(change.entityType)} "${change.entityName}"`);
-        }
-        lines.push('');
-    }
-    if (removedChanges.length > 0) {
-        lines.push('Removed:');
-        for (const change of removedChanges) {
-            lines.push(`  - ${formatEntityType(change.entityType)} "${change.entityName}"`);
-        }
-        lines.push('');
-    }
-    if (modifiedChanges.length > 0) {
-        lines.push('Modified:');
-        for (const change of modifiedChanges) {
-            lines.push(`  ~ ${formatEntityType(change.entityType)} "${change.entityName}"`);
-            if (change.propertyChanges) {
-                for (const prop of change.propertyChanges) {
-                    if (prop.property === 'name') {
-                        lines.push(`      renamed from "${prop.oldValue}" to "${prop.newValue}"`);
-                    }
-                    else if (prop.property === 'status') {
-                        lines.push(`      status: ${prop.oldValue} -> ${prop.newValue}`);
-                    }
-                    else {
-                        lines.push(`      ${prop.property} changed`);
-                    }
-                }
-            }
-            if (change.fieldChanges) {
-                for (const field of change.fieldChanges) {
-                    if (field.changeType === 'added') {
-                        lines.push(`      + field "${field.fieldPath}" (${field.newValue?.fieldType})`);
-                    }
-                    else if (field.changeType === 'removed') {
-                        lines.push(`      - field "${field.fieldPath}"`);
-                    }
-                    else {
-                        lines.push(`      ~ field "${field.fieldPath}": ${field.oldValue?.fieldType} -> ${field.newValue?.fieldType}`);
-                    }
-                }
-            }
-        }
-        lines.push('');
-    }
-    // Flow changes
-    const addedFlows = result.flowChanges.filter((c) => c.changeType === 'added');
-    const removedFlows = result.flowChanges.filter((c) => c.changeType === 'removed');
-    const modifiedFlows = result.flowChanges.filter((c) => c.changeType === 'modified');
-    if (addedFlows.length > 0) {
-        lines.push('Flows Added:');
-        for (const flow of addedFlows) {
-            lines.push(`  + ${flow.sourceName} -> ${flow.targetName}`);
-        }
-        lines.push('');
-    }
-    if (removedFlows.length > 0) {
-        lines.push('Flows Removed:');
-        for (const flow of removedFlows) {
-            lines.push(`  - ${flow.sourceName} -> ${flow.targetName}`);
-        }
-        lines.push('');
-    }
-    if (modifiedFlows.length > 0) {
-        lines.push('Flows Modified:');
-        for (const flow of modifiedFlows) {
-            const mappingCount = flow.mappingChanges?.length ?? 0;
-            lines.push(`  ~ ${flow.sourceName} -> ${flow.targetName} (${mappingCount} mapping changes)`);
-        }
-        lines.push('');
-    }
-    return lines.join('\n').trim();
-}
-/**
- * Get file content from a git ref (e.g., HEAD, HEAD~1, branch name)
- */
-function getGitFileContent(filePath, ref) {
-    try {
-        // Get the relative path from the repo root
-        const repoRoot = execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
-        const absolutePath = fs.realpathSync(filePath);
-        const relativePath = absolutePath.replace(repoRoot + '/', '');
-        const content = execSync(`git show ${ref}:${relativePath}`, {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return content;
-    }
-    catch {
-        return null;
-    }
-}
-function outputDiff(result, format) {
-    if (format === 'json') {
-        outputJson(formatDiffJson(result));
-    }
-    else if (format === 'text') {
-        console.log(formatDiffText(result));
-    }
-    else {
-        console.log(formatDiffXml(result));
-    }
-}
-/**
- * Diff two eventmodel files or compare a file against a git ref.
- *
- * Usage:
- *   diff(file1, file2, format)           - Compare two files
- *   diff(file1, undefined, format, ref)  - Compare file against git ref (default: HEAD)
- */
-export function diff(basePath, comparePath, format, gitRef) {
-    // Single file mode: compare against git ref
-    if (!comparePath) {
-        const ref = gitRef ?? 'HEAD';
-        const gitContent = getGitFileContent(basePath, ref);
-        if (gitContent === null) {
-            console.error(`Error: Could not get ${basePath} from git ref '${ref}'`);
-            console.error('Make sure the file is tracked by git and the ref exists.');
-            process.exit(2);
-        }
-        const baseModel = loadModelFromContent(gitContent);
-        const compareModel = loadModel(basePath);
-        const result = diffModels(baseModel, compareModel);
-        outputDiff(result, format);
-        return;
-    }
-    // Two file mode: compare two files
-    if (!fs.existsSync(basePath)) {
-        console.error(`Error: File not found: ${basePath}`);
-        process.exit(2);
-    }
-    if (!fs.existsSync(comparePath)) {
-        console.error(`Error: File not found: ${comparePath}`);
-        process.exit(2);
-    }
-    const baseModel = loadModel(basePath);
-    const compareModel = loadModel(comparePath);
-    const result = diffModels(baseModel, compareModel);
-    outputDiff(result, format);
-}

package/dist/slices/export-eventmodel-to-json/index.d.ts

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

package/dist/slices/export-eventmodel-to-json/index.js

@@ -1,355 +0,0 @@
-function mapFieldType(fieldType) {
-    // Map our field types to spec field types
-    const typeMap = {
-        'UUID': 'UUID',
-        'Boolean': 'Boolean',
-        'Double': 'Double',
-        'Decimal': 'Decimal',
-        'Date': 'Date',
-        'DateTime': 'DateTime',
-        'Long': 'Long',
-        'Int': 'Int',
-        'String': 'String',
-        'Custom': 'Custom',
-    };
-    return typeMap[fieldType] || 'String';
-}
-function mapStatus(status) {
-    const statusMap = {
-        'created': 'Created',
-        'done': 'Done',
-        'in-progress': 'InProgress',
-        'blocked': 'InProgress', // No blocked in spec, map to InProgress
-    };
-    return statusMap[status];
-}
-function convertField(field) {
-    const specField = {
-        name: field.name,
-        type: mapFieldType(field.fieldType),
-    };
-    if (field.isOptional)
-        specField.optional = true;
-    if (field.isGenerated)
-        specField.generated = true;
-    if (field.subfields && field.subfields.length > 0) {
-        specField.subfields = field.subfields.map(convertField);
-    }
-    return specField;
-}
-function isInSlice(slice, pos, width, height) {
-    const centerX = pos.x + width / 2;
-    const centerY = pos.y + height / 2;
-    return (centerX >= slice.position.x &&
-        centerX <= slice.position.x + slice.size.width &&
-        centerY >= slice.position.y &&
-        centerY <= slice.position.y + slice.size.height);
-}
-function getInboundDependencies(model, entityId, entityType) {
-    const deps = [];
-    for (const flow of model.flows.values()) {
-        if (flow.targetId === entityId) {
-            let sourceTitle = '';
-            let sourceType = 'COMMAND';
-            const cmd = model.commands.get(flow.sourceId);
-            const evt = model.events.get(flow.sourceId);
-            const rm = model.readModels.get(flow.sourceId);
-            const scr = model.screens.get(flow.sourceId);
-            const proc = model.processors.get(flow.sourceId);
-            if (cmd) {
-                sourceTitle = cmd.name;
-                sourceType = 'COMMAND';
-            }
-            else if (evt) {
-                sourceTitle = evt.name;
-                sourceType = 'EVENT';
-            }
-            else if (rm) {
-                sourceTitle = rm.name;
-                sourceType = 'READMODEL';
-            }
-            else if (scr) {
-                sourceTitle = scr.name;
-                sourceType = 'SCREEN';
-            }
-            else if (proc) {
-                sourceTitle = proc.name;
-                sourceType = 'AUTOMATION';
-            }
-            if (sourceTitle) {
-                deps.push({
-                    id: flow.id,
-                    title: sourceTitle,
-                    type: 'INBOUND',
-                    elementType: sourceType,
-                });
-            }
-        }
-    }
-    return deps;
-}
-function getOutboundDependencies(model, entityId, entityType) {
-    const deps = [];
-    for (const flow of model.flows.values()) {
-        if (flow.sourceId === entityId) {
-            let targetTitle = '';
-            let targetType = 'EVENT';
-            const cmd = model.commands.get(flow.targetId);
-            const evt = model.events.get(flow.targetId);
-            const rm = model.readModels.get(flow.targetId);
-            const scr = model.screens.get(flow.targetId);
-            const proc = model.processors.get(flow.targetId);
-            if (cmd) {
-                targetTitle = cmd.name;
-                targetType = 'COMMAND';
-            }
-            else if (evt) {
-                targetTitle = evt.name;
-                targetType = 'EVENT';
-            }
-            else if (rm) {
-                targetTitle = rm.name;
-                targetType = 'READMODEL';
-            }
-            else if (scr) {
-                targetTitle = scr.name;
-                targetType = 'SCREEN';
-            }
-            else if (proc) {
-                targetTitle = proc.name;
-                targetType = 'AUTOMATION';
-            }
-            if (targetTitle) {
-                deps.push({
-                    id: flow.id,
-                    title: targetTitle,
-                    type: 'OUTBOUND',
-                    elementType: targetType,
-                });
-            }
-        }
-    }
-    return deps;
-}
-function determineSliceType(commands, events, processors) {
-    // If there are processors, it's an automation slice
-    if (processors.length > 0)
-        return 'AUTOMATION';
-    // If there are commands and events, it's a state change
-    if (commands.length > 0 && events.length > 0)
-        return 'STATE_CHANGE';
-    // Otherwise it's a state view (read-only)
-    return 'STATE_VIEW';
-}
-// Check if two rectangles overlap
-function rectanglesOverlap(r1, r2) {
-    return (r1.x < r2.x + r2.width &&
-        r1.x + r1.width > r2.x &&
-        r1.y < r2.y + r2.height &&
-        r1.y + r1.height > r2.y);
-}
-// Find aggregates that overlap with the slice
-function getAggregatesForSlice(model, slice) {
-    const sliceRect = {
-        x: slice.position.x,
-        y: slice.position.y,
-        width: slice.size.width,
-        height: slice.size.height,
-    };
-    const aggregateNames = [];
-    for (const aggregate of model.aggregates.values()) {
-        const aggRect = {
-            x: aggregate.position.x,
-            y: aggregate.position.y,
-            width: aggregate.size.width,
-            height: aggregate.size.height,
-        };
-        if (rectanglesOverlap(sliceRect, aggRect)) {
-            aggregateNames.push(aggregate.name);
-        }
-    }
-    return aggregateNames;
-}
-// Find actors that overlap with the slice
-function getActorsForSlice(model, slice) {
-    const sliceRect = {
-        x: slice.position.x,
-        y: slice.position.y,
-        width: slice.size.width,
-        height: slice.size.height,
-    };
-    const actors = [];
-    for (const actor of model.actors.values()) {
-        const actorRect = {
-            x: actor.position.x,
-            y: actor.position.y,
-            width: actor.size.width,
-            height: actor.size.height,
-        };
-        if (rectanglesOverlap(sliceRect, actorRect)) {
-            actors.push({
-                name: actor.name,
-                authRequired: false, // Default - we don't track this property yet
-            });
-        }
-    }
-    return actors;
-}
-export function exportEventmodelToJson(model) {
-    const specSlices = [];
-    // Sort slices by position
-    const sortedSlices = [...model.slices.values()].sort((a, b) => a.position.x - b.position.x);
-    for (const slice of sortedSlices) {
-        // Find components in this slice
-        const commands = [];
-        const events = [];
-        const readModels = [];
-        const screens = [];
-        const processors = [];
-        for (const cmd of model.commands.values()) {
-            if (isInSlice(slice, cmd.position, cmd.width, cmd.height)) {
-                commands.push(cmd);
-            }
-        }
-        // Filter out linked copies - only export originals
-        for (const evt of model.events.values()) {
-            if (!evt.originalNodeId && isInSlice(slice, evt.position, evt.width, evt.height)) {
-                events.push(evt);
-            }
-        }
-        // Filter out linked copies - only export originals
-        for (const rm of model.readModels.values()) {
-            if (!rm.originalNodeId && isInSlice(slice, rm.position, rm.width, rm.height)) {
-                readModels.push(rm);
-            }
-        }
-        // Filter out linked copies - only export originals
-        for (const scr of model.screens.values()) {
-            if (!scr.originalNodeId && isInSlice(slice, scr.position, scr.width, scr.height)) {
-                screens.push(scr);
-            }
-        }
-        for (const proc of model.processors.values()) {
-            if (isInSlice(slice, proc.position, proc.width, proc.height)) {
-                processors.push(proc);
-            }
-        }
-        // Find scenarios for this slice
-        const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
-        // Convert to spec format
-        const specSlice = {
-            id: slice.id,
-            title: slice.name,
-            sliceType: determineSliceType(commands, events, processors),
-            status: mapStatus(slice.status),
-            commands: commands.map(cmd => ({
-                id: cmd.id,
-                title: cmd.name,
-                type: 'COMMAND',
-                fields: cmd.fields.map(convertField),
-                dependencies: [
-                    ...getInboundDependencies(model, cmd.id, 'COMMAND'),
-                    ...getOutboundDependencies(model, cmd.id, 'COMMAND'),
-                ],
-            })),
-            events: events.map(evt => ({
-                id: evt.id,
-                title: evt.name,
-                type: 'EVENT',
-                fields: evt.fields.map(convertField),
-                dependencies: [
-                    ...getInboundDependencies(model, evt.id, 'EVENT'),
-                    ...getOutboundDependencies(model, evt.id, 'EVENT'),
-                ],
-            })),
-            readmodels: readModels.map(rm => ({
-                id: rm.id,
-                title: rm.name,
-                type: 'READMODEL',
-                fields: rm.fields.map(convertField),
-                dependencies: [
-                    ...getInboundDependencies(model, rm.id, 'READMODEL'),
-                    ...getOutboundDependencies(model, rm.id, 'READMODEL'),
-                ],
-            })),
-            screens: screens.map(scr => ({
-                id: scr.id,
-                title: scr.name,
-                type: 'SCREEN',
-                fields: scr.fields.map(convertField),
-                dependencies: [
-                    ...getInboundDependencies(model, scr.id, 'SCREEN'),
-                    ...getOutboundDependencies(model, scr.id, 'SCREEN'),
-                ],
-            })),
-            processors: processors.map(proc => ({
-                id: proc.id,
-                title: proc.name,
-                type: 'AUTOMATION',
-                fields: proc.fields.map(convertField),
-                dependencies: [
-                    ...getInboundDependencies(model, proc.id, 'AUTOMATION'),
-                    ...getOutboundDependencies(model, proc.id, 'AUTOMATION'),
-                ],
-            })),
-            tables: [],
-            actors: getActorsForSlice(model, slice),
-            aggregates: getAggregatesForSlice(model, slice),
-            specifications: scenarios.map(scenario => {
-                const givenSteps = scenario.givenEvents.map(given => {
-                    const evt = model.events.get(given.eventStickyId);
-                    return {
-                        id: given.eventStickyId,
-                        title: evt?.name ?? 'Unknown',
-                        elementType: 'EVENT',
-                        fields: given.fieldValues,
-                    };
-                });
-                const whenSteps = [];
-                if (scenario.whenCommand) {
-                    const cmd = model.commands.get(scenario.whenCommand.commandStickyId);
-                    whenSteps.push({
-                        id: scenario.whenCommand.commandStickyId,
-                        title: cmd?.name ?? 'Unknown',
-                        elementType: 'COMMAND',
-                        fields: scenario.whenCommand.fieldValues,
-                    });
-                }
-                const thenSteps = [];
-                if (scenario.then.type === 'events' && scenario.then.expectedEvents) {
-                    for (const expected of scenario.then.expectedEvents) {
-                        const evt = model.events.get(expected.eventStickyId);
-                        thenSteps.push({
-                            id: expected.eventStickyId,
-                            title: evt?.name ?? 'Unknown',
-                            elementType: 'EVENT',
-                            fields: expected.fieldValues,
-                        });
-                    }
-                }
-                else if (scenario.then.type === 'readModelAssertion' && scenario.then.readModelAssertion) {
-                    const rm = model.readModels.get(scenario.then.readModelAssertion.readModelStickyId);
-                    thenSteps.push({
-                        id: scenario.then.readModelAssertion.readModelStickyId,
-                        title: rm?.name ?? 'Unknown',
-                        elementType: 'READMODEL',
-                        fields: scenario.then.readModelAssertion.expectedFieldValues,
-                    });
-                }
-                return {
-                    id: scenario.id,
-                    title: scenario.name,
-                    linkedId: slice.id,
-                    given: givenSteps,
-                    when: whenSteps,
-                    then: thenSteps,
-                };
-            }),
-        };
-        specSlices.push(specSlice);
-    }
-    const exportData = {
-        slices: specSlices,
-    };
-    console.log(JSON.stringify(exportData, null, 2));
-}

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

@@ -1,2 +0,0 @@
-export declare function gitSetup(global: boolean): void;
-export declare function gitStatus(): void;