eventmodeler 0.6.9 → 0.6.11

package/dist/index.js

@@ -1815,8 +1815,8 @@ var require_semver2 = __commonJS((exports, module) => {
 });
 
 // src/index.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
@@ -2871,6 +2871,9 @@ var SCOPE_SCHEMAS = {
   notes: NoteSchema,
   flows: FlowSchema
 };
+function isValidatedScope(scope) {
+  return scope in SCOPE_SCHEMAS;
+}
 function validateEntry(scope, data) {
   const schema = pickSchema(scope, data);
   const result = schema.safeParse(data);
@@ -3727,6 +3730,9 @@ function resolveType(alias) {
     return;
   return TYPES.find((t) => t.type === canonical);
 }
+function resolveScope(scope2) {
+  return TYPES.find((t) => t.scope === scope2);
+}
 function knownTypeAliases() {
   return TYPES.map((t) => t.type);
 }
@@ -3824,6 +3830,10 @@ function registerCreateCommands(program) {
   });
 }
 
+// src/commands/update.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+
 // src/lib/resolve-entity.ts
 function resolveEntity(doc, scope2, idKey, nameKey, name, opts = {}) {
   const entries = getEntries(doc, scope2);
@@ -3864,6 +3874,78 @@ function resolveEntity(doc, scope2, idKey, nameKey, name, opts = {}) {
   return { id: String(hit[idKey]), entry: hit };
 }
 
+// src/lib/model-snapshot.ts
+var SNAPSHOT_FILENAME = "model.eventmodel";
+var SNAPSHOT_VERSION = 1;
+var SNAPSHOT_SCOPES = [...Object.keys(SCOPE_SCHEMAS), "scenarios"];
+function serializeModel(doc, modelId) {
+  const scopes = {};
+  for (const scope2 of SNAPSHOT_SCOPES) {
+    const map = getScopeMap(doc, scope2);
+    if (map.size === 0)
+      continue;
+    const entries = {};
+    for (const [id, entry] of map.entries()) {
+      entries[id] = entry.toJSON();
+    }
+    scopes[scope2] = entries;
+  }
+  return { version: SNAPSHOT_VERSION, modelId, scopes };
+}
+function applyModelSnapshot(doc, modelId, snapshot) {
+  const issues = [];
+  const unknownScopes = [];
+  const writes = [];
+  for (const [scope2, entries] of Object.entries(snapshot.scopes ?? {})) {
+    if (!SNAPSHOT_SCOPES.includes(scope2)) {
+      unknownScopes.push(scope2);
+      continue;
+    }
+    const map = getScopeMap(doc, scope2);
+    const validated = isValidatedScope(scope2);
+    const meta = resolveScope(scope2);
+    for (const [id, rawEntry] of Object.entries(entries)) {
+      if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+        issues.push(`${scope2}/${id}: entry must be a JSON object`);
+        continue;
+      }
+      let finalEntry;
+      if (validated) {
+        const res = validateEntry(scope2, rawEntry);
+        if (!res.ok) {
+          for (const issue of res.issues)
+            issues.push(`${scope2}/${id}: ${issue}`);
+          continue;
+        }
+        finalEntry = { ...res.data, modelId };
+        if (meta)
+          finalEntry[meta.idKey] = id;
+      } else {
+        finalEntry = { ...rawEntry };
+      }
+      writes.push({ scope: scope2, id, entry: finalEntry, isNew: !map.has(id) });
+    }
+  }
+  if (issues.length)
+    return { ok: false, issues };
+  const perScope = {};
+  doc.transact(() => {
+    for (const w of writes) {
+      const map = getScopeMap(doc, w.scope);
+      map.delete(w.id);
+      map.set(w.id, deepToY(w.entry));
+      const counts = perScope[w.scope] ??= { created: 0, updated: 0 };
+      if (w.isNew)
+        counts.created++;
+      else
+        counts.updated++;
+    }
+  });
+  const created = Object.values(perScope).reduce((a, s) => a + s.created, 0);
+  const updated = Object.values(perScope).reduce((a, s) => a + s.updated, 0);
+  return { ok: true, result: { created, updated, perScope, unknownScopes } };
+}
+
 // src/commands/update.ts
 var UPDATE_HELP = `
 Replace an existing element's entry with a new JSON shape. The new JSON is
@@ -3876,10 +3958,13 @@ Pattern (read-modify-write):
     | jq '.fields += [{"name":"customerId","fieldType":"UUID","isList":false,"isGenerated":false}]')
   eventmodeler update event "OrderPlaced" "$NEW"
 
-Linked-copy entries cannot be updated. They share the original's name and
-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).
+Linked-copy entries can be repositioned/resized but never re-identified. A
+copy shares its original's name and fields by design, so an update to a copy
+writes geometry (x, y, width, height) only — any name/field keys in the
+payload are ignored. To change a copy's name or fields, edit the original and
+all copies pick up the change. Address a copy by uuid:
+
+  eventmodeler --id <copy-uuid> update event '{"x":120,"y":340}'
 
 Flows have no addressable name and must be updated via uuid:
 
@@ -3893,9 +3978,82 @@ 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.
+
+Whole-model upsert:
+  eventmodeler update model [file]
+
+Reads a snapshot file (default ${SNAPSHOT_FILENAME}; see \`eventmodeler
+snapshot\`) and upserts every entry by id — existing ids are replaced, new
+ids created, and entries absent from the file are left untouched (upsert, not
+sync; nothing is deleted). Validation is all-or-nothing: if any entry fails,
+nothing is written.
 `;
+var GEOMETRY_KEYS = ["x", "y", "width", "height"];
+function extractGeometry(parsed) {
+  if (!parsed || typeof parsed !== "object") {
+    return { ok: false, values: {}, issues: ["payload must be a JSON object"] };
+  }
+  const obj = parsed;
+  const values = {};
+  const issues = [];
+  for (const k of GEOMETRY_KEYS) {
+    const v = obj[k];
+    if (v === undefined)
+      continue;
+    if (typeof v !== "number" || !Number.isFinite(v)) {
+      issues.push(`${k} must be a finite number`);
+      continue;
+    }
+    if ((k === "width" || k === "height") && v <= 0) {
+      issues.push(`${k} must be positive`);
+      continue;
+    }
+    values[k] = v;
+  }
+  if (issues.length === 0 && Object.keys(values).length === 0) {
+    issues.push("no geometry fields (x, y, width, height) present to update");
+  }
+  return { ok: issues.length === 0, values, issues };
+}
+async function runModelUpdate(args, opts) {
+  const file = args[0] ?? SNAPSHOT_FILENAME;
+  const filePath = path3.resolve(process.cwd(), file);
+  if (!fs3.existsSync(filePath)) {
+    console.error(`Snapshot file not found: ${file}. Run \`eventmodeler snapshot\` first.`);
+    process.exit(2);
+  }
+  let snapshot;
+  try {
+    snapshot = JSON.parse(fs3.readFileSync(filePath, "utf8"));
+  } catch (err) {
+    console.error(`Invalid JSON in ${file}: ${err.message}`);
+    process.exit(2);
+  }
+  if (!snapshot || typeof snapshot !== "object" || typeof snapshot.scopes !== "object") {
+    console.error(`${file} is not a model snapshot (missing "scopes"). Run \`eventmodeler snapshot\` to generate one.`);
+    process.exit(2);
+  }
+  const modelId = resolveModelId(opts.model);
+  const outcome = await withDoc(modelId, (doc) => applyModelSnapshot(doc, modelId, snapshot));
+  if (!outcome.ok) {
+    console.error(`Model update aborted — ${outcome.issues.length} validation error(s), nothing written:`);
+    for (const issue of outcome.issues)
+      console.error(`  - ${issue}`);
+    process.exit(2);
+  }
+  const { created, updated, perScope, unknownScopes } = outcome.result;
+  const breakdown = Object.entries(perScope).map(([scope2, c]) => `${scope2} +${c.created}/~${c.updated}`).join(", ");
+  console.log(`Model updated — ${created} created, ${updated} updated${breakdown ? ` (${breakdown})` : ""}.`);
+  if (unknownScopes.length) {
+    console.error(`Ignored unknown scope(s): ${unknownScopes.join(", ")}`);
+  }
+}
 function registerUpdateCommands(program) {
-  program.command("update <type> <args...>").description(`Replace an element's shape with JSON. Types: ${knownTypeAliases().join(", ")}`).option("--model <id>", "Model id (defaults to .eventmodeler.json in cwd)").addHelpText("after", UPDATE_HELP).action(async (type, args, opts) => {
+  program.command("update <type> [args...]").description(`Replace an element's shape with JSON (or 'model' for whole-model upsert). Types: ${knownTypeAliases().join(", ")}`).option("--model <id>", "Model id (defaults to .eventmodeler.json in cwd)").addHelpText("after", UPDATE_HELP).action(async (type, args, opts) => {
+    if (type === "model") {
+      await runModelUpdate(args, opts);
+      return;
+    }
     const meta = resolveType(type);
     if (!meta) {
       console.error(`Unknown type "${type}". Known: ${knownTypeAliases().join(", ")}`);
@@ -3933,32 +4091,45 @@ function registerUpdateCommands(program) {
       if (note)
         console.error(note);
     }
-    const validation = validateEntry(meta.scope, parsed);
-    if (!validation.ok) {
-      console.error(`Validation failed for ${meta.type}:`);
-      for (const issue of validation.issues)
-        console.error(`  - ${issue}`);
-      process.exit(2);
-    }
     const modelId = resolveModelId(opts.model);
     await withDoc(modelId, (doc) => {
       const { id, entry } = resolveEntity(doc, meta.scope, meta.idKey, meta.nameKey, name, {
         idOverride,
         includeLinkedCopies: Boolean(idOverride)
       });
+      const map = getScopeMap(doc, meta.scope);
       if (entry.isLinkedCopy) {
-        const originalId = meta.originalIdKey ? entry[meta.originalIdKey] : undefined;
-        console.error(`Cannot update ${meta.type} ${id} — it is a linked copy. ` + `Linked copies share their original's name and fields; edit the original instead` + (originalId ? ` (--id ${originalId}).` : "."));
+        const geom = extractGeometry(parsed);
+        if (!geom.ok) {
+          console.error(`Cannot update ${meta.type} ${id} (linked copy):`);
+          for (const issue of geom.issues)
+            console.error(`  - ${issue}`);
+          process.exit(2);
+        }
+        doc.transact(() => {
+          const e = map.get(id);
+          if (!e)
+            return;
+          for (const [k, v] of Object.entries(geom.values))
+            e.set(k, v);
+        });
+        console.log(`Updated ${meta.type} geometry (linked copy — name and fields stay tied to the original).`);
+        return;
+      }
+      const validation = validateEntry(meta.scope, parsed);
+      if (!validation.ok) {
+        console.error(`Validation failed for ${meta.type}:`);
+        for (const issue of validation.issues)
+          console.error(`  - ${issue}`);
         process.exit(2);
       }
-      const map = getScopeMap(doc, meta.scope);
       const finalEntry = { ...validation.data, [meta.idKey]: id, modelId };
       doc.transact(() => {
         map.delete(id);
         map.set(id, deepToY(finalEntry));
       });
+      console.log(`Updated ${meta.type}.`);
     });
-    console.log(`Updated ${meta.type}.`);
   });
 }
 
@@ -4037,6 +4208,37 @@ function removeGroup(doc, meta, originalId) {
   return { copies, flows };
 }
 
+// src/commands/snapshot.ts
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+var SNAPSHOT_HELP = `
+Write the entire model to a single JSON file (default ${SNAPSHOT_FILENAME})
+in the current directory. The file captures every scope — stickies,
+containers, flows and scenarios — keyed by id, so it is a faithful, editable
+copy of the whole model.
+
+Workflow (snapshot → edit → upsert):
+  eventmodeler snapshot                 # writes ${SNAPSHOT_FILENAME}
+  $EDITOR ${SNAPSHOT_FILENAME}                  # diff/edit the whole model
+  eventmodeler update model             # upserts your edits back
+
+The file is plain JSON. Each scope is an object of { "<id>": { ...entry } };
+the id is the map key, so renaming/adding entries means editing those keys.
+`;
+function registerSnapshotCommands(program) {
+  program.command("snapshot").description(`Save the entire model as JSON to ${SNAPSHOT_FILENAME} for offline editing`).option("--model <id>", "Model id (defaults to .eventmodeler.json in cwd)").option("--out <file>", `Output file (default ${SNAPSHOT_FILENAME})`).addHelpText("after", SNAPSHOT_HELP).action(async (opts) => {
+    const modelId = resolveModelId(opts.model);
+    const snapshot = await withDoc(modelId, (doc) => serializeModel(doc, modelId));
+    const outPath = path4.resolve(process.cwd(), opts.out ?? SNAPSHOT_FILENAME);
+    fs4.writeFileSync(outPath, `${JSON.stringify(snapshot, null, 2)}
+`, "utf8");
+    const scopeCount = Object.keys(snapshot.scopes).length;
+    const total = Object.values(snapshot.scopes).reduce((a, s) => a + Object.keys(s).length, 0);
+    const rel = path4.relative(process.cwd(), outPath) || outPath;
+    console.log(`Wrote ${total} element(s) across ${scopeCount} scope(s) to ${rel}.`);
+  });
+}
+
 // src/lib/update-check.ts
 var import_semver = __toESM(require_semver2(), 1);
 import { spawn } from "node:child_process";
@@ -4097,28 +4299,28 @@ async function fetchLatestVersion() {
   }
 }
 function promptYesNo(question) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     const rl = readline2.createInterface({
       input: process.stdin,
       output: process.stdout
     });
     const timeout = setTimeout(() => {
       rl.close();
-      resolve2(false);
+      resolve4(false);
     }, PROMPT_TIMEOUT_MS);
     rl.question(question, (answer) => {
       clearTimeout(timeout);
       rl.close();
-      resolve2(["y", "yes"].includes(answer.trim().toLowerCase()));
+      resolve4(["y", "yes"].includes(answer.trim().toLowerCase()));
     });
   });
 }
 function runUpdate() {
   const [command, args] = updateCommand(detectPackageManager());
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     const child = spawn(command, args, { stdio: "inherit" });
-    child.on("close", (code) => resolve2(code ?? 1));
-    child.on("error", () => resolve2(1));
+    child.on("close", (code) => resolve4(code ?? 1));
+    child.on("error", () => resolve4(1));
   });
 }
 async function maybeUpdateCli(packageName, currentVersion, argv) {
@@ -4159,8 +4361,8 @@ async function maybeUpdateCli(packageName, currentVersion, argv) {
 
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path3.dirname(__filename2);
-var packageJson = JSON.parse(fs3.readFileSync(path3.join(__dirname2, "..", "package.json"), "utf-8"));
+var __dirname2 = path5.dirname(__filename2);
+var packageJson = JSON.parse(fs5.readFileSync(path5.join(__dirname2, "..", "package.json"), "utf-8"));
 var program = new Command().name("eventmodeler").version(packageJson.version).description("CLI tool for interacting with Event Model files").option("--id <uuid>", "Skip name resolution, use UUID directly").option("--no-update-check", "Skip checking npm for a newer CLI version");
 setProgram(program);
 registerAuthCommands(program);
@@ -4171,6 +4373,7 @@ registerSummaryCommands(program);
 registerCreateCommands(program);
 registerUpdateCommands(program);
 registerRemoveCommands(program);
+registerSnapshotCommands(program);
 await maybeUpdateCli(packageJson.name, packageJson.version, process.argv);
 program.parseAsync(process.argv).catch((err) => {
   console.error("Error:", err.message);

package/package.json

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