eventmodeler 0.5.0 → 0.6.0

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/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;

package/dist/slices/codegen-chapter-events/index.js

@@ -1,145 +0,0 @@
-import { outputJson } from '../../lib/format.js';
-import { findElementOrExit } from '../../lib/element-lookup.js';
-import { getChapterHierarchy } from '../../lib/chapter-utils.js';
-function countFieldsDeep(fields) {
-    if (!fields || fields.length === 0) {
-        return 0;
-    }
-    return fields.reduce((count, field) => count + 1 + countFieldsDeep(field.subfields), 0);
-}
-function normalizeName(name) {
-    return name.trim().toLowerCase();
-}
-function fieldToJson(field) {
-    const result = {
-        name: field.name,
-        type: field.fieldType,
-    };
-    if (field.isList)
-        result.list = true;
-    if (field.isGenerated)
-        result.generated = true;
-    if (field.isOptional)
-        result.optional = true;
-    if (field.isUserInput)
-        result.userInput = true;
-    if (field.subfields && field.subfields.length > 0) {
-        result.subfields = field.subfields.map(fieldToJson);
-    }
-    return result;
-}
-function isCenterInSlice(slice, x, y, width, height) {
-    const centerX = x + width / 2;
-    const centerY = y + height / 2;
-    return (centerX >= slice.position.x &&
-        centerX <= slice.position.x + slice.size.width &&
-        centerY >= slice.position.y &&
-        centerY <= slice.position.y + slice.size.height);
-}
-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()) {
-        if (centerX >= aggregate.position.x &&
-            centerX <= aggregate.position.x + aggregate.size.width &&
-            centerY >= aggregate.position.y &&
-            centerY <= aggregate.position.y + aggregate.size.height) {
-            return aggregate.name;
-        }
-    }
-    return undefined;
-}
-function determineSliceType(model, slice) {
-    const hasProcessors = [...model.processors.values()].some(processor => isCenterInSlice(slice, processor.position.x, processor.position.y, processor.width, processor.height));
-    if (hasProcessors) {
-        return 'AUTOMATION';
-    }
-    const hasCommands = [...model.commands.values()].some(command => isCenterInSlice(slice, command.position.x, command.position.y, command.width, command.height));
-    const hasEvents = [...model.events.values()].some(event => !event.originalNodeId && isCenterInSlice(slice, event.position.x, event.position.y, event.width, event.height));
-    if (hasCommands && hasEvents) {
-        return 'STATE_CHANGE';
-    }
-    return 'STATE_VIEW';
-}
-function getSlicesUnderChapter(model, chapter) {
-    const chapterLeft = chapter.position.x;
-    const chapterRight = chapter.position.x + chapter.size.width;
-    return [...model.slices.values()].filter(slice => {
-        const sliceCenterX = slice.position.x + slice.size.width / 2;
-        return sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight;
-    });
-}
-function codegenChapterEvents(model, chapterName) {
-    const chapter = findElementOrExit(model.chapters, chapterName, 'chapter');
-    const chapterHierarchy = getChapterHierarchy(model, chapter);
-    const slices = getSlicesUnderChapter(model, chapter).sort((a, b) => a.position.x - b.position.x);
-    outputEventsFromSlices(model, slices, chapterHierarchy);
-}
-export function codegenEvents(model, chapterName) {
-    if (chapterName) {
-        codegenChapterEvents(model, chapterName);
-        return;
-    }
-    const slices = [...model.slices.values()].sort((a, b) => {
-        if (a.position.x === b.position.x) {
-            return a.position.y - b.position.y;
-        }
-        return a.position.x - b.position.x;
-    });
-    outputEventsFromSlices(model, slices, null);
-}
-function outputEventsFromSlices(model, slices, chapterHierarchy) {
-    const eventsByName = new Map();
-    const sliceSummaries = [];
-    for (const slice of slices) {
-        sliceSummaries.push({
-            id: slice.id,
-            name: slice.name,
-            sliceType: determineSliceType(model, slice),
-        });
-        const sliceEvents = [...model.events.values()].filter(event => !event.originalNodeId &&
-            isCenterInSlice(slice, event.position.x, event.position.y, event.width, event.height));
-        for (const event of sliceEvents) {
-            const key = normalizeName(event.name);
-            if (!key) {
-                continue;
-            }
-            const eventFields = event.fields.map(fieldToJson);
-            const existing = eventsByName.get(key);
-            if (!existing) {
-                eventsByName.set(key, {
-                    id: event.id,
-                    name: event.name,
-                    fields: eventFields,
-                    aggregate: findAggregateForEvent(model, event),
-                    sourceSlices: [slice.name],
-                });
-                continue;
-            }
-            if (!existing.sourceSlices.includes(slice.name)) {
-                existing.sourceSlices.push(slice.name);
-            }
-            if (!existing.aggregate) {
-                existing.aggregate = findAggregateForEvent(model, event);
-            }
-            if (countFieldsDeep(eventFields) > countFieldsDeep(existing.fields)) {
-                existing.fields = eventFields;
-            }
-            if (!existing.id) {
-                existing.id = event.id;
-            }
-        }
-    }
-    const events = [...eventsByName.values()]
-        .map(event => ({ ...event, sourceSlices: [...event.sourceSlices].sort((a, b) => a.localeCompare(b)) }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-    const sortedSlices = [...sliceSummaries].sort((a, b) => a.name.localeCompare(b.name));
-    const output = {
-        chapter: chapterHierarchy,
-        sliceCount: sortedSlices.length,
-        eventCount: events.length,
-        slices: sortedSlices,
-        events,
-    };
-    outputJson(output);
-}

package/dist/slices/codegen-slice/index.d.ts

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