@xanots/sdk 0.0.1

package/dist/routes-manifest-SP3ZXLMR.js

@@ -0,0 +1,244 @@
+import {
+  parsePathParams
+} from "./chunk-WHOJWOSV.js";
+
+// src/emit/routes-manifest.ts
+var RouteManifestError = class extends Error {
+};
+function literal(value) {
+  return JSON.stringify(value);
+}
+function objectLiteral(rows) {
+  return rows.length === 0 ? "{}" : `{
+${rows.join("\n")}
+}`;
+}
+function overloadsFor(fn, rows) {
+  return rows.map(
+    (r) => r.params.length === 0 ? `export function ${fn}(name: ${literal(r.name)}): string;` : `export function ${fn}(name: ${literal(r.name)}, params: { ${r.params.map((p) => `${literal(p)}: string | number`).join("; ")} }): string;`
+  ).join("\n");
+}
+function renderRealtime(realtime) {
+  const servers = [...realtime.servers].sort((a, b) => a.name.localeCompare(b.name));
+  const known = new Map(servers.map((s) => [s.name, s]));
+  const seenServer = /* @__PURE__ */ new Set();
+  for (const server of servers) {
+    if (seenServer.has(server.name)) {
+      throw new RouteManifestError(
+        `Two realtime servers are both named "${server.name}". The manifest keys on the server name, so the names must be unique. Rename one.`
+      );
+    }
+    seenServer.add(server.name);
+  }
+  const seenChannel = /* @__PURE__ */ new Map();
+  const channels = [...realtime.channels].sort((a, b) => a.name.localeCompare(b.name)).map((channel) => {
+    const clash = seenChannel.get(channel.name);
+    if (clash !== void 0) {
+      throw new RouteManifestError(
+        `The channel path "${channel.name}" is owned by both realtime server "${clash}" and "${channel.server}". The route manifest keys channels on their path, so the paths must be unique across servers. Rename one channel.`
+      );
+    }
+    seenChannel.set(channel.name, channel.server);
+    if (!known.has(channel.server)) {
+      throw new RouteManifestError(
+        `The channel "${channel.name}" names the realtime server "${channel.server}", which is not in this workspace. A channel's socket URL comes from its server's canonical, so the server must be registered too.`
+      );
+    }
+    return { ...channel, params: parsePathParams(`channel "${channel.name}"`, channel.name) };
+  });
+  const serverRows = servers.map(
+    (s) => `  ${literal(s.name)}: { canonical: ${literal(s.canonical)} },`
+  );
+  const channelRows = channels.map(
+    (c) => `  ${literal(c.name)}: { server: ${literal(c.server)} },`
+  );
+  return `
+/** Every realtime server in this workspace, by name, with its resolved canonical. */
+export const REALTIME_SERVERS = ${objectLiteral(serverRows)} as const;
+
+/** Every realtime server name in this workspace. */
+export type RealtimeServerName = keyof typeof REALTIME_SERVERS;
+
+/** Every realtime channel in this workspace, by path, with its owning server. */
+export const CHANNELS = ${objectLiteral(channelRows)} as const;
+
+/** Every realtime channel path in this workspace. */
+export type ChannelName = keyof typeof CHANNELS;
+
+${overloadsFor("channelPath", channels)}
+${REALTIME_IMPLEMENTATION}`;
+}
+function renderRouteManifest(routes, realtime) {
+  const sorted = [...routes].sort(
+    (a, b) => a.canonical.localeCompare(b.canonical) || a.name.localeCompare(b.name)
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const rows = sorted.map((route) => {
+    if (seen.has(route.name)) {
+      throw new RouteManifestError(
+        `Two endpoints are both named "${route.name}". The route manifest keys on the endpoint name, so the names must be unique across api groups. Rename one.`
+      );
+    }
+    seen.add(route.name);
+    const params = parsePathParams(`route "${route.name}"`, route.name);
+    const path = `/api:${route.canonical}/${route.name.replace(/^\/+/, "")}`;
+    return { ...route, params, path };
+  });
+  const entries = rows.map(
+    (r) => `  ${literal(r.name)}: { verb: ${literal(r.verb)}, path: ${literal(r.path)} },`
+  );
+  const realtimeSection = realtime && (realtime.servers.length > 0 || realtime.channels.length > 0) ? renderRealtime(realtime) : "";
+  return `${HEADER}${FILL_PARAMS}
+export const ROUTES = ${objectLiteral(entries)} as const;
+
+/** Every endpoint name in this workspace. */
+export type RouteName = keyof typeof ROUTES;
+
+${overloadsFor("routePath", rows)}
+${IMPLEMENTATION}${realtimeSection}`;
+}
+var HEADER = `/**
+ * GENERATED by \`xanots paths --emit\`. Do not edit.
+ *
+ * Plain data plus one interpolator \u2014 this file imports nothing, so a frontend
+ * gets the typed path/verb (and socket) contract without pulling the SDK runtime
+ * into its bundle. Regenerate after changing an endpoint's name, verb, or api
+ * group, or a realtime server's or channel's name.
+ */
+`;
+var FILL_PARAMS = `
+function fillParams(
+  label: string,
+  noun: string,
+  template: string,
+  params?: Record<string, string | number>,
+  encode = false,
+): string {
+  const declared = [...template.matchAll(/\\{([^/{}]+)\\}/g)].map((m) => m[1]!);
+  for (const key of Object.keys(params ?? {})) {
+    if (!declared.includes(key)) {
+      throw new Error(
+        \`\${label}: \\\`\${key}\\\` is not a {param} of this \${noun}.\` +
+          (declared.length ? \` Expected: \${declared.join(", ")}.\` : \` This \${noun} is static.\`),
+      );
+    }
+  }
+  return template.replace(/\\{([^/{}]+)\\}/g, (_all, key: string) => {
+    const value = (params ?? {})[key];
+    if (value === undefined || value === null || value === "") {
+      throw new Error(\`\${label}: missing a value for the path param \\\`\${key}\\\`.\`);
+    }
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new Error(\`\${label}: the path param \\\`\${key}\\\` is \${value}.\`);
+    }
+    const text = String(value);
+    if (text.includes("/")) {
+      throw new Error(
+        \`\${label}: the path param \\\`\${key}\\\` cannot contain "/" \u2014 \` +
+          \`it would address a different \${noun}.\`,
+      );
+    }
+    if (!encode) return text;
+    // A "." or ".." segment is REMOVED before routing (and takes the segment
+    // before it), and encoding does not help \u2014 the URL standard reads "%2e" as
+    // a dot for that check too. Everything else rides percent-encoded.
+    if (/^(\\.|%2e){1,2}$/i.test(text)) {
+      throw new Error(
+        \`\${label}: the path param \\\`\${key}\\\` cannot be "\${text}" \u2014 \` +
+          \`a "." or ".." segment addresses a different \${noun}.\`,
+      );
+    }
+    return encodeURIComponent(text);
+  });
+}
+`;
+var IMPLEMENTATION = `
+export function routePath(name: RouteName, params?: Record<string, string | number>): string {
+  // Read through a widened view: a workspace with no endpoints at all makes
+  // \`RouteName\` \`never\`, which cannot index the literal type.
+  const route = (ROUTES as Record<string, { verb: string; path: string } | undefined>)[name];
+  if (!route) throw new Error(\`routePath: unknown route "\${String(name)}".\`);
+  return fillParams(\`routePath("\${String(name)}")\`, "route", route.path, params, true);
+}
+`;
+var REALTIME_IMPLEMENTATION = `
+export function channelPath(name: ChannelName, params?: Record<string, string | number>): string {
+  if (!(CHANNELS as Record<string, unknown>)[name]) {
+    throw new Error(\`channelPath: unknown channel "\${String(name)}".\`);
+  }
+  return fillParams(\`channelPath("\${String(name)}")\`, "channel", String(name), params);
+}
+
+/** Reject a tenant name that would break the \\\`<tenant>:<canonical>\\\` split. */
+function assertTenant(tenant: string): string {
+  if (!/^[A-Za-z0-9-]+$/.test(tenant)) {
+    throw new Error(
+      \`socketUrl: invalid \\\`tenant\\\` \${JSON.stringify(tenant)} \u2014 a tenant name is alphanumeric with \` +
+        \`dashes (e.g. "xxxx-xxxx-xxxx"). It rides as a "<tenant>:<canonical>" prefix, so ":" and "/" \` +
+        "cannot appear in it.",
+    );
+  }
+  return tenant;
+}
+
+/** The websocket PATH \u2014 \\\`/ws/<canonical>\\\`, or \\\`/ws/<tenant>:<canonical>\\\`. */
+export function socketPath(server: RealtimeServerName, opts?: { tenant?: string }): string {
+  const entry = REALTIME_SERVERS[server];
+  if (!entry) throw new Error(\`socketPath: unknown realtime server "\${String(server)}".\`);
+  const prefix = opts?.tenant ? \`\${assertTenant(opts.tenant)}:\` : "";
+  return \`/ws/\${prefix}\${entry.canonical}\`;
+}
+
+/** The absolute websocket URL \u2014 \\\`baseUrl\\\` + {@link socketPath}, scheme normalized to ws/wss. */
+export function socketUrl(
+  server: RealtimeServerName,
+  baseUrl: string,
+  opts?: { tenant?: string },
+): string {
+  if (!REALTIME_SERVERS[server]) {
+    throw new Error(\`socketUrl: unknown realtime server "\${String(server)}".\`);
+  }
+  const base = (baseUrl ?? "").trim().replace(/\\/+$/, "");
+  if (!base) throw new Error('socketUrl: needs a base URL (e.g. "https://x.dev.xano.io").');
+  const socketBase = /^wss?:\\/\\//i.test(base)
+    ? base
+    : /^https?:\\/\\//i.test(base)
+      ? base.replace(/^http/i, "ws")
+      : \`wss://\${base}\`;
+  // A base URL ending in \\\`/ws/<something>\\\` is this function's own output fed back
+  // in. Appending a second \\\`/ws/<canonical>\\\` is wrong twice: the extra segments
+  // join the connection hash, and the tenant is dropped (the first call already
+  // consumed the \\\`/tenant/<name>\\\` prefix). Refuse rather than dial a bad URL.
+  if (/\\/ws\\/[^/]+$/i.test(socketBase)) {
+    throw new Error(
+      \`socketUrl: \\\`baseUrl\\\` already carries a socket path (\${base}). Pass the http(s) \` +
+        "INSTANCE base URL, not the result of a previous socketUrl()/getUrl() \u2014 resolving twice " +
+        'appends a second "/ws/<canonical>" and drops the tenant.',
+    );
+  }
+  // A tenant base URL names its tenant as its own path segment; the socket glues
+  // it to the canonical inside one segment. Translate rather than concatenate \u2014
+  // the concatenated form never upgrades at all.
+  const lifted = /^(wss?:\\/\\/[^/]+)\\/tenant\\/([^/]+)(\\/.*)?$/i.exec(socketBase);
+  let origin = socketBase;
+  let tenant = opts?.tenant;
+  if (lifted) {
+    const fromBase = lifted[2]!;
+    if (tenant !== undefined && tenant !== fromBase) {
+      throw new Error(
+        \`socketUrl: given tenant \${JSON.stringify(tenant)} but the base URL names \` +
+          \`\${JSON.stringify(fromBase)} (".../tenant/\${fromBase}"). Refusing to guess which one you \` +
+          "meant \u2014 pass the matching tenant, or a base URL without the \\"/tenant/<name>\\" prefix.",
+      );
+    }
+    origin = \`\${lifted[1]!}\${lifted[3] ?? ""}\`;
+    tenant = assertTenant(fromBase);
+  }
+  return \`\${origin}\${socketPath(server, { tenant })}\`;
+}
+`;
+export {
+  RouteManifestError,
+  renderRouteManifest
+};
+//# sourceMappingURL=routes-manifest-SP3ZXLMR.js.map

package/dist/runtime-V4C3AC3A.js

@@ -0,0 +1,13 @@
+// src/validate/runtime.ts
+async function smokeRunFunctions(client, workspaceId, names, inputs = {}) {
+  const out = [];
+  for (const name of names) {
+    const res = await client.runFunction(workspaceId, name, inputs[name] ?? {});
+    out.push({ name, ran: res.ok, status: res.status, detail: res.body });
+  }
+  return out;
+}
+export {
+  smokeRunFunctions
+};
+//# sourceMappingURL=runtime-V4C3AC3A.js.map

package/dist/sandbox-details-command-HJE5SPVG.js

@@ -0,0 +1,18 @@
+import {
+  fetchSandboxDetails,
+  runSandboxDetailsCommand,
+  sandboxBaseUrl
+} from "./chunk-7DKX2SPN.js";
+import "./chunk-NDZFBZHC.js";
+import "./chunk-NUQCEOKA.js";
+import "./chunk-3IGNIP6R.js";
+import "./chunk-C56BC2FY.js";
+import "./chunk-7REDODS2.js";
+import "./chunk-EZG76F7R.js";
+import "./chunk-GNPVYOPB.js";
+export {
+  fetchSandboxDetails,
+  runSandboxDetailsCommand,
+  sandboxBaseUrl
+};
+//# sourceMappingURL=sandbox-details-command-HJE5SPVG.js.map

package/dist/sandbox-export-command-QCJY4GMV.js

@@ -0,0 +1,24 @@
+import {
+  fetchSandboxBundle,
+  fetchSandboxMultidoc,
+  resolveOutputTarget,
+  runSandboxExportCommand
+} from "./chunk-XQ22GLYS.js";
+import "./chunk-QTNO2WD6.js";
+import "./chunk-ZUTSMMAG.js";
+import "./chunk-X4DVXBFY.js";
+import "./chunk-7DKX2SPN.js";
+import "./chunk-NDZFBZHC.js";
+import "./chunk-NUQCEOKA.js";
+import "./chunk-3IGNIP6R.js";
+import "./chunk-C56BC2FY.js";
+import "./chunk-7REDODS2.js";
+import "./chunk-EZG76F7R.js";
+import "./chunk-GNPVYOPB.js";
+export {
+  fetchSandboxBundle,
+  fetchSandboxMultidoc,
+  resolveOutputTarget,
+  runSandboxExportCommand
+};
+//# sourceMappingURL=sandbox-export-command-QCJY4GMV.js.map

package/dist/static-host-D6KS7X45.js

@@ -0,0 +1,138 @@
+import {
+  tarGz
+} from "./chunk-X4DVXBFY.js";
+
+// src/deploy/static-host.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, relative, sep } from "path";
+var STATIC_TIMEOUT_MS = 12e4;
+var MAX_ARCHIVE_BYTES = 100 * 1024 * 1024;
+function collectFiles(dir) {
+  const out = [];
+  const walk = (cur) => {
+    for (const ent of readdirSync(cur, { withFileTypes: true })) {
+      const full = join(cur, ent.name);
+      if (ent.isDirectory()) walk(full);
+      else if (ent.isFile()) out.push({ path: relative(dir, full).split(sep).join("/"), data: readFileSync(full) });
+    }
+  };
+  walk(dir);
+  return out;
+}
+function findSeedLeaks(dir, values) {
+  values = values.filter((v) => v.scannable !== false);
+  if (values.length === 0 || !existsSync(dir)) return [];
+  const leaks = [];
+  for (const file of collectFiles(dir)) {
+    const text = file.data.toString("latin1");
+    for (const v of values) {
+      if (text.includes(v.value)) leaks.push({ file: file.path, table: v.table, column: v.column });
+    }
+  }
+  return leaks;
+}
+function tarGz2(files) {
+  return tarGz(files.map((f) => ({ name: f.path, data: f.data })));
+}
+function detectRouting(paths) {
+  for (const raw of paths) {
+    const path = raw.replace(/^\.?\//, "");
+    if (path === "" || path.toLowerCase() === "index.html") continue;
+    if (/\.html?$/i.test(path)) return "multipage";
+  }
+  return "spa";
+}
+function pickUrl(parsed) {
+  const dev = parsed.dev;
+  const direct = [parsed.custom_url, parsed.default_url, parsed.url, dev?.custom_url, dev?.default_url, dev?.url].find(
+    (c) => typeof c === "string" && c !== ""
+  );
+  if (direct !== void 0) return /^https?:\/\//.test(direct) ? direct : `https://${direct}`;
+  const host = [dev?.custom, dev?.host].find((c) => typeof c === "string" && c !== "");
+  return host !== void 0 ? `https://${host}` : void 0;
+}
+function pickCanonical(parsed) {
+  const dev = parsed.dev;
+  const build = parsed.build;
+  return [parsed.canonical, dev?.canonical, build?.canonical].find(
+    (c) => typeof c === "string" && c !== ""
+  );
+}
+function envScript(env) {
+  const body = Object.entries(env).map(([k, v]) => `window[${JSON.stringify(k)}]=${JSON.stringify(v)};`).join("").replace(/</g, "\\u003c");
+  return `<script>${body}</script>`;
+}
+function injectEnv(html, script) {
+  const head = /<head[^>]*>/i.exec(html);
+  if (!head) return void 0;
+  const at = head.index + head[0].length;
+  return html.slice(0, at) + script + html.slice(at);
+}
+async function deployStaticHost(req) {
+  if (!existsSync(req.dir)) {
+    throw new Error(`--static ${req.dir}: directory not found.`);
+  }
+  const files = collectFiles(req.dir);
+  if (files.length === 0) {
+    throw new Error(`--static ${req.dir}: no files to deploy (directory is empty).`);
+  }
+  const envSkipped = [];
+  let envDocuments = 0;
+  const env = req.env ?? {};
+  if (Object.keys(env).length > 0) {
+    const script = envScript(env);
+    for (const file of files) {
+      if (!/\.html?$/i.test(file.path)) continue;
+      const rewritten = injectEnv(file.data.toString("utf8"), script);
+      if (rewritten === void 0) {
+        envSkipped.push(file.path);
+        continue;
+      }
+      file.data = Buffer.from(rewritten, "utf8");
+      envDocuments++;
+    }
+  }
+  const archive = tarGz2(files);
+  if (archive.length > MAX_ARCHIVE_BYTES) {
+    throw new Error(`--static ${req.dir}: archive is ${archive.length} bytes, over the ${MAX_ARCHIVE_BYTES}-byte cap.`);
+  }
+  const routing = req.routing ?? detectRouting(files.map((f) => f.path));
+  const host = req.host ?? "default";
+  const url = `${req.baseUrl.replace(/\/$/, "")}/api:meta/workspace/${req.workspaceId}/static_host/${encodeURIComponent(host)}/build`;
+  const form = new FormData();
+  form.append("name", "xanots-deploy");
+  form.append("routing", routing);
+  form.append("file", new Blob([archive], { type: "application/gzip" }), "build.tar.gz");
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${req.accessToken}` },
+    body: form,
+    signal: AbortSignal.timeout(STATIC_TIMEOUT_MS)
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Static-host build failed (${res.status} ${res.statusText}):
+${text}`);
+  }
+  let parsed = {};
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+  }
+  return {
+    url: pickUrl(parsed),
+    canonical: pickCanonical(parsed),
+    envInjected: envDocuments > 0,
+    envDocuments,
+    envSkipped,
+    routing,
+    raw: text
+  };
+}
+export {
+  deployStaticHost,
+  detectRouting,
+  findSeedLeaks,
+  tarGz2 as tarGz
+};
+//# sourceMappingURL=static-host-D6KS7X45.js.map