@sonamu-kit/tasks 0.0.1

package/dist/database/pubsub.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/database/pubsub.ts"],"sourcesContent":["import assert from \"assert\";\nimport type { Knex } from \"knex\";\nimport { err, ok, type Result } from \"../core/result\";\n\nexport type OnSubscribed = (result: Result<string | null>) => void | Promise<void>;\n\nexport class PostgresPubSub {\n  private _destroyed = false;\n  private _onClosed: () => Promise<void>;\n  private _listeners = new Map<string, Set<OnSubscribed>>();\n\n  // biome-ignore lint/suspicious/noExplicitAny: Knex exposes a connection as any\n  private _connection: any | null = null;\n\n  private constructor(private readonly knex: Knex) {\n    // Re-connect to the database when the connection is closed and not destroyed manually\n    this._onClosed = (async () => {\n      if (this._destroyed) {\n        return;\n      }\n\n      await this.connect();\n    }).bind(this);\n  }\n\n  get destroyed() {\n    return this._destroyed;\n  }\n\n  // acquire new raw connection and set up listeners\n  async connect() {\n    const connection = await this.knex.client.acquireRawConnection();\n    connection.on(\"close\", this._onClosed);\n    connection.on(\n      \"notification\",\n      async ({ channel, payload: rawPayload }: { channel: string; payload: unknown }) => {\n        const payload =\n          typeof rawPayload === \"string\" && rawPayload.length !== 0 ? rawPayload : null;\n        const listeners = this._listeners.get(channel);\n        if (!listeners) {\n          return;\n        }\n\n        const result = ok(payload);\n        await Promise.allSettled(\n          Array.from(listeners.values()).map((listener) => Promise.resolve(listener(result))),\n        );\n      },\n    );\n    connection.on(\"error\", async (error: Error) => {\n      const result = err(error);\n      await Promise.allSettled(\n        Array.from(this._listeners.values())\n          .flatMap((listeners) => Array.from(listeners))\n          .map((listener) => Promise.resolve(listener(result))),\n      );\n    });\n\n    for (const channel of this._listeners.keys()) {\n      connection.query(`LISTEN ${channel}`);\n    }\n\n    this._connection = connection;\n  }\n\n  // destroy the listener and close the connection, do not destroy the knex connection\n  async destroy() {\n    this._destroyed = true;\n    this._connection.off(\"close\", this._onClosed);\n    await this.knex.client.destroyRawConnection(this._connection);\n  }\n\n  // create a new listener and connect to the database\n  static async create(knex: Knex) {\n    const listener = new PostgresPubSub(knex);\n    await listener.connect();\n    return listener;\n  }\n\n  // add a new listener to the channel\n  listenEvent(channel: string, callback: OnSubscribed) {\n    if (!this._listeners.has(channel)) {\n      this._connection?.query(`LISTEN ${channel}`);\n      this._listeners.set(channel, new Set<OnSubscribed>().add(callback));\n      return;\n    }\n\n    const listeners = this._listeners.get(channel);\n    assert(listeners, \"Listener channel not found\");\n    listeners.add(callback);\n  }\n}\n"],"names":["assert","err","ok","PostgresPubSub","_destroyed","_onClosed","_listeners","Map","_connection","knex","connect","bind","destroyed","connection","client","acquireRawConnection","on","channel","payload","rawPayload","length","listeners","get","result","Promise","allSettled","Array","from","values","map","listener","resolve","error","flatMap","keys","query","destroy","off","destroyRawConnection","create","listenEvent","callback","has","set","Set","add"],"mappings":"AAAA,OAAOA,YAAY,SAAS;AAE5B,SAASC,GAAG,EAAEC,EAAE,QAAqB,oBAAiB;AAItD,OAAO,MAAMC;;IACHC,aAAa,MAAM;IACnBC,UAA+B;IAC/BC,aAAa,IAAIC,MAAiC;IAE1D,+EAA+E;IACvEC,cAA0B,KAAK;IAEvC,YAAoB,AAAiBC,IAAU,CAAE;aAAZA,OAAAA;QACnC,sFAAsF;QACtF,IAAI,CAACJ,SAAS,GAAG,AAAC,CAAA;YAChB,IAAI,IAAI,CAACD,UAAU,EAAE;gBACnB;YACF;YAEA,MAAM,IAAI,CAACM,OAAO;QACpB,CAAA,EAAGC,IAAI,CAAC,IAAI;IACd;IAEA,IAAIC,YAAY;QACd,OAAO,IAAI,CAACR,UAAU;IACxB;IAEA,kDAAkD;IAClD,MAAMM,UAAU;QACd,MAAMG,aAAa,MAAM,IAAI,CAACJ,IAAI,CAACK,MAAM,CAACC,oBAAoB;QAC9DF,WAAWG,EAAE,CAAC,SAAS,IAAI,CAACX,SAAS;QACrCQ,WAAWG,EAAE,CACX,gBACA,OAAO,EAAEC,OAAO,EAAEC,SAASC,UAAU,EAAyC;YAC5E,MAAMD,UACJ,OAAOC,eAAe,YAAYA,WAAWC,MAAM,KAAK,IAAID,aAAa;YAC3E,MAAME,YAAY,IAAI,CAACf,UAAU,CAACgB,GAAG,CAACL;YACtC,IAAI,CAACI,WAAW;gBACd;YACF;YAEA,MAAME,SAASrB,GAAGgB;YAClB,MAAMM,QAAQC,UAAU,CACtBC,MAAMC,IAAI,CAACN,UAAUO,MAAM,IAAIC,GAAG,CAAC,CAACC,WAAaN,QAAQO,OAAO,CAACD,SAASP;QAE9E;QAEFV,WAAWG,EAAE,CAAC,SAAS,OAAOgB;YAC5B,MAAMT,SAAStB,IAAI+B;YACnB,MAAMR,QAAQC,UAAU,CACtBC,MAAMC,IAAI,CAAC,IAAI,CAACrB,UAAU,CAACsB,MAAM,IAC9BK,OAAO,CAAC,CAACZ,YAAcK,MAAMC,IAAI,CAACN,YAClCQ,GAAG,CAAC,CAACC,WAAaN,QAAQO,OAAO,CAACD,SAASP;QAElD;QAEA,KAAK,MAAMN,WAAW,IAAI,CAACX,UAAU,CAAC4B,IAAI,GAAI;YAC5CrB,WAAWsB,KAAK,CAAC,CAAC,OAAO,EAAElB,SAAS;QACtC;QAEA,IAAI,CAACT,WAAW,GAAGK;IACrB;IAEA,oFAAoF;IACpF,MAAMuB,UAAU;QACd,IAAI,CAAChC,UAAU,GAAG;QAClB,IAAI,CAACI,WAAW,CAAC6B,GAAG,CAAC,SAAS,IAAI,CAAChC,SAAS;QAC5C,MAAM,IAAI,CAACI,IAAI,CAACK,MAAM,CAACwB,oBAAoB,CAAC,IAAI,CAAC9B,WAAW;IAC9D;IAEA,oDAAoD;IACpD,aAAa+B,OAAO9B,IAAU,EAAE;QAC9B,MAAMqB,WAAW,IAAI3B,eAAeM;QACpC,MAAMqB,SAASpB,OAAO;QACtB,OAAOoB;IACT;IAEA,oCAAoC;IACpCU,YAAYvB,OAAe,EAAEwB,QAAsB,EAAE;QACnD,IAAI,CAAC,IAAI,CAACnC,UAAU,CAACoC,GAAG,CAACzB,UAAU;YACjC,IAAI,CAACT,WAAW,EAAE2B,MAAM,CAAC,OAAO,EAAElB,SAAS;YAC3C,IAAI,CAACX,UAAU,CAACqC,GAAG,CAAC1B,SAAS,IAAI2B,MAAoBC,GAAG,CAACJ;YACzD;QACF;QAEA,MAAMpB,YAAY,IAAI,CAACf,UAAU,CAACgB,GAAG,CAACL;QACtCjB,OAAOqB,WAAW;QAClBA,UAAUwB,GAAG,CAACJ;IAChB;AACF"}

package/dist/database/pubsub.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pubsub.test.d.ts.map

package/dist/database/pubsub.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pubsub.test.d.ts","sourceRoot":"","sources":["../../src/database/pubsub.test.ts"],"names":[],"mappings":""}

package/dist/database/pubsub.test.js

@@ -0,0 +1,86 @@
+import knex from "knex";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { KNEX_GLOBAL_CONFIG } from "../testing/connection.js";
+import { PostgresPubSub } from "./pubsub.js";
+describe("PostgresPubSub", ()=>{
+    let knexInstance;
+    beforeEach(async ()=>{
+        knexInstance = knex(KNEX_GLOBAL_CONFIG);
+    });
+    afterEach(async ()=>{
+        await knexInstance.destroy();
+    });
+    it("should create a new pubsub and connect to the database", async ()=>{
+        const pubsub = await PostgresPubSub.create(knexInstance);
+        expect(pubsub.destroyed).toBe(false);
+    });
+    it("should destroy the pubsub and close the connection", async ()=>{
+        const pubsub = await PostgresPubSub.create(knexInstance);
+        expect(pubsub.destroyed).toBe(false);
+        await pubsub.destroy();
+        expect(pubsub.destroyed).toBe(true);
+    });
+    it("should not add the same pubsub multiple times", async ()=>{
+        const pubsub = await PostgresPubSub.create(knexInstance);
+        const results = [];
+        const callback = async (result)=>{
+            results.push(result);
+        };
+        pubsub.listenEvent("test", callback);
+        pubsub.listenEvent("test", callback);
+        await knexInstance.raw("NOTIFY test, 'test'");
+        await sleep(100);
+        expect(results.length).toBe(1);
+        expect(results[0]).toStrictEqual({
+            ok: true,
+            value: "test"
+        });
+    });
+    it("should route notifications to the correct pubsubs by channel", async ()=>{
+        const pubsub = await PostgresPubSub.create(knexInstance);
+        const results1 = [];
+        const results2 = [];
+        pubsub.listenEvent("test1", (result)=>{
+            results1.push(result);
+        });
+        pubsub.listenEvent("test2", (result)=>{
+            results2.push(result);
+        });
+        await knexInstance.raw("NOTIFY test1, '!!!'");
+        await sleep(100);
+        expect(results1.length).toBe(1);
+        expect(results1[0]).toStrictEqual({
+            ok: true,
+            value: "!!!"
+        });
+        expect(results2.length).toBe(0);
+        await knexInstance.raw("NOTIFY test2, '###'");
+        await sleep(100);
+        expect(results1.length).toBe(1);
+        expect(results2.length).toBe(1);
+        expect(results2[0]).toStrictEqual({
+            ok: true,
+            value: "###"
+        });
+    });
+    it("should payload be null if the payload is empty string", async ()=>{
+        const pubsub = await PostgresPubSub.create(knexInstance);
+        const results = [];
+        const callback = async (result)=>{
+            results.push(result);
+        };
+        pubsub.listenEvent("test", callback);
+        await knexInstance.raw(`NOTIFY test`);
+        await sleep(100);
+        expect(results.length).toBe(1);
+        expect(results[0]).toStrictEqual({
+            ok: true,
+            value: null
+        });
+    });
+});
+function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+
+//# sourceMappingURL=pubsub.test.js.map

package/dist/database/pubsub.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/database/pubsub.test.ts"],"sourcesContent":["import knex, { type Knex } from \"knex\";\nimport { afterEach, beforeEach, describe, expect, it } from \"vitest\";\nimport type { Result } from \"../core/result\";\nimport { KNEX_GLOBAL_CONFIG } from \"../testing/connection\";\nimport { type OnSubscribed, PostgresPubSub } from \"./pubsub\";\n\ndescribe(\"PostgresPubSub\", () => {\n  let knexInstance: Knex;\n\n  beforeEach(async () => {\n    knexInstance = knex(KNEX_GLOBAL_CONFIG);\n  });\n\n  afterEach(async () => {\n    await knexInstance.destroy();\n  });\n\n  it(\"should create a new pubsub and connect to the database\", async () => {\n    const pubsub = await PostgresPubSub.create(knexInstance);\n    expect(pubsub.destroyed).toBe(false);\n  });\n\n  it(\"should destroy the pubsub and close the connection\", async () => {\n    const pubsub = await PostgresPubSub.create(knexInstance);\n    expect(pubsub.destroyed).toBe(false);\n    await pubsub.destroy();\n    expect(pubsub.destroyed).toBe(true);\n  });\n\n  it(\"should not add the same pubsub multiple times\", async () => {\n    const pubsub = await PostgresPubSub.create(knexInstance);\n    const results: Result<string | null>[] = [];\n    const callback: OnSubscribed = async (result) => {\n      results.push(result);\n    };\n\n    pubsub.listenEvent(\"test\", callback);\n    pubsub.listenEvent(\"test\", callback);\n\n    await knexInstance.raw(\"NOTIFY test, 'test'\");\n    await sleep(100);\n\n    expect(results.length).toBe(1);\n    expect(results[0]).toStrictEqual({ ok: true, value: \"test\" });\n  });\n\n  it(\"should route notifications to the correct pubsubs by channel\", async () => {\n    const pubsub = await PostgresPubSub.create(knexInstance);\n    const results1: Result<string | null>[] = [];\n    const results2: Result<string | null>[] = [];\n\n    pubsub.listenEvent(\"test1\", (result) => {\n      results1.push(result);\n    });\n    pubsub.listenEvent(\"test2\", (result) => {\n      results2.push(result);\n    });\n\n    await knexInstance.raw(\"NOTIFY test1, '!!!'\");\n    await sleep(100);\n\n    expect(results1.length).toBe(1);\n    expect(results1[0]).toStrictEqual({ ok: true, value: \"!!!\" });\n    expect(results2.length).toBe(0);\n\n    await knexInstance.raw(\"NOTIFY test2, '###'\");\n    await sleep(100);\n\n    expect(results1.length).toBe(1);\n    expect(results2.length).toBe(1);\n    expect(results2[0]).toStrictEqual({ ok: true, value: \"###\" });\n  });\n\n  it(\"should payload be null if the payload is empty string\", async () => {\n    const pubsub = await PostgresPubSub.create(knexInstance);\n    const results: Result<string | null>[] = [];\n    const callback: OnSubscribed = async (result) => {\n      results.push(result);\n    };\n\n    pubsub.listenEvent(\"test\", callback);\n    await knexInstance.raw(`NOTIFY test`);\n    await sleep(100);\n\n    expect(results.length).toBe(1);\n    expect(results[0]).toStrictEqual({ ok: true, value: null });\n  });\n});\n\nfunction sleep(ms: number) {\n  return new Promise<void>((resolve) => setTimeout(resolve, ms));\n}\n"],"names":["knex","afterEach","beforeEach","describe","expect","it","KNEX_GLOBAL_CONFIG","PostgresPubSub","knexInstance","destroy","pubsub","create","destroyed","toBe","results","callback","result","push","listenEvent","raw","sleep","length","toStrictEqual","ok","value","results1","results2","ms","Promise","resolve","setTimeout"],"mappings":"AAAA,OAAOA,UAAyB,OAAO;AACvC,SAASC,SAAS,EAAEC,UAAU,EAAEC,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAS;AAErE,SAASC,kBAAkB,QAAQ,2BAAwB;AAC3D,SAA4BC,cAAc,QAAQ,cAAW;AAE7DJ,SAAS,kBAAkB;IACzB,IAAIK;IAEJN,WAAW;QACTM,eAAeR,KAAKM;IACtB;IAEAL,UAAU;QACR,MAAMO,aAAaC,OAAO;IAC5B;IAEAJ,GAAG,0DAA0D;QAC3D,MAAMK,SAAS,MAAMH,eAAeI,MAAM,CAACH;QAC3CJ,OAAOM,OAAOE,SAAS,EAAEC,IAAI,CAAC;IAChC;IAEAR,GAAG,sDAAsD;QACvD,MAAMK,SAAS,MAAMH,eAAeI,MAAM,CAACH;QAC3CJ,OAAOM,OAAOE,SAAS,EAAEC,IAAI,CAAC;QAC9B,MAAMH,OAAOD,OAAO;QACpBL,OAAOM,OAAOE,SAAS,EAAEC,IAAI,CAAC;IAChC;IAEAR,GAAG,iDAAiD;QAClD,MAAMK,SAAS,MAAMH,eAAeI,MAAM,CAACH;QAC3C,MAAMM,UAAmC,EAAE;QAC3C,MAAMC,WAAyB,OAAOC;YACpCF,QAAQG,IAAI,CAACD;QACf;QAEAN,OAAOQ,WAAW,CAAC,QAAQH;QAC3BL,OAAOQ,WAAW,CAAC,QAAQH;QAE3B,MAAMP,aAAaW,GAAG,CAAC;QACvB,MAAMC,MAAM;QAEZhB,OAAOU,QAAQO,MAAM,EAAER,IAAI,CAAC;QAC5BT,OAAOU,OAAO,CAAC,EAAE,EAAEQ,aAAa,CAAC;YAAEC,IAAI;YAAMC,OAAO;QAAO;IAC7D;IAEAnB,GAAG,gEAAgE;QACjE,MAAMK,SAAS,MAAMH,eAAeI,MAAM,CAACH;QAC3C,MAAMiB,WAAoC,EAAE;QAC5C,MAAMC,WAAoC,EAAE;QAE5ChB,OAAOQ,WAAW,CAAC,SAAS,CAACF;YAC3BS,SAASR,IAAI,CAACD;QAChB;QACAN,OAAOQ,WAAW,CAAC,SAAS,CAACF;YAC3BU,SAAST,IAAI,CAACD;QAChB;QAEA,MAAMR,aAAaW,GAAG,CAAC;QACvB,MAAMC,MAAM;QAEZhB,OAAOqB,SAASJ,MAAM,EAAER,IAAI,CAAC;QAC7BT,OAAOqB,QAAQ,CAAC,EAAE,EAAEH,aAAa,CAAC;YAAEC,IAAI;YAAMC,OAAO;QAAM;QAC3DpB,OAAOsB,SAASL,MAAM,EAAER,IAAI,CAAC;QAE7B,MAAML,aAAaW,GAAG,CAAC;QACvB,MAAMC,MAAM;QAEZhB,OAAOqB,SAASJ,MAAM,EAAER,IAAI,CAAC;QAC7BT,OAAOsB,SAASL,MAAM,EAAER,IAAI,CAAC;QAC7BT,OAAOsB,QAAQ,CAAC,EAAE,EAAEJ,aAAa,CAAC;YAAEC,IAAI;YAAMC,OAAO;QAAM;IAC7D;IAEAnB,GAAG,yDAAyD;QAC1D,MAAMK,SAAS,MAAMH,eAAeI,MAAM,CAACH;QAC3C,MAAMM,UAAmC,EAAE;QAC3C,MAAMC,WAAyB,OAAOC;YACpCF,QAAQG,IAAI,CAACD;QACf;QAEAN,OAAOQ,WAAW,CAAC,QAAQH;QAC3B,MAAMP,aAAaW,GAAG,CAAC,CAAC,WAAW,CAAC;QACpC,MAAMC,MAAM;QAEZhB,OAAOU,QAAQO,MAAM,EAAER,IAAI,CAAC;QAC5BT,OAAOU,OAAO,CAAC,EAAE,EAAEQ,aAAa,CAAC;YAAEC,IAAI;YAAMC,OAAO;QAAK;IAC3D;AACF;AAEA,SAASJ,MAAMO,EAAU;IACvB,OAAO,IAAIC,QAAc,CAACC,UAAYC,WAAWD,SAASF;AAC5D"}

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+import { ProcessErrorReasonEnum } from "./types";
+export declare class SonamuTaskError extends Error {
+    cause: Error | undefined;
+    type: ProcessErrorReasonEnum;
+    constructor(type?: ProcessErrorReasonEnum, cause?: Error);
+}
+export declare function isSonamuTaskError(error: unknown): error is SonamuTaskError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEjD,qBAAa,eAAgB,SAAQ,KAAK;IACxC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IACzB,IAAI,EAAE,sBAAsB,CAAC;gBAEjB,IAAI,CAAC,EAAE,sBAAsB,EAAE,KAAK,CAAC,EAAE,KAAK;CAazD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAE1E"}

package/dist/errors.js

@@ -0,0 +1,21 @@
+export class SonamuTaskError extends Error {
+    cause;
+    type;
+    constructor(type, cause){
+        if (!type) {
+            type = "exception";
+        }
+        super(`SonamuTaskError: ${type}`);
+        this.name = "SonamuTaskError";
+        this.type = type;
+        if (cause) {
+            this.cause = cause;
+            this.stack = cause.stack;
+        }
+    }
+}
+export function isSonamuTaskError(error) {
+    return error instanceof SonamuTaskError;
+}
+
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["import { ProcessErrorReasonEnum } from \"./types\";\n\nexport class SonamuTaskError extends Error {\n  cause: Error | undefined;\n  type: ProcessErrorReasonEnum;\n\n  constructor(type?: ProcessErrorReasonEnum, cause?: Error) {\n    if (!type) {\n      type = \"exception\";\n    }\n\n    super(`SonamuTaskError: ${type}`);\n    this.name = \"SonamuTaskError\";\n    this.type = type;\n    if (cause) {\n      this.cause = cause;\n      this.stack = cause.stack;\n    }\n  }\n}\n\nexport function isSonamuTaskError(error: unknown): error is SonamuTaskError {\n  return error instanceof SonamuTaskError;\n}\n"],"names":["SonamuTaskError","Error","cause","type","name","stack","isSonamuTaskError","error"],"mappings":"AAEA,OAAO,MAAMA,wBAAwBC;IACnCC,MAAyB;IACzBC,KAA6B;IAE7B,YAAYA,IAA6B,EAAED,KAAa,CAAE;QACxD,IAAI,CAACC,MAAM;YACTA,OAAO;QACT;QAEA,KAAK,CAAC,CAAC,iBAAiB,EAAEA,MAAM;QAChC,IAAI,CAACC,IAAI,GAAG;QACZ,IAAI,CAACD,IAAI,GAAGA;QACZ,IAAID,OAAO;YACT,IAAI,CAACA,KAAK,GAAGA;YACb,IAAI,CAACG,KAAK,GAAGH,MAAMG,KAAK;QAC1B;IACF;AACF;AAEA,OAAO,SAASC,kBAAkBC,KAAc;IAC9C,OAAOA,iBAAiBP;AAC1B"}

package/dist/execution.d.ts

@@ -0,0 +1,82 @@
+import type { Backend } from "./backend";
+import type { DurationString } from "./core/duration";
+import type { StepAttempt } from "./core/step";
+import type { WorkflowRun } from "./core/workflow";
+/**
+ * Config for an individual step defined with `step.run()`.
+ */
+export interface StepFunctionConfig {
+    /**
+     * The name of the step.
+     */
+    name: string;
+}
+/**
+ * Represents the API for defining steps within a workflow. Used within a
+ * workflow handler to define steps by calling `step.run()`.
+ */
+export interface StepApi {
+    run<Output>(config: Readonly<StepFunctionConfig>, fn: StepFunction<Output>): Promise<Output>;
+    sleep(name: string, duration: DurationString): Promise<void>;
+}
+/**
+ * The step definition (defined by the user) that executes user code. Can return
+ * undefined (e.g., when using `return;`) which will be converted to null.
+ */
+export type StepFunction<Output> = () => Promise<Output | undefined> | Output | undefined;
+/**
+ * Params passed to a workflow function for the user to use when defining steps.
+ */
+export interface WorkflowFunctionParams<Input> {
+    input: Input;
+    step: StepApi;
+    version: string | null;
+}
+/**
+ * The workflow definition's function (defined by the user) that the user uses
+ * to define the workflow's steps.
+ */
+export type WorkflowFunction<Input, Output> = (params: Readonly<WorkflowFunctionParams<Input>>) => Promise<Output> | Output;
+/**
+ * Configures the options for a StepExecutor.
+ */
+export interface StepExecutorOptions {
+    backend: Backend;
+    workflowRunId: string;
+    workerId: string;
+    attempts: StepAttempt[];
+}
+/**
+ * Replays prior step attempts and persists new ones while memoizing
+ * deterministic step outputs.
+ */
+export declare class StepExecutor implements StepApi {
+    private readonly backend;
+    private readonly workflowRunId;
+    private readonly workerId;
+    private cache;
+    constructor(options: Readonly<StepExecutorOptions>);
+    run<Output>(config: Readonly<StepFunctionConfig>, fn: StepFunction<Output>): Promise<Output>;
+    sleep(name: string, duration: DurationString): Promise<void>;
+}
+/**
+ * Parameters for the workflow execution use case.
+ */
+export interface ExecuteWorkflowParams {
+    backend: Backend;
+    workflowRun: WorkflowRun;
+    workflowFn: WorkflowFunction<unknown, unknown>;
+    workflowVersion: string | null;
+    workerId: string;
+}
+/**
+ * Execute a workflow run. This is the core application use case that handles:
+ * - Loading step history
+ * - Handling sleeping steps
+ * - Creating the step executor
+ * - Executing the workflow function
+ * - Completing, failing, or sleeping the workflow run based on the outcome
+ * @param params - The execution parameters
+ */
+export declare function executeWorkflow(params: Readonly<ExecuteWorkflowParams>): Promise<void>;
+//# sourceMappingURL=execution.d.ts.map

package/dist/execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../src/execution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,aAAa,CAAC;AASjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,EAAE,EAAE,YAAY,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7F,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9D;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,MAAM,IAAI,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,SAAS,CAAC;AAE1F;;GAEG;AACH,MAAM,WAAW,sBAAsB,CAAC,KAAK;IAC3C,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,EAAE,MAAM,IAAI,CAC5C,MAAM,EAAE,QAAQ,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,KAC5C,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAgB9B;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB;AAED;;;GAGG;AACH,qBAAa,YAAa,YAAW,OAAO;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,KAAK,CAAmB;gBAEpB,OAAO,EAAE,QAAQ,CAAC,mBAAmB,CAAC;IAQ5C,GAAG,CAAC,MAAM,EACd,MAAM,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EACpC,EAAE,EAAE,YAAY,CAAC,MAAM,CAAC,GACvB,OAAO,CAAC,MAAM,CAAC;IAgDZ,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CA2BnE;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC/C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC,qBAAqB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA2F5F"}

package/dist/execution.js

@@ -0,0 +1,182 @@
+import { serializeError } from "./core/error.js";
+import { addToStepAttemptCache, calculateSleepResumeAt, createSleepContext, createStepAttemptCacheFromAttempts, getCachedStepAttempt, normalizeStepOutput } from "./core/step.js";
+/**
+ * Signal thrown when a workflow needs to sleep. Contains the time when the
+ * workflow should resume.
+ */ class SleepSignal extends Error {
+    resumeAt;
+    constructor(resumeAt){
+        super("SleepSignal");
+        this.name = "SleepSignal";
+        this.resumeAt = resumeAt;
+    }
+}
+/**
+ * Replays prior step attempts and persists new ones while memoizing
+ * deterministic step outputs.
+ */ export class StepExecutor {
+    backend;
+    workflowRunId;
+    workerId;
+    cache;
+    constructor(options){
+        this.backend = options.backend;
+        this.workflowRunId = options.workflowRunId;
+        this.workerId = options.workerId;
+        this.cache = createStepAttemptCacheFromAttempts(options.attempts);
+    }
+    async run(config, fn) {
+        const { name } = config;
+        // return cached result if available
+        const existingAttempt = getCachedStepAttempt(this.cache, name);
+        if (existingAttempt) {
+            return existingAttempt.output;
+        }
+        // not in cache, create new step attempt
+        const attempt = await this.backend.createStepAttempt({
+            workflowRunId: this.workflowRunId,
+            workerId: this.workerId,
+            stepName: name,
+            kind: "function",
+            config: {},
+            context: null
+        });
+        try {
+            // execute step function
+            const result = await fn();
+            const output = normalizeStepOutput(result);
+            // mark success
+            const savedAttempt = await this.backend.completeStepAttempt({
+                workflowRunId: this.workflowRunId,
+                stepAttemptId: attempt.id,
+                workerId: this.workerId,
+                output
+            });
+            // cache result
+            this.cache = addToStepAttemptCache(this.cache, savedAttempt);
+            return savedAttempt.output;
+        } catch (error) {
+            // mark failure
+            await this.backend.failStepAttempt({
+                workflowRunId: this.workflowRunId,
+                stepAttemptId: attempt.id,
+                workerId: this.workerId,
+                error: serializeError(error)
+            });
+            throw error;
+        }
+    }
+    async sleep(name, duration) {
+        // return cached result if this sleep already completed
+        const existingAttempt = getCachedStepAttempt(this.cache, name);
+        if (existingAttempt) return;
+        // create new step attempt for the sleep
+        const result = calculateSleepResumeAt(duration);
+        if (!result.ok) {
+            throw result.error;
+        }
+        const resumeAt = result.value;
+        const context = createSleepContext(resumeAt);
+        await this.backend.createStepAttempt({
+            workflowRunId: this.workflowRunId,
+            workerId: this.workerId,
+            stepName: name,
+            kind: "sleep",
+            config: {},
+            context
+        });
+        // throw sleep signal to trigger postponement
+        // we do not mark the step as completed here; it will be updated
+        // when the workflow resumes
+        throw new SleepSignal(resumeAt);
+    }
+}
+/**
+ * Execute a workflow run. This is the core application use case that handles:
+ * - Loading step history
+ * - Handling sleeping steps
+ * - Creating the step executor
+ * - Executing the workflow function
+ * - Completing, failing, or sleeping the workflow run based on the outcome
+ * @param params - The execution parameters
+ */ export async function executeWorkflow(params) {
+    const { backend, workflowRun, workflowFn, workflowVersion, workerId } = params;
+    try {
+        // load all pages of step history
+        const attempts = [];
+        let cursor;
+        do {
+            const response = await backend.listStepAttempts({
+                workflowRunId: workflowRun.id,
+                ...cursor ? {
+                    after: cursor
+                } : {},
+                limit: 1000
+            });
+            attempts.push(...response.data);
+            cursor = response.pagination.next ?? undefined;
+        }while (cursor)
+        // mark any sleep steps as completed if their sleep duration has elapsed,
+        // or rethrow SleepSignal if still sleeping
+        for(let i = 0; i < attempts.length; i++){
+            const attempt = attempts[i];
+            if (!attempt) continue;
+            if (attempt.status === "running" && attempt.kind === "sleep" && attempt.context?.kind === "sleep") {
+                const now = Date.now();
+                const resumeAt = new Date(attempt.context.resumeAt);
+                const resumeAtMs = resumeAt.getTime();
+                if (now < resumeAtMs) {
+                    // sleep duration HAS NOT elapsed yet, throw signal to put workflow
+                    // back to sleep
+                    throw new SleepSignal(resumeAt);
+                }
+                // sleep duration HAS elapsed, mark the step as completed and continue
+                const completed = await backend.completeStepAttempt({
+                    workflowRunId: workflowRun.id,
+                    stepAttemptId: attempt.id,
+                    workerId,
+                    output: null
+                });
+                // update cache w/ completed attempt
+                attempts[i] = completed;
+            }
+        }
+        // create step executor
+        const executor = new StepExecutor({
+            backend,
+            workflowRunId: workflowRun.id,
+            workerId,
+            attempts
+        });
+        // execute workflow
+        const output = await workflowFn({
+            input: workflowRun.input,
+            step: executor,
+            version: workflowVersion
+        });
+        // mark success
+        await backend.completeWorkflowRun({
+            workflowRunId: workflowRun.id,
+            workerId,
+            output: output ?? null
+        });
+    } catch (error) {
+        // handle sleep signal by setting workflow to sleeping status
+        if (error instanceof SleepSignal) {
+            await backend.sleepWorkflowRun({
+                workflowRunId: workflowRun.id,
+                workerId,
+                availableAt: error.resumeAt
+            });
+            return;
+        }
+        // mark failure
+        await backend.failWorkflowRun({
+            workflowRunId: workflowRun.id,
+            workerId,
+            error: serializeError(error)
+        });
+    }
+}
+
+//# sourceMappingURL=execution.js.map

package/dist/execution.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/execution.ts"],"sourcesContent":["import type { Backend } from \"./backend\";\nimport type { DurationString } from \"./core/duration\";\nimport { serializeError } from \"./core/error\";\nimport type { JsonValue } from \"./core/json\";\nimport type { StepAttempt, StepAttemptCache } from \"./core/step\";\nimport {\n  addToStepAttemptCache,\n  calculateSleepResumeAt,\n  createSleepContext,\n  createStepAttemptCacheFromAttempts,\n  getCachedStepAttempt,\n  normalizeStepOutput,\n} from \"./core/step\";\nimport type { WorkflowRun } from \"./core/workflow\";\n\n/**\n * Config for an individual step defined with `step.run()`.\n */\nexport interface StepFunctionConfig {\n  /**\n   * The name of the step.\n   */\n  name: string;\n}\n\n/**\n * Represents the API for defining steps within a workflow. Used within a\n * workflow handler to define steps by calling `step.run()`.\n */\nexport interface StepApi {\n  run<Output>(config: Readonly<StepFunctionConfig>, fn: StepFunction<Output>): Promise<Output>;\n  sleep(name: string, duration: DurationString): Promise<void>;\n}\n\n/**\n * The step definition (defined by the user) that executes user code. Can return\n * undefined (e.g., when using `return;`) which will be converted to null.\n */\nexport type StepFunction<Output> = () => Promise<Output | undefined> | Output | undefined;\n\n/**\n * Params passed to a workflow function for the user to use when defining steps.\n */\nexport interface WorkflowFunctionParams<Input> {\n  input: Input;\n  step: StepApi;\n  version: string | null;\n}\n\n/**\n * The workflow definition's function (defined by the user) that the user uses\n * to define the workflow's steps.\n */\nexport type WorkflowFunction<Input, Output> = (\n  params: Readonly<WorkflowFunctionParams<Input>>,\n) => Promise<Output> | Output;\n\n/**\n * Signal thrown when a workflow needs to sleep. Contains the time when the\n * workflow should resume.\n */\nclass SleepSignal extends Error {\n  readonly resumeAt: Date;\n\n  constructor(resumeAt: Readonly<Date>) {\n    super(\"SleepSignal\");\n    this.name = \"SleepSignal\";\n    this.resumeAt = resumeAt;\n  }\n}\n\n/**\n * Configures the options for a StepExecutor.\n */\nexport interface StepExecutorOptions {\n  backend: Backend;\n  workflowRunId: string;\n  workerId: string;\n  attempts: StepAttempt[];\n}\n\n/**\n * Replays prior step attempts and persists new ones while memoizing\n * deterministic step outputs.\n */\nexport class StepExecutor implements StepApi {\n  private readonly backend: Backend;\n  private readonly workflowRunId: string;\n  private readonly workerId: string;\n  private cache: StepAttemptCache;\n\n  constructor(options: Readonly<StepExecutorOptions>) {\n    this.backend = options.backend;\n    this.workflowRunId = options.workflowRunId;\n    this.workerId = options.workerId;\n\n    this.cache = createStepAttemptCacheFromAttempts(options.attempts);\n  }\n\n  async run<Output>(\n    config: Readonly<StepFunctionConfig>,\n    fn: StepFunction<Output>,\n  ): Promise<Output> {\n    const { name } = config;\n\n    // return cached result if available\n    const existingAttempt = getCachedStepAttempt(this.cache, name);\n    if (existingAttempt) {\n      return existingAttempt.output as Output;\n    }\n\n    // not in cache, create new step attempt\n    const attempt = await this.backend.createStepAttempt({\n      workflowRunId: this.workflowRunId,\n      workerId: this.workerId,\n      stepName: name,\n      kind: \"function\",\n      config: {},\n      context: null,\n    });\n\n    try {\n      // execute step function\n      const result = await fn();\n      const output = normalizeStepOutput(result);\n\n      // mark success\n      const savedAttempt = await this.backend.completeStepAttempt({\n        workflowRunId: this.workflowRunId,\n        stepAttemptId: attempt.id,\n        workerId: this.workerId,\n        output,\n      });\n\n      // cache result\n      this.cache = addToStepAttemptCache(this.cache, savedAttempt);\n\n      return savedAttempt.output as Output;\n    } catch (error) {\n      // mark failure\n      await this.backend.failStepAttempt({\n        workflowRunId: this.workflowRunId,\n        stepAttemptId: attempt.id,\n        workerId: this.workerId,\n        error: serializeError(error),\n      });\n      throw error;\n    }\n  }\n\n  async sleep(name: string, duration: DurationString): Promise<void> {\n    // return cached result if this sleep already completed\n    const existingAttempt = getCachedStepAttempt(this.cache, name);\n    if (existingAttempt) return;\n\n    // create new step attempt for the sleep\n    const result = calculateSleepResumeAt(duration);\n    if (!result.ok) {\n      throw result.error;\n    }\n    const resumeAt = result.value;\n    const context = createSleepContext(resumeAt);\n\n    await this.backend.createStepAttempt({\n      workflowRunId: this.workflowRunId,\n      workerId: this.workerId,\n      stepName: name,\n      kind: \"sleep\",\n      config: {},\n      context,\n    });\n\n    // throw sleep signal to trigger postponement\n    // we do not mark the step as completed here; it will be updated\n    // when the workflow resumes\n    throw new SleepSignal(resumeAt);\n  }\n}\n\n/**\n * Parameters for the workflow execution use case.\n */\nexport interface ExecuteWorkflowParams {\n  backend: Backend;\n  workflowRun: WorkflowRun;\n  workflowFn: WorkflowFunction<unknown, unknown>;\n  workflowVersion: string | null;\n  workerId: string;\n}\n\n/**\n * Execute a workflow run. This is the core application use case that handles:\n * - Loading step history\n * - Handling sleeping steps\n * - Creating the step executor\n * - Executing the workflow function\n * - Completing, failing, or sleeping the workflow run based on the outcome\n * @param params - The execution parameters\n */\nexport async function executeWorkflow(params: Readonly<ExecuteWorkflowParams>): Promise<void> {\n  const { backend, workflowRun, workflowFn, workflowVersion, workerId } = params;\n\n  try {\n    // load all pages of step history\n    const attempts: StepAttempt[] = [];\n    let cursor: string | undefined;\n    do {\n      const response = await backend.listStepAttempts({\n        workflowRunId: workflowRun.id,\n        ...(cursor ? { after: cursor } : {}),\n        limit: 1000,\n      });\n      attempts.push(...response.data);\n      cursor = response.pagination.next ?? undefined;\n    } while (cursor);\n\n    // mark any sleep steps as completed if their sleep duration has elapsed,\n    // or rethrow SleepSignal if still sleeping\n    for (let i = 0; i < attempts.length; i++) {\n      const attempt = attempts[i];\n      if (!attempt) continue;\n\n      if (\n        attempt.status === \"running\" &&\n        attempt.kind === \"sleep\" &&\n        attempt.context?.kind === \"sleep\"\n      ) {\n        const now = Date.now();\n        const resumeAt = new Date(attempt.context.resumeAt);\n        const resumeAtMs = resumeAt.getTime();\n\n        if (now < resumeAtMs) {\n          // sleep duration HAS NOT elapsed yet, throw signal to put workflow\n          // back to sleep\n          throw new SleepSignal(resumeAt);\n        }\n\n        // sleep duration HAS elapsed, mark the step as completed and continue\n        const completed = await backend.completeStepAttempt({\n          workflowRunId: workflowRun.id,\n          stepAttemptId: attempt.id,\n          workerId,\n          output: null,\n        });\n\n        // update cache w/ completed attempt\n        attempts[i] = completed;\n      }\n    }\n\n    // create step executor\n    const executor = new StepExecutor({\n      backend,\n      workflowRunId: workflowRun.id,\n      workerId,\n      attempts,\n    });\n\n    // execute workflow\n    const output = await workflowFn({\n      input: workflowRun.input as unknown,\n      step: executor,\n      version: workflowVersion,\n    });\n\n    // mark success\n    await backend.completeWorkflowRun({\n      workflowRunId: workflowRun.id,\n      workerId,\n      output: (output ?? null) as JsonValue,\n    });\n  } catch (error) {\n    // handle sleep signal by setting workflow to sleeping status\n    if (error instanceof SleepSignal) {\n      await backend.sleepWorkflowRun({\n        workflowRunId: workflowRun.id,\n        workerId,\n        availableAt: error.resumeAt,\n      });\n\n      return;\n    }\n\n    // mark failure\n    await backend.failWorkflowRun({\n      workflowRunId: workflowRun.id,\n      workerId,\n      error: serializeError(error),\n    });\n  }\n}\n"],"names":["serializeError","addToStepAttemptCache","calculateSleepResumeAt","createSleepContext","createStepAttemptCacheFromAttempts","getCachedStepAttempt","normalizeStepOutput","SleepSignal","Error","resumeAt","name","StepExecutor","backend","workflowRunId","workerId","cache","options","attempts","run","config","fn","existingAttempt","output","attempt","createStepAttempt","stepName","kind","context","result","savedAttempt","completeStepAttempt","stepAttemptId","id","error","failStepAttempt","sleep","duration","ok","value","executeWorkflow","params","workflowRun","workflowFn","workflowVersion","cursor","response","listStepAttempts","after","limit","push","data","pagination","next","undefined","i","length","status","now","Date","resumeAtMs","getTime","completed","executor","input","step","version","completeWorkflowRun","sleepWorkflowRun","availableAt","failWorkflowRun"],"mappings":"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"}

package/dist/execution.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=execution.test.d.ts.map

package/dist/execution.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.test.d.ts","sourceRoot":"","sources":["../src/execution.test.ts"],"names":[],"mappings":""}