@xanots/sdk 0.0.1

package/dist/chunk-5WGEURVI.js

@@ -0,0 +1,156 @@
+import {
+  describeTransportFailure,
+  httpFailure,
+  retryingFetch
+} from "./chunk-3IGNIP6R.js";
+
+// src/deploy/import.ts
+var IMPORT_TIMEOUT_MS = 12e4;
+var PROBE_TIMEOUT_MS = 15e3;
+function query(opts) {
+  const params = new URLSearchParams();
+  if (opts.mode !== void 0) params.set("mode", opts.mode);
+  if (opts.prune !== void 0) params.set("delete", String(opts.prune));
+  if (opts.records !== void 0) params.set("records", String(opts.records));
+  if (opts.truncate !== void 0) params.set("truncate", String(opts.truncate));
+  const qs = params.toString();
+  return qs === "" ? "" : `?${qs}`;
+}
+function endpoint(opts, suffix = "", qs = "") {
+  return `${opts.baseUrl.replace(/\/$/, "")}/api:meta/workspace/${opts.workspaceId ?? 1}/import${suffix}${qs}`;
+}
+function explainDuplicateIdentity(body2) {
+  if (!/duplicate key value violates unique constraint/i.test(body2)) return void 0;
+  return "The import tried to CREATE objects that already exist under different identities, and the engine refused the duplicate.\nThis is what a stale `xano.lock` looks like: it names guids the workspace no longer has, so nothing matched and everything was planned as new. `--replace` causes it by minting fresh identities.\nRun `xanots lock adopt` against this workspace to re-pin the lock to what is actually there, then release again.";
+}
+var ImportHttpError = class extends Error {
+  constructor(status, action, statusText, body2) {
+    const explained = explainDuplicateIdentity(body2);
+    super(
+      explained === void 0 ? httpFailure(action, { status, statusText }, body2) : `${httpFailure(action, { status, statusText }, body2)}
+
+${explained}`
+    );
+    this.status = status;
+    this.name = "ImportHttpError";
+  }
+  status;
+};
+function mergeUnsupported(baseUrl, why) {
+  return new Error(
+    `Refusing to merge: ${why}
+  instance: ${baseUrl}
+An instance that predates merge support silently IGNORES \`mode=merge\`, runs a full replace \u2014 clearing every object, every table row, and all history in the target workspace \u2014 and still answers 200. That is not recoverable, so this is not attempted on an unverified instance.
+Update the instance, or use \`xanots deploy\` to ship to an ephemeral, or \`xanots release --replace\` if wiping the workspace is genuinely what you want.`
+  );
+}
+async function assertMergeSupported(auth, opts) {
+  let res;
+  try {
+    res = await fetch(endpoint(opts, "/dry-run"), {
+      method: "POST",
+      headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
+  } catch (err) {
+    throw mergeUnsupported(opts.baseUrl, `could not reach it to check for merge support (${String(err)}).`);
+  }
+  if (res.status === 404) {
+    throw mergeUnsupported(opts.baseUrl, "this instance has no `/import/dry-run` route, so it cannot merge.");
+  }
+  if (res.ok || res.status === 400 || res.status === 422) return;
+  const text = await res.text().catch(() => "");
+  throw mergeUnsupported(
+    opts.baseUrl,
+    `the merge-support check answered ${res.status} ${res.statusText}, which is neither support nor its absence:
+${text}`
+  );
+}
+function body(archive) {
+  const form = new FormData();
+  form.append("file", new Blob([archive], { type: "application/gzip" }), "workspace.gz");
+  return form;
+}
+async function post(auth, url, archive, action, writes) {
+  let res;
+  try {
+    const init = {
+      method: "POST",
+      headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+      body: body(archive),
+      signal: AbortSignal.timeout(IMPORT_TIMEOUT_MS)
+    };
+    res = writes ? await fetch(url, init) : await retryingFetch(url, init);
+  } catch (err) {
+    const aftermath = writes ? `The request did not complete, so the import ran either not at all or entirely \u2014 it is applied in a single transaction. Re-run with \`--dry-run\` to see the workspace's current state before retrying.` : `A dry run writes nothing, so the workspace is untouched. Retry when the instance is reachable.`;
+    throw new Error(`${action} could not reach ${url}: ${describeTransportFailure(err)}
+${aftermath}`, {
+      cause: err
+    });
+  }
+  const text = await res.text();
+  if (!res.ok) {
+    throw new ImportHttpError(res.status, action, res.statusText, text);
+  }
+  return text;
+}
+async function importWorkspaceArchive(auth, opts) {
+  if (opts.mode === "merge") await assertMergeSupported(auth, opts);
+  const url = endpoint(opts, "", query(opts));
+  const text = await post(auth, url, opts.archive, "import", true);
+  let workspaceId;
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed.id === "number") workspaceId = parsed.id;
+  } catch {
+  }
+  return { workspaceId, raw: text };
+}
+async function planWorkspaceImport(auth, opts) {
+  const url = endpoint(opts, "/dry-run", query(opts));
+  let text;
+  try {
+    text = await post(auth, url, opts.archive, "import dry run", false);
+  } catch (err) {
+    if (err instanceof ImportHttpError && err.status === 404) {
+      throw opts.mode === "merge" ? mergeUnsupported(opts.baseUrl, "this instance has no `/import/dry-run` route, so it cannot merge.") : new Error(
+        `This instance cannot preview an import: it has no \`/import/dry-run\` route (${opts.baseUrl}).
+The import itself is unaffected \u2014 only the preview is unavailable. Update the instance to see a plan before importing.`,
+        { cause: err }
+      );
+    }
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error(`import dry run: could not parse the /import/dry-run response as JSON:
+${text}`);
+  }
+  const rawOps = Array.isArray(parsed.operations) ? parsed.operations : [];
+  const operations = rawOps.map((entry) => {
+    const op = entry ?? {};
+    return {
+      type: typeof op.type === "string" ? op.type : "",
+      name: typeof op.name === "string" ? op.name : "",
+      action: typeof op.action === "string" ? op.action : "",
+      ...typeof op.details === "string" ? { details: op.details } : {},
+      ...typeof op.reason === "string" ? { reason: op.reason } : {}
+    };
+  });
+  return {
+    workspaceName: typeof parsed.workspace_name === "string" ? parsed.workspace_name : void 0,
+    summary: parsed.summary !== null && typeof parsed.summary === "object" && !Array.isArray(parsed.summary) ? parsed.summary : {},
+    hasRecords: parsed.has_records === true,
+    hasEnv: parsed.has_env === true,
+    operations,
+    raw: text
+  };
+}
+
+export {
+  importWorkspaceArchive,
+  planWorkspaceImport
+};
+//# sourceMappingURL=chunk-5WGEURVI.js.map

package/dist/chunk-5YTBTF25.js

@@ -0,0 +1,29 @@
+import {
+  UsageError
+} from "./chunk-IZW6MK3U.js";
+import {
+  style
+} from "./chunk-EZG76F7R.js";
+
+// src/emit/prompt.ts
+import { createInterface } from "readline";
+async function confirm(message, opts) {
+  if (process.stdin.isTTY !== true) {
+    throw new UsageError(
+      `Cannot ask for confirmation: stdin is not a terminal. Re-run with ${opts.flag} to confirm without being asked.`,
+      { helpFor: opts.helpFor }
+    );
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await new Promise((res) => rl.question(`${style.yellow("?")} ${message} (y/N) `, res));
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+
+export {
+  confirm
+};
+//# sourceMappingURL=chunk-5YTBTF25.js.map

package/dist/chunk-6DHBYBTO.js

@@ -0,0 +1,166 @@
+import {
+  fetchOrExplain,
+  httpFailure
+} from "./chunk-3IGNIP6R.js";
+
+// src/deploy/ephemeral.ts
+var TIMEOUT_MS = 3e4;
+var READY_TIMEOUT_MS = 12e4;
+var READY_INTERVAL_MS = 2e3;
+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 isExpired(expiresAt) {
+  const ms = expiresAtMs(expiresAt);
+  return Number.isFinite(ms) && ms <= Date.now();
+}
+function project(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: tenant.ephemeral_expires_at ?? void 0,
+    workspaceId: asNumber(tenant.workspace_id)
+  };
+}
+async function metaFetch(auth, path, action, init) {
+  const url = new URL(path, auth.instance);
+  return fetchOrExplain(
+    url.href,
+    {
+      ...init,
+      headers: {
+        accept: "application/json",
+        Authorization: `Bearer ${auth.access_token}`,
+        ...init?.headers ?? {}
+      },
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    },
+    action,
+    TIMEOUT_MS
+  );
+}
+async function readJson(res, action, pathname) {
+  const text = await res.text();
+  if (!res.ok) throw new Error(httpFailure(action, res, text));
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${action}: could not parse the ${pathname} response as JSON:
+${text}`);
+  }
+}
+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 readJson(res, "create ephemeral", path);
+  return project(tenant, auth.instance);
+}
+async function getEphemeral(auth, opts) {
+  const path = `/api:meta/workspace/${opts.parentWorkspaceId}/tenant/${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 readJson(res, "get ephemeral", path);
+  return project(tenant, auth.instance);
+}
+async function listEphemeral(auth, opts) {
+  const path = `/api:meta/workspace/${opts.parentWorkspaceId}/ephemeral`;
+  const data = await readJson(await metaFetch(auth, path, "list ephemerals", { method: "GET" }), "list ephemerals", path);
+  return toRows(data).map((t) => project(t, auth.instance));
+}
+async function listAllEphemeral(auth) {
+  const path = `/api:meta/ephemeral`;
+  const data = await readJson(await metaFetch(auth, path, "list ephemerals", { method: "GET" }), "list ephemerals", path);
+  return toRows(data).map((t) => project(t, auth.instance));
+}
+function toRows(data) {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object" && Array.isArray(data.items)) {
+    return data.items;
+  }
+  return [];
+}
+async function deleteEphemeral(auth, opts) {
+  const path = `/api:meta/workspace/${opts.parentWorkspaceId}/tenant/${opts.name}`;
+  const res = await metaFetch(auth, path, "delete ephemeral", { method: "DELETE" });
+  if (res.status === 404) {
+    await res.text().catch(() => "");
+    return { alreadyGone: true };
+  }
+  const text = await res.text();
+  if (!res.ok) throw new Error(httpFailure("delete ephemeral", res, text));
+  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 data = await readJson(await metaFetch(auth, path, "impersonate ephemeral", { method: "GET" }), "impersonate ephemeral", path);
+  if (typeof data._ti !== "string" || data._ti === "") {
+    throw new Error(`impersonate ephemeral: no one-time token (\`_ti\`) returned for "${opts.name}".`);
+  }
+  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;
+  for (; ; ) {
+    last = await getEphemeral(auth, opts);
+    if (last && last.state === "ok") return last;
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `Ephemeral "${opts.name}" did not become ready within ${Math.round(timeoutMs / 1e3)}s (last state: ${last?.state ?? "gone"}). Try \`xanots deploy\` again.`
+      );
+    }
+    await sleep(intervalMs);
+  }
+}
+
+export {
+  tenantBaseUrl,
+  isExpired,
+  isEphemeralDisabled,
+  createEphemeral,
+  getEphemeral,
+  listEphemeral,
+  listAllEphemeral,
+  deleteEphemeral,
+  impersonateEphemeral,
+  waitUntilReady
+};
+//# sourceMappingURL=chunk-6DHBYBTO.js.map

package/dist/chunk-76QBEIGO.js

@@ -0,0 +1,66 @@
+// src/validate/kinds.ts
+var ROUND_TRIP_KINDS = [
+  { key: "dbo", fixtureDir: "tables" },
+  { key: "function", fixtureDir: "statements", runnable: true },
+  { key: "query", fixtureDir: "query" },
+  { key: "trigger", fixtureDir: "triggers" },
+  { key: "task", fixtureDir: "task" },
+  { key: "toolset", fixtureDir: "toolset" },
+  { key: "tool", fixtureDir: "toolset" },
+  { key: "middleware", fixtureDir: "middleware" },
+  { key: "addon", fixtureDir: "addon" },
+  { key: "workflow_test", fixtureDir: "workflow-test" }
+];
+var FIXTURE_DIR_BY_KIND = new Map(ROUND_TRIP_KINDS.map((k) => [k.key, k.fixtureDir]));
+var RUNNABLE_KINDS = new Set(ROUND_TRIP_KINDS.filter((k) => k.runnable).map((k) => k.key));
+function fixtureDirForKind(key) {
+  return FIXTURE_DIR_BY_KIND.get(key);
+}
+function kindIsRunnable(key) {
+  return RUNNABLE_KINDS.has(key);
+}
+function strField(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function indexByIdentity(objects) {
+  const byGuid = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  const duplicateGuids = /* @__PURE__ */ new Set();
+  const duplicateNames = /* @__PURE__ */ new Set();
+  for (const obj of objects) {
+    const guid = strField(obj, "guid");
+    if (guid !== void 0) {
+      if (byGuid.has(guid)) duplicateGuids.add(guid);
+      else byGuid.set(guid, obj);
+    }
+    const name = strField(obj, "name");
+    if (name !== void 0) {
+      if (byName.has(name)) duplicateNames.add(name);
+      else byName.set(name, obj);
+    }
+  }
+  return { byGuid, byName, duplicateGuids, duplicateNames };
+}
+function resolveMatch(compiled, index) {
+  const guid = strField(compiled, "guid");
+  if (guid !== void 0 && index.byGuid.has(guid)) {
+    if (index.duplicateGuids.has(guid)) return { outcome: "ambiguous" };
+    return { outcome: "found", fetched: index.byGuid.get(guid) };
+  }
+  const name = strField(compiled, "name");
+  if (name !== void 0 && index.byName.has(name)) {
+    if (index.duplicateNames.has(name)) return { outcome: "ambiguous" };
+    return { outcome: "found", fetched: index.byName.get(name) };
+  }
+  return { outcome: "missing" };
+}
+
+export {
+  ROUND_TRIP_KINDS,
+  fixtureDirForKind,
+  kindIsRunnable,
+  indexByIdentity,
+  resolveMatch
+};
+//# sourceMappingURL=chunk-76QBEIGO.js.map

package/dist/chunk-7DKX2SPN.js

@@ -0,0 +1,100 @@
+import {
+  printMicroserviceSection,
+  readMicroservices
+} from "./chunk-NDZFBZHC.js";
+import {
+  isMachineOutput,
+  writeJson
+} from "./chunk-NUQCEOKA.js";
+import {
+  fetchOrExplain,
+  httpFailure
+} from "./chunk-3IGNIP6R.js";
+import {
+  getAccessToken
+} from "./chunk-C56BC2FY.js";
+import {
+  formatFields,
+  stdoutStyle
+} from "./chunk-EZG76F7R.js";
+
+// src/emit/sandbox-details-command.ts
+var SANDBOX_TIMEOUT_MS = 3e4;
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function sandboxBaseUrl(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(/\/$/, "");
+}
+async function fetchSandboxDetails(args) {
+  const { access_token, instance } = await getAccessToken(args);
+  const url = new URL("/api:meta/sandbox/me", instance);
+  const res = await fetchOrExplain(
+    url.href,
+    {
+      headers: { accept: "application/json", Authorization: `Bearer ${access_token}` },
+      signal: AbortSignal.timeout(SANDBOX_TIMEOUT_MS)
+    },
+    "sandbox details",
+    SANDBOX_TIMEOUT_MS
+  );
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(httpFailure("sandbox details", res, text));
+  }
+  let tenant = {};
+  try {
+    tenant = JSON.parse(text);
+  } catch {
+    throw new Error(`sandbox details: could not parse the ${url.pathname} response as JSON:
+${text}`);
+  }
+  const expiresAt = tenant.sandbox_expires_at;
+  return {
+    baseUrl: sandboxBaseUrl(tenant, instance),
+    sandbox: {
+      id: typeof tenant.id === "number" ? tenant.id : void 0,
+      name: asString(tenant.name),
+      display: asString(tenant.display),
+      state: asString(tenant.state),
+      xanoDomain: asString(tenant.xano_domain),
+      expiresAt: typeof expiresAt === "string" || typeof expiresAt === "number" ? expiresAt : void 0
+    }
+  };
+}
+function prettyDetails(d) {
+  const s = stdoutStyle();
+  const { sandbox } = d;
+  const label = [sandbox.display ?? sandbox.name, sandbox.state && s.dim(`(${sandbox.state})`)].filter(Boolean).join(" ");
+  const rows = [["Base URL", s.bold(s.cyan(d.baseUrl))]];
+  if (label !== "") rows.push(["Sandbox", label]);
+  if (sandbox.expiresAt !== void 0) rows.push(["Expires", s.dim(String(sandbox.expiresAt))]);
+  return "\n" + formatFields(rows);
+}
+async function runSandboxDetailsCommand(args) {
+  const details = await fetchSandboxDetails(args);
+  const auth = await getAccessToken(args);
+  const microservices = await readMicroservices(auth, details.baseUrl);
+  if (isMachineOutput(args)) {
+    writeJson({ ...details, microservices });
+  } else {
+    process.stdout.write(prettyDetails(details));
+    printMicroserviceSection(microservices);
+  }
+}
+
+export {
+  sandboxBaseUrl,
+  fetchSandboxDetails,
+  runSandboxDetailsCommand
+};
+//# sourceMappingURL=chunk-7DKX2SPN.js.map