@xano/sdk 1.0.0

package/dist/static-host-B2Y6AG3W.js

@@ -0,0 +1,352 @@
+import {
+  tarGz
+} from "./chunk-X4DVXBFY.js";
+import {
+  writeTransportFailure
+} from "./chunk-6PBR37LN.js";
+import {
+  SENT_AFTERMATH,
+  fetchOrExplain,
+  httpFailure,
+  parseJsonAnswer,
+  serverMessage,
+  unexpectedAnswerError,
+  withWriteStatusAftermath
+} from "./chunk-YLDALTWZ.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-PTHVMXZI.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import {
+  SERVER_BUNDLE,
+  SERVER_ENV,
+  isServerPath
+} from "./chunk-OOXWYAA4.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/deploy/static-host.ts
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "fs";
+import { join, relative, sep } from "path";
+var STATIC_TIMEOUT_MS = 12e4;
+var MAX_ARCHIVE_BYTES = 100 * 1024 * 1024;
+function scanFiles(dir, opts = {}) {
+  const files = [];
+  const links = walkBuild(dir, opts, (path, full) => files.push({ path, data: readFileSync(full) }));
+  return { files, links };
+}
+function walkBuild(dir, opts, onFile) {
+  const links = [];
+  const root = realpathSync(dir);
+  const inside = (real) => real === root || real.startsWith(root.endsWith(sep) ? root : root + sep);
+  const visiting = /* @__PURE__ */ new Set();
+  const walk = (cur, real) => {
+    if (visiting.has(real)) return;
+    visiting.add(real);
+    for (const ent of readdirSync(cur, { withFileTypes: true })) {
+      const full = join(cur, ent.name);
+      const path = relative(dir, full).split(sep).join("/");
+      if (opts.server === false && isServerPath(path)) continue;
+      if (ent.isSymbolicLink()) {
+        let target;
+        try {
+          target = realpathSync(full);
+        } catch {
+          links.push({ path, reason: "broken" });
+          continue;
+        }
+        if (!inside(target)) {
+          links.push({ path, reason: "outside" });
+          continue;
+        }
+        const st = statSync(target);
+        if (st.isDirectory()) walk(full, target);
+        else if (st.isFile()) onFile(path, full);
+      } else if (ent.isDirectory()) walk(full, join(real, ent.name));
+      else if (ent.isFile()) onFile(path, full);
+    }
+    visiting.delete(real);
+  };
+  walk(dir, root);
+  return links;
+}
+function collectFiles(dir, opts = {}) {
+  return scanFiles(dir, opts).files;
+}
+var UNREQUESTED_DOTFILES = /* @__PURE__ */ new Set([".DS_Store", ".gitkeep", ".gitignore", ".nojekyll"]);
+function isHiddenPath(path) {
+  const segs = path.split("/");
+  return segs.some((seg) => seg.startsWith(".")) && !UNREQUESTED_DOTFILES.has(segs.at(-1));
+}
+function assertStaticDir(dir, label, maxBytes = MAX_ARCHIVE_BYTES, opts = {}) {
+  const where = `${label === void 0 ? "" : `${label} `}${dir}`;
+  const stat = statSync(dir, { throwIfNoEntry: false });
+  if (stat === void 0) throw new StaticDirError(`${where}: directory not found.`);
+  if (!stat.isDirectory()) throw new StaticDirError(`${where}: not a directory.`);
+  const serverRendered = opts.serverRendered === true;
+  if (serverRendered) assertWithinEngineLimits(dir, where);
+  const files = collectFiles(dir, { server: serverRendered });
+  if (files.length === 0) throw new StaticDirError(`${where}: no files to deploy (directory is empty).`);
+  const rendered = files.some((f) => f.path === SERVER_BUNDLE);
+  if (!rendered && !files.some((f) => f.path === "index.html")) {
+    throw new StaticDirError(
+      `${where}: no index.html at its root, so the static host would have no entry page. ` + (existsSync(join(dir, SERVER_BUNDLE)) ? `Its server half (${SERVER_BUNDLE}) renders pages on a local engine only (\`--local-engine\`); a host that serves files needs the root page prerendered.` : `Point it at the build output directory \u2014 the one that holds index.html.`)
+    );
+  }
+  assertArchiveFits(files, where, maxBytes);
+}
+var ENGINE_MAX_FILES = 2e4;
+var ENGINE_MAX_UNPACKED_BYTES = 256 * 1024 * 1024;
+function assertWithinEngineLimits(dir, where) {
+  let files = 0;
+  let bytes = 0;
+  walkBuild(dir, { server: true }, (_path, full) => {
+    files++;
+    bytes += statSync(full).size;
+  });
+  const advice = "Point at the build output only (not the project root or node_modules), or trim what it ships.";
+  if (files > ENGINE_MAX_FILES) {
+    throw new StaticDirError(
+      `${where}: ${files.toLocaleString("en-US")} files, over a local engine's limit of ${ENGINE_MAX_FILES.toLocaleString("en-US")}. ${advice}`
+    );
+  }
+  if (bytes > ENGINE_MAX_UNPACKED_BYTES) {
+    const mb = (n) => Number((n / (1024 * 1024)).toFixed(2));
+    throw new StaticDirError(
+      `${where}: ${mb(bytes)} MB unpacked, over a local engine's limit of ${mb(ENGINE_MAX_UNPACKED_BYTES)} MB. ${advice}`
+    );
+  }
+}
+function assertArchiveFits(files, where, maxBytes) {
+  const bound = files.reduce((sum, f) => sum + f.data.length + 1024, 1024);
+  if (bound <= maxBytes) return;
+  const size = tarGz2(files).length;
+  if (size > maxBytes) throw new StaticDirError(overCapMessage(where, size, maxBytes));
+}
+function overCapMessage(where, size, maxBytes = MAX_ARCHIVE_BYTES) {
+  const mb = (n) => `${Number((n / (1024 * 1024)).toFixed(2))} MB`;
+  return `${where}: the compressed build is ${mb(size)}, over the ${mb(maxBytes)} cap for a static upload. Point at the build output only (not the project root or node_modules), or trim what it ships.`;
+}
+var StaticDirError = class extends Error {
+  name = "StaticDirError";
+};
+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, { server: false })) {
+    const text = file.data.toString("latin1");
+    const seen = /* @__PURE__ */ new Set();
+    for (const v of values) {
+      const key = `${v.table}\0${v.column}`;
+      if (seen.has(key) || !text.includes(v.value)) continue;
+      seen.add(key);
+      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 multipageOnlyForErrorPage(paths) {
+  const docs = paths.map((p) => p.replace(/^\.?\//, "").toLowerCase()).filter((p) => /\.html?$/.test(p));
+  return docs.includes("index.html") && docs.some((p) => p !== "index.html") && docs.every((p) => p === "index.html" || p === "404.html" || p === "200.html");
+}
+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 markup = maskNonMarkup(html);
+  const at = (m) => m === null ? void 0 : m.index + m[0].length;
+  const anchor = at(/<head(?=[\s>/])[^>]*>/i.exec(markup)) ?? at(/<html(?=[\s>/])[^>]*>/i.exec(markup)) ?? at(/^\s*<!doctype[^>]*>/i.exec(markup)) ?? (/<(?:title|meta|link|base|body)(?=[\s>/])/i.test(markup) ? 0 : void 0);
+  if (anchor === void 0) return void 0;
+  return html.slice(0, anchor) + script + html.slice(anchor);
+}
+function maskNonMarkup(html) {
+  return html.replace(
+    /<!--[\s\S]*?(?:-->|$)|<!\[CDATA\[[\s\S]*?(?:\]\]>|$)|<(script|style|noscript|template)(?=[\s>/])[\s\S]*?(?:<\/\1\s*>|$)|<[a-z][^\s/>]*(?:"[^"]*"|'[^']*'|[^'">])*>?/gi,
+    (m, element) => element !== void 0 || m.startsWith("<!") ? " ".repeat(m.length) : m.replace(/"[^"]*"|'[^']*'/g, (q) => `${q[0]}${" ".repeat(q.length - 2)}${q[0]}`)
+  );
+}
+async function deployStaticHost(req) {
+  const serverRendered = req.serverRendered === true;
+  assertStaticDir(req.dir, req.label, MAX_ARCHIVE_BYTES, { serverRendered });
+  const { files, links } = scanFiles(req.dir, { server: serverRendered });
+  const hidden = serverRendered ? [] : files.map((f) => f.path).filter(isHiddenPath);
+  const hasServer = existsSync(join(req.dir, SERVER_BUNDLE));
+  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) || isServerPath(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++;
+    }
+  }
+  if (serverRendered && hasServer && Object.keys(env).length > 0) {
+    const i = files.findIndex((f) => f.path === SERVER_ENV);
+    if (i >= 0) files.splice(i, 1);
+    files.push({ path: SERVER_ENV, data: Buffer.from(JSON.stringify(env), "utf8") });
+  }
+  const archive = tarGz2(files);
+  if (archive.length > MAX_ARCHIVE_BYTES) {
+    throw new StaticDirError(overCapMessage(`${req.label === void 0 ? "" : `${req.label} `}${req.dir}`, archive.length));
+  }
+  const servedPaths = files.filter((f) => !isServerPath(f.path)).map((f) => f.path);
+  const routing = req.routing ?? detectRouting(servedPaths);
+  const routingSuspect = req.routing === void 0 && routing === "multipage" && !hasServer && multipageOnlyForErrorPage(servedPaths);
+  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", "xanosdk-deploy");
+  form.append("routing", routing);
+  form.append("file", new Blob([archive], { type: "application/gzip" }), "build.tar.gz");
+  const res = await fetchOrExplain(
+    url,
+    {
+      method: "POST",
+      headers: { Authorization: `Bearer ${req.accessToken}` },
+      body: form,
+      signal: AbortSignal.timeout(STATIC_TIMEOUT_MS)
+    },
+    "Static-host build",
+    STATIC_TIMEOUT_MS
+  ).catch((err) => {
+    throw writeTransportFailure(err);
+  });
+  const text = await res.text().catch((err) => {
+    throw writeTransportFailure(err);
+  });
+  if (!res.ok) {
+    if (serverMessage(text) === "Invalid host") {
+      throw new StaticHostNotFoundError(host, await listStaticHostNames(req).catch(() => void 0));
+    }
+    throw Object.assign(
+      new Error(withWriteStatusAftermath(httpFailure("Static-host build", res, text), res.status, void 0, { atomic: true })),
+      { status: res.status }
+    );
+  }
+  const answer = parseJsonAnswer(text, "Static-host build", url, { aftermath: SENT_AFTERMATH });
+  const parsed = answer !== null && typeof answer === "object" && !Array.isArray(answer) ? answer : {};
+  const live = pickUrl(parsed);
+  if (live === void 0) throw unexpectedAnswerError("Static-host build", text, url, { aftermath: SENT_AFTERMATH });
+  return {
+    url: live,
+    canonical: pickCanonical(parsed),
+    envInjected: envDocuments > 0,
+    envDocuments,
+    envSkipped,
+    routing,
+    ...routingSuspect ? {
+      routingSuspect: true,
+      routingSuspectPages: servedPaths.map((p) => p.replace(/^\.?\//, "")).filter((p) => /\.html?$/i.test(p) && p.toLowerCase() !== "index.html")
+    } : {},
+    ...hasServer ? { serverBundle: serverRendered ? "uploaded" : "omitted" } : {},
+    ...hidden.length > 0 ? { hiddenUnserved: hidden } : {},
+    ...links.length > 0 ? { skippedLinks: links } : {},
+    raw: text
+  };
+}
+var StaticHostNotFoundError = class extends Error {
+  constructor(host, names, outcome = "Nothing was published.") {
+    super(
+      `No static host named "${host}" exists on the target` + (names === void 0 ? "" : names.length === 0 ? " \u2014 it has none yet" : ` \u2014 its hosts are ${names.map((n) => `"${n}"`).join(", ")}`) + `. Only \`default\` is created on first publish: drop \`--static-host\` to publish to it, or name a host that exists (created in the Xano dashboard's static hosting). ${outcome}`
+    );
+    this.host = host;
+    this.names = names;
+  }
+  host;
+  names;
+  name = "StaticHostNotFoundError";
+  exitCode = 8;
+};
+var STATIC_READ_TIMEOUT_MS = 2e4;
+async function readStaticHostRows(req) {
+  const rows = [];
+  const root = `${req.baseUrl.replace(/\/$/, "")}/api:meta/workspace/${req.workspaceId}/static_host`;
+  for (let page = 1; page <= 10; page++) {
+    const res = await fetchOrExplain(
+      `${root}?page=${page}`,
+      {
+        headers: { Authorization: `Bearer ${req.accessToken}` },
+        signal: AbortSignal.timeout(STATIC_READ_TIMEOUT_MS)
+      },
+      "Reading the static hosts",
+      STATIC_READ_TIMEOUT_MS
+    );
+    const text = await res.text();
+    if (!res.ok) throw new Error(httpFailure("Reading the static hosts", res, text));
+    const parsed = parseJsonAnswer(text, "Reading the static hosts", root) ?? {};
+    if (!Array.isArray(parsed.items)) throw new Error("Reading the static hosts: the answer carried no list.");
+    for (const item of parsed.items) {
+      if (item !== null && typeof item === "object") rows.push(item);
+    }
+    if (typeof parsed.nextPage !== "number") break;
+  }
+  return rows;
+}
+async function listStaticHostNames(req) {
+  const rows = await readStaticHostRows(req);
+  return rows.map((r) => r.name).filter((n) => typeof n === "string" && n !== "");
+}
+async function listServingStaticHosts(req) {
+  const serving = [];
+  for (const row of await readStaticHostRows(req)) {
+    const host = typeof row.name === "string" ? row.name : "";
+    for (const env of [row.dev, row.prod]) {
+      if (env === null || typeof env !== "object") continue;
+      const url = pickUrl(env);
+      if (url !== void 0 && !serving.some((s) => s.url === url)) serving.push({ host, url });
+    }
+  }
+  return serving;
+}
+export {
+  StaticDirError,
+  StaticHostNotFoundError,
+  assertStaticDir,
+  deployStaticHost,
+  detectRouting,
+  findSeedLeaks,
+  listServingStaticHosts,
+  listStaticHostNames,
+  multipageOnlyForErrorPage,
+  tarGz2 as tarGz
+};
+//# sourceMappingURL=static-host-B2Y6AG3W.js.map