eventmodeler 0.5.0 → 0.6.1

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

@@ -1,8 +0,0 @@
-import type { EventModel } from '../../types.js';
-export declare function addField(model: EventModel, filePath: string, options: {
-    command?: string;
-    event?: string;
-    readModel?: string;
-    screen?: string;
-    processor?: string;
-}, input: string): void;

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

@@ -1,211 +0,0 @@
-import * as crypto from 'node:crypto';
-import { appendEvent } from '../../lib/file-loader.js';
-import { findElementOrExit, excludeLinkedCopies } from '../../lib/element-lookup.js';
-const validFieldTypes = ['UUID', 'Boolean', 'Double', 'Decimal', 'Date', 'DateTime', 'Long', 'Int', 'String', 'Custom'];
-function parseJsonInput(input) {
-    return JSON.parse(input);
-}
-function parseXmlInput(input) {
-    const getAttr = (tag, attr) => {
-        const match = tag.match(new RegExp(`${attr}="([^"]*)"`));
-        return match ? match[1] : undefined;
-    };
-    const getBoolAttr = (tag, attr) => {
-        const value = getAttr(tag, attr);
-        if (value === 'true')
-            return true;
-        if (value === 'false')
-            return false;
-        return undefined;
-    };
-    const fieldMatch = input.match(/<field([^>]*?)(?:\/>|>([\s\S]*?)<\/field>)/);
-    if (!fieldMatch) {
-        throw new Error('Invalid XML: missing <field> tag');
-    }
-    const name = getAttr(fieldMatch[1], 'name');
-    if (!name) {
-        throw new Error('Invalid XML: field must have a name attribute');
-    }
-    const type = getAttr(fieldMatch[1], 'type');
-    if (!type) {
-        throw new Error('Invalid XML: field must have a type attribute');
-    }
-    const fieldInput = {
-        name,
-        type,
-        isList: getBoolAttr(fieldMatch[1], 'isList'),
-        isGenerated: getBoolAttr(fieldMatch[1], 'isGenerated'),
-        isOptional: getBoolAttr(fieldMatch[1], 'isOptional'),
-        isUserInput: getBoolAttr(fieldMatch[1], 'isUserInput'),
-    };
-    // Parse nested subfields for Custom type
-    if (type === 'Custom' && fieldMatch[2]) {
-        fieldInput.subfields = [];
-        const subfieldMatches = fieldMatch[2].matchAll(/<field([^>]*?)(?:\/>|>([\s\S]*?)<\/field>)/g);
-        for (const match of subfieldMatches) {
-            const subfieldXml = match[0];
-            fieldInput.subfields.push(parseXmlInput(subfieldXml));
-        }
-    }
-    return fieldInput;
-}
-function parseInput(input) {
-    const trimmed = input.trim();
-    if (trimmed.startsWith('<')) {
-        return parseXmlInput(trimmed);
-    }
-    return parseJsonInput(trimmed);
-}
-function createFieldFromInput(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(createFieldFromInput),
-    };
-}
-export function addField(model, filePath, options, input) {
-    // Determine which entity type
-    const entityCount = [options.command, options.event, options.readModel, options.screen, options.processor].filter(Boolean).length;
-    if (entityCount === 0) {
-        console.error('Error: Must specify one of --command, --event, --read-model, --screen, or --processor');
-        process.exit(1);
-    }
-    if (entityCount > 1) {
-        console.error('Error: Can only specify one of --command, --event, --read-model, --screen, or --processor');
-        process.exit(1);
-    }
-    // Parse input
-    let fieldInput;
-    try {
-        fieldInput = parseInput(input);
-    }
-    catch (err) {
-        console.error(`Error: Invalid input format: ${err.message}`);
-        process.exit(1);
-    }
-    // Validate field type
-    if (!validFieldTypes.includes(fieldInput.type)) {
-        console.error(`Error: Invalid field type: ${fieldInput.type}`);
-        console.error(`Valid types: ${validFieldTypes.join(', ')}`);
-        const typeLower = fieldInput.type.toLowerCase();
-        if (typeLower === 'list' || typeLower === 'array') {
-            console.error(`\nHint: To make a field a list/array, use isList="true" with a valid type:`);
-            console.error(`  <field name="items" type="String" isList="true"/>`);
-        }
-        process.exit(1);
-    }
-    // Find entity and add field
-    if (options.command) {
-        addFieldToCommand(model, filePath, options.command, fieldInput);
-    }
-    else if (options.event) {
-        addFieldToEvent(model, filePath, options.event, fieldInput);
-    }
-    else if (options.readModel) {
-        addFieldToReadModel(model, filePath, options.readModel, fieldInput);
-    }
-    else if (options.screen) {
-        addFieldToScreen(model, filePath, options.screen, fieldInput);
-    }
-    else if (options.processor) {
-        addFieldToProcessor(model, filePath, options.processor, fieldInput);
-    }
-}
-function addFieldToCommand(model, filePath, commandName, fieldInput) {
-    const command = findElementOrExit(model.commands, commandName, 'command');
-    // Check for duplicate field name
-    if (command.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
-        console.error(`Error: Field "${fieldInput.name}" already exists on command "${command.name}"`);
-        process.exit(1);
-    }
-    const field = createFieldFromInput(fieldInput);
-    appendEvent(filePath, {
-        type: 'CommandFieldAdded',
-        data: {
-            commandStickyId: command.id,
-            field,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Added field "${field.name}" to command "${command.name}"`);
-}
-function addFieldToEvent(model, filePath, eventName, fieldInput) {
-    // Exclude linked copies - they share fields with their canonical original
-    const event = findElementOrExit(excludeLinkedCopies(model.events), eventName, 'event');
-    // Check for duplicate field name
-    if (event.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
-        console.error(`Error: Field "${fieldInput.name}" already exists on event "${event.name}"`);
-        process.exit(1);
-    }
-    const field = createFieldFromInput(fieldInput);
-    appendEvent(filePath, {
-        type: 'EventFieldAdded',
-        data: {
-            eventStickyId: event.id,
-            field,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Added field "${field.name}" to event "${event.name}"`);
-}
-function addFieldToReadModel(model, filePath, readModelName, fieldInput) {
-    // Exclude linked copies - they share fields with their canonical original
-    const readModel = findElementOrExit(excludeLinkedCopies(model.readModels), readModelName, 'read model');
-    // Check for duplicate field name
-    if (readModel.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
-        console.error(`Error: Field "${fieldInput.name}" already exists on read model "${readModel.name}"`);
-        process.exit(1);
-    }
-    const field = createFieldFromInput(fieldInput);
-    appendEvent(filePath, {
-        type: 'ReadModelFieldAdded',
-        data: {
-            readModelStickyId: readModel.id,
-            field,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Added field "${field.name}" to read model "${readModel.name}"`);
-}
-function addFieldToScreen(model, filePath, screenName, fieldInput) {
-    // Exclude linked copies - they share fields with their canonical original
-    const screen = findElementOrExit(excludeLinkedCopies(model.screens), screenName, 'screen');
-    // Check for duplicate field name
-    if (screen.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
-        console.error(`Error: Field "${fieldInput.name}" already exists on screen "${screen.name}"`);
-        process.exit(1);
-    }
-    const field = createFieldFromInput(fieldInput);
-    appendEvent(filePath, {
-        type: 'ScreenFieldAdded',
-        data: {
-            screenId: screen.id,
-            field,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Added field "${field.name}" to screen "${screen.name}"`);
-}
-function addFieldToProcessor(model, filePath, processorName, fieldInput) {
-    const processor = findElementOrExit(model.processors, processorName, 'processor');
-    // Check for duplicate field name
-    if (processor.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
-        console.error(`Error: Field "${fieldInput.name}" already exists on processor "${processor.name}"`);
-        process.exit(1);
-    }
-    const field = createFieldFromInput(fieldInput);
-    appendEvent(filePath, {
-        type: 'ProcessorFieldAdded',
-        data: {
-            processorId: processor.id,
-            field,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Added field "${field.name}" to processor "${processor.name}"`);
-}

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

@@ -1,27 +0,0 @@
-export interface ScenarioInput {
-    name: string;
-    description?: string;
-    given?: EventInput[];
-    when?: {
-        command?: string;
-        commandFieldValues?: Record<string, unknown>;
-        events?: EventInput[];
-    };
-    then: {
-        type: 'error' | 'events' | 'readModelAssertion' | 'command' | 'noCommand';
-        errorMessage?: string;
-        errorType?: string;
-        events?: EventInput[];
-        command?: string;
-        commandFieldValues?: Record<string, unknown>;
-        readModel?: string;
-        givenEvents?: EventInput[];
-        expected?: Record<string, unknown>;
-    };
-}
-interface EventInput {
-    event: string;
-    fieldValues?: Record<string, unknown>;
-}
-export declare function parseScenarioInput(input: string): ScenarioInput;
-export {};

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

@@ -1,307 +0,0 @@
-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 };
-    }
-    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;
-}
-function normalizeScenarioInput(rawValue) {
-    const raw = asRecord(rawValue, '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,
-    };
-}
-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/codegen-chapter-events/index.d.ts

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