@xano/sdk 1.0.0

package/dist/chunk-DX4QR4B2.js

@@ -0,0 +1,483 @@
+import {
+  addDependency,
+  removeDependency
+} from "./chunk-6QXLMMT3.js";
+import {
+  condenseNpmError,
+  npmViewVersion
+} from "./chunk-ZFDZKNGG.js";
+import {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import {
+  isLocalSpecifier
+} from "./chunk-2GNFDZA2.js";
+import {
+  addArgs,
+  installSite,
+  removeCommandFor
+} from "./chunk-WRBKLYSJ.js";
+import {
+  homepageOf,
+  installedPackageDir,
+  loadEntryExports,
+  localPathOf,
+  moduleKind,
+  packageNameOf,
+  readInstalledManifest
+} from "./chunk-3LDULPRE.js";
+import {
+  UsageError,
+  spinner,
+  step,
+  success,
+  warn
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/init-modules.ts
+import { existsSync, readFileSync, realpathSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+function isOptionImport(ref) {
+  return "package" in ref;
+}
+function parseMarketplaceFlag(values) {
+  const packages = [];
+  for (const value of values) {
+    for (const raw of value.split(",")) {
+      const pkg = raw.trim();
+      if (pkg === "") continue;
+      if (pkg.startsWith("-")) {
+        throw new UsageError(
+          `\`--marketplace\`: "${pkg}" starts with a dash, so npm would read it as a flag, not a package.`,
+          { helpFor: { command: "init" } }
+        );
+      }
+      if (!packages.includes(pkg)) packages.push(pkg);
+    }
+  }
+  return packages;
+}
+function readOptionRefs(raw) {
+  if (typeof raw !== "object" || raw === null) return {};
+  const refs = {};
+  for (const [name, value] of Object.entries(raw)) {
+    if (typeof value !== "object" || value === null) continue;
+    const entry = value;
+    const pkg = entry["package"];
+    const exported = entry["export"];
+    if (typeof pkg === "string" && pkg !== "" && typeof exported === "string" && exported !== "") {
+      refs[name] = { package: pkg, export: exported };
+      continue;
+    }
+    const literal = entry["value"];
+    if (typeof literal === "string" || typeof literal === "number" || typeof literal === "boolean") {
+      refs[name] = { value: literal };
+    }
+  }
+  return refs;
+}
+var UNDECLARED_OPTIONS = {
+  "@xano-sdk/auth": { canonical: { value: "authn" } },
+  "@xano-sdk/chatbot": { authTable: { package: "@xano-sdk/auth", export: "userTable" } }
+};
+function wrapAt(text, width) {
+  const lines = [];
+  let line = "";
+  for (const word of text.split(" ")) {
+    if (line === "") line = word;
+    else if (`${line} ${word}`.length <= width) line += ` ${word}`;
+    else {
+      lines.push(line);
+      line = word;
+    }
+  }
+  if (line !== "") lines.push(line);
+  return lines;
+}
+function bindingNameFor(register) {
+  const bare = register.replace(/^register/, "");
+  return bare === "" ? "handle" : bare[0].toLowerCase() + bare.slice(1);
+}
+function takesSecondArgument(loaded, register) {
+  const fn = loaded[register];
+  return typeof fn === "function" && fn.length >= 2;
+}
+function verdictFromArity(entry, register) {
+  if (entry.kind !== "loaded") return { kind: "unreadable", why: entry.why };
+  return takesSecondArgument(entry.exports, register) ? { kind: "undeclared" } : { kind: "accounted" };
+}
+async function readRegistration(dir, pkg) {
+  const manifest = readInstalledManifest(dir, pkg);
+  if (manifest === null) return { unwired: "it is not in node_modules after the install" };
+  if (moduleKind(pkg, manifest) === "toolchain") return { toolchain: true };
+  const field = manifest["xanosdk"];
+  if (typeof field === "object" && field !== null) {
+    const declaration = field;
+    const register2 = declaration["register"];
+    if (typeof register2 === "string" && register2 !== "") {
+      const declared = declaration["options"];
+      return {
+        pkg,
+        register: register2,
+        binding: declaration["returns"] === "handle" ? bindingNameFor(register2) : null,
+        // The module's own declaration wins option by option, so a package that
+        // ships one is never second-guessed here.
+        options: { ...UNDECLARED_OPTIONS[pkg], ...readOptionRefs(declared) },
+        optionsVerdict: declared !== void 0 ? { kind: "accounted" } : verdictFromArity(await loadEntryExports(dir, pkg, manifest), register2),
+        source: "manifest",
+        docs: homepageOf(manifest)
+      };
+    }
+  }
+  const entry = await loadEntryExports(dir, pkg, manifest);
+  if (entry.kind !== "loaded") return { unwired: entry.why };
+  const loaded = entry.exports;
+  const names = Object.keys(loaded).filter(
+    (name) => /^register[A-Z]/.test(name) && typeof loaded[name] === "function"
+  );
+  if (names.length === 0) {
+    return {
+      unwired: `it exports no register* function, and its package.json has no "xanosdk" field`
+    };
+  }
+  if (names.length > 1) {
+    return {
+      unwired: `it exports ${names.length} register* functions (${names.join(", ")}) \u2014 its package.json needs a "xanosdk" field naming the one to call`
+    };
+  }
+  const register = names[0];
+  return {
+    pkg,
+    register,
+    optionsVerdict: takesSecondArgument(loaded, register) ? { kind: "undeclared" } : { kind: "accounted" },
+    binding: null,
+    options: { ...UNDECLARED_OPTIONS[pkg] },
+    source: "exports",
+    docs: homepageOf(manifest)
+  };
+}
+function renderImports(modules) {
+  const byPackage = /* @__PURE__ */ new Map();
+  const add = (pkg, name) => {
+    const names = byPackage.get(pkg) ?? /* @__PURE__ */ new Set();
+    names.add(name);
+    byPackage.set(pkg, names);
+  };
+  for (const m of modules) {
+    add(m.pkg, m.register);
+    for (const ref of Object.values(m.options)) {
+      if (isOptionImport(ref)) add(ref.package, ref.export);
+    }
+  }
+  return [...byPackage].map(([pkg, names]) => `import { ${[...names].sort().join(", ")} } from "${pkg}";`);
+}
+function renderRegisterCall(register, options, app = "app") {
+  const entries = Object.entries(options);
+  const opts = entries.length === 0 ? "" : `, { ${entries.map(([name, ref]) => `${name}: ${isOptionImport(ref) ? ref.export : JSON.stringify(ref.value)}`).join(", ")} }`;
+  return `${register}(${app}${opts});`;
+}
+function renderXanoIndexWithModules(appName, modules, unwired = [], env = []) {
+  const imports = renderImports(modules).join("\n");
+  const calls = modules.map((m) => {
+    const call = renderRegisterCall(m.register, m.options);
+    return m.binding === null ? call : `const ${m.binding} = ${call}`;
+  }).join("\n");
+  const note = [];
+  if (unwired.length > 0) {
+    note.push(
+      "Installed but NOT registered \u2014 each needs something this scaffold could",
+      "not supply. Uncomment, fill in the options, and the module is live."
+    );
+    for (const m of unwired) {
+      note.push("", m.pkg, ...wrapAt(`${m.reason}.`, 72).map((line) => `  ${line}`), "");
+      const details = `npx xanosdk marketplace details ${m.pkg}`;
+      const lookup = m.readme === void 0 ? `run \`${details}\`` : `see ${m.readme}`;
+      if (m.register === void 0) {
+        note.push(`  // ${lookup} for the export to call`);
+      } else if (m.options !== void 0) {
+        note.push(...renderImports([{ pkg: m.pkg, register: m.register, options: m.options }]).map((l) => `  ${l}`));
+        note.push(`  ${renderRegisterCall(m.register, m.options)}`);
+      } else {
+        note.push(
+          `  import { ${m.register} } from "${m.pkg}";`,
+          `  ${m.register}(app, { ... }); // options: ${lookup}`
+        );
+      }
+    }
+  }
+  const unwiredNote = note.length === 0 ? "" : `/*
+${note.map((line) => line === "" ? " *" : ` * ${line}`).join("\n").replaceAll("*/", "* /")}
+ */`;
+  const envBlock = env.length === 0 ? "" : `// Env vars the add-ons read. Set their values in xano/.env (see xano/.env.example).
+app.registerWorkspace(workspaceConfig({ env: { ${env.map((name) => `${/^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name)}: ""`).join(", ")} } }));`;
+  const body = [calls, envBlock, unwiredNote].filter(Boolean).map((block) => `${block}
+
+`).join("");
+  const importLines = imports === "" ? "" : `${imports}
+`;
+  const opening = wrapAt(
+    "A workspace is assembled by registering typed objects onto a workspace() instance and default-exporting it. " + (modules.length === 0 ? "The add-ons you picked were installed by `xanosdk init --marketplace`. None of them could be registered for you \u2014 the note below names what each one still needs." : "The add-ons below were installed by `xanosdk init --marketplace` and registered for you." + (unwired.length === 0 ? "" : " The ones that could not be registered are named under them.")),
+    74
+  ).join("\n * ");
+  const handles = modules.filter((m) => m.binding !== null);
+  const handleNote = handles.length === 0 ? "" : `
+ *
+ * ${handles.map((m) => `\`${m.binding}\` is ${m.pkg}'s handle \u2014 its endpoints and helpers.`).join("\n * ")}`;
+  return `import { ${env.length === 0 ? "workspace" : "workspace, workspaceConfig"} } from "@xano/sdk";
+${importLines}
+/**
+ * The ${appName} backend.
+ *
+ * ${opening}
+ *
+ * Each register* call mutates the workspace, so the order does not matter and
+ * the thing exported is the workspace itself. Add your own tables and endpoints
+ * beside them \u2014 xano/EXAMPLE.md walks through the first one.${handleNote}
+ */
+const app = workspace("${appName}");
+
+${body}export default app;
+`;
+}
+function isMissingPackage(stderr) {
+  return /\bE404\b|is not in this registry/i.test(stderr);
+}
+function rebaseLocalSpec(spec, from, to) {
+  const path = localPathOf(spec);
+  if (path === void 0 || isAbsolute(path)) return spec;
+  const abs = resolve(from, path);
+  if (!existsSync(abs)) {
+    throw new UsageError(`\`--marketplace\`: ${spec} is not on disk (looked for ${abs}).`, {
+      helpFor: { command: "init" }
+    });
+  }
+  const rel = relative(resolve(to), abs).split(sep).join("/");
+  const rebased = rel.startsWith("..") ? rel : `./${rel}`;
+  return spec.startsWith("file:") ? `file:${rebased}` : rebased;
+}
+function preflightPackages(specifiers, targetDir, view = npmViewVersion) {
+  const packages = specifiers.filter((p) => !isLocalSpecifier(p));
+  if (packages.length === 0) return;
+  step(`Checking ${packages.join(", ")} on the npm registry`);
+  const cwd = nearestExistingDir(targetDir);
+  const missing = [];
+  for (const specifier of packages) {
+    const result = view(packageNameOf(specifier), cwd);
+    if (!result.ok && isMissingPackage(result.stderr)) missing.push(packageNameOf(specifier));
+  }
+  if (missing.length === 0) return;
+  const names = [...new Set(missing)].join(", ");
+  throw new UsageError(
+    `\`--marketplace\`: the npm registry has no ${missing.length === 1 ? "package" : "packages"} named ${names}. Check the name with \`xanosdk marketplace search\`, or list what is published with \`xanosdk marketplace list\`. (A package published in the last few minutes can 404 until the registry finishes replicating it \u2014 if the name is right, retry.)`,
+    { helpFor: { command: "init" } }
+  );
+}
+function nearestExistingDir(dir) {
+  let current = resolve(dir);
+  for (; ; ) {
+    if (existsSync(current)) return current;
+    const parent = dirname(current);
+    if (parent === current) return process.cwd();
+    current = parent;
+  }
+}
+function wiringPointer(registration) {
+  const details = registration.readme === void 0 ? `run \`npx xanosdk marketplace details ${registration.pkg} --prompt\` for its wiring` : `see ${registration.readme} (from the project root) for its wiring`;
+  return registration.docs === void 0 ? details : `${details}, or see ${registration.docs}`;
+}
+function partitionRegistrations(registered, present) {
+  const writable = [];
+  const unwired = [];
+  for (const registration of registered) {
+    const missingRefs = Object.entries(registration.options).filter(
+      (entry) => isOptionImport(entry[1]) && !present.has(entry[1].package)
+    );
+    const missing = [...new Set(missingRefs.map(([, ref]) => ref.package))];
+    let reason = null;
+    let options;
+    if (missing.length > 0) {
+      const names = missingRefs.map(([name]) => `\`${name}\``).join(", ");
+      reason = `${registration.register}() needs ${names} from ${missing.join(", ")}, which this project does not have \u2014 add it with ${missing.map((pkg) => `\`npx xanosdk marketplace install ${pkg}\``).join(", ")} and wire it as that prints, uncommenting the ${registration.register}() call in xano/index.ts before its last step; or pass your own value for ${names}`;
+      if (registration.optionsVerdict.kind === "accounted") options = registration.options;
+    } else if (registration.optionsVerdict.kind === "undeclared") {
+      reason = `${registration.register}() takes an options argument that ${registration.pkg} does not declare \u2014 ${wiringPointer(registration)}`;
+    } else if (registration.optionsVerdict.kind === "unreadable") {
+      reason = `${registration.pkg} names ${registration.register}() but ${registration.optionsVerdict.why}, so whether the call takes options could not be settled \u2014 ${wiringPointer(registration)}`;
+    }
+    if (reason === null) {
+      writable.push(registration);
+      continue;
+    }
+    unwired.push({
+      pkg: registration.pkg,
+      reason,
+      ...registration.readme === void 0 ? {} : { readme: registration.readme },
+      register: registration.register,
+      ...options === void 0 ? {} : { options }
+    });
+  }
+  return { writable, unwired };
+}
+function classifyNpmFailure(output, dir) {
+  const target = /No matching version found for (\S+)@(.+?)\.?\s*$/m.exec(output);
+  if (/\bETARGET\b/.test(output) && target !== null) {
+    const [, pkg, range] = target;
+    const own = declaredRange(dir, pkg) === range;
+    return `npm has no published ${pkg} matching ${range}` + (own ? ` \u2014 the range this project's package.json declares for it. Point it at a published version (\`npm view ${pkg} versions\`) and run \`npm install\` again.` : ` \u2014 a range this package, or one of its dependencies, asks for.`);
+  }
+  const missing = /'((?:@[^/'\s]+\/)?[^@'\s]+)(?:@[^'\s]*)?' is not in (?:this|the npm) registry/.exec(output);
+  if (/\bE404\b/.test(output)) {
+    return missing === null ? `npm answered 404: a package this install needs is not in the registry.` : `npm answered 404: ${missing[1]} is not in the registry.`;
+  }
+  return void 0;
+}
+function declaredRange(dir, pkg) {
+  try {
+    const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    for (const block of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const range = manifest[block]?.[pkg];
+      if (typeof range === "string") return range;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function inProject(dir) {
+  const here = process.cwd();
+  if (resolve(dir) === resolve(here)) return "";
+  const rel = relative(here, resolve(dir));
+  return `cd ${shellWord(rel === "" || rel.startsWith("..") ? resolve(dir) : rel)} && `;
+}
+async function installModules(dir, packages) {
+  const installed = [];
+  const failed = [];
+  const reported = [];
+  const legacyPeer = [];
+  const registered = [];
+  const unwired = [];
+  const toolchain = [];
+  const present = /* @__PURE__ */ new Set();
+  const { manager } = installSite(dir);
+  for (const specifier of packages) {
+    const spin = spinner(`Installing ${specifier}`);
+    let result;
+    try {
+      result = await addDependency(dir, specifier, {
+        onLink: (member) => spin.update(`Linking ${member} into the npm workspace`),
+        onRetry: () => spin.update(`Installing ${specifier} (retrying with --legacy-peer-deps)`)
+      });
+    } finally {
+      spin.stop();
+    }
+    const { site, installSpec } = result;
+    const peerConflict = result.peerConflict;
+    if (peerConflict !== null && result.status === 0) legacyPeer.push(specifier);
+    if (result.status !== 0) {
+      failed.push(specifier);
+      const cause = classifyNpmFailure(result.output, dir);
+      const reason = condenseNpmError(result.output);
+      if (reason !== "") reported.push(reason);
+      warn(`${manager} ${[...addArgs(manager, installSpec), ...site.scope].join(" ")} failed \u2014 the module was not added.`, "module.install-failed", [
+        ...cause !== void 0 ? [cause] : (
+          // Said even though the retry's own error follows, because the retry is
+          // otherwise invisible: it was announced only in spinner text, which the
+          // spinner erases. Only when the peer conflict is still what failed.
+          peerConflict !== null ? [
+            result.retried ? `It declares a peer range this CLI does not satisfy; --legacy-peer-deps did not resolve it either.` : `It declares a peer range this CLI does not satisfy, and the install ran out of time before --legacy-peer-deps could be tried.`
+          ] : []
+        ),
+        ...reason === "" ? [] : [reason],
+        // Named, so the line is a command to paste rather than a template — and
+        // from inside the new project, since it is printed before the `cd`.
+        `Add it with \`${inProject(dir)}xanosdk marketplace install ${specifier}\` once ${manager}'s error is fixed.`
+      ]);
+      continue;
+    }
+    if (peerConflict !== null) {
+      warn(
+        `${specifier} declares a peer range this CLI does not satisfy \u2014 installed with --legacy-peer-deps.`,
+        "module.legacy-peer-deps"
+      );
+    }
+    const pkg = result.landed;
+    if (pkg === void 0) {
+      failed.push(specifier);
+      warn(
+        `${manager} reported ${specifier} installed, but ${result.recorded === void 0 ? "it is not in this project's package.json" : `${result.recorded} does not resolve from this project`} \u2014 the module was not added.`,
+        "module.install-failed",
+        [`Add it with \`${inProject(dir)}xanosdk marketplace install ${shellWord(specifier)}\`.`]
+      );
+      continue;
+    }
+    const skew = await sdkPeerSkewOf(dir, pkg);
+    if (skew !== null) {
+      failed.push(specifier);
+      warn(
+        `${specifier} requires \`@xano/sdk\` ${skew.range} \u2014 the module was not added.`,
+        "module.sdk-skew",
+        [
+          `This CLI is ${skew.sdkVersion}, so its hooks were built against a contract this one does not have. Upgrade the CLI, or use a ${pkg} built for it.`
+        ]
+      );
+      await removeQuietly(dir, pkg);
+      continue;
+    }
+    success(`Installed ${specifier}`);
+    installed.push(specifier);
+    present.add(pkg);
+    const registration = await readRegistration(dir, pkg);
+    const readme = isLocalSpecifier(specifier) ? localReadme(dir, pkg) : void 0;
+    const where = readme === void 0 ? {} : { readme };
+    if ("toolchain" in registration) toolchain.push(pkg);
+    else if ("unwired" in registration) {
+      const reason = readme === void 0 ? registration.unwired : `${registration.unwired} \u2014 see ${readme} (from the project root) for its wiring`;
+      unwired.push({ pkg, reason, ...where });
+    } else registered.push({ ...registration, ...where });
+  }
+  const { writable, unwired: unwritable } = partitionRegistrations(registered, present);
+  unwired.push(...unwritable);
+  return { installed, failed, reported, legacyPeer, registered: writable, unwired, toolchain };
+}
+function localReadme(dir, pkg) {
+  const at = installedPackageDir(dir, pkg);
+  if (at === null) return void 0;
+  const readme = ["README.md", "readme.md", "README"].map((name) => join(at, name)).find((path) => existsSync(path));
+  return relative(realpathSync(dir), readme ?? at).split(sep).join("/");
+}
+async function sdkPeerSkewOf(dir, pkg) {
+  const manifest = readInstalledManifest(dir, pkg);
+  if (manifest === null) return null;
+  const [{ sdkPeerSkew }, { readVersion }] = await Promise.all([
+    import("./toolchain-modules-5EAZUONB.js"),
+    import("./cli.js")
+  ]);
+  const sdkVersion = readVersion();
+  const range = sdkPeerSkew(manifest, sdkVersion);
+  return range === null ? null : { range, sdkVersion };
+}
+async function removeQuietly(dir, pkg) {
+  const result = await removeDependency(dir, pkg);
+  if (result.status === 0 && !result.stillListed) return;
+  warn(
+    `${pkg} could not be removed again \u2014 it is still in this project's dependencies.`,
+    "module.uninstall-failed",
+    [`Run \`${inProject(dir)}${removeCommandFor(dir, pkg)}\` to finish taking it out.`]
+  );
+}
+
+export {
+  isOptionImport,
+  parseMarketplaceFlag,
+  readRegistration,
+  renderImports,
+  renderRegisterCall,
+  renderXanoIndexWithModules,
+  isMissingPackage,
+  rebaseLocalSpec,
+  preflightPackages,
+  partitionRegistrations,
+  classifyNpmFailure,
+  inProject,
+  installModules
+};
+//# sourceMappingURL=chunk-DX4QR4B2.js.map

package/dist/chunk-EHP3WPEG.js

@@ -0,0 +1,21 @@
+// src/bundle/schema.ts
+function tableRefOf(column) {
+  if (column.type !== "int" && column.type !== "uuid") return null;
+  const last = column.methods?.[column.methods.length - 1];
+  const arg = last?.name === "@" ? last.arg?.[0] : void 0;
+  if (typeof arg !== "string" || !arg.startsWith("dbo=")) return null;
+  const guid = arg.slice("dbo=".length);
+  return guid === "" ? null : guid;
+}
+function linkedTableOf(column) {
+  const suffix = "_mvpschema";
+  if (typeof column.type !== "string" || !column.type.endsWith(suffix)) return null;
+  const guid = column.type.slice(0, -suffix.length);
+  return guid === "" ? null : guid;
+}
+
+export {
+  tableRefOf,
+  linkedTableOf
+};
+//# sourceMappingURL=chunk-EHP3WPEG.js.map