@xano/cli 1.0.6-beta.14 → 1.0.6-beta.16

package/README.md

@@ -323,6 +323,7 @@ xano function run <name> --data email=jo@x.com --data age:=30 --data active:=tru
 xano function run <name> --json @payload.json --data env=staging   # base payload + override
 echo '{"email":"jo@x.com"}' | xano function run <name> --stdin -o json | jq .result
 xano function run <name> --branch dev --logs            # run on a branch, show execution logs
+xano function run <name> --datasource test              # run against the 'test' data source
 ```
 
 Input flexibility for `function run` (assembled into one JSON `input` object):
@@ -335,6 +336,11 @@ Input flexibility for `function run` (assembled into one JSON `input` object):
 | `--json '<inline>'` / `--json @file.json` / `--json -` | a base JSON object (stdin with `-`) |
 | `--stdin` | read the JSON object from stdin (same as `--json -`) |
 
+`--datasource <label>` runs the function against a non-live data source by sending the
+`X-Data-Source` header, so table reads and writes hit that data source's tables. Omit it
+to run against `live`; an unknown label is rejected by the server with
+`Invalid data source.`
+
 Merge order is JSON base first, then `--data` overrides. Missing required inputs are
 prompted for on an interactive terminal; in a non-TTY (CI) context the command fails
 listing them. Output defaults to the raw `result` (`-o json`); the exit code is non-zero

package/dist/base-command.d.ts

@@ -15,6 +15,11 @@ export interface CredentialsFile {
     };
 }
 export declare function buildUserAgent(version: string): string;
+/**
+ * True when `error` is the "foreign dispatcher rejected by built-in fetch"
+ * failure (Node 26+). The real code lives on `error.cause.code`.
+ */
+export declare function isInvalidDispatcherError(error: unknown): boolean;
 export interface SandboxTenant {
     created_at?: string;
     description?: string;

package/dist/base-command.js

@@ -29,13 +29,46 @@ function resolveRequestTimeoutMs(env = process.env) {
         return DEFAULT_REQUEST_TIMEOUT_MS;
     return parsed;
 }
+/**
+ * Whether the built-in `fetch` on this runtime accepts a dispatcher built from
+ * our bundled userland `undici`. Node <= 24 accepts it; Node 26 rejects a
+ * foreign dispatcher with UND_ERR_INVALID_ARG, which `fetch` surfaces only as
+ * the generic "fetch failed" — breaking *every* command (DEV-7773).
+ *
+ * Starts optimistic (`true`); flipped to `false` the first time a request fails
+ * with UND_ERR_INVALID_ARG (see `verboseFetch`, which then retries without the
+ * dispatcher). Once flipped, every later request skips the dispatcher outright.
+ */
+let dispatcherSupported = true;
+/**
+ * True when `error` is the "foreign dispatcher rejected by built-in fetch"
+ * failure (Node 26+). The real code lives on `error.cause.code`.
+ */
+export function isInvalidDispatcherError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const { cause } = error;
+    const code = cause && typeof cause === 'object' && 'code' in cause
+        ? cause.code
+        : error.code;
+    return code === 'UND_ERR_INVALID_ARG';
+}
 /**
  * Lazily-built undici dispatcher whose header/body inactivity timeouts match our
  * request timeout, so undici's internal 300s default never fires first. Built
  * once and reused across requests. `timeout === 0` means "no bound".
+ *
+ * Returns `undefined` when this runtime has been found to reject a foreign
+ * dispatcher (Node 26+, DEV-7773). Dropping the dispatcher does NOT regress the
+ * large-push timeout: the per-request `AbortSignal.timeout(timeoutMs)` in
+ * `verboseFetch` already bounds the whole request (headers included) to the same
+ * 15-min ceiling the dispatcher enforced, so undici's hidden 300s
+ * `headersTimeout` is subsumed by it.
  */
 let sharedDispatcher;
 function getRequestDispatcher(timeoutMs) {
+    if (!dispatcherSupported)
+        return undefined;
     if (timeoutMs === 0) {
         sharedDispatcher ??= new Agent({ bodyTimeout: 0, headersTimeout: 0 });
         return sharedDispatcher;
@@ -324,15 +357,20 @@ export default class BaseCommand extends Command {
             ...options.headers,
         };
         const timeoutMs = resolveRequestTimeoutMs();
-        const fetchOptions = {
+        // Build the fetch options fresh each attempt: a retry needs a new
+        // AbortSignal (the first attempt's may already be aborted/consumed) and,
+        // when the dispatcher is the culprit, no dispatcher at all.
+        const buildFetchOptions = (withDispatcher) => ({
             ...options,
             // undici dispatcher: lifts the hidden 300s headers/body timeout to our bound
-            dispatcher: getRequestDispatcher(timeoutMs),
+            ...(withDispatcher ? { dispatcher: getRequestDispatcher(timeoutMs) } : {}),
             headers,
             // belt-and-suspenders hard ceiling that also covers DNS/connect stalls;
             // surfaces as a clean AbortError (see describeNetworkError). 0 = no bound.
+            // This alone bounds the whole request, so dropping the dispatcher (Node 26)
+            // does not lose the large-push timeout protection.
             ...(timeoutMs > 0 && !options.signal ? { signal: AbortSignal.timeout(timeoutMs) } : {}),
-        };
+        });
         const contentType = headers['Content-Type'] || 'application/json';
         if (verbose) {
             this.log('');
@@ -349,7 +387,26 @@ export default class BaseCommand extends Command {
             }
         }
         const startTime = Date.now();
-        const response = await fetch(url, fetchOptions);
+        let response;
+        try {
+            response = await fetch(url, buildFetchOptions(dispatcherSupported));
+        }
+        catch (error) {
+            // Node 26+ rejects our userland-undici dispatcher with UND_ERR_INVALID_ARG,
+            // surfaced only as "fetch failed" (DEV-7773). Disable it for the rest of the
+            // process and retry once without it; the AbortSignal.timeout ceiling above
+            // still bounds the request, so the large-push protection is preserved.
+            if (dispatcherSupported && isInvalidDispatcherError(error)) {
+                dispatcherSupported = false;
+                if (verbose) {
+                    this.log('  (this Node runtime rejected undici dispatcher; retrying without it — see DEV-7773)');
+                }
+                response = await fetch(url, buildFetchOptions(false));
+            }
+            else {
+                throw error;
+            }
+        }
         const elapsed = Date.now() - startTime;
         if (verbose) {
             this.log(`← ${response.status} ${response.statusText} (${elapsed}ms)`);

package/dist/commands/function/run/index.d.ts

@@ -8,6 +8,7 @@ export default class FunctionRun extends BaseCommand {
     static flags: {
         branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         data: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        datasource: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         logs: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/function/run/index.js

@@ -17,6 +17,8 @@ export default class FunctionRun extends BaseCommand {
         `$ xano function:run calcScore --json @payload.json --data env=staging`,
         `$ echo '{"email":"jo@x.com"}' | xano function:run calcScore --stdin -o json | jq .result`,
         `$ xano function:run calcScore --branch dev --logs`,
+        `$ xano function:run calcScore --datasource test
+# Runs against the 'test' data source instead of 'live'`,
     ];
     static flags = {
         ...BaseCommand.baseFlags,
@@ -30,6 +32,10 @@ export default class FunctionRun extends BaseCommand {
             multiple: true,
             required: false,
         }),
+        datasource: Flags.string({
+            description: 'Data source to run against, e.g. test (defaults to live)',
+            required: false,
+        }),
         json: Flags.string({
             description: "Input as a JSON object: inline, @file.json, or '-' for stdin",
             exclusive: ['stdin'],
@@ -106,13 +112,21 @@ export default class FunctionRun extends BaseCommand {
         const body = { input, name: functionName };
         if (branch)
             body.branch = branch;
+        const headers = {
+            'accept': 'application/json',
+            'Authorization': `Bearer ${profile.access_token}`,
+            'Content-Type': 'application/json',
+        };
+        // The Metadata API resolves the workspace's tables against the data source
+        // named by X-Data-Source (defaulting to `live`), so the run reads and writes
+        // the same tables a request carrying that header would. An unknown label is
+        // rejected server-side with "Invalid data source."
+        const dataSource = flags.datasource?.trim();
+        if (dataSource)
+            headers['X-Data-Source'] = dataSource;
         const response = await this.verboseFetch(apiUrl, {
             body: JSON.stringify(body),
-            headers: {
-                'accept': 'application/json',
-                'Authorization': `Bearer ${profile.access_token}`,
-                'Content-Type': 'application/json',
-            },
+            headers,
             method: 'POST',
         }, flags.verbose, profile.access_token);
         if (!response.ok) {

package/dist/utils/multidoc-push.js

@@ -904,6 +904,7 @@ export function describeNetworkError(error, url, elapsedMs) {
         ETIMEDOUT: `Connection to ${host} timed out. Check your network or VPN, then retry.`,
         UND_ERR_CONNECT_TIMEOUT: `Connection to ${host} timed out. Check your network or VPN, then retry.`,
         UND_ERR_HEADERS_TIMEOUT: `${host} accepted the connection but did not respond in time. The push may be too large; try splitting it or retrying.`,
+        UND_ERR_INVALID_ARG: `Your Node runtime rejected the CLI's HTTP dispatcher. Update the CLI, or run it under Node 24 (see DEV-7773).`,
     };
     let base;
     if (code && hints[code]) {