@restatedev/restate-sdk-cloudflare-workers 1.9.1 → 1.10.1

package/dist/promises.cjs

@@ -0,0 +1,234 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_errors = require('./types/errors.cjs');
+const require_completable_promise = require('./utils/completable_promise.cjs');
+let node_timers_promises = require("node:timers/promises");
+node_timers_promises = require_rolldown_runtime.__toESM(node_timers_promises);
+
+//#region src/promises.ts
+function pendingPromise() {
+	return new Promise(() => {});
+}
+var PromiseState = /* @__PURE__ */ function(PromiseState$1) {
+	PromiseState$1[PromiseState$1["COMPLETED"] = 0] = "COMPLETED";
+	PromiseState$1[PromiseState$1["NOT_COMPLETED"] = 1] = "NOT_COMPLETED";
+	return PromiseState$1;
+}(PromiseState || {});
+const RESTATE_CTX_SYMBOL = Symbol("restateContext");
+function extractContext(n) {
+	return n[RESTATE_CTX_SYMBOL];
+}
+var AbstractRestatePromise = class {
+	[RESTATE_CTX_SYMBOL];
+	pollingPromise;
+	cancelPromise = new require_completable_promise.CompletablePromise();
+	constructor(ctx) {
+		this[RESTATE_CTX_SYMBOL] = ctx;
+	}
+	then(onfulfilled, onrejected) {
+		this.pollingPromise = this.pollingPromise || this[RESTATE_CTX_SYMBOL].promisesExecutor.doProgress(this).catch(() => {});
+		return this.publicPromiseOrCancelPromise().then(onfulfilled, onrejected);
+	}
+	catch(onrejected) {
+		this.pollingPromise = this.pollingPromise || this[RESTATE_CTX_SYMBOL].promisesExecutor.doProgress(this).catch(() => {});
+		return this.publicPromiseOrCancelPromise().catch(onrejected);
+	}
+	finally(onfinally) {
+		this.pollingPromise = this.pollingPromise || this[RESTATE_CTX_SYMBOL].promisesExecutor.doProgress(this).catch(() => {});
+		return this.publicPromiseOrCancelPromise().finally(onfinally);
+	}
+	publicPromiseOrCancelPromise() {
+		return Promise.race([this.cancelPromise.promise, this.publicPromise()]);
+	}
+	orTimeout(duration) {
+		return new RestateCombinatorPromise(this[RESTATE_CTX_SYMBOL], ([thisPromise, sleepPromise]) => {
+			return new Promise((resolve, reject) => {
+				thisPromise.then(resolve, reject);
+				sleepPromise.then(() => {
+					reject(new require_errors.TimeoutError());
+				}, reject);
+			});
+		}, [this, this[RESTATE_CTX_SYMBOL].sleep(duration)]);
+	}
+	map(mapper) {
+		return new RestateMappedPromise(this[RESTATE_CTX_SYMBOL], this, mapper);
+	}
+	tryCancel() {
+		this.cancelPromise.reject(new require_errors.CancelledError());
+	}
+};
+var RestateSinglePromise = class extends AbstractRestatePromise {
+	state = PromiseState.NOT_COMPLETED;
+	completablePromise = new require_completable_promise.CompletablePromise();
+	constructor(ctx, handle, completer) {
+		super(ctx);
+		this.handle = handle;
+		this.completer = completer;
+	}
+	uncompletedLeaves() {
+		return this.state === PromiseState.COMPLETED ? [] : [this.handle];
+	}
+	async tryComplete() {
+		if (this.state === PromiseState.COMPLETED) return;
+		const notification = this[RESTATE_CTX_SYMBOL].coreVm.take_notification(this.handle);
+		if (notification === "NotReady") return;
+		this.state = PromiseState.COMPLETED;
+		await this.completer(notification, this.completablePromise);
+	}
+	publicPromise() {
+		return this.completablePromise.promise;
+	}
+	[Symbol.toStringTag] = "RestateSinglePromise";
+};
+var RestateInvocationPromise = class extends RestateSinglePromise {
+	constructor(ctx, handle, completer, invocationIdPromise) {
+		super(ctx, handle, completer);
+		this.invocationIdPromise = invocationIdPromise;
+	}
+	get invocationId() {
+		return this.invocationIdPromise;
+	}
+};
+var RestateCombinatorPromise = class extends AbstractRestatePromise {
+	state = PromiseState.NOT_COMPLETED;
+	combinatorPromise;
+	constructor(ctx, combinatorConstructor, childs) {
+		super(ctx);
+		this.childs = childs;
+		this.combinatorPromise = combinatorConstructor(childs.map((p) => p.publicPromise())).finally(() => {
+			this.state = PromiseState.COMPLETED;
+		});
+	}
+	uncompletedLeaves() {
+		return this.state === PromiseState.COMPLETED ? [] : this.childs.flatMap((p) => p.uncompletedLeaves());
+	}
+	async tryComplete() {
+		await Promise.allSettled(this.childs.map((c) => c.tryComplete()));
+	}
+	publicPromise() {
+		return this.combinatorPromise;
+	}
+	[Symbol.toStringTag] = "RestateCombinatorPromise";
+};
+var RestatePendingPromise = class {
+	[RESTATE_CTX_SYMBOL];
+	constructor(ctx) {
+		this[RESTATE_CTX_SYMBOL] = ctx;
+	}
+	then(onfulfilled, onrejected) {
+		return pendingPromise().then(onfulfilled, onrejected);
+	}
+	catch(onrejected) {
+		return pendingPromise().catch(onrejected);
+	}
+	finally(onfinally) {
+		return pendingPromise().finally(onfinally);
+	}
+	orTimeout() {
+		return this;
+	}
+	map() {
+		return this;
+	}
+	tryCancel() {}
+	async tryComplete() {}
+	uncompletedLeaves() {
+		return [];
+	}
+	publicPromise() {
+		return pendingPromise();
+	}
+	[Symbol.toStringTag] = "RestatePendingPromise";
+};
+var InvocationPendingPromise = class extends RestatePendingPromise {
+	constructor(ctx) {
+		super(ctx);
+	}
+	get invocationId() {
+		return pendingPromise();
+	}
+};
+var RestateMappedPromise = class extends AbstractRestatePromise {
+	publicPromiseMapper;
+	constructor(ctx, inner, mapper) {
+		super(ctx);
+		this.inner = inner;
+		this.publicPromiseMapper = (value, failure) => {
+			try {
+				return Promise.resolve(mapper(value, failure));
+			} catch (e) {
+				if (e instanceof require_errors.TerminalError) return Promise.reject(e);
+				else {
+					ctx.handleInvocationEndError(e);
+					return pendingPromise();
+				}
+			}
+		};
+	}
+	async tryComplete() {
+		await this.inner.tryComplete();
+	}
+	uncompletedLeaves() {
+		return this.inner.uncompletedLeaves();
+	}
+	publicPromise() {
+		const promiseMapper = this.publicPromiseMapper;
+		return this.inner.publicPromise().then((t) => promiseMapper(t, void 0), (error) => {
+			if (error instanceof require_errors.RestateError) return promiseMapper(void 0, error);
+			else throw error;
+		});
+	}
+	[Symbol.toStringTag] = "RestateMappedPromise";
+};
+/**
+* Promises executor, gluing VM with I/O and Promises given to user space.
+*/
+var PromisesExecutor = class {
+	constructor(coreVm, inputPump, outputPump, runClosuresTracker, errorCallback) {
+		this.coreVm = coreVm;
+		this.inputPump = inputPump;
+		this.outputPump = outputPump;
+		this.runClosuresTracker = runClosuresTracker;
+		this.errorCallback = errorCallback;
+	}
+	async doProgress(restatePromise) {
+		await this.outputPump.awaitNextProgress();
+		await this.doProgressInner(restatePromise);
+	}
+	async doProgressInner(restatePromise) {
+		try {
+			await restatePromise.tryComplete();
+		} catch (e) {
+			restatePromise[RESTATE_CTX_SYMBOL].handleInvocationEndError(e);
+			return Promise.resolve();
+		}
+		return (0, node_timers_promises.setImmediate)().then(async () => {
+			try {
+				const handles = restatePromise.uncompletedLeaves();
+				if (handles.length === 0) return;
+				const doProgressResult = this.coreVm.do_progress(new Uint32Array(handles));
+				if (doProgressResult === "AnyCompleted") {} else if (doProgressResult === "ReadFromInput") await this.inputPump.awaitNextProgress();
+				else if (doProgressResult === "WaitingPendingRun") await this.runClosuresTracker.awaitNextCompletedRun();
+				else if (doProgressResult === "CancelSignalReceived") {
+					restatePromise.tryCancel();
+					return;
+				} else {
+					this.runClosuresTracker.executeRun(doProgressResult.ExecuteRun);
+					await (0, node_timers_promises.setImmediate)();
+				}
+				await this.doProgressInner(restatePromise);
+			} catch (e) {
+				this.errorCallback(e);
+			}
+		});
+	}
+};
+
+//#endregion
+exports.InvocationPendingPromise = InvocationPendingPromise;
+exports.PromisesExecutor = PromisesExecutor;
+exports.RestateCombinatorPromise = RestateCombinatorPromise;
+exports.RestateInvocationPromise = RestateInvocationPromise;
+exports.RestatePendingPromise = RestatePendingPromise;
+exports.RestateSinglePromise = RestateSinglePromise;
+exports.extractContext = extractContext;
+exports.pendingPromise = pendingPromise;

package/dist/promises.js

@@ -0,0 +1,226 @@
+import { CancelledError, RestateError, TerminalError, TimeoutError } from "./types/errors.js";
+import { CompletablePromise } from "./utils/completable_promise.js";
+import { setImmediate } from "node:timers/promises";
+
+//#region src/promises.ts
+function pendingPromise() {
+	return new Promise(() => {});
+}
+var PromiseState = /* @__PURE__ */ function(PromiseState$1) {
+	PromiseState$1[PromiseState$1["COMPLETED"] = 0] = "COMPLETED";
+	PromiseState$1[PromiseState$1["NOT_COMPLETED"] = 1] = "NOT_COMPLETED";
+	return PromiseState$1;
+}(PromiseState || {});
+const RESTATE_CTX_SYMBOL = Symbol("restateContext");
+function extractContext(n) {
+	return n[RESTATE_CTX_SYMBOL];
+}
+var AbstractRestatePromise = class {
+	[RESTATE_CTX_SYMBOL];
+	pollingPromise;
+	cancelPromise = new CompletablePromise();
+	constructor(ctx) {
+		this[RESTATE_CTX_SYMBOL] = ctx;
+	}
+	then(onfulfilled, onrejected) {
+		this.pollingPromise = this.pollingPromise || this[RESTATE_CTX_SYMBOL].promisesExecutor.doProgress(this).catch(() => {});
+		return this.publicPromiseOrCancelPromise().then(onfulfilled, onrejected);
+	}
+	catch(onrejected) {
+		this.pollingPromise = this.pollingPromise || this[RESTATE_CTX_SYMBOL].promisesExecutor.doProgress(this).catch(() => {});
+		return this.publicPromiseOrCancelPromise().catch(onrejected);
+	}
+	finally(onfinally) {
+		this.pollingPromise = this.pollingPromise || this[RESTATE_CTX_SYMBOL].promisesExecutor.doProgress(this).catch(() => {});
+		return this.publicPromiseOrCancelPromise().finally(onfinally);
+	}
+	publicPromiseOrCancelPromise() {
+		return Promise.race([this.cancelPromise.promise, this.publicPromise()]);
+	}
+	orTimeout(duration) {
+		return new RestateCombinatorPromise(this[RESTATE_CTX_SYMBOL], ([thisPromise, sleepPromise]) => {
+			return new Promise((resolve, reject) => {
+				thisPromise.then(resolve, reject);
+				sleepPromise.then(() => {
+					reject(new TimeoutError());
+				}, reject);
+			});
+		}, [this, this[RESTATE_CTX_SYMBOL].sleep(duration)]);
+	}
+	map(mapper) {
+		return new RestateMappedPromise(this[RESTATE_CTX_SYMBOL], this, mapper);
+	}
+	tryCancel() {
+		this.cancelPromise.reject(new CancelledError());
+	}
+};
+var RestateSinglePromise = class extends AbstractRestatePromise {
+	state = PromiseState.NOT_COMPLETED;
+	completablePromise = new CompletablePromise();
+	constructor(ctx, handle, completer) {
+		super(ctx);
+		this.handle = handle;
+		this.completer = completer;
+	}
+	uncompletedLeaves() {
+		return this.state === PromiseState.COMPLETED ? [] : [this.handle];
+	}
+	async tryComplete() {
+		if (this.state === PromiseState.COMPLETED) return;
+		const notification = this[RESTATE_CTX_SYMBOL].coreVm.take_notification(this.handle);
+		if (notification === "NotReady") return;
+		this.state = PromiseState.COMPLETED;
+		await this.completer(notification, this.completablePromise);
+	}
+	publicPromise() {
+		return this.completablePromise.promise;
+	}
+	[Symbol.toStringTag] = "RestateSinglePromise";
+};
+var RestateInvocationPromise = class extends RestateSinglePromise {
+	constructor(ctx, handle, completer, invocationIdPromise) {
+		super(ctx, handle, completer);
+		this.invocationIdPromise = invocationIdPromise;
+	}
+	get invocationId() {
+		return this.invocationIdPromise;
+	}
+};
+var RestateCombinatorPromise = class extends AbstractRestatePromise {
+	state = PromiseState.NOT_COMPLETED;
+	combinatorPromise;
+	constructor(ctx, combinatorConstructor, childs) {
+		super(ctx);
+		this.childs = childs;
+		this.combinatorPromise = combinatorConstructor(childs.map((p) => p.publicPromise())).finally(() => {
+			this.state = PromiseState.COMPLETED;
+		});
+	}
+	uncompletedLeaves() {
+		return this.state === PromiseState.COMPLETED ? [] : this.childs.flatMap((p) => p.uncompletedLeaves());
+	}
+	async tryComplete() {
+		await Promise.allSettled(this.childs.map((c) => c.tryComplete()));
+	}
+	publicPromise() {
+		return this.combinatorPromise;
+	}
+	[Symbol.toStringTag] = "RestateCombinatorPromise";
+};
+var RestatePendingPromise = class {
+	[RESTATE_CTX_SYMBOL];
+	constructor(ctx) {
+		this[RESTATE_CTX_SYMBOL] = ctx;
+	}
+	then(onfulfilled, onrejected) {
+		return pendingPromise().then(onfulfilled, onrejected);
+	}
+	catch(onrejected) {
+		return pendingPromise().catch(onrejected);
+	}
+	finally(onfinally) {
+		return pendingPromise().finally(onfinally);
+	}
+	orTimeout() {
+		return this;
+	}
+	map() {
+		return this;
+	}
+	tryCancel() {}
+	async tryComplete() {}
+	uncompletedLeaves() {
+		return [];
+	}
+	publicPromise() {
+		return pendingPromise();
+	}
+	[Symbol.toStringTag] = "RestatePendingPromise";
+};
+var InvocationPendingPromise = class extends RestatePendingPromise {
+	constructor(ctx) {
+		super(ctx);
+	}
+	get invocationId() {
+		return pendingPromise();
+	}
+};
+var RestateMappedPromise = class extends AbstractRestatePromise {
+	publicPromiseMapper;
+	constructor(ctx, inner, mapper) {
+		super(ctx);
+		this.inner = inner;
+		this.publicPromiseMapper = (value, failure) => {
+			try {
+				return Promise.resolve(mapper(value, failure));
+			} catch (e) {
+				if (e instanceof TerminalError) return Promise.reject(e);
+				else {
+					ctx.handleInvocationEndError(e);
+					return pendingPromise();
+				}
+			}
+		};
+	}
+	async tryComplete() {
+		await this.inner.tryComplete();
+	}
+	uncompletedLeaves() {
+		return this.inner.uncompletedLeaves();
+	}
+	publicPromise() {
+		const promiseMapper = this.publicPromiseMapper;
+		return this.inner.publicPromise().then((t) => promiseMapper(t, void 0), (error) => {
+			if (error instanceof RestateError) return promiseMapper(void 0, error);
+			else throw error;
+		});
+	}
+	[Symbol.toStringTag] = "RestateMappedPromise";
+};
+/**
+* Promises executor, gluing VM with I/O and Promises given to user space.
+*/
+var PromisesExecutor = class {
+	constructor(coreVm, inputPump, outputPump, runClosuresTracker, errorCallback) {
+		this.coreVm = coreVm;
+		this.inputPump = inputPump;
+		this.outputPump = outputPump;
+		this.runClosuresTracker = runClosuresTracker;
+		this.errorCallback = errorCallback;
+	}
+	async doProgress(restatePromise) {
+		await this.outputPump.awaitNextProgress();
+		await this.doProgressInner(restatePromise);
+	}
+	async doProgressInner(restatePromise) {
+		try {
+			await restatePromise.tryComplete();
+		} catch (e) {
+			restatePromise[RESTATE_CTX_SYMBOL].handleInvocationEndError(e);
+			return Promise.resolve();
+		}
+		return setImmediate().then(async () => {
+			try {
+				const handles = restatePromise.uncompletedLeaves();
+				if (handles.length === 0) return;
+				const doProgressResult = this.coreVm.do_progress(new Uint32Array(handles));
+				if (doProgressResult === "AnyCompleted") {} else if (doProgressResult === "ReadFromInput") await this.inputPump.awaitNextProgress();
+				else if (doProgressResult === "WaitingPendingRun") await this.runClosuresTracker.awaitNextCompletedRun();
+				else if (doProgressResult === "CancelSignalReceived") {
+					restatePromise.tryCancel();
+					return;
+				} else {
+					this.runClosuresTracker.executeRun(doProgressResult.ExecuteRun);
+					await setImmediate();
+				}
+				await this.doProgressInner(restatePromise);
+			} catch (e) {
+				this.errorCallback(e);
+			}
+		});
+	}
+};
+
+//#endregion
+export { InvocationPendingPromise, PromisesExecutor, RestateCombinatorPromise, RestateInvocationPromise, RestatePendingPromise, RestateSinglePromise, extractContext, pendingPromise };
+//# sourceMappingURL=promises.js.map

package/dist/promises.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promises.js","names":["handle: number","completer: (\n      value: AsyncResultValue,\n      prom: CompletablePromise<T>\n    ) => Promise<void>","invocationIdPromise: Promise<InvocationId>","childs: Array<InternalRestatePromise<any>>","inner: InternalRestatePromise<T>","coreVm: vm.WasmVM","inputPump: InputPump","outputPump: OutputPump","runClosuresTracker: RunClosuresTracker","errorCallback: (e: any) => void"],"sources":["../src/promises.ts"],"sourcesContent":["/*\n * Copyright (c) 2023-2025 - Restate Software, Inc., Restate GmbH\n *\n * This file is part of the Restate SDK for Node.js/TypeScript,\n * which is released under the MIT license.\n *\n * You can find a copy of the license in file LICENSE in the root\n * directory of this repository or package, or at\n * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type {\n  RestatePromise,\n  InvocationId,\n  InvocationPromise,\n} from \"./context.js\";\nimport type * as vm from \"./endpoint/handlers/vm/sdk_shared_core_wasm_bindings.js\";\nimport {\n  CancelledError,\n  RestateError,\n  TerminalError,\n  TimeoutError,\n} from \"./types/errors.js\";\nimport { CompletablePromise } from \"./utils/completable_promise.js\";\nimport type { ContextImpl, RunClosuresTracker } from \"./context_impl.js\";\nimport { setImmediate } from \"node:timers/promises\";\nimport type { InputPump, OutputPump } from \"./io.js\";\nimport type { Duration } from \"@restatedev/restate-sdk-core\";\n\n// A promise that is never completed\nexport function pendingPromise<T>(): Promise<T> {\n  return new Promise<T>(() => {});\n}\n\n// ------ Restate promises ------\n// These promises are \"proxy promises\" that will be handed over to the user,\n// and moved forward by the PromiseExecutor below when the user awaits on them.\n\nenum PromiseState {\n  COMPLETED,\n  NOT_COMPLETED,\n}\n\nexport const RESTATE_CTX_SYMBOL = Symbol(\"restateContext\");\n\nexport interface InternalRestatePromise<T> extends RestatePromise<T> {\n  [RESTATE_CTX_SYMBOL]: ContextImpl;\n\n  tryCancel(): void;\n  tryComplete(): Promise<void>;\n  uncompletedLeaves(): Array<number>;\n  publicPromise(): Promise<T>;\n}\n\nexport type AsyncResultValue =\n  | \"Empty\"\n  | { Success: Uint8Array }\n  | { Failure: vm.WasmFailure }\n  | { StateKeys: string[] }\n  | { InvocationId: string };\n\nexport function extractContext(n: any): ContextImpl | undefined {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return n[RESTATE_CTX_SYMBOL] as ContextImpl | undefined;\n}\n\nabstract class AbstractRestatePromise<T> implements InternalRestatePromise<T> {\n  [RESTATE_CTX_SYMBOL]: ContextImpl;\n  private pollingPromise?: Promise<any>;\n  private cancelPromise: CompletablePromise<any> = new CompletablePromise();\n\n  protected constructor(ctx: ContextImpl) {\n    this[RESTATE_CTX_SYMBOL] = ctx;\n  }\n\n  // --- Promise methods\n\n  then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null\n  ): Promise<TResult1 | TResult2> {\n    this.pollingPromise =\n      this.pollingPromise ||\n      this[RESTATE_CTX_SYMBOL].promisesExecutor\n        .doProgress(this)\n        .catch(() => {});\n    return this.publicPromiseOrCancelPromise().then(onfulfilled, onrejected);\n  }\n\n  catch<TResult = never>(\n    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null\n  ): Promise<T | TResult> {\n    this.pollingPromise =\n      this.pollingPromise ||\n      this[RESTATE_CTX_SYMBOL].promisesExecutor\n        .doProgress(this)\n        .catch(() => {});\n    return this.publicPromiseOrCancelPromise().catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<T> {\n    this.pollingPromise =\n      this.pollingPromise ||\n      this[RESTATE_CTX_SYMBOL].promisesExecutor\n        .doProgress(this)\n        .catch(() => {});\n    return this.publicPromiseOrCancelPromise().finally(onfinally);\n  }\n\n  private publicPromiseOrCancelPromise(): Promise<T> {\n    return Promise.race([\n      this.cancelPromise.promise as Promise<T>,\n      this.publicPromise(),\n    ]);\n  }\n\n  // --- RestatePromise methods\n\n  orTimeout(duration: number | Duration): RestatePromise<T> {\n    return new RestateCombinatorPromise(\n      this[RESTATE_CTX_SYMBOL],\n      ([thisPromise, sleepPromise]) => {\n        return new Promise((resolve, reject) => {\n          thisPromise!.then(resolve, reject);\n          sleepPromise!.then(() => {\n            reject(new TimeoutError());\n          }, reject);\n        });\n      },\n      [\n        this,\n        this[RESTATE_CTX_SYMBOL].sleep(duration) as InternalRestatePromise<any>,\n      ]\n    ) as RestatePromise<T>;\n  }\n\n  map<U>(mapper: (value?: T, failure?: TerminalError) => U): RestatePromise<U> {\n    return new RestateMappedPromise(this[RESTATE_CTX_SYMBOL], this, mapper);\n  }\n\n  tryCancel() {\n    this.cancelPromise.reject(new CancelledError());\n  }\n\n  abstract tryComplete(): Promise<void>;\n\n  abstract uncompletedLeaves(): Array<number>;\n\n  abstract publicPromise(): Promise<T>;\n\n  abstract [Symbol.toStringTag]: string;\n}\n\nexport class RestateSinglePromise<T> extends AbstractRestatePromise<T> {\n  private state: PromiseState = PromiseState.NOT_COMPLETED;\n  private completablePromise: CompletablePromise<T> = new CompletablePromise();\n\n  constructor(\n    ctx: ContextImpl,\n    readonly handle: number,\n    private readonly completer: (\n      value: AsyncResultValue,\n      prom: CompletablePromise<T>\n    ) => Promise<void>\n  ) {\n    super(ctx);\n  }\n\n  uncompletedLeaves(): number[] {\n    return this.state === PromiseState.COMPLETED ? [] : [this.handle];\n  }\n\n  async tryComplete(): Promise<void> {\n    if (this.state === PromiseState.COMPLETED) {\n      return;\n    }\n    const notification = this[RESTATE_CTX_SYMBOL].coreVm.take_notification(\n      this.handle\n    );\n    if (notification === \"NotReady\") {\n      return;\n    }\n    this.state = PromiseState.COMPLETED;\n    await this.completer(notification, this.completablePromise);\n  }\n\n  publicPromise(): Promise<T> {\n    return this.completablePromise.promise;\n  }\n\n  readonly [Symbol.toStringTag] = \"RestateSinglePromise\";\n}\n\nexport class RestateInvocationPromise<T>\n  extends RestateSinglePromise<T>\n  implements InvocationPromise<T>\n{\n  constructor(\n    ctx: ContextImpl,\n    handle: number,\n    completer: (\n      value: AsyncResultValue,\n      prom: CompletablePromise<T>\n    ) => Promise<void>,\n    private readonly invocationIdPromise: Promise<InvocationId>\n  ) {\n    super(ctx, handle, completer);\n  }\n\n  get invocationId(): Promise<InvocationId> {\n    return this.invocationIdPromise;\n  }\n}\n\nexport class RestateCombinatorPromise extends AbstractRestatePromise<any> {\n  private state: PromiseState = PromiseState.NOT_COMPLETED;\n  private readonly combinatorPromise: Promise<any>;\n\n  constructor(\n    ctx: ContextImpl,\n    combinatorConstructor: (promises: Promise<any>[]) => Promise<any>,\n    readonly childs: Array<InternalRestatePromise<any>>\n  ) {\n    super(ctx);\n    this.combinatorPromise = combinatorConstructor(\n      childs.map((p) => p.publicPromise())\n    ).finally(() => {\n      this.state = PromiseState.COMPLETED;\n    });\n  }\n\n  uncompletedLeaves(): number[] {\n    return this.state === PromiseState.COMPLETED\n      ? []\n      : this.childs.flatMap((p) => p.uncompletedLeaves());\n  }\n\n  async tryComplete(): Promise<void> {\n    await Promise.allSettled(this.childs.map((c) => c.tryComplete()));\n  }\n\n  publicPromise(): Promise<unknown> {\n    return this.combinatorPromise;\n  }\n\n  readonly [Symbol.toStringTag] = \"RestateCombinatorPromise\";\n}\n\nexport class RestatePendingPromise<T> implements InternalRestatePromise<T> {\n  [RESTATE_CTX_SYMBOL]: ContextImpl;\n\n  constructor(ctx: ContextImpl) {\n    this[RESTATE_CTX_SYMBOL] = ctx;\n  }\n\n  // --- Promise methods\n\n  then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null\n  ): Promise<TResult1 | TResult2> {\n    return pendingPromise<T>().then(onfulfilled, onrejected);\n  }\n\n  catch<TResult = never>(\n    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null\n  ): Promise<T | TResult> {\n    return pendingPromise<T>().catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<T> {\n    return pendingPromise<T>().finally(onfinally);\n  }\n\n  // --- RestatePromise methods\n\n  orTimeout(): RestatePromise<T> {\n    return this;\n  }\n\n  map<U>(): RestatePromise<U> {\n    return this as unknown as RestatePromise<U>;\n  }\n\n  tryCancel(): void {}\n  async tryComplete(): Promise<void> {}\n  uncompletedLeaves(): number[] {\n    return [];\n  }\n  publicPromise(): Promise<T> {\n    return pendingPromise<T>();\n  }\n\n  readonly [Symbol.toStringTag] = \"RestatePendingPromise\";\n}\n\nexport class InvocationPendingPromise<T>\n  extends RestatePendingPromise<T>\n  implements InvocationPromise<T>\n{\n  constructor(ctx: ContextImpl) {\n    super(ctx);\n  }\n\n  get invocationId(): Promise<InvocationId> {\n    return pendingPromise();\n  }\n}\n\nexport class RestateMappedPromise<T, U> extends AbstractRestatePromise<U> {\n  private publicPromiseMapper: (\n    value?: T,\n    failure?: TerminalError\n  ) => Promise<U>;\n\n  constructor(\n    ctx: ContextImpl,\n    readonly inner: InternalRestatePromise<T>,\n    mapper: (value?: T, failure?: TerminalError) => U\n  ) {\n    super(ctx);\n    this.publicPromiseMapper = (value?: T, failure?: TerminalError) => {\n      try {\n        return Promise.resolve(mapper(value, failure));\n      } catch (e) {\n        if (e instanceof TerminalError) {\n          return Promise.reject(e);\n        } else {\n          ctx.handleInvocationEndError(e);\n          return pendingPromise();\n        }\n      }\n    };\n  }\n\n  async tryComplete(): Promise<void> {\n    await this.inner.tryComplete();\n  }\n\n  uncompletedLeaves(): number[] {\n    return this.inner.uncompletedLeaves();\n  }\n\n  publicPromise(): Promise<U> {\n    const promiseMapper = this.publicPromiseMapper;\n    return this.inner.publicPromise().then(\n      (t) => promiseMapper(t, undefined),\n      (error) => {\n        if (error instanceof RestateError) {\n          return promiseMapper(undefined, error);\n        } else {\n          // Something else, just re-throw it\n          throw error;\n        }\n      }\n    );\n  }\n\n  readonly [Symbol.toStringTag] = \"RestateMappedPromise\";\n}\n\n/**\n * Promises executor, gluing VM with I/O and Promises given to user space.\n */\nexport class PromisesExecutor {\n  constructor(\n    private readonly coreVm: vm.WasmVM,\n    private readonly inputPump: InputPump,\n    private readonly outputPump: OutputPump,\n    private readonly runClosuresTracker: RunClosuresTracker,\n    private readonly errorCallback: (e: any) => void\n  ) {}\n\n  async doProgress(restatePromise: InternalRestatePromise<unknown>) {\n    // Only the first time try process output\n    await this.outputPump.awaitNextProgress();\n    await this.doProgressInner(restatePromise);\n  }\n\n  private async doProgressInner(\n    restatePromise: InternalRestatePromise<unknown>\n  ) {\n    // Try complete the promise\n    try {\n      await restatePromise.tryComplete();\n    } catch (e) {\n      // This can happen if either take_notification throws an exception or completer throws an exception.\n      // This could either happen for a deserialization issue, or for an SDK bug, but we cover them here.\n      restatePromise[RESTATE_CTX_SYMBOL].handleInvocationEndError(e);\n      return Promise.resolve();\n    }\n\n    // tl;dr don't touch this, or you can break combineable promises,\n    // slinkydeveloper won't be happy about it\n    //\n    // The reason for this setTimeout is that we need to enqueue the polling after\n    // we eventually resolve some promises. This is especially crucial for RestateCombinatorPromise\n    // as it flips the completed state using .finally() on the combinator.\n    return setImmediate().then(async () => {\n      try {\n        // Invoke do progress on the vm\n        const handles = restatePromise.uncompletedLeaves();\n        if (handles.length === 0) {\n          // Completed, we're good!\n          return;\n        }\n        const doProgressResult = this.coreVm.do_progress(\n          new Uint32Array(handles)\n        );\n\n        if (doProgressResult === \"AnyCompleted\") {\n          // Next recursion will cause the promise to do some progress\n        } else if (doProgressResult === \"ReadFromInput\") {\n          // Read from input\n          await this.inputPump.awaitNextProgress();\n        } else if (doProgressResult === \"WaitingPendingRun\") {\n          // Wait for any of the pending run to complete\n          await this.runClosuresTracker.awaitNextCompletedRun();\n        } else if (doProgressResult === \"CancelSignalReceived\") {\n          restatePromise.tryCancel();\n          return;\n        } else {\n          // We need to execute a run closure\n          this.runClosuresTracker.executeRun(doProgressResult.ExecuteRun);\n          // Let the run context switch, then come back to this flow.\n          await setImmediate();\n        }\n\n        // Recursion\n        await this.doProgressInner(restatePromise);\n      } catch (e) {\n        // Not good, this is a retryable error.\n        this.errorCallback(e);\n      }\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/types/errors.cjs

@@ -0,0 +1,110 @@
+
+//#region src/types/errors.ts
+const INTERNAL_ERROR_CODE = 500;
+const TIMEOUT_ERROR_CODE = 408;
+const CANCEL_ERROR_CODE = 409;
+const UNKNOWN_ERROR_CODE = 500;
+const CLOSED_ERROR_CODE = 598;
+const SUSPENDED_ERROR_CODE = 599;
+function ensureError(e, asTerminalError) {
+	if (e instanceof TerminalError) return e;
+	const maybeTerminalError = asTerminalError ? asTerminalError(e) : void 0;
+	if (maybeTerminalError) return maybeTerminalError;
+	if (e instanceof Error) return e;
+	if (typeof e === "object" && e !== null && "code" in e && "message" in e) return new RestateError(e.message, { errorCode: e.code });
+	let msg;
+	try {
+		msg = JSON.stringify(e);
+	} catch {
+		msg = "(no JSON representation)";
+	}
+	return /* @__PURE__ */ new Error("Non-Error value: " + msg);
+}
+function logError(log, e) {
+	if (e instanceof RestateError) {
+		if (e.code === SUSPENDED_ERROR_CODE) {
+			log.info("Invocation suspended");
+			return;
+		} else if (e.code === CLOSED_ERROR_CODE) {
+			log.error("DANGER! The invocation is closed, but some related operation is still running. \nThis might indicate that a RestatePromise is being awaited on an asynchronous task, outside the handler, or you're awaiting a RestatePromise inside a ctx.run.\nThis is dangerous, and can lead the service to deadlock. Please fix the issue.\nDiagnostic: ", e);
+			return;
+		}
+	}
+	log.warn("Error when processing a Restate context operation.\n", e);
+}
+var RestateError = class extends Error {
+	code;
+	name = "RestateError";
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.code = options?.errorCode ?? INTERNAL_ERROR_CODE;
+	}
+};
+/**
+* Does not lead to Restate retries.
+*
+* Leads to an output message with a failure defined.
+*/
+var TerminalError = class extends RestateError {
+	name = "TerminalError";
+	constructor(message, options) {
+		super(message, options);
+	}
+};
+/**
+* Returned by `RestatePromise.withTimeout` when the timeout is reached.
+*/
+var TimeoutError = class extends TerminalError {
+	name = "TimeoutError";
+	constructor() {
+		super("Timeout occurred", { errorCode: TIMEOUT_ERROR_CODE });
+	}
+};
+/**
+* Returned when the invocation was cancelled.
+*/
+var CancelledError = class extends TerminalError {
+	name = "CancelledError";
+	constructor() {
+		super("Cancelled", { errorCode: CANCEL_ERROR_CODE });
+	}
+};
+/**
+* Error that Restate will retry. By using this error type within a `ctx.run` closure,
+* you can dynamically provide the retry delay specified in {@link RetryableErrorOptions}.
+*
+* You can wrap another error using {@link from}.
+*/
+var RetryableError = class RetryableError extends RestateError {
+	name = "RetryableError";
+	retryAfter;
+	constructor(message, options) {
+		super(message, {
+			errorCode: options?.errorCode,
+			cause: options?.cause
+		});
+		this.retryAfter = options?.retryAfter;
+	}
+	/**
+	* Create a `RetryableError` from the given cause.
+	*/
+	static from(cause, options) {
+		const error = ensureError(cause);
+		return new RetryableError(error.message, {
+			errorCode: error["errorCode"],
+			cause,
+			...options
+		});
+	}
+};
+
+//#endregion
+exports.CancelledError = CancelledError;
+exports.INTERNAL_ERROR_CODE = INTERNAL_ERROR_CODE;
+exports.RestateError = RestateError;
+exports.RetryableError = RetryableError;
+exports.TerminalError = TerminalError;
+exports.TimeoutError = TimeoutError;
+exports.UNKNOWN_ERROR_CODE = UNKNOWN_ERROR_CODE;
+exports.ensureError = ensureError;
+exports.logError = logError;

package/dist/types/errors.d.cts

@@ -0,0 +1,71 @@
+import { Duration } from "@restatedev/restate-sdk-core";
+
+//#region src/types/errors.d.ts
+
+declare class RestateError extends Error {
+  readonly code: number;
+  name: string;
+  constructor(message: string, options?: {
+    errorCode?: number;
+    cause?: any;
+  });
+}
+/**
+ * Does not lead to Restate retries.
+ *
+ * Leads to an output message with a failure defined.
+ */
+declare class TerminalError extends RestateError {
+  name: string;
+  constructor(message: string, options?: {
+    /**
+     * Error code. This should be an HTTP status code, and in case the service was invoked from the ingress, this will be propagated back to the caller.
+     */
+    errorCode?: number;
+    /**
+     * @deprecated YOU MUST NOT USE THIS FIELD, AS IT WON'T BE RECORDED AND CAN LEAD TO NON-DETERMINISM! From the next SDK version, the constructor won't accept this field anymore.
+     */
+    cause?: any;
+  });
+}
+/**
+ * Returned by `RestatePromise.withTimeout` when the timeout is reached.
+ */
+declare class TimeoutError extends TerminalError {
+  name: string;
+  constructor();
+}
+/**
+ * Returned when the invocation was cancelled.
+ */
+declare class CancelledError extends TerminalError {
+  name: string;
+  constructor();
+}
+interface RetryableErrorOptions {
+  /**
+   * In how long it should retry.
+   */
+  retryAfter?: Duration | number;
+}
+/**
+ * Error that Restate will retry. By using this error type within a `ctx.run` closure,
+ * you can dynamically provide the retry delay specified in {@link RetryableErrorOptions}.
+ *
+ * You can wrap another error using {@link from}.
+ */
+declare class RetryableError extends RestateError {
+  name: string;
+  readonly retryAfter?: Duration | number;
+  constructor(message: string, options?: RetryableErrorOptions & {
+    errorCode?: number;
+    cause?: any;
+  });
+  /**
+   * Create a `RetryableError` from the given cause.
+   */
+  static from(cause: any, options?: RetryableErrorOptions): RetryableError;
+}
+//#endregion
+export { CancelledError, RestateError, RetryableError, RetryableErrorOptions, TerminalError, TimeoutError };
+//# sourceMappingURL=errors.d.cts.map

package/dist/types/errors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.cts","names":[],"sources":["../../src/types/errors.ts"],"sourcesContent":[],"mappings":";;;;AAsJwB,cAzEX,YAAA,SAAqB,KAAA,CAyEV;EAIV,SAAA,IAAA,EAAA,MAAA;EAgBsB,IAAA,EAAA,MAAA;EAAwB,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,QAAA,EAAA;IAvBxB,SAAA,CAAA,EAAA,MAAA;IAAY,KAAA,CAAA,EAAA,GAAA;;;;;;;;cAvDnC,aAAA,SAAsB,YAAA;;;;;;;;;;;;;;;;cAuBtB,YAAA,SAAqB,aAAA;;;;;;;cAWrB,cAAA,SAAuB,aAAA;;;;UAQnB,qBAAA;;;;eAIF;;;;;;;;cASF,cAAA,SAAuB,YAAA;;wBAGZ;yCAIV;;;;;;;oCAgBsB,wBAAwB"}