@resonatehq/sdk 0.3.3 → 0.3.4

package/dist/generator.js

@@ -0,0 +1,396 @@
+import { DeferredExecution, GeneratorExecution, OrdinaryExecution } from "./core/execution";
+import { Future } from "./core/future";
+import { Invocation } from "./core/invocation";
+import * as utils from "./core/utils";
+import { ResonateBase } from "./resonate";
+/////////////////////////////////////////////////////////////////////
+// Resonate
+/////////////////////////////////////////////////////////////////////
+export class Resonate extends ResonateBase {
+    scheduler;
+    /**
+     * Creates a Resonate instance. This is the starting point for using Resonate.
+     *
+     * @constructor
+     * @param opts - A partial {@link ResonateOptions} object.
+     */
+    constructor(opts = {}) {
+        super(opts);
+        this.scheduler = new Scheduler(this.logger);
+    }
+    register(name, funcOrVersion, funcOrOpts) {
+        return super.register(name, funcOrVersion, funcOrOpts);
+    }
+    /**
+     * Register a module with Resonate. Registered functions can be invoked by calling {@link run}.
+     *
+     * @template F The type of the generator function.
+     * @param module The module to register with Resonate.
+     * @param opts Resonate options, can be constructed by calling {@link options}.
+     * @returns Resonate function
+     */
+    registerModule(module, opts = {}) {
+        super.registerModule(module, opts);
+    }
+    execute(name, version, id, func, args, opts) {
+        return this.scheduler.add(name, version, id, func, args, opts);
+    }
+}
+/////////////////////////////////////////////////////////////////////
+// Context
+/////////////////////////////////////////////////////////////////////
+export class Info {
+    invocation;
+    constructor(invocation) {
+        this.invocation = invocation;
+    }
+    /**
+     * The running count of function execution attempts.
+     */
+    get attempt() {
+        return this.invocation.attempt;
+    }
+    /**
+     * Uniquely identifies the function invocation.
+     */
+    get id() {
+        return this.invocation.id;
+    }
+    /**
+     * Deduplicates function invocations with the same id.
+     */
+    get idempotencyKey() {
+        return this.invocation.idempotencyKey;
+    }
+    /**
+     * The timestamp in ms, once this time elapses the function invocation will timeout.
+     */
+    get timeout() {
+        return this.invocation.timeout;
+    }
+    /**
+     * The resonate function version.
+     */
+    get version() {
+        return this.invocation.version;
+    }
+}
+export class Context {
+    invocation;
+    constructor(invocation) {
+        this.invocation = invocation;
+    }
+    /**
+     * The running count of child function invocations.
+     */
+    get counter() {
+        return this.invocation.counter;
+    }
+    /**
+     * Uniquely identifies the function invocation.
+     */
+    get id() {
+        return this.invocation.id;
+    }
+    /**
+     * Deduplicates function invocations with the same id.
+     */
+    get idempotencyKey() {
+        return this.invocation.idempotencyKey;
+    }
+    /**
+     * The timestamp in ms, once this time elapses the function invocation will timeout.
+     */
+    get timeout() {
+        return this.invocation.timeout;
+    }
+    /**
+     * The resonate function version.
+     */
+    get version() {
+        return this.invocation.version;
+    }
+    run(func, ...args) {
+        return this._call(func, args, false);
+    }
+    call(func, ...args) {
+        return this._call(func, args, true);
+    }
+    _call(func, argsWithOpts, yieldFuture) {
+        const { args, opts } = this.invocation.split(argsWithOpts);
+        if (typeof func === "string") {
+            return { kind: "call", value: { kind: "deferred", func, args: args[0], opts }, yieldFuture };
+        }
+        else if (func.constructor.name === "GeneratorFunction") {
+            return { kind: "call", value: { kind: "resonate", func, args, opts }, yieldFuture };
+        }
+        else {
+            return { kind: "call", value: { kind: "ordinary", func, args, opts }, yieldFuture };
+        }
+    }
+    /**
+     * Construct options.
+     *
+     * @param opts A partial {@link Options} object.
+     * @returns Options with the __resonate flag set.
+     */
+    options(opts = {}) {
+        return { ...opts, __resonate: true };
+    }
+}
+/////////////////////////////////////////////////////////////////////
+// Scheduler
+/////////////////////////////////////////////////////////////////////
+class Scheduler {
+    logger;
+    // tick is mutually exclusive
+    running = false;
+    // all top level executions
+    cache = {};
+    // executions ready to be run
+    runnable = [];
+    // executions that are awaiting another execution
+    awaiting = [];
+    // all executions
+    executions = [];
+    // executions that have been killed
+    killed = [];
+    constructor(logger) {
+        this.logger = logger;
+    }
+    add(name, version, id, func, args, opts) {
+        // if the execution is already running, and not killed,
+        // return the promise
+        if (this.cache[id] && !this.cache[id].killed) {
+            return this.cache[id].execute();
+        }
+        // the idempotency key is a hash of the id
+        const idempotencyKey = utils.hash(id);
+        // params, used for recovery
+        const param = {
+            func: name,
+            version,
+            args,
+        };
+        // create a new invocation
+        const invocation = new Invocation(name, version, id, idempotencyKey, undefined, param, opts);
+        // create a new execution
+        const generator = func(new Context(invocation), ...args);
+        const execution = new GeneratorExecution(invocation, generator);
+        const promise = execution.execute();
+        // once the durable promise has been created,
+        // add the execution to runnable
+        execution.create().then((promise) => {
+            if (promise && promise.pending) {
+                this.runnable.push({ execution, promise, next: { kind: "init" } });
+                this.tick();
+            }
+        });
+        // store the invocation, execution, and promise
+        // will be used if run is called again with the same id
+        this.cache[id] = execution;
+        this.executions.push(execution);
+        return promise;
+    }
+    async tick() {
+        // need to ensure that tick is mutually exclusive,
+        // if tick is already running all continuations will be picked up in the while loop
+        if (this.running)
+            return;
+        this.running = true;
+        while (this.runnable.length > 0) {
+            // grab the next continuation
+            const continuation = this.runnable.shift();
+            // step through the generator if in debug mode
+            if (this.logger.level === "debug" && (await this.keypress()) === "\u001b") {
+                // kill when escape key is pressed
+                continuation?.execution.kill("manual kill");
+            }
+            if (continuation && !continuation.execution.killed) {
+                try {
+                    // apply the next value to the generator
+                    const result = this.next(continuation);
+                    // if done, we can resolve the execution
+                    if (result.done) {
+                        // need to handle the special case where a generator returns a future
+                        if (result.value instanceof Future) {
+                            result.value.promise.then((v) => continuation.execution.resolve(continuation.promise, v), (e) => continuation.execution.reject(continuation.promise, e));
+                        }
+                        else {
+                            // resolve the durable promise
+                            await continuation.execution.resolve(continuation.promise, result.value);
+                        }
+                    }
+                    else {
+                        // apply the yielded value to the generator
+                        await this.apply(continuation, result.value);
+                    }
+                }
+                catch (error) {
+                    // if anything goes wrong, reject the durable promise
+                    await continuation.execution.reject(continuation.promise, error);
+                }
+                // housekeeping
+                if (continuation.execution.killed) {
+                    this.kill(continuation.execution);
+                }
+            }
+            // print all invocations if in debug mode
+            this.print();
+        }
+        // TODO: suspend
+        // set running back to false
+        this.running = false;
+    }
+    next({ execution, next }) {
+        // apply the next value to the generator
+        switch (next.kind) {
+            case "init":
+                return execution.generator.next();
+            case "value":
+                return execution.generator.next(next.value);
+            case "error":
+                return execution.generator.throw(next.error);
+            default:
+                this.yeet(`permitted continuation values are (init, value, error), received ${next}`);
+        }
+    }
+    async apply(continuation, yielded) {
+        // apply the yielded value to the generator
+        switch (yielded.kind) {
+            case "call":
+                await this.applyCall(continuation, yielded);
+                break;
+            case "future":
+                this.applyFuture(continuation, yielded);
+                break;
+            default:
+                this.yeet(`permitted yielded values are (call, future), received ${yielded}`);
+        }
+    }
+    async applyCall(continuation, { value, yieldFuture }) {
+        // the parent is the current invocation
+        const parent = continuation.execution.invocation;
+        // the id is either:
+        // 1. a provided string in the case of a deferred execution
+        // 2. a generated string in the case of an ordinary execution
+        const id = value.kind === "deferred" ? value.func : `${parent.id}.${parent.counter}`;
+        // the idempotency key is a hash of the id
+        const idempotencyKey = utils.hash(id);
+        // human readable name of the function
+        const name = value.kind === "deferred" ? value.func : value.func.name;
+        // version is inherited from the parent
+        const version = parent.version;
+        // create a new invocation
+        const invocation = new Invocation(name, version, id, idempotencyKey, undefined, undefined, value.opts, parent);
+        // add child and increment counter
+        parent.addChild(invocation);
+        parent.counter++;
+        let execution;
+        if (value.kind === "resonate") {
+            // create a generator execution
+            const ctx = new Context(invocation);
+            execution = new GeneratorExecution(invocation, value.func(ctx, ...value.args));
+            const promise = await execution.create();
+            if (promise && promise.pending) {
+                // if the durable promise is pending, add to runnable
+                this.runnable.push({ execution, promise, next: { kind: "init" } });
+            }
+        }
+        else if (value.kind === "ordinary") {
+            // create an ordinary execution
+            const info = new Info(invocation);
+            execution = new OrdinaryExecution(invocation, () => value.func(info, ...value.args));
+            execution.execute().catch(() => { });
+        }
+        else if (value.kind === "deferred") {
+            // create a deferred execution
+            execution = new DeferredExecution(invocation);
+            execution.execute().catch(() => { });
+        }
+        else {
+            this.yeet(`permitted call values are (resonate, ordinary, deferred), received ${value}`);
+        }
+        // add to all executions
+        this.executions.push(execution);
+        if (yieldFuture) {
+            // if the call is expected to yield a future, add the future to runnable
+            this.runnable.push({
+                execution: continuation.execution,
+                promise: continuation.promise,
+                next: { kind: "value", value: invocation.future },
+            });
+        }
+        else {
+            // otherwise, skip ahead to apply future
+            this.applyFuture(continuation, invocation.future);
+        }
+    }
+    applyFuture({ execution, promise }, future) {
+        if (execution.invocation.future.root !== future.root) {
+            this.yeet(`yielded future originates from ${future.root.id}, but this execution originates from ${execution.invocation.future.root.id}`);
+        }
+        // add to awaiting
+        this.awaiting.push(execution);
+        execution.invocation.await(future);
+        execution.invocation.block(future);
+        const apply = (next) => {
+            // unblock
+            execution.invocation.unblock();
+            // remove from awaiting
+            this.awaiting = this.awaiting.filter((e) => e !== execution);
+            // add to runnable
+            this.runnable.push({ execution, promise, next });
+            // tick again
+            this.tick();
+        };
+        // add the next value to runnable when the future fulfills
+        future.promise.then((value) => apply({ kind: "value", value }), (error) => apply({ kind: "error", error }));
+    }
+    kill(execution) {
+        // add to killed
+        const killed = this.executions.filter((e) => e.invocation.root === execution.invocation.root);
+        this.killed = this.killed.concat(killed);
+        // remove from awaiting and runnable
+        this.runnable = this.runnable.filter((c) => c.execution.invocation.root !== execution.invocation.root);
+        this.awaiting = this.awaiting.filter((e) => e.invocation.root !== execution.invocation.root);
+    }
+    async keypress() {
+        this.logger.debug("Press any key to continue...");
+        return new Promise((resolve) => {
+            const onData = (data) => {
+                process.stdin.removeListener("data", onData);
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+                const c = data.toString();
+                if (c === "\u0003") {
+                    this.logger.debug("^C");
+                    process.exit(1);
+                }
+                resolve(c);
+            };
+            process.stdin.resume();
+            process.stdin.setRawMode(true);
+            process.stdin.once("data", onData);
+        });
+    }
+    print() {
+        this.logger.debug("Executions");
+        this.logger.table(this.executions.map((e) => ({
+            name: e.invocation.name,
+            version: e.invocation.version,
+            id: e.invocation.id,
+            idempotencyKey: e.invocation.idempotencyKey,
+            parent: e.invocation.parent ? e.invocation.parent.id : undefined,
+            killed: e.killed,
+            pending: e.invocation.future.value.kind === "pending",
+            awaited: e.invocation.awaited.map((f) => f.id).join(","),
+            blocked: e.invocation.blocked?.id,
+        })));
+    }
+    yeet(msg) {
+        // an unrecoverable error has occurred, log and exit
+        this.logger.error(msg);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import * as async from "./async";
+import * as generator from "./generator";
+export { async, generator };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+import * as async from "./async";
+import * as generator from "./generator";
+export { async, generator };

package/dist/resonate.d.ts

@@ -0,0 +1,73 @@
+import { IEncoder } from "./core/encoder";
+import { ResonatePromise } from "./core/future";
+import { ILogger } from "./core/logger";
+import { ResonateOptions, Options } from "./core/options";
+import { DurablePromise, CreateOptions, CompleteOptions } from "./core/promises/promises";
+import { IRetry } from "./core/retry";
+import { IStore } from "./core/store";
+type Func = (...args: any[]) => any;
+export declare abstract class ResonateBase {
+    private readonly functions;
+    readonly pid: string;
+    readonly timeout: number;
+    readonly tags: Record<string, string>;
+    protected readonly encoder: IEncoder<unknown, string | undefined>;
+    protected readonly logger: ILogger;
+    protected readonly retry: IRetry;
+    protected readonly store: IStore;
+    private interval;
+    constructor({ encoder, logger, pid, retry, store, tags, timeout, // 10s
+    url, }?: Partial<ResonateOptions>);
+    register(name: string, funcOrVersion: Func | number, funcOrOpts: Func | Partial<Options>): (id: string, ...args: any) => ResonatePromise<any>;
+    registerModule(module: Record<string, Func>, opts?: Partial<Options>): void;
+    /**
+     * Run a Resonate function. Functions must first be registered with {@link register}.
+     *
+     * @template T The return type of the function.
+     * @param id A unique id for the function invocation.
+     * @param name The function name.
+     * @param args The function arguments.
+     * @returns A promise that resolve to the function return value.
+     */
+    run<T>(name: string, id: string, ...args: any[]): ResonatePromise<T>;
+    /**
+     * Run a Resonate function. Functions must first be registered with {@link register}.
+     *
+     * @template T The return type of the function.
+     * @param name The function name.
+     * @param version The function version.
+     * @param id A unique id for the function invocation.
+     * @param args The function arguments.
+     * @returns A promise that resolve to the function return value.
+     */
+    run<T>(name: string, version: number, id: string, ...args: any[]): ResonatePromise<T>;
+    protected abstract execute(name: string, version: number, id: string, func: Func, args: any[], opts: Options): ResonatePromise<any>;
+    /**
+     * Start the resonate service.
+     *
+     * @param delay Frequency in ms to check for pending promises.
+     */
+    start(delay?: number): void;
+    /**
+     * Stop the resonate service.
+     */
+    stop(): void;
+    private _start;
+    get promises(): {
+        create: <T>(id: string, timeout: number, opts?: Partial<CreateOptions>) => Promise<DurablePromise<T>>;
+        resolve: <T_1>(id: string, value: T_1, opts?: Partial<CompleteOptions>) => Promise<DurablePromise<T_1>>;
+        reject: <T_2>(id: string, error: any, opts?: Partial<CompleteOptions>) => Promise<DurablePromise<T_2>>;
+        cancel: <T_3>(id: string, error: any, opts?: Partial<CompleteOptions>) => Promise<DurablePromise<T_3>>;
+        get: <T_4>(id: string) => Promise<DurablePromise<T_4>>;
+        search: (id: string, state?: string, tags?: Record<string, string>, limit?: number) => AsyncGenerator<DurablePromise<any>[], void, unknown>;
+    };
+    /**
+     * Construct options.
+     *
+     * @param opts A partial {@link Options} object.
+     * @returns Options with the __resonate flag set.
+     */
+    options({ encoder, retry, store, tags, timeout, }: Partial<Options>): Options;
+}
+export {};
+//# sourceMappingURL=resonate.d.ts.map

package/dist/resonate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resonate.d.ts","sourceRoot":"","sources":["../lib/resonate.ts"],"names":[],"mappings":"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"}

package/dist/resonate.js

@@ -0,0 +1,142 @@
+import { JSONEncoder } from "./core/encoders/json";
+import { Logger } from "./core/loggers/logger";
+import { DurablePromise } from "./core/promises/promises";
+import { Retry } from "./core/retries/retry";
+import { LocalStore } from "./core/stores/local";
+import { RemoteStore } from "./core/stores/remote";
+import * as utils from "./core/utils";
+/////////////////////////////////////////////////////////////////////
+// Resonate
+/////////////////////////////////////////////////////////////////////
+export class ResonateBase {
+    functions = {};
+    pid;
+    timeout;
+    tags;
+    encoder;
+    logger;
+    retry;
+    store;
+    interval;
+    constructor({ encoder = new JSONEncoder(), logger = new Logger(), pid = utils.randomId(), retry = Retry.exponential(), store = undefined, tags = {}, timeout = 10000, // 10s
+    url = undefined, } = {}) {
+        this.encoder = encoder;
+        this.logger = logger;
+        this.pid = pid;
+        this.retry = retry;
+        this.tags = tags;
+        this.timeout = timeout;
+        if (store) {
+            this.store = store;
+        }
+        else if (url) {
+            this.store = new RemoteStore(url, this.pid, this.logger);
+        }
+        else {
+            this.store = new LocalStore(this.logger);
+        }
+    }
+    register(name, funcOrVersion, funcOrOpts) {
+        const version = typeof funcOrVersion === "number" ? funcOrVersion : 1;
+        const func = typeof funcOrVersion === "function" ? funcOrVersion : typeof funcOrOpts === "function" ? funcOrOpts : null;
+        const opts = typeof funcOrOpts === "object" ? this.options(funcOrOpts) : this.options({});
+        if (!func) {
+            throw new Error("Must provide value for func");
+        }
+        if (version <= 0) {
+            throw new Error("Version must be greater than 0");
+        }
+        if (!this.functions[name]) {
+            this.functions[name] = {};
+        }
+        if (this.functions[name][version]) {
+            throw new Error(`Function ${name} version ${version} already registered`);
+        }
+        // register as latest (0) if version is greatest so far
+        if (version > Math.max(...Object.values(this.functions[name]).map((f) => f.version))) {
+            this.functions[name][0] = { version, func, opts };
+        }
+        // register specific version
+        this.functions[name][version] = { version, func, opts };
+        return (id, ...args) => this.run(name, version, id, ...args);
+    }
+    registerModule(module, opts = {}) {
+        for (const key in module) {
+            this.register(key, module[key], opts);
+        }
+    }
+    run(name, idOrVersion, ...args) {
+        const id = typeof idOrVersion === "string" ? idOrVersion : args.shift();
+        const v = typeof idOrVersion === "number" ? idOrVersion : 0;
+        if (!this.functions[name] || !this.functions[name][v]) {
+            throw new Error(`Function ${name} version ${v} not registered`);
+        }
+        const { version, func, opts } = this.functions[name][v];
+        return this.execute(name, version, id, func, args, opts);
+    }
+    /**
+     * Start the resonate service.
+     *
+     * @param delay Frequency in ms to check for pending promises.
+     */
+    start(delay = 5000) {
+        clearInterval(this.interval);
+        this.interval = setInterval(() => this._start(), delay);
+    }
+    /**
+     * Stop the resonate service.
+     */
+    stop() {
+        clearInterval(this.interval);
+    }
+    async _start() {
+        for await (const promises of this.promises.search("*", "pending", { "resonate:invocation": "true" })) {
+            for (const promise of promises) {
+                try {
+                    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)) {
+                        this.run(param.func, param.version, promise.id, param.args);
+                    }
+                }
+                catch (e) {
+                    this.logger.warn(e);
+                }
+            }
+        }
+    }
+    get promises() {
+        return {
+            create: (id, timeout, opts = {}) => DurablePromise.create(this.store.promises, this.encoder, id, timeout, opts),
+            resolve: (id, value, opts = {}) => DurablePromise.resolve(this.store.promises, this.encoder, id, value, opts),
+            reject: (id, error, opts = {}) => DurablePromise.reject(this.store.promises, this.encoder, id, error, opts),
+            cancel: (id, error, opts = {}) => DurablePromise.cancel(this.store.promises, this.encoder, id, error, opts),
+            get: (id) => DurablePromise.get(this.store.promises, this.encoder, id),
+            search: (id, state, tags, limit) => DurablePromise.search(this.store.promises, this.encoder, id, state, tags, limit),
+        };
+    }
+    /**
+     * Construct options.
+     *
+     * @param opts A partial {@link Options} object.
+     * @returns Options with the __resonate flag set.
+     */
+    options({ encoder = this.encoder, retry = this.retry, store = this.store, tags = {}, timeout = this.timeout, }) {
+        // merge tags
+        tags = { ...this.tags, ...tags };
+        return {
+            __resonate: true,
+            encoder,
+            retry,
+            store,
+            tags,
+            timeout,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@resonatehq/sdk",
-    "version": "0.3.3",
+    "version": "0.3.4",
     "description": "Resonate TypeScript SDK",
     "main": "dist/index.js",
     "type": "module",