@xano/sdk 1.0.0

package/dist/chunk-2GNFDZA2.js

@@ -0,0 +1,390 @@
+import {
+  declaredDependencies,
+  readProjectManifest,
+  readToolchainBlock
+} from "./chunk-JTUKLCXS.js";
+import {
+  localPackageName,
+  packageNameOf
+} from "./chunk-3LDULPRE.js";
+import {
+  parseJsonAnswer,
+  serverMessage,
+  statusLabel
+} from "./chunk-YLDALTWZ.js";
+import {
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+import {
+  CliError,
+  EXIT_SOURCE_UNRESOLVABLE,
+  info
+} from "./chunk-PTHVMXZI.js";
+import {
+  suggest
+} from "./chunk-UTI5G6OJ.js";
+
+// src/emit/marketplace-catalogue.ts
+var DEFAULT_BASE_URL = "https://xare-rvr8-mnnt.dev.xano.io";
+var CATALOGUE_TIMEOUT_MS = 3e4;
+function baseUrl() {
+  return readEnvVar("XANOSDK_MARKETPLACE_URL") ?? DEFAULT_BASE_URL;
+}
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+function asStringArray(v) {
+  return Array.isArray(v) ? v.filter((x) => typeof x === "string" && x !== "") : [];
+}
+function asBoolean(v) {
+  return typeof v === "boolean" ? v : void 0;
+}
+function asRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+}
+function projectRow(raw) {
+  return {
+    id: typeof raw.id === "number" ? raw.id : void 0,
+    slug: asString(raw.slug),
+    npm_package: asString(raw.npm_package),
+    title: asString(raw.title),
+    tagline: asString(raw.tagline),
+    tags: asStringArray(raw.tags),
+    repo_url: asString(raw.repo_url),
+    docs_url: asString(raw.docs_url),
+    // Closed set: an unknown kind is not passed through for a caller to guess at.
+    kind: raw.kind === "workspace" || raw.kind === "toolchain" ? raw.kind : void 0
+  };
+}
+function projectRequirements(v) {
+  if (!Array.isArray(v)) return [];
+  return v.map((entry) => typeof entry === "string" ? entry : asString(asRecord(entry)?.text)).filter((t) => t !== void 0);
+}
+function projectIncludes(v) {
+  if (!Array.isArray(v)) return [];
+  return v.flatMap((entry) => {
+    const rec = asRecord(entry);
+    if (rec === void 0) return [];
+    return [{ kind: asString(rec.kind), name: asString(rec.name), summary: asString(rec.summary) }];
+  });
+}
+function projectModule(raw) {
+  return {
+    ...projectRow(raw),
+    description: asString(raw.description),
+    includes: projectIncludes(raw.includes),
+    requirements: projectRequirements(raw.requirements),
+    register_snippet: asString(raw.register_snippet),
+    agent_prompt: asString(raw.agent_prompt),
+    listed: asBoolean(raw.listed),
+    deleted: asBoolean(raw.deleted)
+  };
+}
+var ModuleNotFoundError = class extends Error {
+  name = "ModuleNotFoundError";
+  constructor(message) {
+    super(message);
+  }
+};
+var CatalogueHttpError = class extends Error {
+  constructor(status, detail, message) {
+    super(message);
+    this.status = status;
+    this.detail = detail;
+  }
+  status;
+  detail;
+  name = "CatalogueHttpError";
+};
+var CatalogueUnreachableError = class extends Error {
+  name = "CatalogueUnreachableError";
+  exitCode = EXIT_SOURCE_UNRESOLVABLE;
+};
+function isCatalogueOutage(err) {
+  return err instanceof CatalogueUnreachableError || err instanceof CatalogueHttpError && err.status >= 500;
+}
+async function read(path, params) {
+  let url;
+  try {
+    url = new URL(path, baseUrl());
+  } catch {
+    throw new Error(
+      `XANOSDK_MARKETPLACE_URL is not a valid URL: ${JSON.stringify(process.env.XANOSDK_MARKETPLACE_URL)}`
+    );
+  }
+  for (const [key, value] of Object.entries(params ?? {})) {
+    url.searchParams.set(key, value);
+  }
+  let res;
+  try {
+    res = await fetch(url.href, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(CATALOGUE_TIMEOUT_MS)
+    });
+  } catch (err) {
+    throw new CatalogueUnreachableError(
+      `Could not reach the marketplace catalogue at ${url.origin} \u2014 ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const text = await res.text();
+  if (!res.ok) {
+    const detail = serverMessage(text);
+    throw new CatalogueHttpError(
+      res.status,
+      detail,
+      `The marketplace catalogue returned ${statusLabel(res)} for ${url.pathname}` + (detail !== void 0 ? `:
+${detail}` : ".")
+    );
+  }
+  return parseJsonAnswer(text, "Reading the marketplace catalogue", url.href);
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "an array";
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    return `an object with keys ${keys.length > 0 ? keys.join(", ") : "(none)"}`;
+  }
+  return typeof value;
+}
+function expectArray(value, path) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Expected ${path} to return a list of modules, got ${describe(value)}.`);
+  }
+  return value.flatMap((entry) => {
+    const rec = asRecord(entry);
+    return rec === void 0 ? [] : [rec];
+  });
+}
+async function fetchCatalogue() {
+  const path = "/api:marketplace/plugins";
+  return expectArray(await read(path), path).filter((raw) => raw.deleted !== true).map(projectModule);
+}
+var SEARCHED = ["title", "slug", "npm_package", "tagline", "description"];
+async function searchCatalogue(query) {
+  const needle = query.toLowerCase();
+  return (await fetchCatalogue()).filter(
+    (mod) => SEARCHED.some((column) => {
+      const value = mod[column];
+      return typeof value === "string" && value.toLowerCase().includes(needle);
+    })
+  );
+}
+async function fetchModule(pkg) {
+  const path = "/api:marketplace/plugins-details";
+  let body;
+  try {
+    body = await read(path, { package: pkg });
+  } catch (err) {
+    if (err instanceof CatalogueHttpError && err.status === 404) {
+      throw new ModuleNotFoundError(err.detail ?? "No module is published under that name.");
+    }
+    throw err;
+  }
+  if (body === null) {
+    throw new ModuleNotFoundError("No module is published under that name.");
+  }
+  const raw = asRecord(body);
+  if (raw === void 0) {
+    throw new Error(`Expected ${path} to return one module, got ${describe(body)}.`);
+  }
+  return projectModule(raw);
+}
+
+// src/emit/marketplace-resolve.ts
+var FIRST_PARTY_SCOPE = "@xano-sdk/";
+function isLocalSpecifier(spec) {
+  return /^(file|git|git\+[a-z]+|https?|link|workspace):/i.test(spec) || /^[./~]/.test(spec) || /\.(tgz|tar\.gz)$/i.test(spec);
+}
+var MarketplaceModuleNotFoundError = class extends Error {
+  name = "MarketplaceModuleNotFoundError";
+  exitCode = EXIT_SOURCE_UNRESOLVABLE;
+  /** The near name to type — the failure document's `suggestion` (the first of {@link suggestions}). */
+  suggestion;
+  /** Every near name, one per missed name, when there is more than one. */
+  suggestions;
+  /**
+   * Of a list lookup ({@link resolveMarketplaceSpecs}): every name's package,
+   * each missed one swapped for the listed module it is one slip from — set
+   * only when every miss has one. What a caller spells its corrected
+   * commands from.
+   */
+  corrected;
+  constructor(message, near = []) {
+    super(message);
+    this.suggestion = near[0];
+    this.suggestions = near.length > 1 ? [...near] : void 0;
+  }
+};
+function searchHint(name) {
+  const query = name.startsWith(FIRST_PARTY_SCOPE) ? name.slice(FIRST_PARTY_SCOPE.length) : name;
+  return `Run \`xanosdk marketplace search ${query}\` to find the module's real name, or \`xanosdk marketplace list\` for every one.`;
+}
+async function missHint(names) {
+  let byName;
+  try {
+    byName = spellingsOf((await fetchCatalogue()).flatMap((row) => row.npm_package === void 0 ? [] : [row.npm_package]));
+  } catch {
+    return { text: searchHint(names[0]), near: [], modules: [] };
+  }
+  const near = nearNames(names, byName);
+  if (near.length === 0) return { text: searchHint(names[0]), near: [], modules: [] };
+  return {
+    text: `Did you mean ${saidNear(near, names.length)}? \`xanosdk marketplace list\` lists every module.`,
+    near: near.map((n) => n.hit),
+    modules: near
+  };
+}
+async function notFound(head, names) {
+  return (await notFoundWith(head, names)).err;
+}
+async function notFoundWith(head, names) {
+  const hint = await missHint(names);
+  return { err: new MarketplaceModuleNotFoundError(`${head} ${hint.text}`, hint.near), modules: hint.modules };
+}
+function spellingsOf(packages) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    byName.set(pkg, pkg);
+    if (pkg.startsWith(FIRST_PARTY_SCOPE)) byName.set(pkg.slice(FIRST_PARTY_SCOPE.length), pkg);
+  }
+  return byName;
+}
+function nearPackage(name, packages) {
+  const byName = spellingsOf(packages);
+  const exact = byName.get(name);
+  if (exact !== void 0 && exact !== name) return { name, hit: exact, pkg: exact };
+  return nearNames([name], byName)[0];
+}
+function nearNames(names, byName) {
+  const spellings = [...byName.keys()];
+  return names.flatMap((name) => {
+    const bare = name.startsWith(FIRST_PARTY_SCOPE) ? name.slice(FIRST_PARTY_SCOPE.length) : name;
+    const hit = suggest(bare, spellings) ?? suggest(name, spellings);
+    return hit === void 0 || hit === name ? [] : [{ name, hit, pkg: byName.get(hit) }];
+  });
+}
+function saidNear(near, of) {
+  return near.map(({ name, hit, pkg }) => `\`${hit}\`${pkg === hit ? "" : ` (${pkg})`}${of > 1 ? ` for ${name}` : ""}`).join(", ");
+}
+async function resolveMarketplaceSpec(spec, command) {
+  if (isLocalSpecifier(spec)) return spec;
+  const name = packageNameOf(spec);
+  const version = spec.length > name.length ? spec.slice(name.length) : "";
+  let mod;
+  try {
+    mod = await fetchModule(name);
+  } catch (err) {
+    if (err instanceof ModuleNotFoundError) {
+      throw await notFound(
+        `\`${command}\`: ${name} is not in the Xano SDK marketplace, so nothing was installed.`,
+        [name]
+      );
+    }
+    if (name.startsWith(FIRST_PARTY_SCOPE)) return spec;
+    const message = `\`${command}\`: could not reach the Xano SDK marketplace to confirm that ${name} is a module (${err instanceof Error ? err.message : String(err)}), so nothing was installed. An \`${FIRST_PARTY_SCOPE}\` module installs by its full name without it.`;
+    throw isCatalogueOutage(err) ? new CatalogueUnreachableError(message) : new Error(message);
+  }
+  if (mod.deleted === true) {
+    throw new MarketplaceModuleNotFoundError(
+      `\`${command}\`: ${mod.npm_package ?? name} has been removed from the Xano SDK marketplace, so nothing was installed. Run \`xanosdk marketplace list\` for the modules that are published.`
+    );
+  }
+  const pkg = mod.npm_package ?? name;
+  if (pkg !== name) info(`${name} is the marketplace module ${pkg}.`);
+  return `${pkg}${version}`;
+}
+async function resolveMarketplaceSpecs(specs, command) {
+  const resolved = [];
+  const missing = [];
+  for (const spec of specs) {
+    try {
+      resolved.push(await resolveMarketplaceSpec(spec, command));
+    } catch (err) {
+      if (!(err instanceof MarketplaceModuleNotFoundError)) throw err;
+      if (specs.length === 1) throw err;
+      missing.push(packageNameOf(spec));
+      resolved.push(void 0);
+    }
+  }
+  if (missing.length > 0) {
+    const { err, modules } = await notFoundWith(
+      `\`${command}\`: ${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} not in the Xano SDK marketplace, so nothing was installed.`,
+      missing
+    );
+    const fix = new Map(modules.map((m) => [m.name, m.pkg]));
+    if (missing.every((name) => fix.has(name))) {
+      err.corrected = specs.map((spec, i) => resolved[i] ?? fix.get(packageNameOf(spec)));
+    }
+    throw err;
+  }
+  return resolved;
+}
+async function resolveProjectModule(spec, dir) {
+  return (await resolveProjectModuleListing(spec, dir)).pkg;
+}
+async function resolveProjectModuleListing(spec, dir) {
+  const manifest = readProjectManifest(dir);
+  const known = /* @__PURE__ */ new Set([
+    ...manifest === null ? [] : declaredDependencies(manifest),
+    ...Object.keys(readToolchainBlock(dir, manifest))
+  ]);
+  if (isLocalSpecifier(spec)) {
+    const name = localPackageName(spec, dir);
+    if (name === void 0) return { pkg: spec, listing: "unknown" };
+    return { pkg: name, listing: known.has(name) ? "project" : "unknown" };
+  }
+  if (known.has(spec)) return { pkg: spec, listing: "project" };
+  let mod;
+  try {
+    mod = await fetchModule(spec);
+  } catch (err) {
+    return { pkg: spec, listing: err instanceof ModuleNotFoundError ? "unlisted" : "unknown" };
+  }
+  if (mod.deleted === true && !known.has(mod.npm_package ?? spec)) return { pkg: spec, listing: "unlisted" };
+  const pkg = mod.npm_package ?? spec;
+  if (pkg !== spec) info(`${spec} is the marketplace module ${pkg}.`);
+  return { pkg, listing: known.has(pkg) ? "project" : "catalogue" };
+}
+async function notInMarketplaceError(command, name) {
+  return notFound(
+    `\`${command}\`: ${name} is not in the Xano SDK marketplace.`,
+    [name]
+  );
+}
+async function unlistedModuleError(command, name) {
+  return notFound(
+    `\`${command}\`: ${name} is not a dependency of this project and not in the Xano SDK marketplace.`,
+    [name]
+  );
+}
+async function withCatalogueRerun(err, args, command) {
+  if (!isCatalogueOutage(err)) return err;
+  const { retryCommand } = await import("./retry-command-AS5EVREX.js");
+  const rerun = retryCommand(args, { command }).command;
+  return new CliError("SDK_ERROR", `${err.message}
+Run \`${rerun}\` again once it answers.`, {
+    exitCode: EXIT_SOURCE_UNRESOLVABLE,
+    details: { reason: "catalogue-unreachable", rerun },
+    cause: err
+  });
+}
+
+export {
+  ModuleNotFoundError,
+  fetchCatalogue,
+  searchCatalogue,
+  fetchModule,
+  FIRST_PARTY_SCOPE,
+  isLocalSpecifier,
+  MarketplaceModuleNotFoundError,
+  nearPackage,
+  resolveMarketplaceSpec,
+  resolveMarketplaceSpecs,
+  resolveProjectModule,
+  resolveProjectModuleListing,
+  notInMarketplaceError,
+  unlistedModuleError,
+  withCatalogueRerun
+};
+//# sourceMappingURL=chunk-2GNFDZA2.js.map

package/dist/chunk-2MNLRIOX.js

@@ -0,0 +1,11 @@
+// src/util/timestamp.ts
+function asTimestamp(v) {
+  if (typeof v !== "string" || v === "") return void 0;
+  const parsed = new Date(v);
+  return Number.isNaN(parsed.getTime()) ? v : parsed.toISOString();
+}
+
+export {
+  asTimestamp
+};
+//# sourceMappingURL=chunk-2MNLRIOX.js.map

package/dist/chunk-2TFRR6JV.js

@@ -0,0 +1,104 @@
+// src/emit/semver.ts
+function parseSemver(v) {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(v.trim());
+  if (!m) return null;
+  return {
+    nums: [Number(m[1]), Number(m[2]), Number(m[3])],
+    pre: m[4] ? m[4].split(".") : []
+  };
+}
+function compareSemver(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a.nums[i] !== b.nums[i]) return a.nums[i] > b.nums[i] ? 1 : -1;
+  }
+  if (a.pre.length === 0) return b.pre.length === 0 ? 0 : 1;
+  if (b.pre.length === 0) return -1;
+  return comparePre(a.pre, b.pre);
+}
+function comparePre(a, b) {
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    if (i >= a.length) return -1;
+    if (i >= b.length) return 1;
+    const x = a[i];
+    const y = b[i];
+    const xn = /^\d+$/.test(x);
+    const yn = /^\d+$/.test(y);
+    if (xn && yn) {
+      if (Number(x) !== Number(y)) return Number(x) < Number(y) ? -1 : 1;
+    } else if (xn !== yn) {
+      return xn ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function satisfiesRange(version, range) {
+  const v = parseSemver(version);
+  if (!v || v.pre.length > 0) return null;
+  const text = range.trim();
+  if (text === "" || text === "*" || text === "x" || text === "X") return true;
+  let unknown = false;
+  for (const group of text.split("||")) {
+    const result = satisfiesAll(v, group);
+    if (result === true) return true;
+    if (result === null) unknown = true;
+  }
+  return unknown ? null : false;
+}
+function satisfiesAll(v, group) {
+  const tokens = group.trim().replace(/(>=|<=|>|<|=|\^|~)\s+/g, "$1").split(/\s+/).filter((t) => t !== "");
+  if (tokens.length === 0) return true;
+  if (tokens.some((t) => t === "-" || t.startsWith("-"))) return null;
+  let unknown = false;
+  for (const token of tokens) {
+    const result = satisfiesComparator(v, token);
+    if (result === false) return false;
+    if (result === null) unknown = true;
+  }
+  return unknown ? null : true;
+}
+function satisfiesComparator(v, token) {
+  if (token === "*" || token === "x" || token === "X") return true;
+  const m = /^(>=|<=|>|<|=|\^|~)?\s*(.+)$/.exec(token);
+  if (!m) return null;
+  const op = m[1] ?? "=";
+  const target = parseSemver(m[2]);
+  if (!target || target.pre.length > 0) return null;
+  const cmp = compareSemver(v, target);
+  switch (op) {
+    case ">=":
+      return cmp >= 0;
+    case ">":
+      return cmp > 0;
+    case "<=":
+      return cmp <= 0;
+    case "<":
+      return cmp < 0;
+    case "=":
+      return cmp === 0;
+    // `^` allows changes that do not modify the left-most NON-ZERO field, which
+    // is why `^0.0.30` is an exact pin and `^0.2.3` stops at 0.3.0.
+    case "^":
+      return cmp >= 0 && compareSemver(v, { nums: caretCeiling(target), pre: [] }) < 0;
+    // `~` allows patch-level changes: `~1.2.3` stops at 1.3.0.
+    case "~":
+      return cmp >= 0 && compareSemver(v, { nums: [target.nums[0], target.nums[1] + 1, 0], pre: [] }) < 0;
+    default:
+      return null;
+  }
+}
+function caretCeiling(target) {
+  const [major, minor, patch] = target.nums;
+  if (major !== 0) return [major + 1, 0, 0];
+  if (minor !== 0) return [0, minor + 1, 0];
+  return [0, 0, patch + 1];
+}
+
+export {
+  parseSemver,
+  compareSemver,
+  satisfiesRange
+};
+//# sourceMappingURL=chunk-2TFRR6JV.js.map