@xanots/sdk 0.0.3-beta.0 → 0.0.4

package/dist/{chunk-4HKZH6YK.js → chunk-EAIR6VUL.js}

@@ -2,11 +2,17 @@ import {
   presetFilePath,
   resolveAiPresets,
   scaffoldProject
-} from "./chunk-WRYT2PAX.js";
+} from "./chunk-7SISR3CS.js";
+import {
+  runNpmCapturingStderr
+} from "./chunk-ZSYZTGJH.js";
 import {
   DEFAULT_FRAMEWORK,
   allFrontendPresets,
   findFrontendPreset,
+  resolveFrameworkFlag
+} from "./chunk-WGDAOOXG.js";
+import {
   initLanding,
   renderApiTs,
   renderCnUtil,
@@ -20,9 +26,8 @@ import {
   renderTsconfig,
   renderViteConfig,
   renderXanoExampleMd,
-  renderXanoIndex,
-  resolveFrameworkFlag
-} from "./chunk-YZ4GU6F5.js";
+  renderXanoIndex
+} from "./chunk-QUUB7HYK.js";
 import {
   DEFAULT_DARK_MODE,
   curatedThemes,
@@ -39,18 +44,214 @@ import {
 } from "./chunk-6DHJVLYP.js";
 import {
   readVersion
-} from "./chunk-VVXPK6SE.js";
+} from "./chunk-DUC3PXDG.js";
+import {
+  UsageError
+} from "./chunk-KGNJM4LN.js";
 import {
   blank,
   detail,
   info,
   step,
   style,
-  success
+  success,
+  warn
 } from "./chunk-EZG76F7R.js";
 
 // src/emit/init-command.ts
-import { basename, resolve } from "path";
+import { writeFileSync } from "fs";
+import { basename, join as join2, resolve } from "path";
+
+// src/emit/init-modules.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { pathToFileURL } from "url";
+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 packageNameOf(specifier) {
+  const at = specifier.lastIndexOf("@");
+  return at > 0 ? specifier.slice(0, at) : specifier;
+}
+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 };
+    }
+  }
+  return refs;
+}
+function bindingNameFor(register) {
+  const bare = register.replace(/^register/, "");
+  return bare === "" ? "handle" : bare[0].toLowerCase() + bare.slice(1);
+}
+function readInstalledManifest(dir, pkg) {
+  const path = join(dir, "node_modules", ...pkg.split("/"), "package.json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function entryFileOf(dir, pkg, manifest) {
+  const root = join(dir, "node_modules", ...pkg.split("/"));
+  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;
+  const file = join(root, candidate);
+  return existsSync(file) ? file : null;
+}
+async function readRegistration(dir, pkg) {
+  const manifest = readInstalledManifest(dir, pkg);
+  if (manifest === null) return { unwired: "it is not in node_modules after the install" };
+  const declared = manifest["xanots"];
+  if (typeof declared === "object" && declared !== null) {
+    const field = declared;
+    const register = field["register"];
+    if (typeof register === "string" && register !== "") {
+      return {
+        pkg,
+        register,
+        binding: field["returns"] === "handle" ? bindingNameFor(register) : null,
+        options: readOptionRefs(field["options"]),
+        source: "manifest"
+      };
+    }
+  }
+  const entry = entryFileOf(dir, pkg, manifest);
+  if (entry === null) return { unwired: "its package.json names no entry we could read" };
+  let names;
+  try {
+    const loaded = await import(pathToFileURL(entry).href);
+    names = Object.keys(loaded).filter(
+      (name) => /^register[A-Z]/.test(name) && typeof loaded[name] === "function"
+    );
+  } catch (error) {
+    return { unwired: `importing it failed (${error instanceof Error ? error.message : String(error)})` };
+  }
+  if (names.length === 0) {
+    return {
+      unwired: `it exports no register* function, and its package.json has no "xanots" field`
+    };
+  }
+  if (names.length > 1) {
+    return {
+      unwired: `it exports ${names.length} register* functions (${names.join(", ")}) \u2014 its package.json needs a "xanots" field naming the one to call`
+    };
+  }
+  return { pkg, register: names[0], binding: null, options: {}, source: "exports" };
+}
+function renderXanoIndexWithModules(appName, 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)) add(ref.package, ref.export);
+  }
+  const imports = [...byPackage].map(([pkg, names]) => `import { ${[...names].sort().join(", ")} } from "${pkg}";`).join("\n");
+  const calls = modules.map((m) => {
+    const entries = Object.entries(m.options);
+    const opts = entries.length === 0 ? "" : `, { ${entries.map(([name, ref]) => `${name}: ${ref.export}`).join(", ")} }`;
+    const call = `${m.register}(app${opts});`;
+    return m.binding === null ? call : `const ${m.binding} = ${call}`;
+  }).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 { workspace } from "@xanots/sdk";
+${imports}
+
+/**
+ * The ${appName} backend.
+ *
+ * A workspace is assembled by registering typed objects onto a workspace()
+ * instance and default-exporting it. The add-ons below were installed by
+ * \`xanots init --marketplace\` and registered for you.
+ *
+ * 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}");
+
+${calls}
+
+export default app;
+`;
+}
+function isPeerConflict(stderr) {
+  return /ERESOLVE|peer dep|peerinvalid/i.test(stderr);
+}
+async function installModules(dir, packages) {
+  const installed = [];
+  const failed = [];
+  const legacyPeer = [];
+  const registered = [];
+  const unwired = [];
+  for (const specifier of packages) {
+    step(`Adding ${specifier}`);
+    let result = runNpmCapturingStderr(["install", specifier], dir);
+    if (result.status !== 0 && isPeerConflict(result.stderr)) {
+      warn(
+        `${specifier} declares a peer range this CLI does not satisfy \u2014 retrying with --legacy-peer-deps.`
+      );
+      result = runNpmCapturingStderr(["install", specifier, "--legacy-peer-deps"], dir);
+      if (result.status === 0) legacyPeer.push(specifier);
+    }
+    if (result.status !== 0) {
+      failed.push(specifier);
+      warn(`npm install ${specifier} failed \u2014 the module was not added.`);
+      continue;
+    }
+    installed.push(specifier);
+    const pkg = packageNameOf(specifier);
+    const registration = await readRegistration(dir, pkg);
+    if ("unwired" in registration) unwired.push({ pkg, reason: registration.unwired });
+    else registered.push(registration);
+  }
+  const present = new Set(installed.map(packageNameOf));
+  const writable = [];
+  for (const registration of registered) {
+    const missing = Object.values(registration.options).map((ref) => ref.package).filter((pkg) => !present.has(pkg));
+    if (missing.length === 0) {
+      writable.push(registration);
+      continue;
+    }
+    unwired.push({
+      pkg: registration.pkg,
+      reason: `it needs ${[...new Set(missing)].join(", ")}, which this project does not have`
+    });
+  }
+  return { installed, failed, legacyPeer, registered: writable, unwired };
+}
 
 // src/emit/frontend-resolve.ts
 import { createInterface } from "readline/promises";
@@ -91,7 +292,7 @@ async function resolveFrontendPreset(flag) {
 
 // src/emit/theme-resolve.ts
 import { createInterface as createInterface2 } from "readline/promises";
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { resolve as resolvePath } from "path";
 function isRegistryRef(value) {
   return /^https?:\/\//i.test(value) || value.toLowerCase().endsWith(".json");
@@ -113,7 +314,7 @@ async function loadRegistryTheme(ref) {
   const path = resolvePath(ref);
   let text;
   try {
-    text = readFileSync(path, "utf8");
+    text = readFileSync2(path, "utf8");
   } catch (err) {
     throw new Error(
       `Could not read the theme file ${path}: ${err instanceof Error ? err.message : String(err)}`
@@ -280,6 +481,30 @@ async function runInitCommand(args) {
   if (presets.length > 0) {
     info(`AI instructions: ${presets.map(presetFilePath).join(", ")}`);
   }
+  const modules = parseMarketplaceFlag(args.marketplace);
+  if (modules.length > 0) {
+    blank();
+    const outcome = await installModules(targetDir, modules);
+    if (outcome.registered.length > 0) {
+      writeFileSync(
+        join2(targetDir, "xano", "index.ts"),
+        renderXanoIndexWithModules(appName, outcome.registered),
+        "utf8"
+      );
+      info(
+        `Registered in xano/index.ts: ${outcome.registered.map((m) => m.pkg).join(", ")}`
+      );
+    }
+    for (const module of outcome.unwired) {
+      warn(`${module.pkg} is installed but not registered \u2014 ${module.reason}.`);
+      detail(`Import it in xano/index.ts and register it onto the workspace yourself.`);
+    }
+    if (outcome.legacyPeer.length > 0) {
+      warn(
+        `Installed with --legacy-peer-deps: ${outcome.legacyPeer.join(", ")}. npm refused the tree on peer ranges, so this one is not the tree npm would build on its own.`
+      );
+    }
+  }
   blank();
   success("Project ready.");
   const cdHint = targetDir === process.cwd() ? "" : `  cd ${targetArg}
@@ -304,4 +529,4 @@ export {
   projectShellFiles,
   runInitCommand
 };
-//# sourceMappingURL=chunk-4HKZH6YK.js.map
+//# sourceMappingURL=chunk-EAIR6VUL.js.map

package/dist/chunk-ERQZFWIW.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-ERQZFWIW.js.map

package/dist/{chunk-TQUO2OXY.js → chunk-FN4OQT2J.js}

@@ -6,7 +6,7 @@ import {
   realtimeChannelGuid,
   realtimeServerRefName,
   resolveRealtimeServerRef
-} from "./chunk-U3G2UW65.js";
+} from "./chunk-CYJ7R3AD.js";
 import {
   assertCanonical,
   assertOneOf,
@@ -25,7 +25,7 @@ import {
   resolveAuthRef,
   resolveMockKeys,
   warnLiveDatasource
-} from "./chunk-5L4X5LS6.js";
+} from "./chunk-YUPQOLFX.js";
 import {
   encodeStatement
 } from "./chunk-5XZ744TS.js";
@@ -35,7 +35,7 @@ import {
   lockKey,
   realtimeMessageSeedName,
   resolveRef
-} from "./chunk-4HT3BNZ7.js";
+} from "./chunk-YUBJLB6G.js";
 
 // src/kinds/canonical.ts
 function resolveCanonicalToken(label, payloadKey, accessor, def, override) {
@@ -667,4 +667,4 @@ export {
   addonKind,
   addon
 };
-//# sourceMappingURL=chunk-TQUO2OXY.js.map
+//# sourceMappingURL=chunk-FN4OQT2J.js.map

package/dist/{chunk-FY6LXRR6.js → chunk-KGNJM4LN.js}

@@ -19,7 +19,7 @@ import {
   liveSubcommandNames,
   renderArgs,
   suggest
-} from "./chunk-QO4I5OYF.js";
+} from "./chunk-YYSJAAJM.js";
 
 // src/emit/help.ts
 function table(rows, s, indent = "  ", fixedWidth) {
@@ -245,4 +245,4 @@ export {
   reportFailure,
   exitCodeOf
 };
-//# sourceMappingURL=chunk-FY6LXRR6.js.map
+//# sourceMappingURL=chunk-KGNJM4LN.js.map

package/dist/{chunk-HJPTWBLH.js → chunk-MFIHIS6B.js}

@@ -4,7 +4,7 @@ import {
 import {
   parseLock,
   serializeLock
-} from "./chunk-4HT3BNZ7.js";
+} from "./chunk-YUBJLB6G.js";
 
 // src/lock/io.ts
 import { readFileSync, existsSync } from "fs";
@@ -35,4 +35,4 @@ export {
   readLockFile,
   writeLockFile
 };
-//# sourceMappingURL=chunk-HJPTWBLH.js.map
+//# sourceMappingURL=chunk-MFIHIS6B.js.map

package/dist/{chunk-F6JCFRKO.js → chunk-PXXLBXOP.js}

@@ -1,7 +1,7 @@
 import {
   c,
   resp
-} from "./chunk-5L4X5LS6.js";
+} from "./chunk-YUPQOLFX.js";
 
 // src/values/expect.ts
 var TEST_EXPECT_TYPES = [
@@ -90,4 +90,4 @@ export {
   TEST_EXPECT_TYPES,
   expect
 };
-//# sourceMappingURL=chunk-F6JCFRKO.js.map
+//# sourceMappingURL=chunk-PXXLBXOP.js.map