@xanots/sdk 0.0.1

package/dist/test-command-TSPBQHBM.js

@@ -0,0 +1,383 @@
+import {
+  resolveMetaTarget
+} from "./chunk-33ND6LKO.js";
+import "./chunk-DGSF2Q5H.js";
+import "./chunk-7DKX2SPN.js";
+import "./chunk-NDZFBZHC.js";
+import {
+  isMachineOutput,
+  writeJson
+} from "./chunk-NUQCEOKA.js";
+import {
+  fetchOrExplain,
+  httpFailure,
+  serverMessage
+} from "./chunk-3IGNIP6R.js";
+import {
+  getAccessToken
+} from "./chunk-C56BC2FY.js";
+import "./chunk-7REDODS2.js";
+import {
+  unknownSubcommand
+} from "./chunk-IZW6MK3U.js";
+import {
+  blank,
+  detail,
+  stderrStyle,
+  step,
+  success,
+  warn
+} from "./chunk-EZG76F7R.js";
+import "./chunk-YYRDLFSJ.js";
+import "./chunk-GNPVYOPB.js";
+
+// src/deploy/tests.ts
+var TIMEOUT_MS = 12e4;
+var PAGE_SIZE = 100;
+var MAX_PAGES = 100;
+function qualifiedName(handle) {
+  return handle.object === void 0 ? handle.name : `${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
+  );
+}
+function readPage(data, action) {
+  if (Array.isArray(data)) return { rows: data, nextPage: void 0 };
+  if (data !== null && typeof data === "object") {
+    const record = data;
+    if (Array.isArray(record.items)) {
+      return {
+        rows: record.items,
+        // Measured: a final page sends `nextPage: null`, not an absent key. The
+        // `typeof` check reads that as "no next page" — a truthiness check would
+        // too, but would also swallow a legitimate page 0.
+        nextPage: typeof record.nextPage === "number" ? record.nextPage : void 0
+      };
+    }
+  }
+  throw new Error(
+    `${action}: the response was 2xx but carried neither an array nor an \`items\` list \u2014 refusing to report an unread suite as empty. Body: ${JSON.stringify(data).slice(0, 200)}`
+  );
+}
+async function collectPages(auth, buildUrl, action, onTruncate) {
+  const rows = [];
+  for (let page = 1; page <= MAX_PAGES; page++) {
+    const res = await metaFetch(auth, buildUrl(page), action, { method: "GET" });
+    const text = await res.text();
+    if (!res.ok) throw new Error(httpFailure(action, res, text));
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new Error(`${action}: could not parse the response as JSON:
+${text.slice(0, 200)}`);
+    }
+    const { rows: pageRows, nextPage } = readPage(parsed, action);
+    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",
+    onTruncate
+  );
+  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);
+    return [
+      {
+        kind: "unit",
+        id,
+        name,
+        object: objectType !== void 0 && objectName !== void 0 ? { type: objectType, name: objectName } : void 0,
+        datasource: typeof row.datasource === "string" ? row.datasource : void 0
+      }
+    ];
+  });
+}
+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",
+    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 firstFailureMessage(results) {
+  if (!Array.isArray(results)) return void 0;
+  for (const entry of results) {
+    if (entry === null || typeof entry !== "object") continue;
+    const row = entry;
+    if (row.status === "fail" && typeof row.message === "string" && row.message !== "") return row.message;
+  }
+  return void 0;
+}
+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}`; XanoTS 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) {
+    const detail2 = serverMessage(text);
+    return { ...handle, status: "fail", message: `${res.status} ${res.statusText}${detail2 ? `: ${detail2}` : ""}` };
+  }
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return { ...handle, status: "fail", message: `the engine's response was not JSON: ${text.slice(0, 200)}` };
+  }
+  const passed = body.status === "ok";
+  return {
+    ...handle,
+    status: passed ? "pass" : "fail",
+    message: passed ? void 0 : firstFailureMessage(body.results) ?? asString(body.message) ?? `status: ${String(body.status)}`,
+    // Optional by contract — read defensively, never format unguarded.
+    timing: typeof body.timing === "number" ? body.timing : void 0
+  };
+}
+
+// src/emit/test-command.ts
+var EXIT_TESTS_FAILED = 5;
+var DEFAULT_DEST = "ephemeral";
+async function mapWithConcurrency(items, limit, work) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      results[index] = await work(items[index], index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(Math.max(1, limit), items.length) }, worker));
+  return results;
+}
+function describe(handle) {
+  return handle.object === void 0 ? "[workflow]" : `[unit: ${handle.object.type} ${handle.object.name}]`;
+}
+function renderOutcome(outcome, width) {
+  const s = stderrStyle();
+  const verdict = outcome.status === "pass" ? s.green("PASS") : s.red("FAIL");
+  const timing = outcome.timing === void 0 ? "" : s.dim(`  ${outcome.timing.toFixed(3)}s`);
+  process.stderr.write(`  ${verdict}  ${outcome.name.padEnd(width)}  ${s.dim(describe(outcome))}${timing}
+`);
+  if (outcome.status === "fail" && outcome.message !== void 0) {
+    process.stderr.write(`        ${s.dim(outcome.message)}
+`);
+  }
+}
+function summarize(dest, env, outcomes) {
+  return {
+    dest,
+    env,
+    total: outcomes.length,
+    passed: outcomes.filter((o) => o.status === "pass").length,
+    failed: outcomes.filter((o) => o.status === "fail").length,
+    results: outcomes.map((o) => ({
+      kind: o.kind,
+      name: o.name,
+      object: o.object,
+      status: o.status,
+      message: o.message,
+      timing: o.timing
+    }))
+  };
+}
+function report(args, dest, env, outcomes) {
+  const summary = summarize(dest, env, outcomes);
+  if (isMachineOutput(args)) {
+    writeJson(summary);
+  } else if (outcomes.length === 0) {
+    detail("No tests found.");
+  } else {
+    blank();
+    const s = stderrStyle();
+    const line = `${summary.passed} passed, ${summary.failed} failed`;
+    if (summary.failed > 0) process.stderr.write(`  ${s.red(line)}
+`);
+    else success(line);
+  }
+  if (summary.failed > 0) process.exitCode = EXIT_TESTS_FAILED;
+}
+async function resolveTarget(args, auth) {
+  const dest = args.dest ?? DEFAULT_DEST;
+  const target = await resolveMetaTarget(auth, { dest, name: args.name });
+  return { dest, env: target.env ?? null, target };
+}
+async function collect(auth, target, kind) {
+  return listTests(auth, target, {
+    kind,
+    onTruncate: (collected) => warn(`Stopped after ${collected} tests \u2014 the list did not terminate, so some may not have run.`)
+  });
+}
+function nameWidth(handles) {
+  return Math.max(0, ...handles.map((h) => h.name.length));
+}
+async function runList(args, auth) {
+  const { dest, env, target } = await resolveTarget(args, auth);
+  const handles = await collect(auth, target, args.kind);
+  if (isMachineOutput(args)) {
+    writeJson({
+      dest,
+      env,
+      total: handles.length,
+      tests: handles.map((h) => ({
+        kind: h.kind,
+        name: h.name,
+        qualified: qualifiedName(h),
+        object: h.object,
+        datasource: h.datasource
+      }))
+    });
+    return;
+  }
+  if (handles.length === 0) {
+    detail("No tests found.");
+    return;
+  }
+  const s = stderrStyle();
+  step(`${handles.length} test${handles.length === 1 ? "" : "s"} in ${target.label}`);
+  const width = nameWidth(handles);
+  for (const handle of handles) {
+    const ds = handle.datasource === void 0 || handle.datasource === "" ? "" : s.yellow(`  datasource: ${handle.datasource}`);
+    process.stderr.write(`  ${handle.name.padEnd(width)}  ${s.dim(describe(handle))}${ds}
+`);
+  }
+}
+function match(handles, needle) {
+  const qualified = handles.filter((h) => h.object !== void 0 && qualifiedName(h) === needle);
+  if (qualified.length > 0) return qualified;
+  return handles.filter((h) => h.name === needle);
+}
+async function runOne(args, auth, name) {
+  const { dest, env, target } = await resolveTarget(args, auth);
+  const handles = await collect(auth, target, args.kind);
+  const found = match(handles, name);
+  if (found.length === 0) {
+    throw new Error(
+      `No test named "${name}" in ${target.label}. Run \`xanots test list${args.dest ? ` --dest ${args.dest}` : ""}\` to see what is there.`
+    );
+  }
+  if (found.length > 1) {
+    throw new Error(
+      `"${name}" names ${found.length} tests in ${target.label}. Use the qualified form:
+` + found.map((h) => `  xanots test run "${qualifiedName(h)}"`).join("\n")
+    );
+  }
+  const handle = found[0];
+  step(`Running ${handle.name} in ${target.label}`);
+  const outcome = await runTest(auth, target, handle);
+  if (!isMachineOutput(args)) renderOutcome(outcome, handle.name.length);
+  report(args, dest, env, [outcome]);
+}
+async function runSuite(auth, target, opts) {
+  const handles = await collect(auth, target, opts.kind);
+  if (handles.length === 0) return [];
+  const units = handles.filter((h) => h.kind === "unit").length;
+  const flows = handles.length - units;
+  if (opts.human) {
+    step(
+      `Running ${handles.length} test${handles.length === 1 ? "" : "s"} against ${target.label} (${units} unit, ${flows} workflow)`
+    );
+    blank();
+  }
+  const width = nameWidth(handles);
+  let emitted = 0;
+  const settled = new Array(handles.length);
+  const flush = () => {
+    while (emitted < settled.length && settled[emitted] !== void 0) {
+      renderOutcome(settled[emitted], width);
+      emitted++;
+    }
+  };
+  return mapWithConcurrency(handles, opts.concurrency ?? 1, async (handle, index) => {
+    const outcome = await runTest(auth, target, handle);
+    settled[index] = outcome;
+    if (opts.human) flush();
+    return outcome;
+  });
+}
+async function runAll(args, auth) {
+  const { dest, env, target } = await resolveTarget(args, auth);
+  const outcomes = await runSuite(auth, target, {
+    kind: args.kind,
+    concurrency: args.concurrency,
+    human: !isMachineOutput(args)
+  });
+  report(args, dest, env, outcomes);
+}
+async function runTestCommand(args) {
+  const auth = await getAccessToken(args);
+  switch (args.subcommand) {
+    case "list":
+      return runList(args, auth);
+    case "run": {
+      const name = args.positionals[0];
+      if (name === void 0 || name === "") {
+        throw new Error('`xanots test run` needs a test name: `xanots test run "<name>"`.');
+      }
+      return runOne(args, auth, name);
+    }
+    case "run-all":
+      return runAll(args, auth);
+    default:
+      throw unknownSubcommand("test", args.subcommand);
+  }
+}
+export {
+  EXIT_TESTS_FAILED,
+  runSuite,
+  runTestCommand
+};
+//# sourceMappingURL=test-command-TSPBQHBM.js.map

package/dist/validate-command-4ERHJSCO.js

@@ -0,0 +1,122 @@
+import {
+  assertBundleInput,
+  loadBundleText
+} from "./chunk-NOO35BQ2.js";
+import "./chunk-YGPIY3WT.js";
+import "./chunk-IZW6MK3U.js";
+import {
+  blank,
+  detail,
+  info,
+  step,
+  success,
+  warn
+} from "./chunk-EZG76F7R.js";
+import "./chunk-3DUAGYGP.js";
+import "./chunk-YYRDLFSJ.js";
+import "./chunk-EMCAWMHC.js";
+import "./chunk-WHOJWOSV.js";
+import "./chunk-LH6Z6KFV.js";
+import "./chunk-HJPTWBLH.js";
+import "./chunk-GNPVYOPB.js";
+import "./chunk-4HT3BNZ7.js";
+
+// src/emit/validate-command.ts
+var EXIT_VALIDATION_FAILED = 2;
+async function runValidateCommand(args) {
+  assertBundleInput(args, { command: "validate" });
+  const { resolveValidateConfig, verifyToken } = await import("./config-NL33PN4D.js");
+  const { MetaClient } = await import("./meta-client-OW5WKWW7.js");
+  const config = resolveValidateConfig({ instance: args.instance });
+  const who = await verifyToken(config);
+  const host = new URL(config.instance).host;
+  step(`Validating against ${host}${who.name ? ` (as ${who.name})` : ""}`);
+  const { bundle } = await loadBundleText(args, { command: "validate" });
+  const client = new MetaClient(config);
+  try {
+    await validateWithClient(args, client, bundle);
+  } finally {
+    const teardown = await client.dispose();
+    if (teardown.error !== void 0) {
+      warn("Could not delete the validation environment; it will expire on its own:");
+      detail(teardown.error);
+    }
+  }
+}
+async function validateWithClient(args, client, bundle) {
+  const { runValidateLoop, runnableFunctionNames } = await import("./loop-OM3P2Z6O.js");
+  const result = await runValidateLoop(client, bundle);
+  if (!result.accepted) {
+    warn("Import rejected by the engine:");
+    detail(result.importError ?? "(no message)");
+    process.exitCode = EXIT_VALIDATION_FAILED;
+    return;
+  }
+  success(`Import accepted (workspace #${result.workspaceId ?? "?"})`);
+  let failed = false;
+  for (const entry of result.roundTrip) {
+    if (entry.status === "match") {
+      success(`round-trip \u2713 ${entry.kind} ${entry.name}`);
+    } else if (entry.status === "missing") {
+      warn(`round-trip ? ${entry.kind} ${entry.name} \u2014 not found in the imported workspace`);
+      failed = true;
+    } else if (entry.status === "ambiguous") {
+      warn(`round-trip ? ${entry.kind} ${entry.name} \u2014 multiple imported objects share its identity`);
+      failed = true;
+    } else {
+      warn(`round-trip \u2717 ${entry.kind} ${entry.name} \u2014 ${entry.diffs.length} field diff(s)`);
+      const shown = args.verbose ? entry.diffs : entry.diffs.slice(0, 10);
+      for (const d of shown) detail(`${d.path}: expected ${fmt(d.expected)}, got ${fmt(d.actual)}`);
+      if (!args.verbose && entry.diffs.length > shown.length) {
+        detail(`\u2026 ${entry.diffs.length - shown.length} more (run with --verbose)`);
+      }
+      failed = true;
+    }
+  }
+  for (const u of result.unchecked) {
+    info(`imported ${u.count} ${u.kind} object(s) \u2014 round-trip not checked`);
+  }
+  if (args.runtime && result.workspaceId !== void 0) {
+    const names = runnableFunctionNames(result.roundTrip);
+    if (names.length > 0) {
+      const { smokeRunFunctions } = await import("./runtime-V4C3AC3A.js");
+      blank();
+      const entries = await smokeRunFunctions(client, result.workspaceId, names);
+      for (const e of entries) {
+        if (e.ran) {
+          success(`runtime \u2713 ${e.name}`);
+          if (args.verbose) detail(fmt(e.detail));
+        } else {
+          warn(`runtime \u2717 ${e.name} (status ${e.status})`);
+          if (args.verbose) detail(fmt(e.detail));
+          failed = true;
+        }
+      }
+    }
+  }
+  if (args.capture) {
+    const { captureFixtures } = await import("./capture-HUV5BNTC.js");
+    const written = captureFixtures(result.roundTrip, args.out);
+    if (written.length === 0) warn("nothing to capture (no objects round-tripped)");
+    for (const w of written) detail(`captured ${w.name} \u2192 ${w.path}`);
+  }
+  if (failed) {
+    process.exitCode = EXIT_VALIDATION_FAILED;
+  } else {
+    blank();
+    success("Validation passed");
+  }
+}
+function fmt(v) {
+  if (typeof v === "string") return JSON.stringify(v);
+  if (v === void 0) return "(absent)";
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+export {
+  runValidateCommand
+};
+//# sourceMappingURL=validate-command-4ERHJSCO.js.map

package/dist/verify-rollout-FAVQ6EJY.js

@@ -0,0 +1,40 @@
+// src/deploy/verify-rollout.ts
+var CANONICAL_HEADER = "X-Xano-Canonical";
+var FAST_POLL_MS = 1e3;
+var FAST_PHASE_MS = 3e4;
+var SLOW_POLL_MS = 2e3;
+var REQUEST_TIMEOUT_MS = 1e4;
+function cacheBust(url, nonce) {
+  try {
+    const u = new URL(url);
+    u.searchParams.set("_xc", String(nonce));
+    return u.toString();
+  } catch {
+    return `${url}${url.includes("?") ? "&" : "?"}_xc=${nonce}`;
+  }
+}
+async function verifyRollout(url, canonical, opts = {}) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const totalDeadlineMs = opts.totalDeadlineMs ?? 12e4;
+  if (url === "" || canonical === "") return { live: false };
+  const start = now();
+  for (; ; ) {
+    try {
+      const res = await fetchFn(cacheBust(url, now()), {
+        method: "GET",
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (res.headers.get(CANONICAL_HEADER) === canonical) return { live: true };
+    } catch {
+    }
+    const elapsed = now() - start;
+    if (elapsed >= totalDeadlineMs) return { live: false };
+    await sleep(elapsed < FAST_PHASE_MS ? FAST_POLL_MS : SLOW_POLL_MS);
+  }
+}
+export {
+  verifyRollout
+};
+//# sourceMappingURL=verify-rollout-FAVQ6EJY.js.map

package/dist/workspace-K72NP7SX.js

@@ -0,0 +1,49 @@
+import {
+  fetchReadOrExplain
+} from "./chunk-3IGNIP6R.js";
+
+// src/deploy/workspace.ts
+var RESOLVE_TIMEOUT_MS = 3e4;
+async function resolveScopedWorkspaceId(auth) {
+  const url = new URL("/api:meta/auth/me", auth.instance);
+  const res = await fetchReadOrExplain(
+    url.href,
+    {
+      headers: { Authorization: `Bearer ${auth.access_token}` },
+      signal: AbortSignal.timeout(RESOLVE_TIMEOUT_MS)
+    },
+    "resolve workspace",
+    RESOLVE_TIMEOUT_MS
+  );
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`resolve workspace failed (${res.status} ${res.statusText}):
+${text}`);
+  }
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new Error(`resolve workspace: could not parse the ${url.pathname} response as JSON:
+${text}`);
+  }
+  const extras = data.extras ?? {};
+  const oauth = extras.oauth ?? {};
+  const instance = extras.instance ?? {};
+  const membership = instance.membership ?? {};
+  const list = Array.isArray(membership.workspace) ? membership.workspace : [];
+  const scopedGuid = typeof oauth.workspace === "string" ? oauth.workspace : void 0;
+  if (scopedGuid !== void 0 && scopedGuid !== "") {
+    const match = list.find((w) => w.guid === scopedGuid);
+    if (match !== void 0 && typeof match.id === "number") return match.id;
+  }
+  const ids = list.filter((w) => typeof w.id === "number");
+  if (ids.length === 1) return ids[0].id;
+  throw new Error(
+    `Could not resolve which workspace this token is scoped to (scoped workspace ${scopedGuid ?? "(none)"} not found among ${ids.length} membership workspaces). Run \`xanots login\` again and pick a single workspace at the consent screen. There is no workspace override \u2014 a credential addresses exactly one workspace.`
+  );
+}
+export {
+  resolveScopedWorkspaceId
+};
+//# sourceMappingURL=workspace-K72NP7SX.js.map