@xano/sdk 1.0.0

package/dist/chunk-3KZCLN4Z.js

@@ -0,0 +1,241 @@
+import {
+  HEADER_BREAK,
+  HEADER_NAME,
+  generated,
+  literalText
+} from "./chunk-YGZHHAAB.js";
+import {
+  fl
+} from "./chunk-6HO3NCSJ.js";
+import {
+  c,
+  resp,
+  withFilters
+} from "./chunk-OXA6PSZT.js";
+import {
+  describeEntry,
+  isTaggedArg
+} from "./chunk-CIMQZRRE.js";
+
+// src/statements/respond.ts
+var REDIRECT_STATUSES = [301, 302, 303, 307];
+function assertHeaderValue(helper, field, v) {
+  if (typeof v === "string" || isTaggedArg(v)) return;
+  throw new Error(`${helper}: ${field} must be a string or a tagged value (\`ref()\`, \`inp()\`, \u2026) \u2014 got ${describeEntry(v)}.`);
+}
+function assertNoHeaderBreak(helper, field, v) {
+  const literal = literalText(v);
+  if (literal === void 0 || !HEADER_BREAK.test(literal)) return;
+  throw new Error(
+    `${helper}: ${field} ${JSON.stringify(literal)} contains a newline or NUL, which would splice a second header into the response. Strip it.`
+  );
+}
+var setHeader = (value, duplicates) => generated.util.set_header(
+  duplicates === void 0 ? { value } : { value, duplicates }
+);
+var IGNORED_STATUS = {
+  102: "an interim status a final response cannot carry \u2014 drop it",
+  103: "an interim status a final response cannot carry \u2014 drop it",
+  308: "use 301 (Moved Permanently), which is honored; 307 is the temporary equivalent",
+  425: "use 429 (Too Many Requests) or 400, both honored",
+  451: "use 403 (Forbidden), which is honored"
+};
+var UNPARSEABLE_STATUS = {
+  100: "an informational status is not a final response; an HTTP client errors on it",
+  101: "a protocol switch is not something a stack can answer; an HTTP client errors on it",
+  407: "proxy authentication needs headers this surface cannot supply; an HTTP client errors on it"
+};
+function assertStatus(code) {
+  if (!Number.isInteger(code) || code < 100 || code > 599) {
+    throw new Error(
+      `respond.status(${code}): not an HTTP status code. Pass an integer between 100 and 599.`
+    );
+  }
+  const unparseable = Object.hasOwn(UNPARSEABLE_STATUS, code) ? UNPARSEABLE_STATUS[code] : void 0;
+  if (unparseable !== void 0) {
+    throw new Error(`respond.status(${code}) is refused: ${unparseable}.`);
+  }
+  const ignored = Object.hasOwn(IGNORED_STATUS, code) ? IGNORED_STATUS[code] : void 0;
+  if (ignored !== void 0) {
+    throw new Error(
+      `respond.status(${code}) is refused: the platform writes the header and does not act on it, so the response is 200 \u2014 measured live, with nothing reported anywhere. Instead, ${ignored}.`
+    );
+  }
+}
+var respond = {
+  /**
+   * Answer with `code` instead of 200.
+   *
+   * ```ts
+   * stack: [s.db.add({ table: notes, row, as: "note" }), respond.status(201)],
+   * ```
+   *
+   * Position does not matter — the header is written while the stack runs and
+   * the body is serialized afterwards, so this works before or after the
+   * statement that builds the response.
+   *
+   * ⚠ A `204` answers with an EMPTY body whatever the def's `response` says:
+   * that is HTTP, not this helper. Do not pair it with a response a client
+   * needs to read.
+   *
+   * See the module note for the codes this refuses and why.
+   */
+  status: (code) => {
+    assertStatus(code);
+    return setHeader(c.text(`HTTP/1.1 ${code}`));
+  },
+  /**
+   * Redirect to `url` — the status line plus the `Location` header, as a
+   * fixed-arity tuple to spread:
+   *
+   * ```ts
+   * stack: [s.set_var("target", ref("row.url")), ...respond.redirect(ref("target"))],
+   * ```
+   *
+   * `url` takes a literal or any `Value` (a `ref`, an `inp`, a filtered chain);
+   * a computed one is concatenated onto the header at request time.
+   *
+   * Defaults to **302** (temporary, and a client may switch the method to GET).
+   * `301` is the permanent form, `307` the temporary one that PRESERVES the
+   * method, and `303` forces GET. **`308` is not offered** — the platform
+   * ignores it and answers 200, measured live.
+   *
+   * ⚠ A `Location` header alone does NOT redirect: without the status line the
+   * response is a 200 carrying a header no client acts on. That is the whole
+   * reason this emits both.
+   */
+  redirect: (url, opts = {}) => {
+    assertHeaderValue("respond.redirect", "url", url);
+    assertNoHeaderBreak("respond.redirect", "url", url);
+    opts = opts ?? {};
+    if (opts.status !== void 0 && !REDIRECT_STATUSES.includes(opts.status)) {
+      throw new Error(
+        `respond.redirect: status ${JSON.stringify(opts.status)} is not a redirect \u2014 use ${REDIRECT_STATUSES.join(", ")} (302 when omitted). 308 is not offered: the platform answers 200 for it. A non-3xx status with a Location header redirects nothing; for another status use respond.status().`
+      );
+    }
+    const location = typeof url === "string" ? c.text(`Location: ${url}`) : withFilters(c.text("Location: "), fl.concat(url));
+    return [respond.status(opts.status ?? 302), setHeader(location)];
+  },
+  /**
+   * Add a response header, `name` and `value` given separately.
+   *
+   * The underlying statement takes ONE string — `"X-Request-Id: abc"` — so a
+   * computed value has to be concatenated onto the name by hand. This does that,
+   * and keeps a literal a literal.
+   *
+   * ```ts
+   * respond.header("Cache-Control", "public, max-age=60"),
+   * respond.header("X-Request-Id", ref("id")),
+   * ```
+   */
+  header: (name, value, opts = {}) => {
+    if (typeof name !== "string") {
+      throw new Error(`respond.header: the header name must be a string \u2014 got ${describeEntry(name)}.`);
+    }
+    assertHeaderValue("respond.header", "value", value);
+    opts = opts ?? {};
+    if (opts.duplicates !== void 0 && opts.duplicates !== "replace" && opts.duplicates !== "append") {
+      throw new Error(
+        `respond.header: duplicates accepts only "replace" | "append" \u2014 got ${typeof opts.duplicates === "string" ? JSON.stringify(opts.duplicates) : describeEntry(opts.duplicates)}.`
+      );
+    }
+    if (!HEADER_NAME.test(name)) {
+      throw new Error(
+        `respond.header: ${JSON.stringify(name)} is not a header name \u2014 use the token charset (letters, digits and !#$%&'*+-.^_\`|~), with no whitespace and no colon (the colon is added for you). Pass the name and the value separately: respond.header("X-Request-Id", ref("id")).`
+      );
+    }
+    assertNoHeaderBreak("respond.header", "value", value);
+    const line = typeof value === "string" ? c.text(`${name}: ${value}`) : withFilters(c.text(`${name}: `), fl.concat(value));
+    return setHeader(line, opts.duplicates);
+  }
+};
+
+// src/values/expect.ts
+var TEST_EXPECT_TYPES = [
+  "to_be_defined",
+  "to_be_empty",
+  "to_be_false",
+  "to_be_greater_than",
+  "to_be_in_the_future",
+  "to_be_in_the_past",
+  "to_be_less_than",
+  "to_be_null",
+  "to_be_true",
+  "to_be_within",
+  "to_contain",
+  "to_end_with",
+  "to_equal",
+  "to_match",
+  "to_not_be_defined",
+  "to_not_be_null",
+  "to_not_equal",
+  "to_start_with",
+  "to_throw"
+];
+function mk(type, ...vars) {
+  return { type, vars };
+}
+var expect = {
+  /** The subject is set (not undefined). */
+  to_be_defined: (subject) => mk("to_be_defined", subject),
+  /** The subject is undefined. */
+  to_not_be_defined: (subject) => mk("to_not_be_defined", subject),
+  /** The subject is empty — `""`, `[]`, `{}`, `0`, or null. */
+  to_be_empty: (subject) => mk("to_be_empty", subject),
+  /** The subject is `null`. */
+  to_be_null: (subject) => mk("to_be_null", subject),
+  /** The subject is not `null`. */
+  to_not_be_null: (subject) => mk("to_not_be_null", subject),
+  /** The subject is boolean true. */
+  to_be_true: (subject) => mk("to_be_true", subject),
+  /** The subject is boolean false. */
+  to_be_false: (subject) => mk("to_be_false", subject),
+  /** The subject is a timestamp later than now. */
+  to_be_in_the_future: (subject) => mk("to_be_in_the_future", subject),
+  /** The subject is a timestamp earlier than now. */
+  to_be_in_the_past: (subject) => mk("to_be_in_the_past", subject),
+  /** `subject === value`. */
+  to_equal: (subject, value) => mk("to_equal", subject, value),
+  /** `subject !== value`. */
+  to_not_equal: (subject, value) => mk("to_not_equal", subject, value),
+  /** `subject > value`, both read as numbers. */
+  to_be_greater_than: (subject, value) => mk("to_be_greater_than", subject, value),
+  /** `subject < value`, both read as numbers. */
+  to_be_less_than: (subject, value) => mk("to_be_less_than", subject, value),
+  /** A list subject contains the item; a text subject contains the substring. */
+  to_contain: (subject, item) => mk("to_contain", subject, item),
+  /** The subject, as text, starts with `prefix`. */
+  to_start_with: (subject, prefix) => mk("to_start_with", subject, prefix),
+  /** The subject, as text, ends with `suffix`. */
+  to_end_with: (subject, suffix) => mk("to_end_with", subject, suffix),
+  /**
+   * The subject matches a regular expression. `pattern` is a PCRE pattern
+   * INCLUDING its delimiters — build it with `c.regex(...)` rather than by hand;
+   * a bare `"^a"` is not a runnable pattern and the engine's match silently
+   * fails rather than erroring.
+   */
+  to_match: (subject, pattern) => mk("to_match", subject, pattern),
+  /**
+   * `min < subject < max`, both bounds EXCLUSIVE and all three read as numbers.
+   * A subject equal to either bound fails.
+   */
+  to_be_within: (subject, min, max) => mk("to_be_within", subject, min, max),
+  /**
+   * The run raised an error. Pass `exception` to require that text to appear in
+   * the error message (a case-insensitive substring, not an exact match);
+   * omit it to accept ANY error.
+   *
+   * Unlike every other matcher this one takes no subject: the thing under
+   * assertion is the run's failure, and the engine stores the response slot as
+   * a fixed first var. That is what the editor writes, and it is preserved so
+   * an authored test and a pulled one are the same bytes.
+   */
+  to_throw: (exception) => mk("to_throw", resp(), exception ?? c.text(""))
+};
+
+export {
+  respond,
+  TEST_EXPECT_TYPES,
+  expect
+};
+//# sourceMappingURL=chunk-3KZCLN4Z.js.map

package/dist/chunk-3LDULPRE.js

@@ -0,0 +1,168 @@
+import {
+  UsageError
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/module-manifest.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { gunzipSync } from "zlib";
+import { dirname, join, resolve, sep } from "path";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+var MODULE_KINDS = ["workspace", "toolchain"];
+function packageNameOf(specifier) {
+  const at = specifier.lastIndexOf("@");
+  return at > 0 ? specifier.slice(0, at) : specifier;
+}
+function localPathOf(spec) {
+  if (/^file:/i.test(spec)) return spec.slice(5);
+  if (/^[a-z][a-z0-9+.-]*:/i.test(spec) || spec.startsWith("~")) return void 0;
+  if (/^\.{1,2}(\/|$)|^\//.test(spec) || /\.(tgz|tar\.gz)$/i.test(spec)) return spec;
+  return void 0;
+}
+function localPackageName(specifier, dir) {
+  const path = localPathOf(specifier);
+  if (path === void 0) return void 0;
+  const abs = resolve(dir, path);
+  try {
+    const raw = statSync(abs).isFile() ? tarballManifest(readFileSync(abs)) : readFileSync(join(abs, "package.json"), "utf8");
+    const name = raw === void 0 ? void 0 : JSON.parse(raw).name;
+    if (typeof name === "string" && name !== "") return name;
+  } catch {
+  }
+  return recordedLocalDependency(dir, abs);
+}
+function recordedLocalDependency(dir, abs) {
+  try {
+    const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    for (const block of ["dependencies", "devDependencies", "optionalDependencies"]) {
+      for (const [name, range] of Object.entries(manifest[block] ?? {})) {
+        if (typeof range === "string" && /^file:/i.test(range) && resolve(dir, range.slice(5)) === abs) return name;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function tarballManifest(tgz) {
+  const tar = gunzipSync(tgz);
+  let longName;
+  for (let at = 0; at + 512 <= tar.length; ) {
+    const header = tar.subarray(at, at + 512);
+    if (header.every((b) => b === 0)) return void 0;
+    const field = (start, length) => {
+      const raw = header.subarray(start, start + length);
+      const end = raw.indexOf(0);
+      return raw.subarray(0, end === -1 ? length : end).toString("utf8");
+    };
+    const size = parseInt(field(124, 12).trim() || "0", 8);
+    const type = field(156, 1);
+    const prefix = field(345, 155);
+    const name = longName ?? (prefix === "" ? field(0, 100) : `${prefix}/${field(0, 100)}`);
+    const body = tar.subarray(at + 512, at + 512 + size);
+    longName = type === "L" ? body.toString("utf8").replace(/\0+$/, "") : void 0;
+    if ((type === "0" || type === "") && /^[^/]+\/package\.json$/.test(name.replace(/^\.\//, ""))) return body.toString("utf8");
+    at += 512 + Math.ceil(size / 512) * 512;
+  }
+  return void 0;
+}
+function manifestPathOf(dir, pkg) {
+  try {
+    return createRequire(join(dir, "package.json")).resolve(`${pkg}/package.json`);
+  } catch {
+    const literal = join(dir, "node_modules", ...pkg.split("/"), "package.json");
+    return existsSync(literal) ? literal : null;
+  }
+}
+function installedPackageDir(dir, pkg) {
+  const path = manifestPathOf(dir, pkg);
+  return path === null ? null : dirname(path);
+}
+function readInstalledManifestState(dir, pkg) {
+  const path = manifestPathOf(dir, pkg);
+  if (path === null) return { kind: "absent" };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { kind: "unreadable", why: `${path} is not a JSON object` };
+    }
+    return { kind: "ok", manifest: parsed };
+  } catch (error) {
+    return {
+      kind: "unreadable",
+      why: `${path} could not be parsed (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+}
+function readInstalledManifest(dir, pkg) {
+  const state = readInstalledManifestState(dir, pkg);
+  return state.kind === "ok" ? state.manifest : null;
+}
+function moduleKind(pkg, manifest) {
+  const field = manifest["xanosdk"];
+  if (typeof field !== "object" || field === null) return "workspace";
+  const kind = field["kind"];
+  if (kind === void 0) return "workspace";
+  if (typeof kind === "string" && MODULE_KINDS.includes(kind)) {
+    return kind;
+  }
+  throw new UsageError(
+    `${pkg} declares "xanosdk": { "kind": ${JSON.stringify(kind)} }, which is not a module kind. Valid kinds are ${MODULE_KINDS.map((k) => JSON.stringify(k)).join(" and ")}. Omit the field entirely for a workspace module.`
+  );
+}
+function entryFileOf(dir, pkg, manifest) {
+  const exports = manifest["exports"];
+  const dot = typeof exports === "object" && exports !== null ? exports["."] : void 0;
+  const nested = typeof dot === "object" && dot !== null ? dot["import"] ?? dot["default"] : typeof dot === "string" ? dot : void 0;
+  const candidate = nested ?? manifest["module"] ?? manifest["main"];
+  if (typeof candidate !== "string") return null;
+  return fileInPackage(dir, pkg, candidate);
+}
+function fileInPackage(dir, pkg, relative) {
+  const manifest = manifestPathOf(dir, pkg);
+  if (manifest === null) return null;
+  const root = dirname(manifest);
+  const file = resolve(root, relative);
+  if (file !== root && !file.startsWith(root + sep)) return null;
+  return existsSync(file) ? file : null;
+}
+async function loadEntryExports(dir, pkg, manifest) {
+  const entry = entryFileOf(dir, pkg, manifest);
+  if (entry === null) {
+    return { kind: "missing", why: "its package.json names no entry we could read" };
+  }
+  return loadFile(entry);
+}
+async function loadFile(file) {
+  try {
+    return {
+      kind: "loaded",
+      exports: await import(pathToFileURL(file).href)
+    };
+  } catch (error) {
+    return {
+      kind: "failed",
+      why: `importing it failed (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+}
+function homepageOf(manifest) {
+  const homepage = manifest["homepage"];
+  return typeof homepage === "string" && /^https?:\/\//.test(homepage) ? homepage : void 0;
+}
+
+export {
+  packageNameOf,
+  localPathOf,
+  localPackageName,
+  tarballManifest,
+  installedPackageDir,
+  readInstalledManifestState,
+  readInstalledManifest,
+  moduleKind,
+  entryFileOf,
+  fileInPackage,
+  loadEntryExports,
+  loadFile,
+  homepageOf
+};
+//# sourceMappingURL=chunk-3LDULPRE.js.map

package/dist/chunk-3M4LFYNQ.js

@@ -0,0 +1,111 @@
+import {
+  localEngineHome
+} from "./chunk-AM4FKL4J.js";
+import {
+  filledAt,
+  withValidFilled
+} from "./chunk-ZYJP6BOO.js";
+import {
+  atomicWrite
+} from "./chunk-LLNZGEFK.js";
+
+// src/deploy/local-engine-state.ts
+import { createHash } from "crypto";
+import { mkdirSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+var LOCAL_ENGINE_STATE_FILE = "engines.json";
+function localEngineStatePath(env = process.env) {
+  return join(localEngineHome(env), LOCAL_ENGINE_STATE_FILE);
+}
+function projectKey(dir) {
+  return resolve(dir);
+}
+function engineNameForProject(dir) {
+  return `xanosdk-${createHash("sha256").update(projectKey(dir)).digest("hex").slice(0, 12)}`;
+}
+function isRecord(value) {
+  if (value === null || typeof value !== "object") return false;
+  const raw = value;
+  return typeof raw.name === "string" && typeof raw.url === "string" && typeof raw.workspaceId === "number" && typeof raw.project === "string";
+}
+function readLocalEngineState(env = process.env) {
+  let text;
+  try {
+    text = readFileSync(localEngineStatePath(env), "utf8");
+  } catch {
+    return { version: 1, engines: {} };
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed !== null && typeof parsed === "object") {
+      const rows = parsed.engines;
+      if (rows !== null && typeof rows === "object") {
+        const engines = {};
+        for (const [key, value] of Object.entries(rows)) {
+          if (isRecord(value)) engines[key] = withValidFilled(value);
+        }
+        return { version: 1, engines };
+      }
+    }
+  } catch {
+  }
+  return { version: 1, engines: {} };
+}
+function getEngineRecord(dir, env = process.env) {
+  return readLocalEngineState(env).engines[projectKey(dir)];
+}
+function listEngineRecords(env = process.env) {
+  return Object.values(readLocalEngineState(env).engines).sort(
+    (a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0)
+  );
+}
+function setEngineRecord(dir, record, env = process.env) {
+  const state = readLocalEngineState(env);
+  state.engines[projectKey(dir)] = { ...record, project: projectKey(dir) };
+  writeState(state, env);
+}
+function markEngineFilled(dir, url, env = process.env) {
+  const state = readLocalEngineState(env);
+  const record = state.engines[projectKey(dir)];
+  if (record === void 0) return;
+  state.engines[projectKey(dir)] = { ...record, filled: filledAt(url) };
+  writeState(state, env);
+}
+function clearEngineRecord(dir, env = process.env) {
+  const state = readLocalEngineState(env);
+  const key = projectKey(dir);
+  if (!(key in state.engines)) return false;
+  delete state.engines[key];
+  writeState(state, env);
+  return true;
+}
+function clearEngineRecordsNamed(name, env = process.env) {
+  const state = readLocalEngineState(env);
+  const cleared = Object.entries(state.engines).filter(([, record]) => record.name === name).map(([key]) => key);
+  if (cleared.length === 0) return [];
+  for (const key of cleared) delete state.engines[key];
+  writeState(state, env);
+  return cleared;
+}
+function writeState(state, env) {
+  const path = localEngineStatePath(env);
+  mkdirSync(localEngineHome(env), { recursive: true, mode: 448 });
+  atomicWrite(path, JSON.stringify({ version: 1, engines: state.engines }, null, 2) + "\n", {
+    mode: 384
+  });
+}
+
+export {
+  LOCAL_ENGINE_STATE_FILE,
+  localEngineStatePath,
+  projectKey,
+  engineNameForProject,
+  readLocalEngineState,
+  getEngineRecord,
+  listEngineRecords,
+  setEngineRecord,
+  markEngineFilled,
+  clearEngineRecord,
+  clearEngineRecordsNamed
+};
+//# sourceMappingURL=chunk-3M4LFYNQ.js.map

package/dist/chunk-3XI5CTUE.js

@@ -0,0 +1,22 @@
+// src/emit/project-dir.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function assertProjectDir(dir, ctx) {
+  const manifest = join(dir, "package.json");
+  if (!existsSync(manifest)) {
+    throw new Error(`No package.json in ${dir} \u2014 ${ctx.what}.
+  ${ctx.remedy}`);
+  }
+  try {
+    JSON.parse(readFileSync(manifest, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `${manifest} is not valid JSON, so npm cannot install into it \u2014 fix it and re-run. (${err instanceof Error ? err.message : String(err)})`
+    );
+  }
+}
+
+export {
+  assertProjectDir
+};
+//# sourceMappingURL=chunk-3XI5CTUE.js.map

package/dist/chunk-3YW23UFH.js

@@ -0,0 +1,50 @@
+// src/fields/generated/field-methods.generated.ts
+var FIELD_METHODS = {
+  "decimal": {
+    "max": "int",
+    "min": "int"
+  },
+  "email": {
+    "lower": "bool",
+    "trim": "bool"
+  },
+  "int": {
+    "max": "int",
+    "min": "int"
+  },
+  "password": {
+    "max": "int",
+    "min": "int",
+    "minAlpha": "int",
+    "minDigit": "int",
+    "minLowerAlpha": "int",
+    "minSymbol": "int",
+    "minUpperAlpha": "int",
+    "salt": "text"
+  },
+  "tableRef": {
+    "max": "int",
+    "min": "int"
+  },
+  "text": {
+    "alphaOk": "bool",
+    "digitOk": "bool",
+    "lower": "bool",
+    "max": "int",
+    "min": "int",
+    "ok": "text",
+    "pattern": "text",
+    "startsWith": "text",
+    "trim": "bool",
+    "upper": "bool"
+  },
+  "vector": {
+    "max": "int",
+    "min": "int"
+  }
+};
+
+export {
+  FIELD_METHODS
+};
+//# sourceMappingURL=chunk-3YW23UFH.js.map