windmill-client 1.772.0 → 1.774.0

package/dist/wacError.d.ts

@@ -0,0 +1,24 @@
+/** @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. */
+export declare function isSuspendSignal(e: unknown, suspendCtor: Function): boolean;
+/** @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. */
+export declare function stepErrorMarker(key: string, e: unknown): Record<string, any>;
+/** @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. */
+export declare function taskErrorFromMarker(marker: any, fallbackMessage: string): Error;

package/dist/wacError.mjs

@@ -0,0 +1,103 @@
+//#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
+export { isSuspendSignal, stepErrorMarker, taskErrorFromMarker };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "windmill-client",
   "description": "Windmill SDK client for browsers and Node.js",
-  "version": "1.772.0",
+  "version": "1.774.0",
   "author": "Ruben Fiszel",
   "license": "Apache 2.0",
   "homepage": "https://github.com/windmill-labs/windmill/tree/main/typescript-client#readme",