eventmodeler 0.5.0 → 0.6.1

package/dist/lib/diff/model-differ.js

@@ -1,568 +0,0 @@
-// Flatten nested Custom fields into dot-notation paths
-function flattenFields(fields, prefix = '') {
-    const result = [];
-    for (const field of fields) {
-        const path = prefix ? `${prefix}.${field.name}` : field.name;
-        result.push({ path, field });
-        if (field.fieldType === 'Custom' && field.subfields) {
-            result.push(...flattenFields(field.subfields, path));
-        }
-    }
-    return result;
-}
-// Compare two fields for semantic equality (ignoring id)
-function fieldsEqual(a, b) {
-    if (a.name !== b.name)
-        return false;
-    if (a.fieldType !== b.fieldType)
-        return false;
-    if (a.isList !== b.isList)
-        return false;
-    if (a.isGenerated !== b.isGenerated)
-        return false;
-    if (a.isOptional !== b.isOptional)
-        return false;
-    if (a.isUserInput !== b.isUserInput)
-        return false;
-    // Compare subfields recursively
-    const aSubfields = a.subfields ?? [];
-    const bSubfields = b.subfields ?? [];
-    if (aSubfields.length !== bSubfields.length)
-        return false;
-    for (let i = 0; i < aSubfields.length; i++) {
-        if (!fieldsEqual(aSubfields[i], bSubfields[i]))
-            return false;
-    }
-    return true;
-}
-// Compare field arrays and return changes
-function compareFields(baseFields, compareFields) {
-    const changes = [];
-    const baseFlat = flattenFields(baseFields);
-    const compareFlat = flattenFields(compareFields);
-    const baseByPath = new Map(baseFlat.map((f) => [f.path, f]));
-    const compareByPath = new Map(compareFlat.map((f) => [f.path, f]));
-    // Find removed and modified fields
-    for (const [path, baseEntry] of baseByPath) {
-        const compareEntry = compareByPath.get(path);
-        if (!compareEntry) {
-            changes.push({
-                fieldPath: path,
-                changeType: 'removed',
-                oldValue: baseEntry.field,
-            });
-        }
-        else if (!fieldsEqual(baseEntry.field, compareEntry.field)) {
-            changes.push({
-                fieldPath: path,
-                changeType: 'modified',
-                oldValue: baseEntry.field,
-                newValue: compareEntry.field,
-            });
-        }
-    }
-    // Find added fields
-    for (const [path, compareEntry] of compareByPath) {
-        if (!baseByPath.has(path)) {
-            changes.push({
-                fieldPath: path,
-                changeType: 'added',
-                newValue: compareEntry.field,
-            });
-        }
-    }
-    return changes;
-}
-// Get canonical ID for an entity (for linked copies)
-function getCanonicalId(entity) {
-    // If it's a linked copy, use the originalNodeId as the canonical reference
-    // If it has a canonicalId, use that
-    // Otherwise use its own id
-    return entity.originalNodeId ?? entity.canonicalId ?? entity.id;
-}
-// Build a map of canonical entities (deduplicating linked copies)
-function buildCanonicalMap(entities) {
-    const canonical = new Map();
-    for (const entity of entities.values()) {
-        // Skip linked copies - only use originals
-        if (entity.originalNodeId)
-            continue;
-        canonical.set(entity.id, entity);
-    }
-    return canonical;
-}
-// Compare entities with fields (commands, events, readModels, screens, processors)
-function compareEntitiesWithFields(baseEntities, compareEntities, entityType) {
-    const changes = [];
-    // Build canonical maps (filter out linked copies)
-    const baseCanonical = buildCanonicalMap(baseEntities);
-    const compareCanonical = buildCanonicalMap(compareEntities);
-    // Find removed entities
-    for (const [id, baseEntity] of baseCanonical) {
-        if (!compareCanonical.has(id)) {
-            changes.push({
-                entityType,
-                entityId: id,
-                entityName: baseEntity.name,
-                canonicalId: baseEntity.canonicalId,
-                changeType: 'removed',
-            });
-        }
-    }
-    // Find added entities
-    for (const [id, compareEntity] of compareCanonical) {
-        if (!baseCanonical.has(id)) {
-            changes.push({
-                entityType,
-                entityId: id,
-                entityName: compareEntity.name,
-                canonicalId: compareEntity.canonicalId,
-                changeType: 'added',
-            });
-        }
-    }
-    // Find modified entities
-    for (const [id, baseEntity] of baseCanonical) {
-        const compareEntity = compareCanonical.get(id);
-        if (!compareEntity)
-            continue;
-        const propertyChanges = [];
-        const fieldChanges = compareFields(baseEntity.fields, compareEntity.fields);
-        // Check name change
-        if (baseEntity.name !== compareEntity.name) {
-            propertyChanges.push({
-                property: 'name',
-                oldValue: baseEntity.name,
-                newValue: compareEntity.name,
-            });
-        }
-        if (propertyChanges.length > 0 || fieldChanges.length > 0) {
-            changes.push({
-                entityType,
-                entityId: id,
-                entityName: compareEntity.name,
-                canonicalId: compareEntity.canonicalId,
-                changeType: 'modified',
-                propertyChanges: propertyChanges.length > 0 ? propertyChanges : undefined,
-                fieldChanges: fieldChanges.length > 0 ? fieldChanges : undefined,
-            });
-        }
-    }
-    return changes;
-}
-// Compare slices
-function compareSlices(baseSlices, compareSlices) {
-    const changes = [];
-    // Find removed slices
-    for (const [id, baseSlice] of baseSlices) {
-        if (!compareSlices.has(id)) {
-            changes.push({
-                entityType: 'slice',
-                entityId: id,
-                entityName: baseSlice.name,
-                changeType: 'removed',
-            });
-        }
-    }
-    // Find added slices
-    for (const [id, compareSlice] of compareSlices) {
-        if (!baseSlices.has(id)) {
-            changes.push({
-                entityType: 'slice',
-                entityId: id,
-                entityName: compareSlice.name,
-                changeType: 'added',
-            });
-        }
-    }
-    // Find modified slices
-    for (const [id, baseSlice] of baseSlices) {
-        const compareSlice = compareSlices.get(id);
-        if (!compareSlice)
-            continue;
-        const propertyChanges = [];
-        if (baseSlice.name !== compareSlice.name) {
-            propertyChanges.push({
-                property: 'name',
-                oldValue: baseSlice.name,
-                newValue: compareSlice.name,
-            });
-        }
-        if (baseSlice.status !== compareSlice.status) {
-            propertyChanges.push({
-                property: 'status',
-                oldValue: baseSlice.status,
-                newValue: compareSlice.status,
-            });
-        }
-        // Compare nodeIds (membership)
-        const baseNodes = new Set(baseSlice.nodeIds);
-        const compareNodes = new Set(compareSlice.nodeIds);
-        const addedNodes = [...compareNodes].filter((n) => !baseNodes.has(n));
-        const removedNodes = [...baseNodes].filter((n) => !compareNodes.has(n));
-        if (addedNodes.length > 0 || removedNodes.length > 0) {
-            propertyChanges.push({
-                property: 'nodeIds',
-                oldValue: baseSlice.nodeIds,
-                newValue: compareSlice.nodeIds,
-            });
-        }
-        if (propertyChanges.length > 0) {
-            changes.push({
-                entityType: 'slice',
-                entityId: id,
-                entityName: compareSlice.name,
-                changeType: 'modified',
-                propertyChanges,
-            });
-        }
-    }
-    return changes;
-}
-// Compare chapters
-function compareChapters(baseChapters, compareChapters) {
-    const changes = [];
-    for (const [id, baseChapter] of baseChapters) {
-        if (!compareChapters.has(id)) {
-            changes.push({
-                entityType: 'chapter',
-                entityId: id,
-                entityName: baseChapter.name,
-                changeType: 'removed',
-            });
-        }
-    }
-    for (const [id, compareChapter] of compareChapters) {
-        if (!baseChapters.has(id)) {
-            changes.push({
-                entityType: 'chapter',
-                entityId: id,
-                entityName: compareChapter.name,
-                changeType: 'added',
-            });
-        }
-    }
-    for (const [id, baseChapter] of baseChapters) {
-        const compareChapter = compareChapters.get(id);
-        if (!compareChapter)
-            continue;
-        if (baseChapter.name !== compareChapter.name) {
-            changes.push({
-                entityType: 'chapter',
-                entityId: id,
-                entityName: compareChapter.name,
-                changeType: 'modified',
-                propertyChanges: [
-                    { property: 'name', oldValue: baseChapter.name, newValue: compareChapter.name },
-                ],
-            });
-        }
-    }
-    return changes;
-}
-// Compare aggregates
-function compareAggregates(baseAggregates, compareAggregates) {
-    const changes = [];
-    for (const [id, baseAggregate] of baseAggregates) {
-        if (!compareAggregates.has(id)) {
-            changes.push({
-                entityType: 'aggregate',
-                entityId: id,
-                entityName: baseAggregate.name,
-                changeType: 'removed',
-            });
-        }
-    }
-    for (const [id, compareAggregate] of compareAggregates) {
-        if (!baseAggregates.has(id)) {
-            changes.push({
-                entityType: 'aggregate',
-                entityId: id,
-                entityName: compareAggregate.name,
-                changeType: 'added',
-            });
-        }
-    }
-    for (const [id, baseAggregate] of baseAggregates) {
-        const compareAggregate = compareAggregates.get(id);
-        if (!compareAggregate)
-            continue;
-        const propertyChanges = [];
-        if (baseAggregate.name !== compareAggregate.name) {
-            propertyChanges.push({
-                property: 'name',
-                oldValue: baseAggregate.name,
-                newValue: compareAggregate.name,
-            });
-        }
-        if (baseAggregate.aggregateIdFieldName !== compareAggregate.aggregateIdFieldName) {
-            propertyChanges.push({
-                property: 'aggregateIdFieldName',
-                oldValue: baseAggregate.aggregateIdFieldName,
-                newValue: compareAggregate.aggregateIdFieldName,
-            });
-        }
-        if (baseAggregate.aggregateIdFieldType !== compareAggregate.aggregateIdFieldType) {
-            propertyChanges.push({
-                property: 'aggregateIdFieldType',
-                oldValue: baseAggregate.aggregateIdFieldType,
-                newValue: compareAggregate.aggregateIdFieldType,
-            });
-        }
-        // Compare eventIds
-        const baseEvents = new Set(baseAggregate.eventIds);
-        const compareEvents = new Set(compareAggregate.eventIds);
-        if (baseEvents.size !== compareEvents.size ||
-            [...baseEvents].some((e) => !compareEvents.has(e))) {
-            propertyChanges.push({
-                property: 'eventIds',
-                oldValue: baseAggregate.eventIds,
-                newValue: compareAggregate.eventIds,
-            });
-        }
-        if (propertyChanges.length > 0) {
-            changes.push({
-                entityType: 'aggregate',
-                entityId: id,
-                entityName: compareAggregate.name,
-                changeType: 'modified',
-                propertyChanges,
-            });
-        }
-    }
-    return changes;
-}
-// Compare actors
-function compareActors(baseActors, compareActors) {
-    const changes = [];
-    for (const [id, baseActor] of baseActors) {
-        if (!compareActors.has(id)) {
-            changes.push({
-                entityType: 'actor',
-                entityId: id,
-                entityName: baseActor.name,
-                changeType: 'removed',
-            });
-        }
-    }
-    for (const [id, compareActor] of compareActors) {
-        if (!baseActors.has(id)) {
-            changes.push({
-                entityType: 'actor',
-                entityId: id,
-                entityName: compareActor.name,
-                changeType: 'added',
-            });
-        }
-    }
-    for (const [id, baseActor] of baseActors) {
-        const compareActor = compareActors.get(id);
-        if (!compareActor)
-            continue;
-        const propertyChanges = [];
-        if (baseActor.name !== compareActor.name) {
-            propertyChanges.push({
-                property: 'name',
-                oldValue: baseActor.name,
-                newValue: compareActor.name,
-            });
-        }
-        // Compare screenIds
-        const baseScreens = new Set(baseActor.screenIds);
-        const compareScreens = new Set(compareActor.screenIds);
-        if (baseScreens.size !== compareScreens.size ||
-            [...baseScreens].some((s) => !compareScreens.has(s))) {
-            propertyChanges.push({
-                property: 'screenIds',
-                oldValue: baseActor.screenIds,
-                newValue: compareActor.screenIds,
-            });
-        }
-        if (propertyChanges.length > 0) {
-            changes.push({
-                entityType: 'actor',
-                entityId: id,
-                entityName: compareActor.name,
-                changeType: 'modified',
-                propertyChanges,
-            });
-        }
-    }
-    return changes;
-}
-// Compare scenarios
-function compareScenarios(baseScenarios, compareScenarios) {
-    const changes = [];
-    for (const [id, baseScenario] of baseScenarios) {
-        if (!compareScenarios.has(id)) {
-            changes.push({
-                entityType: 'scenario',
-                entityId: id,
-                entityName: baseScenario.name,
-                changeType: 'removed',
-            });
-        }
-    }
-    for (const [id, compareScenario] of compareScenarios) {
-        if (!baseScenarios.has(id)) {
-            changes.push({
-                entityType: 'scenario',
-                entityId: id,
-                entityName: compareScenario.name,
-                changeType: 'added',
-            });
-        }
-    }
-    for (const [id, baseScenario] of baseScenarios) {
-        const compareScenario = compareScenarios.get(id);
-        if (!compareScenario)
-            continue;
-        const propertyChanges = [];
-        if (baseScenario.name !== compareScenario.name) {
-            propertyChanges.push({
-                property: 'name',
-                oldValue: baseScenario.name,
-                newValue: compareScenario.name,
-            });
-        }
-        if (baseScenario.description !== compareScenario.description) {
-            propertyChanges.push({
-                property: 'description',
-                oldValue: baseScenario.description,
-                newValue: compareScenario.description,
-            });
-        }
-        // Compare givenEvents, whenCommand, then (deep comparison)
-        if (JSON.stringify(baseScenario.givenEvents) !== JSON.stringify(compareScenario.givenEvents)) {
-            propertyChanges.push({
-                property: 'givenEvents',
-                oldValue: baseScenario.givenEvents,
-                newValue: compareScenario.givenEvents,
-            });
-        }
-        if (JSON.stringify(baseScenario.whenCommand) !== JSON.stringify(compareScenario.whenCommand)) {
-            propertyChanges.push({
-                property: 'whenCommand',
-                oldValue: baseScenario.whenCommand,
-                newValue: compareScenario.whenCommand,
-            });
-        }
-        if (JSON.stringify(baseScenario.then) !== JSON.stringify(compareScenario.then)) {
-            propertyChanges.push({
-                property: 'then',
-                oldValue: baseScenario.then,
-                newValue: compareScenario.then,
-            });
-        }
-        if (propertyChanges.length > 0) {
-            changes.push({
-                entityType: 'scenario',
-                entityId: id,
-                entityName: compareScenario.name,
-                changeType: 'modified',
-                propertyChanges,
-            });
-        }
-    }
-    return changes;
-}
-// Compare flows
-function compareFlows(baseFlows, compareFlows, baseModel, compareModel) {
-    const changes = [];
-    // Helper to get entity name by ID
-    const getEntityName = (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 ??
-            id);
-    };
-    for (const [id, baseFlow] of baseFlows) {
-        if (!compareFlows.has(id)) {
-            changes.push({
-                flowId: id,
-                flowType: baseFlow.flowType,
-                changeType: 'removed',
-                sourceName: getEntityName(baseModel, baseFlow.sourceId),
-                targetName: getEntityName(baseModel, baseFlow.targetId),
-            });
-        }
-    }
-    for (const [id, compareFlow] of compareFlows) {
-        if (!baseFlows.has(id)) {
-            changes.push({
-                flowId: id,
-                flowType: compareFlow.flowType,
-                changeType: 'added',
-                sourceName: getEntityName(compareModel, compareFlow.sourceId),
-                targetName: getEntityName(compareModel, compareFlow.targetId),
-            });
-        }
-    }
-    // Check for modified flows (mapping changes)
-    for (const [id, baseFlow] of baseFlows) {
-        const compareFlow = compareFlows.get(id);
-        if (!compareFlow)
-            continue;
-        const mappingChanges = [];
-        // Build mapping sets for comparison
-        const baseMappings = new Map(baseFlow.fieldMappings.map((m) => [`${m.sourceFieldId}->${m.targetFieldId}`, m]));
-        const compareMappings = new Map(compareFlow.fieldMappings.map((m) => [`${m.sourceFieldId}->${m.targetFieldId}`, m]));
-        for (const [key] of baseMappings) {
-            if (!compareMappings.has(key)) {
-                mappingChanges.push({ changeType: 'removed' });
-            }
-        }
-        for (const [key] of compareMappings) {
-            if (!baseMappings.has(key)) {
-                mappingChanges.push({ changeType: 'added' });
-            }
-        }
-        if (mappingChanges.length > 0) {
-            changes.push({
-                flowId: id,
-                flowType: compareFlow.flowType,
-                changeType: 'modified',
-                sourceName: getEntityName(compareModel, compareFlow.sourceId),
-                targetName: getEntityName(compareModel, compareFlow.targetId),
-                mappingChanges,
-            });
-        }
-    }
-    return changes;
-}
-/**
- * Compare two EventModels and return semantic differences.
- * Ignores layout properties (position, size) and linked copies.
- */
-export function diffModels(baseModel, compareModel) {
-    const entityChanges = [];
-    const flowChanges = [];
-    // Compare entities with fields
-    entityChanges.push(...compareEntitiesWithFields(baseModel.commands, compareModel.commands, 'command'));
-    entityChanges.push(...compareEntitiesWithFields(baseModel.events, compareModel.events, 'event'));
-    entityChanges.push(...compareEntitiesWithFields(baseModel.readModels, compareModel.readModels, 'readModel'));
-    entityChanges.push(...compareEntitiesWithFields(baseModel.screens, compareModel.screens, 'screen'));
-    entityChanges.push(...compareEntitiesWithFields(baseModel.processors, compareModel.processors, 'processor'));
-    // Compare organizational entities
-    entityChanges.push(...compareSlices(baseModel.slices, compareModel.slices));
-    entityChanges.push(...compareChapters(baseModel.chapters, compareModel.chapters));
-    entityChanges.push(...compareAggregates(baseModel.aggregates, compareModel.aggregates));
-    entityChanges.push(...compareActors(baseModel.actors, compareModel.actors));
-    entityChanges.push(...compareScenarios(baseModel.scenarios, compareModel.scenarios));
-    // Compare flows
-    flowChanges.push(...compareFlows(baseModel.flows, compareModel.flows, baseModel, compareModel));
-    // Calculate summary
-    const added = entityChanges.filter((c) => c.changeType === 'added').length +
-        flowChanges.filter((c) => c.changeType === 'added').length;
-    const removed = entityChanges.filter((c) => c.changeType === 'removed').length +
-        flowChanges.filter((c) => c.changeType === 'removed').length;
-    const modified = entityChanges.filter((c) => c.changeType === 'modified').length +
-        flowChanges.filter((c) => c.changeType === 'modified').length;
-    return {
-        summary: { added, removed, modified },
-        entityChanges,
-        flowChanges,
-    };
-}

package/dist/lib/diff/three-way-merge.d.ts

@@ -1,7 +0,0 @@
-import type { EventModel, RawEvent } from '../../types.js';
-import type { MergeResult, MergeConflict, AutoResolution } from './types.js';
-/**
- * Perform a three-way merge of event models.
- */
-export declare function threeWayMerge(baseModel: EventModel, oursModel: EventModel, theirsModel: EventModel, baseEvents: RawEvent[], oursEvents: RawEvent[], theirsEvents: RawEvent[], strategy?: 'ours' | 'theirs'): MergeResult;
-export type { MergeResult, MergeConflict, AutoResolution };