eventmodeler 0.1.0 → 0.2.0

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

@@ -0,0 +1,339 @@
+import * as crypto from 'node:crypto';
+import { appendEvent } from '../../lib/file-loader.js';
+function parseJsonInput(input) {
+    return JSON.parse(input);
+}
+function parseXmlInput(input) {
+    // Simple XML parser for scenario format
+    const getAttr = (tag, attr) => {
+        const match = tag.match(new RegExp(`${attr}="([^"]*)"`));
+        return match ? match[1] : undefined;
+    };
+    const getContent = (xml, tagName) => {
+        const match = xml.match(new RegExp(`<${tagName}[^>]*>([\\s\\S]*?)</${tagName}>`));
+        return match ? match[1].trim() : undefined;
+    };
+    const scenarioMatch = input.match(/<scenario([^>]*)>/);
+    if (!scenarioMatch) {
+        throw new Error('Invalid XML: missing <scenario> tag');
+    }
+    const name = getAttr(scenarioMatch[1], 'name');
+    if (!name) {
+        throw new Error('Invalid XML: scenario must have a name attribute');
+    }
+    const description = getAttr(scenarioMatch[1], 'description');
+    // Parse given events
+    const givenContent = getContent(input, 'given');
+    const given = [];
+    if (givenContent) {
+        const eventMatches = givenContent.matchAll(/<event([^>]*?)(?:\/>|>([\s\S]*?)<\/event>)/g);
+        for (const match of eventMatches) {
+            const eventName = getAttr(match[1], 'name');
+            if (eventName) {
+                const fieldValues = {};
+                if (match[2]) {
+                    const fieldMatches = match[2].matchAll(/<field name="([^"]*)"[^>]*>([^<]*)<\/field>/g);
+                    for (const fieldMatch of fieldMatches) {
+                        fieldValues[fieldMatch[1]] = parseFieldValue(fieldMatch[2]);
+                    }
+                }
+                given.push({ event: eventName, fieldValues: Object.keys(fieldValues).length > 0 ? fieldValues : undefined });
+            }
+        }
+    }
+    // Parse when command
+    const whenContent = getContent(input, 'when');
+    let when;
+    if (whenContent) {
+        const commandMatch = whenContent.match(/<command([^>]*?)(?:\/>|>([\s\S]*?)<\/command>)/);
+        if (commandMatch) {
+            const commandName = getAttr(commandMatch[1], 'name');
+            if (commandName) {
+                const fieldValues = {};
+                if (commandMatch[2]) {
+                    const fieldMatches = commandMatch[2].matchAll(/<field name="([^"]*)"[^>]*>([^<]*)<\/field>/g);
+                    for (const fieldMatch of fieldMatches) {
+                        fieldValues[fieldMatch[1]] = parseFieldValue(fieldMatch[2]);
+                    }
+                }
+                when = { command: commandName, fieldValues: Object.keys(fieldValues).length > 0 ? fieldValues : undefined };
+            }
+        }
+    }
+    // Parse then
+    const thenMatch = input.match(/<then([^>]*)(?:\/>|>([\s\S]*?)<\/then>)/);
+    if (!thenMatch) {
+        throw new Error('Invalid XML: missing <then> tag');
+    }
+    const thenType = getAttr(thenMatch[1], 'type');
+    if (!thenType) {
+        throw new Error('Invalid XML: <then> must have a type attribute');
+    }
+    const then = { type: thenType };
+    if (thenType === 'error') {
+        then.errorType = getAttr(thenMatch[1], 'errorType');
+        then.errorMessage = thenMatch[2]?.trim();
+    }
+    else if (thenType === 'events' && thenMatch[2]) {
+        then.events = [];
+        const eventMatches = thenMatch[2].matchAll(/<event([^>]*?)(?:\/>|>([\s\S]*?)<\/event>)/g);
+        for (const match of eventMatches) {
+            const eventName = getAttr(match[1], 'name');
+            if (eventName) {
+                const fieldValues = {};
+                if (match[2]) {
+                    const fieldMatches = match[2].matchAll(/<field name="([^"]*)"[^>]*>([^<]*)<\/field>/g);
+                    for (const fieldMatch of fieldMatches) {
+                        fieldValues[fieldMatch[1]] = parseFieldValue(fieldMatch[2]);
+                    }
+                }
+                then.events.push({ event: eventName, fieldValues: Object.keys(fieldValues).length > 0 ? fieldValues : undefined });
+            }
+        }
+    }
+    else if (thenType === 'readModelAssertion' && thenMatch[2]) {
+        const rmMatch = thenMatch[2].match(/<read-model([^>]*?)(?:\/>|>([\s\S]*?)<\/read-model>)/);
+        if (rmMatch) {
+            then.readModel = getAttr(rmMatch[1], 'name');
+            then.expected = {};
+            if (rmMatch[2]) {
+                const fieldMatches = rmMatch[2].matchAll(/<field name="([^"]*)"[^>]*>([^<]*)<\/field>/g);
+                for (const fieldMatch of fieldMatches) {
+                    then.expected[fieldMatch[1]] = parseFieldValue(fieldMatch[2]);
+                }
+            }
+        }
+    }
+    return { name, description, given: given.length > 0 ? given : undefined, when, then };
+}
+function parseFieldValue(value) {
+    // Try to parse as JSON for complex values, otherwise return as string
+    const trimmed = value.trim();
+    if (trimmed === 'true')
+        return true;
+    if (trimmed === 'false')
+        return false;
+    if (trimmed === 'null')
+        return null;
+    if (/^-?\d+$/.test(trimmed))
+        return parseInt(trimmed, 10);
+    if (/^-?\d+\.\d+$/.test(trimmed))
+        return parseFloat(trimmed);
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function parseInput(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith('<')) {
+        return parseXmlInput(trimmed);
+    }
+    return parseJsonInput(trimmed);
+}
+export function addScenario(model, filePath, sliceName, input) {
+    // Parse input
+    let scenarioInput;
+    try {
+        scenarioInput = parseInput(input);
+    }
+    catch (err) {
+        console.error(`Error: Invalid input format: ${err.message}`);
+        process.exit(1);
+    }
+    // Find slice by name
+    const slices = [...model.slices.values()];
+    const sliceNameLower = sliceName.toLowerCase();
+    const slice = slices.find(s => s.name.toLowerCase() === sliceNameLower || s.name.toLowerCase().includes(sliceNameLower));
+    if (!slice) {
+        console.error(`Error: Slice not found: ${sliceName}`);
+        console.error('Available slices:');
+        for (const s of slices) {
+            console.error(`  - ${s.name}`);
+        }
+        process.exit(1);
+    }
+    // Resolve event references in given
+    const givenEvents = [];
+    if (scenarioInput.given) {
+        for (const g of scenarioInput.given) {
+            const event = findEventByName(model, g.event);
+            if (!event) {
+                console.error(`Error: Event not found in "given": ${g.event}`);
+                listAvailableEvents(model);
+                process.exit(1);
+            }
+            givenEvents.push({
+                eventStickyId: event.id,
+                fieldValues: g.fieldValues,
+            });
+        }
+    }
+    // Resolve command reference in when
+    let whenCommand = null;
+    if (scenarioInput.when) {
+        const command = findCommandByName(model, scenarioInput.when.command);
+        if (!command) {
+            console.error(`Error: Command not found in "when": ${scenarioInput.when.command}`);
+            listAvailableCommands(model);
+            process.exit(1);
+        }
+        whenCommand = {
+            commandStickyId: command.id,
+            fieldValues: scenarioInput.when.fieldValues,
+        };
+    }
+    // Resolve then clause
+    const then = { type: scenarioInput.then.type };
+    if (scenarioInput.then.type === 'error') {
+        then.errorMessage = scenarioInput.then.errorMessage;
+        then.errorType = scenarioInput.then.errorType;
+    }
+    else if (scenarioInput.then.type === 'events') {
+        then.expectedEvents = [];
+        if (scenarioInput.then.events) {
+            for (const e of scenarioInput.then.events) {
+                const event = findEventByName(model, e.event);
+                if (!event) {
+                    console.error(`Error: Event not found in "then.events": ${e.event}`);
+                    listAvailableEvents(model);
+                    process.exit(1);
+                }
+                then.expectedEvents.push({
+                    eventStickyId: event.id,
+                    fieldValues: e.fieldValues,
+                });
+            }
+        }
+    }
+    else if (scenarioInput.then.type === 'readModelAssertion') {
+        if (!scenarioInput.then.readModel) {
+            console.error('Error: readModelAssertion requires a readModel name');
+            process.exit(1);
+        }
+        const readModel = findReadModelByName(model, scenarioInput.then.readModel);
+        if (!readModel) {
+            console.error(`Error: Read model not found: ${scenarioInput.then.readModel}`);
+            listAvailableReadModels(model);
+            process.exit(1);
+        }
+        const assertionGivenEvents = [];
+        if (scenarioInput.then.givenEvents) {
+            for (const g of scenarioInput.then.givenEvents) {
+                const event = findEventByName(model, g.event);
+                if (!event) {
+                    console.error(`Error: Event not found in "then.givenEvents": ${g.event}`);
+                    listAvailableEvents(model);
+                    process.exit(1);
+                }
+                assertionGivenEvents.push({
+                    eventStickyId: event.id,
+                    fieldValues: g.fieldValues,
+                });
+            }
+        }
+        then.readModelAssertion = {
+            readModelStickyId: readModel.id,
+            givenEvents: assertionGivenEvents,
+            expectedFieldValues: scenarioInput.then.expected ?? {},
+        };
+    }
+    // Calculate position below slice
+    const existingScenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
+    const sliceBottom = slice.position.y + slice.size.height;
+    let positionY;
+    if (existingScenarios.length === 0) {
+        positionY = sliceBottom + 20;
+    }
+    else {
+        const lowestY = Math.max(...existingScenarios.map(s => s.position.y + s.height));
+        positionY = lowestY + 10;
+    }
+    const position = {
+        x: slice.position.x + 10,
+        y: positionY,
+    };
+    // Generate scenario ID
+    const scenarioId = crypto.randomUUID();
+    // Append ScenarioCreated event
+    appendEvent(filePath, {
+        type: 'ScenarioCreated',
+        scenarioId,
+        sliceId: slice.id,
+        name: scenarioInput.name,
+        position,
+        width: 200,
+        height: 80,
+        timestamp: Date.now(),
+    });
+    // Append description update if provided
+    if (scenarioInput.description) {
+        appendEvent(filePath, {
+            type: 'ScenarioDescriptionUpdated',
+            scenarioId,
+            description: scenarioInput.description,
+            timestamp: Date.now(),
+        });
+    }
+    // Append given events update if provided
+    if (givenEvents.length > 0) {
+        appendEvent(filePath, {
+            type: 'ScenarioGivenEventsUpdated',
+            scenarioId,
+            givenEvents,
+            timestamp: Date.now(),
+        });
+    }
+    // Append when command update if provided
+    if (whenCommand) {
+        appendEvent(filePath, {
+            type: 'ScenarioWhenCommandUpdated',
+            scenarioId,
+            whenCommand,
+            timestamp: Date.now(),
+        });
+    }
+    // Append then update
+    appendEvent(filePath, {
+        type: 'ScenarioThenUpdated',
+        scenarioId,
+        then,
+        timestamp: Date.now(),
+    });
+    console.log(`Added scenario "${scenarioInput.name}" to slice "${slice.name}"`);
+}
+function findEventByName(model, name) {
+    const nameLower = name.toLowerCase();
+    const events = [...model.events.values()];
+    return events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
+}
+function findCommandByName(model, name) {
+    const nameLower = name.toLowerCase();
+    const commands = [...model.commands.values()];
+    return commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
+}
+function findReadModelByName(model, name) {
+    const nameLower = name.toLowerCase();
+    const readModels = [...model.readModels.values()];
+    return readModels.find(rm => rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower));
+}
+function listAvailableEvents(model) {
+    console.error('Available events:');
+    for (const e of model.events.values()) {
+        console.error(`  - ${e.name}`);
+    }
+}
+function listAvailableCommands(model) {
+    console.error('Available commands:');
+    for (const c of model.commands.values()) {
+        console.error(`  - ${c.name}`);
+    }
+}
+function listAvailableReadModels(model) {
+    console.error('Available read models:');
+    for (const rm of model.readModels.values()) {
+        console.error(`  - ${rm.name}`);
+    }
+}

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

@@ -141,6 +141,60 @@ function determineSliceType(commands, events, processors) {
     // 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
@@ -157,18 +211,21 @@ export function exportEventmodelToJson(model) {
                 commands.push(cmd);
             }
         }
+        // Filter out linked copies - only export originals
         for (const evt of model.events.values()) {
-            if (isInSlice(slice, evt.position, evt.width, evt.height)) {
+            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 (isInSlice(slice, rm.position, rm.width, rm.height)) {
+            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 (isInSlice(slice, scr.position, scr.width, scr.height)) {
+            if (!scr.originalNodeId && isInSlice(slice, scr.position, scr.width, scr.height)) {
                 screens.push(scr);
             }
         }
@@ -236,6 +293,8 @@ export function exportEventmodelToJson(model) {
                 ],
             })),
             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);

package/dist/slices/list-events/index.js

@@ -6,16 +6,72 @@ function escapeXml(str) {
         .replace(/"/g, '"')
         .replace(/'/g, ''');
 }
+// Find which aggregate an event belongs to (center point inside aggregate bounds)
+function findAggregateForEvent(model, event) {
+    const centerX = event.position.x + event.width / 2;
+    const centerY = event.position.y + event.height / 2;
+    for (const aggregate of model.aggregates.values()) {
+        const bounds = {
+            left: aggregate.position.x,
+            right: aggregate.position.x + aggregate.size.width,
+            top: aggregate.position.y,
+            bottom: aggregate.position.y + aggregate.size.height,
+        };
+        if (centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom) {
+            return aggregate;
+        }
+    }
+    return null;
+}
+// Find which slice contains an event
+function findSliceForEvent(model, event) {
+    for (const slice of model.slices.values()) {
+        const centerX = event.position.x + event.width / 2;
+        const centerY = event.position.y + event.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;
+}
 export function listEvents(model) {
     const events = [...model.events.values()];
     if (events.length === 0) {
         console.log('<events/>');
         return;
     }
-    const sorted = [...events].sort((a, b) => a.name.localeCompare(b.name));
+    // Sort: originals first, then copies; alphabetically within each group
+    const sorted = [...events].sort((a, b) => {
+        // Originals before copies
+        if (!a.originalNodeId && b.originalNodeId)
+            return -1;
+        if (a.originalNodeId && !b.originalNodeId)
+            return 1;
+        // Alphabetically by name
+        return a.name.localeCompare(b.name);
+    });
     console.log('<events>');
     for (const evt of sorted) {
-        console.log(`  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}"/>`);
+        const aggregate = findAggregateForEvent(model, evt);
+        const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
+        if (evt.originalNodeId) {
+            // This is a linked copy - show origin info
+            const original = model.events.get(evt.originalNodeId);
+            const originSlice = original ? findSliceForEvent(model, original) : null;
+            const originAttr = originSlice ? ` origin-slice="${escapeXml(originSlice)}"` : '';
+            console.log(`  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr} linked-copy="true"${originAttr}/>`);
+        }
+        else {
+            // This is an original - show copy count
+            const copyCount = evt.canonicalId
+                ? [...model.events.values()].filter(e => e.canonicalId === evt.canonicalId && e.originalNodeId).length
+                : 0;
+            const copiesAttr = copyCount > 0 ? ` copies="${copyCount}"` : '';
+            console.log(`  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr}${copiesAttr}/>`);
+        }
     }
     console.log('</events>');
 }

package/dist/slices/map-fields/index.d.ts

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