@xano/sdk 1.0.0

package/dist/chunk-BWPNT55T.js

@@ -0,0 +1,680 @@
+import {
+  diffAgainstLive,
+  payloadOf,
+  sectionKind,
+  tableAdditions,
+  vectorSize
+} from "./chunk-45UIT5T2.js";
+import {
+  ReleaseHttpError
+} from "./chunk-2ZUEE4EK.js";
+import {
+  TenantHttpError
+} from "./chunk-A3UDOZB6.js";
+import {
+  CliError,
+  detail,
+  warn,
+  withoutUrls
+} from "./chunk-PTHVMXZI.js";
+import {
+  suggest
+} from "./chunk-UTI5G6OJ.js";
+import {
+  authoredFieldType
+} from "./chunk-TTEIYD5P.js";
+
+// src/emit/plan-disclosure.ts
+var NO_TABLE_EFFECTS = {
+  mode: "merge",
+  droppedTables: [],
+  createdTables: [],
+  addedColumns: [],
+  addedDefaults: {},
+  renamedTables: [],
+  droppedColumns: [],
+  retypedColumns: [],
+  narrowedEnums: [],
+  retargetedRefs: [],
+  indexChanges: [],
+  notNullKept: [],
+  notNullTightened: []
+};
+function tableEffects(outgoing, live, opts) {
+  const diff = diffAgainstLive(outgoing, live, {
+    mode: opts.mode === "rebuild" ? "replace" : "merge",
+    ...opts.stored === void 0 ? {} : { stored: opts.stored }
+  });
+  return tableEffectsOf(diff, tableAdditions(outgoing, live), opts);
+}
+function tableEffectsOf(diff, additions, opts) {
+  const skip = opts.skipTables ?? /* @__PURE__ */ new Set();
+  const kept = (list) => list.filter((c) => !skip.has(c.table));
+  const keptName = (list) => list.filter((c) => !skip.has(c.slice(0, c.indexOf("."))));
+  const dotted = (list) => kept(list).map((c) => `${c.table}.${c.column}`);
+  const rebuild = opts.mode === "rebuild";
+  const addedColumns = keptName(additions?.addedColumns ?? []);
+  return {
+    mode: opts.mode,
+    droppedTables: opts.mode === "replace" ? diff.uncarriedTables.map((table) => ({
+      table,
+      rows: null,
+      ...diff.replacedTables.includes(table) ? { replaced: true } : {}
+    })) : [],
+    createdTables: (additions?.createdTables ?? []).filter((t) => !skip.has(t)),
+    addedColumns,
+    addedDefaults: Object.fromEntries(
+      Object.entries(additions?.addedDefaults ?? {}).filter(([c]) => addedColumns.includes(c))
+    ),
+    renamedTables: (additions?.renamedTables ?? []).filter((r) => !skip.has(r.to)),
+    droppedColumns: dotted(diff.droppedColumns),
+    retypedColumns: rebuild ? [] : kept(diff.retypedColumns),
+    narrowedEnums: kept(diff.narrowedEnums),
+    retargetedRefs: kept(diff.retargetedRefs),
+    indexChanges: kept(diff.indexChanges),
+    // Measured: a replace relaxes NOT NULL, so only a merge can keep it.
+    notNullKept: opts.mode === "merge" ? dotted(diff.unrelaxedColumns) : [],
+    notNullTightened: kept(diff.tightenedColumns),
+    // A replace converts a reseeded table's storage like any other (measured),
+    // so the reseed does not take it out of the check.
+    storageChanges: rebuild ? [] : opts.mode === "replace" ? [...diff.storageChanges] : kept(diff.storageChanges)
+  };
+}
+async function assertStorageModesKept(changes, count, ctx) {
+  if (changes === void 0 || changes.length === 0) return;
+  const mode = (xdo) => xdo ? "JSON storage" : "column storage";
+  const Subject = ctx.subject.charAt(0).toUpperCase() + ctx.subject.slice(1);
+  const Target = ctx.target.charAt(0).toUpperCase() + ctx.target.slice(1);
+  const countOf = async (c) => await count({ name: c.liveName, ...c.guid === void 0 ? {} : { guid: c.guid } }) ?? null;
+  const rowsText = (rows) => rows === null ? "rows not counted" : `${rows} ${rows === 1 ? "row" : "rows"}`;
+  const refuse = (message, held2) => new CliError("SDK_IMPORT_REFUSED", message, {
+    exitCode: 2,
+    details: {
+      refused: "storageModeChange",
+      landed: false,
+      tables: held2.map((c) => ({ table: c.table, from: c.from, to: c.to, rows: c.rows }))
+    }
+  });
+  if (ctx.mode === "replace") {
+    for (const c of changes.filter((c2) => !c2.to)) {
+      detail(`${Subject} switches table ${c.table} to column storage (useXdo true \u2192 false); the instance converts it and keeps every value.`);
+    }
+    const toXdo = changes.filter((c) => c.to);
+    if (toXdo.length === 0) return;
+    const held2 = await Promise.all(toXdo.map(async (c) => ({ ...c, rows: await countOf(c) })));
+    throw refuse(
+      `${Target} was not changed: ${ctx.subject} switches ${held2.length === 1 ? "a table" : `${held2.length} tables`} to JSON storage, and the instance cannot convert a table from column storage back to JSON storage \u2014 it refuses the deploy whether or not the table holds rows:
+` + held2.map((c) => `  table ${c.table} (${rowsText(c.rows)}): useXdo false \u2192 true`).join("\n") + `
+Nothing was sent. Keep each table's storage as it is: give the table \`useXdo: false\` \u2014 a table without its own \`useXdo\` follows the workspace's \`use_xdo\`. To switch one anyway, land a release that carries the JSON-storage table under a new name beside the old one, copy the rows across, then land one without the old table.`,
+      held2
+    );
+  }
+  const counted = await Promise.all(changes.map(async (c) => ({ ...c, rows: await countOf(c) })));
+  for (const c of counted.filter((c2) => c2.rows === 0)) {
+    detail(`${Subject} switches table ${c.table} to ${mode(c.to)} (useXdo ${c.from} \u2192 ${c.to}); it holds no rows, so nothing is lost.`);
+  }
+  const held = counted.filter((c) => c.rows !== 0);
+  if (held.length === 0) return;
+  const lines = held.map(
+    (c) => `  table ${c.table} (${rowsText(c.rows)}): useXdo ${c.from} \u2192 ${c.to} \u2014 ` + (c.from ? "every stored value would be erased (the rows stay, every field reads empty) and cannot be restored" : "the instance cannot convert a table that holds rows: the deploy fails partway on a NOT NULL violation")
+  );
+  throw refuse(
+    `${Target} was not changed: ${ctx.subject} switches ${held.length === 1 ? "a table" : `${held.length} tables`} holding rows to the other storage mode, which a merge cannot do without losing them:
+${lines.join("\n")}
+Nothing was written. Keep each table's storage as it is: give the table \`useXdo: ${held[0].from}\`${held.some((c) => c.from !== held[0].from) ? " (or the mode it has now)" : ""} \u2014 a table without its own \`useXdo\` follows the workspace's \`use_xdo\`. To switch one anyway, declare the switched table as a new table, copy the rows across, then remove the old one${ctx.remedy === void 0 ? "." : `, or ${ctx.remedy}`}`,
+    held
+  );
+}
+function xdoConversionRefused(err) {
+  return (err instanceof TenantHttpError || err instanceof ReleaseHttpError) && /cannot be migrated from custom column names back to xdo/i.test(err.message);
+}
+function xdoConversionRefusal(target, err, cause) {
+  const table = /\bdatabase (\S+) cannot be migrated/i.exec(err.message)?.[1];
+  const Target = target.charAt(0).toUpperCase() + target.slice(1);
+  return new CliError(
+    "SDK_IMPORT_REFUSED",
+    `${Target} was not changed: the instance cannot convert ${table === void 0 ? "a table" : `table ${table}`} from column storage back to JSON storage (useXdo false \u2192 true), whether or not it holds rows, and refused the deploy. Nothing landed. Keep the table's storage as it is: give it \`useXdo: false\` \u2014 a table without its own \`useXdo\` follows the workspace's \`use_xdo\`.`,
+    {
+      exitCode: 2,
+      cause,
+      details: {
+        refused: "storageModeChange",
+        landed: false,
+        tables: table === void 0 ? [] : [{ table, from: false, to: true, rows: null }]
+      }
+    }
+  );
+}
+function replaceRetype(c) {
+  if (resizesVector(c)) return "stops";
+  const time = (t) => t === "epochms" || t === "timestamp";
+  if (c.from === "bool") return time(c.to) ? "stops" : c.to === "decimal" ? "converts" : "re-read";
+  if (time(c.from)) {
+    if (c.to === "int") return c.nullable === true ? "converts" : "stops";
+    return c.to === "decimal" ? "stops" : c.to === "bool" ? "converts" : "re-read";
+  }
+  return "converts";
+}
+function replaceConverts(c) {
+  return replaceRetype(c) === "converts";
+}
+function replaceCanStop(c) {
+  return replaceRetype(c) === "stops" || c.from === "text" && (c.to === "epochms" || c.to === "timestamp");
+}
+function stoppingRetypes(e) {
+  return e.mode === "replace" ? e.retypedColumns.filter(replaceCanStop).map((c) => `${c.table}.${c.column}`) : [];
+}
+function replaceRetypeNote(c) {
+  const outcome = replaceRetype(c);
+  if (outcome === "re-read") return ` \u2014 re-read, not converted: ${reReading(c)}`;
+  if (outcome === "stops") return ` \u2014 not converted: ${stopCondition(c)}`;
+  if (c.from === "bool") return " \u2014 converted for good: true \u2192 1, false \u2192 0";
+  if (c.from !== "epochms" && c.from !== "timestamp") return "";
+  return c.to === "int" ? " \u2014 converted for good: every timestamp \u2192 null" : " \u2014 converted for good: every value \u2192 false";
+}
+function reReading(c) {
+  const to = authoredFieldType(c.to);
+  if (c.from === "bool" && c.to === "text") return `true and false read "true" and "false"`;
+  if (c.from === "bool" && c.to === "int") return "true and false read 1 and 0";
+  if ((c.from === "epochms" || c.from === "timestamp") && c.to === "text") return `a timestamp reads as its epoch milliseconds ("1767225600000")`;
+  return `a value that does not read as ${to} reads null`;
+}
+function stopCondition(c) {
+  const from = authoredFieldType(c.from);
+  const to = authoredFieldType(c.to);
+  if (c.to === "int") {
+    return `a stored ${from} converts to null and ${c.column} is not nullable, so the deploy stops partway while a row holds a ${from} (a 0 lands as 0)`;
+  }
+  return `a stored ${from} does not convert to ${to}, so the deploy stops partway while the table holds rows`;
+}
+var READ_ONLY_SOURCES = /* @__PURE__ */ new Set(["bool", "epochms", "timestamp"]);
+function omittedInsertsFail(retype, mode) {
+  if (mode === "rebuild") return false;
+  if (mode === "replace") return retype.to === "text" && READ_ONLY_SOURCES.has(retype.from);
+  if (retype.useXdo === true) return false;
+  const c = asStored(retype);
+  if (c.from === c.to) return false;
+  if (c.to === "uuid") return c.from !== "json";
+  if (TEXT_HELD.has(c.from)) return false;
+  const writes = TEXT_HELD.has(c.to) ? "text" : c.to === "json" ? "json" : NUMBER_WRITTEN.has(c.to) ? "number" : void 0;
+  if (writes === void 0) return false;
+  if (writes === "number" && !REFUSES_NUMBER.has(c.from) && !c.from.startsWith("geo_")) return false;
+  return !(writes === "text" && c.default !== void 0 && readsAs(c.from, c.default));
+}
+var TEXT_HELD = /* @__PURE__ */ new Set(["text", "email", "password", "enum"]);
+var NUMBER_WRITTEN = /* @__PURE__ */ new Set(["int", "decimal", "epochms", "timestamp", "bool"]);
+var REFUSES_NUMBER = /* @__PURE__ */ new Set(["date", "uuid"]);
+function readsAs(type, value) {
+  const v = value.trim();
+  switch (type) {
+    case "int":
+    case "epochms":
+    case "timestamp":
+      return /^[+-]?\d+$/.test(v);
+    case "decimal":
+      return v !== "" && Number.isFinite(Number(v));
+    case "bool":
+      return /^(t|f|true|false|y|n|yes|no|on|off|1|0)$/i.test(v);
+    case "date":
+      return /^\d{4}-\d{2}-\d{2}$/.test(v);
+    case "uuid":
+      return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(v);
+    case "json":
+      try {
+        JSON.parse(v);
+        return true;
+      } catch {
+        return false;
+      }
+    default:
+      return false;
+  }
+}
+function setInsertsFail(retype, mode) {
+  const c = asStored(retype);
+  if (mode !== "merge") return false;
+  return resizesVector(c) || c.useXdo !== true && c.to === "uuid" && c.from !== "uuid" && !TEXT_HELD.has(c.from);
+}
+function resizesVector(c) {
+  const from = vectorSize(c.from);
+  const to = vectorSize(c.to);
+  return from !== void 0 && to !== void 0 && from !== to;
+}
+function newColumnRemedy(c) {
+  return `add the ${resizesVector(c) ? "new size" : "uuid"} as a new column (another name) instead`;
+}
+function asStored(c) {
+  return c.stored === void 0 || c.stored === c.from ? c : { ...c, from: c.stored };
+}
+function holding(c, mode, aside = "") {
+  const old = authoredFieldType(asStored(c).from);
+  if (mode !== "merge" || c.stored !== void 0) return `the column keeps holding ${old}${aside}, so`;
+  return `if the column still holds ${old} as created (no record here says an earlier merge retyped it)${aside},`;
+}
+function unknownStorageNote(c, mode) {
+  if (mode !== "merge" || c.stored !== void 0 || c.useXdo === true) return "";
+  return ` \u2014 what inserts do depends on the type the column holds, and no record here says it still holds ${authoredFieldType(c.from)} as created`;
+}
+function insertsFailNote(c, mode) {
+  if (setInsertsFail(c, mode)) {
+    return `${holding(c, mode, resizesVector(asStored(c)) ? ", which takes no other size" : ", which takes no uuid")} an insert that sets it fails with an SQL error` + (omittedInsertsFail(c, mode) ? " and so does one that leaves it unset" : "") + ` \u2014 ${newColumnRemedy(asStored(c))}`;
+  }
+  return `${holding(c, mode)} an insert that leaves it unset fails ${mode === "replace" ? "(SQL 22P02)" : "with an SQL error"} ${omittedInsertsRemedy(mode === "merge" ? asStored(c) : c)}`;
+}
+function omittedInsertsRemedy(c) {
+  if (c.to === "uuid") return "\u2014 a uuid column takes no default, so set it on every insert";
+  const example = TEXT_HELD.has(c.to) ? OLD_TYPE_DEFAULTS[c.from] : void 0;
+  if (example === void 0) return "whatever default it declares \u2014 set it on every insert";
+  const old = authoredFieldType(c.from);
+  return c.to === "enum" ? `until it declares a default ${old} also reads \u2014 an enum value such as ${JSON.stringify(example)}` : `until it declares a default ${old} also reads, such as ${JSON.stringify(example)}`;
+}
+var OLD_TYPE_DEFAULTS = {
+  int: "0",
+  decimal: "0",
+  epochms: "0",
+  timestamp: "0",
+  bool: "false",
+  date: "1970-01-01",
+  json: "{}",
+  uuid: "00000000-0000-0000-0000-000000000000"
+};
+function mergeReading(retype) {
+  const c = asStored(retype);
+  if (c.from === c.to) return "back to the type its values are stored as: every value reads as stored";
+  if (resizesVector(c)) {
+    return `every stored vector has ${vectorSize(c.from)} dimensions, so each reads null while the column has the new size, and reads again if it is changed back`;
+  }
+  if (c.from === "decimal" && c.to === "int") return "values read truncated (29.789 reads 29) and read whole again once retyped back";
+  if (c.useXdo === true) {
+    const dated = c.to === "epochms" || c.to === "timestamp" || c.to === "date";
+    if (c.from === "json" && c.to === "date") return "every read of the table fails (HTTP 500) while a row holds a json object there";
+    if ((c.from === "text" || c.from === "enum") && dated) {
+      return 'a stored value is not checked as a date: it can read as written ("12" reads 12) or as the time of the read ("x"), not null';
+    }
+    if (c.from === "bool" && c.to === "enum") return "true reads the enum's first value";
+    if (c.from === "decimal" && c.to === "text") return 'values read as stored (1.5 reads "1.5")';
+  }
+  if (c.from === "decimal" && c.to === "text") return `values read padded to the column's scale (29.789 reads "29.78900")`;
+  if (c.from === "bool" && c.to === "text") return 'true reads "1" and false reads ""';
+  if (c.from === "int" && c.to === "date") return 'values read as epoch milliseconds (5 reads "1970-01-01")';
+  if (c.from.startsWith("geo_") && c.to === "text") return "values read as hex-encoded geometry";
+  return void 0;
+}
+function typeChange(c) {
+  return `${authoredFieldType(c.from)} \u2192 ${authoredFieldType(c.to)}`;
+}
+function alteringChanges(e) {
+  const replace = e.mode === "replace";
+  return [
+    ...e.droppedTables.map((t) => `drop table ${t.table} \u2014 ${rowsGone(t.rows)}${t.replaced ? REPLACED_TABLE : ""}`),
+    ...e.renamedTables.map((r) => `rename table ${r.from} \u2192 ${r.to} (rows kept)`),
+    ...e.droppedColumns.map((c) => `drop column ${c} \u2014 every value it holds is destroyed`),
+    ...e.retypedColumns.map(
+      (c) => `retype ${c.table}.${c.column} (${typeChange(c)}) \u2014 ` + (!replace ? mergeReading(c) ?? `a stored value that does not read as ${authoredFieldType(c.to)} reads null` : replaceRetype(c) === "stops" ? stopCondition(c) : replaceConverts(c) ? `stored values are converted to ${authoredFieldType(c.to)} for good; one that does not convert becomes ${c.to === "int" && c.nullable === true ? "null" : emptyOf(c.to)}` : reReading(c)) + (setInsertsFail(c, e.mode) ? `; an insert that sets it fails${omittedInsertsFail(c, e.mode) ? ", and so does one that leaves it unset" : ""} \u2014 ${newColumnRemedy(asStored(c))}` : omittedInsertsFail(c, e.mode) ? `; an insert that leaves it unset fails ${omittedInsertsRemedy(e.mode === "merge" ? asStored(c) : c)}` : "")
+    ),
+    ...e.narrowedEnums.map(
+      (n) => `${n.table}.${n.column} loses ${n.removed.map((v) => `"${v}"`).join(", ")} \u2014 a row holding one reads null`
+    ),
+    ...e.retargetedRefs.map(
+      (r) => `${r.table}.${r.column} points at ${r.to} instead of ${r.from} \u2014 the ids rows hold now name ${r.to} rows`
+    ),
+    ...e.indexChanges.map(
+      (c) => `${c.action} index ${c.table}: ${c.index}` + (c.action === "add" && c.unique ? " \u2014 refused if the rows already hold duplicates for it" : "")
+    ),
+    ...e.notNullKept.map(
+      (c) => `${c} becomes nullable \u2014 if the table enforces NOT NULL there, it keeps refusing a row without a value`
+    ),
+    ...e.notNullTightened.map(
+      (c) => `${c.table}.${c.column} stops being nullable \u2014 a row holding null ` + (replace ? `is rewritten to ${emptyOf(c.type)} for good` : `reads ${emptyOf(c.type)}`)
+    )
+  ];
+}
+function additiveChanges(e) {
+  return [
+    ...e.createdTables.map((t) => `create table ${t}`),
+    ...e.addedColumns.map((c) => {
+      const value = e.addedDefaults[c];
+      return `add column ${c} \u2014 existing rows read ${value === void 0 ? "the type's empty value" : `its default ${JSON.stringify(value)}`}`;
+    })
+  ];
+}
+var REPLACED_TABLE = "; the release's table of that name is another table (another identity), created empty in its place";
+function droppedTableLine(t) {
+  return `${t.table} (${t.rows === null ? "rows not counted" : `${t.rows} ${t.rows === 1 ? "row" : "rows"}`})` + (t.replaced ? REPLACED_TABLE : "");
+}
+function rowsGone(rows) {
+  return rows === null ? "every row it holds is deleted" : `its ${rows} ${rows === 1 ? "row is" : "rows are"} deleted`;
+}
+function emptyOf(type) {
+  if (type === "int" || type === "decimal" || type === "epochms" || type === "timestamp") return "0";
+  if (type === "text" || type === "email" || type === "password") return '""';
+  if (type === "bool") return "false";
+  return "the type's empty value";
+}
+function tableEffectFields(e) {
+  return {
+    droppedColumns: [...e.droppedColumns],
+    // `converted` under a replace only; `omittedInsertsFail` / `setInsertsFail` only where they hold.
+    // Types as authored (`timestamp`, never the stored `epochms`), matching the text output.
+    retypedColumns: e.retypedColumns.map((c) => ({
+      ...c,
+      from: authoredFieldType(c.from),
+      to: authoredFieldType(c.to),
+      ...c.stored !== void 0 ? { stored: authoredFieldType(c.stored) } : {},
+      ...e.mode === "replace" ? { converted: replaceConverts(c), ...replaceRetype(c) === "stops" ? { stops: true } : {} } : {},
+      ...omittedInsertsFail(c, e.mode) ? { omittedInsertsFail: true } : {},
+      ...setInsertsFail(c, e.mode) ? { setInsertsFail: true } : {}
+    })),
+    narrowedEnums: e.narrowedEnums.map((c) => ({ ...c, removed: [...c.removed] })),
+    retargetedRefs: e.retargetedRefs.map((c) => ({ ...c })),
+    indexChanges: e.indexChanges.map((c) => ({ ...c })),
+    notNullKept: [...e.notNullKept],
+    notNullTightened: e.notNullTightened.map((c) => ({ ...c, type: authoredFieldType(c.type) })),
+    storageChanges: storageChangesPayload(e.storageChanges ?? [])
+  };
+}
+function storageChangesPayload(changes) {
+  return changes.map((c) => ({ table: c.table, from: c.from, to: c.to }));
+}
+function tableEffectsPayload(e) {
+  return {
+    mode: e.mode,
+    droppedTables: e.droppedTables.map((t) => ({ ...t })),
+    createdTables: [...e.createdTables],
+    addedColumns: [...e.addedColumns],
+    addedDefaults: { ...e.addedDefaults },
+    renamedTables: e.renamedTables.map((r) => ({ ...r })),
+    ...tableEffectFields(e)
+  };
+}
+function discloseTableEffects(e, opts) {
+  const will = opts.will ?? "will";
+  const Subject = opts.subject.charAt(0).toUpperCase() + opts.subject.slice(1);
+  const say = (code, msg, items) => {
+    const remedy = opts.remedies?.[code];
+    warn(msg, code, remedy === void 0 ? items : [...items, remedy]);
+  };
+  const replace = e.mode === "replace";
+  if (opts.additiveWhere !== void 0) {
+    const added = additiveChanges(e);
+    if (added.length > 0) say("plan.schema-additive", `${Subject} ${will} add to ${opts.additiveWhere}:`, added);
+  }
+  if (e.droppedTables.length > 0) {
+    const one = e.droppedTables.length === 1;
+    say(
+      "plan.table-drop",
+      `${Subject} ${will} DROP ${plural(e.droppedTables.length, "table", "tables")} the release does not carry, with every row in ${one ? "it" : "them"}:`,
+      e.droppedTables.map(droppedTableLine)
+    );
+  }
+  if (e.renamedTables.length > 0) {
+    say(
+      "plan.table-rename",
+      `${Subject} ${will} rename ${plural(e.renamedTables.length, "table", "tables")}, keeping ${e.renamedTables.length === 1 ? "its" : "their"} rows:`,
+      e.renamedTables.map((r) => `${r.from} \u2192 ${r.to}`)
+    );
+  }
+  if (e.droppedColumns.length > 0) {
+    const one = e.droppedColumns.length === 1;
+    say(
+      "plan.column-drop",
+      `${Subject} ${will} DROP ${plural(e.droppedColumns.length, "column", "columns")}, with the values in ${one ? "it" : "them"}:`,
+      // A drop beside an add on one table reads as a rename, and is not one.
+      [...e.droppedColumns, ...droppedAndAdded(e).map((p) => renameHint(p, opts.stages))]
+    );
+  }
+  if (e.retypedColumns.length > 0) {
+    const n = plural(e.retypedColumns.length, "column changes", "columns change");
+    const lead = replace ? `${n} type \u2014 ${opts.subject} CONVERTS the stored values for good, and retyping back does not restore them: a value that converts does (int \u2192 text: 11 \u2192 "11"; text \u2192 int: "12" \u2192 12, "1.5" \u2192 2), one that does not becomes the type's empty value (text \u2192 int: "hello" \u2192 0; int or decimal \u2192 bool: every value \u2192 false), and one it cannot convert stops the deploy partway (text \u2192 timestamp: "hello"). A pair that differs says so:` : `${n} type \u2014 ${opts.subject} changes only the definition and leaves the stored values: one that reads as the new type does (int \u2192 text: 11 reads "11"), one that does not reads null while the column has the new type, and reads again if it is retyped back:`;
+    say(
+      "plan.column-retype",
+      lead,
+      e.retypedColumns.map(
+        (c) => `${c.table}.${c.column} (${typeChange(c)})` + (replace ? replaceRetypeNote(c) : "") + (!replace && mergeReading(c) !== void 0 ? ` \u2014 ${mergeReading(c)}` : "") + (omittedInsertsFail(c, e.mode) || setInsertsFail(c, e.mode) ? ` \u2014 ${insertsFailNote(c, e.mode)}` : unknownStorageNote(c, e.mode))
+      )
+    );
+  }
+  if (e.narrowedEnums.length > 0) {
+    say(
+      "plan.enum-values-removed",
+      `${plural(e.narrowedEnums.length, "enum column loses", "enum columns lose")} values \u2014 ${opts.subject} changes only the definition: a row holding a removed value reads null until the value is restored:`,
+      e.narrowedEnums.map((n) => `${n.table}.${n.column} (removes ${n.removed.map((v) => `"${v}"`).join(", ")})`)
+    );
+  }
+  if (e.retargetedRefs.length > 0) {
+    say(
+      "plan.tableref-retarget",
+      `${plural(e.retargetedRefs.length, "table reference points", "table references point")} at another table \u2014 ${opts.subject} keeps the ids the rows hold, which now name rows of the new table:`,
+      e.retargetedRefs.map((r) => `${r.table}.${r.column} (${r.from} \u2192 ${r.to})`)
+    );
+  }
+  if (e.indexChanges.length > 0) {
+    const uniqueAdd = e.indexChanges.some((c) => c.action === "add" && c.unique);
+    say(
+      "plan.index-change",
+      `${Subject} ${will} change ${plural(e.indexChanges.length, "index", "indexes")}` + (uniqueAdd ? " \u2014 a unique index it adds is refused if the rows already there hold duplicates for it:" : ":"),
+      e.indexChanges.map((c) => `${c.action} ${c.table}: ${c.index}`)
+    );
+  }
+  if (e.notNullKept.length > 0) {
+    say(
+      "plan.not-null-kept",
+      `${plural(e.notNullKept.length, "column becomes", "columns become")} nullable, and a merge does not relax a NOT NULL the table enforces: a column created required keeps refusing a row without a value (NOT NULL violation) while the export reads nullable \u2014 one made required by a merge was never enforced \u2014 and later deploys cannot see it:`,
+      e.notNullKept
+    );
+  }
+  if (e.notNullTightened.length > 0) {
+    say(
+      "plan.not-null-tightened",
+      replace ? `${plural(e.notNullTightened.length, "column stops", "columns stop")} being nullable \u2014 ${opts.subject} rewrites the rows that hold null there to the type's empty value (int 0, text "") for good: making it nullable again does not bring the nulls back:` : `${plural(e.notNullTightened.length, "column stops", "columns stop")} being nullable, and a merge does not rewrite the rows that hold null there: they read back as the type's empty value (int 0, text "", and a date column's key is left out of every row):`,
+      e.notNullTightened.map((c) => `${c.table}.${c.column} (${authoredFieldType(c.type)})`)
+    );
+  }
+}
+function droppedAndAdded(e) {
+  return droppedAndAddedAll(e).flatMap((p) => {
+    if (p.dropped.length === p.added.length) return [p];
+    const near = (a, b) => {
+      const [x, y] = [a.toLowerCase(), b.toLowerCase()];
+      const shorter = Math.min(x.length, y.length);
+      return shorter >= 4 && suggest(x, [y]) !== void 0 || shorter >= 3 && (x.includes(y) || y.includes(x));
+    };
+    const pairs = p.dropped.flatMap((d) => {
+      const a = p.added.find((c) => near(d, c));
+      return a === void 0 ? [] : [[d, a]];
+    });
+    if (pairs.length === 0) return [];
+    return [{ table: p.table, dropped: pairs.map(([d]) => d), added: [...new Set(pairs.map(([, a]) => a))] }];
+  });
+}
+function droppedAndAddedAll(e) {
+  const column = (dotted) => {
+    const at = dotted.indexOf(".");
+    return [dotted.slice(0, at), dotted.slice(at + 1)];
+  };
+  const out = /* @__PURE__ */ new Map();
+  for (const d of e.droppedColumns) {
+    const [table, name] = column(d);
+    const entry = out.get(table) ?? { dropped: [], added: [] };
+    entry.dropped.push(name);
+    out.set(table, entry);
+  }
+  for (const a of e.addedColumns) {
+    const [table, name] = column(a);
+    out.get(table)?.added.push(name);
+  }
+  return [...out].filter(([, v]) => v.added.length > 0).map(([table, v]) => ({ table, ...v }));
+}
+function renameHint(p, stages = "releases") {
+  const list = (names) => names.join(", ");
+  return `${p.table} drops ${list(p.dropped)} and adds ${list(p.added)}. A column has no identity of its own to rename by, so this does not move the values: those in ${list(p.dropped)} are destroyed and ${list(p.added)} start${p.added.length === 1 ? "s" : ""} empty. To keep them, land it as two ${stages}: one that adds ${list(p.added)} beside ${list(p.dropped)}, then backfill the rows, then one that drops ${list(p.dropped)}.`;
+}
+function releaseCanonicalMoves(archive, live) {
+  const out = [];
+  const held = payloadOf(live);
+  for (const [section, rows] of Object.entries(payloadOf(archive))) {
+    const there = held[section];
+    if (!Array.isArray(rows) || !Array.isArray(there)) continue;
+    for (const row of rows) {
+      if (row === null || typeof row !== "object") continue;
+      const r = row;
+      if (typeof r.guid !== "string" || r.guid === "" || typeof r.canonical !== "string" || r.canonical === "") continue;
+      const current = there.find(
+        (l) => l !== null && typeof l === "object" && l.guid === r.guid
+      );
+      const from = current?.canonical;
+      if (typeof from !== "string" || from === "" || from === r.canonical) continue;
+      out.push({ kind: sectionKind(section, r), name: typeof r.name === "string" ? r.name : "", from, to: r.canonical });
+    }
+  }
+  return out;
+}
+function discloseCanonicalMoves(moves, opts) {
+  if (moves.length === 0) return;
+  const Subject = opts.subject.charAt(0).toUpperCase() + opts.subject.slice(1);
+  warn(
+    `${Subject} ${opts.will ?? "will"} move ${plural(moves.length, "public URL", "public URLs")}${opts.when === void 0 ? "" : ` ${opts.when}`} \u2014 every endpoint under the slug served now stops answering:`,
+    "plan.canonical-change",
+    moves.map((m) => `${m.kind} "${m.name}": ${m.from} \u2192 ${m.to}`)
+  );
+}
+function movesClause(moves, lead = "It") {
+  if (moves.length === 0) return "";
+  return ` ${lead} MOVES ${moves.length === 1 ? "a public URL" : `${moves.length} public URLs`} (` + moves.map((m) => `${m.from} \u2192 ${m.to}`).join(", ") + `): the old ${moves.length === 1 ? "slug stops" : "slugs stop"} answering.`;
+}
+function plural(n, one, many) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+async function releaseTableEffects(loadArchive, loadLive, opts = {}) {
+  let archive;
+  try {
+    archive = await loadArchive();
+  } catch (err) {
+    return { failure: "the release archive could not be read", read: "archive", cause: err };
+  }
+  if (archive === void 0) return { failure: "the release carries no id to read its archive from" };
+  let live;
+  try {
+    live = await loadLive();
+  } catch (err) {
+    const raw = err instanceof Error ? err.message : String(err);
+    const reason = withoutUrls(raw).replace(/\s+/g, " ").trim();
+    return { failure: reason.length > 200 ? `${reason.slice(0, 200)}\u2026` : reason, read: "destination", cause: err };
+  }
+  return { effects: tableEffects(archive, live, { ...opts, mode: opts.mode ?? "merge" }) };
+}
+function readOnce(read) {
+  let cached;
+  return () => {
+    cached ??= read().catch((err) => {
+      cached = void 0;
+      throw err;
+    });
+    return cached;
+  };
+}
+function uniqueIndexCandidates(e) {
+  return (e?.indexChanges ?? []).filter((c) => c.action === "add" && c.unique).map((c) => ({ table: c.table, index: c.index }));
+}
+function namedConstraint(stop, effects) {
+  const retyped = effects?.retypedColumns ?? [];
+  if (stop.kind === "not-null" && stop.column === void 0 && retyped.length > 0 && (effects?.notNullTightened ?? []).length === 0) {
+    return namedConstraint({ ...stop, kind: "conversion", notNull: true }, effects);
+  }
+  if (stop.kind === "conversion") {
+    if (stop.column !== void 0) return stop;
+    const stopping = effects?.mode === "replace" ? retyped.filter(replaceCanStop) : [];
+    const from = stopping.length > 0 ? stopping : retyped;
+    if (from.length === 1) {
+      const c = from[0];
+      return { ...stop, table: c.table, column: c.column, retypes: [{ ...c }] };
+    }
+    return from.length > 1 ? { ...stop, retypes: from.map((c) => ({ ...c })) } : stop;
+  }
+  if (stop.kind !== "unique" || stop.table !== void 0 || stop.index !== void 0) return stop;
+  const candidates = uniqueIndexCandidates(effects);
+  if (candidates.length === 1) return { ...stop, table: candidates[0].table, index: candidates[0].index };
+  return candidates.length > 1 ? { ...stop, candidates } : stop;
+}
+function constraintWhere(stop) {
+  const parts = [
+    stop.table === void 0 ? void 0 : `table "${stop.table}"`,
+    stop.index === void 0 ? void 0 : `index "${stop.index}"`,
+    stop.column === void 0 ? void 0 : `field "${stop.column}"`
+  ].filter((p) => p !== void 0);
+  const retype = stop.retypes?.length === 1 ? stop.retypes[0] : void 0;
+  if (parts.length > 0) return ` (${parts.join(", ")}${retype === void 0 ? "" : `: ${typeChange(retype)}`})`;
+  if (stop.retypes !== void 0 && stop.retypes.length > 1) {
+    return ` (one of: ${stop.retypes.map((c) => `${c.table}.${c.column} ${typeChange(c)}`).join("; ")})`;
+  }
+  if (stop.candidates !== void 0 && stop.candidates.length > 0) {
+    return ` (one of: ${stop.candidates.map((c) => `table "${c.table}" ${c.index}`).join("; ")})`;
+  }
+  return "";
+}
+function constraintStop(err) {
+  if (!(err instanceof TenantHttpError || err instanceof ReleaseHttpError)) return void 0;
+  const m = err.message;
+  const kind = /\b23505\b|unique[ _]violation|duplicate key/i.test(m) ? "unique" : /\b23502\b|not[ _-]null[ _]violation/i.test(m) ? "not-null" : /\b23503\b|foreign[ _]key[ _]violation/i.test(m) ? "foreign-key" : (
+    // Data exceptions: a value that does not read as the column's new
+    // type (22P02), is out of its range (22003), or is not a date (22007, 22008).
+    /\b22(?:P02|003|007|008|018)\b|invalid (?:text|input) (?:representation|syntax)|out of range/i.test(m) ? "conversion" : void 0
+  );
+  if (kind === void 0) return void 0;
+  const table = /\b(?:table|relation) "([^"]+)"/i.exec(m)?.[1];
+  const index = /\b(?:constraint|index) "([^"]+)"/i.exec(m)?.[1];
+  const column = /\bKey \(([^)]+)\)=/.exec(m)?.[1] ?? /\bcolumn "([^"]+)"/i.exec(m)?.[1];
+  return {
+    kind,
+    ...table === void 0 ? {} : { table },
+    ...index === void 0 ? {} : { index },
+    ...column === void 0 ? {} : { column }
+  };
+}
+var CONSTRAINT_PHRASE = {
+  unique: "a unique index",
+  "not-null": "a required column",
+  "foreign-key": "a reference",
+  conversion: "a column type (a stored value does not convert to it)"
+};
+var CONSTRAINT_FIX = {
+  unique: "Make the rows that share a value in the newly unique field distinct (or drop the unique index from the release)",
+  "not-null": "Fill the rows the newly required field is empty in (or give the field a default in the release)",
+  "foreign-key": "Remove or repoint the rows that reference a row that is not there",
+  conversion: "Change the stored values that do not read as the new type (or drop the retype from the release)"
+};
+
+export {
+  NO_TABLE_EFFECTS,
+  tableEffects,
+  tableEffectsOf,
+  assertStorageModesKept,
+  xdoConversionRefused,
+  xdoConversionRefusal,
+  replaceRetype,
+  replaceConverts,
+  stoppingRetypes,
+  omittedInsertsFail,
+  setInsertsFail,
+  alteringChanges,
+  additiveChanges,
+  droppedTableLine,
+  tableEffectFields,
+  storageChangesPayload,
+  tableEffectsPayload,
+  discloseTableEffects,
+  droppedAndAdded,
+  renameHint,
+  releaseCanonicalMoves,
+  discloseCanonicalMoves,
+  movesClause,
+  releaseTableEffects,
+  readOnce,
+  uniqueIndexCandidates,
+  namedConstraint,
+  constraintWhere,
+  constraintStop,
+  CONSTRAINT_PHRASE,
+  CONSTRAINT_FIX
+};
+//# sourceMappingURL=chunk-BWPNT55T.js.map