windmill-client 1.773.0 → 1.774.0

package/dist/index.js

@@ -126,7 +126,7 @@ const OpenAPI = {
 	PASSWORD: void 0,
 	TOKEN: getEnv$1("WM_TOKEN"),
 	USERNAME: void 0,
-	VERSION: "1.773.0",
+	VERSION: "1.774.0",
 	WITH_CREDENTIALS: true,
 	interceptors: {
 		request: new Interceptors(),
@@ -2761,6 +2761,24 @@ var WorkspaceService = class {
 		});
 	}
 	/**
+	* check what the data table's database lets its role do
+	* @param data The data for the request.
+	* @param data.workspace
+	* @param data.datatableName
+	* @returns unknown connection and privilege report
+	* @throws ApiError
+	*/
+	static testDataTableConnection(data) {
+		return request(OpenAPI, {
+			method: "GET",
+			url: "/w/{workspace}/workspaces/test_datatable_connection/{datatable_name}",
+			path: {
+				workspace: data.workspace,
+				datatable_name: data.datatableName
+			}
+		});
+	}
+	/**
 	* list tables of all connected Datatables
 	* @param data The data for the request.
 	* @param data.workspace
@@ -9582,6 +9600,30 @@ var JobService = class {
 		});
 	}
 	/**
+	* get statuses and truncated results for all jobs of a flow job's execution tree
+	* @param data The data for the request.
+	* @param data.workspace
+	* @param data.id
+	* @param data.maxResultLen per-entry cap (in characters of JSON text) on result_prefix (default 2000, max 30000)
+	* @param data.step step address to resolve to a single job instead of enumerating the tree: "b", "b/c", "b[12]" (1-based iteration/branch), composable as "b[12]/c"
+	* @returns unknown per-job statuses and truncated results of the flow's execution tree, or the single resolved entry when step is provided
+	* @throws ApiError
+	*/
+	static getFlowAllResults(data) {
+		return request(OpenAPI, {
+			method: "GET",
+			url: "/w/{workspace}/jobs_u/get_flow_all_results/{id}",
+			path: {
+				workspace: data.workspace,
+				id: data.id
+			},
+			query: {
+				max_result_len: data.maxResultLen,
+				step: data.step
+			}
+		});
+	}
+	/**
 	* get completed job logs tail
 	* @param data The data for the request.
 	* @param data.workspace
@@ -16453,6 +16495,108 @@ var HubPublishService = class {
 	}
 };
 
+//#endregion
+//#region src/wacError.ts
+/** Error properties the executors already report as named fields, so they must
+*  not be repeated inside `extra`. Kept identical to the skip-list in the
+*  generated bun/deno job wrappers. */
+const SERIALIZED_ERROR_FIELDS = [
+	"line",
+	"name",
+	"stack",
+	"column",
+	"message",
+	"sourceURL",
+	"originalLine",
+	"originalColumn"
+];
+/** Read a property off a value that may fight back: a proxy `get` trap or a
+*  throwing accessor turns an ordinary field read into an exception. Callers
+*  are on the failure-reporting path, where nothing has been checkpointed yet. */
+function safeRead(o, k) {
+	try {
+		return o?.[k];
+	} catch {
+		return void 0;
+	}
+}
+/** @internal
+*  Whether a caught value is the SDK's own suspend signal, which must be
+*  rethrown rather than reported as a step failure.
+*
+*  Both halves of the check can throw on a hostile value: `instanceof` consults
+*  a proxy's `getPrototypeOf` trap, and reading `.name` its `get` trap. This
+*  runs before anything has been checkpointed, so neither may escape — a value
+*  that fights back is simply not a suspend. */
+function isSuspendSignal(e, suspendCtor) {
+	try {
+		if (e instanceof suspendCtor) return true;
+	} catch {}
+	return safeRead(e, "name") === "StepSuspend";
+}
+/** @internal
+*  Serialize a failed `step()` body into the `__wmill_error` marker that task
+*  failures also use, so it can be stored in `completed_steps`.
+*
+*  The record's final shape is decided by the backend (`wac_failure_record`),
+*  which normalizes task failures through the same function; what is built here
+*  is the raw material plus the envelope the backend recognizes. */
+function stepErrorMarker(key, e) {
+	const thrown = e;
+	const rawName = safeRead(thrown, "name");
+	const rawMessage = safeRead(thrown, "message");
+	const rawStack = safeRead(thrown, "stack");
+	const name = typeof rawName === "string" ? rawName : void 0;
+	const message = typeof rawMessage === "string" ? rawMessage : void 0;
+	const stack = typeof rawStack === "string" ? rawStack : void 0;
+	const error = {};
+	if (name) error.name = name;
+	if (message !== void 0) error.message = message;
+	if (stack) error.stack = stack;
+	if (thrown !== null && typeof thrown === "object") {
+		const extra = {};
+		let keys = [];
+		try {
+			keys = Object.getOwnPropertyNames(thrown);
+		} catch {
+			keys = [];
+		}
+		for (const k of keys) {
+			if (SERIALIZED_ERROR_FIELDS.includes(k)) continue;
+			try {
+				extra[k] = JSON.parse(JSON.stringify(thrown[k]));
+			} catch {}
+		}
+		if (Object.keys(extra).length > 0) error.extra = extra;
+	}
+	let fallback;
+	try {
+		fallback = String(e);
+	} catch {
+		fallback = `unrepresentable ${typeof e} thrown`;
+	}
+	return {
+		__wmill_error: true,
+		message: message ?? fallback,
+		step_key: key,
+		result: { error }
+	};
+}
+/** @internal
+*  Rebuild the error a failed task or step throws. The run that produced the
+*  failure and every later replay go through here: a catch is control flow,
+*  `workflow()` re-runs its body from the top every round, so a handler that
+*  branches on the failure it caught must be handed the same thing in every
+*  round or it dispatches different tasks on the way back. */
+function taskErrorFromMarker(marker, fallbackMessage) {
+	const err = new Error(marker?.message || fallbackMessage);
+	err.name = "TaskError";
+	err.result = marker?.result;
+	err.step_key = marker?.step_key;
+	err.child_job_id = marker?.child_job_id;
+	return err;
+}
+
 //#endregion
 //#region src/s3Types.ts
 /**
@@ -17786,31 +17930,24 @@ var StepSuspend = class extends Error {
 		this.name = "StepSuspend";
 	}
 };
-/** Serialize a failed `step()` body into the `__wmill_error` marker that task
-*  failures also use, so it can be stored in `completed_steps`. */
-function stepErrorMarker(key, e) {
-	const message = e instanceof Error ? e.message : String(e);
-	const type = e instanceof Error ? e.constructor?.name ?? e.name : typeof e;
-	return {
-		__wmill_error: true,
-		message,
-		step_key: key,
-		result: {
-			error: message,
-			type
-		}
-	};
+/** Encode a checkpoint payload the way the worker wrapper does on the suspend
+*  path, so both arms record the same value for the same step. `undefined` maps
+*  to null; a bigint to its digits, which the wrapper gets instead from the
+*  `BigInt.prototype.toJSON` it installs and the SDK cannot count on. */
+function encodeCheckpointPayload(payload) {
+	return JSON.stringify(payload, (_key, value) => typeof value === "undefined" ? null : typeof value === "bigint" ? value.toString() : value);
 }
-/** Rebuild the error a failed step throws. Both the run that produced the
-*  failure and every later replay go through here, so a workflow's catch block
-*  sees the same shape either way. */
-function stepErrorFromMarker(marker, name) {
-	const err = new Error(marker?.message || `Step '${name}' failed`);
-	err.name = "TaskError";
-	err.result = marker?.result;
-	err.step_key = marker?.step_key;
-	err.child_job_id = marker?.child_job_id;
-	return err;
+/** A whole result that `JSON.stringify` drops the key for leaves a checkpoint
+*  with no `result`, which neither the endpoint nor `WacOutput` accepts. Only
+*  the top level: nested, a dropped key is what every other bun path does. */
+function checkpointableResult(value) {
+	return typeof value === "function" || typeof value === "symbol" ? null : value;
+}
+/** Put a value through the checkpoint's encoding without checkpointing it, so
+*  the paths that never persist anything still hand back the shape the ones
+*  that do would. */
+function jsonRoundTrip(value) {
+	return JSON.parse(encodeCheckpointPayload({ value: checkpointableResult(value) })).value;
 }
 /** A step key travels as one path segment when its URLs are minted, so it must be
 *  non-empty and free of `/` and dot segments — otherwise `waitForApproval` would
@@ -17838,6 +17975,11 @@ var WorkflowCtx = class {
 	*  `complete` whose step never reached `completed_steps`. Python is immune:
 	*  `_StepSuspend` derives from `BaseException`. */
 	_pendingSuspend = null;
+	/** The failure raised by the step this child round is executing. That exception
+	*  *is* the round's result, so a `catch` in the body must not be able to turn it
+	*  into a `complete` — the parent would then record the caught branch's value as
+	*  a successful step. Boxed: the thrown value may be any falsy value. */
+	_pendingStepFailure = null;
 	/** When set, the task matching this key executes its inner function directly */
 	_executingKey;
 	/** Serializes fast-path POSTs across concurrent step() calls within one
@@ -17870,16 +18012,12 @@ var WorkflowCtx = class {
 		return key;
 	}
 	_nextStep(name, script, args = {}, dispatch_type = "inline", options) {
-		this._rethrowSwallowedSuspend();
+		this._rethrowSwallowed();
 		const key = this._allocKey(name || script || "step");
 		if (key in this.completed) {
 			const value = this.completed[key];
 			if (value && typeof value === "object" && value.__wmill_error) {
-				const err = new Error(value.message || `Task '${name}' failed`);
-				err.name = "TaskError";
-				err.result = value.result;
-				err.step_key = value.step_key;
-				err.child_job_id = value.child_job_id;
+				const err = taskErrorFromMarker(value, `Task '${name}' failed`);
 				return { then: (_resolve, reject) => {
 					if (reject) reject(err);
 					else throw err;
@@ -17929,7 +18067,7 @@ var WorkflowCtx = class {
 		return steps;
 	}
 	_waitForApproval(options) {
-		this._rethrowSwallowedSuspend();
+		this._rethrowSwallowed();
 		if (options?.key !== void 0) assertUsableStepKey(options.key, "waitForApproval key");
 		const key = this._allocKey(options?.key || "approval");
 		if (options?.key && key !== options.key) throw new Error(`WAC step key "${options.key}" is already used in this workflow. Give each waitForApproval() its own key so getApprovalUrls() can address it.`);
@@ -17949,7 +18087,7 @@ var WorkflowCtx = class {
 		});
 	}
 	_sleep(seconds) {
-		this._rethrowSwallowedSuspend();
+		this._rethrowSwallowed();
 		const key = this._allocKey("sleep");
 		if (key in this.completed) return { then: (resolve$1) => resolve$1(void 0) };
 		if (this._executingKey !== null) return { then: () => new Promise(() => {}) };
@@ -17962,11 +18100,11 @@ var WorkflowCtx = class {
 		});
 	}
 	async _runInlineStep(name, fn) {
-		this._rethrowSwallowedSuspend();
+		this._rethrowSwallowed();
 		const key = this._allocKey(name || "step");
 		if (key in this.completed) {
 			const value = this.completed[key];
-			if (value && typeof value === "object" && value.__wmill_error) throw stepErrorFromMarker(value, name);
+			if (value && typeof value === "object" && value.__wmill_error) throw taskErrorFromMarker(value, `Step '${name}' failed`);
 			return value;
 		}
 		if (this._executingKey !== null) return new Promise(() => {});
@@ -17978,22 +18116,36 @@ var WorkflowCtx = class {
 		})}`);
 		const t0 = Date.now();
 		let result;
-		let stepError;
 		let errored = false;
 		try {
 			result = await fn();
 		} catch (e) {
-			if (e?.name === "StepSuspend" || e instanceof StepSuspend) throw e;
+			if (isSuspendSignal(e, StepSuspend)) throw e;
 			errored = true;
-			stepError = e;
 			result = stepErrorMarker(key, e);
+			console.log(`--- WAC: ${key} failed ---`);
+			console.log(result?.result?.error?.stack ?? result?.message ?? "step failed");
 		}
 		const durationMs = Date.now() - t0;
 		const fastPathFlagRaw = (getEnv("WM_WAC_INLINE_FAST_PATH") ?? "1").trim().toLowerCase();
 		const fastPathEnabled = fastPathFlagRaw !== "0" && fastPathFlagRaw !== "false" && fastPathFlagRaw !== "off" && fastPathFlagRaw !== "no";
 		const jobId = getEnv("WM_JOB_ID");
 		const workspace = getEnv("WM_WORKSPACE");
-		if (fastPathEnabled && jobId && workspace && OpenAPI.BASE && OpenAPI.TOKEN) {
+		let payload;
+		let checkpointed;
+		if (fastPathEnabled && jobId && workspace && OpenAPI.BASE && OpenAPI.TOKEN) try {
+			payload = encodeCheckpointPayload({
+				key,
+				result: checkpointableResult(result),
+				started_at: startedAt,
+				duration_ms: durationMs
+			});
+			checkpointed = JSON.parse(payload).result;
+		} catch (e) {
+			console.log(`WAC v2 inline fast path could not serialize key ${key}, falling back to suspend: ${e}`);
+		}
+		if (payload !== void 0) {
+			const body = payload;
 			const chainTail = this._inlineChain.then(async () => {
 				const ctrl = new AbortController();
 				const t = setTimeout(() => ctrl.abort(), 1e4);
@@ -18004,37 +18156,36 @@ var WorkflowCtx = class {
 							"Content-Type": "application/json",
 							Authorization: `Bearer ${OpenAPI.TOKEN}`
 						},
-						body: JSON.stringify({
-							key,
-							result,
-							started_at: startedAt,
-							duration_ms: durationMs
-						}),
+						body,
 						signal: ctrl.signal
 					});
 					if (!resp.ok) throw new Error(`inline_checkpoint API ${resp.status}`);
+					if (!errored) return void 0;
+					if (!(resp.headers.get("content-type") ?? "").includes("json")) return void 0;
+					return (await resp.json())?.failure;
 				} finally {
 					clearTimeout(t);
 				}
 			});
 			this._inlineChain = chainTail.catch(() => {});
 			let fastPathOk = false;
+			let storedFailure;
 			try {
-				await chainTail;
+				storedFailure = await chainTail;
 				fastPathOk = true;
 			} catch (e) {
 				console.log(`WAC v2 inline fast path failed for key ${key}, falling back to suspend: ${e}`);
 			}
 			if (fastPathOk) {
-				if (errored) throw Object.assign(stepErrorFromMarker(result, name), { cause: stepError });
-				return result;
+				if (errored) throw taskErrorFromMarker(storedFailure ?? checkpointed, `Step '${name}' failed`);
+				return checkpointed;
 			}
 		}
 		this._raiseSuspend({
 			mode: "inline_checkpoint",
 			steps: [],
 			key,
-			result,
+			result: checkpointableResult(result),
 			started_at: startedAt,
 			duration_ms: durationMs
 		});
@@ -18046,11 +18197,18 @@ var WorkflowCtx = class {
 		this._pendingSuspend = suspend;
 		throw suspend;
 	}
-	/** Re-throw a swallowed suspend at the next SDK call. It happened before
-	*  whatever the body is doing now, so it wins: the run is unwinding either
-	*  way and everything after it re-runs on the replay. Left set, so a body
-	*  that catches in a loop can't swallow it a second time. */
-	_rethrowSwallowedSuspend() {
+	/** Park then raise the executing step's failure. Child mode only — in a parent
+	*  round a task failure is an ordinary `TaskError` the body may handle. */
+	_raiseStepFailure(error) {
+		this._pendingStepFailure = { error };
+		throw error;
+	}
+	/** Re-throw a swallowed suspend or step failure at the next SDK call. It
+	*  happened before whatever the body is doing now, so it wins: the run is
+	*  unwinding either way and everything after it re-runs on the replay. Left
+	*  set, so a body that catches in a loop can't swallow it a second time. */
+	_rethrowSwallowed() {
+		if (this._pendingStepFailure) throw this._pendingStepFailure.error;
 		if (this._pendingSuspend) throw this._pendingSuspend;
 	}
 	/** Hand the runner a suspend the workflow body caught and swallowed, so it is
@@ -18061,16 +18219,30 @@ var WorkflowCtx = class {
 		this._pendingSuspend = null;
 		return s;
 	}
+	/** Same for the executing step's failure, so the runner can fail the child job. */
+	_takePendingStepFailure() {
+		const f = this._pendingStepFailure;
+		this._pendingStepFailure = null;
+		return f;
+	}
 };
 async function sleep(seconds) {
 	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
 	if (ctx) return ctx._sleep(seconds);
 	await new Promise((r) => setTimeout(r, seconds * 1e3));
 }
+/**
+* Execute `fn` inline and checkpoint the result. On replay the cached value is
+* returned without re-executing `fn`.
+*
+* `fn`'s result is encoded as JSON and decoded back before it is returned, so
+* the round that runs the body sees the same types every replay sees: a `Date`
+* comes back as a string, a `Map` as `{}`. {@link Jsonified} is that shape.
+*/
 async function step(name, fn) {
 	const ctx = _workflowCtx ?? Reflect.get(globalThis, "__wmill_wf_ctx");
 	if (ctx) return ctx._runInlineStep(name, fn);
-	return fn();
+	return jsonRoundTrip(await fn());
 }
 /**
 * Wrap an async function as a workflow task.
@@ -18081,6 +18253,10 @@ async function step(name, fn) {
 *
 * Inside a `workflow()`, calling a task dispatches it as a step.
 * Outside a workflow, the function body executes directly.
+*
+* A task runs as its own job, so its result is always encoded as JSON and
+* decoded back before the caller sees it: a `Date` comes back as a string, a
+* `Map` as `{}`. {@link JsonifiedFn} is that shape.
 */
 function task(fnOrPath, maybeFnOrOptions, maybeOptions) {
 	let fn;
@@ -18105,11 +18281,17 @@ function task(fnOrPath, maybeFnOrOptions, maybeOptions) {
 			else kwargs[`arg${i}`] = args[i];
 			const stepResult = ctx._nextStep(taskName, script, kwargs, "inline", taskOptions);
 			if (stepResult?._execute_directly) return (async () => {
-				const result = await fn(...args);
+				let result;
+				try {
+					result = await fn(...args);
+				} catch (e) {
+					if (isSuspendSignal(e, StepSuspend)) throw e;
+					ctx._raiseStepFailure(e);
+				}
 				ctx._raiseSuspend({
 					mode: "step_complete",
 					steps: [],
-					result
+					result: checkpointableResult(result)
 				});
 			})();
 			return stepResult;
@@ -18131,7 +18313,7 @@ function task(fnOrPath, maybeFnOrOptions, maybeOptions) {
 			console.log(`Task ${taskName} (${jobId}) completed`);
 			return r;
 		})();
-		else return fn(...args);
+		else return Promise.resolve(fn(...args)).then(jsonRoundTrip);
 	};
 	Object.defineProperty(wrapper, "name", { value: taskName });
 	wrapper._is_task = true;