@xano/sdk 1.0.0

package/dist/chunk-TRJCALW3.js

@@ -0,0 +1,291 @@
+import {
+  asTimestamp
+} from "./chunk-2MNLRIOX.js";
+import {
+  pipedYes
+} from "./chunk-T5KELPAR.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import {
+  describeTransportFailure,
+  httpFailure,
+  noteMetaAnswer,
+  parseJsonAnswer,
+  retryingFetch,
+  transportTarget,
+  withWriteStatusAftermath
+} from "./chunk-YLDALTWZ.js";
+import {
+  suggestAll
+} from "./chunk-UTI5G6OJ.js";
+
+// src/deploy/branch.ts
+var BRANCH_TIMEOUT_MS = 3e4;
+var BranchHttpError = class extends Error {
+  constructor(status, action, statusText, body, write = false) {
+    const head = httpFailure(action, { status, statusText }, body);
+    super(write ? withWriteStatusAftermath(head, status) : head);
+    this.status = status;
+    this.name = "BranchHttpError";
+  }
+  status;
+};
+var DEFAULT_BRANCH_LABEL = "v1";
+function endpoint(baseUrl, workspaceId, suffix = "") {
+  return `${baseUrl.replace(/\/$/, "")}/api:meta/workspace/${workspaceId}/branch${suffix}`;
+}
+var BranchLabelError = class extends Error {
+  name = "BranchLabelError";
+  code = "SDK_USAGE";
+};
+var BranchNotFoundError = class extends Error {
+  name = "BranchNotFoundError";
+  exitCode = 8;
+  /** The near label a typo most likely meant — the document's `suggestion`. */
+  suggestion;
+  /** Every near label, when several tie. */
+  suggestions;
+  constructor(message, near = []) {
+    super(message);
+    this.suggestion = near[0];
+    this.suggestions = near.length > 1 ? [...near] : void 0;
+  }
+};
+var BRANCH_LABEL_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/;
+function assertUsableBranchLabel(label, flag, withoutFlag = "drop the flag to release to whichever branch is currently live") {
+  const trimmed = label.trim();
+  if (trimmed === "") {
+    throw new BranchLabelError(
+      `\`${flag}\` needs a branch label and was given an empty one.
+The engine does not reject an empty label \u2014 it would create a branch with no name, which cannot be selected, promoted or deleted afterwards.`
+    );
+  }
+  if (trimmed === DEFAULT_BRANCH_LABEL) {
+    throw new BranchLabelError(
+      `\`${flag}=${DEFAULT_BRANCH_LABEL}\` names the workspace's DEFAULT branch, which is reserved.
+The engine does not store it as an ordinary branch, so it is not caught by an "already exists" check \u2014 targeting it does not stage anything, it writes to the branch every workspace starts on.
+Pick a different label, or ${withoutFlag}.`
+    );
+  }
+  if (!BRANCH_LABEL_PATTERN.test(trimmed)) {
+    throw new BranchLabelError(
+      `\`${flag}\` was given "${trimmed}", which is not a usable branch label.
+A label starts with a letter, digit or underscore and carries only letters, digits, underscores, dashes and dots (e.g. \`staging\`, \`release-2.1\`) \u2014 no spaces or slashes.`
+    );
+  }
+  return trimmed;
+}
+function findBranch(branches, label) {
+  const exact = branches.find((b) => b.label === label);
+  if (exact !== void 0) return exact;
+  const trimmed = label.trim();
+  if (trimmed === "") return void 0;
+  const near = branches.filter((b) => b.label.trim() === trimmed);
+  return near.length === 1 ? near[0] : void 0;
+}
+function requestInit(auth, init) {
+  return {
+    signal: AbortSignal.timeout(BRANCH_TIMEOUT_MS),
+    ...init,
+    headers: {
+      accept: "application/json",
+      Authorization: `Bearer ${auth.access_token}`,
+      ...init.headers ?? {}
+    }
+  };
+}
+function unreachable(action, url, err) {
+  return new Error(`${action} could not reach ${transportTarget(url)}: ${describeTransportFailure(err)}`, { cause: err });
+}
+async function bodyOf(res, action, write = false) {
+  const text = await res.text();
+  if (!res.ok) throw new BranchHttpError(res.status, action, res.statusText, text, write);
+  return text;
+}
+async function call(auth, url, init, action) {
+  let res;
+  try {
+    res = await fetch(url, requestInit(auth, init));
+    await noteMetaAnswer(url, res);
+  } catch (err) {
+    throw unreachable(action, url, err);
+  }
+  return bodyOf(res, action, true);
+}
+async function read(auth, url, action) {
+  let res;
+  try {
+    res = await retryingFetch(url, requestInit(auth, { method: "GET" }));
+  } catch (err) {
+    throw unreachable(action, url, err);
+  }
+  return bodyOf(res, action);
+}
+function toRecord(entry) {
+  if (entry === null || typeof entry !== "object") return void 0;
+  const row = entry;
+  const label = row.label;
+  if (typeof label !== "string" || label === "") return void 0;
+  return {
+    ...typeof row.id === "number" ? { id: row.id } : {},
+    label,
+    // Absent means false: the list shape omits `live` on non-live rows.
+    live: row.live === true,
+    backup: row.backup === true,
+    ...typeof row.created_at === "string" ? { createdAt: asTimestamp(row.created_at) ?? row.created_at } : {}
+  };
+}
+async function listBranchListing(auth, opts) {
+  const text = await read(auth, endpoint(opts.baseUrl, opts.workspaceId), "list branches");
+  const parsed = parseJsonAnswer(text, "list branches", opts.baseUrl);
+  if (!Array.isArray(parsed)) {
+    throw new Error(`list branches: ${transportTarget(opts.baseUrl)} answered with JSON that is not a list of branches.`);
+  }
+  const branches = [];
+  const unaddressable = [];
+  for (const entry of parsed) {
+    const record = toRecord(entry);
+    if (record !== void 0) {
+      branches.push(record);
+      continue;
+    }
+    if (entry === null || typeof entry !== "object") continue;
+    const row = entry;
+    unaddressable.push({
+      live: row.live === true,
+      backup: row.backup === true,
+      ...typeof row.created_at === "string" ? { createdAt: asTimestamp(row.created_at) ?? row.created_at } : {}
+    });
+  }
+  return { branches, unaddressable };
+}
+async function listBranches(auth, opts) {
+  return (await listBranchListing(auth, opts)).branches;
+}
+function liveBranchLabel(branches) {
+  return branches.find((b) => b.live)?.label;
+}
+async function createBranch(auth, opts) {
+  const label = assertUsableBranchLabel(opts.label, "branch label");
+  const text = await call(
+    auth,
+    endpoint(opts.baseUrl, opts.workspaceId),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        source_branch: opts.sourceBranch ?? DEFAULT_BRANCH_LABEL,
+        label,
+        description: opts.description ?? ""
+      })
+    },
+    "create branch"
+  );
+  const parsed = parseJsonAnswer(text, "create branch", opts.baseUrl);
+  const record = toRecord(parsed);
+  if (record === void 0) {
+    throw new Error(`create branch: ${transportTarget(opts.baseUrl)} answered, but named no branch.`);
+  }
+  return record;
+}
+async function setLiveBranch(auth, opts) {
+  await call(
+    auth,
+    `${endpoint(opts.baseUrl, opts.workspaceId, `/${encodeURIComponent(opts.label)}/live`)}`,
+    { method: "POST" },
+    "set live branch"
+  );
+}
+async function deleteBranch(auth, opts) {
+  await call(
+    auth,
+    endpoint(opts.baseUrl, opts.workspaceId, `/${encodeURIComponent(opts.label)}`),
+    { method: "DELETE" },
+    "delete branch"
+  );
+}
+function assertBranchAbsent(branches, label, purpose = "deploy") {
+  const trimmed = label.trim();
+  const held = branches.find((b) => b.label === label) ?? branches.find((b) => b.label.trim() === trimmed);
+  if (held === void 0) return;
+  const shown = held.label === label ? `"${label}"` : `${JSON.stringify(held.label)} (the stored label of "${label}")`;
+  const free = freeBranchLabel(branches, trimmed);
+  if (purpose === "backup") {
+    throw new BranchTakenError(
+      `A branch named ${shown} already exists in this workspace, so \`--backup-branch\` cannot snapshot the live branch under that label \u2014 a snapshot is always a new branch.
+Choose another label (\`${free}\` is free), or pass \`--backup-branch\` with no label for a timestamped one.`,
+      held.label,
+      free
+    );
+  }
+  const remedy = held.live ? `It is the LIVE branch, so it cannot be deleted. Pick a label that is free (\`${free}\` is), or make another branch live first (\`xanosdk workspace branch set-live <other>${pipedYes()}${contextFlags()}\`) and then delete it.` : `Pick a label that is free (\`${free}\` is), or delete it first with \`xanosdk workspace branch delete ${shellWord(held.label)}${pipedYes()}${contextFlags()}\`.`;
+  throw new BranchTakenError(
+    `A branch named ${shown} already exists in this workspace.
+Deploying into it is not offered: it would be a fresh import over a branch someone may be reviewing, and the SDK cannot tell those apart.
+` + remedy,
+    held.label,
+    free
+  );
+}
+var BranchTakenError = class extends Error {
+  constructor(message, label, freeLabel) {
+    super(message);
+    this.label = label;
+    this.details = { conflictsWith: { branch: label }, ...freeLabel === void 0 ? {} : { freeLabel } };
+  }
+  label;
+  name = "BranchTakenError";
+  code = "SDK_BRANCH_TAKEN";
+  exitCode = 2;
+  details;
+};
+function derivedLabelTail(now, random = Math.random) {
+  const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+  const tag = Math.floor(random() * 65536).toString(16).padStart(4, "0");
+  return `${stamp}-${tag}`;
+}
+function freeBranchLabel(branches, label, random = Math.random) {
+  const taken = new Set(branches.map((b) => b.label.trim()));
+  for (; ; ) {
+    const candidate = `${label}-${Math.floor(random() * 65536).toString(16).padStart(4, "0")}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+function requireBranch(branches, label) {
+  const found = findBranch(branches, label);
+  if (found !== void 0) return found;
+  const known = branches.map((b) => /\s/.test(b.label) ? JSON.stringify(b.label) : b.label).join(", ");
+  const near = suggestAll(label.trim(), branches.map((b) => b.label));
+  throw new BranchNotFoundError(
+    `This workspace has no branch named "${label}".
+` + (known === "" ? `It reports no branches at all.` : `It has: ${known}`) + (near.length === 0 ? "" : `
+Did you mean ${near.map((n) => JSON.stringify(n)).join(" or ")}?`),
+    near
+  );
+}
+
+export {
+  BranchHttpError,
+  DEFAULT_BRANCH_LABEL,
+  BranchLabelError,
+  BranchNotFoundError,
+  BRANCH_LABEL_PATTERN,
+  assertUsableBranchLabel,
+  findBranch,
+  listBranchListing,
+  listBranches,
+  liveBranchLabel,
+  createBranch,
+  setLiveBranch,
+  deleteBranch,
+  assertBranchAbsent,
+  BranchTakenError,
+  derivedLabelTail,
+  freeBranchLabel,
+  requireBranch
+};
+//# sourceMappingURL=chunk-TRJCALW3.js.map

package/dist/chunk-TTEIYD5P.js

@@ -0,0 +1,133 @@
+// src/fields/field.ts
+var COLUMN_NULLABLE_TYPES = [
+  "blob",
+  "blob_img",
+  "blob_video",
+  "blob_audio",
+  "geo_point",
+  "geo_multipoint",
+  "geo_linestring",
+  "geo_multilinestring",
+  "geo_polygon",
+  "geo_multipolygon",
+  "uuid",
+  "vector"
+];
+var COLUMN_NULLABLE_BY_DEFAULT = new Set(COLUMN_NULLABLE_TYPES);
+var INPUT_NULLABLE_TYPES = [...COLUMN_NULLABLE_TYPES, "file", "date", "epochms"];
+var INPUT_NULLABLE_BY_DEFAULT = new Set(INPUT_NULLABLE_TYPES);
+var INPUT_CONTEXT = {
+  customize: {},
+  marketItem: { id: 0, version: 0, guid: "" },
+  includeDescription: true,
+  nullableTypes: INPUT_NULLABLE_BY_DEFAULT
+};
+var COLUMN_CONTEXT = {
+  customize: {},
+  marketItem: { id: 0, version: 0, guid: "" },
+  includeDescription: true,
+  nullableTypes: COLUMN_NULLABLE_BY_DEFAULT
+};
+function defaultNullable(type, ctx) {
+  return ctx.nullableTypes.has(type);
+}
+function parseMethod(spec) {
+  if (typeof spec !== "string") return { name: spec.name, disabled: false, arg: spec.arg ?? [] };
+  const [name = spec, ...arg] = spec.split(/:(?<!^(?:ok|pattern|salt|startsWith):.+)/);
+  return { name, disabled: false, arg: arg.map((part) => part !== "" && String(Number(part)) === part ? Number(part) : part) };
+}
+function encodeMethods(methods) {
+  return (methods ?? []).map(parseMethod);
+}
+function encodeCustomize(customize) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [name, node] of Object.entries(customize ?? {})) {
+    out[name] = {
+      hidden: node.hidden ?? false,
+      default: node.default !== void 0 ? String(node.default) : "",
+      methods: encodeMethods(node.methods),
+      required: node.required ?? false,
+      customize: encodeCustomize(node.customize)
+    };
+  }
+  return out;
+}
+var RAW_FIELD = /* @__PURE__ */ Symbol.for("xanosdk.field.rawEnvelope");
+function defaultEntry(options) {
+  if (options.noDefault === true) return {};
+  return { default: options.default !== void 0 ? String(options.default) : "" };
+}
+function isListColumn(col) {
+  return (col.style?.type ?? (col.array ? "list" : "single")) === "list";
+}
+function encodeField(name, type, options, ctx) {
+  const rawEnvelope = options?.[RAW_FIELD];
+  if (rawEnvelope !== void 0) return rawEnvelope;
+  const field = {
+    name,
+    type,
+    _xsid: "",
+    nullable: options.nullable ?? ctx.nullableTypes.has(type),
+    ...defaultEntry(options),
+    merge: options.merge ?? false,
+    hidden: options.hidden !== void 0 ? [...options.hidden] : [],
+    override: [],
+    customize: options.customize !== void 0 ? encodeCustomize(options.customize) : ctx.customize,
+    required: options.required ?? false,
+    values: options.values ?? [],
+    mode: options.mode ?? "",
+    format: options.format ?? "",
+    sensitive: options.sensitive ?? false,
+    list: options.list ?? { min: "", max: "" },
+    vector: options.vector ?? { size: 3 },
+    access: options.access ?? "public",
+    style: options.style ?? { type: options.array ? "list" : "single" },
+    children: (options.children ?? []).map((ch) => encodeField(ch.name, ch.type, ch, ctx)),
+    methods: encodeMethods(options.methods),
+    market_item: ctx.marketItem,
+    is_settings_registry: false
+  };
+  if (ctx.includeDescription) {
+    field.description = options.description ?? "";
+  }
+  return field;
+}
+var CATALOG_BY_TYPE = {
+  text: "text",
+  int: "int",
+  decimal: "decimal",
+  bool: "bool",
+  uuid: "uuid",
+  date: "date",
+  email: "email",
+  password: "password",
+  json: "json",
+  epochms: "timestamp",
+  blob_img: "image",
+  blob_video: "video",
+  blob_audio: "audio",
+  blob: "attachment",
+  geo_point: "geo.point",
+  geo_multipoint: "geo.multipoint",
+  geo_linestring: "geo.linestring",
+  geo_multilinestring: "geo.multilinestring",
+  geo_polygon: "geo.polygon",
+  geo_multipolygon: "geo.multipolygon"
+};
+function authoredFieldType(type) {
+  return Object.hasOwn(CATALOG_BY_TYPE, type) ? CATALOG_BY_TYPE[type] : type;
+}
+
+export {
+  COLUMN_NULLABLE_TYPES,
+  INPUT_CONTEXT,
+  COLUMN_CONTEXT,
+  defaultNullable,
+  parseMethod,
+  RAW_FIELD,
+  isListColumn,
+  encodeField,
+  CATALOG_BY_TYPE,
+  authoredFieldType
+};
+//# sourceMappingURL=chunk-TTEIYD5P.js.map