@resonatehq/sdk 0.5.5 → 0.6.1

package/dist/resonate.js

@@ -23,42 +23,33 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResonateBase = void 0;
+exports.InvocationHandle = exports.Context = exports.Resonate = void 0;
 const json_1 = require("./core/encoders/json");
+const errors_1 = require("./core/errors");
 const logger_1 = require("./core/loggers/logger");
-const promises = __importStar(require("./core/promises/promises"));
-const retryPolicy = __importStar(require("./core/retry"));
+const options_1 = require("./core/options");
+const durablePromises = __importStar(require("./core/promises/promises"));
+const retryPolicies = __importStar(require("./core/retry"));
+const retry_1 = require("./core/retry");
 const schedules = __importStar(require("./core/schedules/schedules"));
 const local_1 = require("./core/stores/local");
 const remote_1 = require("./core/stores/remote");
 const utils = __importStar(require("./core/utils"));
-/////////////////////////////////////////////////////////////////////
-// Resonate
-/////////////////////////////////////////////////////////////////////
-class ResonateBase {
-    functions = {};
+const utils_1 = require("./core/utils");
+//////////////////////////////////////////////////////////////////////
+class Resonate {
+    #registeredFunctions = {};
+    #invocationHandles;
+    #interval;
+    store;
+    logger;
+    defaultInvocationOptions;
     promises;
     schedules;
-    pid;
-    poll;
-    timeout;
-    tags;
-    encoder;
-    logger;
-    retry;
-    store;
-    interval;
     constructor({ auth = undefined, encoder = new json_1.JSONEncoder(), heartbeat = 15000, // 15s
-    logger = new logger_1.Logger(), pid = utils.randomId(), poll = 5000, // 5s
-    retry = retryPolicy.exponential(), store = undefined, tags = {}, timeout = 10000, // 10s
+    logger = new logger_1.Logger(), pid = utils.randomId(), pollFrequency = 5000, // 5s
+    retryPolicy = retryPolicies.exponential(), store = undefined, tags = {}, timeout = 10000, // 10s
     url = undefined, } = {}) {
-        this.encoder = encoder;
-        this.logger = logger;
-        this.pid = pid;
-        this.poll = poll;
-        this.retry = retry;
-        this.tags = tags;
-        this.timeout = timeout;
         if (store) {
             this.store = store;
         }
@@ -78,43 +69,74 @@ class ResonateBase {
                 pid,
             });
         }
+        this.logger = logger;
+        this.#invocationHandles = new Map();
+        this.defaultInvocationOptions = {
+            __resonate: true,
+            durable: true,
+            eidFn: utils.randomId,
+            encoder: encoder,
+            idempotencyKeyFn: utils.hash,
+            shouldLock: undefined,
+            pollFrequency,
+            retryPolicy,
+            tags,
+            timeout,
+            version: 0,
+        };
         // promises
         this.promises = {
-            create: (id, timeout, opts = {}) => promises.DurablePromise.create(this.store.promises, this.encoder, id, timeout, opts),
-            resolve: (id, value, opts = {}) => promises.DurablePromise.resolve(this.store.promises, this.encoder, id, value, opts),
-            reject: (id, error, opts = {}) => promises.DurablePromise.reject(this.store.promises, this.encoder, id, error, opts),
-            cancel: (id, error, opts = {}) => promises.DurablePromise.cancel(this.store.promises, this.encoder, id, error, opts),
-            get: (id) => promises.DurablePromise.get(this.store.promises, this.encoder, id),
-            search: (id, state, tags, limit) => promises.DurablePromise.search(this.store.promises, this.encoder, id, state, tags, limit),
+            create: (id, timeout, opts = {}) => durablePromises.DurablePromise.create(this.promisesStore, encoder, id, timeout, opts),
+            resolve: (id, value, opts = {}) => durablePromises.DurablePromise.resolve(this.promisesStore, encoder, id, value, opts),
+            reject: (id, error, opts = {}) => durablePromises.DurablePromise.reject(this.promisesStore, encoder, id, error, opts),
+            cancel: (id, error, opts = {}) => durablePromises.DurablePromise.cancel(this.promisesStore, encoder, id, error, opts),
+            get: (id) => durablePromises.DurablePromise.get(this.promisesStore, encoder, id),
+            search: (id, state, tags, limit) => durablePromises.DurablePromise.search(this.promisesStore, encoder, id, state, tags, limit),
         };
         // schedules
         this.schedules = {
-            create: (id, cron, promiseId, promiseTimeout, opts = {}) => schedules.Schedule.create(this.store.schedules, this.encoder, id, cron, promiseId, promiseTimeout, opts),
-            get: (id) => schedules.Schedule.get(this.store.schedules, this.encoder, id),
-            search: (id, tags, limit) => schedules.Schedule.search(this.store.schedules, this.encoder, id, tags, limit),
+            create: (id, cron, promiseId, promiseTimeout, opts = {}) => schedules.Schedule.create(this.store.schedules, encoder, id, cron, promiseId, promiseTimeout, opts),
+            get: (id) => schedules.Schedule.get(this.store.schedules, encoder, id),
+            search: (id, tags, limit) => schedules.Schedule.search(this.store.schedules, encoder, id, tags, limit),
         };
     }
+    get promisesStore() {
+        return this.store.promises;
+    }
+    get locksStore() {
+        return this.store.locks;
+    }
+    options(opts) {
+        return (0, options_1.options)(opts);
+    }
+    registeredFunction(funcName, version) {
+        if (!this.#registeredFunctions[funcName]?.[version]) {
+            throw new Error(`Function ${funcName} version ${version} not registered`);
+        }
+        return this.#registeredFunctions[funcName][version];
+    }
     register(name, func, opts = {}) {
         // set default version
         opts.version = opts.version ?? 1;
-        // set default options
-        const options = this.defaults(opts);
+        // set default values for the options options
+        const options = this.withDefaultOpts(opts);
         if (options.version <= 0) {
             throw new Error("Version must be greater than 0");
         }
-        if (!this.functions[name]) {
-            this.functions[name] = {};
+        if (!this.#registeredFunctions[name]) {
+            this.#registeredFunctions[name] = {};
         }
-        if (this.functions[name][options.version]) {
+        if (this.#registeredFunctions[name][options.version]) {
             throw new Error(`Function ${name} version ${options.version} already registered`);
         }
-        // register as latest (0) if version is greatest so far
-        if (options.version > Math.max(...Object.values(this.functions[name]).map((f) => f.opts.version))) {
-            this.functions[name][0] = { func, opts: options };
+        // Get the highest version number of existing functions with this name
+        const latestVersion = Math.max(...Object.values(this.#registeredFunctions[name]).map((f) => f.opts.version));
+        // If the new function's version is higher, register it as the latest (index 0)
+        if (options.version > latestVersion) {
+            this.#registeredFunctions[name][0] = { func, opts: options };
         }
         // register specific version
-        this.functions[name][options.version] = { func, opts: options };
-        return (id, ...args) => this.run(name, id, ...args, options);
+        this.#registeredFunctions[name][options.version] = { func, opts: options };
     }
     registerModule(module, opts = {}) {
         for (const key in module) {
@@ -122,78 +144,105 @@ class ResonateBase {
         }
     }
     /**
-     * Run a Resonate function. Functions must first be registered with {@link register}.
+     * Start the resonate service which continually checks for pending promises
+     * every `delay` ms.
      *
-     * @template T The return type of the function.
-     * @param id A unique id for the function invocation.
-     * @param name The function name.
-     * @param argsWithOpts The function arguments.
-     * @returns A promise that resolve to the function return value.
+     * @param delay Frequency in ms to check for pending promises.
      */
-    run(nameOrTfc, id, ...argsWithOpts) {
-        let tfc;
-        if (typeof nameOrTfc === "string") {
-            const { args, opts: givenOpts } = utils.split(argsWithOpts);
-            const { durable, eidFn, idempotencyKeyFn, retry, tags, timeout, version } = givenOpts;
-            if (!id) {
-                throw new Error("Id was not set for a top level function call");
+    async start(delay = 5000) {
+        clearInterval(this.#interval);
+        this.#_start();
+        this.#interval = setInterval(this.#_start.bind(this), delay);
+    }
+    /**
+     * Stop the resonate service.
+     */
+    async stop() {
+        clearInterval(this.#interval);
+    }
+    async #_start() {
+        try {
+            for await (const promises of this.promisesStore.search("*", "pending", { "resonate:invocation": "true" })) {
+                for (const promiseRecord of promises) {
+                    const param = this.defaultInvocationOptions.encoder.decode(promiseRecord.param.data);
+                    if (param &&
+                        typeof param === "object" &&
+                        "func" in param &&
+                        typeof param.func === "string" &&
+                        "version" in param &&
+                        typeof param.version === "number" &&
+                        "args" in param &&
+                        Array.isArray(param.args) &&
+                        "retryPolicy" in param &&
+                        retryPolicies.isRetryPolicy(param.retryPolicy)) {
+                        // Since the promise is already created on the server, we should use that idempotencyKey.
+                        // If for whatever reason it is not, we should recalculate it using our defaults.
+                        const idempotencyKeyFn = (_) => {
+                            return (promiseRecord.idempotencyKeyForCreate ??
+                                this.defaultInvocationOptions.idempotencyKeyFn(promiseRecord.id));
+                        };
+                        await this.invokeLocal(param.func, promiseRecord.id, ...param.args, (0, options_1.options)({
+                            retryPolicy: param.retryPolicy,
+                            version: param.version,
+                            idempotencyKeyFn,
+                        }));
+                    }
+                }
             }
-            tfc = {
-                funcName: nameOrTfc,
-                id,
-                args,
-                optsOverrides: {
-                    durable,
-                    eidFn,
-                    idempotencyKeyFn,
-                    retry,
-                    tags,
-                    timeout,
-                    version,
-                },
-            };
         }
-        else {
-            tfc = nameOrTfc;
-        }
-        return this._run(tfc);
-    }
-    _run(tfc) {
-        // Sets the defaults for the optional fields of TFC
-        tfc.optsOverrides = tfc.optsOverrides ?? {};
-        tfc.args = tfc.args ?? [];
-        tfc.optsOverrides.version = tfc.optsOverrides.version || 0;
-        if (!this.functions[tfc.funcName] || !this.functions[tfc.funcName][tfc.optsOverrides.version]) {
-            throw new Error(`Function ${tfc.funcName} version ${tfc.optsOverrides.version} not registered`);
-        }
-        // the options registered with the function are the defaults
-        const { func, opts: registeredOpts } = this.functions[tfc.funcName][tfc.optsOverrides.version];
-        // merge defaults with override to get opts
-        const opts = utils.mergeObjects(tfc.optsOverrides, registeredOpts);
-        // We want to preserve the version that was registered with the function
-        // when calling the function with `version=0` we will find the latest
-        // registered version of a function, but we want to make sure the registered
-        // version is preserved.
+        catch (e) {
+            // squash all errors and log,
+            // transient errors will be ironed out in the next interval
+            this.logger.error(e);
+        }
+    }
+    async run(name, id, ...argsWithOverrides) {
+        const handle = await this.invokeLocal(name, id, ...argsWithOverrides);
+        return await handle.result();
+    }
+    async invokeLocal(name, id, ...argsWithOverrides) {
+        if (this.#invocationHandles.has(id)) {
+            return this.#invocationHandles.get(id);
+        }
+        const { args, opts: optionOverrides } = utils.split(argsWithOverrides);
+        // version 0 means the latest registered version
+        const givenVersion = optionOverrides?.version ?? 0;
+        // guarantees we only use the overrides in case the user pass an object with more properties
+        const { eidFn, idempotencyKeyFn, retryPolicy, tags, timeout, version } = optionOverrides;
+        const { func, opts: registeredOpts } = this.registeredFunction(name, givenVersion);
+        const opts = utils.mergeObjects({
+            eidFn,
+            idempotencyKeyFn,
+            retryPolicy,
+            tags,
+            timeout,
+            version,
+        }, registeredOpts);
+        // We want to preserve the registered version.
         opts.version = registeredOpts.version;
-        // For tags we need to merge the objects themselves and add the
+        // For tags we need to merge the objects themselves
+        // giving priority to the passed tags and add the
         // resonate:invocation tag to identify a top level invocation
-        opts.tags = { ...registeredOpts.tags, ...tfc.optsOverrides.tags, "resonate:invocation": "true" };
+        opts.tags = { ...registeredOpts.tags, ...tags, "resonate:invocation": "true" };
         // lock on top level is true by default
-        opts.lock = opts.lock ?? true;
-        return this.execute(tfc.funcName, tfc.id, func, tfc.args, opts);
-    }
-    // Gets the registered options for a specific function and version
-    // that has been previously registered.
-    registeredOptions(name, version) {
-        if (!this.functions[name] || !this.functions[name][version]) {
-            throw new Error(`Function ${name} version ${version} not registered`);
-        }
-        const { opts } = this.functions[name][version];
-        return opts;
+        opts.shouldLock = opts.shouldLock ?? true;
+        const param = {
+            func: name,
+            version: opts.version,
+            retryPolicy: opts.retryPolicy,
+            args,
+        };
+        const idempotencyKey = opts.idempotencyKeyFn(id);
+        const storedPromise = await this.promisesStore.create(id, idempotencyKey, false, undefined, opts.encoder.encode(param), Date.now() + opts.timeout, opts.tags);
+        const ctx = Context.createRootContext(this, { id, name, opts, eid: opts.eidFn(id) });
+        const resultPromise = _runFunc(func, ctx, args, idempotencyKey, storedPromise, this.store.locks, this.store.promises);
+        const handle = new InvocationHandle(id, resultPromise);
+        this.#invocationHandles.set(id, handle);
+        return handle;
     }
-    schedule(name, cron, func, ...argsWithOpts) {
+    async schedule(name, cron, func, ...argsWithOpts) {
         const { args, opts: givenOpts } = utils.split(argsWithOpts);
-        const opts = this.defaults(givenOpts);
+        const opts = this.withDefaultOpts(givenOpts);
         if (typeof func === "function") {
             // if function is provided, the default version is 1
             // as opposed to 0 (alias for latest version)
@@ -201,10 +250,7 @@ class ResonateBase {
             this.register(name, func, opts);
         }
         const funcName = typeof func === "string" ? func : name;
-        if (!this.functions[funcName] || !this.functions[funcName][opts.version]) {
-            throw new Error(`Function ${funcName} version ${opts.version} not registered`);
-        }
-        const { opts: { retry, version, timeout, tags: promiseTags }, } = this.functions[funcName][opts.version];
+        const { opts: { retryPolicy: retry, version, timeout, tags: promiseTags }, } = this.registeredFunction(funcName, opts.version);
         const idempotencyKey = opts.idempotencyKeyFn(funcName);
         const promiseParam = {
             func: funcName,
@@ -212,83 +258,460 @@ class ResonateBase {
             retryPolicy: retry,
             args,
         };
-        return this.schedules.create(name, cron, "{{.id}}.{{.timestamp}}", timeout, {
+        return await this.schedules.create(name, cron, "{{.id}}.{{.timestamp}}", timeout, {
             idempotencyKey,
             promiseParam,
             promiseTags,
         });
     }
+    withDefaultOpts(givenOpts = {}) {
+        // merge tags
+        const tags = { ...this.defaultInvocationOptions.tags, ...givenOpts.tags };
+        return {
+            ...this.defaultInvocationOptions,
+            ...givenOpts,
+            tags,
+        };
+    }
+}
+exports.Resonate = Resonate;
+class Context {
+    #resonate;
+    #stopAllPolling = false;
+    #invocationHandles;
+    #aborted;
+    #abortCause;
+    #resources;
+    #finalizers;
+    childrenCount;
+    invocationData;
+    parent;
+    root;
+    constructor(resonate, invocationData, parent) {
+        this.#resonate = resonate;
+        this.#invocationHandles = new Map();
+        this.#resources = new Map();
+        this.#finalizers = [];
+        this.#aborted = false;
+        this.parent = parent;
+        this.root = !parent ? this : parent.root;
+        this.invocationData = invocationData;
+        this.childrenCount = 0;
+    }
+    static createRootContext(resonate, invocationData) {
+        return new Context(resonate, invocationData, undefined);
+    }
+    static createChildrenContext(parentCtx, invocationData) {
+        return new Context(parentCtx.#resonate, invocationData, parentCtx);
+    }
+    async onRetry() {
+        this.childrenCount = 0;
+        await this.finalize();
+    }
+    async finalize() {
+        // It is important to await all promises before finalizing the resources
+        // doing it the other way around could cause problems
+        await Promise.allSettled(Array.from(this.#invocationHandles, ([_, handle]) => handle.result()));
+        // We need to run the finalizers in reverse insertion order since later set finalizers might have
+        // a dependency in early set resources
+        for (const finalizer of this.#finalizers.reverse()) {
+            await finalizer();
+        }
+        this.#resources.clear();
+        this.#finalizers = [];
+    }
+    abort(cause) {
+        this.#aborted = true;
+        this.#abortCause = cause;
+        this.root.#aborted = true;
+        this.root.#abortCause = cause;
+    }
+    get aborted() {
+        return this.#aborted;
+    }
+    get abortCause() {
+        return this.#abortCause;
+    }
     /**
-     * Construct options.
+     * Adds a finalizer function to be executed at the end of the current context.
+     * Finalizers are run in reverse order of their definition (last-in, first-out).
+     *
+     * @param fn - An asynchronous function to be executed as a finalizer.
+     *             It should return a Promise that resolves to void.
      *
-     * @param opts A partial {@link Options} object.
-     * @returns PartialOptions.
+     * @remarks
+     * Finalizer functions must be non fallible.
      */
-    options(opts = {}) {
-        return { ...opts, __resonate: true };
+    addFinalizer(fn) {
+        this.#finalizers.push(fn);
     }
     /**
-     * Start the resonate service which continually checks for pending promises
-     * every `delay` ms.
+     * Sets a named resource for the current context and optionally adds a finalizer.
      *
-     * @param delay Frequency in ms to check for pending promises.
+     * @param name - A unique string identifier for the resource.
+     * @param resource - The resource to be stored. Can be of any type.
+     * @param finalizer - Optional. An asynchronous function to be executed when the context ends.
+     *                    Finalizers are run in reverse order of their addition to the context and
+     *                    must not fail.
+     * @throws {Error} Throws an error if a resource with the same name already exists in the current context.
+     *
+     * This method associates a resource with a unique name in the current context.
+     * If a finalizer is provided, it will be executed when the context ends.
+     * Finalizers are useful for cleanup operations, such as closing connections or freeing resources.
      */
-    start(delay = 5000) {
-        clearInterval(this.interval);
-        this._start();
-        this.interval = setInterval(() => this._start(), delay);
+    setResource(name, resource, finalizer) {
+        if (this.#resources.has(name)) {
+            throw new Error("Resource already set for this context");
+        }
+        this.#resources.set(name, resource);
+        if (finalizer) {
+            this.#finalizers.push(finalizer);
+        }
     }
     /**
-     * Stop the resonate service.
+     * Retrieves a resource by name from the current context or its parent contexts.
+     *
+     * @template R - The expected type of the resource.
+     * @param name - The unique string identifier of the resource to retrieve.
+     * @returns The resource of type R if found, or undefined if not found.
+     *
+     * This method searches for a resource in the following order:
+     * 1. In the current context.
+     * 2. If not found, it recursively searches in parent contexts.
+     * 3. Returns undefined if the resource is not found in any context.
+     *
+     * @remarks
+     * The method uses type assertion to cast the resource to type R.
+     * Ensure that the type parameter R matches the actual type of the stored resource
+     * to avoid runtime type errors.
      */
-    stop() {
-        clearInterval(this.interval);
+    getResource(name) {
+        const resource = this.#resources.get(name);
+        if (resource) {
+            return resource;
+        }
+        return this.parent ? this.parent.getResource(name) : undefined;
     }
-    defaults({ durable = true, eidFn = utils.randomId, encoder = this.encoder, idempotencyKeyFn = utils.hash, lock = undefined, poll = this.poll, retry = this.retry, tags = {}, timeout = this.timeout, version = 0, } = {}) {
-        // merge tags
-        tags = { ...this.tags, ...tags };
-        return {
-            __resonate: true,
-            eidFn,
-            durable,
-            encoder,
-            idempotencyKeyFn,
-            lock,
-            poll,
-            retry,
-            tags,
-            timeout,
-            version,
-        };
+    options(opts) {
+        return (0, options_1.options)(opts);
     }
-    async _start() {
-        try {
-            for await (const promises of this.promises.search("*", "pending", { "resonate:invocation": "true" })) {
-                for (const promise of promises) {
-                    const param = promise.param();
-                    if (param &&
-                        typeof param === "object" &&
-                        "func" in param &&
-                        typeof param.func === "string" &&
-                        "version" in param &&
-                        typeof param.version === "number" &&
-                        "args" in param &&
-                        Array.isArray(param.args) &&
-                        "retryPolicy" in param &&
-                        retryPolicy.isRetryPolicy(param.retryPolicy)) {
-                        const { func, opts } = this.functions[param.func][param.version];
-                        opts.retry = param.retryPolicy;
-                        this.execute(param.func, promise.id, func, param.args, opts, promise);
-                    }
+    async run(funcOrId, ...argsWithOpts) {
+        let handle;
+        if (typeof funcOrId === "string") {
+            handle = await this.invokeRemote(funcOrId, ...argsWithOpts);
+        }
+        else {
+            handle = await this.invokeLocal(funcOrId, ...argsWithOpts);
+        }
+        return await handle.result();
+    }
+    async invokeRemote(funcId, ...argsWithOpts) {
+        if (this.#invocationHandles.has(funcId)) {
+            return this.#invocationHandles.get(funcId);
+        }
+        const { opts: givenOpts } = utils.split(argsWithOpts);
+        const { opts: registeredOpts } = this.#resonate.registeredFunction(this.root.invocationData.name, this.root.invocationData.opts.version);
+        const opts = { ...registeredOpts, ...givenOpts };
+        // Merge the tags
+        opts.tags = { ...registeredOpts.tags, ...givenOpts?.tags };
+        // Default lock is false for children execution
+        opts.shouldLock = opts.shouldLock ?? false;
+        // Children execution do not need params since we don't go trough the recovery path with children
+        const param = {};
+        const idempotencyKey = opts.idempotencyKeyFn(funcId);
+        const storedPromise = await this.#resonate.promisesStore.create(funcId, idempotencyKey, false, undefined, opts.encoder.encode(param), Date.now() + opts.timeout, opts.tags);
+        const runFunc = async () => {
+            while (!this.#stopAllPolling) {
+                const durablePromiseRecord = await this.#resonate.promisesStore.get(storedPromise.id);
+                switch (durablePromiseRecord.state) {
+                    case "RESOLVED":
+                        return opts.encoder.decode(durablePromiseRecord.value.data);
+                    case "REJECTED":
+                        throw opts.encoder.decode(durablePromiseRecord.value.data);
+                    case "REJECTED_CANCELED":
+                        throw new errors_1.ResonateError("Resonate function canceled", errors_1.ErrorCodes.CANCELED, opts.encoder.decode(durablePromiseRecord.value.data));
+                    case "REJECTED_TIMEDOUT":
+                        throw new errors_1.ResonateError(`Resonate function timedout at ${new Date(durablePromiseRecord.timeout).toISOString()}`, errors_1.ErrorCodes.TIMEDOUT);
+                    case "PENDING":
+                        break;
                 }
+                // TODO: Consider using exponential backoff instead.
+                (0, utils_1.sleep)(opts.pollFrequency);
             }
+            throw new Error(`Polling of remote invocation with ${funcId} was stopped`);
+        };
+        const resultPromise = runFunc();
+        const invocationHandle = new InvocationHandle(funcId, resultPromise);
+        this.#invocationHandles.set(funcId, invocationHandle);
+        return invocationHandle;
+    }
+    async invokeLocal(func, ...argsWithOpts) {
+        const { args, opts: givenOpts } = utils.split(argsWithOpts);
+        const { opts: registeredOpts } = this.#resonate.registeredFunction(this.root.invocationData.name, this.root.invocationData.opts.version);
+        const opts = { ...registeredOpts, ...givenOpts };
+        // Merge the tags
+        opts.tags = { ...registeredOpts.tags, ...givenOpts.tags };
+        // Default lock is false for children execution
+        opts.shouldLock = opts.shouldLock ?? false;
+        this.childrenCount++;
+        // If it is an anonymous function give at anon name nested within the current invocation name
+        const name = func.name ? func.name : `${this.invocationData.name}__anon${this.childrenCount}`;
+        const id = `${this.invocationData.id}.${this.childrenCount}.${name}`;
+        if (this.#invocationHandles.has(id)) {
+            return this.#invocationHandles.get(id);
         }
-        catch (e) {
-            // squash all errors and log,
-            // transient errors will be ironed out in the next interval
-            this.logger.error(e);
+        const ctx = Context.createChildrenContext(this, { name, id, eid: opts.eidFn(id), opts });
+        if (!opts.durable) {
+            const runFunc = async () => {
+                const timeout = Date.now() + opts.timeout;
+                return (await (0, retry_1.runWithRetry)(async () => await func(ctx, ...args), async () => await ctx.onRetry(), opts.retryPolicy, timeout));
+            };
+            const resultPromise = runFunc();
+            const handle = new InvocationHandle(id, resultPromise);
+            this.#invocationHandles.set(id, handle);
+            return handle;
+        }
+        // Children execution do not need params since we don't go trough the recovery path with children
+        const param = {};
+        const idempotencyKey = opts.idempotencyKeyFn(id);
+        const storedPromise = await this.#resonate.promisesStore.create(id, idempotencyKey, false, undefined, opts.encoder.encode(param), Date.now() + opts.timeout, opts.tags);
+        const resultPromise = _runFunc(func, ctx, args, idempotencyKey, storedPromise, this.#resonate.store.locks, this.#resonate.store.promises);
+        const invocationHandle = new InvocationHandle(id, resultPromise);
+        this.#invocationHandles.set(id, invocationHandle);
+        return invocationHandle;
+    }
+    /**
+     * Durable version of sleep.
+     * Sleep for the specified time (ms).
+     *
+     * @param ms Amount of time to sleep in milliseconds.
+     * @returns A Promise that resolves after the specified time has elapsed.
+     */
+    async sleep(ms) {
+        const id = `${this.invocationData.id}.${this.childrenCount++}`;
+        const handle = await this.invokeRemote(id, (0, options_1.options)({ timeout: ms, pollFrequency: ms, tags: { "resonate:timeout": "true" }, durable: true }));
+        await handle.result();
+    }
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     *
+     * @param values An array of Promises.
+     * @param opts Optional {@link options}.
+     * @returns A new ResonatePromise.
+     */
+    all(values, opts = {}) {
+        // catch all promises to prevent unhandled promise rejections,
+        // since Promise.all will not be called in the case where the
+        // durable promise already completed
+        for (const v of values) {
+            if (v instanceof Promise)
+                v.catch(() => { });
+        }
+        // prettier-ignore
+        return this.run(() => Promise.all(values), (0, options_1.options)({
+            retryPolicy: retryPolicies.never(),
+            ...opts,
+        }));
+    }
+    /**
+     * Creates a Promise that is fulfilled by the first given promise to be fulfilled, or rejected
+     * with an AggregateError.
+     *
+     * @param values An array of Promises.
+     * @param opts Optional {@link options}.
+     * @returns A new ResonatePromise.
+     */
+    any(values, opts = {}) {
+        // catch all promises to prevent unhandled promise rejections,
+        // since Promise.any will not be called in the case where the
+        // durable promise already completed
+        for (const v of values) {
+            if (v instanceof Promise)
+                v.catch(() => { });
+        }
+        // prettier-ignore
+        return this.run(() => Promise.any(values), (0, options_1.options)({
+            retryPolicy: retryPolicies.never(),
+            ...opts,
+        }));
+    }
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     *
+     * @param values An array of Promises.
+     * @param opts Optional {@link options}.
+     * @returns A new ResonatePromise.
+     */
+    race(values, opts = {}) {
+        // catch all promises to prevent unhandled promise rejections,
+        // since Promise.race will not be called in the case where the
+        // durable promise already completed
+        for (const v of values) {
+            if (v instanceof Promise)
+                v.catch(() => { });
+        }
+        // prettier-ignore
+        return this.run(() => Promise.race(values), (0, options_1.options)({
+            retryPolicy: retryPolicies.never(),
+            ...opts,
+        }));
+    }
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve or reject.
+     *
+     * @param values An array of Promises.
+     * @param opts Optional {@link options}.
+     * @returns A new Promise.
+     */
+    allSettled(values, opts = {}) {
+        // catch all promises to prevent unhandled promise rejections,
+        // since Promise.allSettled will not be called in the case where the
+        // durable promise already completed
+        for (const v of values) {
+            if (v instanceof Promise)
+                v.catch(() => { });
         }
+        // prettier-ignore
+        return this.run(() => Promise.allSettled(values), (0, options_1.options)({
+            retryPolicy: retryPolicies.never(),
+            ...opts,
+        }));
+    }
+    /**
+     * Invoke a Resonate function in detached mode. Functions must first be registered with Resonate.
+     * a detached invocation will not be implecitly awaited at the end of the current context, instead
+     * it will be "supervised" as a top level invocation.
+     *
+     * @template R The return type of the function.
+     * @param id A unique id for the function invocation.
+     * @param name The function name.
+     * @param argsWithOverrides The function arguments and options overrides.
+     * @returns A Res.
+     */
+    async detached(name, id, ...argsWithOverrides) {
+        return await this.#resonate.invokeLocal(name, id, ...argsWithOverrides);
     }
 }
-exports.ResonateBase = ResonateBase;
+exports.Context = Context;
+class InvocationHandle {
+    invocationId;
+    resultPromise;
+    constructor(invocationId, resultPromise) {
+        this.invocationId = invocationId;
+        this.resultPromise = resultPromise;
+    }
+    /**
+     * get the current state of the resultPromise.
+     *
+     */
+    async state() {
+        return await utils.promiseState(this.resultPromise);
+    }
+    async result() {
+        return this.resultPromise;
+    }
+}
+exports.InvocationHandle = InvocationHandle;
+const acquireLock = async (id, eid, locksStore) => {
+    try {
+        return await locksStore.tryAcquire(id, eid);
+    }
+    catch (e) {
+        // if lock is already acquired, return false so we can poll
+        if (e instanceof errors_1.ResonateError && e.code === errors_1.ErrorCodes.STORE_FORBIDDEN) {
+            return false;
+        }
+        throw e;
+    }
+};
+const _runFunc = async (func, ctx, args, idempotencyKey, storedPromise, locksStore, promisesStore) => {
+    const { id, eid, opts } = ctx.invocationData;
+    // If the promise that comes back from the server is already completed, resolve or reject right away.
+    switch (storedPromise.state) {
+        case "RESOLVED":
+            return opts.encoder.decode(storedPromise.value.data);
+        case "REJECTED":
+            throw opts.encoder.decode(storedPromise.value.data);
+        case "REJECTED_CANCELED":
+            throw new errors_1.ResonateError("Resonate function canceled", errors_1.ErrorCodes.CANCELED, opts.encoder.decode(storedPromise.value.data));
+        case "REJECTED_TIMEDOUT":
+            throw new errors_1.ResonateError(`Resonate function timedout at ${new Date(storedPromise.timeout).toISOString()}`, errors_1.ErrorCodes.TIMEDOUT);
+    }
+    // storedPromise.state === "PENDING"
+    try {
+        // Acquire the lock if necessary
+        if (opts.shouldLock) {
+            while (!(await acquireLock(id, eid, locksStore))) {
+                await (0, utils_1.sleep)(opts.pollFrequency);
+            }
+        }
+        let error;
+        let value;
+        // we need to hold on to a boolean to determine if the function was successful,
+        // we cannot rely on the value or error as these values could be undefined
+        let success = true;
+        try {
+            value = await (0, retry_1.runWithRetry)(async () => await func(ctx, ...args), async () => await ctx.onRetry(), opts.retryPolicy, storedPromise.timeout);
+        }
+        catch (e) {
+            // We need to capture the error to be able to reject the durable promise,
+            // after that we will then propagate this error by rejecting the result promise
+            error = e;
+            success = false;
+        }
+        finally {
+            // Resonate will implicitly await all the invocationHandles as the last
+            // thing it does with the context before it goes out of scope
+            await ctx.finalize();
+        }
+        if (ctx.root.aborted) {
+            throw new errors_1.ResonateError("Unrecoverable Error: Aborting", errors_1.ErrorCodes.ABORT, ctx.root.abortCause);
+        }
+        let completedPromiseRecord;
+        if (success) {
+            completedPromiseRecord = await promisesStore.resolve(id, idempotencyKey, false, storedPromise.value.headers, opts.encoder.encode(value));
+        }
+        else {
+            completedPromiseRecord = await promisesStore.reject(id, idempotencyKey, false, storedPromise.value.headers, opts.encoder.encode(error));
+        }
+        // Because of eventual consistency and recovery paths it is possible that we get a
+        // rejected promise even if we did call `resolve` on it or the other way around.
+        // What should never happen is that we get a "PENDING" promise
+        switch (completedPromiseRecord.state) {
+            case "RESOLVED":
+                return value;
+            case "REJECTED":
+                throw error;
+            case "REJECTED_CANCELED":
+                throw new errors_1.ResonateError("Resonate function canceled", errors_1.ErrorCodes.CANCELED, error);
+            case "REJECTED_TIMEDOUT":
+                throw new errors_1.ResonateError(`Resonate function timedout at ${new Date(completedPromiseRecord.timeout).toISOString()}`, errors_1.ErrorCodes.TIMEDOUT);
+            case "PENDING":
+                throw new Error("Unreachable");
+        }
+    }
+    catch (err) {
+        if (err instanceof errors_1.ResonateError && (err.code === errors_1.ErrorCodes.CANCELED || err.code === errors_1.ErrorCodes.TIMEDOUT)) {
+            // Cancel and timeout errors, just forward them
+            throw err;
+        }
+        else if (err instanceof errors_1.ResonateError && err.code !== errors_1.ErrorCodes.ABORT) {
+            // Any other instance of ResonateError we must abort the current execution.
+            ctx.abort(err);
+            throw new errors_1.ResonateError("Unrecoverable Error: Aborting", errors_1.ErrorCodes.ABORT, err);
+        }
+        else {
+            throw err;
+        }
+    }
+    finally {
+        // release lock if necessary
+        if (opts.shouldLock) {
+            await locksStore.release(id, eid);
+        }
+    }
+};
 //# sourceMappingURL=resonate.js.map