@resonatehq/sdk 0.6.2 → 0.7.0

package/dist/resonate.js

@@ -1,718 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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 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"));
-const utils_1 = require("./core/utils");
-//////////////////////////////////////////////////////////////////////
-class Resonate {
-    #registeredFunctions = {};
-    #invocationHandles;
-    #interval;
-    store;
-    logger;
-    defaultInvocationOptions;
-    promises;
-    schedules;
-    constructor({ auth = undefined, encoder = new json_1.JSONEncoder(), heartbeat = 15000, // 15s
-    logger = new logger_1.Logger(), pid = utils.randomId(), pollFrequency = 5000, // 5s
-    retryPolicy = retryPolicies.exponential(), store = undefined, tags = {}, timeout = 10000, // 10s
-    url = undefined, } = {}) {
-        if (store) {
-            this.store = store;
-        }
-        else if (url) {
-            this.store = new remote_1.RemoteStore(url, {
-                auth,
-                heartbeat,
-                logger,
-                pid,
-            });
-        }
-        else {
-            this.store = new local_1.LocalStore({
-                auth,
-                heartbeat,
-                logger,
-                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 = {}) => 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, 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 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.#registeredFunctions[name]) {
-            this.#registeredFunctions[name] = {};
-        }
-        if (this.#registeredFunctions[name][options.version]) {
-            throw new Error(`Function ${name} version ${options.version} already registered`);
-        }
-        // 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.#registeredFunctions[name][options.version] = { func, opts: options };
-    }
-    registerModule(module, opts = {}) {
-        for (const key in module) {
-            this.register(key, module[key], opts);
-        }
-    }
-    /**
-     * Start the resonate service which continually checks for pending promises
-     * every `delay` ms.
-     *
-     * @param delay Frequency in ms to check for pending promises.
-     */
-    async start(delay = 5000) {
-        clearInterval(this.#interval);
-        // await the first run of the recovery path to avoid races with the normal flow of the program
-        await 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,
-                        }));
-                    }
-                }
-            }
-        }
-        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
-        // giving priority to the passed tags and add the
-        // resonate:invocation tag to identify a top level invocation
-        opts.tags = { ...registeredOpts.tags, ...tags, "resonate:invocation": "true" };
-        // locking is false by default
-        opts.shouldLock = opts.shouldLock ?? false;
-        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;
-    }
-    async schedule(name, cron, func, ...argsWithOpts) {
-        const { args, opts: givenOpts } = utils.split(argsWithOpts);
-        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)
-            opts.version = opts.version || 1;
-            this.register(name, func, opts);
-        }
-        const funcName = typeof func === "string" ? func : name;
-        const { opts: { retryPolicy: retry, version, timeout, tags: promiseTags }, } = this.registeredFunction(funcName, opts.version);
-        const idempotencyKey = opts.idempotencyKeyFn(funcName);
-        const promiseParam = {
-            func: funcName,
-            version,
-            retryPolicy: retry,
-            args,
-        };
-        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;
-    }
-    /**
-     * 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.
-     *
-     * @remarks
-     * Finalizer functions must be non fallible.
-     */
-    addFinalizer(fn) {
-        this.#finalizers.push(fn);
-    }
-    /**
-     * Sets a named resource for the current context and optionally adds a finalizer.
-     *
-     * @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.
-     */
-    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);
-        }
-    }
-    /**
-     * 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.
-     */
-    getResource(name) {
-        const resource = this.#resources.get(name);
-        if (resource) {
-            return resource;
-        }
-        return this.parent ? this.parent.getResource(name) : undefined;
-    }
-    options(opts) {
-        return (0, options_1.options)(opts);
-    }
-    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);
-        }
-        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.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