@xano/sdk 1.0.0

package/dist/chunk-LIEOKXKD.js

@@ -0,0 +1,354 @@
+import {
+  projectSdkVersion
+} from "./chunk-D7VGG3WS.js";
+import {
+  compareSemver,
+  parseSemver
+} from "./chunk-2TFRR6JV.js";
+import {
+  readVersion
+} from "./chunk-ETO6LGLD.js";
+import {
+  registerSecret
+} from "./chunk-AWQ7BQTQ.js";
+import {
+  readPathEnvVar
+} from "./chunk-EUUUMY7J.js";
+import {
+  serverMessage
+} from "./chunk-YLDALTWZ.js";
+import {
+  atomicWrite
+} from "./chunk-LLNZGEFK.js";
+import {
+  envFlagSet,
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+import {
+  blank,
+  noteRunWarning,
+  style,
+  warn
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/update-check.ts
+import { existsSync, readFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+function registryUrl() {
+  const override = readEnvVar("XANOSDK_UPDATE_REGISTRY");
+  if (override !== void 0) return override;
+  return `${npmRegistry().replace(/\/+$/, "")}/@xano/sdk/latest`;
+}
+var DEFAULT_REGISTRY = "https://registry.npmjs.org/";
+function npmRegistry(env = process.env, cwd = process.cwd()) {
+  const { fromEnv, configs } = npmConfig(env, cwd);
+  for (const key of ["@xano:registry", "registry"]) {
+    const value = (key === "registry" ? fromEnv("registry") : void 0) ?? configs.find((c) => c.has(key))?.get(key);
+    if (value !== void 0 && value !== "") return value;
+  }
+  return DEFAULT_REGISTRY;
+}
+function npmConfig(env, cwd) {
+  const fromEnv = (key) => {
+    const value = env[`npm_config_${key}`] ?? env[`NPM_CONFIG_${key.toUpperCase()}`];
+    return value === void 0 || value === "" ? void 0 : value;
+  };
+  const files = [projectNpmrc(cwd), fromEnv("userconfig") ?? join(homedir(), ".npmrc")];
+  const prefix = fromEnv("prefix");
+  if (prefix !== void 0) files.push(join(prefix, "etc", "npmrc"));
+  return { fromEnv, configs: files.flatMap((file) => file === void 0 ? [] : [readNpmrc(file, env)]) };
+}
+function npmAuthHeader(url, env = process.env, cwd = process.cwd()) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return void 0;
+  }
+  const { fromEnv, configs } = npmConfig(env, cwd);
+  const get = (key) => {
+    const value = fromEnv(key) ?? configs.find((c) => c.has(key))?.get(key);
+    return value === void 0 || value === "" ? void 0 : value;
+  };
+  const parts = parsed.pathname.split("/").filter(Boolean);
+  for (let n = parts.length; n >= 0; n--) {
+    const nerf = `//${parsed.host}/${parts.slice(0, n).map((p) => `${p}/`).join("")}`;
+    const header = credentialAt(nerf, get);
+    if (header !== void 0) return header;
+  }
+  const defaultHost = new URL(npmRegistry(env, cwd)).host;
+  return parsed.host === defaultHost ? credentialAt("", get) : void 0;
+}
+function credentialAt(prefix, get) {
+  const key = (name) => prefix === "" ? name : `${prefix}:${name}`;
+  const token = get(key("_authToken"));
+  registerSecret(token);
+  if (token !== void 0) return `Bearer ${token}`;
+  const auth = get(key("_auth"));
+  registerSecret(auth);
+  if (auth !== void 0) return `Basic ${auth}`;
+  const user = get(key("username"));
+  const password = get(key("_password"));
+  registerSecret(password);
+  if (user !== void 0 && password !== void 0) {
+    return `Basic ${Buffer.from(`${user}:${Buffer.from(password, "base64").toString("utf8")}`).toString("base64")}`;
+  }
+  return void 0;
+}
+function projectNpmrc(cwd) {
+  let dir = cwd;
+  for (; ; ) {
+    if (existsSync(join(dir, "package.json"))) return join(dir, ".npmrc");
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function readNpmrc(file, env) {
+  const out = /* @__PURE__ */ new Map();
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return out;
+  }
+  for (const line of text.split(/\r?\n/)) {
+    const m = /^\s*([^#;=\s][^=]*?)\s*=\s*(.*?)\s*$/.exec(line);
+    if (m === null) continue;
+    const value = m[2].replace(/^(["'])(.*)\1$/, "$2").replace(/\$\{([^}]+)\}/g, (_, name) => env[name] ?? "");
+    out.set(m[1], value);
+  }
+  return out;
+}
+function registryUrlIsHttp() {
+  try {
+    const { protocol } = new URL(registryUrl());
+    return protocol === "https:" || protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+function cachePath() {
+  return readPathEnvVar("XANOSDK_UPDATE_CACHE") ?? join(homedir(), ".xanosdk", "update-check.json");
+}
+var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 2e3;
+var CHECK_TIMEOUT_MS = 1e4;
+function isNewer(candidate, current) {
+  const a = parseSemver(candidate);
+  const b = parseSemver(current);
+  if (!a || !b) return false;
+  return compareSemver(a, b) > 0;
+}
+function readCache() {
+  const path = cachePath();
+  if (!existsSync(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.registry === registryUrl() && typeof parsed.latest === "string" && // A cache written before the registry's answer was validated can hold
+    // anything; one that is not a version answers nothing.
+    parseSemver(parsed.latest) !== null && typeof parsed.checkedAt === "number") {
+      return { registry: parsed.registry, latest: parsed.latest, checkedAt: parsed.checkedAt };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function writeCache(cache) {
+  try {
+    const path = cachePath();
+    mkdirSync(dirname(path), { recursive: true });
+    atomicWrite(path, JSON.stringify(cache, null, 2) + "\n");
+  } catch {
+  }
+}
+async function fetchLatest(timeoutMs = FETCH_TIMEOUT_MS) {
+  const got = await fetchLatestOrWhy(timeoutMs);
+  return "latest" in got ? got.latest : null;
+}
+async function fetchLatestOrWhy(timeoutMs) {
+  if (!registryUrlIsHttp()) return {};
+  const authorization = npmAuthHeader(registryUrl());
+  let res;
+  try {
+    res = await fetch(registryUrl(), {
+      headers: { accept: "application/json", ...authorization === void 0 ? {} : { authorization } },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch {
+    return {};
+  }
+  if (res.status === 401 || res.status === 403) {
+    return { answered: `HTTP ${res.status}`, refused: authorization === void 0 ? "no-credential" : "credential" };
+  }
+  let text = "";
+  try {
+    text = await res.text();
+  } catch {
+  }
+  const said = serverMessage(text);
+  if (!res.ok) return { answered: `HTTP ${res.status}${said === void 0 ? "" : ` \u2014 ${said}`}` };
+  let version;
+  try {
+    version = JSON.parse(text).version;
+  } catch {
+  }
+  if (typeof version === "string" && parseSemver(version) !== null) return { latest: version };
+  if (typeof version === "string") {
+    const shown = version.length > 40 ? `${version.slice(0, 40)}\u2026` : version;
+    return { answered: `a version field that is not a version (${JSON.stringify(shown)})` };
+  }
+  return { answered: `a body that holds no version${said === void 0 ? "" : ` \u2014 ${said}`}` };
+}
+var noticeSuppressed = false;
+function suppressUpdateNotice() {
+  noticeSuppressed = true;
+}
+function disabled() {
+  return Boolean(
+    noticeSuppressed || envFlagSet("XANOSDK_NO_UPDATE_CHECK") || envFlagSet("NO_UPDATE_NOTIFIER") || process.env.CI
+  );
+}
+async function resolveUpdateNotice(opts) {
+  if (!opts?.force && disabled()) return null;
+  const current = opts?.current ?? readVersion();
+  if (current === "unknown") return null;
+  const cache = readCache();
+  let latest = cache?.latest;
+  const now = Date.now();
+  if (!cache || now - cache.checkedAt > CHECK_INTERVAL_MS) {
+    const fetched = await fetchLatest();
+    if (fetched) {
+      latest = fetched;
+      writeCache({ registry: registryUrl(), latest: fetched, checkedAt: now });
+    }
+  }
+  return latest && isNewer(latest, current) ? { current, latest } : null;
+}
+async function checkForUpgrade(opts) {
+  const current = opts?.current ?? readVersion();
+  if (current === "unknown") return { status: "unknown", reason: "local-version" };
+  if (!registryUrlIsHttp()) return { status: "unknown", reason: "registry-url" };
+  const got = await fetchLatestOrWhy(CHECK_TIMEOUT_MS);
+  if (!("latest" in got)) {
+    return {
+      status: "unknown",
+      reason: "registry",
+      ...got.answered === void 0 ? {} : { answered: got.answered },
+      ..."refused" in got && got.refused !== void 0 ? { refused: got.refused } : {}
+    };
+  }
+  const latest = got.latest;
+  writeCache({ registry: registryUrl(), latest, checkedAt: Date.now() });
+  const status = isNewer(latest, current) ? "available" : isNewer(current, latest) ? "ahead" : "current";
+  return { status, current, latest };
+}
+function detectInstallMode() {
+  const override = readEnvVar("XANOSDK_INSTALL_MODE")?.trim();
+  if (override === "global" || override === "local") return override;
+  try {
+    const requireFromCwd = createRequire(join(process.cwd(), "package.json"));
+    return packageRunnerOf(requireFromCwd.resolve("@xano/sdk/package.json")) === void 0 ? "local" : "global";
+  } catch {
+    return "global";
+  }
+}
+function packageRunnerOf(path) {
+  for (const seg of path.split(/[\\/]/)) {
+    if (seg === "_npx") return "npx";
+    if (seg === "dlx") return "pnpm dlx";
+    if (/^dlx-\d+$/.test(seg)) return "yarn dlx";
+    if (seg.startsWith("bunx-")) return "bunx";
+  }
+  return void 0;
+}
+function isPackageRunnerPath(path) {
+  return packageRunnerOf(path) !== void 0;
+}
+function runFromPackageRunner() {
+  return packageRunnerOf(fileURLToPath(import.meta.url));
+}
+function upgradeCommand(mode) {
+  return mode === "global" ? "npm i -g @xano/sdk@latest" : "xanosdk upgrade";
+}
+function nudgeBaseline() {
+  const running = readVersion();
+  if (detectInstallMode() !== "local") return { current: running };
+  const project = projectSdkVersion(process.cwd());
+  return project === void 0 || project === running ? { current: running } : { current: project, cli: running };
+}
+function nudgeFor(latest) {
+  const { current, cli } = nudgeBaseline();
+  if (current === "unknown") return null;
+  if (isNewer(latest, current)) {
+    return { message: `A new @xano/sdk is available: ${style.dim(current)} \u2192 ${style.green(latest)}`, remedy: "update: xanosdk upgrade" };
+  }
+  if (cli !== void 0 && isNewer(latest, cli)) {
+    return {
+      message: `This project's @xano/sdk ${current} is current, but the CLI you ran is ${style.dim(cli)} (latest ${style.green(latest)}) \u2014 your global CLI is older`,
+      remedy: "update: npm i -g @xano/sdk@latest"
+    };
+  }
+  return null;
+}
+function printUpdateNotice(notice) {
+  blank();
+  warn(`A new @xano/sdk is available: ${style.dim(notice.current)} \u2192 ${style.green(notice.latest)}`, "update.available", [
+    `update: xanosdk upgrade`
+  ]);
+}
+function routeUpdateNoticeToDocument() {
+  try {
+    if (disabled() || process.stderr.isTTY !== true) return;
+    suppressUpdateNotice();
+    const latest = readCache()?.latest;
+    const nudge = latest === void 0 ? null : nudgeFor(latest);
+    if (nudge !== null) noteRunWarning("update.available", `${stripAnsi(nudge.message)}
+${nudge.remedy}`);
+  } catch {
+  }
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function runExitedClean(code = process.exitCode) {
+  return code === void 0 || code === 0;
+}
+async function maybeNotifyUpdate() {
+  try {
+    if (disabled() || process.stderr.isTTY !== true || !runExitedClean()) return;
+    const { current, cli } = nudgeBaseline();
+    const notice = await resolveUpdateNotice({ current: cli !== void 0 && isNewer(current, cli) ? cli : current });
+    const nudge = notice === null ? null : nudgeFor(notice.latest);
+    if (nudge !== null) {
+      blank();
+      warn(nudge.message, "update.available", [nudge.remedy]);
+    }
+  } catch {
+  }
+}
+
+export {
+  registryUrl,
+  npmRegistry,
+  npmAuthHeader,
+  registryUrlIsHttp,
+  isNewer,
+  suppressUpdateNotice,
+  resolveUpdateNotice,
+  checkForUpgrade,
+  detectInstallMode,
+  packageRunnerOf,
+  isPackageRunnerPath,
+  runFromPackageRunner,
+  upgradeCommand,
+  nudgeBaseline,
+  printUpdateNotice,
+  routeUpdateNoticeToDocument,
+  runExitedClean,
+  maybeNotifyUpdate
+};
+//# sourceMappingURL=chunk-LIEOKXKD.js.map

package/dist/chunk-LLNZGEFK.js

@@ -0,0 +1,51 @@
+// src/util/atomic-write.ts
+import { accessSync, constants, lstatSync, readlinkSync, statSync, writeFileSync, renameSync, rmSync } from "fs";
+import { dirname, resolve } from "path";
+function atomicWrite(path, contents, opts) {
+  const target = linkTarget(path);
+  const mode = opts?.mode ?? existingMode(target);
+  const tmp = `${target}.tmp-${process.pid}`;
+  try {
+    writeFileSync(tmp, contents, mode !== void 0 ? { encoding: "utf8", mode } : "utf8");
+    renameSync(tmp, target);
+  } catch (err) {
+    rmSync(tmp, { force: true });
+    throw err;
+  }
+}
+function linkTarget(path) {
+  let current = path;
+  for (let hops = 0; hops < 40; hops++) {
+    let isLink;
+    try {
+      isLink = lstatSync(current).isSymbolicLink();
+    } catch {
+      return current;
+    }
+    if (!isLink) return current;
+    current = resolve(dirname(current), readlinkSync(current));
+  }
+  return current;
+}
+function existingMode(path) {
+  try {
+    return statSync(path).mode & 4095;
+  } catch {
+    return void 0;
+  }
+}
+function assertWritable(path) {
+  try {
+    accessSync(path, constants.W_OK);
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+}
+
+export {
+  atomicWrite,
+  linkTarget,
+  assertWritable
+};
+//# sourceMappingURL=chunk-LLNZGEFK.js.map

package/dist/chunk-LPECSJ2J.js

@@ -0,0 +1,55 @@
+import {
+  ensureGitignored
+} from "./chunk-XW6KISBB.js";
+import {
+  atomicWrite
+} from "./chunk-LLNZGEFK.js";
+
+// src/deploy/deployed-state.ts
+import { mkdirSync, readFileSync, rmSync } from "fs";
+import { dirname, join, resolve } from "path";
+var DEPLOYED_KINDS = ["ephemeral", "local-engine"];
+function isRealDeployment(kind) {
+  return kind === "workspace" || kind === "tenant";
+}
+function deployedStatePath(dir) {
+  return join(resolve(dir), ".xano", "deployed.json");
+}
+function readDeployed(dir) {
+  let text;
+  try {
+    text = readFileSync(deployedStatePath(dir), "utf8");
+  } catch {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+  const kind = parsed.kind;
+  if (typeof kind !== "string" || !DEPLOYED_KINDS.includes(kind)) return void 0;
+  const at = parsed.deployedAt;
+  return { version: 1, kind, deployedAt: typeof at === "string" ? at : "" };
+}
+function recordDeployed(dir, kind, now = /* @__PURE__ */ new Date()) {
+  if (isRealDeployment(kind)) return false;
+  if (!DEPLOYED_KINDS.includes(kind)) {
+    throw new Error(`Internal: "${kind}" is not a backend a deploy records as the tracked default.`);
+  }
+  const path = deployedStatePath(dir);
+  mkdirSync(dirname(path), { recursive: true });
+  const pointer = { version: 1, kind, deployedAt: now.toISOString() };
+  atomicWrite(path, JSON.stringify(pointer, null, 2) + "\n");
+  ensureGitignored(path);
+  return true;
+}
+
+export {
+  isRealDeployment,
+  readDeployed,
+  recordDeployed
+};
+//# sourceMappingURL=chunk-LPECSJ2J.js.map