eventmodeler 0.6.0 → 0.6.2

package/dist/lib/excalidraw-schema.js

@@ -1,66 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,103 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-const PROJECT_CONFIG_FILENAME = '.eventmodeler.json';
-/**
- * Find .eventmodeler.json by walking up from cwd to find the repo root.
- * Returns the path to the config file if found, null otherwise.
- */
-export function findProjectConfigPath(startDir = process.cwd()) {
-    let dir = path.resolve(startDir);
-    const root = path.parse(dir).root;
-    while (dir !== root) {
-        const configPath = path.join(dir, PROJECT_CONFIG_FILENAME);
-        if (fs.existsSync(configPath)) {
-            return configPath;
-        }
-        // Also check if we're at a git repo root (stop searching)
-        const gitDir = path.join(dir, '.git');
-        if (fs.existsSync(gitDir)) {
-            // We're at the git root but no config found
-            return null;
-        }
-        dir = path.dirname(dir);
-    }
-    return null;
-}
-/**
- * Load the project config from the nearest .eventmodeler.json file.
- */
-export function loadProjectConfig(startDir) {
-    const configPath = findProjectConfigPath(startDir);
-    if (!configPath)
-        return null;
-    try {
-        const content = fs.readFileSync(configPath, 'utf-8');
-        const config = JSON.parse(content);
-        // Validate config structure
-        if (config.type === 'cloud' && config.modelId && config.modelName) {
-            return { type: 'cloud', modelId: config.modelId, modelName: config.modelName };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Save a project config to the current directory or specified path.
- */
-export function saveProjectConfig(config, targetDir = process.cwd()) {
-    const configPath = path.join(targetDir, PROJECT_CONFIG_FILENAME);
-    const content = { type: 'cloud', modelId: config.modelId, modelName: config.modelName };
-    fs.writeFileSync(configPath, JSON.stringify(content, null, 2) + '\n');
-    return configPath;
-}
-/**
- * Get the project root directory (where .eventmodeler.json is or should be).
- * Falls back to git root or current directory.
- */
-export function getProjectRoot(startDir = process.cwd()) {
-    // First try to find existing config
-    const configPath = findProjectConfigPath(startDir);
-    if (configPath) {
-        return path.dirname(configPath);
-    }
-    // Otherwise find git root
-    let dir = path.resolve(startDir);
-    const root = path.parse(dir).root;
-    while (dir !== root) {
-        const gitDir = path.join(dir, '.git');
-        if (fs.existsSync(gitDir)) {
-            return dir;
-        }
-        dir = path.dirname(dir);
-    }
-    // Fall back to current directory
-    return process.cwd();
-}
-/**
- * Check if the current directory is within a project with .eventmodeler.json.
- */
-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

@@ -1,59 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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,103 +0,0 @@
-function asRecord(value, context) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error(`${context} must be an object`);
-    }
-    return value;
-}
-function parseEventInput(value, context) {
-    if (typeof value === 'string') {
-        return { event: value };
-    }
-    const map = asRecord(value, context);
-    const eventName = map.event ?? map.name ?? map.eventName;
-    if (typeof eventName !== 'string' || eventName.trim() === '') {
-        throw new Error(`${context} must include an event name`);
-    }
-    const fieldValues = map.fieldValues ?? map.fields;
-    if (fieldValues === undefined) {
-        return { event: eventName };
-    }
-    if (!fieldValues || typeof fieldValues !== 'object' || Array.isArray(fieldValues)) {
-        throw new Error(`${context}.fieldValues must be an object`);
-    }
-    return { event: eventName, fieldValues: fieldValues };
-}
-function parseEventInputs(value, context) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (!Array.isArray(value)) {
-        throw new Error(`${context} must be an array`);
-    }
-    return value.map((entry, index) => parseEventInput(entry, `${context}[${index}]`));
-}
-function parseCommandName(value, context) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value === 'string')
-        return value;
-    const map = asRecord(value, context);
-    const name = map.name ?? map.command;
-    if (typeof name !== 'string' || name.trim() === '') {
-        throw new Error(`${context} must include a command name`);
-    }
-    return name;
-}
-function parseObjectValue(value, context) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error(`${context} must be an object`);
-    }
-    return value;
-}
-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');
-    }
-    const given = Array.isArray(raw.given)
-        ? parseEventInputs(raw.given, 'scenario.given')
-        : raw.given && typeof raw.given === 'object'
-            ? parseEventInputs(raw.given.events, 'scenario.given.events')
-            : undefined;
-    const whenRaw = raw.when && typeof raw.when === 'object'
-        ? raw.when
-        : undefined;
-    const whenCommand = parseCommandName(whenRaw?.command, 'scenario.when.command');
-    const whenCommandFieldValues = parseObjectValue(whenRaw?.commandFieldValues ?? whenRaw?.command?.fieldValues, 'scenario.when.commandFieldValues');
-    const whenEvents = parseEventInputs(whenRaw?.events, 'scenario.when.events');
-    const thenRaw = asRecord(raw.then, 'scenario.then');
-    const thenType = thenRaw.type;
-    if (thenType !== 'error' &&
-        thenType !== 'events' &&
-        thenType !== 'readModelAssertion' &&
-        thenType !== 'command' &&
-        thenType !== 'noCommand') {
-        throw new Error('scenario.then.type must be one of: error, events, readModelAssertion, command, noCommand');
-    }
-    const readModelAssertionRaw = thenRaw.readModelAssertion && typeof thenRaw.readModelAssertion === 'object'
-        ? thenRaw.readModelAssertion
-        : undefined;
-    const then = {
-        type: thenType,
-        errorMessage: typeof thenRaw.errorMessage === 'string' ? thenRaw.errorMessage : undefined,
-        errorType: typeof thenRaw.errorType === 'string' ? thenRaw.errorType : undefined,
-        events: parseEventInputs(thenRaw.events, 'scenario.then.events'),
-        command: parseCommandName(thenRaw.command, 'scenario.then.command'),
-        commandFieldValues: parseObjectValue(thenRaw.commandFieldValues ?? thenRaw.command?.fieldValues, 'scenario.then.commandFieldValues'),
-        readModel: (thenRaw.readModel
-            ?? readModelAssertionRaw?.readModel
-            ?? readModelAssertionRaw?.readModelName
-            ?? readModelAssertionRaw?.readModelStickyId),
-        givenEvents: parseEventInputs(thenRaw.givenEvents ?? readModelAssertionRaw?.givenEvents, 'scenario.then.givenEvents'),
-        expected: parseObjectValue(thenRaw.expected ?? thenRaw.expectedFieldValues ?? readModelAssertionRaw?.expectedFieldValues, 'scenario.then.expected'),
-    };
-    return {
-        name,
-        description: typeof raw.description === 'string' ? raw.description : undefined,
-        given,
-        when: whenRaw ? { command: whenCommand, commandFieldValues: whenCommandFieldValues, events: whenEvents } : undefined,
-        then,
-    };
-}