@xano/sdk 1.0.0

package/dist/preflight-command-2T5Z36MI.js

@@ -0,0 +1,321 @@
+import {
+  describeRuntimeFailure,
+  runtimeErrorMessage
+} from "./chunk-6KEB3C3U.js";
+import {
+  sectionKind
+} from "./chunk-45UIT5T2.js";
+import "./chunk-HRVBLCVJ.js";
+import {
+  assertBundleFile,
+  assertBundleInput,
+  assertEntryFile,
+  loadBundleText,
+  refuseValueFlagsBesideBundle
+} from "./chunk-ETO6LGLD.js";
+import "./chunk-ZIY7RNUT.js";
+import "./chunk-DAD3ONIS.js";
+import "./chunk-HHN734BU.js";
+import "./chunk-LPECSJ2J.js";
+import "./chunk-6NNTNXN7.js";
+import "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import "./chunk-ET4Y4XCB.js";
+import "./chunk-SWBF2LTK.js";
+import "./chunk-UZ6QQWJT.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-3M4LFYNQ.js";
+import "./chunk-AM4FKL4J.js";
+import "./chunk-Q325JKYB.js";
+import "./chunk-STSFNCY4.js";
+import "./chunk-I4F5TCJH.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import "./chunk-NAQDMEHV.js";
+import "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-U64O2MXY.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-P2HAGF6H.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-OPHB5ORL.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import "./chunk-JGE7CAWB.js";
+import {
+  UsageError,
+  blank,
+  detail,
+  error,
+  info,
+  isMachineOutput,
+  step,
+  success,
+  warn,
+  writeJson
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-MXHSQOC4.js";
+import "./chunk-6IUMKYWI.js";
+import "./chunk-2CMJZDCL.js";
+import "./chunk-CTMO46PK.js";
+import "./chunk-ZDPP6RKB.js";
+import "./chunk-K5BBGTYZ.js";
+import "./chunk-LQCMKAJ7.js";
+import "./chunk-YGZHHAAB.js";
+import "./chunk-XVBGLISP.js";
+import "./chunk-6HO3NCSJ.js";
+import "./chunk-5V5XU32D.js";
+import "./chunk-GSGDWJB5.js";
+import "./chunk-HVRUQXGD.js";
+import "./chunk-ERVIASGL.js";
+import "./chunk-4POWHT2K.js";
+import "./chunk-H2V3N23D.js";
+import "./chunk-3JDU4VRL.js";
+import "./chunk-WTPZRR4I.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-AKNCFVKZ.js";
+import "./chunk-YU4HSQW7.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-L5JYN3NM.js";
+import "./chunk-G554NZNI.js";
+import "./chunk-N5GKCWE5.js";
+import "./chunk-OXA6PSZT.js";
+import "./chunk-VAX3UZOY.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-TTEIYD5P.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/preflight-command.ts
+var EXIT_VALIDATION_FAILED = 2;
+async function runPreflightCommand(args) {
+  assertBundleInput(args, { command: "preflight" });
+  refuseValueFlagsBesideBundle(args, { command: "preflight" });
+  assertBundleFile(args, { command: "preflight" });
+  assertEntryFile(args);
+  if (args.out !== void 0 && !args.capture) {
+    throw new UsageError("`xanosdk preflight --out` names the directory `--capture` writes its fixtures to \u2014 add `--capture`, or drop `--out`.", {
+      helpFor: { command: "preflight" }
+    });
+  }
+  const { resolveValidateConfig, envNamesValidateTarget, verifyToken } = await import("./config-MBYGCAFK.js");
+  const { MetaClient } = await import("./meta-client-YXGPW53C.js");
+  const fromEnv = envNamesValidateTarget(args.instance);
+  if (fromEnv) refuseCredentialFlagsDisplacedByEnv(args);
+  const credential = fromEnv ? void 0 : await (await import("./token-NICJUTMT.js")).getAccessToken(args);
+  const config = credential === void 0 ? resolveValidateConfig({ instance: args.instance }) : validateTargetOf(credential);
+  const host = new URL(config.instance).host;
+  let who;
+  try {
+    who = await verifyToken(config, fromEnv ? "env" : "credential");
+  } catch (err) {
+    const { unansweredRead } = await import("./source-resolve-S2XA3XZF.js");
+    throw unansweredRead(err, "check the credential", "workspace");
+  }
+  step(`Validating against ${host}${who.name ? ` (as ${who.name})` : ""}`);
+  const { discoverToolchainPlugins } = await import("./toolchain-modules-5EAZUONB.js");
+  const toolchain = await discoverToolchainPlugins(process.cwd(), { frozen: true });
+  const { bundle } = await loadBundleText(args, { command: "preflight" });
+  const client = new MetaClient(config);
+  try {
+    await validateWithClient(args, client, bundle, toolchain.loaded, credential);
+  } finally {
+    const teardown = await client.dispose();
+    if (teardown.error !== void 0) {
+      warn(
+        "Could not delete the validation environment; it will expire on its own:",
+        "preflight.teardown-failed",
+        [teardown.error]
+      );
+    }
+  }
+}
+function refuseCredentialFlagsDisplacedByEnv(args) {
+  if (args.profile === void 0) return;
+  throw new UsageError(
+    `\`--profile ${args.profile}\` selects a stored credential, but this run targets the instance named by XANO_VALIDATE_INSTANCE / --instance, which carries its own token \u2014 there is no profile for it to select. Unset the XANO_VALIDATE_* variables (and drop \`--instance\`) to validate as profile "${args.profile}", or drop \`--profile\`.`,
+    { helpFor: { command: "preflight" } }
+  );
+}
+function validateTargetOf(auth) {
+  return { instance: auth.instance, token: auth.access_token, workspaceId: auth.workspaceId };
+}
+async function validateWithClient(args, client, bundle, plugins, credential) {
+  const { runValidateLoop, runnableFunctionNames } = await import("./loop-ALIZLOSX.js");
+  const { anyDeclares } = await import("./toolchain-hooks-GHKLUJOH.js");
+  const wantsPluginInputs = anyDeclares(plugins, "onPreflight");
+  const result = await runValidateLoop(client, bundle, {
+    includeEngineRendering: wantsPluginInputs
+  });
+  const report = (passed, runtime2, captured2) => {
+    if (!isMachineOutput(args)) return;
+    writeJson({
+      passed,
+      accepted: result.accepted,
+      importError: result.importError ?? null,
+      workspaceId: result.workspaceId ?? null,
+      // The SDK's kind names, not the payload's storage keys: an author wrote a
+      // `table`, never a `dbo`.
+      roundTrip: result.roundTrip.map(({ sdkKind, name, label, status, diffs }) => ({
+        kind: sdkKind,
+        name,
+        label,
+        status,
+        diffs
+      })),
+      unchecked: result.unchecked.map(({ kind, count }) => ({ kind: sectionKind(kind), count })),
+      // The raw run body is `--verbose` only, as in the human view: a success
+      // can carry live row data, and a failure carries the engine's whole debug
+      // structure (internal keys, a value store) that nothing outside it reads.
+      // A failure's `error` is the one line out of it a caller acts on.
+      runtime: args.verbose ? runtime2 : runtime2?.map((e) => runtimeSummary(e)) ?? null,
+      captured: captured2
+    });
+  };
+  if (!result.accepted) {
+    if (credential !== void 0) {
+      const { refuseUnreachableWorkspace } = await import("./workspace-binding-56PIIPCP.js");
+      await refuseUnreachableWorkspace(credential);
+    }
+    warn("Import rejected by the engine:", "preflight.import-rejected", [result.importError ?? "(no message)"]);
+    process.exitCode = EXIT_VALIDATION_FAILED;
+    report(false, null, null);
+    return;
+  }
+  success(`Import accepted (workspace #${result.workspaceId ?? "?"})`);
+  let failed = false;
+  for (const entry of result.roundTrip) {
+    if (entry.status === "match") {
+      success(`round-trip ${entry.label}`);
+    } else if (entry.status === "missing") {
+      warn(`round-trip ? ${entry.label} \u2014 not found in the imported workspace`, "preflight.roundtrip");
+      failed = true;
+    } else if (entry.status === "ambiguous") {
+      warn(`round-trip ? ${entry.label} \u2014 multiple imported objects share its identity`, "preflight.roundtrip");
+      failed = true;
+    } else {
+      const shown = args.verbose ? entry.diffs : entry.diffs.slice(0, 10);
+      warn(
+        `round-trip \u2717 ${entry.label} \u2014 ${entry.diffs.length} field diff${entry.diffs.length === 1 ? "" : "s"}`,
+        "preflight.roundtrip",
+        [
+          ...shown.map((d) => `${d.path}: expected ${fmt(d.expected)}, got ${fmt(d.actual)}`),
+          ...!args.verbose && entry.diffs.length > shown.length ? [`\u2026 ${entry.diffs.length - shown.length} more (run with --verbose)`] : []
+        ]
+      );
+      failed = true;
+    }
+  }
+  for (const u of result.unchecked) {
+    info(`imported ${u.count} ${sectionKind(u.kind)} object${u.count === 1 ? "" : "s"} \u2014 round-trip not checked`);
+  }
+  if (wantsPluginInputs && result.engineComparison === void 0) {
+    warn(
+      "A toolchain module's check could not run: the engine comparison was unavailable.",
+      "preflight.check-unavailable",
+      ["preflight imported the bundle but could not read the workspace back to compare against."]
+    );
+    failed = true;
+  } else if (wantsPluginInputs && result.engineComparison !== void 0) {
+    const { fireOnPreflight } = await import("./toolchain-hooks-GHKLUJOH.js");
+    const { readVersion } = await import("./cli.js");
+    const outcome = await fireOnPreflight(plugins, {
+      engineRendering: result.engineComparison.engineRendering,
+      exportedPayload: result.engineComparison.exportedPayload,
+      remappedPayload: result.engineComparison.remappedPayload,
+      verbose: args.verbose === true,
+      cwd: process.cwd(),
+      sdkVersion: readVersion()
+    });
+    if (outcome.failed) failed = true;
+  }
+  let runtime = null;
+  if (args.runtime && result.workspaceId !== void 0) {
+    const names = runnableFunctionNames(result.roundTrip);
+    if (names.length > 0) {
+      const { smokeRunFunctions, functionsWithInputs } = await import("./runtime-XETHVF33.js");
+      blank();
+      const entries = await smokeRunFunctions(client, result.workspaceId, names, {}, functionsWithInputs(JSON.parse(bundle)));
+      runtime = entries;
+      for (const e of entries) {
+        if (e.needsInputs) {
+          const why = runtimeErrorMessage(e.detail);
+          info(`runtime \u2013 ${e.name} not run: it needs inputs${why !== void 0 ? ` (${why})` : ""}`);
+          if (args.verbose) detail(fmt(e.detail));
+        } else if (e.ran) {
+          success(`runtime ${e.name}`);
+          if (args.verbose) detail(fmt(e.detail));
+        } else {
+          warn(`runtime \u2717 ${e.name} (${describeRuntimeFailure(e)})`, "preflight.runtime", args.verbose ? [fmt(e.detail)] : []);
+          failed = true;
+        }
+      }
+    }
+  }
+  let captured = null;
+  if (args.capture) {
+    const { captureFixtures } = await import("./capture-WAXPD7DR.js");
+    const written = captureFixtures(result.roundTrip, args.out);
+    captured = written;
+    if (written.length === 0) warn("nothing to capture (no objects round-tripped)", "preflight.nothing-captured");
+    for (const w of written) detail(`captured ${w.name} \u2192 ${w.path}`);
+  }
+  if (failed) {
+    process.exitCode = EXIT_VALIDATION_FAILED;
+    blank();
+    error("Validation failed");
+  } else {
+    blank();
+    success("Validation passed");
+  }
+  report(!failed, runtime, captured);
+}
+function runtimeSummary(e) {
+  const head = { name: e.name, ran: e.ran, status: e.status, ...e.needsInputs ? { needsInputs: true } : {} };
+  return e.ran ? head : { ...head, error: runtimeErrorMessage(e.detail) ?? null };
+}
+function fmt(v) {
+  if (typeof v === "string") return JSON.stringify(v);
+  if (v === void 0) return "(absent)";
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+export {
+  runPreflightCommand
+};
+//# sourceMappingURL=preflight-command-2T5Z36MI.js.map