@xano/sdk 1.0.0

package/dist/chunk-YU4HSQW7.js

@@ -0,0 +1,229 @@
+import {
+  conditionalEntryHint,
+  describeEntry,
+  describeStatementEntry,
+  isStatementEntry,
+  isVarName
+} from "./chunk-CIMQZRRE.js";
+
+// src/values/mock.ts
+function isWrapped(e) {
+  return typeof e === "object" && e !== null && typeof e.tag !== "string";
+}
+function encodeMockMap(mock) {
+  const out = {};
+  if (typeof mock !== "object" || mock === null || Array.isArray(mock)) {
+    throw new Error(
+      `\`mock\` must be a { "<test name>": value } record, keyed by the name of each test it applies to \u2014 got ${describeEntry(mock)}.`
+    );
+  }
+  for (const [testName, entry] of Object.entries(mock)) {
+    const wrapped = isWrapped(entry);
+    const value = wrapped ? entry.value : entry;
+    if (typeof value?.tag !== "string") {
+      throw new Error(
+        `mock for test "${testName}": expected a tagged value (\`c.*\`/\`ref\`/\u2026) or \`{ value, enabled }\`, got ${describeEntry(entry)}. A mock stores \`{value,tag,filters}\` copied off this argument, so a plain JS value encodes an empty mock that silently returns nothing when the test runs.`
+      );
+    }
+    out[testName] = {
+      value: value.value,
+      tag: value.tag,
+      filters: value.filters,
+      enabled: wrapped ? entry.enabled ?? true : true
+    };
+  }
+  return out;
+}
+
+// src/statements/statement.ts
+function readableStatementName(storedName) {
+  return storedName.replace(/^mvp:/, "");
+}
+function assertAnnotations(stmt) {
+  if (stmt.as != null && typeof stmt.as !== "string") {
+    throw new Error(
+      `Statement "${statementLabel(stmt.name)}": argument \`as\` must be the variable name as a string \u2014 got ${describeEntry(stmt.as)}.`
+    );
+  }
+  if (typeof stmt.as === "string" && stmt.as !== "" && !isVarName(stmt.as)) {
+    throw new Error(
+      `Statement "${statementLabel(stmt.name)}": argument \`as\` is ${JSON.stringify(stmt.as)}, which is not a variable name \u2014 use a letter or underscore, then letters, digits and underscores (e.g. "order_total")${stmt.as.startsWith("$") ? `; \`as\` takes the bare name, without the "$"` : ""}.`
+    );
+  }
+  if (stmt.disabled != null && typeof stmt.disabled !== "boolean") {
+    throw new Error(
+      `Statement "${statementLabel(stmt.name)}": option \`disabled\` must be true or false \u2014 got ${describeEntry(stmt.disabled)}.`
+    );
+  }
+  if (stmt.description != null && typeof stmt.description !== "string") {
+    throw new Error(
+      `Statement "${statementLabel(stmt.name)}": option \`description\` must be a string \u2014 got ${describeEntry(stmt.description)}.`
+    );
+  }
+}
+var ANNOTATION_KEYS = /* @__PURE__ */ Object.keys({ disabled: 1, description: 1, mock: 1 });
+var OPTION_KEYS = /* @__PURE__ */ Object.keys({ disabled: 1, description: 1, mock: 1, asFilters: 1 });
+function annotate(stmt, a) {
+  if (a?.disabled !== void 0 && a.disabled !== null) stmt.disabled = a.disabled;
+  if (a?.description !== void 0 && a.description !== null) stmt.description = a.description;
+  assertAnnotations(stmt);
+  if (a?.mock !== void 0 && a.mock !== null) {
+    try {
+      stmt.mocks = encodeMockMap(a.mock);
+    } catch (err) {
+      throw new Error(`Statement "${statementLabel(stmt.name)}": ${err.message}`);
+    }
+  }
+  if (a?.asFilters !== void 0 && a.asFilters !== null) assertFilterList(stmt, a.asFilters);
+  if (a?.asFilters !== void 0 && a.asFilters !== null && a.asFilters.length > 0) {
+    assertBindsAs(stmt, "asFilters");
+    stmt.output = { ...stmt.output ?? {}, filters: a.asFilters };
+  }
+  return stmt;
+}
+function assertBindsAs(stmt, option) {
+  if (stmt.as) return;
+  throw new Error(
+    `Statement "${statementLabel(stmt.name)}" binds no \`as\` variable, so \`${option}\` has nothing to filter. Bind the result with \`as\` first, or drop the option.`
+  );
+}
+function assertFilterList(stmt, list) {
+  const where = `Statement "${statementLabel(stmt.name)}": argument "asFilters`;
+  if (!Array.isArray(list)) {
+    throw new Error(`${where}" must be an array of filters (\`fl.*\`) \u2014 got ${describeEntry(list)}.`);
+  }
+  list.forEach((f, i) => {
+    if (typeof f !== "object" || f === null || typeof f.name !== "string") {
+      throw new Error(`${where}[${i}]" must be a filter (\`fl.*\`) \u2014 got ${describeEntry(f)}.`);
+    }
+  });
+}
+function statements(...items) {
+  return items;
+}
+var RAW_ENVELOPE = /* @__PURE__ */ Symbol.for("xanosdk.statement.rawEnvelope");
+var registry = /* @__PURE__ */ new Map();
+var factoryPaths = /* @__PURE__ */ new Map();
+var namesByFactory = /* @__PURE__ */ new Map();
+function registerStatement(name, factory, path) {
+  registry.set(name, factory);
+  namesByFactory.set(factory, name);
+  if (path !== void 0 && !factoryPaths.has(name)) factoryPaths.set(name, path);
+}
+function registerFactoryPaths(tree, prefix, seen = /* @__PURE__ */ new Set()) {
+  if (tree === null || typeof tree !== "object" && typeof tree !== "function" || seen.has(tree)) return;
+  seen.add(tree);
+  const name = namesByFactory.get(tree);
+  if (name !== void 0 && !factoryPaths.has(name)) factoryPaths.set(name, prefix);
+  for (const [key, child] of Object.entries(tree)) {
+    registerFactoryPaths(child, `${prefix}.${key}`, seen);
+  }
+}
+function statementLabel(storedName) {
+  return factoryPaths.get(storedName) ?? readableStatementName(storedName);
+}
+function assertStatementList(owner, where, list) {
+  if (!Array.isArray(list)) {
+    throw new Error(`${owner}: \`${where}\` must be an array of statements (\`s.*\`) \u2014 got ${describeEntry(list)}.`);
+  }
+  list.forEach((entry, i) => {
+    if (isStatementEntry(entry)) return;
+    throw new Error(
+      `${owner}: \`${where}[${i}]\` must be a statement (\`s.*\`) \u2014 got ${describeStatementEntry(entry)}.${conditionalEntryHint(entry)}`
+    );
+  });
+}
+function encodeStack(kind, name, stack) {
+  if (stack === void 0 || stack === null) return [];
+  assertStatementList(`${kind} "${name ?? "?"}"`, "stack", stack);
+  return stack.map(encodeStatement);
+}
+function isRegisteredStatement(name) {
+  return registry.has(name);
+}
+function getStatementFactory(name) {
+  const factory = registry.get(name);
+  if (!factory) {
+    throw new Error(
+      `Unknown statement "${readableStatementName(name)}": no factory is registered for it in this copy of @xano/sdk.`
+    );
+  }
+  return factory;
+}
+function fullInputEntry(raw) {
+  const e = raw ?? {};
+  return {
+    name: e.name,
+    value: e.value,
+    tag: e.tag,
+    filters: e.filters ?? [],
+    ignore: e.ignore ?? false,
+    expand: e.expand ?? false,
+    children: e.children ?? []
+  };
+}
+var marks = /* @__PURE__ */ new WeakMap();
+function markStatement(stmt, mark) {
+  marks.set(stmt, mark);
+}
+function statementMark(stmt) {
+  return marks.get(stmt);
+}
+function encodeStatement(stmt) {
+  const encoded = encodeStatementBytes(stmt);
+  const mark = marks.get(stmt);
+  if (mark) marks.set(encoded, mark);
+  return encoded;
+}
+function encodeStatementBytes(stmt) {
+  const rawEnvelope = stmt[RAW_ENVELOPE];
+  if (rawEnvelope !== void 0) return rawEnvelope;
+  if (!isRegisteredStatement(stmt.name)) {
+    throw new Error(
+      `Cannot encode unregistered statement "${readableStatementName(stmt.name)}": it is not registered in this copy of @xano/sdk. A def is encoded by the SDK copy that built it \u2014 when two copies are loaded (a global \`xanosdk\` and a project install), run the project's own (\`npx xanosdk\`), or encode through the def's own workspace.`
+    );
+  }
+  assertAnnotations(stmt);
+  const output = {
+    items: [],
+    filters: [],
+    customize: false,
+    ...stmt.output ?? {}
+  };
+  const sr = stmt.settings_registry;
+  const settings_registry = sr == null || Array.isArray(sr) && sr.length === 0 ? null : sr;
+  return {
+    as: stmt.as ?? "",
+    name: stmt.name,
+    _xsid: "",
+    addon: stmt.addon ?? [],
+    input: (stmt.input ?? []).map(fullInputEntry),
+    mocks: stmt.mocks ?? {},
+    output,
+    context: stmt.context,
+    runtime: stmt.runtime ?? null,
+    disabled: stmt.disabled ?? false,
+    description: stmt.description ?? "",
+    settings_registry
+  };
+}
+
+export {
+  encodeMockMap,
+  readableStatementName,
+  ANNOTATION_KEYS,
+  OPTION_KEYS,
+  annotate,
+  statements,
+  RAW_ENVELOPE,
+  registerStatement,
+  registerFactoryPaths,
+  statementLabel,
+  encodeStack,
+  isRegisteredStatement,
+  getStatementFactory,
+  markStatement,
+  statementMark,
+  encodeStatement
+};
+//# sourceMappingURL=chunk-YU4HSQW7.js.map

package/dist/chunk-ZDPP6RKB.js

@@ -0,0 +1,27 @@
+import {
+  resolveRef
+} from "./chunk-NZOWWHU5.js";
+
+// src/refs/auth.ts
+function resolveAuthRef(hostLabel, host, auth) {
+  if (auth === void 0 || auth === false || auth === null) return false;
+  if (auth === true) {
+    throw new Error(
+      `${hostLabel} "${host}": \`auth: true\` is no longer supported. Pass the auth table (e.g. \`auth: user\` for a \`table({ auth: true })\`) or its numeric id.`
+    );
+  }
+  if (typeof auth === "number") {
+    if (!Number.isInteger(auth) || auth <= 0) {
+      throw new Error(
+        `${hostLabel} "${host}": numeric \`auth\` must be a positive integer \`dbo.id\` (got ${auth}). Use \`false\` for no auth, or pass the auth table def/name.`
+      );
+    }
+    return auth;
+  }
+  return resolveRef("dbo", auth);
+}
+
+export {
+  resolveAuthRef
+};
+//# sourceMappingURL=chunk-ZDPP6RKB.js.map

package/dist/chunk-ZFDZKNGG.js

@@ -0,0 +1,194 @@
+// src/emit/npm.ts
+import { spawn, spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+function findNpmCli(nodeExecPath = process.execPath) {
+  const bin = dirname(nodeExecPath);
+  const tail = ["node_modules", "npm", "bin", "npm-cli.js"];
+  const candidates = [
+    join(bin, ...tail),
+    join(bin, "..", "lib", ...tail),
+    join(bin, "..", "libexec", "lib", ...tail)
+  ];
+  return candidates.find((c) => existsSync(c));
+}
+function npmCommand(platform, args, nodeExecPath = process.execPath, resolveNpmCli = findNpmCli) {
+  if (platform !== "win32") return { file: "npm", args, shell: false };
+  const cli = resolveNpmCli(nodeExecPath);
+  if (cli !== void 0) return { file: nodeExecPath, args: [cli, ...args], shell: false };
+  return { file: "npm.cmd", args: args.map(quoteForCmd), shell: true };
+}
+function quoteForCmd(arg) {
+  if (arg !== "" && !/[\s"&|<>^()%!]/.test(arg)) return arg;
+  const escaped = arg.replace(/(\\*)"/g, '$1$1""').replace(/(\\*)$/, "$1$1");
+  return `"${escaped}"`;
+}
+function runNpm(args, cwd, opts) {
+  const stdout = opts?.stdout === "stderr" ? 2 : "inherit";
+  const npm = managerCommand(opts?.manager, args);
+  const res = spawnSync(npm.file, [...npm.args], {
+    cwd,
+    stdio: ["inherit", stdout, "inherit"],
+    shell: npm.shell,
+    // Bounded on the same budget as the captured runs. This one STREAMS to the
+    // user's terminal, so a stall is at least visible — but visible is not the
+    // same as escapable in CI, where nobody is there to press Ctrl-C.
+    timeout: opts?.timeoutMs ?? NPM_RUN_TIMEOUT_MS,
+    killSignal: "SIGKILL"
+  });
+  return res.status ?? 1;
+}
+function runNpmStreaming(args, cwd, opts) {
+  const stdout = opts?.stdout === "stderr" ? 2 : "inherit";
+  const npm = managerCommand(opts?.manager, args);
+  return new Promise((resolve) => {
+    const child = spawn(npm.file, [...npm.args], { cwd, stdio: ["inherit", stdout, "inherit"], shell: npm.shell });
+    const timer = setTimeout(() => child.kill("SIGKILL"), opts?.timeoutMs ?? NPM_RUN_TIMEOUT_MS);
+    const settle = (status) => {
+      clearTimeout(timer);
+      resolve(status);
+    };
+    child.once("error", () => settle(1));
+    child.once("close", (code) => settle(code ?? 1));
+  });
+}
+function managerCommand(manager, args) {
+  if (manager === void 0 || manager === "npm") return npmCommand(process.platform, args);
+  if (process.platform !== "win32") return { file: manager, args, shell: false };
+  return { file: `${manager}.cmd`, args: args.map(quoteForCmd), shell: true };
+}
+function runNpmQuiet(args, cwd, opts = {}) {
+  return captureCommand(managerCommand(opts.manager, args), cwd, opts);
+}
+var NPM_RUN_TIMEOUT_MS = 10 * 6e4;
+function isPeerConflict(stderr) {
+  return /ERESOLVE|peer dep|peerinvalid/i.test(stderr);
+}
+function captureCommand(npm, cwd, opts = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(npm.file, [...npm.args], {
+      cwd,
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: npm.shell
+    });
+    let output = "";
+    const budget = opts.timeoutMs ?? NPM_RUN_TIMEOUT_MS;
+    let timedOut = false;
+    let escalation;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      escalation = setTimeout(() => {
+        child.kill("SIGKILL");
+        detach();
+        done(stalled());
+      }, 5e3);
+      escalation.unref();
+    }, budget);
+    timer.unref();
+    const done = (result) => {
+      clearTimeout(timer);
+      if (escalation !== void 0) clearTimeout(escalation);
+      resolve(result);
+    };
+    const detach = () => {
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      child.unref();
+    };
+    const stalled = () => {
+      const reason = `npm timed out after ${Math.round(budget / 1e3)}s and was killed. A registry that accepts the connection and then says nothing looks exactly like this.`;
+      return { status: 1, output: output !== "" ? `${output}
+${reason}` : reason };
+    };
+    const collect = (stream) => {
+      stream?.setEncoding("utf8");
+      stream?.on("data", (chunk) => {
+        output += chunk;
+      });
+    };
+    collect(child.stdout);
+    collect(child.stderr);
+    child.on("error", (error) => {
+      done({ status: 1, output: output !== "" ? output : describeSpawnFailure(npm.file, error) });
+    });
+    child.on("close", (code) => {
+      const status = code ?? 1;
+      if (timedOut) {
+        const killed = stalled();
+        done({ ...killed, status: status === 0 ? 1 : status });
+        return;
+      }
+      done({
+        // A failure with nothing to show still has to say something, and the
+        // something must be about THIS command: npm silenced by a `loglevel`
+        // in .npmrc, or killed by a signal, prints nothing at all.
+        output: output !== "" ? output : `npm exited ${status} without printing anything.`,
+        status
+      });
+    });
+  });
+}
+function npmViewVersion(pkg, cwd) {
+  const npm = npmCommand(process.platform, ["view", pkg, "version"]);
+  const res = spawnSync(npm.file, [...npm.args], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+    shell: npm.shell,
+    // Bounded, like every other outbound call in this CLI. A registry that
+    // accepts the connection and then says nothing — a stalled proxy, a
+    // captive portal — would otherwise hang the command with no way out but
+    // Ctrl-C, and this one runs BEFORE the user has been asked anything.
+    timeout: NPM_VIEW_TIMEOUT_MS,
+    killSignal: "SIGKILL"
+  });
+  const stderr = (res.stderr ?? "").trim();
+  const version = (res.stdout ?? "").trim();
+  if ((res.status ?? 1) !== 0 || version === "") {
+    if (stderr !== "") return { ok: false, stderr };
+    return {
+      ok: false,
+      stderr: res.error !== void 0 ? describeSpawnFailure(npm.file, res.error) : "npm exited without reporting a version."
+    };
+  }
+  return { ok: true, version };
+}
+var NPM_VIEW_TIMEOUT_MS = 3e4;
+function describeSpawnFailure(file, error) {
+  return `Could not run ${file}: ${error.message}`;
+}
+function condenseNpmError(stderr) {
+  const kept = [];
+  for (const line of stderr.split("\n")) {
+    const body = line.replace(/^npm (?:error|ERR!)\s?/, "");
+    if (body.trim() === "") continue;
+    if (/^\s*at\s/.test(body)) continue;
+    if (/^\s{2,}\S+:\s/.test(body)) continue;
+    if (/^\s*[{}],?\s*$/.test(body)) continue;
+    if (/^A complete log of this run can be found in: .*\*\*\*/.test(body.trim())) {
+      kept.push(`${line.slice(0, line.indexOf(body))}A complete log of this run is in npm's debug log directory (\`_logs\` under \`npm config get cache\`); npm masked part of the path it printed.`);
+      continue;
+    }
+    kept.push(/\{\s*$/.test(body) ? line.replace(/\s*\{\s*$/, "") : line);
+  }
+  return kept.join("\n").trim();
+}
+function sameNpmFailure(a, b) {
+  return a === b || npmFailureKey(a) === npmFailureKey(b);
+}
+function npmFailureKey(reason) {
+  return reason.replace(/https?:\/\/\S+/g, "<url>").replace(/'(?:@[^/'\s]+\/)?[^@'\s]+@[^'\s]*'/g, "'<package>'").replace(/(?:[A-Za-z]:)?[\\/]\S*\.log\b/g, "<log>").replace(/\d{4}-\d{2}-\d{2}T[\d_:.-]+Z?/g, "<time>");
+}
+
+export {
+  runNpm,
+  runNpmStreaming,
+  runNpmQuiet,
+  NPM_RUN_TIMEOUT_MS,
+  isPeerConflict,
+  npmViewVersion,
+  condenseNpmError,
+  sameNpmFailure
+};
+//# sourceMappingURL=chunk-ZFDZKNGG.js.map

package/dist/chunk-ZIY7RNUT.js

@@ -0,0 +1,49 @@
+import {
+  retryCommand,
+  withheldNote
+} from "./chunk-T5KELPAR.js";
+import {
+  checkOneName,
+  setRunNameContext
+} from "./chunk-PTHVMXZI.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/emit/name-argument.ts
+var SLOT = "XANOSDKNAMESLOT";
+function assertOneName(value, what, opts = {}) {
+  const { args } = opts;
+  checkOneName(value, what, {
+    ...opts.helpFor === void 0 ? {} : { helpFor: opts.helpFor },
+    ...opts.echo === void 0 ? {} : { echo: opts.echo },
+    ...runContextOf(args)
+  });
+}
+function runContextOf(args) {
+  return {
+    ...args?.command === void 0 ? {} : { verb: `xanosdk ${args.command}${args.subcommand === void 0 ? "" : ` ${args.subcommand}`}` },
+    loop: (raw, prefix, names) => loopOver(raw, prefix, names, args)
+  };
+}
+function noteRunArgs(args) {
+  setRunNameContext(args === void 0 ? void 0 : runContextOf(args));
+}
+function loopOver(value, prefix, names, args) {
+  if (args?.argv === void 0) return void 0;
+  const argv = args.argv;
+  const at = argv.findIndex((t) => t === value || t.startsWith("--") && t.endsWith(`=${value}`));
+  if (at === -1) return void 0;
+  const token = argv[at];
+  const swapped = argv.map((t, i) => i === at ? `${token.slice(0, token.length - value.length)}${prefix}${SLOT}` : t);
+  const { command, withheld } = retryCommand({ ...args, argv: swapped });
+  const note = withheldNote(withheld).trim();
+  return `for n in ${names.map(shellQuote).join(" ")}; do ${command.replace(SLOT, '"$n"')}; done${note === "" ? "" : `
+  ${note}`}`;
+}
+
+export {
+  assertOneName,
+  noteRunArgs
+};
+//# sourceMappingURL=chunk-ZIY7RNUT.js.map

package/dist/chunk-ZYJP6BOO.js

@@ -0,0 +1,30 @@
+// src/deploy/keep-data.ts
+function readFilledMarker(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  const { url, at } = value;
+  if (typeof url !== "string" || url === "" || typeof at !== "number") return void 0;
+  return { url, at };
+}
+function withValidFilled(record) {
+  const { filled, ...rest } = record;
+  const marker = readFilledMarker(filled);
+  return marker === void 0 ? rest : { ...rest, filled: marker };
+}
+function filledAt(url) {
+  return { url, at: Date.now() };
+}
+function selectDeployArm(input) {
+  if (!input.keepData) return { arm: "replace" };
+  if (input.reset) return { arm: "replace", skipped: "reset" };
+  if (input.created) return { arm: "replace", skipped: input.hadRecord ? "recreated" : "new" };
+  if (input.priorFilled === void 0) return { arm: "replace", skipped: "never-filled" };
+  if (input.priorFilled.url !== input.url) return { arm: "replace", skipped: "recreated" };
+  return { arm: "merge" };
+}
+
+export {
+  withValidFilled,
+  filledAt,
+  selectDeployArm
+};
+//# sourceMappingURL=chunk-ZYJP6BOO.js.map