eventmodeler 0.2.1 → 0.2.3

package/dist/slices/list-slices/index.js

@@ -1,18 +1,17 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-export function listSlices(model) {
+import { escapeXml, outputJson } from '../../lib/format.js';
+export function listSlices(model, format) {
     const slices = [...model.slices.values()];
+    const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
+    if (format === 'json') {
+        outputJson({
+            slices: sorted.map(s => ({ name: s.name, status: s.status }))
+        });
+        return;
+    }
     if (slices.length === 0) {
         console.log('<slices/>');
         return;
     }
-    const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
     console.log('<slices>');
     for (const slice of sorted) {
         console.log(`  <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>`);

package/dist/slices/search/index.d.ts

@@ -1,2 +1,3 @@
 import type { EventModel } from '../../types.js';
-export declare function search(model: EventModel, term: string): void;
+import { type OutputFormat } from '../../lib/format.js';
+export declare function search(model: EventModel, term: string, format: OutputFormat): void;

package/dist/slices/search/index.js

@@ -1,11 +1,4 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
+import { escapeXml, outputJson } from '../../lib/format.js';
 function isInSlice(slice, pos, width, height) {
     const centerX = pos.x + width / 2;
     const centerY = pos.y + height / 2;
@@ -17,15 +10,42 @@ function isInSlice(slice, pos, width, height) {
 function findSlicesContaining(model, pos, width, height) {
     return [...model.slices.values()].filter(slice => isInSlice(slice, pos, width, height));
 }
-export function search(model, term) {
+export function search(model, term, format) {
     const termLower = term.toLowerCase();
-    const results = [];
+    const xmlResults = [];
+    const jsonResults = [];
     // Search commands
     for (const cmd of model.commands.values()) {
         if (cmd.name.toLowerCase().includes(termLower)) {
             const slices = findSlicesContaining(model, cmd.position, cmd.width, cmd.height);
             const incomingFlows = [...model.flows.values()].filter(f => f.targetId === cmd.id);
             const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === cmd.id);
+            // JSON result
+            const jsonResult = { type: 'command', name: cmd.name, fields: cmd.fields.length };
+            if (slices.length > 0) {
+                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
+            }
+            const triggeredBy = [];
+            for (const flow of incomingFlows) {
+                const screen = model.screens.get(flow.sourceId);
+                const processor = model.processors.get(flow.sourceId);
+                if (screen)
+                    triggeredBy.push(screen.name);
+                if (processor)
+                    triggeredBy.push(processor.name);
+            }
+            if (triggeredBy.length > 0)
+                jsonResult.triggeredBy = triggeredBy;
+            const produces = [];
+            for (const flow of outgoingFlows) {
+                const evt = model.events.get(flow.targetId);
+                if (evt)
+                    produces.push(evt.name);
+            }
+            if (produces.length > 0)
+                jsonResult.produces = produces;
+            jsonResults.push(jsonResult);
+            // XML result
             let xml = `  <command name="${escapeXml(cmd.name)}" fields="${cmd.fields.length}">\n`;
             if (slices.length > 0) {
                 xml += '    <in-slices>\n';
@@ -56,7 +76,7 @@ export function search(model, term) {
                 xml += '    </produces>\n';
             }
             xml += '  </command>';
-            results.push(xml);
+            xmlResults.push(xml);
         }
     }
     // Search events
@@ -65,6 +85,29 @@ export function search(model, term) {
             const slices = findSlicesContaining(model, evt.position, evt.width, evt.height);
             const incomingFlows = [...model.flows.values()].filter(f => f.targetId === evt.id);
             const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === evt.id);
+            // JSON result
+            const jsonResult = { type: 'event', name: evt.name, fields: evt.fields.length };
+            if (slices.length > 0) {
+                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
+            }
+            const producedBy = [];
+            for (const flow of incomingFlows) {
+                const cmd = model.commands.get(flow.sourceId);
+                if (cmd)
+                    producedBy.push(cmd.name);
+            }
+            if (producedBy.length > 0)
+                jsonResult.producedBy = producedBy;
+            const consumedBy = [];
+            for (const flow of outgoingFlows) {
+                const rm = model.readModels.get(flow.targetId);
+                if (rm)
+                    consumedBy.push(rm.name);
+            }
+            if (consumedBy.length > 0)
+                jsonResult.consumedBy = consumedBy;
+            jsonResults.push(jsonResult);
+            // XML result
             let xml = `  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}">\n`;
             if (slices.length > 0) {
                 xml += '    <in-slices>\n';
@@ -92,13 +135,20 @@ export function search(model, term) {
                 xml += '    </consumed-by>\n';
             }
             xml += '  </event>';
-            results.push(xml);
+            xmlResults.push(xml);
         }
     }
     // Search read models
     for (const rm of model.readModels.values()) {
         if (rm.name.toLowerCase().includes(termLower)) {
             const slices = findSlicesContaining(model, rm.position, rm.width, rm.height);
+            // JSON result
+            const jsonResult = { type: 'read-model', name: rm.name, fields: rm.fields.length };
+            if (slices.length > 0) {
+                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
+            }
+            jsonResults.push(jsonResult);
+            // XML result
             let xml = `  <read-model name="${escapeXml(rm.name)}" fields="${rm.fields.length}">\n`;
             if (slices.length > 0) {
                 xml += '    <in-slices>\n';
@@ -108,13 +158,20 @@ export function search(model, term) {
                 xml += '    </in-slices>\n';
             }
             xml += '  </read-model>';
-            results.push(xml);
+            xmlResults.push(xml);
         }
     }
     // Search screens
     for (const scr of model.screens.values()) {
         if (scr.name.toLowerCase().includes(termLower)) {
             const slices = findSlicesContaining(model, scr.position, scr.width, scr.height);
+            // JSON result
+            const jsonResult = { type: 'screen', name: scr.name, fields: scr.fields.length };
+            if (slices.length > 0) {
+                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
+            }
+            jsonResults.push(jsonResult);
+            // XML result
             let xml = `  <screen name="${escapeXml(scr.name)}" fields="${scr.fields.length}">\n`;
             if (slices.length > 0) {
                 xml += '    <in-slices>\n';
@@ -124,13 +181,20 @@ export function search(model, term) {
                 xml += '    </in-slices>\n';
             }
             xml += '  </screen>';
-            results.push(xml);
+            xmlResults.push(xml);
         }
     }
     // Search processors
     for (const proc of model.processors.values()) {
         if (proc.name.toLowerCase().includes(termLower)) {
             const slices = findSlicesContaining(model, proc.position, proc.width, proc.height);
+            // JSON result
+            const jsonResult = { type: 'processor', name: proc.name, fields: proc.fields.length };
+            if (slices.length > 0) {
+                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
+            }
+            jsonResults.push(jsonResult);
+            // XML result
             let xml = `  <processor name="${escapeXml(proc.name)}" fields="${proc.fields.length}">\n`;
             if (slices.length > 0) {
                 xml += '    <in-slices>\n';
@@ -140,34 +204,97 @@ export function search(model, term) {
                 xml += '    </in-slices>\n';
             }
             xml += '  </processor>';
-            results.push(xml);
+            xmlResults.push(xml);
         }
     }
     // Search slices
     for (const slice of model.slices.values()) {
         if (slice.name.toLowerCase().includes(termLower)) {
-            let xml = `  <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>`;
-            results.push(xml);
+            // JSON result
+            jsonResults.push({ type: 'slice', name: slice.name });
+            // XML result
+            xmlResults.push(`  <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
+        }
+    }
+    // Search aggregates
+    for (const agg of model.aggregates.values()) {
+        if (agg.name.toLowerCase().includes(termLower)) {
+            const events = agg.eventIds
+                .map(id => model.events.get(id))
+                .filter((e) => e !== undefined);
+            // JSON result
+            const jsonResult = { type: 'aggregate', name: agg.name, events: events.length };
+            if (events.length > 0) {
+                jsonResult.contains = events.map(e => e.name);
+            }
+            jsonResults.push(jsonResult);
+            // XML result
+            let xml = `  <aggregate name="${escapeXml(agg.name)}" events="${events.length}">\n`;
+            if (events.length > 0) {
+                xml += '    <contains>\n';
+                for (const evt of events) {
+                    xml += `      <event name="${escapeXml(evt.name)}"/>\n`;
+                }
+                xml += '    </contains>\n';
+            }
+            xml += '  </aggregate>';
+            xmlResults.push(xml);
+        }
+    }
+    // Search actors
+    for (const actor of model.actors.values()) {
+        if (actor.name.toLowerCase().includes(termLower)) {
+            const screens = actor.screenIds
+                .map(id => model.screens.get(id))
+                .filter((s) => s !== undefined);
+            // JSON result
+            const jsonResult = { type: 'actor', name: actor.name, screens: screens.length };
+            if (screens.length > 0) {
+                jsonResult.contains = screens.map(s => s.name);
+            }
+            jsonResults.push(jsonResult);
+            // XML result
+            let xml = `  <actor name="${escapeXml(actor.name)}" screens="${screens.length}">\n`;
+            if (screens.length > 0) {
+                xml += '    <contains>\n';
+                for (const scr of screens) {
+                    xml += `      <screen name="${escapeXml(scr.name)}"/>\n`;
+                }
+                xml += '    </contains>\n';
+            }
+            xml += '  </actor>';
+            xmlResults.push(xml);
         }
     }
     // Search scenarios
     for (const scenario of model.scenarios.values()) {
         if (scenario.name.toLowerCase().includes(termLower)) {
             const slice = model.slices.get(scenario.sliceId);
+            // JSON result
+            const jsonResult = { type: 'scenario', name: scenario.name };
+            if (slice) {
+                jsonResult.inSlice = { name: slice.name, status: slice.status };
+            }
+            jsonResults.push(jsonResult);
+            // XML result
             let xml = `  <scenario name="${escapeXml(scenario.name)}">\n`;
             if (slice) {
                 xml += `    <in-slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
             }
             xml += '  </scenario>';
-            results.push(xml);
+            xmlResults.push(xml);
         }
     }
-    if (results.length === 0) {
+    if (format === 'json') {
+        outputJson({ query: term, count: jsonResults.length, results: jsonResults });
+        return;
+    }
+    if (xmlResults.length === 0) {
         console.log(`<search-results query="${escapeXml(term)}" count="0"/>`);
     }
     else {
-        console.log(`<search-results query="${escapeXml(term)}" count="${results.length}">`);
-        for (const result of results) {
+        console.log(`<search-results query="${escapeXml(term)}" count="${xmlResults.length}">`);
+        for (const result of xmlResults) {
             console.log(result);
         }
         console.log('</search-results>');

package/dist/slices/show-actor/index.d.ts

@@ -1,3 +1,4 @@
 import type { EventModel } from '../../types.js';
-export declare function showActor(model: EventModel, actorName: string): void;
-export declare function listActors(model: EventModel): void;
+import { type OutputFormat } from '../../lib/format.js';
+export declare function showActor(model: EventModel, actorName: string, format: OutputFormat): void;
+export declare function listActors(model: EventModel, format: OutputFormat): void;

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

@@ -1,10 +1,4 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
+import { escapeXml, outputJson } from '../../lib/format.js';
 // Get screens whose center point is inside the actor bounds
 function getScreensInActor(model, actor) {
     const bounds = {
@@ -34,7 +28,7 @@ function findSliceForScreen(model, screen) {
     }
     return null;
 }
-export function showActor(model, actorName) {
+export function showActor(model, actorName, format) {
     // Find the actor
     const nameLower = actorName.toLowerCase();
     const actors = [...model.actors.values()];
@@ -49,6 +43,29 @@ export function showActor(model, actorName) {
     }
     // Get screens dynamically based on position (center point inside actor bounds)
     const screensInActor = getScreensInActor(model, actor);
+    if (format === 'json') {
+        outputJson({
+            id: actor.id,
+            name: actor.name,
+            screensCount: screensInActor.length,
+            screens: screensInActor.map(screen => {
+                const result = {
+                    id: screen.id,
+                    name: screen.name,
+                    fields: screen.fields.length
+                };
+                if (screen.originalNodeId) {
+                    result.linkedCopy = true;
+                    const original = model.screens.get(screen.originalNodeId);
+                    const originSlice = original ? findSliceForScreen(model, original) : null;
+                    if (originSlice)
+                        result.originSlice = originSlice;
+                }
+                return result;
+            })
+        });
+        return;
+    }
     console.log(`<actor id="${actor.id}" name="${escapeXml(actor.name)}">`);
     console.log(`  <screens-count>${screensInActor.length}</screens-count>`);
     if (screensInActor.length > 0) {
@@ -70,8 +87,26 @@ export function showActor(model, actorName) {
     }
     console.log('</actor>');
 }
-export function listActors(model) {
+export function listActors(model, format) {
     const actors = [...model.actors.values()];
+    if (format === 'json') {
+        outputJson({
+            actors: actors.map(actor => {
+                const screensInActor = getScreensInActor(model, actor);
+                const originalCount = screensInActor.filter(s => !s.originalNodeId).length;
+                const copyCount = screensInActor.filter(s => s.originalNodeId).length;
+                const result = {
+                    id: actor.id,
+                    name: actor.name,
+                    screens: originalCount
+                };
+                if (copyCount > 0)
+                    result.copies = copyCount;
+                return result;
+            })
+        });
+        return;
+    }
     if (actors.length === 0) {
         console.log('<actors/>');
         return;

package/dist/slices/show-aggregate-completeness/index.d.ts

@@ -1,3 +1,4 @@
 import type { EventModel } from '../../types.js';
-export declare function showAggregateCompleteness(model: EventModel, aggregateName: string): void;
-export declare function listAggregates(model: EventModel): void;
+import { type OutputFormat } from '../../lib/format.js';
+export declare function showAggregateCompleteness(model: EventModel, aggregateName: string, format: OutputFormat): void;
+export declare function listAggregates(model: EventModel, format: OutputFormat): void;

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

@@ -1,10 +1,4 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
+import { escapeXml, outputJson } from '../../lib/format.js';
 function findMatchingField(fields, targetName, targetType) {
     for (const field of fields) {
         // Check if name and type match
@@ -38,7 +32,7 @@ function getEventsInAggregate(model, aggregate) {
     // Linked copies have originalNodeId set, originals do not
     return [...model.events.values()].filter(e => !e.originalNodeId && isInAggregate(e.position, e.width, e.height));
 }
-export function showAggregateCompleteness(model, aggregateName) {
+export function showAggregateCompleteness(model, aggregateName, format) {
     // Find the aggregate
     const nameLower = aggregateName.toLowerCase();
     const aggregates = [...model.aggregates.values()];
@@ -55,6 +49,16 @@ export function showAggregateCompleteness(model, aggregateName) {
     const eventsInAggregate = getEventsInAggregate(model, aggregate);
     // Check if aggregate has ID field configured
     if (!aggregate.aggregateIdFieldName || !aggregate.aggregateIdFieldType) {
+        if (format === 'json') {
+            outputJson({
+                aggregate: aggregate.name,
+                status: 'unconfigured',
+                eventsCount: eventsInAggregate.length,
+                events: eventsInAggregate.map(e => ({ id: e.id, name: e.name })),
+                message: 'Aggregate ID field not configured. Set aggregateIdFieldName and aggregateIdFieldType.'
+            });
+            return;
+        }
         console.log(`<aggregate-completeness aggregate="${escapeXml(aggregate.name)}" status="unconfigured">`);
         console.log(`  <events-count>${eventsInAggregate.length}</events-count>`);
         console.log('  <events>');
@@ -69,6 +73,15 @@ export function showAggregateCompleteness(model, aggregateName) {
     const idFieldName = aggregate.aggregateIdFieldName;
     const idFieldType = aggregate.aggregateIdFieldType;
     if (eventsInAggregate.length === 0) {
+        if (format === 'json') {
+            outputJson({
+                aggregate: aggregate.name,
+                status: 'empty',
+                idField: { name: idFieldName, type: idFieldType },
+                message: 'No events in this aggregate.'
+            });
+            return;
+        }
         console.log(`<aggregate-completeness aggregate="${escapeXml(aggregate.name)}" status="empty">`);
         console.log(`  <id-field name="${escapeXml(idFieldName)}" type="${idFieldType}"/>`);
         console.log('  <message>No events in this aggregate.</message>');
@@ -97,6 +110,26 @@ export function showAggregateCompleteness(model, aggregateName) {
     const completionPercent = eventResults.length > 0
         ? Math.round((completeEvents.length / eventResults.length) * 100)
         : 100;
+    if (format === 'json') {
+        outputJson({
+            aggregate: aggregate.name,
+            status: overallStatus,
+            completion: `${completionPercent}%`,
+            idField: { name: idFieldName, type: idFieldType },
+            summary: {
+                total: eventResults.length,
+                complete: completeEvents.length,
+                incomplete: incompleteEvents.length
+            },
+            incompleteEvents: incompleteEvents.map(e => ({ id: e.eventId, name: e.eventName })),
+            completeEvents: completeEvents.map(e => ({
+                id: e.eventId,
+                name: e.eventName,
+                fieldId: e.matchingField?.fieldId
+            }))
+        });
+        return;
+    }
     console.log(`<aggregate-completeness aggregate="${escapeXml(aggregate.name)}" status="${overallStatus}" completion="${completionPercent}%">`);
     console.log(`  <id-field name="${escapeXml(idFieldName)}" type="${idFieldType}"/>`);
     console.log(`  <summary total="${eventResults.length}" complete="${completeEvents.length}" incomplete="${incompleteEvents.length}"/>`);
@@ -119,8 +152,26 @@ export function showAggregateCompleteness(model, aggregateName) {
     }
     console.log('</aggregate-completeness>');
 }
-export function listAggregates(model) {
+export function listAggregates(model, format) {
     const aggregates = [...model.aggregates.values()];
+    if (format === 'json') {
+        outputJson({
+            aggregates: aggregates.map(aggregate => {
+                const eventsInAggregate = getEventsInAggregate(model, aggregate);
+                const result = {
+                    id: aggregate.id,
+                    name: aggregate.name,
+                    events: eventsInAggregate.length
+                };
+                if (aggregate.aggregateIdFieldName) {
+                    result.idField = aggregate.aggregateIdFieldName;
+                    result.idType = aggregate.aggregateIdFieldType ?? 'Unknown';
+                }
+                return result;
+            })
+        });
+        return;
+    }
     if (aggregates.length === 0) {
         console.log('<aggregates/>');
         return;

package/dist/slices/show-chapter/index.d.ts

@@ -1,2 +1,3 @@
 import type { EventModel } from '../../types.js';
-export declare function showChapter(model: EventModel, name: string): void;
+import { type OutputFormat } from '../../lib/format.js';
+export declare function showChapter(model: EventModel, name: string, format: OutputFormat): void;

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

@@ -1,11 +1,4 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
+import { escapeXml, outputJson } from '../../lib/format.js';
 function getSlicesUnderChapter(model, chapter) {
     // A slice is "under" a chapter if its horizontal center falls within the chapter's x range
     const chapterLeft = chapter.position.x;
@@ -15,7 +8,7 @@ function getSlicesUnderChapter(model, chapter) {
         return sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight;
     }).sort((a, b) => a.position.x - b.position.x);
 }
-export function showChapter(model, name) {
+export function showChapter(model, name, format) {
     const chapters = [...model.chapters.values()];
     const nameLower = name.toLowerCase();
     const chapter = chapters.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
@@ -28,6 +21,13 @@ export function showChapter(model, name) {
         process.exit(1);
     }
     const slices = getSlicesUnderChapter(model, chapter);
+    if (format === 'json') {
+        outputJson({
+            name: chapter.name,
+            slices: slices.map(s => ({ name: s.name, status: s.status }))
+        });
+        return;
+    }
     console.log(`<chapter name="${escapeXml(chapter.name)}">`);
     if (slices.length === 0) {
         console.log('  <slices/>');

package/dist/slices/show-command/index.d.ts

@@ -1,2 +1,3 @@
 import type { EventModel } from '../../types.js';
-export declare function showCommand(model: EventModel, name: string): void;
+import { type OutputFormat } from '../../lib/format.js';
+export declare function showCommand(model: EventModel, name: string, format: OutputFormat): void;

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

@@ -1,11 +1,4 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
+import { escapeXml, outputJson } from '../../lib/format.js';
 function formatFieldXml(field, indent) {
     const attrs = [
         `name="${escapeXml(field.name)}"`,
@@ -27,6 +20,22 @@ function formatFieldXml(field, indent) {
     }
     return `${indent}<field ${attrs.join(' ')}/>\n`;
 }
+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.subfields && field.subfields.length > 0) {
+        result.subfields = field.subfields.map(fieldToJson);
+    }
+    return result;
+}
 // Find which aggregate an event belongs to (center point inside aggregate bounds)
 function findAggregateForEvent(model, event) {
     const centerX = event.position.x + event.width / 2;
@@ -82,7 +91,7 @@ function formatCommandXml(model, command) {
     xml += '</command>';
     return xml;
 }
-export function showCommand(model, name) {
+export function showCommand(model, name, format) {
     const commands = [...model.commands.values()];
     const nameLower = name.toLowerCase();
     const command = commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
@@ -94,5 +103,39 @@ export function showCommand(model, name) {
         }
         process.exit(1);
     }
+    if (format === 'json') {
+        const incomingFlows = [...model.flows.values()].filter(f => f.targetId === command.id);
+        const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === command.id);
+        const result = {
+            name: command.name,
+            fields: command.fields.map(fieldToJson)
+        };
+        const triggeredBy = [];
+        for (const flow of incomingFlows) {
+            const screen = model.screens.get(flow.sourceId);
+            const processor = model.processors.get(flow.sourceId);
+            if (screen)
+                triggeredBy.push(screen.name);
+            if (processor)
+                triggeredBy.push(processor.name);
+        }
+        if (triggeredBy.length > 0)
+            result.triggeredBy = triggeredBy;
+        const produces = [];
+        for (const flow of outgoingFlows) {
+            const target = model.events.get(flow.targetId);
+            if (target) {
+                const aggregate = findAggregateForEvent(model, target);
+                produces.push({
+                    name: target.name,
+                    ...(aggregate ? { aggregate: aggregate.name } : {})
+                });
+            }
+        }
+        if (produces.length > 0)
+            result.produces = produces;
+        outputJson(result);
+        return;
+    }
     console.log(formatCommandXml(model, command));
 }

package/dist/slices/show-completeness/index.d.ts

@@ -1,2 +1,4 @@
 import type { EventModel } from '../../types.js';
-export declare function showCompleteness(model: EventModel, readModelName: string): void;
+import { type OutputFormat } from '../../lib/format.js';
+export declare function showCompleteness(model: EventModel, elementName: string, format: OutputFormat): void;
+export declare function showModelCompleteness(model: EventModel, format: OutputFormat): void;