eventmodeler 0.4.7 → 0.6.0

package/dist/lib/auth.js

@@ -1,7 +1,7 @@
 import * as http from 'node:http';
 import * as crypto from 'node:crypto';
 import { exec } from 'node:child_process';
-import { saveAuthTokens, clearAuthTokens, getAuthTokens, getKeycloakUrl } from './config.js';
+import { saveAuthTokens, clearAuthTokens, getAuthTokens, getKeycloakUrl } from './config';
 const KEYCLOAK_CLIENT_ID = 'eventmodeler-cli';
 const REDIRECT_URI = 'http://localhost:8787/callback';
 /**

package/dist/lib/config.js

@@ -78,18 +78,3 @@ export function setKeycloakUrl(url) {
     config.keycloakUrl = url;
     saveGlobalConfig(config);
 }
-export function getDefaultFormat() {
-    // 1. Check environment variable
-    const envFormat = process.env.EVENTMODELER_FORMAT;
-    if (envFormat === 'json')
-        return 'json';
-    if (envFormat === 'xml')
-        return 'xml';
-    // 2. Check config file
-    const config = loadGlobalConfig();
-    if (config.format === 'json' || config.format === 'xml') {
-        return config.format;
-    }
-    // 3. Default to XML (better for AI agents)
-    return 'xml';
-}

package/dist/lib/excalidraw-schema.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+const FillStyle = z.enum(['solid', 'hachure', 'cross-hatch', 'zigzag']);
+const StrokeStyle = z.enum(['solid', 'dashed', 'dotted']);
+const TextAlign = z.enum(['left', 'center', 'right']);
+const VerticalAlign = z.enum(['top', 'middle', 'bottom']);
+const StyleFields = {
+    strokeColor: z.string().optional(),
+    backgroundColor: z.string().optional(),
+    fillStyle: FillStyle.optional(),
+    strokeStyle: StrokeStyle.optional(),
+    strokeWidth: z.number().nonnegative().optional(),
+    roughness: z.number().nonnegative().optional(),
+    opacity: z.number().min(0).max(100).optional(),
+    angle: z.number().optional(),
+};
+const BoxFields = {
+    id: z.string().min(1),
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number(),
+    ...StyleFields,
+};
+const ShapeElement = z.object({
+    type: z.enum(['rectangle', 'ellipse', 'diamond', 'frame', 'magicframe', 'iframe', 'embeddable', 'image', 'freedraw']),
+    ...BoxFields,
+}).passthrough();
+const LineElement = z.object({
+    type: z.enum(['line', 'arrow']),
+    ...BoxFields,
+    points: z.array(z.tuple([z.number(), z.number()])).optional(),
+}).passthrough();
+const TextElement = z.object({
+    type: z.literal('text'),
+    id: z.string().min(1),
+    x: z.number(),
+    y: z.number(),
+    width: z.number().optional(),
+    height: z.number().optional(),
+    text: z.string(),
+    fontSize: z.number().positive(),
+    fontFamily: z.number().int().positive().optional(),
+    textAlign: TextAlign.optional(),
+    verticalAlign: VerticalAlign.optional(),
+    ...StyleFields,
+}).passthrough();
+const Element = z.discriminatedUnion('type', [ShapeElement, LineElement, TextElement]);
+export const ExcalidrawDesign = z.array(Element).superRefine((elements, ctx) => {
+    const seen = new Set();
+    elements.forEach((el, i) => {
+        if (seen.has(el.id)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: [i, 'id'],
+                message: `duplicate id "${el.id}"`,
+            });
+        }
+        seen.add(el.id);
+    });
+});
+export function formatZodError(error) {
+    return error.issues.map(issue => {
+        const path = issue.path.length > 0 ? issue.path.join('.') : '(root)';
+        return `${path}: ${issue.message}`;
+    });
+}

package/dist/lib/globals.js

@@ -0,0 +1,8 @@
+let _program;
+export function setProgram(program) {
+    _program = program;
+}
+/** Get the global --id option value. */
+export function getGlobalId() {
+    return _program?.opts()?.id;
+}

package/dist/lib/model.js

@@ -0,0 +1,11 @@
+import { loadProjectConfig } from './project-config';
+/** Load modelId from .eventmodeler.json or exit with error. */
+export function requireModelId() {
+    const config = loadProjectConfig();
+    if (!config || config.type !== 'cloud') {
+        console.error('Error: No project configured.');
+        console.error('Run "eventmodeler init" to connect this directory to a model.');
+        process.exit(1);
+    }
+    return config.modelId;
+}

package/dist/lib/project-config.js

@@ -81,3 +81,23 @@ export function getProjectRoot(startDir = process.cwd()) {
 export function isInProject(startDir) {
     return findProjectConfigPath(startDir) !== null;
 }
+/**
+ * Load the `loop` block from .eventmodeler.json, if present.
+ */
+export function loadLoopConfig(startDir) {
+    const configPath = findProjectConfigPath(startDir);
+    if (!configPath)
+        return null;
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        const loop = config.loop;
+        if (loop && typeof loop.command === 'string' && typeof loop.interval === 'number') {
+            return { command: loop.command, interval: loop.interval };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/resolve.js

@@ -0,0 +1,59 @@
+import * as sdk from '../api/generated/sdk.gen';
+const FIELD_BEARING_TYPES = ['command', 'event', 'readmodel', 'screen', 'processor', 'external-event'];
+/** Map element type to the body key name used by the SDK. */
+export function elementIdKey(type) {
+    switch (type) {
+        case 'command': return 'commandStickyId';
+        case 'event': return 'eventStickyId';
+        case 'readmodel': return 'readModelStickyId';
+        case 'external-event': return 'externalEventId';
+        case 'swimlane': return 'swimLaneId';
+        default: return `${type}Id`;
+    }
+}
+/** Unwrap SDK response — throw on error, return data on success. */
+export function unwrap(result) {
+    if (result.error) {
+        const err = result.error;
+        const message = err?.error ?? err?.message ?? err?.detail ?? JSON.stringify(err);
+        throw new Error(String(message));
+    }
+    if (result.data === undefined) {
+        throw new Error(`Empty response (HTTP ${result.response.status})`);
+    }
+    return result.data;
+}
+/**
+ * Resolve an element name to its UUID via the CLI resolver.
+ * If idOverride is provided, skip resolution and return it directly.
+ */
+export async function resolve(modelId, elementType, name, idOverride) {
+    if (idOverride)
+        return idOverride;
+    const result = unwrap(await sdk.resolveElement({
+        query: { modelId, elementType, name }
+    }));
+    const elementId = result.elementId;
+    if (!elementId) {
+        throw new Error(`${elementType} "${name}" not found`);
+    }
+    return String(elementId);
+}
+/** Resolve an element name to its UUID, trying all field-bearing types. */
+export async function resolveAnyElement(modelId, name, idOverride) {
+    if (idOverride) {
+        return { elementId: idOverride, elementType: 'unknown' };
+    }
+    for (const t of FIELD_BEARING_TYPES) {
+        try {
+            const id = await resolve(modelId, t, name);
+            return { elementId: id, elementType: t };
+        }
+        catch { /* try next */ }
+    }
+    throw new Error(`Element "${name}" not found`);
+}
+/** Pretty-print JSON to stdout. */
+export function out(data) {
+    console.log(JSON.stringify(data, null, 2));
+}

package/dist/lib/scenario.js

@@ -0,0 +1,15 @@
+import * as sdk from '../api/generated/sdk.gen';
+import { unwrap } from './resolve';
+/** Resolve a scenario name to its UUID. If idOverride is provided, skip resolution. */
+export async function resolveScenarioId(modelId, name, idOverride) {
+    if (idOverride)
+        return idOverride;
+    const result = unwrap(await sdk.resolveScenario({
+        query: { modelId, name }
+    }));
+    const scenarioId = result.scenarioId;
+    if (!scenarioId) {
+        throw new Error(`Scenario "${name}" not found`);
+    }
+    return String(scenarioId);
+}

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

@@ -1,101 +1,9 @@
-import { XMLParser } from 'fast-xml-parser';
-const xmlParser = new XMLParser({
-    ignoreAttributes: false,
-    attributeNamePrefix: '@_',
-    allowBooleanAttributes: false,
-    parseAttributeValue: false,
-    isArray: (name) => name === 'event' || name === 'field',
-    trimValues: true,
-});
-function asArray(value) {
-    if (value === undefined || value === null)
-        return [];
-    return Array.isArray(value) ? value : [value];
-}
 function asRecord(value, context) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         throw new Error(`${context} must be an object`);
     }
     return value;
 }
-function parseFieldValue(value) {
-    const trimmed = value.trim();
-    if (trimmed === '')
-        return '';
-    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 parseFieldValuesFromNodes(nodes) {
-    if (nodes.length === 0)
-        return undefined;
-    const result = {};
-    for (const node of nodes) {
-        const n = node;
-        const name = n['@_name'];
-        if (!name)
-            continue;
-        const childFields = asArray(n['field']);
-        let value;
-        if (childFields.length > 0) {
-            value = parseFieldValuesFromNodes(childFields);
-        }
-        else {
-            // Get text content (fast-xml-parser stores it as #text)
-            const text = n['#text'];
-            if (text === undefined || text === '') {
-                value = null;
-            }
-            else {
-                value = parseFieldValue(String(text));
-            }
-        }
-        // Handle duplicate keys (multiple values → array)
-        if (name in result) {
-            const current = result[name];
-            if (Array.isArray(current)) {
-                current.push(value);
-            }
-            else {
-                result[name] = [current, value];
-            }
-        }
-        else {
-            result[name] = value;
-        }
-    }
-    return Object.keys(result).length > 0 ? result : undefined;
-}
-function parseEventInputsFromNodes(nodes) {
-    const result = [];
-    for (const node of nodes) {
-        const n = node;
-        const nameFromAttr = n['@_name'];
-        const textContent = n['#text'];
-        const eventName = nameFromAttr ?? textContent;
-        if (!eventName)
-            continue;
-        const childFields = asArray(n['field']);
-        result.push({
-            event: eventName,
-            fieldValues: parseFieldValuesFromNodes(childFields),
-        });
-    }
-    return result;
-}
 function parseEventInput(value, context) {
     if (typeof value === 'string') {
         return { event: value };
@@ -142,8 +50,8 @@ function parseObjectValue(value, context) {
     }
     return value;
 }
-function normalizeScenarioInput(rawValue) {
-    const raw = asRecord(rawValue, 'scenario');
+export function parseScenarioInput(input) {
+    const raw = asRecord(JSON.parse(input.trim()), 'scenario');
     const name = raw.name;
     if (typeof name !== 'string' || name.trim() === '') {
         throw new Error('scenario.name is required');
@@ -193,115 +101,3 @@ function normalizeScenarioInput(rawValue) {
         then,
     };
 }
-function parseJsonInput(input) {
-    return normalizeScenarioInput(JSON.parse(input));
-}
-function parseXmlInput(input) {
-    const parsed = xmlParser.parse(input);
-    const scenario = parsed['scenario'];
-    if (!scenario) {
-        throw new Error('Invalid XML: missing <scenario> tag');
-    }
-    const name = scenario['@_name'];
-    if (!name) {
-        throw new Error('Invalid XML: scenario must have a name attribute');
-    }
-    const description = scenario['@_description'];
-    // Parse given events
-    const givenNode = scenario['given'];
-    const given = givenNode ? parseEventInputsFromNodes(asArray(givenNode['event'])) : [];
-    // Parse when
-    let when;
-    const whenNode = scenario['when'];
-    if (whenNode) {
-        const commandNodes = asArray(whenNode['command']);
-        const commandNode = commandNodes[0];
-        const whenEvents = parseEventInputsFromNodes(asArray(whenNode['event']));
-        if (commandNode || whenEvents.length > 0) {
-            let commandName;
-            let commandFieldValues;
-            if (commandNode) {
-                const nameFromAttr = commandNode['@_name'];
-                const textContent = commandNode['#text'];
-                commandName = nameFromAttr ?? textContent ?? undefined;
-                commandFieldValues = parseFieldValuesFromNodes(asArray(commandNode['field']));
-            }
-            when = {
-                command: commandName || undefined,
-                commandFieldValues,
-                events: whenEvents.length > 0 ? whenEvents : undefined,
-            };
-        }
-    }
-    // Parse then
-    const thenNode = scenario['then'];
-    if (!thenNode) {
-        throw new Error('Invalid XML: missing <then> tag');
-    }
-    const thenType = thenNode['@_type'];
-    if (thenType !== 'error' &&
-        thenType !== 'events' &&
-        thenType !== 'readModelAssertion' &&
-        thenType !== 'command' &&
-        thenType !== 'noCommand') {
-        throw new Error('Invalid XML: <then> must have a type attribute');
-    }
-    const then = { type: thenType };
-    if (thenType === 'error') {
-        then.errorType = thenNode['@_errorType'];
-        const errorTypeNode = thenNode['errorType'];
-        if (!then.errorType && errorTypeNode) {
-            then.errorType = typeof errorTypeNode === 'string' ? errorTypeNode : errorTypeNode['#text'];
-        }
-        const messageNode = thenNode['message'];
-        if (messageNode) {
-            then.errorMessage = typeof messageNode === 'string' ? messageNode : messageNode['#text'];
-        }
-    }
-    else if (thenType === 'events') {
-        then.events = parseEventInputsFromNodes(asArray(thenNode['event']));
-    }
-    else if (thenType === 'command') {
-        const commandNodes = asArray(thenNode['command']);
-        const commandNode = commandNodes[0];
-        if (commandNode) {
-            const nameFromAttr = commandNode['@_name'];
-            const textContent = commandNode['#text'];
-            then.command = nameFromAttr ?? textContent ?? undefined;
-            then.commandFieldValues = parseFieldValuesFromNodes(asArray(commandNode['field']));
-        }
-    }
-    else if (thenType === 'readModelAssertion') {
-        const readModelNode = thenNode['read-model'];
-        if (readModelNode) {
-            const nameFromAttr = readModelNode['@_name'];
-            const textContent = readModelNode['#text'];
-            then.readModel = nameFromAttr ?? textContent ?? undefined;
-            const expectedNode = readModelNode['expected'];
-            const directFields = parseFieldValuesFromNodes(asArray(readModelNode['field']));
-            const expectedFields = expectedNode ? parseFieldValuesFromNodes(asArray(expectedNode['field'])) : undefined;
-            then.expected = {
-                ...(directFields ?? {}),
-                ...(expectedFields ?? {}),
-            };
-            const givenEventsNode = (readModelNode['given'] ?? readModelNode['given-events']);
-            if (givenEventsNode) {
-                then.givenEvents = parseEventInputsFromNodes(asArray(givenEventsNode['event']));
-            }
-        }
-    }
-    return {
-        name,
-        description,
-        given: given.length > 0 ? given : undefined,
-        when,
-        then,
-    };
-}
-export function parseScenarioInput(input) {
-    const trimmed = input.trim();
-    if (trimmed.startsWith('<')) {
-        return parseXmlInput(trimmed);
-    }
-    return parseJsonInput(trimmed);
-}

package/dist/slices/guide/guides/codegen.js

@@ -316,7 +316,7 @@ export class \${aggregate}Aggregate {
 eventmodeler codegen slice "Place Order" | node generator.js
 
 # All slices (bash loop)
-for slice in $(eventmodeler list slices --format json | node -e 'const fs=require("fs");const d=JSON.parse(fs.readFileSync(0,"utf8"));for(const s of (d.slices||[])) console.log(s.name)'); do
+for slice in $(eventmodeler list slices | node -e 'const fs=require("fs");const d=JSON.parse(fs.readFileSync(0,"utf8"));for(const s of (d.slices||[])) console.log(s.name)'); do
   eventmodeler codegen slice "$slice" | node generator.js
 done
 

package/dist/slices/guide/guides/connect-slices.js

@@ -50,30 +50,7 @@ eventmodeler create flow --from "<source>" --to "<target>"
 
 ### 1. Create Your Slices First
 
-\`\`\`bash
-# User places an order
-eventmodeler create state-change-slice --xml '<state-change-slice name="Place Order">
-  <screen name="Checkout">...</screen>
-  <command name="PlaceOrder">...</command>
-  <event name="OrderPlaced">...</event>
-</state-change-slice>'
-
-# View for order status
-eventmodeler create state-view-slice --xml '<state-view-slice name="View Order Status" after="Place Order">
-  <read-model name="OrderStatus">...</read-model>
-</state-view-slice>'
-
-# System automatically fulfills order (includes its own read model)
-eventmodeler create automation-slice --xml '<automation-slice name="Auto Fulfill" after="View Order Status">
-  <read-model name="OrderReadyToFulfill">
-    <field name="orderId" type="UUID"/>
-    <field name="isPaid" type="Boolean"/>
-  </read-model>
-  <processor name="Fulfillment Processor"/>
-  <command name="FulfillOrder">...</command>
-  <event name="OrderFulfilled">...</event>
-</automation-slice>'
-\`\`\`
+Build each slice by adding fields to its elements and connecting them with internal flows.
 
 ### 2. Connect Events to Read Models
 
@@ -115,11 +92,11 @@ eventmodeler create flow --from "OrderStatus" --to "Order Details Screen"
 After creating flows, map the fields:
 
 \`\`\`bash
-eventmodeler map fields --flow "OrderPlaced→OrderStatus" --xml '
-  <mapping from="orderId" to="orderId"/>
-  <mapping from="customerId" to="customerId"/>
-  <mapping from="placedAt" to="placedAt"/>
-'
+eventmodeler map fields --from "OrderPlaced" --to "OrderStatus" '[
+  {"from": "orderId", "to": "orderId"},
+  {"from": "customerId", "to": "customerId"},
+  {"from": "placedAt", "to": "placedAt"}
+]'
 \`\`\`
 
 ### 6. Verify Completeness
@@ -140,11 +117,9 @@ When multiple elements share the same name (e.g., linked copies of events or rea
 \`\`\`bash
 # List events with their IDs
 eventmodeler list events
-# Output:
-# <events>
-#   <event id="abc12345-..." name="OrderPlaced" fields="4"/>
-#   <event id="def67890-..." name="OrderPlaced" fields="4"/>  <!-- linked copy -->
-# </events>
+# Output includes id and name for each event, e.g.:
+# [{"id": "abc12345-...", "name": "OrderPlaced", "fields": 4},
+#  {"id": "def67890-...", "name": "OrderPlaced", "fields": 4}]
 \`\`\`
 
 ### Using IDs in Commands
@@ -156,9 +131,9 @@ Prefix the ID (or ID prefix) with \`id:\`:
 eventmodeler create flow --from "id:abc12345" --to "OrderStatus"
 
 # Map fields using ID prefix
-eventmodeler map fields --flow "id:abc12345→OrderStatus" --xml '
-  <mapping from="orderId" to="orderId"/>
-'
+eventmodeler map fields --from "id:abc12345" --to "OrderStatus" '[
+  {"from": "orderId", "to": "orderId"}
+]'
 \`\`\`
 
 ### When the CLI Finds Duplicates