@xano/sdk 1.0.0

package/dist/chunk-KTSDSD36.js

@@ -0,0 +1,165 @@
+import {
+  ENV_WORKSPACE
+} from "./chunk-ET4Y4XCB.js";
+import {
+  credentialFileOf
+} from "./chunk-NAQDMEHV.js";
+import {
+  credentialFileFlag,
+  globalAuthFilePath,
+  loginCommand,
+  readCredentialFile,
+  readProfile,
+  recordedCredentialPath,
+  sameOriginAs
+} from "./chunk-XW6KISBB.js";
+import {
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+import {
+  CliError,
+  UsageError
+} from "./chunk-PTHVMXZI.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/emit/workspace-binding.ts
+function reachableWorkspaces(list) {
+  return (Array.isArray(list) ? list : []).flatMap(
+    (w) => typeof w.id === "number" ? [{ id: w.id, name: typeof w.name === "string" && w.name !== "" ? w.name : void 0 }] : []
+  );
+}
+function workspaceIdFix(auth) {
+  return auth.credentialType === "oauth" ? "Run `xanosdk login` again to re-pin it" : auth.credentialType === "oauth-refresh" ? "Mint `XANO_REFRESH_TOKEN` for the workspace you mean" : readEnvVar(ENV_WORKSPACE) !== void 0 ? `Fix \`${ENV_WORKSPACE}\` in the environment` : "Fix `workspace_id` in your credential file";
+}
+function reachableLines(all) {
+  return all.map((w) => `  ${String(w.id).padStart(3)}  ${w.name ?? "(unnamed)"}`).join("\n");
+}
+function reachableInline(all) {
+  return all.map((w) => w.name === void 0 ? String(w.id) : `${w.id} (${JSON.stringify(w.name)})`).join(", ");
+}
+function unreachableWorkspaceMessage(auth, all) {
+  const known = reachableLines(all);
+  return `Workspace ${auth.workspaceId} does not exist on ${new URL(auth.instance).host} (or your credential cannot see it).
+${workspaceIdFix(auth)}.` + (known === "" ? "" : `
+
+Workspaces you can reach:
+${known}`);
+}
+async function refuseUnreachableWorkspace(auth) {
+  const all = await readReachableWorkspaces(auth);
+  if (all === void 0 || all.length === 0 || all.some((w) => w.id === auth.workspaceId)) return;
+  throw new UsageError(unreachableWorkspaceMessage(auth, all));
+}
+async function readReachableWorkspaces(auth, timeoutMs = 3e4) {
+  try {
+    const res = await fetch(new URL("/api:meta/workspace", auth.instance).href, {
+      headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) return void 0;
+    return reachableWorkspaces(JSON.parse(await res.text()));
+  } catch {
+    return void 0;
+  }
+}
+async function whereaboutsOf(auth, name, kinds) {
+  const { listAllEphemeral } = await import("./ephemeral-P7F3PMAD.js");
+  const failures = [];
+  const reason = (err) => (err instanceof Error ? err.message : String(err)).split("\n")[0].replace(/[.:]$/, "");
+  const [all, ephemerals] = await Promise.all([
+    readReachableWorkspaces(auth),
+    listAllEphemeral(auth).catch((err) => {
+      failures.push(reason(err));
+      return void 0;
+    })
+  ]);
+  const listed = ephemerals?.some((r) => r.name === name) === true;
+  if (kinds === "ephemeral" && ephemerals !== void 0 && !listed) return { at: "nowhere" };
+  if (all === void 0) failures.push("the workspace list could not be read");
+  const { getTenant } = await import("./tenant-IIHPOHGP.js");
+  const others = (all ?? []).filter((w) => w.id !== auth.workspaceId);
+  const found = await Promise.all(
+    others.map(
+      (w) => getTenant(auth, { workspaceId: w.id, name }).then(
+        (record) => {
+          if (record === null) return void 0;
+          const kind = record.type === "ephemeral" ? "ephemeral" : "tenant";
+          return kinds === "ephemeral" && kind !== "ephemeral" ? void 0 : { workspace: w, kind };
+        },
+        (err) => {
+          failures.push(`workspace ${w.id}: ${reason(err)}`);
+          return void 0;
+        }
+      )
+    )
+  );
+  const hit = found.find((f) => f !== void 0);
+  if (hit !== void 0) return { at: "elsewhere", ...hit };
+  if (listed) failures.push("the ephemeral list names it, but no workspace this credential reaches holds it");
+  return failures.length === 0 ? { at: "nowhere" } : { at: "unknown", detail: failures.join("; ") };
+}
+function rerunInWorkspace(auth, id, command) {
+  if (auth.credentialType === "token" && readEnvVar(ENV_WORKSPACE) !== void 0) return `Run \`${ENV_WORKSPACE}=${id} ${command}\`.`;
+  if (auth.credentialType === "oauth-refresh") return `Mint \`XANO_REFRESH_TOKEN\` for workspace ${id}, then run \`${command}\`.`;
+  const recorded = credentialFileOf();
+  const path = recordedCredentialPath(recorded) ?? globalAuthFilePath();
+  let file = null;
+  try {
+    file = readCredentialFile(path);
+  } catch {
+  }
+  const current = auth.profile?.name;
+  const as = (profile) => {
+    const without = current === void 0 ? command : command.split(` --profile ${shellQuote(current)}`).join("");
+    return `${without} --profile ${shellQuote(profile)}`;
+  };
+  const stored = (name) => {
+    try {
+      return file !== null && readProfile(file, name, path) || void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  const reaches = file === null || auth.instance === void 0 ? void 0 : Object.keys(file.profiles).find((name) => {
+    const record = name === current ? void 0 : stored(name);
+    return record !== void 0 && record.workspace_id === id && sameOriginAs(record.type === "token" ? record.instance_base_url : record.instance, auth.instance);
+  });
+  if (reaches !== void 0) return `Run \`${as(reaches)}\`.`;
+  const taken = new Set(file === null ? [] : Object.keys(file.profiles));
+  let fresh = `workspace-${id}`;
+  for (let n = 2; taken.has(fresh); n++) fresh = `workspace-${id}-${n}`;
+  const fileFlag = credentialFileFlag(path);
+  if (auth.credentialType === "oauth") {
+    const record = current === void 0 ? void 0 : stored(current);
+    const origin = record?.type === "oauth" ? record.auth_host : void 0;
+    return `Run \`${loginCommand(fresh, { path, ...origin === void 0 ? {} : { origin } })}\` and choose workspace ${id}, then run \`${as(fresh)}\`.`;
+  }
+  const instance = auth.instance ?? "<instance-url>";
+  return `Store a profile for workspace ${id} with \`printf %s "$TOKEN" | xanosdk profile add ${shellQuote(fresh)} --instance ${shellQuote(instance)} --workspace-id ${id}${fileFlag}\`, then run \`${as(fresh)}\`.`;
+}
+function heldElsewhereError(auth, where, name, aftermath, command, details) {
+  const kind = where.kind === "ephemeral" ? "Ephemeral" : "Tenant";
+  const label = `${where.workspace.id}${where.workspace.name === void 0 ? "" : ` (${JSON.stringify(where.workspace.name)})`}`;
+  return new CliError(
+    "SDK_USAGE",
+    `${kind} "${name}" is in workspace ${label}, not workspace ${auth.workspaceId} this credential is pinned to \u2014 ${aftermath}.
+` + rerunInWorkspace(auth, where.workspace.id, command),
+    { exitCode: 1, details: { reason: "wrong-workspace", ...details, heldIn: where.workspace.id } }
+  );
+}
+
+export {
+  reachableWorkspaces,
+  workspaceIdFix,
+  reachableLines,
+  reachableInline,
+  unreachableWorkspaceMessage,
+  refuseUnreachableWorkspace,
+  readReachableWorkspaces,
+  whereaboutsOf,
+  rerunInWorkspace,
+  heldElsewhereError
+};
+//# sourceMappingURL=chunk-KTSDSD36.js.map