@xano/sdk 1.0.0

package/dist/chunk-73IVBKMA.js

@@ -0,0 +1,250 @@
+import {
+  hasString,
+  isRecord,
+  listAnswer,
+  recordAnswer,
+  writeTransportFailure
+} from "./chunk-6PBR37LN.js";
+import {
+  appendSentence,
+  fetchOrExplain,
+  httpFailure,
+  serverMessage,
+  statusLabel,
+  transportTarget
+} from "./chunk-YLDALTWZ.js";
+
+// src/deploy/tests.ts
+function labelledMessage(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed) || typeof parsed.message !== "string" || parsed.message.trim() === "") return void 0;
+  return serverMessage(text);
+}
+var PERMANENT_CODES = /* @__PURE__ */ new Set([
+  "ERROR_CODE_NOT_FOUND",
+  "ERROR_CODE_ACCESS_DENIED",
+  "ERROR_CODE_UNAUTHORIZED",
+  "ERROR_CODE_BAD_REQUEST",
+  "ERROR_CODE_INPUT_ERROR",
+  "ERROR_CODE_PERMISSION_DENIED"
+]);
+function permanentEngineError(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return false;
+  }
+  if (!isRecord(parsed)) return false;
+  if (typeof parsed.code === "string" && PERMANENT_CODES.has(parsed.code)) return true;
+  const message = typeof parsed.message === "string" ? parsed.message : "";
+  return /^\s*invalid\b|\bnot found\b|\baccess denied\b|\bpermission denied\b|\bunauthori[sz]ed\b/i.test(message);
+}
+var TIMEOUT_MS = 12e4;
+var PAGE_SIZE = 100;
+var MAX_PAGES = 100;
+function qualifiedName(handle) {
+  if (handle.kind === "workflow") return `workflow:${handle.name}`;
+  const object = handle.object;
+  if (object === void 0) return handle.name;
+  const owner = object.type === "query" && object.group !== void 0 && object.verb !== void 0 ? `${object.group}|${object.verb}|${object.name}` : object.name;
+  return `${object.type}:${owner}/${handle.name}`;
+}
+function objectQualifiedName(handle) {
+  return handle.object === void 0 ? void 0 : `${handle.object.type}:${handle.object.name}/${handle.name}`;
+}
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+async function metaFetch(auth, url, action, init) {
+  return fetchOrExplain(
+    url,
+    {
+      ...init,
+      headers: {
+        accept: "application/json",
+        Authorization: `Bearer ${auth.access_token}`,
+        ...init?.headers ?? {}
+      },
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    },
+    action,
+    TIMEOUT_MS
+  ).catch((err) => {
+    throw (init?.method ?? "GET").toUpperCase() !== "GET" ? writeTransportFailure(err) : err;
+  });
+}
+function readPage(text, action, url, isRow) {
+  const { rows, envelope } = listAnswer(text, action, url, isRow);
+  return { rows, nextPage: typeof envelope?.nextPage === "number" ? envelope.nextPage : void 0 };
+}
+async function collectPages(auth, buildUrl, action, isRow, onTruncate) {
+  const rows = [];
+  for (let page = 1; page <= MAX_PAGES; page++) {
+    const url = buildUrl(page);
+    const res = await metaFetch(auth, url, action, { method: "GET" });
+    const text = await res.text();
+    if (!res.ok) {
+      const message = httpFailure(action, res, text);
+      const unanswered = res.status >= 500 && !permanentEngineError(text) || res.status === 429;
+      throw unanswered ? new TestRunUnansweredError(message, res.status) : new Error(message);
+    }
+    const { rows: pageRows, nextPage } = readPage(text, action, url, isRow);
+    rows.push(...pageRows);
+    if (pageRows.length === 0 || nextPage === void 0) return rows;
+  }
+  onTruncate?.(rows.length);
+  return rows;
+}
+async function listUnitTests(auth, target, onTruncate) {
+  const rows = await collectPages(
+    auth,
+    (page) => `${target.base}/api:meta/workspace/${target.workspaceId}/unit_test?page=${page}&per_page=${PAGE_SIZE}`,
+    "list unit tests",
+    // A unit test is addressed by its string id and shown by its name.
+    (row) => hasString(row, "id") && hasString(row, "name"),
+    onTruncate
+  );
+  const queryIds = new Set(
+    rows.flatMap((row) => row.obj_type === "query" && typeof row.obj_id === "number" ? [row.obj_id] : [])
+  );
+  const located = queryIds.size === 0 ? /* @__PURE__ */ new Map() : await locateQueries(auth, target, queryIds);
+  return rows.flatMap((row) => {
+    const id = asString(row.id);
+    const name = asString(row.name);
+    if (id === void 0 || name === void 0) return [];
+    const objectType = asString(row.obj_type);
+    const objectName = asString(row.obj_name);
+    const place = objectType === "query" && typeof row.obj_id === "number" ? located.get(row.obj_id) : void 0;
+    return [
+      {
+        kind: "unit",
+        id,
+        name,
+        object: objectType !== void 0 && objectName !== void 0 ? { type: objectType, name: objectName, ...place ?? {} } : void 0,
+        datasource: typeof row.datasource === "string" ? row.datasource : void 0
+      }
+    ];
+  });
+}
+async function locateQueries(auth, target, ids) {
+  const root = `${target.base}/api:meta/workspace/${target.workspaceId}/apigroup`;
+  const groups = await collectPages(
+    auth,
+    (page) => `${root}?page=${page}&per_page=${PAGE_SIZE}`,
+    "list API groups",
+    (row) => typeof row.id === "number" && hasString(row, "name")
+  );
+  const placed = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    if (placed.size === ids.size) break;
+    const groupName = group.name;
+    const queries = await collectPages(
+      auth,
+      (page) => `${root}/${group.id}/api?page=${page}&per_page=${PAGE_SIZE}`,
+      `list the queries in API group "${groupName}"`,
+      (row) => typeof row.id === "number" && hasString(row, "verb")
+    );
+    for (const query of queries) {
+      const id = query.id;
+      if (ids.has(id)) placed.set(id, { group: groupName, verb: query.verb });
+    }
+  }
+  return placed;
+}
+async function listWorkflowTests(auth, target, onTruncate) {
+  const rows = await collectPages(
+    auth,
+    (page) => `${target.base}/api:meta/workspace/${target.workspaceId}/workflow_test?page=${page}&per_page=${PAGE_SIZE}&include_xanoscript=false`,
+    "list workflow tests",
+    // A workflow test is addressed by its numeric id and shown by its name.
+    (row) => typeof row.id === "number" && hasString(row, "name"),
+    onTruncate
+  );
+  return rows.flatMap((row) => {
+    const name = asString(row.name);
+    if (typeof row.id !== "number" || name === void 0) return [];
+    return [
+      {
+        kind: "workflow",
+        id: row.id,
+        name,
+        datasource: typeof row.datasource === "string" ? row.datasource : void 0
+      }
+    ];
+  });
+}
+async function listTests(auth, target, opts = {}) {
+  const out = [];
+  if (opts.kind !== "workflow") out.push(...await listUnitTests(auth, target, opts.onTruncate));
+  if (opts.kind !== "unit") out.push(...await listWorkflowTests(auth, target, opts.onTruncate));
+  return out;
+}
+function readExpectations(results) {
+  if (!Array.isArray(results)) return void 0;
+  const expectations = results.flatMap((entry, index) => {
+    if (entry === null || typeof entry !== "object") return [];
+    const row = entry;
+    if (row.status !== "pass" && row.status !== "fail") return [];
+    const message = asString(row.message);
+    return [{ index, status: row.status, ...row.status === "fail" && message !== void 0 ? { message } : {} }];
+  });
+  return expectations.length > 0 ? expectations : void 0;
+}
+var TestRunUnansweredError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+  name = "TestRunUnansweredError";
+};
+async function runTest(auth, target, handle) {
+  const route = handle.kind === "unit" ? "unit_test" : "workflow_test";
+  const url = `${target.base}/api:meta/workspace/${target.workspaceId}/${route}/${handle.id}/run`;
+  const action = `run ${handle.kind} test "${handle.name}"`;
+  const res = await metaFetch(auth, url, action, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    // The unit-test route reads an optional `{branch}`; Xano SDK models no branch
+    // concept, so an empty object takes the engine's live-branch default. The
+    // workflow route reads no body at all and ignores this.
+    body: "{}"
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    if (res.status >= 500 || res.status === 401 || res.status === 403 || res.status === 429 || labelledMessage(text) === void 0) {
+      const message = appendSentence(
+        httpFailure(action, res, text),
+        `Nothing was run to a result \u2014 ${transportTarget(url)} did not report one.`
+      );
+      throw res.status >= 500 || res.status === 429 ? new TestRunUnansweredError(message, res.status) : new Error(message);
+    }
+    return { ...handle, status: "fail", message: `${statusLabel(res)}: ${labelledMessage(text)}` };
+  }
+  const body = recordAnswer(text, action, url, (row) => typeof row.status === "string");
+  const passed = body.status === "ok";
+  const expectations = readExpectations(body.results);
+  return {
+    ...handle,
+    status: passed ? "pass" : "fail",
+    message: passed ? void 0 : expectations?.find((e) => e.status === "fail" && e.message !== void 0)?.message ?? asString(body.message) ?? `status: ${String(body.status)}`,
+    ...expectations !== void 0 ? { expectations } : {},
+    // Optional by contract — read defensively, never format unguarded.
+    timing: typeof body.timing === "number" ? body.timing : void 0
+  };
+}
+
+export {
+  qualifiedName,
+  objectQualifiedName,
+  listTests,
+  TestRunUnansweredError,
+  runTest
+};
+//# sourceMappingURL=chunk-73IVBKMA.js.map

package/dist/chunk-7G3CTU7I.js

@@ -0,0 +1,286 @@
+import {
+  deleteAnswer,
+  hasString,
+  listAnswer,
+  recordAnswer,
+  writeTransportFailure
+} from "./chunk-6PBR37LN.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import {
+  TransportError,
+  fetchOrExplain,
+  httpFailure,
+  readBodyText,
+  withWriteStatusAftermath
+} from "./chunk-YLDALTWZ.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+import {
+  withArticle
+} from "./chunk-36JUQZVQ.js";
+
+// src/deploy/ephemeral.ts
+var TIMEOUT_MS = 3e4;
+var READY_TIMEOUT_MS = 12e4;
+var READY_INTERVAL_MS = 2e3;
+function namedEphemeral(summary) {
+  const shown = summary.display !== void 0 && summary.display !== "" && summary.display !== summary.name ? ` (${JSON.stringify(summary.display)})` : "";
+  return `ephemeral ${JSON.stringify(summary.name)}${shown}`;
+}
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function asNumber(v) {
+  return typeof v === "number" ? v : void 0;
+}
+function tenantBaseUrl(tenant, instance) {
+  const host = asString(tenant.xano_domain);
+  if (host !== void 0) {
+    const scheme = host.startsWith("localhost:") ? "http" : "https";
+    return `${scheme}://${host}`;
+  }
+  const name = asString(tenant.name);
+  if (name !== void 0) return new URL(`/tenant/${name}`, instance).href.replace(/\/$/, "");
+  return instance.replace(/\/$/, "");
+}
+function expiresAtMs(expiresAt) {
+  if (expiresAt === void 0 || expiresAt === null) return NaN;
+  return typeof expiresAt === "number" ? expiresAt * 1e3 : Date.parse(String(expiresAt).replace(" ", "T"));
+}
+function isoExpiry(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? new Date(v * 1e3).toISOString() : v;
+  if (typeof v !== "string" || v === "") return void 0;
+  const ms = expiresAtMs(v);
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : v;
+}
+function isExpired(expiresAt) {
+  const ms = expiresAtMs(expiresAt);
+  return Number.isFinite(ms) && ms <= Date.now();
+}
+function projectTenant(tenant, instance) {
+  const name = asString(tenant.name);
+  return {
+    id: asNumber(tenant.id),
+    name: name ?? "",
+    display: asString(tenant.display),
+    url: name !== void 0 || asString(tenant.xano_domain) ? tenantBaseUrl(tenant, instance) : void 0,
+    state: asString(tenant.state),
+    expiresAt: isoExpiry(tenant.ephemeral_expires_at),
+    workspaceId: asNumber(tenant.workspace_id),
+    type: asString(tenant.type),
+    // `{ id: 0 }` is the row's empty relation: nothing landed.
+    ...releaseIdOf(tenant.release)
+  };
+}
+async function metaFetch(auth, path, action, init) {
+  const url = new URL(path, auth.instance);
+  const write = (init?.method ?? "GET").toUpperCase() !== "GET";
+  return fetchOrExplain(
+    url.href,
+    {
+      ...init,
+      headers: {
+        accept: "application/json",
+        Authorization: `Bearer ${auth.access_token}`,
+        ...init?.headers ?? {}
+      },
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    },
+    action,
+    TIMEOUT_MS
+  ).catch((err) => {
+    throw write ? writeTransportFailure(err) : err;
+  });
+}
+async function readText(res, action, url, opts = {}) {
+  const text = await readBodyText(res, action, { url });
+  if (!res.ok) {
+    const head = httpFailure(action, res, text);
+    const err = new Error(opts.write === true ? withWriteStatusAftermath(head, res.status) : head);
+    Object.defineProperty(err, "status", { value: res.status, enumerable: false });
+    throw err;
+  }
+  return text;
+}
+async function readTenant(res, action, path, instance, opts = {}) {
+  const url = new URL(path, instance).href;
+  return recordAnswer(await readText(res, action, url, opts), action, url, (row) => hasString(row, "name"), opts);
+}
+function isEphemeralDisabled(err) {
+  return err instanceof Error && /ephemeral tenants are not enabled/i.test(err.message);
+}
+async function createEphemeral(auth, opts) {
+  const path = `/api:meta/workspace/${opts.parentWorkspaceId}/ephemeral`;
+  const body = { display: opts.display, tag: [] };
+  if (opts.description !== void 0) body.description = opts.description;
+  if (opts.expiresHours !== void 0) body.expires_hours = opts.expiresHours;
+  const res = await metaFetch(auth, path, "create ephemeral", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const tenant = await readTenant(res, "create ephemeral", path, auth.instance, { write: true });
+  return projectTenant(tenant, auth.instance);
+}
+var NotAnEphemeralError = class extends Error {
+  constructor(tenant, type, display) {
+    const named = `tenant ${JSON.stringify(tenant)}${display !== void 0 && display !== "" && display !== tenant ? ` (${JSON.stringify(display)})` : ""}`;
+    super(
+      (type === void 0 ? `No ephemeral named "${tenant}": ${named} exists but reports no type, so it is not treated as one.` : `No ephemeral named "${tenant}": ${named} is ${withArticle(type)} tenant, not an ephemeral.`) + // With this run's credential flags, which a bare `tenant` command would not read.
+      ` Nothing was changed. \`xanosdk tenant get ${shellQuote(tenant)}${contextFlags()}\` shows it, and \`tenant:${tenant}\` selects it (\`xanosdk tenant delete ${shellQuote(tenant)}${contextFlags()}\` is how a tenant is deleted).`
+    );
+    this.tenant = tenant;
+    this.type = type;
+    this.display = display;
+  }
+  tenant;
+  type;
+  display;
+  name = "NotAnEphemeralError";
+  exitCode = 8;
+};
+async function getEphemeral(auth, opts) {
+  const path = `/api:meta/workspace/${opts.parentWorkspaceId}/tenant/${encodeURIComponent(opts.name)}`;
+  const res = await metaFetch(auth, path, "get ephemeral", { method: "GET" });
+  if (res.status === 404) {
+    await res.text().catch(() => "");
+    return null;
+  }
+  const tenant = await readTenant(res, "get ephemeral", path, auth.instance);
+  const summary = projectTenant(tenant, auth.instance);
+  if (summary.type !== void 0 && summary.type !== "ephemeral") throw new NotAnEphemeralError(opts.name, summary.type, summary.display);
+  return summary;
+}
+async function renameEphemeral(auth, opts) {
+  const path = `/api:meta/workspace/${opts.parentWorkspaceId}/tenant/${encodeURIComponent(opts.name)}`;
+  const current = await readTenant(
+    await metaFetch(auth, path, "read ephemeral", { method: "GET" }),
+    "read ephemeral",
+    path,
+    auth.instance
+  );
+  const type = asString(current.type);
+  if (type !== "ephemeral") throw new NotAnEphemeralError(opts.name, type, asString(current.display));
+  const rbac = current.rbac;
+  const body = {
+    display: opts.display,
+    description: typeof current.description === "string" ? current.description : "",
+    domain: current.domain ?? null,
+    proxy: current.proxy ?? null,
+    tag: Array.isArray(current.tag) ? current.tag : [],
+    rbac: { enabled: rbac?.enabled === true },
+    tasks: current.tasks === true,
+    ingress: current.ingress === true
+  };
+  const res = await metaFetch(auth, path, "rename ephemeral", {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const url = new URL(path, auth.instance).href;
+  recordAnswer(await readText(res, "rename ephemeral", url, { write: true }), "rename ephemeral", url, () => true, { write: true });
+}
+function releaseIdOf(release) {
+  const id = release !== null && typeof release === "object" ? release.id : void 0;
+  return typeof id === "number" && id > 0 ? { deployedReleaseId: id } : {};
+}
+async function listEphemeral(auth, opts) {
+  const path = `/api:meta/workspace/${opts.parentWorkspaceId}/ephemeral`;
+  return (await readRows(auth, path)).map((t) => projectTenant(t, auth.instance));
+}
+async function listAllEphemeral(auth) {
+  const path = `/api:meta/ephemeral`;
+  return (await readRows(auth, path)).map((t) => projectTenant(t, auth.instance));
+}
+async function readRows(auth, path) {
+  const res = await metaFetch(auth, path, "list ephemerals", { method: "GET" });
+  const url = new URL(path, auth.instance).href;
+  return listAnswer(await readText(res, "list ephemerals", url), "list ephemerals", url, (row) => hasString(row, "name")).rows;
+}
+async function deleteEphemeral(auth, opts) {
+  if (opts.verified !== true) {
+    const found = await getEphemeral(auth, opts);
+    if (found === null) return { alreadyGone: true };
+    if (found.type !== "ephemeral") throw new NotAnEphemeralError(opts.name, found.type, found.display);
+  }
+  const path = `/api:meta/workspace/${opts.parentWorkspaceId}/tenant/${encodeURIComponent(opts.name)}`;
+  const res = await metaFetch(auth, path, "delete ephemeral", { method: "DELETE" });
+  if (res.status === 404) {
+    await res.text().catch(() => "");
+    return { alreadyGone: true };
+  }
+  const url = new URL(path, auth.instance).href;
+  deleteAnswer(await readText(res, "delete ephemeral", url, { write: true }), "delete ephemeral", url);
+  return { alreadyGone: false };
+}
+async function impersonateEphemeral(auth, opts) {
+  const query = opts.guest ? "?guest_read_only=true" : "";
+  const path = `/api:meta/workspace/${opts.parentWorkspaceId}/tenant/${encodeURIComponent(opts.name)}/impersonate${query}`;
+  const url = new URL(path, auth.instance).href;
+  const action = "open a dashboard session";
+  const res = await metaFetch(auth, path, action, { method: "GET" });
+  const data = recordAnswer(await readText(res, action, url), action, url, (row) => hasString(row, "_ti"));
+  return { _ti: data._ti };
+}
+async function waitUntilReady(auth, opts, cfg = {}) {
+  const timeoutMs = cfg.timeoutMs ?? READY_TIMEOUT_MS;
+  const intervalMs = cfg.intervalMs ?? READY_INTERVAL_MS;
+  const sleep = cfg.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  let stateless = 0;
+  for (; ; ) {
+    try {
+      last = await getEphemeral(auth, opts);
+    } catch (err) {
+      if (!isServerErrorPoll(err) || Date.now() >= deadline) throw err;
+      await sleep(intervalMs);
+      continue;
+    }
+    if (last && last.state === "ok") return last;
+    stateless = last !== null && last.state === void 0 ? stateless + 1 : 0;
+    if (stateless >= STATELESS_ANSWERS_TOLERATED) {
+      throw new Error(
+        `Ephemeral "${opts.name}" answered ${stateless} times with no \`state\`, so whether it is ready cannot be read \u2014 stopped waiting rather than polling for ${Math.round(timeoutMs / 1e3)}s.`
+      );
+    }
+    if (Date.now() >= deadline) {
+      const lastSaid = last === null ? "the last answer was not found \u2014 the ephemeral is gone" : last.state === void 0 ? "the last answer carried no state" : `last state: ${last.state}`;
+      throw new Error(
+        `Ephemeral "${opts.name}" did not become ready within ${Math.round(timeoutMs / 1e3)}s (${lastSaid}).`
+      );
+    }
+    await sleep(intervalMs);
+  }
+}
+function isUnansweredPoll(err) {
+  return err instanceof TransportError || isServerErrorPoll(err);
+}
+function isServerErrorPoll(err) {
+  const status = err?.status;
+  return typeof status === "number" && (status >= 500 && status < 600 || status === 429);
+}
+var STATELESS_ANSWERS_TOLERATED = 3;
+
+export {
+  namedEphemeral,
+  tenantBaseUrl,
+  expiresAtMs,
+  isExpired,
+  projectTenant,
+  isEphemeralDisabled,
+  createEphemeral,
+  NotAnEphemeralError,
+  getEphemeral,
+  renameEphemeral,
+  listEphemeral,
+  listAllEphemeral,
+  deleteEphemeral,
+  impersonateEphemeral,
+  waitUntilReady,
+  isUnansweredPoll
+};
+//# sourceMappingURL=chunk-7G3CTU7I.js.map