@resonatehq/sdk 0.3.2 → 0.3.4

package/dist/core/execution.js

@@ -0,0 +1,195 @@
+import { ErrorCodes, ResonateError } from "./errors";
+import { ResonatePromise } from "./future";
+import { DurablePromise } from "./promises/promises";
+/////////////////////////////////////////////////////////////////////
+// Execution
+/////////////////////////////////////////////////////////////////////
+export class Execution {
+    invocation;
+    promise = null;
+    /**
+     * Represents an execution of a Resonate function invocation.
+     *
+     * @constructor
+     * @param invocation - An invocation correpsonding to the Resonate function.
+     */
+    constructor(invocation) {
+        this.invocation = invocation;
+    }
+    execute() {
+        if (this.promise) {
+            return this.promise;
+        }
+        const forkPromise = this.fork();
+        const joinPromise = forkPromise.then((f) => this.join(f));
+        this.promise = new ResonatePromise(this.invocation.id, forkPromise, joinPromise);
+        return this.promise;
+    }
+    get killed() {
+        return this.invocation.root.killed;
+    }
+    kill(error) {
+        // this will mark the entire invocation tree as killed
+        this.invocation.root.killed = true;
+        // reject only the root invocation
+        this.invocation.root.reject(new ResonateError("Resonate function killed", ErrorCodes.KILLED, error, true));
+    }
+    tags() {
+        if (this.invocation.parent === null) {
+            return { ...this.invocation.opts.tags, "resonate:invocation": "true" };
+        }
+        return this.invocation.opts.tags;
+    }
+}
+export class OrdinaryExecution extends Execution {
+    func;
+    retry;
+    constructor(invocation, func, retry = invocation.opts.retry) {
+        super(invocation);
+        this.func = func;
+        this.retry = retry;
+    }
+    async fork() {
+        try {
+            // create a durable promise
+            const promise = await DurablePromise.create(this.invocation.opts.store.promises, this.invocation.opts.encoder, this.invocation.id, this.invocation.timeout, this.invocation.param, {
+                idempotencyKey: this.invocation.idempotencyKey,
+                headers: this.invocation.headers,
+                tags: this.tags(),
+            });
+            if (promise.pending) {
+                // if pending, invoke the function and resolve/reject the durable promise
+                await this.run().then((v) => promise.resolve(v, { idempotencyKey: this.invocation.idempotencyKey }), (e) => promise.reject(e, { idempotencyKey: this.invocation.idempotencyKey }));
+            }
+            // resolve/reject the invocation
+            if (promise.resolved) {
+                this.invocation.resolve(promise.value());
+            }
+            else if (promise.rejected || promise.canceled || promise.timedout) {
+                this.invocation.reject(promise.error());
+            }
+        }
+        catch (e) {
+            // if an error occurs, kill the execution
+            this.kill(e);
+        }
+        return this.invocation.future;
+    }
+    async join(future) {
+        return await future.promise;
+    }
+    async run() {
+        let error;
+        // invoke the function according to the retry policy
+        for (const delay of this.retry.iterator(this.invocation)) {
+            try {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return await this.func();
+            }
+            catch (e) {
+                error = e;
+                // bump the attempt count
+                this.invocation.attempt++;
+            }
+        }
+        // if all attempts fail throw the last error
+        throw error;
+    }
+}
+export class DeferredExecution extends Execution {
+    constructor(invocation) {
+        super(invocation);
+    }
+    async fork() {
+        try {
+            // create a durable promise
+            const promise = await DurablePromise.create(this.invocation.opts.store.promises, this.invocation.opts.encoder, this.invocation.id, this.invocation.timeout, this.invocation.param, {
+                idempotencyKey: this.invocation.idempotencyKey,
+                headers: this.invocation.headers,
+                tags: this.tags(),
+                poll: true,
+            });
+            // poll the completion of the durable promise
+            promise.completed.then((p) => p.resolved ? this.invocation.resolve(p.value()) : this.invocation.reject(p.error()));
+        }
+        catch (e) {
+            // if an error occurs, kill the execution
+            this.kill(e);
+        }
+        return this.invocation.future;
+    }
+    async join(future) {
+        return await future.promise;
+    }
+}
+export class GeneratorExecution extends Execution {
+    generator;
+    constructor(invocation, generator) {
+        super(invocation);
+        this.generator = generator;
+    }
+    async create() {
+        try {
+            // create a durable promise
+            const promise = await DurablePromise.create(this.invocation.opts.store.promises, this.invocation.opts.encoder, this.invocation.id, this.invocation.timeout, this.invocation.param, {
+                idempotencyKey: this.invocation.idempotencyKey,
+                headers: this.invocation.headers,
+                tags: this.tags(),
+            });
+            // resolve/reject the invocation if already completed
+            if (promise.resolved) {
+                this.invocation.resolve(promise.value());
+            }
+            else if (promise.rejected || promise.canceled || promise.timedout) {
+                this.invocation.reject(promise.error());
+            }
+            return promise;
+        }
+        catch (e) {
+            // if an error occurs, kill the execution
+            this.kill(e);
+        }
+    }
+    async resolve(promise, value) {
+        try {
+            // resolve the durable promise
+            await promise.resolve(value, { idempotencyKey: this.invocation.idempotencyKey });
+            // resolve/reject the invocation
+            if (promise.resolved) {
+                this.invocation.resolve(promise.value());
+            }
+            else if (promise.rejected || promise.canceled || promise.timedout) {
+                this.invocation.reject(promise.error());
+            }
+        }
+        catch (e) {
+            // if an error occurs, kill the execution
+            this.kill(e);
+        }
+        return promise;
+    }
+    async reject(promise, error) {
+        try {
+            // reject the durable promise
+            await promise.reject(error, { idempotencyKey: this.invocation.idempotencyKey });
+            // resolve/reject the invocation
+            if (promise.resolved) {
+                this.invocation.resolve(promise.value());
+            }
+            else if (promise.rejected || promise.canceled || promise.timedout) {
+                this.invocation.reject(promise.error());
+            }
+        }
+        catch (e) {
+            // if an error occurs, kill the execution
+            this.kill(e);
+        }
+        return promise;
+    }
+    async fork() {
+        return this.invocation.future;
+    }
+    async join(future) {
+        return await future.promise;
+    }
+}

package/dist/core/future.d.ts

@@ -0,0 +1,54 @@
+import { Invocation } from "./invocation";
+export declare class ResonatePromise<T> extends Promise<T> {
+    id: string;
+    created: Promise<string>;
+    static [Symbol.species]: PromiseConstructor;
+    /**
+     * Represents the eventual return value of a Resonate function. This is achieved by wrapping a Javscript promise.
+     *
+     * @constructor
+     * @param id - A unique identifier for this promise.
+     * @param created - A promise that resolves when the durable promise has been created.
+     * @param completed - A promise that resolves when the durable promise has been fulfilled.
+     */
+    constructor(id: string, created: Promise<any>, completed: Promise<T>);
+}
+export type Value<T> = {
+    kind: "pending";
+} | {
+    kind: "resolved";
+    value: T;
+} | {
+    kind: "rejected";
+    error: unknown;
+};
+export declare class Future<T> {
+    private invocation;
+    promise: Promise<T>;
+    private _resolve;
+    private _reject;
+    readonly kind = "future";
+    private _value;
+    /**
+     * Represents the eventual return value of a Resonate function.
+     *
+     * @constructor
+     * @param invocation - An invocation correpsonding to the Resonate function.
+     * @param promise - A promise that resolves to the return value of the Resonate function.
+     */
+    constructor(invocation: Invocation<T>, promise: Promise<T>, _resolve: (v: T) => void, _reject: (v?: unknown) => void);
+    static deferred<T>(invocation: Invocation<T>): {
+        future: Future<T>;
+        resolve: (value: T) => void;
+        reject: (error: unknown) => void;
+    };
+    get id(): string;
+    get idempotencyKey(): string | undefined;
+    get root(): Future<any>;
+    get parent(): Future<any> | null;
+    get children(): Future<any>[];
+    get value(): Value<T>;
+    private resolve;
+    private reject;
+}
+//# sourceMappingURL=future.d.ts.map

package/dist/core/future.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"future.d.ts","sourceRoot":"","sources":["../../lib/core/future.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM1C,qBAAa,eAAe,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IAkBvC,EAAE,EAAE,MAAM;IAfnB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAIzB,MAAM,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,qBAAW;IAElC;;;;;;;OAOG;gBAEM,EAAE,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,EACrB,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;CAUxB;AAMD,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAEnH,qBAAa,MAAM,CAAC,CAAC;IAejB,OAAO,CAAC,UAAU;IACX,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;IAhBjB,QAAQ,CAAC,IAAI,YAAY;IAGzB,OAAO,CAAC,MAAM,CAAiC;IAE/C;;;;;;OAMG;gBAEO,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAC1B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,EACxB,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI;IAGxC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;;;;;IAqB5C,IAAI,EAAE,WAEL;IAED,IAAI,cAAc,uBAEjB;IAED,IAAI,IAAI,gBAEP;IAED,IAAI,MAAM,uBAET;IAED,IAAI,QAAQ,kBAEX;IAED,IAAI,KAAK,aAER;IAED,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,MAAM;CAIf"}

package/dist/core/future.js

@@ -0,0 +1,95 @@
+/////////////////////////////////////////////////////////////////////
+// Promise
+/////////////////////////////////////////////////////////////////////
+export class ResonatePromise extends Promise {
+    id;
+    // resolves to the id of the durable promise
+    // can be used to await durable promise creation
+    created;
+    // You are not expected to understand this (we don't either)
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/@@species
+    static [Symbol.species] = Promise;
+    /**
+     * Represents the eventual return value of a Resonate function. This is achieved by wrapping a Javscript promise.
+     *
+     * @constructor
+     * @param id - A unique identifier for this promise.
+     * @param created - A promise that resolves when the durable promise has been created.
+     * @param completed - A promise that resolves when the durable promise has been fulfilled.
+     */
+    constructor(id, created, completed) {
+        // bind the promise to the completed promise
+        super((resolve, reject) => {
+            completed.then(resolve, reject);
+        });
+        this.id = id;
+        // expose the id when the durable promise has been created
+        this.created = created.then(() => this.id);
+    }
+}
+export class Future {
+    invocation;
+    promise;
+    _resolve;
+    _reject;
+    // a discriminate property
+    kind = "future";
+    // initial value
+    _value = { kind: "pending" };
+    /**
+     * Represents the eventual return value of a Resonate function.
+     *
+     * @constructor
+     * @param invocation - An invocation correpsonding to the Resonate function.
+     * @param promise - A promise that resolves to the return value of the Resonate function.
+     */
+    constructor(invocation, promise, _resolve, _reject) {
+        this.invocation = invocation;
+        this.promise = promise;
+        this._resolve = _resolve;
+        this._reject = _reject;
+    }
+    static deferred(invocation) {
+        let resolve;
+        let reject;
+        // construct a javascript promise
+        const promise = new Promise((_resolve, _reject) => {
+            resolve = _resolve;
+            reject = _reject;
+        });
+        // construct a new future
+        const future = new Future(invocation, promise, resolve, reject);
+        // return future and resolvers
+        return {
+            future: future,
+            resolve: future.resolve.bind(future),
+            reject: future.reject.bind(future),
+        };
+    }
+    get id() {
+        return this.invocation.id;
+    }
+    get idempotencyKey() {
+        return this.invocation.idempotencyKey;
+    }
+    get root() {
+        return this.invocation.root.future;
+    }
+    get parent() {
+        return this.invocation.parent?.future ?? null;
+    }
+    get children() {
+        return this.invocation.children.map((i) => i.future);
+    }
+    get value() {
+        return this._value;
+    }
+    resolve(value) {
+        this._resolve(value);
+        this._value = { kind: "resolved", value };
+    }
+    reject(error) {
+        this._reject(error);
+        this._value = { kind: "rejected", error };
+    }
+}

package/dist/core/invocation.d.ts

@@ -0,0 +1,43 @@
+import { Future } from "./future";
+import { Options, PartialOptions } from "./options";
+export declare class Invocation<T> {
+    readonly name: string;
+    readonly version: number;
+    readonly id: string;
+    readonly idempotencyKey: string | undefined;
+    readonly headers: Record<string, string> | undefined;
+    readonly param: unknown;
+    readonly opts: Options;
+    future: Future<T>;
+    resolve: (v: T) => void;
+    reject: (e: unknown) => void;
+    killed: boolean;
+    createdAt: number;
+    counter: number;
+    attempt: number;
+    awaited: Future<any>[];
+    blocked: Future<any> | null;
+    readonly root: Invocation<any>;
+    readonly parent: Invocation<any> | null;
+    readonly children: Invocation<any>[];
+    /**
+     * Represents a Resonate function invocation.
+     *
+     * @constructor
+     * @param id - A unique id for this invocation.
+     * @param idempotencyKey - An idempotency key used to deduplicate invocations.
+     * @param opts - The invocation options.
+     * @param parent - The parent invocation.
+     */
+    constructor(name: string, version: number, id: string, idempotencyKey: string | undefined, headers: Record<string, string> | undefined, param: unknown, opts: Options, parent?: Invocation<any>);
+    get timeout(): number;
+    addChild(child: Invocation<any>): void;
+    await(future: Future<any>): void;
+    block(future: Future<any>): void;
+    unblock(): void;
+    split(args: [...any, PartialOptions?]): {
+        args: any[];
+        opts: Options;
+    };
+}
+//# sourceMappingURL=invocation.d.ts.map

package/dist/core/invocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocation.d.ts","sourceRoot":"","sources":["../../lib/core/invocation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAoB,MAAM,WAAW,CAAC;AAMtE,qBAAa,UAAU,CAAC,CAAC;aA4BL,IAAI,EAAE,MAAM;aACZ,OAAO,EAAE,MAAM;aACf,EAAE,EAAE,MAAM;aACV,cAAc,EAAE,MAAM,GAAG,SAAS;aAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;aAC3C,KAAK,EAAE,OAAO;aACd,IAAI,EAAE,OAAO;IAjC/B,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAClB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IACxB,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAE7B,MAAM,EAAE,OAAO,CAAS;IAExB,SAAS,EAAE,MAAM,CAAc;IAC/B,OAAO,EAAE,MAAM,CAAK;IACpB,OAAO,EAAE,MAAM,CAAK;IAEpB,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAM;IAC5B,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAQ;IAEnC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAM;IAE1C;;;;;;;;OAQG;gBAEe,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,MAAM,EACV,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EAC3C,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,OAAO,EAC7B,MAAM,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC;IAW1B,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC;IAI/B,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC;IAIzB,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC;IAIzB,OAAO;IAIP,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,GAAG,EAAE,cAAc,CAAC,CAAC,GAAG;QAAE,IAAI,EAAE,GAAG,EAAE,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE;CAQvE"}

package/dist/core/invocation.js

@@ -0,0 +1,72 @@
+import { Future } from "./future";
+import { isPartialOptions } from "./options";
+/////////////////////////////////////////////////////////////////////
+// Invocation
+/////////////////////////////////////////////////////////////////////
+export class Invocation {
+    name;
+    version;
+    id;
+    idempotencyKey;
+    headers;
+    param;
+    opts;
+    future;
+    resolve;
+    reject;
+    killed = false;
+    createdAt = Date.now();
+    counter = 0;
+    attempt = 0;
+    awaited = [];
+    blocked = null;
+    root;
+    parent;
+    children = [];
+    /**
+     * Represents a Resonate function invocation.
+     *
+     * @constructor
+     * @param id - A unique id for this invocation.
+     * @param idempotencyKey - An idempotency key used to deduplicate invocations.
+     * @param opts - The invocation options.
+     * @param parent - The parent invocation.
+     */
+    constructor(name, version, id, idempotencyKey, headers, param, opts, parent) {
+        this.name = name;
+        this.version = version;
+        this.id = id;
+        this.idempotencyKey = idempotencyKey;
+        this.headers = headers;
+        this.param = param;
+        this.opts = opts;
+        const { future, resolve, reject } = Future.deferred(this);
+        this.future = future;
+        this.resolve = resolve;
+        this.reject = reject;
+        this.root = parent?.root ?? this;
+        this.parent = parent ?? null;
+    }
+    get timeout() {
+        return Math.min(this.createdAt + this.opts.timeout, this.parent?.timeout ?? Infinity);
+    }
+    addChild(child) {
+        this.children.push(child);
+    }
+    await(future) {
+        this.awaited.push(future);
+    }
+    block(future) {
+        this.blocked = future;
+    }
+    unblock() {
+        this.blocked = null;
+    }
+    split(args) {
+        const opts = args[args.length - 1];
+        const parentOpts = this.parent?.opts ?? this.root.opts;
+        return isPartialOptions(opts)
+            ? { args: args.slice(0, -1), opts: { ...parentOpts, ...opts, tags: { ...parentOpts.tags, ...opts.tags } } }
+            : { args, opts: parentOpts };
+    }
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,10 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface ILogger {
+    level: LogLevel;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    table(...args: any[]): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/core/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../lib/core/logger.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,QAAQ,CAAC;IAChB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5B,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC3B,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC3B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;CAC7B"}

package/dist/core/logger.js

@@ -0,0 +1 @@
+export {};

package/dist/core/loggers/logger.d.ts

@@ -0,0 +1,13 @@
+import { ILogger, LogLevel } from "../logger";
+export declare class Logger implements ILogger {
+    level: LogLevel;
+    private _level;
+    constructor(level?: LogLevel);
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    table(...args: any[]): void;
+    private log;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/core/loggers/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../lib/core/loggers/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE9C,qBAAa,MAAO,YAAW,OAAO;IAC7B,KAAK,EAAE,QAAQ,CAAC;IACvB,OAAO,CAAC,MAAM,CAAS;gBAEX,KAAK,CAAC,EAAE,QAAQ;IAmB5B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI3B,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI1B,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI1B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI3B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM3B,OAAO,CAAC,GAAG;CAKZ"}

package/dist/core/loggers/logger.js

@@ -0,0 +1,43 @@
+export class Logger {
+    level;
+    _level;
+    constructor(level) {
+        this.level = level ?? process.env.LOG_LEVEL ?? "info";
+        switch (this.level) {
+            case "debug":
+                this._level = 0;
+                break;
+            case "info":
+                this._level = 1;
+                break;
+            case "warn":
+                this._level = 2;
+                break;
+            case "error":
+                this._level = 3;
+                break;
+        }
+    }
+    debug(...args) {
+        this.log(0, args);
+    }
+    info(...args) {
+        this.log(1, args);
+    }
+    warn(...args) {
+        this.log(2, args);
+    }
+    error(...args) {
+        this.log(3, args);
+    }
+    table(...args) {
+        if (this._level <= 0) {
+            console.table(...args);
+        }
+    }
+    log(level, args) {
+        if (this._level <= level) {
+            console.log(...args);
+        }
+    }
+}

package/dist/core/options.d.ts

@@ -0,0 +1,79 @@
+import { IEncoder } from "./encoder";
+import { ILogger } from "./logger";
+import { IRetry } from "./retry";
+import { IStore } from "./store";
+/**
+ * Resonate configuration options.
+ */
+export interface ResonateOptions {
+    /**
+     * An encoder instance used for encoding and decoding values
+     * returned (or thrown) by registered functions. If not provided,
+     * a default JSON encoder will be used.
+     */
+    encoder: IEncoder<unknown, string | undefined>;
+    /**
+     * A process id that can be used to uniquely identify this Resonate
+     * instance. If not provided a default value will be generated.
+     */
+    pid: string;
+    /**
+     * A logger instance, if not provided a default logger will be
+     * used.
+     */
+    logger: ILogger;
+    /**
+     * A retry instance, defaults to exponential backoff.
+     */
+    retry: IRetry;
+    /**
+     * Tags to add to all durable promises.
+     */
+    tags: Record<string, string>;
+    /**
+     * A store instance, if provided this will take precedence over a
+     * remote store.
+     */
+    store: IStore;
+    /**
+     * The default promise timeout in ms, used for every function
+     * executed by calling run. Defaults to 1000.
+     */
+    timeout: number;
+    /**
+     * The remote promise store url. If not provided, an in-memory
+     * promise store will be used.
+     */
+    url: string;
+}
+/**
+ * Resonate function invocation options.
+ */
+export interface Options {
+    __resonate: true;
+    /**
+     * Overrides the default encoder.
+     */
+    encoder: IEncoder<unknown, string | undefined>;
+    /**
+     * Overrides the default retry policy.
+     */
+    retry: IRetry;
+    /**
+     * Overrides the default store.
+     */
+    store: IStore;
+    /**
+     * Additional tags to add to the durable promise.
+     */
+    tags: Record<string, string>;
+    /**
+     * Overrides the default timeout.
+     */
+    timeout: number;
+}
+export type PartialOptions = Partial<Options> & {
+    __resonate: true;
+};
+export declare function isPartialOptions(o: unknown): o is PartialOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/core/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../lib/core/options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAE/C;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;;OAGG;IACH,MAAM,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,UAAU,EAAE,IAAI,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAE/C;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE,CAAC;AAErE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,cAAc,CAEhE"}

package/dist/core/options.js

@@ -0,0 +1,3 @@
+export function isPartialOptions(o) {
+    return typeof o === "object" && o !== null && o.__resonate === true;
+}