eventmodeler 0.5.0 → 0.6.0

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;