@xano/sdk 1.0.5 → 1.0.6

package/dist/{chunk-5D6DGF3W.js → chunk-JRVQ7M7W.js}

@@ -1,27 +1,27 @@
 import {
   BranchHttpError,
   BranchTakenError
-} from "./chunk-5RLAF6RL.js";
+} from "./chunk-NPODGBVJ.js";
 import {
   SourceError
-} from "./chunk-JXKO6JT7.js";
+} from "./chunk-3II44CUJ.js";
 import {
   ReleaseHttpError
-} from "./chunk-3BJYQGAZ.js";
+} from "./chunk-GWTFI3GA.js";
 import {
   ImportHttpError
-} from "./chunk-5XVBT6CQ.js";
+} from "./chunk-BL3AZ3AP.js";
 import {
   TenantHttpError
-} from "./chunk-4GDEEY2U.js";
+} from "./chunk-VW4CWVYX.js";
 import {
   TLS_CERTIFICATE_CODES,
   isTimeoutError,
   writeRefusedBy
-} from "./chunk-HLQH3AXB.js";
+} from "./chunk-YR2I5HGE.js";
 import {
   UsageError
-} from "./chunk-XNZURZ7T.js";
+} from "./chunk-D7BUMOKU.js";
 
 // src/emit/operation-outcome.ts
 var SettledWriteFailure = class extends Error {
@@ -82,4 +82,4 @@ export {
   SettledWriteFailure,
   classifyFailure
 };
-//# sourceMappingURL=chunk-5D6DGF3W.js.map
+//# sourceMappingURL=chunk-JRVQ7M7W.js.map

package/dist/{chunk-AESE434J.js → chunk-JXVJGF3Y.js}

@@ -6,7 +6,7 @@ import {
   UsageError,
   style,
   terminalText
-} from "./chunk-XNZURZ7T.js";
+} from "./chunk-D7BUMOKU.js";
 
 // src/emit/prompt.ts
 import { createInterface } from "readline";
@@ -174,4 +174,4 @@ export {
   STDIN_IDLE_MS,
   readStdin
 };
-//# sourceMappingURL=chunk-AESE434J.js.map
+//# sourceMappingURL=chunk-JXVJGF3Y.js.map

package/dist/chunk-KPFS3RGM.js

@@ -0,0 +1,257 @@
+import {
+  MANIFEST_HEADER,
+  ROUTES_MANIFEST_BASENAME,
+  RouteManifestError
+} from "./chunk-LBJA7IEM.js";
+import {
+  byCodeUnit
+} from "./chunk-WAVNUTMT.js";
+import {
+  blockPackages,
+  composeBlock,
+  findBlock
+} from "./chunk-3EDSPMXN.js";
+import {
+  UsageError,
+  detail,
+  info,
+  warn
+} from "./chunk-D7BUMOKU.js";
+
+// src/emit/routes-manifest-modules.ts
+var MODULE_DIALECT = {
+  begin: (pkg) => `// xanosdk:begin ${pkg}`,
+  end: (pkg) => `// xanosdk:end ${pkg}`,
+  stamp: (version) => `// xanosdk:version ${version} - generated; edits inside this block are overwritten`,
+  parseStamp: (block) => /^\/\/ xanosdk:version (\S+)/m.exec(block)?.[1] ?? null
+};
+var IMPORTS_LINE = "// xanosdk:imports ";
+var moduleSpec = (pkg) => ({ dialect: MODULE_DIALECT, pkg, file: ROUTES_MANIFEST_BASENAME });
+var BARE_SPECIFIER = /^(?:@[a-z0-9~][\w.~-]*\/)?[a-z0-9~][\w.~-]*(?:\/[\w.~@-]+)*$/i;
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+var STATIC_IMPORT = /^import(?:\s+type)?(?:\s*["'{*]|\s+[A-Za-z_$][\w$]*\s*(?:,|from\b))/;
+var RE_EXPORT = /^[ \t]*export\s+(?:type\s+)?(?:\*(?:\s+as\s+[A-Za-z_$][\w$]*)?|\{[^}]*\})\s*from\s*["']/m;
+var SDK_LOAD = /\b(?:import|require)\s*\(\s*["'`]@xano\/sdk(?:\/|["'`])/;
+function checkModuleSection(pkg, section) {
+  const refuse = (why) => {
+    throw new RouteManifestError(`${pkg}: its routes.gen.ts section ${why}`);
+  };
+  if (section === null || typeof section !== "object") return refuse("is not an object with a `source` string.");
+  if (typeof section.then === "function") {
+    return refuse("is a Promise. `routesManifest` must be synchronous: every writer of the file has to produce the same bytes, and the decode paths write it synchronously.");
+  }
+  const { source, imports } = section;
+  if (typeof source !== "string") return refuse("has no `source` string.");
+  const lines = source.split(/\r?\n/);
+  const trimmed = lines.map((line) => line.trim());
+  const markers = [MODULE_DIALECT.begin("").trim(), MODULE_DIALECT.end("").trim()];
+  const forged = trimmed.find((line) => markers.some((marker) => line.startsWith(marker)));
+  if (forged !== void 0) {
+    return refuse(`has a line that spells a block marker (${forged}); the file's blocks are found by counting them.`);
+  }
+  const first = lines.find((line) => line.trim() !== "");
+  if (first?.startsWith(IMPORTS_LINE)) {
+    return refuse(`starts with a line that spells the block's imports line (${first.trim()}); declare imports in \`imports\`.`);
+  }
+  const written = trimmed.find((line) => STATIC_IMPORT.test(line) || SDK_LOAD.test(line)) ?? RE_EXPORT.exec(source)?.[0].trim().split(/\r?\n/)[0];
+  if (written !== void 0) {
+    return refuse(`writes an import in its source (${written}); declare imports in \`imports\`.`);
+  }
+  if (imports !== void 0 && !Array.isArray(imports)) return refuse("has `imports` that is not an array.");
+  const merged = /* @__PURE__ */ new Map();
+  for (const entry of imports ?? []) {
+    const { from, names } = entry ?? {};
+    if (typeof from !== "string") return refuse("declares an import with no `from` string.");
+    if (from === "@xano/sdk" || from.startsWith("@xano/sdk/")) {
+      return refuse(
+        `imports from ${JSON.stringify(from)}. The manifest exists so a frontend can skip the SDK runtime; a module section may not import it.`
+      );
+    }
+    if (!BARE_SPECIFIER.test(from) || from.split("/").some((part) => part === "." || part === "..")) {
+      return refuse(
+        `imports from ${JSON.stringify(from)}, which is not a bare package specifier. A relative or absolute path resolves against wherever the file is written, and a protocol is not a package the project depends on.`
+      );
+    }
+    if (!Array.isArray(names) || names.length === 0) return refuse(`imports nothing by name from ${JSON.stringify(from)}.`);
+    for (const name of names) {
+      if (typeof name !== "string" || !IDENTIFIER.test(name)) {
+        return refuse(`imports ${JSON.stringify(name)} from ${JSON.stringify(from)}, which is not a plain identifier.`);
+      }
+      merged.set(from, (merged.get(from) ?? /* @__PURE__ */ new Set()).add(name));
+    }
+  }
+  return [...merged].sort(([a], [b]) => byCodeUnit(a, b)).map(([from, names]) => ({ from, names: [...names].sort(byCodeUnit) }));
+}
+function composeRoutesManifest(core, modules) {
+  if (!core.startsWith(MANIFEST_HEADER)) {
+    throw new RouteManifestError("composeRoutesManifest: `core` is not a rendered route manifest.");
+  }
+  const imports = /* @__PURE__ */ new Map();
+  const blocks = [];
+  let previous;
+  for (const { pkg, version, section } of [...modules].sort((a, b) => byCodeUnit(a.pkg, b.pkg))) {
+    if (pkg === previous) {
+      throw new RouteManifestError(`${pkg}: two routes.gen.ts sections for one module; a module contributes one.`);
+    }
+    previous = pkg;
+    const own = checkModuleSection(pkg, section);
+    if (section.source.trim() === "") continue;
+    for (const { from, names } of own) {
+      for (const name of names) imports.set(from, (imports.get(from) ?? /* @__PURE__ */ new Set()).add(name));
+    }
+    const lines = own.length > 0 ? [`${IMPORTS_LINE}${JSON.stringify(own)}`, section.source] : [section.source];
+    try {
+      blocks.push(composeBlock(moduleSpec(pkg), lines, version));
+    } catch (error) {
+      throw new RouteManifestError(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (blocks.length === 0) return core;
+  const importLines = [...imports].sort(([a], [b]) => byCodeUnit(a, b)).map(([from, names]) => `import { ${[...names].sort(byCodeUnit).join(", ")} } from ${JSON.stringify(from)};
+`);
+  return `${MANIFEST_HEADER}${importLines.join("")}${core.slice(MANIFEST_HEADER.length)}${blocks.map((b) => `
+${b}
+`).join("")}`;
+}
+function parseModuleSections(text, only) {
+  return blockPackages(text, MODULE_DIALECT).filter((pkg) => only === void 0 || only.has(pkg)).sort(byCodeUnit).map((pkg) => {
+    const fail = (why) => {
+      throw new RouteManifestError(
+        `${pkg}: its block in ${ROUTES_MANIFEST_BASENAME} ${why} Repair or delete the block by hand, then regenerate the file.`
+      );
+    };
+    let span;
+    try {
+      span = findBlock(text, moduleSpec(pkg));
+    } catch (error) {
+      return fail(`cannot be read: ${error instanceof Error ? error.message : String(error)}.`);
+    }
+    const lines = span.text.split(/\r?\n/);
+    const version = MODULE_DIALECT.parseStamp(lines[1] ?? "");
+    if (version === null || lines[2] !== "") return fail("has no version stamp under its begin marker.");
+    let body = lines.slice(3, -1);
+    let imports;
+    if (body[0]?.startsWith(IMPORTS_LINE)) {
+      try {
+        imports = JSON.parse(body[0].slice(IMPORTS_LINE.length));
+      } catch {
+        return fail("has an imports line that is not valid JSON.");
+      }
+      body = body.slice(1);
+    }
+    const section = { ...imports === void 0 ? {} : { imports }, source: body.join("\n") };
+    checkModuleSection(pkg, section);
+    return { pkg, version, section };
+  });
+}
+
+// src/emit/toolchain-hooks.ts
+function redactEnvValues(payload) {
+  const env = payload["env"];
+  if (!Array.isArray(env)) return payload;
+  return {
+    ...payload,
+    env: env.map(
+      (entry) => typeof entry === "object" && entry !== null && "value" in entry ? { ...entry, value: "" } : entry
+    )
+  };
+}
+function report(pkg, result) {
+  if (result.message !== void 0 && result.message !== "") {
+    if (result.failed === true) warn(`${pkg} \u2014 ${result.message}`, "toolchain.failed");
+    else info(result.message);
+  }
+  for (const line of result.warnings ?? []) detail(line);
+}
+function handleThrow(pkg, error, frozen) {
+  const why = error instanceof Error ? error.message : String(error);
+  if (frozen) {
+    throw new UsageError(
+      `${pkg} failed while checking this bundle, so whatever it verifies was not verified \u2014 and this run was asked to verify, not to write:
+  ${why}`
+    );
+  }
+  warn(`${pkg} failed and was skipped.`, "toolchain.failed", [why]);
+}
+async function fireOnBundle(plugins, ctx) {
+  let failed = false;
+  const bundle = { ...ctx.bundle, payload: redactEnvValues(ctx.bundle.payload) };
+  for (const { pkg, plugin, config } of plugins) {
+    if (plugin.onBundle === void 0) continue;
+    try {
+      const result = await plugin.onBundle({ ...ctx, bundle, config });
+      report(pkg, result);
+      if (result.failed === true) failed = true;
+    } catch (error) {
+      handleThrow(pkg, error, ctx.frozen);
+    }
+  }
+  return { failed };
+}
+async function fireOnPreflight(plugins, ctx) {
+  let failed = false;
+  const payloads = {
+    exportedPayload: redactEnvValues(ctx.exportedPayload),
+    remappedPayload: redactEnvValues(ctx.remappedPayload)
+  };
+  for (const { pkg, plugin, config } of plugins) {
+    if (plugin.onPreflight === void 0) continue;
+    try {
+      const result = await plugin.onPreflight({ ...ctx, ...payloads, config });
+      report(pkg, result);
+      if (result.failed === true) failed = true;
+    } catch (error) {
+      const why = error instanceof Error ? error.message : String(error);
+      warn(`${pkg} could not complete its check.`, "toolchain.failed", [why]);
+      failed = true;
+    }
+  }
+  return { failed };
+}
+async function runBundleHooks(plugins, ctx, consequence) {
+  if (plugins.length === 0) return;
+  const outcome = await fireOnBundle(plugins, ctx);
+  if (outcome.failed) {
+    throw new UsageError(
+      `A toolchain module reported that its check did not pass${consequence}. See the report above.`
+    );
+  }
+}
+function fireRoutesManifest(plugins, ctx) {
+  const results = [];
+  for (const { pkg, version, plugin, config } of [...plugins].sort((a, b) => byCodeUnit(a.pkg, b.pkg))) {
+    if (plugin.routesManifest === void 0) continue;
+    try {
+      const section = plugin.routesManifest({ ...ctx, config });
+      if (typeof section?.then === "function") {
+        Promise.resolve(section).catch(() => {
+        });
+      }
+      const imports = checkModuleSection(pkg, section);
+      results.push({
+        kind: "section",
+        pkg,
+        version,
+        section: { ...imports.length > 0 ? { imports } : {}, source: section.source }
+      });
+    } catch (error) {
+      results.push({ kind: "failed", pkg, version, why: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return results;
+}
+function anyDeclares(plugins, hook) {
+  return plugins.some((p) => p.plugin[hook] !== void 0);
+}
+
+export {
+  composeRoutesManifest,
+  parseModuleSections,
+  redactEnvValues,
+  fireOnBundle,
+  fireOnPreflight,
+  runBundleHooks,
+  fireRoutesManifest,
+  anyDeclares
+};
+//# sourceMappingURL=chunk-KPFS3RGM.js.map

package/dist/{chunk-SNGFEESM.js → chunk-LAOMN6QQ.js}

@@ -1,6 +1,6 @@
 import {
   classifyFailure
-} from "./chunk-5D6DGF3W.js";
+} from "./chunk-JRVQ7M7W.js";
 import {
   describeWrite
 } from "./chunk-4KHEMC32.js";
@@ -14,7 +14,7 @@ import {
   warn,
   writeJson,
   writeTargetPayload
-} from "./chunk-XNZURZ7T.js";
+} from "./chunk-D7BUMOKU.js";
 
 // src/emit/operation-result.ts
 var SERVER_PROCESSING_BOUND_MS = 6e5;
@@ -253,4 +253,4 @@ export {
   OperationError,
   runOperation
 };
-//# sourceMappingURL=chunk-SNGFEESM.js.map
+//# sourceMappingURL=chunk-LAOMN6QQ.js.map