@xanots/sdk 0.0.1

package/dist/release-command-VV5UVZKL.js

@@ -0,0 +1,427 @@
+import {
+  confirm
+} from "./chunk-5YTBTF25.js";
+import {
+  assertBundleInput,
+  loadBundleText
+} from "./chunk-NOO35BQ2.js";
+import {
+  importWorkspaceArchive,
+  planWorkspaceImport
+} from "./chunk-5WGEURVI.js";
+import {
+  encodeWorkspaceArchive
+} from "./chunk-ZUTSMMAG.js";
+import "./chunk-X4DVXBFY.js";
+import {
+  isMachineOutput,
+  writeJson
+} from "./chunk-NUQCEOKA.js";
+import "./chunk-3IGNIP6R.js";
+import {
+  getAccessToken
+} from "./chunk-C56BC2FY.js";
+import "./chunk-7REDODS2.js";
+import {
+  resolveLockPath
+} from "./chunk-YGPIY3WT.js";
+import {
+  UsageError,
+  assertWritableDest
+} from "./chunk-IZW6MK3U.js";
+import {
+  blank,
+  detail,
+  info,
+  link,
+  step,
+  success,
+  warn
+} from "./chunk-EZG76F7R.js";
+import "./chunk-3DUAGYGP.js";
+import "./chunk-YYRDLFSJ.js";
+import "./chunk-EMCAWMHC.js";
+import "./chunk-WHOJWOSV.js";
+import "./chunk-LH6Z6KFV.js";
+import {
+  readLockFile
+} from "./chunk-HJPTWBLH.js";
+import "./chunk-GNPVYOPB.js";
+import {
+  REFERENCEABLE_KIND_PAYLOAD_KEYS,
+  lockKey
+} from "./chunk-4HT3BNZ7.js";
+
+// src/emit/release-command.ts
+import { existsSync } from "fs";
+var DESTRUCTIVE_ACTIONS = /* @__PURE__ */ new Set(["delete", "truncate", "drop"]);
+var IDENTITY_EXEMPT_TYPES = /* @__PURE__ */ new Set(["workspace"]);
+function resolveRequest(args) {
+  if (args.replace) {
+    const conflicting = [
+      args.prune ? "--prune" : "",
+      args.resetData ? "--reset-data" : "",
+      args.seed ? "--seed" : ""
+    ].filter(Boolean);
+    if (conflicting.length > 0) {
+      throw new UsageError(
+        `\`--replace\` cannot be combined with ${conflicting.join(" or ")}. A replace already clears every object and every table row, so there is nothing left for those flags to describe. Drop \`--replace\` to merge, or drop ${conflicting.join("/")}.`,
+        { helpFor: { command: "release" } }
+      );
+    }
+    return { mode: "replace" };
+  }
+  return {
+    mode: "merge",
+    prune: args.prune,
+    records: args.seed,
+    truncate: args.resetData
+  };
+}
+function isDestructive(req) {
+  return req.mode === "replace" || req.prune === true || req.truncate === true || req.records === true;
+}
+function countByAction(plan) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const op of plan.operations) {
+    counts.set(op.action, (counts.get(op.action) ?? 0) + 1);
+  }
+  return counts;
+}
+function correspondence(plan) {
+  let matched = 0;
+  let created = 0;
+  let orphaned = 0;
+  for (const op of plan.operations) {
+    if (IDENTITY_EXEMPT_TYPES.has(op.type)) continue;
+    if (op.action === "create") created++;
+    else if (op.action === "delete") orphaned++;
+    else matched++;
+  }
+  return { matched, created, orphaned };
+}
+function warnOnZeroCorrespondence(plan, req, targetIsEmpty2) {
+  if (req.mode !== "merge") return;
+  const { matched, created, orphaned } = correspondence(plan);
+  if (matched > 0 || created === 0) return;
+  if (targetIsEmpty2) return;
+  blank();
+  if (orphaned > 0) {
+    warn(
+      `NOTHING MATCHED. All ${created} objects would be created and ${orphaned} existing objects deleted \u2014 not one object already in this workspace shares an identity with this project.`
+    );
+    detail("This is not an update. It empties the workspace and rebuilds it from scratch.");
+    detail(
+      "That is what promoting into a workspace this project has never released to looks like \u2014 including one populated by `--replace`, which mints its own identities."
+    );
+    detail("To adopt what is already there, pin those objects' guids on your defs first. A prune here is not recoverable.");
+  } else {
+    warn(`Nothing matched: all ${created} objects would be created, none updated.`);
+    detail(
+      "If this workspace is already populated, its objects carry different identities and you will end up with two of everything. Only a workspace this project has already released to will match."
+    );
+  }
+}
+function payloadKeyFor(type) {
+  return REFERENCEABLE_KIND_PAYLOAD_KEYS[type] ?? type;
+}
+function splitPruneDeletes(plan, tracked) {
+  const collateral = [];
+  const owned = [];
+  for (const op of plan.operations) {
+    if (op.action !== "delete") continue;
+    if (IDENTITY_EXEMPT_TYPES.has(op.type)) continue;
+    (tracked.has(lockKey(payloadKeyFor(op.type), op.name)) ? owned : collateral).push(op);
+  }
+  return { collateral, owned };
+}
+async function reconcileLockAfterReplace(args, auth, workspaceId) {
+  const lockPath = args.lockPath ?? (args.file !== void 0 ? resolveLockPath(args, args.file) : void 0);
+  if (lockPath === void 0 || !existsSync(lockPath)) {
+    blank();
+    warn("`--replace` rebuilt this workspace with new object identities.");
+    detail("Nothing pins them, so the next release will match nothing and create a duplicate of every object.");
+    detail("Run `xanots lock adopt` against this workspace, and commit the lock.");
+    return;
+  }
+  const live = await readLiveWorkspace(auth, workspaceId);
+  if (live === void 0) {
+    blank();
+    warn(`\`--replace\` minted new object identities and ${lockPath} still names the old ones.`);
+    detail("The target could not be re-read to update it, so the next release would match nothing.");
+    detail(`Run \`xanots lock adopt\` against this workspace before releasing again.`);
+    return;
+  }
+  try {
+    const { adoptFromBundle } = await import("./lock-3CVKALKT.js");
+    const { readLockFile: readLockFile2, writeLockFile } = await import("./io-AMIKRLPC.js");
+    const { lock, added, changed } = adoptFromBundle(readLockFile2(lockPath), live, lockPath);
+    writeLockFile(lockPath, lock);
+    const touched = added.length + changed.length;
+    if (touched > 0) {
+      detail(`Updated ${touched} lock entr${touched === 1 ? "y" : "ies"} to the identities \`--replace\` minted.`);
+      detail("Commit the lock \u2014 without it the next release matches nothing.");
+    }
+  } catch (err) {
+    blank();
+    warn(`Could not update ${lockPath} after the replace: ${err instanceof Error ? err.message : String(err)}`);
+    detail("It still names the identities the replace destroyed. Run `xanots lock adopt` before releasing again.");
+  }
+}
+async function readLiveWorkspace(auth, workspaceId) {
+  try {
+    const { exportWorkspaceBundle } = await import("./workspace-export-AJMGN3CQ.js");
+    return await exportWorkspaceBundle(auth, {
+      base: auth.instance,
+      workspaceId,
+      label: "reading the target workspace"
+    });
+  } catch {
+    return void 0;
+  }
+}
+function targetIsEmpty(live) {
+  if (live === void 0) return false;
+  const payload = live.payload;
+  if (payload === null || typeof payload !== "object") return false;
+  return !Object.entries(payload).some(
+    // The workspace settings row is present in every workspace, empty or not.
+    ([key, value]) => key !== "workspace" && Array.isArray(value) && value.length > 0
+  );
+}
+async function convergedWithLive(live, req, outgoingBundle) {
+  if (live === void 0 || req.mode !== "merge") return false;
+  if (req.records === true || req.truncate === true) return false;
+  const { compareToLive } = await import("./live-diff-Y3AKETHE.js");
+  let result;
+  try {
+    result = compareToLive(JSON.parse(outgoingBundle), live);
+  } catch {
+    return false;
+  }
+  if (!result.converged) return false;
+  if (req.prune === true && result.liveOnly.length > 0) return false;
+  return true;
+}
+async function warnAboutLiveLosses(live, req, outgoingBundle) {
+  if (live === void 0) {
+    blank();
+    warn("Could not read the target workspace, so this plan does not account for dropped columns or env that will not update.");
+    return { droppedColumns: 0, unchangedEnv: [] };
+  }
+  const { diffAgainstLive } = await import("./live-diff-Y3AKETHE.js");
+  let diff;
+  try {
+    diff = diffAgainstLive(JSON.parse(outgoingBundle), live, { mode: req.mode });
+  } catch {
+    return { droppedColumns: 0, unchangedEnv: [] };
+  }
+  if (diff.droppedColumns.length > 0) {
+    blank();
+    warn(
+      `${diff.droppedColumns.length} column${diff.droppedColumns.length === 1 ? "" : "s"} will be DROPPED, destroying the data held in ${diff.droppedColumns.length === 1 ? "it" : "them"}:`
+    );
+    for (const { table, column } of diff.droppedColumns) {
+      detail(`drop column ${table}."${column}"`);
+    }
+    detail("The plan reports these as a routine in-place table update; they are not recoverable.");
+  }
+  if (diff.unchangedEnv.length > 0) {
+    blank();
+    warn(
+      `${diff.unchangedEnv.length} environment variable${diff.unchangedEnv.length === 1 ? "" : "s"} will NOT be updated: ${diff.unchangedEnv.map((e) => e.name).join(", ")}`
+    );
+    detail("A merge is add-only for env: it creates keys that do not exist and leaves existing ones as they are.");
+    detail("To change these values, set them in the workspace directly, or release with `--replace` (which rebuilds the workspace).");
+  }
+  return {
+    droppedColumns: diff.droppedColumns.length,
+    unchangedEnv: diff.unchangedEnv.map((e) => e.name)
+  };
+}
+function assertPruneStaysInScope(args, plan) {
+  if (args.lockPath === void 0 && args.file === void 0) {
+    throw new UsageError(
+      "`--prune` needs a lock file to know which objects belong to this project, and `--bundle` carries none. Pass `--lock=<path>` to name the lock that was written when the bundle was compiled, release from the entry file instead, or drop `--prune`.",
+      { helpFor: { command: "release" } }
+    );
+  }
+  const lockPath = resolveLockPath(args, args.file ?? ".");
+  if (!existsSync(lockPath)) {
+    throw new UsageError(
+      `\`--prune\` needs a lock file and none exists at ${lockPath}.
+Without it there is no record of which objects this project created, so a prune cannot tell yours from ones that were already in the workspace \u2014 and it deletes both.
+Create one with \`xanots export ${args.file} --lock\` and commit it, or drop \`--prune\`.`,
+      { helpFor: { command: "release" } }
+    );
+  }
+  const tracked = new Set(Object.keys(readLockFile(lockPath).objects));
+  const { collateral, owned } = splitPruneDeletes(plan, tracked);
+  if (collateral.length === 0) return;
+  blank();
+  const lines = collateral.map((op) => `  ${op.type} "${op.name}"${op.reason !== void 0 ? ` \u2014 ${op.reason}` : ""}`);
+  throw new UsageError(
+    `\`--prune\` would delete ${collateral.length} object${collateral.length === 1 ? "" : "s"} this project has never released:
+${lines.join("\n")}
+
+\`--prune\` is documented as deleting objects your project no longer defines, but the endpoint deletes everything absent from the bundle \u2014 including objects that predate the project. Dropping a populated table is not recoverable.
+` + (owned.length > 0 ? `The ${owned.length} deletion${owned.length === 1 ? "" : "s"} this project does own would have been correct.
+` : "") + `To delete the objects above anyway, adopt them into the project first (\`xanots lock adopt\`) so they are yours to remove. To keep them, drop \`--prune\`.`,
+    { helpFor: { command: "release" } }
+  );
+}
+function renderPlan(plan, req, workspaceId, targetIsEmpty2, converged = false) {
+  const counts = countByAction(plan);
+  const label = plan.workspaceName !== void 0 ? `${plan.workspaceName} (#${workspaceId})` : `#${workspaceId}`;
+  blank();
+  step(`Plan for workspace ${label}`);
+  if (converged) {
+    detail("no changes \u2014 every object this project defines already matches the workspace");
+    return;
+  }
+  const order = ["create", "update", "delete", "truncate", "drop"];
+  const seen = [...order.filter((a) => counts.has(a)), ...[...counts.keys()].filter((a) => !order.includes(a))];
+  if (seen.length === 0) {
+    detail("no changes");
+  } else {
+    for (const action of seen) {
+      detail(`${action}: ${counts.get(action)}`);
+    }
+  }
+  const destructive = plan.operations.filter((op) => DESTRUCTIVE_ACTIONS.has(op.action));
+  if (destructive.length > 0) {
+    blank();
+    warn(`${destructive.length} destructive operation${destructive.length === 1 ? "" : "s"}:`);
+    for (const op of destructive) {
+      const why = op.reason !== void 0 ? ` \u2014 ${op.reason}` : "";
+      detail(`${op.action} ${op.type} "${op.name}"${why}`);
+    }
+  }
+  if (plan.hasRecords) {
+    blank();
+    warn("Table rows from the bundle WILL be written.");
+  }
+  blank();
+  if (plan.hasEnv) {
+    warn("Environment variables from the bundle WILL be written.");
+    if (req.mode === "merge") {
+      detail("Merge is add-only: keys that do not exist are created; existing keys are NOT updated.");
+    }
+  } else {
+    detail("The archive carries no environment variables \u2014 existing env is left untouched.");
+  }
+  const notes = plan.summary.notes;
+  if (typeof notes === "string" && notes !== "") {
+    blank();
+    warn(notes);
+  } else if (Array.isArray(notes)) {
+    blank();
+    for (const note of notes) {
+      if (typeof note === "string" && note !== "") warn(note);
+    }
+  }
+  if (req.mode === "replace") {
+    blank();
+    warn("`--replace` wipes this workspace before importing \u2014 including table data and history.");
+  }
+  warnOnZeroCorrespondence(plan, req, targetIsEmpty2);
+  blank();
+}
+async function runReleaseCommand(args) {
+  assertWritableDest(args.dest, "release");
+  const req = resolveRequest(args);
+  assertBundleInput(args, { command: "release" });
+  const auth = await getAccessToken(args);
+  const { bundle, source, content, nonPublicSeedValues } = await loadBundleText(
+    args,
+    { command: "release" },
+    { withSeed: req.records === true }
+  );
+  if (args.static !== void 0) {
+    const { assertNoSeedLeaks } = await import("./deploy-command-4EQ7XX5G.js");
+    await assertNoSeedLeaks(args.static, nonPublicSeedValues, args.allowSeedInStatic);
+  }
+  const workspaceId = auth.workspaceId;
+  const archive = encodeWorkspaceArchive(bundle, content);
+  if (req.records === true && content.length === 0) {
+    warn("`--seed` was passed, but no table in this project declares seed rows \u2014 no rows will be written.");
+  }
+  const target = { baseUrl: auth.instance, archive, workspaceId, ...req };
+  step(
+    `Releasing ${source} \u2192 instance workspace #${workspaceId}` + (req.mode === "replace" ? " (full replace)" : " (merge)")
+  );
+  const plan = await planWorkspaceImport(auth, target);
+  const live = await readLiveWorkspace(auth, workspaceId);
+  const converged = await convergedWithLive(live, req, bundle);
+  renderPlan(plan, req, workspaceId, targetIsEmpty(live), converged);
+  const losses = await warnAboutLiveLosses(live, req, bundle);
+  if (req.prune === true) assertPruneStaysInScope(args, plan);
+  if (args.dryRun) {
+    info("Dry run \u2014 nothing was sent.");
+    if (isMachineOutput(args)) writeJson({ released: false, dryRun: true, workspaceId, plan });
+    return;
+  }
+  const upToDate = plan.operations.length === 0 || converged;
+  if (upToDate) {
+    success(`Workspace #${workspaceId} is already up to date \u2014 no import sent.`);
+  } else {
+    if ((isDestructive(req) || losses.droppedColumns > 0) && !args.yes && !args.force) {
+      const ok = await confirm(`Apply this plan to workspace #${workspaceId}?`, {
+        flag: "--yes",
+        helpFor: { command: "release" }
+      });
+      if (!ok) {
+        info("Release cancelled.");
+        return;
+      }
+    }
+    await importWorkspaceArchive(auth, target);
+    success(`Released to instance workspace #${workspaceId}`);
+    if (req.mode === "replace") await reconcileLockAfterReplace(args, auth, workspaceId);
+  }
+  link(auth.instance);
+  const summary = {
+    // `released: false` with `upToDate: true` is a SUCCESS, not a failure — the
+    // workspace already matches. A wrapper gating on `released` alone would read
+    // a converged release as a broken one, so both fields are always present.
+    released: !upToDate,
+    upToDate,
+    mode: req.mode,
+    prune: req.prune === true,
+    // What HAPPENED, not the flag that was asked for. This is the one field
+    // someone checks to confirm a seed landed, and echoing the input into it
+    // reported success over a write that never occurred (issue #167). Rows go
+    // out only when the flag was set AND the archive actually carried some AND
+    // the import ran.
+    records: req.records === true && content.length > 0 && !upToDate,
+    truncate: req.truncate === true,
+    workspaceId,
+    instance: auth.instance,
+    // What this release will DO, not what the plan enumerated: a converged
+    // release sends nothing, and reporting the server's matched-identity count
+    // beside `upToDate: true` would contradict it.
+    operations: upToDate ? 0 : plan.operations.length,
+    droppedColumns: losses.droppedColumns,
+    unchangedEnv: losses.unchangedEnv
+  };
+  if (args.static !== void 0) {
+    const { buildStaticEnv, deployStaticTo } = await import("./deploy-command-4EQ7XX5G.js");
+    const env = buildStaticEnv(auth.instance, args.staticEnv);
+    const explicit = Object.keys(args.staticEnv).length > 0;
+    summary.static = await deployStaticTo(
+      args.static,
+      auth,
+      { baseUrl: auth.instance, workspaceId, label: void 0 },
+      env,
+      explicit,
+      args.staticHost,
+      args.noVerify,
+      args.staticRouting
+    );
+  }
+  if (isMachineOutput(args)) writeJson(summary);
+}
+export {
+  runReleaseCommand
+};
+//# sourceMappingURL=release-command-VV5UVZKL.js.map