eventmodeler 0.6.10 → 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
@@ -3896,6 +3978,15 @@ 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) {
@@ -3924,8 +4015,45 @@ function extractGeometry(parsed) {
   }
   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(", ")}`);
@@ -4080,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";
@@ -4140,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) {
@@ -4202,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);
@@ -4214,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.10",
+  "version": "0.6.11",
   "description": "CLI tool for event modeling - explore, design, and generate code from your event models",
   "type": "module",
   "repository": {