eventmodeler 0.2.4 → 0.2.5

package/dist/projection.js

@@ -824,138 +824,6 @@ function applyEvent(model, event) {
         case 'ScreenDesignUpdated':
             // Screen designs are visual-only, not relevant for CLI
             break;
-        // Compound slice placement events - place entire slices atomically
-        case 'StateChangeSlicePlaced': {
-            // Create slice
-            model.slices.set(event.sliceId, {
-                id: event.sliceId,
-                name: event.sliceName,
-                status: 'created',
-                position: event.slicePosition,
-                size: event.sliceSize,
-                nodeIds: [event.screenId, event.commandId, event.eventId],
-            });
-            // Create screen
-            model.screens.set(event.screenId, {
-                id: event.screenId,
-                name: event.screenName,
-                fields: event.screenFields,
-                position: event.screenPosition,
-                width: event.screenSize.width,
-                height: event.screenSize.height,
-            });
-            // Create command
-            model.commands.set(event.commandId, {
-                id: event.commandId,
-                name: event.commandName,
-                fields: event.commandFields,
-                position: event.commandPosition,
-                width: event.commandSize.width,
-                height: event.commandSize.height,
-            });
-            // Create event
-            model.events.set(event.eventId, {
-                id: event.eventId,
-                name: event.eventName,
-                fields: event.eventFields,
-                position: event.eventPosition,
-                width: event.eventSize.width,
-                height: event.eventSize.height,
-            });
-            // Create screen->command flow
-            model.flows.set(event.screenToCommandFlowId, {
-                id: event.screenToCommandFlowId,
-                flowType: 'ScreenToCommand',
-                sourceId: event.screenId,
-                targetId: event.commandId,
-                fieldMappings: event.screenToCommandMappings,
-            });
-            // Create command->event flow
-            model.flows.set(event.commandToEventFlowId, {
-                id: event.commandToEventFlowId,
-                flowType: 'CommandToEvent',
-                sourceId: event.commandId,
-                targetId: event.eventId,
-                fieldMappings: event.commandToEventMappings,
-            });
-            break;
-        }
-        case 'AutomationSlicePlaced': {
-            // Create slice
-            model.slices.set(event.sliceId, {
-                id: event.sliceId,
-                name: event.sliceName,
-                status: 'created',
-                position: event.slicePosition,
-                size: event.sliceSize,
-                nodeIds: [event.processorId, event.commandId, event.eventId],
-            });
-            // Create processor
-            model.processors.set(event.processorId, {
-                id: event.processorId,
-                name: event.processorName,
-                fields: [],
-                position: event.processorPosition,
-                width: event.processorSize.width,
-                height: event.processorSize.height,
-            });
-            // Create command
-            model.commands.set(event.commandId, {
-                id: event.commandId,
-                name: event.commandName,
-                fields: event.commandFields,
-                position: event.commandPosition,
-                width: event.commandSize.width,
-                height: event.commandSize.height,
-            });
-            // Create event
-            model.events.set(event.eventId, {
-                id: event.eventId,
-                name: event.eventName,
-                fields: event.eventFields,
-                position: event.eventPosition,
-                width: event.eventSize.width,
-                height: event.eventSize.height,
-            });
-            // Create processor->command flow
-            model.flows.set(event.processorToCommandFlowId, {
-                id: event.processorToCommandFlowId,
-                flowType: 'ProcessorToCommand',
-                sourceId: event.processorId,
-                targetId: event.commandId,
-                fieldMappings: [],
-            });
-            // Create command->event flow
-            model.flows.set(event.commandToEventFlowId, {
-                id: event.commandToEventFlowId,
-                flowType: 'CommandToEvent',
-                sourceId: event.commandId,
-                targetId: event.eventId,
-                fieldMappings: event.commandToEventMappings,
-            });
-            break;
-        }
-        case 'StateViewSlicePlaced': {
-            // Create slice
-            model.slices.set(event.sliceId, {
-                id: event.sliceId,
-                name: event.sliceName,
-                status: 'created',
-                position: event.slicePosition,
-                size: event.sliceSize,
-                nodeIds: [event.readModelId],
-            });
-            // Create read model
-            model.readModels.set(event.readModelId, {
-                id: event.readModelId,
-                name: event.readModelName,
-                fields: event.readModelFields,
-                position: event.readModelPosition,
-                width: event.readModelSize.width,
-                height: event.readModelSize.height,
-            });
-            break;
-        }
     }
 }
 // Merge propagated fields with existing fields:

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

@@ -207,15 +207,20 @@ export function addScenario(model, filePath, sliceName, input) {
         };
     }
     // Calculate position below slice
+    // Scenarios are tall (GWT rows with 100px stickies + labels + padding = ~400px+)
+    // so we need adequate spacing between them
+    const SCENARIO_GAP = 20; // Match slice gap
+    const SCENARIO_ESTIMATED_HEIGHT = 450; // Approximate rendered height for positioning
     const existingScenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
     const sliceBottom = slice.position.y + slice.size.height;
     let positionY;
     if (existingScenarios.length === 0) {
-        positionY = sliceBottom + 20;
+        positionY = sliceBottom + SCENARIO_GAP;
     }
     else {
-        const lowestY = Math.max(...existingScenarios.map(s => s.position.y + s.height));
-        positionY = lowestY + 10;
+        // Use estimated height since stored height (80px) doesn't reflect actual rendered size
+        const lowestY = Math.max(...existingScenarios.map(s => s.position.y + SCENARIO_ESTIMATED_HEIGHT));
+        positionY = lowestY + SCENARIO_GAP;
     }
     const position = {
         x: slice.position.x + 10,

package/dist/slices/show-completeness/index.js

@@ -23,7 +23,7 @@ function findElementByName(model, name) {
         }
         for (const rm of model.readModels.values()) {
             if (rm.id.toLowerCase().startsWith(idSearch)) {
-                return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' }, ambiguous: [] };
+                return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel', canonicalId: rm.canonicalId }, ambiguous: [] };
             }
         }
         for (const scr of model.screens.values()) {
@@ -49,7 +49,7 @@ function findElementByName(model, name) {
             return { element: { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' }, ambiguous: [] };
         const rm = model.readModels.get(name);
         if (rm)
-            return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' }, ambiguous: [] };
+            return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel', canonicalId: rm.canonicalId }, ambiguous: [] };
         const scr = model.screens.get(name);
         if (scr)
             return { element: { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' }, ambiguous: [] };
@@ -73,7 +73,7 @@ function findElementByName(model, name) {
     }
     for (const rm of model.readModels.values()) {
         if (rm.name.toLowerCase() === nameLower) {
-            matches.push({ element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' }, type: 'readModel' });
+            matches.push({ element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel', canonicalId: rm.canonicalId }, type: 'readModel' });
         }
     }
     for (const scr of model.screens.values()) {
@@ -123,6 +123,95 @@ function flattenFields(fields, prefix = '') {
     }
     return result;
 }
+/**
+ * Calculates completeness for a read model using the union approach.
+ * A field is satisfied if ANY incoming event provides it.
+ * For linked copies, considers flows into ALL nodes in the canonical group.
+ */
+function calculateReadModelUnionCompleteness(model, readModelId, readModelFields, canonicalId) {
+    // Find all node IDs in the canonical group (original + all copies)
+    let targetNodeIds;
+    if (canonicalId) {
+        targetNodeIds = [...model.readModels.values()]
+            .filter(rm => rm.canonicalId === canonicalId)
+            .map(rm => rm.id);
+    }
+    else {
+        targetNodeIds = [readModelId];
+    }
+    // Find all incoming EventToReadModel flows to ANY node in the group
+    const incomingFlows = [...model.flows.values()].filter(f => targetNodeIds.includes(f.targetId) && f.flowType === 'EventToReadModel');
+    // Collect all source fields from all incoming events (union)
+    const allSourceFields = [];
+    const allManualMappings = [];
+    const sourceEventNames = [];
+    for (const flow of incomingFlows) {
+        const sourceFields = getSourceFields(model, flow.sourceId);
+        allSourceFields.push(...flattenFields(sourceFields));
+        if (flow.fieldMappings) {
+            allManualMappings.push(...flow.fieldMappings);
+        }
+        // Get event name for reporting
+        const event = model.events.get(flow.sourceId);
+        if (event && !sourceEventNames.includes(event.name)) {
+            sourceEventNames.push(event.name);
+        }
+    }
+    // Check each target field against the union of all sources
+    const flatTarget = flattenFields(readModelFields);
+    const untraceableFields = [];
+    const optionalMissingFields = [];
+    const fieldStatuses = [];
+    for (const { id, path, field } of flatTarget) {
+        // 1. Generated fields don't need a source
+        if (field.isGenerated) {
+            fieldStatuses.push({ fieldId: id, fieldName: path, status: 'generated' });
+            continue;
+        }
+        // 2. Check if there's a manual mapping from any flow
+        const manualMapping = allManualMappings.find(m => m.targetFieldId === id);
+        if (manualMapping) {
+            const sourceField = allSourceFields.find(sf => sf.id === manualMapping.sourceFieldId);
+            fieldStatuses.push({
+                fieldId: id,
+                fieldName: path,
+                status: 'satisfied',
+                sourceFieldId: manualMapping.sourceFieldId,
+                sourceFieldName: sourceField?.path,
+            });
+            continue;
+        }
+        // 3. Check auto-mapping by path match from any source
+        const autoMatch = allSourceFields.find(sf => sf.path === path);
+        if (autoMatch) {
+            fieldStatuses.push({
+                fieldId: id,
+                fieldName: path,
+                status: 'satisfied',
+                sourceFieldId: autoMatch.id,
+                sourceFieldName: autoMatch.path,
+            });
+            continue;
+        }
+        // 4. Optional fields missing is a warning, not an error
+        if (field.isOptional) {
+            optionalMissingFields.push(path);
+            fieldStatuses.push({ fieldId: id, fieldName: path, status: 'optional-missing' });
+            continue;
+        }
+        // Field is untraceable (required but no source)
+        untraceableFields.push(path);
+        fieldStatuses.push({ fieldId: id, fieldName: path, status: 'unsatisfied' });
+    }
+    return {
+        isComplete: untraceableFields.length === 0,
+        hasWarnings: optionalMissingFields.length > 0,
+        untraceableFields,
+        optionalMissingFields,
+        sourceEvents: sourceEventNames,
+        fieldStatuses,
+    };
+}
 function calculateFlowCompleteness(model, flow, targetFields, sourceFields) {
     const flatSource = flattenFields(sourceFields);
     const flatTarget = flattenFields(targetFields);
@@ -254,10 +343,112 @@ export function showCompleteness(model, elementName, format) {
         }
         process.exit(1);
     }
-    // Find all incoming flows for this element type
+    const elementTypeLabel = element.type === 'readModel' ? 'read-model' : element.type;
+    // For read models, use union completeness (all incoming events combined)
+    if (element.type === 'readModel') {
+        const unionResult = calculateReadModelUnionCompleteness(model, element.id, element.fields, element.canonicalId);
+        // Check if there are any incoming flows at all
+        let targetNodeIds;
+        if (element.canonicalId) {
+            targetNodeIds = [...model.readModels.values()]
+                .filter(rm => rm.canonicalId === element.canonicalId)
+                .map(rm => rm.id);
+        }
+        else {
+            targetNodeIds = [element.id];
+        }
+        const hasIncomingFlows = [...model.flows.values()].some(f => targetNodeIds.includes(f.targetId) && f.flowType === 'EventToReadModel');
+        if (!hasIncomingFlows) {
+            if (format === 'json') {
+                outputJson({
+                    elementType: elementTypeLabel,
+                    name: element.name,
+                    message: `No flows into this ${elementTypeLabel}`
+                });
+            }
+            else {
+                console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}">`);
+                console.log(`  <no-flows>No flows into this ${elementTypeLabel}</no-flows>`);
+                console.log('</completeness>');
+            }
+            return;
+        }
+        const overallStatus = unionResult.isComplete ? 'complete' : 'incomplete';
+        const flatTargetFields = flattenFields(element.fields);
+        if (format === 'json') {
+            outputJson({
+                elementType: elementTypeLabel,
+                name: element.name,
+                status: overallStatus,
+                ...(unionResult.hasWarnings ? { hasWarnings: true } : {}),
+                sourceEvents: unionResult.sourceEvents,
+                ...(unionResult.untraceableFields.length > 0 ? { untraceableFields: unionResult.untraceableFields } : {}),
+                ...(unionResult.optionalMissingFields.length > 0 ? { optionalMissingFields: unionResult.optionalMissingFields } : {}),
+                fieldStatuses: unionResult.fieldStatuses.map(f => ({
+                    name: f.fieldName,
+                    status: f.status,
+                    ...(f.sourceFieldName ? { source: f.sourceFieldName } : {})
+                })),
+                elementFields: flatTargetFields.map(({ id, path, field }) => ({
+                    id,
+                    name: path,
+                    type: field.fieldType,
+                    ...(field.isList ? { isList: true } : {}),
+                    ...(field.isOptional ? { isOptional: true } : {}),
+                    ...(field.isGenerated ? { isGenerated: true } : {})
+                }))
+            });
+            return;
+        }
+        // XML output for read models
+        console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}" status="${overallStatus}"${unionResult.hasWarnings ? ' hasWarnings="true"' : ''}>`);
+        console.log('  <source-events>');
+        for (const eventName of unionResult.sourceEvents) {
+            console.log(`    <event name="${escapeXml(eventName)}"/>`);
+        }
+        console.log('  </source-events>');
+        if (unionResult.untraceableFields.length > 0) {
+            console.log('  <untraceable-fields>');
+            for (const fieldName of unionResult.untraceableFields) {
+                console.log(`    <field name="${escapeXml(fieldName)}"/>`);
+            }
+            console.log('  </untraceable-fields>');
+        }
+        if (unionResult.optionalMissingFields.length > 0) {
+            console.log('  <optional-missing-fields>');
+            for (const fieldName of unionResult.optionalMissingFields) {
+                console.log(`    <field name="${escapeXml(fieldName)}"/>`);
+            }
+            console.log('  </optional-missing-fields>');
+        }
+        console.log('  <field-statuses>');
+        for (const field of unionResult.fieldStatuses) {
+            if (field.sourceFieldName) {
+                console.log(`    <field name="${escapeXml(field.fieldName)}" status="${field.status}" source="${escapeXml(field.sourceFieldName)}"/>`);
+            }
+            else {
+                console.log(`    <field name="${escapeXml(field.fieldName)}" status="${field.status}"/>`);
+            }
+        }
+        console.log('  </field-statuses>');
+        console.log(`  <${elementTypeLabel}-fields>`);
+        for (const { id, path, field } of flatTargetFields) {
+            const attrs = [`id="${id}"`, `name="${escapeXml(path)}"`, `type="${field.fieldType}"`];
+            if (field.isList)
+                attrs.push('isList="true"');
+            if (field.isOptional)
+                attrs.push('isOptional="true"');
+            if (field.isGenerated)
+                attrs.push('isGenerated="true"');
+            console.log(`    <field ${attrs.join(' ')}/>`);
+        }
+        console.log(`  </${elementTypeLabel}-fields>`);
+        console.log('</completeness>');
+        return;
+    }
+    // For non-read-model elements, use per-flow completeness
     const validFlowTypes = INCOMING_FLOW_TYPES[element.type];
     const incomingFlows = [...model.flows.values()].filter(f => f.targetId === element.id && validFlowTypes.includes(f.flowType));
-    const elementTypeLabel = element.type === 'readModel' ? 'read-model' : element.type;
     if (incomingFlows.length === 0) {
         if (format === 'json') {
             outputJson({
@@ -367,14 +558,22 @@ export function showModelCompleteness(model, format) {
     const incompleteFlows = [];
     let completeCount = 0;
     let totalCount = 0;
+    // For read models, we use union completeness - track which canonical groups we've processed
+    const processedReadModelGroups = new Set();
+    const incompleteReadModels = [];
+    let readModelCompleteCount = 0;
+    let readModelTotalCount = 0;
     for (const flow of allFlows) {
+        // Skip EventToReadModel flows - we handle read models separately with union logic
+        if (flow.flowType === 'EventToReadModel') {
+            continue;
+        }
         // Get target element info
         let targetName = 'Unknown';
         let targetType = 'unknown';
         let targetFields = [];
         const targetCmd = model.commands.get(flow.targetId);
         const targetEvt = model.events.get(flow.targetId);
-        const targetRm = model.readModels.get(flow.targetId);
         const targetScr = model.screens.get(flow.targetId);
         const targetProc = model.processors.get(flow.targetId);
         if (targetCmd) {
@@ -387,11 +586,6 @@ export function showModelCompleteness(model, format) {
             targetType = 'event';
             targetFields = targetEvt.fields;
         }
-        else if (targetRm) {
-            targetName = targetRm.name;
-            targetType = 'read-model';
-            targetFields = targetRm.fields;
-        }
         else if (targetScr) {
             targetName = targetScr.name;
             targetType = 'screen';
@@ -423,13 +617,51 @@ export function showModelCompleteness(model, format) {
             });
         }
     }
+    // Process read models with union completeness
+    // Group read models by canonicalId (or use id if no canonicalId)
+    for (const rm of model.readModels.values()) {
+        const groupKey = rm.canonicalId ?? rm.id;
+        // Skip if we've already processed this canonical group
+        if (processedReadModelGroups.has(groupKey)) {
+            continue;
+        }
+        processedReadModelGroups.add(groupKey);
+        // Check if this read model has any incoming EventToReadModel flows
+        let targetNodeIds;
+        if (rm.canonicalId) {
+            targetNodeIds = [...model.readModels.values()]
+                .filter(r => r.canonicalId === rm.canonicalId)
+                .map(r => r.id);
+        }
+        else {
+            targetNodeIds = [rm.id];
+        }
+        const hasIncomingFlows = allFlows.some(f => targetNodeIds.includes(f.targetId) && f.flowType === 'EventToReadModel');
+        if (!hasIncomingFlows) {
+            // No incoming flows - skip this read model
+            continue;
+        }
+        readModelTotalCount++;
+        const unionResult = calculateReadModelUnionCompleteness(model, rm.id, rm.fields, rm.canonicalId);
+        if (unionResult.isComplete) {
+            readModelCompleteCount++;
+        }
+        else {
+            incompleteReadModels.push({
+                name: rm.name,
+                untraceableFields: unionResult.untraceableFields,
+                sourceEvents: unionResult.sourceEvents,
+            });
+        }
+    }
     const incompleteCount = totalCount - completeCount;
+    const readModelIncompleteCount = readModelTotalCount - readModelCompleteCount;
     if (format === 'json') {
         outputJson({
             summary: {
-                complete: completeCount,
-                incomplete: incompleteCount,
-                total: totalCount
+                complete: completeCount + readModelCompleteCount,
+                incomplete: incompleteCount + readModelIncompleteCount,
+                total: totalCount + readModelTotalCount
             },
             incompleteFlows: incompleteFlows.map(item => ({
                 from: item.sourceName,
@@ -437,12 +669,19 @@ export function showModelCompleteness(model, format) {
                 targetType: item.targetType,
                 flowType: item.flow.flowType,
                 unsatisfiedFields: item.unsatisfiedFields
-            }))
+            })),
+            ...(incompleteReadModels.length > 0 ? {
+                incompleteReadModels: incompleteReadModels.map(item => ({
+                    name: item.name,
+                    untraceableFields: item.untraceableFields,
+                    sourceEvents: item.sourceEvents
+                }))
+            } : {})
         });
         return;
     }
     console.log('<model-completeness>');
-    console.log(`  <summary complete="${completeCount}" incomplete="${incompleteCount}" total="${totalCount}"/>`);
+    console.log(`  <summary complete="${completeCount + readModelCompleteCount}" incomplete="${incompleteCount + readModelIncompleteCount}" total="${totalCount + readModelTotalCount}"/>`);
     if (incompleteFlows.length > 0) {
         console.log('  <incomplete-flows>');
         for (const item of incompleteFlows) {
@@ -458,5 +697,23 @@ export function showModelCompleteness(model, format) {
         }
         console.log('  </incomplete-flows>');
     }
+    if (incompleteReadModels.length > 0) {
+        console.log('  <incomplete-read-models>');
+        for (const item of incompleteReadModels) {
+            console.log(`    <read-model name="${escapeXml(item.name)}">`);
+            console.log('      <untraceable-fields>');
+            for (const fieldName of item.untraceableFields) {
+                console.log(`        <field name="${escapeXml(fieldName)}"/>`);
+            }
+            console.log('      </untraceable-fields>');
+            console.log('      <source-events>');
+            for (const eventName of item.sourceEvents) {
+                console.log(`        <event name="${escapeXml(eventName)}"/>`);
+            }
+            console.log('      </source-events>');
+            console.log('    </read-model>');
+        }
+        console.log('  </incomplete-read-models>');
+    }
     console.log('</model-completeness>');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eventmodeler",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "CLI tool for interacting with Event Model files - query, update, and export event models from the terminal",
   "type": "module",
   "bin": {