@xano/sdk 1.0.0

package/dist/chunk-A3UDOZB6.js

@@ -0,0 +1,222 @@
+import {
+  asTimestamp
+} from "./chunk-2MNLRIOX.js";
+import {
+  impersonateEphemeral,
+  projectTenant
+} from "./chunk-7G3CTU7I.js";
+import {
+  deleteAnswer,
+  hasString,
+  isRecord,
+  listAnswer,
+  recordAnswer,
+  writeTransportFailure
+} from "./chunk-6PBR37LN.js";
+import {
+  SENT_AFTERMATH,
+  fetchOrExplain,
+  fetchReadOrExplain,
+  readBodyText,
+  safeHttpFailure,
+  writeStatusAftermath
+} from "./chunk-YLDALTWZ.js";
+
+// src/deploy/tenant.ts
+var TIMEOUT_MS = 3e4;
+var DEPLOY_TIMEOUT_MS = 6e5;
+var TenantHttpError = class extends Error {
+  constructor(status, action, statusText, body, bind, remedy) {
+    const head = safeHttpFailure(action, { status, statusText }, body, bind);
+    super(remedy === void 0 ? head : `${head}
+${remedy}`);
+    this.status = status;
+    this.name = "TenantHttpError";
+  }
+  status;
+};
+function relationId(v) {
+  if (v === null || typeof v !== "object") return void 0;
+  const id = v.id;
+  return typeof id === "number" && id > 0 ? id : void 0;
+}
+function projectTenantRecord(raw, instance) {
+  return {
+    ...projectTenant(raw, instance),
+    deployedAt: asTimestamp(raw.deployed_at),
+    deployedReleaseId: relationId(raw.release)
+  };
+}
+function metaRequest(auth, path, init, timeoutMs) {
+  return {
+    url: new URL(path, auth.instance).href,
+    init: {
+      ...init,
+      headers: {
+        accept: "application/json",
+        Authorization: `Bearer ${auth.access_token}`,
+        ...init.headers ?? {}
+      },
+      signal: AbortSignal.timeout(timeoutMs)
+    }
+  };
+}
+async function metaWrite(auth, path, action, init, timeoutMs = TIMEOUT_MS) {
+  const req = metaRequest(auth, path, init, timeoutMs);
+  return fetchOrExplain(req.url, req.init, action, timeoutMs).catch((err) => {
+    throw writeTransportFailure(err);
+  });
+}
+async function metaRead(auth, path, action) {
+  const req = metaRequest(auth, path, { method: "GET" }, TIMEOUT_MS);
+  return fetchReadOrExplain(req.url, req.init, action, TIMEOUT_MS);
+}
+function binding(auth, workspaceId) {
+  return {
+    boundWorkspaceId: auth.workspaceId,
+    instance: auth.instance,
+    profile: auth.profile,
+    addressedWorkspaceId: workspaceId,
+    credentialType: auth.credentialType,
+    tenantHost: false
+  };
+}
+async function readText(res, action, bind) {
+  const text = await readBodyText(res, action);
+  if (!res.ok) throw new TenantHttpError(res.status, action, res.statusText, text, bind);
+  return text;
+}
+var isTenantRow = (row) => hasString(row, "name");
+function base(workspaceId) {
+  return `/api:meta/workspace/${workspaceId}/tenant`;
+}
+var PER_PAGE = 100;
+async function listTenants(auth, opts) {
+  const out = [];
+  for (let page = 1; ; page++) {
+    const path = `${base(opts.workspaceId)}?page=${page}&per_page=${PER_PAGE}`;
+    const res = await metaRead(auth, path, "list tenants");
+    const url = new URL(path, auth.instance).href;
+    const { rows } = listAnswer(await readText(res, "list tenants", binding(auth, opts.workspaceId)), "list tenants", url, isTenantRow, {
+      safe: true
+    });
+    for (const r of rows) out.push(projectTenantRecord(r, auth.instance));
+    if (rows.length < PER_PAGE) return out;
+  }
+}
+async function getTenant(auth, opts) {
+  const path = `${base(opts.workspaceId)}/${encodeURIComponent(opts.name)}`;
+  const res = await metaRead(auth, path, "get tenant");
+  if (res.status === 404) {
+    await res.text().catch(() => "");
+    return null;
+  }
+  const url = new URL(path, auth.instance).href;
+  const text = await readText(res, "get tenant", binding(auth, opts.workspaceId));
+  return projectTenantRecord(recordAnswer(text, "get tenant", url, isTenantRow, { safe: true }), auth.instance);
+}
+async function tenantHasWorkspace(auth, base2) {
+  const url = `${base2.replace(/\/$/, "")}/api:meta/workspace`;
+  try {
+    const res = await metaRead(auth, url, "list the tenant's workspaces");
+    const text = await res.text();
+    if (!res.ok) return true;
+    const data = JSON.parse(text);
+    return !(Array.isArray(data) && data.length === 0);
+  } catch {
+    return true;
+  }
+}
+function isFailedMicroservice(m) {
+  return /^(error|failed)$/i.test(m.status);
+}
+var MAX_MICROSERVICE_DETAIL = 300;
+function projectMicroservice(raw) {
+  if (raw === null || typeof raw !== "object") return void 0;
+  const r = raw;
+  if (typeof r.name !== "string" || typeof r.status !== "string") return void 0;
+  const id = typeof r.microservice_id === "number" && r.microservice_id > 0 ? r.microservice_id : void 0;
+  const detail = typeof r.detail === "string" && r.detail.trim() !== "" ? capDetail(r.detail) : void 0;
+  return {
+    ...id === void 0 ? {} : { id },
+    name: r.name,
+    status: r.status,
+    ...detail === void 0 ? {} : { detail }
+  };
+}
+function capDetail(text) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > MAX_MICROSERVICE_DETAIL ? `${flat.slice(0, MAX_MICROSERVICE_DETAIL)}\u2026` : flat;
+}
+function readDeployOutcome(text, action, url) {
+  const record = recordAnswer(
+    text,
+    action,
+    url,
+    (row) => hasString(row, "name") || "deployed_at" in row || Array.isArray(row.microservices) || isRecord(row.release),
+    { safe: true, write: true }
+  );
+  const list = Array.isArray(record.microservices) ? record.microservices : [];
+  return {
+    deployedAt: asTimestamp(record.deployed_at),
+    deployedReleaseId: relationId(record.release),
+    microservices: list.flatMap((m) => projectMicroservice(m) ?? [])
+  };
+}
+var DEPLOY_REFUSED_REMEDY = `The tenant refused the deploy, and nothing was landed. A tenant can require an approved deployment request before a release lands on it, and deploying needs permission to deploy to tenants in this workspace. Get the deployment approved (or the permission granted), then run it again.`;
+async function deployReleaseToTenant(auth, opts) {
+  const path = `${base(opts.workspaceId)}/${encodeURIComponent(opts.tenant)}/deploy`;
+  const res = await metaWrite(
+    auth,
+    path,
+    "deploy release to tenant",
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ release_name: opts.release })
+    },
+    DEPLOY_TIMEOUT_MS
+  );
+  const text = await readBodyText(res, "deploy release to tenant", { aftermath: SENT_AFTERMATH });
+  if (!res.ok) {
+    if (res.status === 403) {
+      throw new TenantHttpError(res.status, "deploy release to tenant", res.statusText, text, void 0, DEPLOY_REFUSED_REMEDY);
+    }
+    throw new TenantHttpError(res.status, "deploy release to tenant", res.statusText, text, binding(auth, opts.workspaceId));
+  }
+  return readDeployOutcome(text, "deploy release to tenant", new URL(path, auth.instance).href);
+}
+async function deleteTenant(auth, opts) {
+  const path = `${base(opts.workspaceId)}/${encodeURIComponent(opts.name)}`;
+  const res = await metaWrite(auth, path, "delete tenant", { method: "DELETE" });
+  const text = await readBodyText(res, "delete tenant", { aftermath: SENT_AFTERMATH });
+  if (res.status === 404) return { alreadyGone: true };
+  if (!res.ok) {
+    throw new TenantHttpError(
+      res.status,
+      "delete tenant",
+      res.statusText,
+      text,
+      binding(auth, opts.workspaceId),
+      writeStatusAftermath(res.status)
+    );
+  }
+  deleteAnswer(text, "delete tenant", new URL(path, auth.instance).href, { safe: true });
+  return { alreadyGone: false };
+}
+async function impersonateTenant(auth, opts) {
+  return impersonateEphemeral(auth, { parentWorkspaceId: opts.workspaceId, name: opts.name, guest: opts.guest });
+}
+
+export {
+  TenantHttpError,
+  projectTenantRecord,
+  listTenants,
+  getTenant,
+  tenantHasWorkspace,
+  isFailedMicroservice,
+  deployReleaseToTenant,
+  deleteTenant,
+  impersonateTenant
+};
+//# sourceMappingURL=chunk-A3UDOZB6.js.map

package/dist/chunk-A6E77GDW.js

@@ -0,0 +1,85 @@
+import {
+  BranchHttpError,
+  BranchTakenError
+} from "./chunk-TRJCALW3.js";
+import {
+  SourceError
+} from "./chunk-QCNYHBL7.js";
+import {
+  ReleaseHttpError
+} from "./chunk-2ZUEE4EK.js";
+import {
+  ImportHttpError
+} from "./chunk-AN6BL47T.js";
+import {
+  TenantHttpError
+} from "./chunk-A3UDOZB6.js";
+import {
+  TLS_CERTIFICATE_CODES,
+  isTimeoutError,
+  writeRefusedBy
+} from "./chunk-YLDALTWZ.js";
+import {
+  UsageError
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/operation-outcome.ts
+var SettledWriteFailure = class extends Error {
+  name = "SettledWriteFailure";
+};
+var NEVER_OPENED = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ENETUNREACH",
+  // A certificate the TLS handshake refused: the connection closed before a
+  // request was written.
+  ...TLS_CERTIFICATE_CODES
+]);
+var MAX_CHAIN = 16;
+function httpStatusOf(err) {
+  if (err instanceof ReleaseHttpError || err instanceof TenantHttpError || err instanceof BranchHttpError || err instanceof ImportHttpError) {
+    return err.status;
+  }
+  return void 0;
+}
+function chainOf(err) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const queue = [err];
+  while (queue.length > 0 && out.length < MAX_CHAIN) {
+    const next = queue.shift();
+    if (next === void 0 || next === null || seen.has(next)) continue;
+    seen.add(next);
+    out.push(next);
+    if (typeof next !== "object") continue;
+    const cause = next.cause;
+    if (cause !== void 0) queue.push(cause);
+    const errors = next.errors;
+    if (Array.isArray(errors)) queue.push(...errors);
+  }
+  return out;
+}
+function classifyFailure(err, opts) {
+  if (!opts.writeSent) return "no";
+  const chain = chainOf(err);
+  if (chain.some(
+    (e) => e instanceof UsageError || e instanceof SourceError || e instanceof BranchTakenError || e instanceof SettledWriteFailure
+  ))
+    return "no";
+  for (const e of chain) {
+    const status = httpStatusOf(e);
+    if (status !== void 0) return writeRefusedBy(status) ? "no" : "unknown";
+  }
+  if (chain.some(isTimeoutError)) return "unknown";
+  if (chain.some((e) => e instanceof Error && e.message === "bad port")) return "no";
+  const codes = chain.map((e) => typeof e === "object" && e !== null ? e.code : void 0).filter((c) => typeof c === "string");
+  if (codes.length > 0 && codes.every((c) => NEVER_OPENED.has(c))) return "no";
+  return "unknown";
+}
+
+export {
+  SettledWriteFailure,
+  classifyFailure
+};
+//# sourceMappingURL=chunk-A6E77GDW.js.map