eventmodeler 0.5.0 → 0.6.0

package/dist/commands/resize.js

@@ -0,0 +1,30 @@
+import { getGlobalId } from '../lib/globals';
+import { requireModelId } from '../lib/model';
+import { resolve, unwrap, elementIdKey } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+const RESIZE_MAP = {
+    slice: sdk.resizeSlice,
+    aggregate: sdk.resizeAggregate,
+    actor: sdk.resizeActor,
+    chapter: sdk.resizeChapter,
+    context: sdk.resizeContext,
+    swimlane: sdk.resizeSwimLane,
+};
+export function registerResizeCommands(program) {
+    program.command('resize <type> [name]')
+        .description('Resize an element')
+        .requiredOption('--x <n>', 'X coordinate', Number)
+        .requiredOption('--y <n>', 'Y coordinate', Number)
+        .requiredOption('--width <n>', 'Width', Number)
+        .requiredOption('--height <n>', 'Height', Number)
+        .action(async (type, name, opts, cmd) => {
+        const modelId = requireModelId();
+        const fn = RESIZE_MAP[type];
+        if (!fn)
+            throw new Error(`Unknown type: ${type}. Valid types: ${Object.keys(RESIZE_MAP).join(', ')}`);
+        const id = await resolve(modelId, type, name ?? '', getGlobalId());
+        const key = elementIdKey(type);
+        unwrap(await fn({ body: { modelId, [key]: id, x: opts.x, y: opts.y, width: opts.width, height: opts.height } }));
+        console.log(`Resized ${type}.`);
+    });
+}

package/dist/commands/search.js

@@ -0,0 +1,14 @@
+import { requireModelId } from '../lib/model';
+import { unwrap, out } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+import { SEARCH_HELP } from './list-schemas';
+export function registerSearchCommands(program) {
+    program.command('search <term...>')
+        .description('Search elements by name')
+        .addHelpText('after', SEARCH_HELP)
+        .action(async (terms) => {
+        const modelId = requireModelId();
+        const search = terms.join(' ');
+        out(unwrap(await sdk.search({ path: { modelId }, query: { search } })));
+    });
+}

package/dist/commands/set.js

@@ -0,0 +1,199 @@
+import { getGlobalId } from '../lib/globals';
+import { requireModelId } from '../lib/model';
+import { resolve, unwrap } from '../lib/resolve';
+import { resolveScenarioId } from '../lib/scenario';
+import * as sdk from '../api/generated/sdk.gen';
+const SET_FIELD_VALUE_MAP = {
+    event: sdk.setScenarioEventFieldValue,
+    command: sdk.setScenarioCommandFieldValue,
+    readmodel: sdk.setScenarioReadModelFieldValue,
+};
+const SET_FIELD_LIST_VALUES_MAP = {
+    event: sdk.setScenarioEventFieldListValues,
+    command: sdk.setScenarioCommandFieldListValues,
+    readmodel: sdk.setScenarioReadModelFieldListValues,
+};
+const SET_FIELD_CUSTOM_VALUE_MAP = {
+    event: sdk.setScenarioEventFieldCustomValue,
+    command: sdk.setScenarioCommandFieldCustomValue,
+    readmodel: sdk.setScenarioReadModelFieldCustomValue,
+};
+const SET_FIELD_CUSTOM_LIST_VALUES_MAP = {
+    event: sdk.setScenarioEventFieldCustomListValues,
+    command: sdk.setScenarioCommandFieldCustomListValues,
+    readmodel: sdk.setScenarioReadModelFieldCustomListValues,
+};
+function collectListValue(value, previous) {
+    return [...previous, value];
+}
+export function registerSetCommands(program) {
+    const set = program.command('set').description('Set values on elements');
+    // set example --scenario <name> --entry <entryId> --type event|command|readmodel --field <name>
+    //   Primitive scalar:  --value <val>
+    //   Primitive list:    --value <v> [--value <v> ...]   or   --values <csv>
+    //   Custom (any shape): --json '<obj or array>'
+    // Primitive list is auto-detected when --values is given or --value is repeated.
+    // Custom mode is auto-detected from --json (object → scalar, array → list).
+    set.command('example')
+        .description('Set a field example value on a scenario entry (primitive or Custom)')
+        .requiredOption('--scenario <name>', 'Scenario name')
+        .requiredOption('--entry <entryId>', 'Entry ID (from show output)')
+        .requiredOption('--type <type>', 'Entry type: event, command, or readmodel')
+        .requiredOption('--field <name>', 'Field name')
+        .option('--value <val>', 'Primitive value (repeat for list-typed fields)', collectListValue, [])
+        .option('--values <csv>', 'Comma-separated values for a primitive list-typed field')
+        .option('--json <json>', 'JSON for a Custom-typed field (object for scalar, array of objects for list)')
+        .addHelpText('after', `
+Pick the input flag based on the field's type and shape — discover both via:
+  show element <elementName>
+
+Primitive scalar field:
+  --value "42"
+Primitive list field (any of):
+  --value "a" --value "b"
+  --values "a,b,c"
+Custom scalar field (object tree):
+  --json '{ "city": "NYC", "zip": "10001" }'
+Custom list field (array of objects):
+  --json '[{"sku":"a","qty":"2"},{"sku":"b","qty":"1"}]'
+
+Inside a Custom tree, primitive leaves MUST be JSON strings ("42", "true", ISO dates).
+Nested Custom subfields nest as inner objects/arrays.
+
+Tip: to set many fields / many entries at once, use 'add scenario' which takes
+a single JSON spec covering the whole given/when/then.
+`)
+        .action(async (opts) => {
+        const modelId = requireModelId();
+        const scenarioId = await resolveScenarioId(modelId, opts.scenario, getGlobalId());
+        const collected = opts.value;
+        const csvProvided = opts.values !== undefined;
+        const jsonProvided = opts.json !== undefined;
+        if (jsonProvided && (csvProvided || collected.length > 0)) {
+            throw new Error('Use either --json (Custom) or --value/--values (primitive), not both.');
+        }
+        if (!jsonProvided && !csvProvided && collected.length === 0) {
+            throw new Error('Provide --value (repeatable), --values <csv>, or --json <tree>.');
+        }
+        if (jsonProvided) {
+            let parsed;
+            try {
+                parsed = JSON.parse(opts.json);
+            }
+            catch (e) {
+                throw new Error(`--json must be valid JSON: ${e.message}`);
+            }
+            if (Array.isArray(parsed)) {
+                const fn = SET_FIELD_CUSTOM_LIST_VALUES_MAP[opts.type];
+                if (!fn)
+                    throw new Error(`Cannot set Custom list examples on type: ${opts.type}. Use event, command, or readmodel.`);
+                for (const item of parsed) {
+                    if (item === null || typeof item !== 'object' || Array.isArray(item)) {
+                        throw new Error('--json array items must be objects (one per list entry).');
+                    }
+                }
+                unwrap(await fn({
+                    body: { modelId, scenarioId, entryId: opts.entry, fieldName: opts.field, items: parsed }
+                }));
+                console.log(`Set "${opts.field}" = ${parsed.length} Custom item(s).`);
+            }
+            else if (parsed !== null && typeof parsed === 'object') {
+                const fn = SET_FIELD_CUSTOM_VALUE_MAP[opts.type];
+                if (!fn)
+                    throw new Error(`Cannot set Custom examples on type: ${opts.type}. Use event, command, or readmodel.`);
+                unwrap(await fn({
+                    body: { modelId, scenarioId, entryId: opts.entry, fieldName: opts.field, value: parsed }
+                }));
+                console.log(`Set "${opts.field}" = Custom value.`);
+            }
+            else {
+                throw new Error('--json must be an object (Custom scalar) or array of objects (Custom list).');
+            }
+            return;
+        }
+        const isList = csvProvided || collected.length > 1;
+        if (isList) {
+            const fn = SET_FIELD_LIST_VALUES_MAP[opts.type];
+            if (!fn)
+                throw new Error(`Cannot set list examples on type: ${opts.type}. Use event, command, or readmodel.`);
+            const values = csvProvided
+                ? String(opts.values).split(',').map((s) => s.trim())
+                : collected;
+            unwrap(await fn({
+                body: { modelId, scenarioId, entryId: opts.entry, fieldName: opts.field, values }
+            }));
+            console.log(`Set "${opts.field}" = [${values.map((v) => `"${v}"`).join(', ')}].`);
+        }
+        else {
+            const fn = SET_FIELD_VALUE_MAP[opts.type];
+            if (!fn)
+                throw new Error(`Cannot set examples on type: ${opts.type}. Use event, command, or readmodel.`);
+            const value = collected[0];
+            unwrap(await fn({
+                body: { modelId, scenarioId, entryId: opts.entry, fieldName: opts.field, value: String(value) }
+            }));
+            console.log(`Set "${opts.field}" = "${value}".`);
+        }
+    });
+    // set description --scenario <name> --text <description>
+    set.command('description')
+        .description('Set a scenario description')
+        .requiredOption('--scenario <name>', 'Scenario name')
+        .requiredOption('--text <description>', 'Description text')
+        .action(async (opts) => {
+        const modelId = requireModelId();
+        const scenarioId = await resolveScenarioId(modelId, opts.scenario, getGlobalId());
+        unwrap(await sdk.redescribeScenario({
+            body: { modelId, scenarioId, description: opts.text }
+        }));
+        console.log(`Set description on scenario.`);
+    });
+    // reorder entry --scenario <name> --section given|when|then --entry <entryId> --position <n>
+    const REORDER_ENTRY_MAP = {
+        given: sdk.reorderScenarioGivenEntry,
+        when: sdk.reorderScenarioWhenEntry,
+        then: sdk.reorderScenarioThenEntry,
+    };
+    set.command('position')
+        .description('Reorder a scenario entry within its section')
+        .requiredOption('--scenario <name>', 'Scenario name')
+        .requiredOption('--section <section>', 'Section: given, when, or then')
+        .requiredOption('--entry <entryId>', 'Entry ID (from show output)')
+        .requiredOption('--position <n>', 'New position (0-based)', parseInt)
+        .action(async (opts) => {
+        const modelId = requireModelId();
+        const scenarioId = await resolveScenarioId(modelId, opts.scenario, getGlobalId());
+        const fn = REORDER_ENTRY_MAP[opts.section];
+        if (!fn)
+            throw new Error(`Unknown section: ${opts.section}. Use given, when, or then.`);
+        unwrap(await fn({
+            body: { modelId, scenarioId, entryId: opts.entry, position: opts.position }
+        }));
+        console.log(`Moved entry to position ${opts.position}.`);
+    });
+    // set aggregate-id [aggregateName] --field-name <name> --field-type <type>
+    set.command('aggregate-id [aggregateName]')
+        .description('Set the ID field on an aggregate')
+        .requiredOption('--field-name <name>', 'ID field name')
+        .option('--field-type <type>', 'ID field type', 'UUID')
+        .action(async (aggregateName, opts) => {
+        const modelId = requireModelId();
+        const aggregateId = await resolve(modelId, 'aggregate', aggregateName ?? '', getGlobalId());
+        unwrap(await sdk.setAggregateIdField({
+            body: { modelId, aggregateId, aggregateIdFieldName: opts.fieldName, aggregateIdFieldType: opts.fieldType }
+        }));
+        console.log(`Set aggregate ID field to "${opts.fieldName}: ${opts.fieldType}".`);
+    });
+    // set note-description [noteName] --text <description>
+    set.command('note-description [noteName]')
+        .description('Set a note description')
+        .requiredOption('--text <description>', 'Description text')
+        .action(async (noteName, opts) => {
+        const modelId = requireModelId();
+        const noteId = await resolve(modelId, 'note', noteName ?? '', getGlobalId());
+        unwrap(await sdk.redescribeNote({
+            body: { modelId, noteId, description: opts.text }
+        }));
+        console.log('Set note description.');
+    });
+}

package/dist/commands/show-schemas.js

@@ -0,0 +1,259 @@
+// Response shapes for show-* commands, pulled from the backend ReadModels.
+// Attached to each command's --help so agents can consume without out-of-band docs.
+const FIELD_VIEW = `FieldView:
+  {
+    "fieldId":     "<uuid>",
+    "name":        "customerId",
+    "fieldType":   "UUID" | "String" | "Int" | "Long" | "Double"
+                 | "Decimal" | "Boolean" | "Date" | "DateTime" | "Custom",
+    "isList":      false,
+    "isOptional":  false,
+    "isGenerated": false,
+    "isUserInput": false,              // screens only
+    "subfields":   [FieldView, ...]    // non-empty only when fieldType = "Custom"
+  }`;
+const MAPPING_VIEW = `MappingView:
+  { "sourceFieldName": "customerId", "targetFieldName": "customerId" }`;
+const FLOW_VIEW = `FlowView:
+  {
+    "flowId":     "<uuid>",
+    "flowType":   "screen->command" | "command->event" | "event->readmodel"
+                | "readmodel->screen" | "readmodel->processor"
+                | "processor->command" | "command->external-event"
+                | "external-event->processor",
+    "sourceName": "OrderForm",
+    "sourceId":   "<uuid>",
+    "targetName": "PlaceOrder",
+    "targetId":   "<uuid>",
+    "direction":  "forward" | "reverse",
+    "mappings":   [MappingView, ...]
+  }`;
+const SCENARIO_ENTRY_VIEW = `ScenarioEntryView:
+  {
+    "entryId":     "<uuid>",
+    "entryType":   "event" | "command" | "readmodel" | ...,
+    "elementName": "OrderPlaced",
+    "fieldValues": { "customerId": "abc-123", "tags": ["a", "b"], ... }
+                   // string for scalar fields, array for fields marked isList=true
+  }`;
+const SCENARIO_VIEW = `ScenarioView:
+  {
+    "scenarioId":  "<uuid>",
+    "name":        "happy path",
+    "description": "A customer places a valid order",
+    "given":       [ScenarioEntryView, ...],
+    "when":        [ScenarioEntryView, ...],
+    "then":        [ScenarioEntryView, ...]
+  }`;
+const ELEMENT_VIEW_IN_SLICE = `ElementView (as returned inside slices):
+  {
+    "elementId":    "<uuid>",
+    "elementType":  "screen" | "command" | "event" | "readmodel"
+                  | "processor" | "external-event",
+    "name":         "PlaceOrder",
+    "x": 0, "y": 0, "width": 0, "height": 0,
+    "fields":        [FieldView, ...],
+    "linkedCopy":    false,             // true = visual proxy; real element lives elsewhere
+    "originalId":    "<uuid>",          // only when linkedCopy = true
+    "originalSlice": "Place Order"      // only when linkedCopy = true
+  }`;
+const SLICE_VIEW = `SliceView:
+  {
+    "sliceId":   "<uuid>",
+    "name":      "Place Order",
+    "status":    "created" | "planned" | "in-progress" | "blocked" | "done",
+    "x": 0, "y": 0, "width": 0, "height": 0,
+    "aggregate": { "aggregateId": "<uuid>", "name": "Order" } | null,
+    "elements":  [ElementView, ...],
+    "flows":     [FlowView, ...],
+    "scenarios": [ScenarioView, ...]
+  }`;
+const CHAPTER_VIEW = `ChapterView:
+  {
+    "chapterId":   "<uuid>",
+    "name":        "User Onboarding",
+    "x": 0, "y": 0, "width": 0, "height": 0,
+    "chapters":    [ChapterView, ...],    // nested chapters
+    "slices":      [SliceView, ...],
+    "uncontained": [ElementView, ...]     // elements in the chapter but outside any slice
+  }`;
+const CONTEXT_VIEW = `ContextView:
+  {
+    "contextId":   "<uuid>",
+    "name":        "Orders",
+    "x": 0, "y": 0, "width": 0, "height": 0,
+    "chapters":    [ChapterView, ...],
+    "slices":      [SliceView, ...],
+    "uncontained": [ElementView, ...]
+  }`;
+// show slice → SliceView (with nested ElementView/FlowView/ScenarioView)
+export const SHOW_SLICE_HELP = `
+Response (JSON on stdout):
+
+${SLICE_VIEW}
+
+${ELEMENT_VIEW_IN_SLICE}
+
+${FIELD_VIEW}
+
+${FLOW_VIEW}
+
+${MAPPING_VIEW}
+
+${SCENARIO_VIEW}
+
+${SCENARIO_ENTRY_VIEW}
+`;
+// show chapter → ChapterView
+export const SHOW_CHAPTER_HELP = `
+Response (JSON on stdout):
+
+${CHAPTER_VIEW}
+
+${SLICE_VIEW}
+
+${ELEMENT_VIEW_IN_SLICE}
+
+${FIELD_VIEW}
+
+${FLOW_VIEW}
+
+${MAPPING_VIEW}
+
+${SCENARIO_VIEW}
+
+${SCENARIO_ENTRY_VIEW}
+`;
+// show context → ContextView
+export const SHOW_CONTEXT_HELP = `
+Response (JSON on stdout):
+
+${CONTEXT_VIEW}
+
+${CHAPTER_VIEW}
+
+${SLICE_VIEW}
+
+${ELEMENT_VIEW_IN_SLICE}
+
+${FIELD_VIEW}
+
+${FLOW_VIEW}
+
+${MAPPING_VIEW}
+
+${SCENARIO_VIEW}
+
+${SCENARIO_ENTRY_VIEW}
+`;
+// show model → ModelView
+export const SHOW_MODEL_HELP = `
+Response (JSON on stdout):
+
+ModelView:
+  {
+    "modelId":     "<uuid>",
+    "modelName":   "My Model",
+    "contexts":    [ContextView, ...],
+    "chapters":    [ChapterView, ...],    // chapters not inside any context
+    "slices":      [SliceView, ...],      // slices not inside any chapter
+    "uncontained": [ElementView, ...]     // elements outside every container
+  }
+
+${CONTEXT_VIEW}
+
+${CHAPTER_VIEW}
+
+${SLICE_VIEW}
+
+${ELEMENT_VIEW_IN_SLICE}
+
+${FIELD_VIEW}
+
+${FLOW_VIEW}
+
+${MAPPING_VIEW}
+
+${SCENARIO_VIEW}
+
+${SCENARIO_ENTRY_VIEW}
+`;
+// show <element> → richer element response with cross-slice context
+export const SHOW_ELEMENT_HELP = `
+Response (JSON on stdout):
+
+ShowElementView:
+  {
+    "elementId":   "<uuid>",
+    "elementType": "screen" | "command" | "event" | "readmodel"
+                 | "processor" | "external-event",
+    "name":        "OrderPlaced",
+    "x": 0, "y": 0, "width": 0, "height": 0,
+    "fields":           [FieldEntry, ...],
+    "linkedCopy":       false,
+    "originalId":       "<uuid>",          // only when linkedCopy = true
+    "copies":           [CopyEntry, ...],       // all visual proxies of this element
+    "appearsInSlices":  [SliceEntry, ...],      // slices this element belongs to
+    "inboundFlows":     [FlowEntry, ...],       // flows pointing at this element
+    "outboundFlows":    [FlowEntry, ...]        // flows leaving this element
+  }
+
+FieldEntry:
+  {
+    "fieldId":     "<uuid>",
+    "name":        "customerId",
+    "fieldType":   "UUID" | "String" | "Int" | "Long" | "Double"
+                 | "Decimal" | "Boolean" | "Date" | "DateTime" | "Custom",
+    "isList":      false,
+    "isOptional":  false,
+    "isGenerated": false,
+    "isUserInput": false,
+    "subfields":   [FieldEntry, ...]
+  }
+
+CopyEntry:
+  {
+    "copyId":    "<uuid>",
+    "x": 0, "y": 0,
+    "sliceName": "Place Order" | null
+  }
+
+SliceEntry:
+  { "sliceId": "<uuid>", "sliceName": "Place Order" }
+
+FlowEntry:
+  {
+    "flowId":     "<uuid>",
+    "flowType":   "screen->command" | "command->event" | ...,
+    "sourceName": "OrderForm",
+    "sourceId":   "<uuid>",
+    "targetName": "PlaceOrder",
+    "targetId":   "<uuid>",
+    "mappings":   [{ "sourceFieldName": "customerId", "targetFieldName": "customerId" }, ...]
+  }
+`;
+// show completeness → model-level coverage report
+export const SHOW_COMPLETENESS_HELP = `
+Response (JSON on stdout):
+
+CompletenessReport:
+  {
+    "modelId":    "<uuid>",
+    "complete":   0,    // count of fields with full traceability
+    "incomplete": 0,    // count of fields missing mappings
+    "total":      0,
+    "incompleteElements": [IncompleteElement, ...]
+  }
+
+IncompleteElement:
+  {
+    "elementId":    "<uuid>",
+    "elementName":  "PlaceOrder",
+    "elementType":  "command" | "event" | "readmodel" | "screen" | "processor" | "external-event",
+    "unmappedFields": ["fieldName", ...],
+    "missingAggregateIdField": {
+      "aggregateName": "Order",
+      "expectedField": "orderId"
+    } | null
+  }
+`;

package/dist/commands/show.js

@@ -0,0 +1,56 @@
+import { getGlobalId } from '../lib/globals';
+import { requireModelId } from '../lib/model';
+import { resolve, unwrap, out } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+import { SHOW_MODEL_HELP, SHOW_CONTEXT_HELP, SHOW_CHAPTER_HELP, SHOW_SLICE_HELP, SHOW_ELEMENT_HELP, SHOW_COMPLETENESS_HELP, } from './show-schemas';
+export function registerShowCommands(program) {
+    const show = program.command('show').description('Show detailed information');
+    show.command('model')
+        .description('Show full model hierarchy')
+        .addHelpText('after', SHOW_MODEL_HELP)
+        .action(async () => {
+        const modelId = requireModelId();
+        out(unwrap(await sdk.showModel({ path: { modelId } })));
+    });
+    show.command('context [name]')
+        .description('Show context with contained chapters and slices')
+        .addHelpText('after', SHOW_CONTEXT_HELP)
+        .action(async (name, cmd) => {
+        const modelId = requireModelId();
+        const contextId = await resolve(modelId, 'context', name ?? '', getGlobalId());
+        out(unwrap(await sdk.showContext({ path: { modelId, contextId } })));
+    });
+    show.command('chapter [name]')
+        .description('Show chapter with contained slices')
+        .addHelpText('after', SHOW_CHAPTER_HELP)
+        .action(async (name, cmd) => {
+        const modelId = requireModelId();
+        const chapterId = await resolve(modelId, 'chapter', name ?? '', getGlobalId());
+        out(unwrap(await sdk.showChapter({ path: { modelId, chapterId } })));
+    });
+    show.command('slice [name]')
+        .description('Show slice with all elements, flows, and scenarios')
+        .addHelpText('after', SHOW_SLICE_HELP)
+        .action(async (name, cmd) => {
+        const modelId = requireModelId();
+        const sliceId = await resolve(modelId, 'slice', name ?? '', getGlobalId());
+        out(unwrap(await sdk.showSlice({ path: { modelId, sliceId } })));
+    });
+    for (const type of ['event', 'command', 'readmodel', 'screen', 'processor', 'external-event']) {
+        show.command(`${type} [name]`)
+            .description(`Show ${type} detail with fields and flows`)
+            .addHelpText('after', SHOW_ELEMENT_HELP)
+            .action(async (name, cmd) => {
+            const modelId = requireModelId();
+            const elementId = await resolve(modelId, type, name ?? '', getGlobalId());
+            out(unwrap(await sdk.showElement({ path: { modelId, elementId } })));
+        });
+    }
+    show.command('completeness')
+        .description('Show completeness for the entire model')
+        .addHelpText('after', SHOW_COMPLETENESS_HELP)
+        .action(async () => {
+        const modelId = requireModelId();
+        out(unwrap(await sdk.showCompleteness({ path: { modelId } })));
+    });
+}

package/dist/commands/summary.js

@@ -0,0 +1,13 @@
+import { requireModelId } from '../lib/model';
+import { unwrap, out } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+import { SUMMARY_HELP } from './list-schemas';
+export function registerSummaryCommands(program) {
+    program.command('summary')
+        .description('Show model summary')
+        .addHelpText('after', SUMMARY_HELP)
+        .action(async () => {
+        const modelId = requireModelId();
+        out(unwrap(await sdk.summary({ path: { modelId } })));
+    });
+}