eventmodeler 0.4.4 → 0.4.5

package/dist/lib/config.d.ts

@@ -1,4 +1,4 @@
-import type { OutputFormat } from './format.js';
+type OutputFormat = 'xml' | 'json';
 export interface AuthTokens {
     accessToken: string;
     refreshToken: string;
@@ -27,3 +27,4 @@ export declare function setBackendUrl(url: string): void;
 export declare function getKeycloakUrl(): string;
 export declare function setKeycloakUrl(url: string): void;
 export declare function getDefaultFormat(): OutputFormat;
+export {};

package/dist/lib/project-config.d.ts

@@ -2,9 +2,6 @@ export type ProjectConfig = {
     type: 'cloud';
     modelId: string;
     modelName: string;
-} | {
-    type: 'local';
-    file: string;
 };
 /**
  * Find .eventmodeler.json by walking up from cwd to find the repo root.

package/dist/lib/project-config.js

@@ -37,11 +37,6 @@ export function loadProjectConfig(startDir) {
         if (config.type === 'cloud' && config.modelId && config.modelName) {
             return { type: 'cloud', modelId: config.modelId, modelName: config.modelName };
         }
-        if (config.type === 'local' && config.file) {
-            // Resolve file path relative to the config file location
-            const configDir = path.dirname(configPath);
-            return { type: 'local', file: path.resolve(configDir, config.file) };
-        }
         return null;
     }
     catch {
@@ -53,9 +48,7 @@ export function loadProjectConfig(startDir) {
  */
 export function saveProjectConfig(config, targetDir = process.cwd()) {
     const configPath = path.join(targetDir, PROJECT_CONFIG_FILENAME);
-    const content = config.type === 'cloud'
-        ? { type: 'cloud', modelId: config.modelId, modelName: config.modelName }
-        : { type: 'local', file: config.file };
+    const content = { type: 'cloud', modelId: config.modelId, modelName: config.modelName };
     fs.writeFileSync(configPath, JSON.stringify(content, null, 2) + '\n');
     return configPath;
 }

package/dist/lib/slice-utils.d.ts

@@ -1,81 +1,3 @@
-import type { EventModel, Field, FieldMapping, Slice } from '../types.js';
-export declare const STATE_CHANGE_SLICE: {
-    width: number;
-    height: number;
-    screen: {
-        width: number;
-        height: number;
-        offsetX: number;
-        offsetY: number;
-    };
-    command: {
-        width: number;
-        height: number;
-        offsetX: number;
-        offsetY: number;
-    };
-    event: {
-        width: number;
-        height: number;
-        offsetX: number;
-        offsetY: number;
-    };
-};
-export declare const AUTOMATION_SLICE: {
-    width: number;
-    height: number;
-    readModel: {
-        width: number;
-        height: number;
-        offsetX: number;
-        offsetY: number;
-    };
-    processor: {
-        width: number;
-        height: number;
-        offsetX: number;
-        offsetY: number;
-    };
-    command: {
-        width: number;
-        height: number;
-        offsetX: number;
-        offsetY: number;
-    };
-    event: {
-        width: number;
-        height: number;
-        offsetX: number;
-        offsetY: number;
-    };
-};
-export declare const STATE_VIEW_SLICE: {
-    width: number;
-    height: number;
-    readModel: {
-        width: number;
-        height: number;
-        offsetX: number;
-        offsetY: number;
-    };
-};
-export declare const SLICE_GAP = 20;
-export interface PositionReference {
-    after?: string;
-    before?: string;
-}
-export declare function findSliceByName(model: EventModel, name: string): Slice | undefined;
-export declare function validateSliceNameUnique(model: EventModel, name: string): void;
-export declare function calculateSlicePosition(model: EventModel, sliceWidth: number, ref: PositionReference): {
-    x: number;
-    y: number;
-};
-export declare function getSlicesToShift(model: EventModel, insertX: number, shiftAmount: number): Array<{
-    sliceId: string;
-    newX: number;
-    currentY: number;
-}>;
-export declare function inferFieldMappings(sourceFields: Field[], targetFields: Field[]): FieldMapping[];
 export interface FieldInput {
     name: string;
     type: string;
@@ -86,7 +8,6 @@ export interface FieldInput {
     subfields?: FieldInput[];
 }
 export declare function parseFieldsFromXml(xml: string): FieldInput[];
-export declare function fieldInputToField(input: FieldInput): Field;
 export interface StateChangeSliceInput {
     sliceName: string;
     after?: string;

package/dist/lib/slice-utils.js

@@ -1,96 +1,4 @@
-// Fixed dimensions from requirements
-export const STATE_CHANGE_SLICE = {
-    width: 560,
-    height: 1000,
-    screen: { width: 180, height: 120, offsetX: 40, offsetY: 120 },
-    command: { width: 160, height: 100, offsetX: 180, offsetY: 460 },
-    event: { width: 160, height: 100, offsetX: 360, offsetY: 860 },
-};
-export const AUTOMATION_SLICE = {
-    width: 880,
-    height: 1000,
-    readModel: { width: 160, height: 100, offsetX: 40, offsetY: 460 },
-    processor: { width: 120, height: 120, offsetX: 280, offsetY: 120 },
-    command: { width: 160, height: 100, offsetX: 440, offsetY: 460 },
-    event: { width: 160, height: 100, offsetX: 680, offsetY: 860 },
-};
-export const STATE_VIEW_SLICE = {
-    width: 380,
-    height: 1000,
-    readModel: { width: 160, height: 100, offsetX: 110, offsetY: 460 },
-};
-export const SLICE_GAP = 20;
-export function findSliceByName(model, name) {
-    const nameLower = name.toLowerCase();
-    return [...model.slices.values()].find(s => s.name.toLowerCase() === nameLower || s.name.toLowerCase().includes(nameLower));
-}
-export function validateSliceNameUnique(model, name) {
-    const existing = findSliceByName(model, name);
-    if (existing && existing.name.toLowerCase() === name.toLowerCase()) {
-        throw new Error(`Slice "${name}" already exists`);
-    }
-}
-export function calculateSlicePosition(model, sliceWidth, ref) {
-    const slices = [...model.slices.values()];
-    if (slices.length === 0) {
-        return { x: 0, y: 0 };
-    }
-    if (ref.after) {
-        const refSlice = findSliceByName(model, ref.after);
-        if (!refSlice) {
-            const available = slices.map(s => s.name).join(', ');
-            throw new Error(`Slice "${ref.after}" not found. Available: ${available}`);
-        }
-        return {
-            x: refSlice.position.x + refSlice.size.width + SLICE_GAP,
-            y: refSlice.position.y
-        };
-    }
-    if (ref.before) {
-        const refSlice = findSliceByName(model, ref.before);
-        if (!refSlice) {
-            const available = slices.map(s => s.name).join(', ');
-            throw new Error(`Slice "${ref.before}" not found. Available: ${available}`);
-        }
-        return {
-            x: refSlice.position.x,
-            y: refSlice.position.y
-        };
-    }
-    // Default: append to end (right of rightmost slice)
-    const rightmost = slices.reduce((max, s) => Math.max(max, s.position.x + s.size.width), 0);
-    const avgY = slices.reduce((sum, s) => sum + s.position.y, 0) / slices.length;
-    return {
-        x: rightmost + SLICE_GAP,
-        y: avgY
-    };
-}
-export function getSlicesToShift(model, insertX, shiftAmount) {
-    return [...model.slices.values()]
-        .filter(s => s.position.x >= insertX)
-        .map(s => ({
-        sliceId: s.id,
-        newX: s.position.x + shiftAmount,
-        currentY: s.position.y
-    }));
-}
-export function inferFieldMappings(sourceFields, targetFields) {
-    const mappings = [];
-    for (const targetField of targetFields) {
-        // Skip generated fields - they have no source
-        if (targetField.isGenerated)
-            continue;
-        // Find source field with matching name (case-insensitive)
-        const sourceField = sourceFields.find(sf => sf.name.toLowerCase() === targetField.name.toLowerCase());
-        if (sourceField) {
-            mappings.push({
-                sourceFieldId: sourceField.id,
-                targetFieldId: targetField.id
-            });
-        }
-    }
-    return mappings;
-}
+import { XMLParser } from 'fast-xml-parser';
 const VALID_FIELD_TYPES = ['UUID', 'Boolean', 'Double', 'Decimal', 'Date', 'DateTime', 'Long', 'Int', 'String', 'Custom'];
 function validateFieldType(type, fieldName) {
     if (!VALID_FIELD_TYPES.includes(type)) {
@@ -102,189 +10,131 @@ function validateFieldType(type, fieldName) {
         throw new Error(`Invalid field type "${type}" for field "${fieldName}". Valid types: ${VALID_FIELD_TYPES.join(', ')}${hint}`);
     }
 }
-function getAttr(attrs, name) {
-    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
-    return match ? match[1] : undefined;
+const xmlParser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    allowBooleanAttributes: false,
+    parseAttributeValue: false,
+    isArray: (name) => name === 'field',
+});
+function asArray(value) {
+    if (value === undefined || value === null)
+        return [];
+    return Array.isArray(value) ? value : [value];
 }
-export function parseFieldsFromXml(xml) {
+function parseFieldNodes(nodes) {
     const fields = [];
-    // Match top-level field elements only (not nested inside other fields)
-    const fieldMatches = xml.matchAll(/<field([^>]*?)(?:\/>|>([\s\S]*?)<\/field>)/g);
-    for (const match of fieldMatches) {
-        const attrs = match[1];
-        const content = match[2];
-        const name = getAttr(attrs, 'name');
-        const type = getAttr(attrs, 'type');
+    for (const node of nodes) {
+        const n = node;
+        const name = n['@_name'];
+        const type = n['@_type'];
         if (!name || !type)
             continue;
-        // Validate the field type
         validateFieldType(type, name);
         const field = {
             name,
             type,
-            isList: getAttr(attrs, 'isList') === 'true',
-            isGenerated: getAttr(attrs, 'isGenerated') === 'true',
-            isOptional: getAttr(attrs, 'isOptional') === 'true',
-            isUserInput: getAttr(attrs, 'isUserInput') === 'true',
+            isList: n['@_isList'] === 'true',
+            isGenerated: n['@_isGenerated'] === 'true',
+            isOptional: n['@_isOptional'] === 'true',
+            isUserInput: n['@_isUserInput'] === 'true',
         };
-        // Parse nested subfields for Custom type
-        if (type === 'Custom' && content) {
-            field.subfields = parseFieldsFromXml(content);
+        if (type === 'Custom') {
+            const childFields = asArray(n['field']);
+            if (childFields.length > 0) {
+                field.subfields = parseFieldNodes(childFields);
+            }
         }
         fields.push(field);
     }
     return fields;
 }
-export function fieldInputToField(input) {
-    return {
-        id: crypto.randomUUID(),
-        name: input.name,
-        fieldType: input.type,
-        isList: input.isList ?? false,
-        isGenerated: input.isGenerated ?? false,
-        isOptional: input.isOptional,
-        isUserInput: input.isUserInput,
-        subfields: input.subfields?.map(fieldInputToField),
-    };
+export function parseFieldsFromXml(xml) {
+    const wrapper = `<root>${xml}</root>`;
+    const parsed = xmlParser.parse(wrapper);
+    const root = parsed['root'];
+    if (!root)
+        return [];
+    return parseFieldNodes(asArray(root['field']));
 }
-export function parseStateChangeSliceXml(xml) {
-    // Parse <state-change-slice name="..." after="..." before="...">
-    const sliceMatch = xml.match(/<state-change-slice([^>]*)>/);
-    if (!sliceMatch) {
-        throw new Error('Invalid XML: missing <state-change-slice> tag');
+function requireAttr(node, attr, tagName) {
+    const value = node[`@_${attr}`];
+    if (!value) {
+        throw new Error(`Invalid XML: ${tagName} must have a ${attr} attribute`);
     }
-    const sliceName = getAttr(sliceMatch[1], 'name');
-    if (!sliceName) {
-        throw new Error('Invalid XML: state-change-slice must have a name attribute');
-    }
-    const after = getAttr(sliceMatch[1], 'after');
-    const before = getAttr(sliceMatch[1], 'before');
-    // Parse screen
-    const screenMatch = xml.match(/<screen([^>]*)>([\s\S]*?)<\/screen>/);
-    if (!screenMatch) {
-        throw new Error('Invalid XML: missing <screen> element');
-    }
-    const screenName = getAttr(screenMatch[1], 'name');
-    if (!screenName) {
-        throw new Error('Invalid XML: screen must have a name attribute');
-    }
-    const screenFields = parseFieldsFromXml(screenMatch[2]);
-    // Parse command
-    const commandMatch = xml.match(/<command([^>]*)>([\s\S]*?)<\/command>/);
-    if (!commandMatch) {
-        throw new Error('Invalid XML: missing <command> element');
-    }
-    const commandName = getAttr(commandMatch[1], 'name');
-    if (!commandName) {
-        throw new Error('Invalid XML: command must have a name attribute');
-    }
-    const commandFields = parseFieldsFromXml(commandMatch[2]);
-    // Parse event
-    const eventMatch = xml.match(/<event([^>]*)>([\s\S]*?)<\/event>/);
-    if (!eventMatch) {
-        throw new Error('Invalid XML: missing <event> element');
+    return value;
+}
+function optAttr(node, attr) {
+    return node[`@_${attr}`];
+}
+function getElement(parent, tag) {
+    const el = parent[tag];
+    if (!el) {
+        throw new Error(`Invalid XML: missing <${tag}> element`);
     }
-    const eventName = getAttr(eventMatch[1], 'name');
-    if (!eventName) {
-        throw new Error('Invalid XML: event must have a name attribute');
+    return el;
+}
+function extractFields(node) {
+    return parseFieldNodes(asArray(node['field']));
+}
+export function parseStateChangeSliceXml(xml) {
+    const parsed = xmlParser.parse(xml);
+    const slice = parsed['state-change-slice'];
+    if (!slice) {
+        throw new Error('Invalid XML: missing <state-change-slice> tag');
     }
-    const eventFields = parseFieldsFromXml(eventMatch[2]);
+    const sliceName = requireAttr(slice, 'name', 'state-change-slice');
+    const after = optAttr(slice, 'after');
+    const before = optAttr(slice, 'before');
+    const screen = getElement(slice, 'screen');
+    const command = getElement(slice, 'command');
+    const event = getElement(slice, 'event');
     return {
         sliceName,
         after,
         before,
-        screen: { name: screenName, fields: screenFields },
-        command: { name: commandName, fields: commandFields },
-        event: { name: eventName, fields: eventFields },
+        screen: { name: requireAttr(screen, 'name', 'screen'), fields: extractFields(screen) },
+        command: { name: requireAttr(command, 'name', 'command'), fields: extractFields(command) },
+        event: { name: requireAttr(event, 'name', 'event'), fields: extractFields(event) },
     };
 }
 export function parseAutomationSliceXml(xml) {
-    // Parse <automation-slice name="..." after="..." before="...">
-    const sliceMatch = xml.match(/<automation-slice([^>]*)>/);
-    if (!sliceMatch) {
+    const parsed = xmlParser.parse(xml);
+    const slice = parsed['automation-slice'];
+    if (!slice) {
         throw new Error('Invalid XML: missing <automation-slice> tag');
     }
-    const sliceName = getAttr(sliceMatch[1], 'name');
-    if (!sliceName) {
-        throw new Error('Invalid XML: automation-slice must have a name attribute');
-    }
-    const after = getAttr(sliceMatch[1], 'after');
-    const before = getAttr(sliceMatch[1], 'before');
-    // Parse read-model
-    const readModelMatch = xml.match(/<read-model([^>]*)>([\s\S]*?)<\/read-model>/);
-    if (!readModelMatch) {
-        throw new Error('Invalid XML: missing <read-model> element');
-    }
-    const readModelName = getAttr(readModelMatch[1], 'name');
-    if (!readModelName) {
-        throw new Error('Invalid XML: read-model must have a name attribute');
-    }
-    const readModelFields = parseFieldsFromXml(readModelMatch[2]);
-    // Parse processor (fields are not supported for processor in this slice type)
-    const processorMatch = xml.match(/<processor([^>]*?)(?:\/>|>([\s\S]*?)<\/processor>)/);
-    if (!processorMatch) {
-        throw new Error('Invalid XML: missing <processor> element');
-    }
-    const processorName = getAttr(processorMatch[1], 'name');
-    if (!processorName) {
-        throw new Error('Invalid XML: processor must have a name attribute');
-    }
-    // Parse command
-    const commandMatch = xml.match(/<command([^>]*)>([\s\S]*?)<\/command>/);
-    if (!commandMatch) {
-        throw new Error('Invalid XML: missing <command> element');
-    }
-    const commandName = getAttr(commandMatch[1], 'name');
-    if (!commandName) {
-        throw new Error('Invalid XML: command must have a name attribute');
-    }
-    const commandFields = parseFieldsFromXml(commandMatch[2]);
-    // Parse event
-    const eventMatch = xml.match(/<event([^>]*)>([\s\S]*?)<\/event>/);
-    if (!eventMatch) {
-        throw new Error('Invalid XML: missing <event> element');
-    }
-    const eventName = getAttr(eventMatch[1], 'name');
-    if (!eventName) {
-        throw new Error('Invalid XML: event must have a name attribute');
-    }
-    const eventFields = parseFieldsFromXml(eventMatch[2]);
+    const sliceName = requireAttr(slice, 'name', 'automation-slice');
+    const after = optAttr(slice, 'after');
+    const before = optAttr(slice, 'before');
+    const readModel = getElement(slice, 'read-model');
+    const processor = getElement(slice, 'processor');
+    const command = getElement(slice, 'command');
+    const event = getElement(slice, 'event');
     return {
         sliceName,
         after,
         before,
-        readModel: { name: readModelName, fields: readModelFields },
-        processor: { name: processorName },
-        command: { name: commandName, fields: commandFields },
-        event: { name: eventName, fields: eventFields },
+        readModel: { name: requireAttr(readModel, 'name', 'read-model'), fields: extractFields(readModel) },
+        processor: { name: requireAttr(processor, 'name', 'processor') },
+        command: { name: requireAttr(command, 'name', 'command'), fields: extractFields(command) },
+        event: { name: requireAttr(event, 'name', 'event'), fields: extractFields(event) },
     };
 }
 export function parseStateViewSliceXml(xml) {
-    // Parse <state-view-slice name="..." after="..." before="...">
-    const sliceMatch = xml.match(/<state-view-slice([^>]*)>/);
-    if (!sliceMatch) {
+    const parsed = xmlParser.parse(xml);
+    const slice = parsed['state-view-slice'];
+    if (!slice) {
         throw new Error('Invalid XML: missing <state-view-slice> tag');
     }
-    const sliceName = getAttr(sliceMatch[1], 'name');
-    if (!sliceName) {
-        throw new Error('Invalid XML: state-view-slice must have a name attribute');
-    }
-    const after = getAttr(sliceMatch[1], 'after');
-    const before = getAttr(sliceMatch[1], 'before');
-    // Parse read-model
-    const readModelMatch = xml.match(/<read-model([^>]*)>([\s\S]*?)<\/read-model>/);
-    if (!readModelMatch) {
-        throw new Error('Invalid XML: missing <read-model> element');
-    }
-    const readModelName = getAttr(readModelMatch[1], 'name');
-    if (!readModelName) {
-        throw new Error('Invalid XML: read-model must have a name attribute');
-    }
-    const readModelFields = parseFieldsFromXml(readModelMatch[2]);
+    const sliceName = requireAttr(slice, 'name', 'state-view-slice');
+    const after = optAttr(slice, 'after');
+    const before = optAttr(slice, 'before');
+    const readModel = getElement(slice, 'read-model');
     return {
         sliceName,
         after,
         before,
-        readModel: { name: readModelName, fields: readModelFields },
+        readModel: { name: requireAttr(readModel, 'name', 'read-model'), fields: extractFields(readModel) },
     };
 }

package/dist/projection.js

@@ -450,16 +450,6 @@ function applyEvent(model, event) {
                 nodeIds: [],
             });
             break;
-        case 'NodesGroupedIntoSlice':
-            model.slices.set(d.sliceId, {
-                id: d.sliceId,
-                name: d.name,
-                status: 'created',
-                position: d.position,
-                size: d.size,
-                nodeIds: d.nodeIds,
-            });
-            break;
         case 'SliceMoved': {
             const slice = model.slices.get(d.sliceId);
             if (slice)
@@ -540,17 +530,6 @@ function applyEvent(model, event) {
                 aggregateIdFieldType: d.aggregateIdFieldType,
             });
             break;
-        case 'EventsGroupedIntoAggregate':
-            model.aggregates.set(d.aggregateId, {
-                id: d.aggregateId,
-                name: d.name,
-                position: d.position,
-                size: d.size,
-                eventIds: d.eventIds,
-                aggregateIdFieldName: d.aggregateIdFieldName,
-                aggregateIdFieldType: d.aggregateIdFieldType,
-            });
-            break;
         case 'AggregateMoved': {
             const aggregate = model.aggregates.get(d.aggregateId);
             if (aggregate)
@@ -592,15 +571,6 @@ function applyEvent(model, event) {
                 screenIds: [],
             });
             break;
-        case 'ScreensGroupedIntoActor':
-            model.actors.set(d.actorId, {
-                id: d.actorId,
-                name: d.name,
-                position: d.position,
-                size: d.size,
-                screenIds: d.screenIds,
-            });
-            break;
         case 'ActorMoved': {
             const actor = model.actors.get(d.actorId);
             if (actor)

package/dist/slices/add-scenario/index.d.ts

@@ -1,4 +1,3 @@
-import type { EventModel } from '../../types.js';
 export interface ScenarioInput {
     name: string;
     description?: string;
@@ -25,5 +24,4 @@ interface EventInput {
     fieldValues?: Record<string, unknown>;
 }
 export declare function parseScenarioInput(input: string): ScenarioInput;
-export declare function addScenario(model: EventModel, filePath: string, sliceName: string, input: string): void;
 export {};