eventmodeler 0.5.0 → 0.6.1

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;

package/dist/slices/codegen-slice/index.js

@@ -1,448 +0,0 @@
-import { outputJson } from '../../lib/format.js';
-import { findElementOrExit } from '../../lib/element-lookup.js';
-import { findChapterForSlice, getChapterHierarchy } from '../../lib/chapter-utils.js';
-// Get components inside a slice by checking if center point is within bounds
-function getSliceComponents(model, slice) {
-    const bounds = {
-        left: slice.position.x,
-        right: slice.position.x + slice.size.width,
-        top: slice.position.y,
-        bottom: slice.position.y + slice.size.height,
-    };
-    function isInSlice(pos, width, height) {
-        const centerX = pos.x + width / 2;
-        const centerY = pos.y + height / 2;
-        return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
-    }
-    // Only include canonical elements - linked copies are UI-only conveniences
-    // and should not appear as slice contents in codegen output
-    return {
-        commands: [...model.commands.values()].filter(c => isInSlice(c.position, c.width, c.height)),
-        events: [...model.events.values()].filter(e => !e.originalNodeId && isInSlice(e.position, e.width, e.height)),
-        readModels: [...model.readModels.values()].filter(rm => !rm.originalNodeId && isInSlice(rm.position, rm.width, rm.height)),
-        screens: [...model.screens.values()].filter(s => !s.originalNodeId && isInSlice(s.position, s.width, s.height)),
-        processors: [...model.processors.values()].filter(p => isInSlice(p.position, p.width, p.height)),
-    };
-}
-// Find which slice contains a node
-function findSliceForNode(model, nodeId) {
-    const event = model.events.get(nodeId);
-    const readModel = model.readModels.get(nodeId);
-    const screen = model.screens.get(nodeId);
-    const command = model.commands.get(nodeId);
-    const processor = model.processors.get(nodeId);
-    const node = event ?? readModel ?? screen ?? command ?? processor;
-    if (!node)
-        return null;
-    for (const slice of model.slices.values()) {
-        const centerX = node.position.x + node.width / 2;
-        const centerY = node.position.y + node.height / 2;
-        if (centerX >= slice.position.x &&
-            centerX <= slice.position.x + slice.size.width &&
-            centerY >= slice.position.y &&
-            centerY <= slice.position.y + slice.size.height) {
-            return slice;
-        }
-    }
-    return null;
-}
-// Find which aggregate an event belongs to
-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;
-}
-// Find which actor a screen belongs to
-function findActorForScreen(model, screen) {
-    const centerX = screen.position.x + screen.width / 2;
-    const centerY = screen.position.y + screen.height / 2;
-    for (const actor of model.actors.values()) {
-        if (centerX >= actor.position.x &&
-            centerX <= actor.position.x + actor.size.width &&
-            centerY >= actor.position.y &&
-            centerY <= actor.position.y + actor.size.height) {
-            return actor.name;
-        }
-    }
-    return undefined;
-}
-// Convert Field to JSON-friendly format
-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;
-}
-// Determine slice type based on components, returns null for invalid configurations
-function determineSliceType(hasProcessors, hasCommands, hasEvents, hasReadModels, hasScreens) {
-    // AUTOMATION: Must have a Processor (and typically ReadModel, Command, Event)
-    if (hasProcessors)
-        return 'AUTOMATION';
-    // STATE_CHANGE: Must have both Command and Event (typically with Screen)
-    if (hasCommands && hasEvents)
-        return 'STATE_CHANGE';
-    // STATE_VIEW: Must have at least one ReadModel
-    if (hasReadModels && !hasCommands && !hasEvents)
-        return 'STATE_VIEW';
-    // Invalid configurations:
-    // - Empty slice
-    // - Only Command (no Event)
-    // - Only Event (no Command)
-    // - Only Screen (no Command)
-    return null;
-}
-// Get element type for an ID
-function getElementType(model, id) {
-    if (model.commands.has(id))
-        return 'COMMAND';
-    if (model.events.has(id))
-        return 'EVENT';
-    if (model.readModels.has(id))
-        return 'READMODEL';
-    if (model.screens.has(id))
-        return 'SCREEN';
-    if (model.processors.has(id))
-        return 'PROCESSOR';
-    return null;
-}
-// Get element name for an ID
-function getElementName(model, id) {
-    return (model.commands.get(id)?.name ??
-        model.events.get(id)?.name ??
-        model.readModels.get(id)?.name ??
-        model.screens.get(id)?.name ??
-        model.processors.get(id)?.name ??
-        'Unknown');
-}
-// Get element fields for an ID
-function getElementFields(model, id) {
-    return (model.commands.get(id)?.fields ??
-        model.events.get(id)?.fields ??
-        model.readModels.get(id)?.fields ??
-        model.screens.get(id)?.fields ??
-        model.processors.get(id)?.fields ??
-        []);
-}
-// Find a field by ID within an element's fields
-function findFieldById(fields, fieldId) {
-    for (const field of fields) {
-        if (field.id === fieldId)
-            return field;
-        if (field.subfields) {
-            const found = findFieldById(field.subfields, fieldId);
-            if (found)
-                return found;
-        }
-    }
-    return undefined;
-}
-// Get element reference (type, id, name)
-function getElementRef(model, id) {
-    return {
-        type: getElementType(model, id) ?? 'EVENT',
-        id,
-        name: getElementName(model, id),
-    };
-}
-// Get element with full schema
-function getElementWithSchema(model, id) {
-    const type = getElementType(model, id) ?? 'EVENT';
-    const name = getElementName(model, id);
-    const fields = getElementFields(model, id).map(fieldToJson);
-    const result = { type, id, name, fields };
-    // Add aggregate info for events
-    const event = model.events.get(id);
-    if (event) {
-        const aggregate = findAggregateForEvent(model, event);
-        if (aggregate)
-            result.aggregate = aggregate;
-        const originSlice = findSliceForNode(model, id);
-        if (originSlice)
-            result.originSlice = originSlice.name;
-    }
-    // Add actor info for screens
-    const screen = model.screens.get(id);
-    if (screen) {
-        const actor = findActorForScreen(model, screen);
-        if (actor)
-            result.actor = actor;
-    }
-    return result;
-}
-// Enrich field mappings with field names
-function enrichFieldMappings(model, flow) {
-    const sourceFields = getElementFields(model, flow.sourceId);
-    const targetFields = getElementFields(model, flow.targetId);
-    return flow.fieldMappings.map(mapping => {
-        const sourceField = findFieldById(sourceFields, mapping.sourceFieldId);
-        const targetField = findFieldById(targetFields, mapping.targetFieldId);
-        return {
-            sourceFieldId: mapping.sourceFieldId,
-            sourceFieldName: sourceField?.name ?? 'unknown',
-            targetFieldId: mapping.targetFieldId,
-            targetFieldName: targetField?.name ?? 'unknown',
-        };
-    });
-}
-// Get inbound dependencies (flows where target is in slice but source is not)
-function getInboundDependencies(model, componentIds) {
-    return [...model.flows.values()]
-        .filter(f => componentIds.has(f.targetId) && !componentIds.has(f.sourceId))
-        .map(flow => ({
-        flowId: flow.id,
-        flowType: flow.flowType,
-        source: getElementWithSchema(model, flow.sourceId),
-        target: getElementRef(model, flow.targetId),
-        fieldMappings: enrichFieldMappings(model, flow),
-    }));
-}
-// Get internal flows (both source and target are in slice)
-function getInternalFlows(model, componentIds) {
-    return [...model.flows.values()]
-        .filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId))
-        .map(flow => ({
-        flowId: flow.id,
-        flowType: flow.flowType,
-        source: getElementRef(model, flow.sourceId),
-        target: getElementRef(model, flow.targetId),
-        fieldMappings: enrichFieldMappings(model, flow),
-    }));
-}
-// Format scenario then clause
-function formatScenarioThen(model, then) {
-    if (then.type === 'error') {
-        return {
-            type: 'error',
-            errorType: then.errorType,
-            errorMessage: then.errorMessage,
-        };
-    }
-    if (then.type === 'events' && then.expectedEvents) {
-        return {
-            type: 'events',
-            expectedEvents: then.expectedEvents.map(expected => {
-                const event = model.events.get(expected.eventStickyId);
-                return {
-                    eventId: expected.eventStickyId,
-                    eventName: event?.name ?? 'UnknownEvent',
-                    eventSchema: { fields: event?.fields.map(fieldToJson) ?? [] },
-                    fieldValues: expected.fieldValues ?? {},
-                };
-            }),
-        };
-    }
-    if (then.type === 'command' && then.expectedCommand) {
-        const command = model.commands.get(then.expectedCommand.commandStickyId);
-        return {
-            type: 'command',
-            expectedCommand: {
-                commandId: then.expectedCommand.commandStickyId,
-                commandName: command?.name ?? 'UnknownCommand',
-                commandSchema: { fields: command?.fields.map(fieldToJson) ?? [] },
-                fieldValues: then.expectedCommand.fieldValues ?? {},
-            },
-        };
-    }
-    if (then.type === 'noCommand') {
-        return {
-            type: 'noCommand',
-        };
-    }
-    if (then.type === 'readModelAssertion' && then.readModelAssertion) {
-        const rm = model.readModels.get(then.readModelAssertion.readModelStickyId);
-        return {
-            type: 'readModelAssertion',
-            readModelName: rm?.name ?? 'UnknownReadModel',
-            expectedFieldValues: then.readModelAssertion.expectedFieldValues,
-        };
-    }
-    // Default fallback
-    return { type: 'events', expectedEvents: [] };
-}
-// Format scenarios with resolved schemas
-function formatScenarios(model, scenarios) {
-    return scenarios.map(scenario => ({
-        id: scenario.id,
-        name: scenario.name,
-        description: scenario.description,
-        given: scenario.givenEvents.map(ref => {
-            const event = model.events.get(ref.eventStickyId);
-            const originSlice = findSliceForNode(model, ref.eventStickyId);
-            return {
-                eventId: ref.eventStickyId,
-                eventName: event?.name ?? 'UnknownEvent',
-                originSlice: originSlice?.name ?? null,
-                eventSchema: { fields: event?.fields.map(fieldToJson) ?? [] },
-                fieldValues: ref.fieldValues ?? {},
-            };
-        }),
-        whenCommand: scenario.whenCommand
-            ? {
-                commandId: scenario.whenCommand.commandStickyId,
-                commandName: model.commands.get(scenario.whenCommand.commandStickyId)?.name ?? 'UnknownCommand',
-                fieldValues: scenario.whenCommand.fieldValues ?? {},
-            }
-            : null,
-        whenEvents: scenario.whenEvents.map(ref => {
-            const event = model.events.get(ref.eventStickyId);
-            const originSlice = findSliceForNode(model, ref.eventStickyId);
-            return {
-                eventId: ref.eventStickyId,
-                eventName: event?.name ?? 'UnknownEvent',
-                originSlice: originSlice?.name ?? null,
-                eventSchema: { fields: event?.fields.map(fieldToJson) ?? [] },
-                fieldValues: ref.fieldValues ?? {},
-            };
-        }),
-        then: formatScenarioThen(model, scenario.then),
-    }));
-}
-export function codegenSlice(model, sliceName) {
-    // 1. Find the slice
-    const slice = findElementOrExit(model.slices, sliceName, 'slice');
-    // 2. Get components inside slice
-    const components = getSliceComponents(model, slice);
-    // 3. Build component ID set (including canonical group members for linked copies)
-    const componentIds = new Set();
-    components.commands.forEach(c => componentIds.add(c.id));
-    components.events.forEach(e => {
-        componentIds.add(e.id);
-        // If this is a linked copy, also add all elements in the same canonical group
-        if (e.canonicalId) {
-            for (const evt of model.events.values()) {
-                if (evt.canonicalId === e.canonicalId) {
-                    componentIds.add(evt.id);
-                }
-            }
-        }
-    });
-    components.readModels.forEach(rm => {
-        componentIds.add(rm.id);
-        // If this is a linked copy, also add all elements in the same canonical group
-        if (rm.canonicalId) {
-            for (const r of model.readModels.values()) {
-                if (r.canonicalId === rm.canonicalId) {
-                    componentIds.add(r.id);
-                }
-            }
-        }
-    });
-    components.screens.forEach(s => {
-        componentIds.add(s.id);
-        // If this is a linked copy, also add all elements in the same canonical group
-        if (s.canonicalId) {
-            for (const scr of model.screens.values()) {
-                if (scr.canonicalId === s.canonicalId) {
-                    componentIds.add(scr.id);
-                }
-            }
-        }
-    });
-    components.processors.forEach(p => componentIds.add(p.id));
-    // 4. Determine slice type
-    const sliceType = determineSliceType(components.processors.length > 0, components.commands.length > 0, components.events.length > 0, components.readModels.length > 0, components.screens.length > 0);
-    // Validate slice type - exit with error for invalid configurations
-    if (sliceType === null) {
-        const hasAny = componentIds.size > 0;
-        if (!hasAny) {
-            console.error(`Error: Slice "${slice.name}" is empty - no elements found inside slice bounds`);
-        }
-        else {
-            const parts = [];
-            if (components.commands.length > 0)
-                parts.push(`${components.commands.length} command(s)`);
-            if (components.events.length > 0)
-                parts.push(`${components.events.length} event(s)`);
-            if (components.screens.length > 0)
-                parts.push(`${components.screens.length} screen(s)`);
-            if (components.readModels.length > 0)
-                parts.push(`${components.readModels.length} read model(s)`);
-            console.error(`Error: Slice "${slice.name}" has invalid configuration for codegen: ${parts.join(', ')}`);
-            console.error('Valid configurations:');
-            console.error('  AUTOMATION:   Processor + ReadModel + Command + Event');
-            console.error('  STATE_CHANGE: Screen + Command + Event');
-            console.error('  STATE_VIEW:   ReadModel only');
-        }
-        process.exit(1);
-    }
-    // 5. Get inbound dependencies with full schemas
-    const inboundDependencies = getInboundDependencies(model, componentIds);
-    // 6. Get internal flows with field mappings
-    const internalFlows = getInternalFlows(model, componentIds);
-    // 7. Get scenarios for this slice
-    const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
-    // 8. Find which chapter this slice belongs to
-    const chapter = findChapterForSlice(model, slice);
-    // 9. Build output
-    const output = {
-        sliceType,
-        slice: {
-            id: slice.id,
-            name: slice.name,
-        },
-        ...(chapter && { chapter: getChapterHierarchy(model, chapter) }),
-        elements: {
-            readModels: components.readModels.map(rm => ({
-                id: rm.id,
-                name: rm.name,
-                fields: rm.fields.map(fieldToJson),
-            })),
-            processors: components.processors.map(p => ({
-                id: p.id,
-                name: p.name,
-            })),
-            commands: components.commands.map(cmd => ({
-                id: cmd.id,
-                name: cmd.name,
-                fields: cmd.fields.map(fieldToJson),
-            })),
-            events: components.events.map(evt => {
-                const result = {
-                    id: evt.id,
-                    name: evt.name,
-                    fields: evt.fields.map(fieldToJson),
-                };
-                const aggregate = findAggregateForEvent(model, evt);
-                if (aggregate)
-                    result.aggregate = aggregate;
-                return result;
-            }),
-            screens: components.screens.map(scr => {
-                const result = {
-                    id: scr.id,
-                    name: scr.name,
-                    fields: scr.fields.map(fieldToJson),
-                };
-                const actor = findActorForScreen(model, scr);
-                if (actor)
-                    result.actor = actor;
-                return result;
-            }),
-        },
-        inboundDependencies,
-        internalFlows,
-        scenarios: formatScenarios(model, scenarios),
-    };
-    // 10. Output JSON
-    outputJson(output);
-}

package/dist/slices/create-automation-slice/index.d.ts

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