eventmodeler 0.6.7 → 0.6.9

package/dist/index.js

@@ -2576,6 +2576,33 @@ function getEntry(doc, scope, id) {
     return;
   return entry instanceof Y4.AbstractType ? entry.toJSON() : entry;
 }
+// ../packages/canvas-model/src/dimensions.ts
+var ELEMENT_DIMENSIONS = {
+  commandSticky: { width: 160, height: 100 },
+  eventSticky: { width: 160, height: 100 },
+  readModelSticky: { width: 160, height: 100 },
+  screen: { width: 180, height: 120 },
+  processor: { width: 120, height: 120 },
+  slice: { width: 300, height: 200 },
+  aggregate: { width: 300, height: 200 },
+  actor: { width: 300, height: 200 },
+  chapter: { width: 800, height: 1200 },
+  note: { width: 200, height: 150 },
+  externalEvent: { width: 160, height: 100 },
+  context: { width: 300, height: 200 },
+  swimLane: { width: 300, height: 200 }
+};
+var FIXED_SIZE_SCOPE_DIMENSIONS = {
+  commands: ELEMENT_DIMENSIONS.commandSticky,
+  events: ELEMENT_DIMENSIONS.eventSticky,
+  readModels: ELEMENT_DIMENSIONS.readModelSticky,
+  screens: ELEMENT_DIMENSIONS.screen,
+  processors: ELEMENT_DIMENSIONS.processor,
+  externalEvents: ELEMENT_DIMENSIONS.externalEvent
+};
+function canonicalSizeForScope(scope) {
+  return FIXED_SIZE_SCOPE_DIMENSIONS[scope];
+}
 // ../packages/canvas-model/src/actions.ts
 import * as Y5 from "yjs";
 // ../packages/canvas-model/src/containment.ts
@@ -2705,7 +2732,7 @@ var FieldTypeSchema = z.enum([
   "Custom"
 ]);
 var FieldBase = z.object({
-  id: z.string().uuid().optional(),
+  id: z.string().uuid().default(() => crypto.randomUUID()),
   name: z.string().min(1),
   fieldType: FieldTypeSchema,
   isList: z.boolean().optional(),
@@ -2742,12 +2769,22 @@ var NoteSchema = Box.extend({
   title: z.string().min(1),
   description: z.string().optional()
 });
+var ExcalidrawElementSchema = z.object({
+  id: z.string().min(1),
+  type: z.string().min(1),
+  version: z.number().int().optional(),
+  isDeleted: z.boolean().optional()
+}).passthrough();
+var DesignSchema = z.array(ExcalidrawElementSchema);
 var canonicalSticky = (idKey) => NamedBox.extend({
   [idKey]: z.string().uuid().optional(),
   modelId: z.string().uuid().optional(),
   fields: z.array(FieldSchema).optional(),
   isLinkedCopy: z.literal(false).optional()
 });
+var canonicalScreen = canonicalSticky("screenId").extend({
+  design: DesignSchema.optional()
+});
 var linkedCopySticky = (idKey, originalIdKey) => Box.extend({
   [idKey]: z.string().uuid().optional(),
   modelId: z.string().uuid().optional(),
@@ -2766,7 +2803,7 @@ var stickyVariants = {
     linkedCopy: linkedCopySticky("readModelStickyId", "originalReadModelStickyId")
   },
   screens: {
-    canonical: canonicalSticky("screenId"),
+    canonical: canonicalScreen,
     linkedCopy: linkedCopySticky("screenId", "originalScreenId")
   },
   processors: {
@@ -2783,6 +2820,41 @@ var ReadModelSchema = z.union([stickyVariants.readModels.canonical, stickyVarian
 var ScreenSchema = z.union([stickyVariants.screens.canonical, stickyVariants.screens.linkedCopy]);
 var ProcessorSchema = z.union([stickyVariants.processors.canonical, stickyVariants.processors.linkedCopy]);
 var ExternalEventSchema = z.union([stickyVariants.externalEvents.canonical, stickyVariants.externalEvents.linkedCopy]);
+var FlowTypeSchema = z.enum([
+  "CommandToEvent",
+  "EventToReadModel",
+  "ReadModelToScreen",
+  "ReadModelToProcessor",
+  "ScreenToCommand",
+  "ProcessorToCommand",
+  "CommandToExternalEvent",
+  "ExternalEventToProcessor"
+]);
+var FlowHandleSchema = z.enum([
+  "top-source",
+  "right-source",
+  "bottom-source",
+  "left-source",
+  "top-target",
+  "right-target",
+  "bottom-target",
+  "left-target"
+]);
+var FlowMappingSchema = z.object({
+  mappingId: z.string().uuid().optional(),
+  sourceFieldId: z.string().uuid(),
+  targetFieldId: z.string().uuid()
+});
+var FlowSchema = z.object({
+  flowId: z.string().uuid().optional(),
+  modelId: z.string().uuid().optional(),
+  flowType: FlowTypeSchema,
+  sourceId: z.string().uuid(),
+  targetId: z.string().uuid(),
+  sourceHandle: FlowHandleSchema.optional(),
+  targetHandle: FlowHandleSchema.optional(),
+  mappings: z.array(FlowMappingSchema).optional()
+});
 var SCOPE_SCHEMAS = {
   commands: CommandSchema,
   events: EventSchema,
@@ -2796,7 +2868,8 @@ var SCOPE_SCHEMAS = {
   chapters: ChapterSchema,
   contexts: ContextSchema,
   swimLanes: SwimLaneSchema,
-  notes: NoteSchema
+  notes: NoteSchema,
+  flows: FlowSchema
 };
 function validateEntry(scope, data) {
   const schema = pickSchema(scope, data);
@@ -2975,7 +3048,19 @@ var ELEMENT_VIEW = `ElementView:
     "x": 0, "y": 0, "width": 0, "height": 0,
     "fields":      [FieldView, ...],
     "linkedCopy":  false,
-    "originalId":  "<uuid>"          // only when linkedCopy = true
+    "originalId":  "<uuid>",         // only when linkedCopy = true
+    "design":      [ExcalidrawElement, ...]
+                                     // screens only; omitted when empty/absent
+  }
+
+ExcalidrawElement (passthrough — Excalidraw owns the full shape):
+  {
+    "id":        "<element-id>",     // required
+    "type":      "rectangle" | "ellipse" | "diamond" | "arrow"
+               | "line" | "freedraw" | "text" | "image" | "frame" | ...,
+    "version":   1,                  // optional
+    "isDeleted": false,              // optional
+    ...                              // any extra Excalidraw props pass through
   }`;
 var SLICE_VIEW = `SliceView:
   {
@@ -3318,6 +3403,9 @@ function buildElementView(e) {
     if (originalId)
       view.originalId = originalId;
   }
+  if (e.scope === "screens" && Array.isArray(e.design) && e.design.length > 0) {
+    view.design = e.design;
+  }
   return view;
 }
 function buildSliceView(doc, slice) {
@@ -3427,6 +3515,9 @@ function buildShowElementView(doc, scope2, element) {
   if (element.isLinkedCopy && originalKey) {
     view.originalId = read(element, originalKey);
   }
+  if (scope2 === "screens" && Array.isArray(element.design) && element.design.length > 0) {
+    view.design = element.design;
+  }
   view.copies = copies.map((c) => ({
     copyId: read(c, ID_KEY[scope2]),
     x: c.x,
@@ -3587,7 +3678,8 @@ var TYPES = [
   { type: "chapter", scope: "chapters", idKey: "chapterId", nameKey: "name" },
   { type: "context", scope: "contexts", idKey: "contextId", nameKey: "name" },
   { type: "swim-lane", scope: "swimLanes", idKey: "swimLaneId", nameKey: "name" },
-  { type: "note", scope: "notes", idKey: "noteId", nameKey: "title" }
+  { type: "note", scope: "notes", idKey: "noteId", nameKey: "title" },
+  { type: "flow", scope: "flows", idKey: "flowId", nameKey: "name", nameless: true }
 ];
 var ALIAS_TO_CANONICAL = {
   command: "command",
@@ -3625,7 +3717,9 @@ var ALIAS_TO_CANONICAL = {
   swimLane: "swim-lane",
   swimLanes: "swim-lane",
   note: "note",
-  notes: "note"
+  notes: "note",
+  flow: "flow",
+  flows: "flow"
 };
 function resolveType(alias) {
   const canonical = ALIAS_TO_CANONICAL[alias];
@@ -3637,6 +3731,22 @@ function knownTypeAliases() {
   return TYPES.map((t) => t.type);
 }
 
+// src/lib/enforce-size.ts
+function enforceCanonicalSize(meta, entry) {
+  const dims = canonicalSizeForScope(meta.scope);
+  if (!dims)
+    return;
+  const hadW = typeof entry.width === "number";
+  const hadH = typeof entry.height === "number";
+  const mismatched = hadW && entry.width !== dims.width || hadH && entry.height !== dims.height;
+  entry.width = dims.width;
+  entry.height = dims.height;
+  if (mismatched) {
+    return `${meta.type} is a fixed-size element; using canonical ${dims.width}x${dims.height}.`;
+  }
+  return;
+}
+
 // src/commands/create.ts
 var CREATE_HELP = `
 Place a new element described by a JSON shape. The JSON is validated against
@@ -3647,6 +3757,23 @@ type-specific fields (e.g. \`status\` on slices, \`fields\` on stickies).
 Notes use \`title\` instead of \`name\`. The CLI fills in the id and modelId
 automatically — agents do not need to supply them.
 
+Fixed-size elements (command, event, read-model, screen, processor,
+external-event) are not resizable in the editor: the CLI always writes their
+canonical dimensions, so width/height are optional and any supplied size is
+overridden (a note is printed when it differs). Containers (slice, chapter,
+context, …) are resizable — pass the size you want.
+
+Screens accept an optional \`design\` field — an Excalidraw scene as a JSON
+array of elements. The CLI converts the array to the Y.Doc representation that
+the canvas streams in realtime, so passing valid Excalidraw JSON is enough:
+
+  eventmodeler create screen '{"name":"OrderForm","x":0,"y":0,"width":400,"height":300,"fields":[],"design":[{"id":"r1","type":"rectangle","x":10,"y":10,"width":80,"height":40}]}'
+
+Flows are nameless edges between elements. Provide flowType, sourceId,
+targetId, and optional handles + mappings:
+
+  eventmodeler create flow '{"flowType":"CommandToEvent","sourceId":"<commandStickyId>","targetId":"<eventStickyId>","sourceHandle":"right-source","targetHandle":"left-target","mappings":[{"sourceFieldId":"<uuid>","targetFieldId":"<uuid>"}]}'
+
 Examples:
   eventmodeler create slice '{"name":"PlaceOrder","x":0,"y":0,"width":300,"height":200}'
   eventmodeler create event '{"name":"OrderPlaced","x":40,"y":40,"width":160,"height":100,"fields":[{"name":"orderId","fieldType":"UUID","isList":false,"isGenerated":true}]}'
@@ -3667,6 +3794,11 @@ function registerCreateCommands(program) {
       console.error(`Invalid JSON: ${err.message}`);
       process.exit(2);
     }
+    if (parsed && typeof parsed === "object") {
+      const note = enforceCanonicalSize(meta, parsed);
+      if (note)
+        console.error(note);
+    }
     const validation = validateEntry(meta.scope, parsed);
     if (!validation.ok) {
       console.error(`Validation failed for ${meta.type}:`);
@@ -3749,6 +3881,16 @@ fields by design — edit the original and all copies pick up the change. The
 CLI refuses both name-based updates (ambiguous with the original) and
 --id <copy-uuid> updates (would diverge from the original).
 
+Flows have no addressable name and must be updated via uuid:
+
+  eventmodeler --id <flowId> update flow '<json>'
+
+Screens accept a typed \`design\` field — an array of Excalidraw elements.
+The CLI converts it to the Y.Doc array the canvas streams in realtime, so
+agents can emit Excalidraw JSON directly without worrying about CRDT wire
+shape. Omitting \`design\` on update wipes the existing design (replace
+semantics); to preserve it, round-trip via \`show screen ... | jq\`.
+
 This is a *replace*, not a patch: keys present in the previous entry but
 absent in the new JSON are removed.
 `;
@@ -3768,6 +3910,9 @@ function registerUpdateCommands(program) {
         process.exit(2);
       }
       json = args[0];
+    } else if (meta.nameless) {
+      console.error(`${meta.type} entries have no name — address them by uuid: ` + `eventmodeler --id <${meta.idKey}> update ${meta.type} '<json>'`);
+      process.exit(2);
     } else {
       if (args.length < 2) {
         console.error(`Usage: eventmodeler update <type> "<name>" '<json>'`);
@@ -3783,6 +3928,11 @@ function registerUpdateCommands(program) {
       console.error(`Invalid JSON: ${err.message}`);
       process.exit(2);
     }
+    if (parsed && typeof parsed === "object") {
+      const note = enforceCanonicalSize(meta, parsed);
+      if (note)
+        console.error(note);
+    }
     const validation = validateEntry(meta.scope, parsed);
     if (!validation.ok) {
       console.error(`Validation failed for ${meta.type}:`);
@@ -3835,6 +3985,10 @@ function registerRemoveCommands(program) {
     }
     const modelId = resolveModelId(opts.model);
     const idOverride = getGlobalId();
+    if (meta.nameless && !idOverride) {
+      console.error(`${meta.type} entries have no name — address them by uuid: ` + `eventmodeler --id <${meta.idKey}> remove ${meta.type}`);
+      process.exit(2);
+    }
     let summary = `Removed ${meta.type}.`;
     await withDoc(modelId, (doc) => {
       const { id, entry } = resolveEntity(doc, meta.scope, meta.idKey, meta.nameKey, name, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eventmodeler",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "CLI tool for event modeling - explore, design, and generate code from your event models",
   "type": "module",
   "repository": {