openworkflow 0.4.1 → 0.6.0

package/dist/{worker/worker.js → worker.js}

@@ -1,5 +1,5 @@
-import { executeWorkflow } from "../execution/execution.js";
-import { getWorkflowKey } from "../sdk/sdk.js";
+import { executeWorkflow } from "./execution.js";
+import { WorkflowRegistry } from "./registry.js";
 import { randomUUID } from "node:crypto";
 const DEFAULT_LEASE_DURATION_MS = 30 * 1000; // 30s
 const DEFAULT_POLL_INTERVAL_MS = 100; // 100ms
@@ -11,22 +11,22 @@ const DEFAULT_CONCURRENCY = 1;
 export class Worker {
     backend;
     workerIds;
-    registeredWorkflows = new Map();
+    registry = new WorkflowRegistry();
     activeExecutions = new Set();
     running = false;
     loopPromise = null;
     constructor(options) {
         this.backend = options.backend;
+        for (const workflow of options.workflows) {
+            this.registry.register(workflow);
+        }
         const concurrency = Math.max(DEFAULT_CONCURRENCY, options.concurrency ?? DEFAULT_CONCURRENCY);
         // generate worker IDs for every concurrency slot
         this.workerIds = Array.from({ length: concurrency }, () => randomUUID());
-        // register workflows
-        for (const [name, workflow] of options.workflows) {
-            this.registeredWorkflows.set(name, workflow);
-        }
     }
     /**
      * Start the worker. It will begin polling for and executing workflows.
+     * @returns Promise resolved when started
      */
     async start() {
         if (this.running)
@@ -38,6 +38,7 @@ export class Worker {
     /**
      * Stop the worker gracefully. Waits for all active workflow runs to complete
      * before returning.
+     * @returns Promise resolved when stopped
      */
     async stop() {
         this.running = false;
@@ -51,6 +52,7 @@ export class Worker {
     /**
      * Processes one round of work claims and execution. Exposed for testing.
      * Returns the number of workflow runs claimed.
+     * @returns Number of workflow runs claimed
      */
     async tick() {
         const availableSlots = this.concurrency - this.activeExecutions.size;
@@ -68,6 +70,7 @@ export class Worker {
     }
     /**
      * Get the configured concurrency limit.
+     * @returns Concurrency limit
      */
     get concurrency() {
         return this.workerIds.length;
@@ -92,7 +95,7 @@ export class Worker {
         }
     }
     /*
-     * Cclaim and process a workflow run for the given worker ID. Do not await the
+     * Claim and process a workflow run for the given worker ID. Do not await the
      * processing here to avoid blocking the caller.
      * Returns the claimed workflow run, or null if none was available.
      */
@@ -104,8 +107,7 @@ export class Worker {
         });
         if (!workflowRun)
             return null;
-        const key = getWorkflowKey(workflowRun.workflowName, workflowRun.version);
-        const workflow = this.registeredWorkflows.get(key);
+        const workflow = this.registry.get(workflowRun.workflowName, workflowRun.version);
         if (!workflow) {
             const versionStr = workflowRun.version
                 ? ` (version: ${workflowRun.version})`
@@ -139,6 +141,9 @@ export class Worker {
     /**
      * Process a workflow execution, handling heartbeats, step execution, and
      * marking success or failure.
+     * @param execution - Workflow execution
+     * @param workflow - Workflow to execute
+     * @returns Promise resolved when processing completes
      */
     async processExecutionInBackground(execution, workflow) {
         // start heartbeating
@@ -202,7 +207,11 @@ class WorkflowExecution {
         }
     }
 }
+/**
+ * Sleep for a given duration.
+ * @param ms - Milliseconds to sleep
+ * @returns Promise resolved after sleeping
+ */
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=worker.js.map

package/dist/{worker/worker.test.d.ts.map → worker.test.d.ts.map}

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

package/dist/{worker/worker.test.js → worker.test.js}

@@ -1,10 +1,11 @@
-import { BackendPostgres } from "../../backend-postgres/backend.js";
-import { DEFAULT_DATABASE_URL } from "../../backend-postgres/postgres.js";
-import { OpenWorkflow } from "../sdk/sdk.js";
+import { OpenWorkflow } from "./client.js";
+import { BackendPostgres } from "./postgres.js";
+import { DEFAULT_POSTGRES_URL } from "./postgres/postgres.js";
+import { defineWorkflowSpec } from "./workflow.js";
 import { randomUUID } from "node:crypto";
 import { describe, expect, test } from "vitest";
 describe("Worker", () => {
-    test("passes workflow input to handlers (known slow test)", async () => {
+    test("passes workflow input to handlers", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const workflow = client.defineWorkflow({ name: "context" }, ({ input }) => input);
@@ -15,7 +16,7 @@ describe("Worker", () => {
         const result = await handle.result();
         expect(result).toEqual(payload);
     });
-    test("processes workflow runs to completion (known slow test)", async () => {
+    test("processes workflow runs to completion", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const workflow = client.defineWorkflow({ name: "process" }, ({ input }) => input.value * 2);
@@ -25,7 +26,7 @@ describe("Worker", () => {
         const result = await handle.result();
         expect(result).toBe(42);
     });
-    test("step.run reuses cached results (known slow test)", async () => {
+    test("step.run reuses cached results", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         let executionCount = 0;
@@ -69,7 +70,7 @@ describe("Worker", () => {
         expect(updated?.error).toBeDefined();
         expect(updated?.availableAt).not.toBeNull();
     });
-    test("retries failed workflows automatically (known slow test)", async () => {
+    test("retries failed workflows automatically", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         let attemptCount = 0;
@@ -102,7 +103,7 @@ describe("Worker", () => {
         const worker = client.newWorker();
         await worker.tick(); // no runs queued
     });
-    test("handles step functions that return undefined (known slow test)", async () => {
+    test("handles step functions that return undefined", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const workflow = client.defineWorkflow({ name: "undefined-steps" }, async ({ step }) => {
@@ -120,7 +121,7 @@ describe("Worker", () => {
         const result = await handle.result();
         expect(result).toEqual({ success: true });
     });
-    test("executes steps synchronously within workflow (known slow test)", async () => {
+    test("executes steps synchronously within workflow", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const executionOrder = [];
@@ -144,7 +145,7 @@ describe("Worker", () => {
         const result = await handle.result();
         expect(result).toEqual(["start", "step1", "between", "step2", "end"]);
     });
-    test("executes parallel steps with Promise.all (known slow test)", async () => {
+    test("executes parallel steps with Promise.all", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const executionTimes = {};
@@ -205,7 +206,7 @@ describe("Worker", () => {
         }
         expect(completed).toBe(2);
     });
-    test("worker starts, processes work, and stops gracefully (known slow test)", async () => {
+    test("worker starts, processes work, and stops gracefully", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const workflow = client.defineWorkflow({ name: "lifecycle" }, () => {
@@ -219,7 +220,7 @@ describe("Worker", () => {
         const result = await handle.result();
         expect(result).toBe("complete");
     });
-    test("recovers from crashes during parallel step execution (known slow test)", async () => {
+    test("recovers from crashes during parallel step execution", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         let attemptCount = 0;
@@ -254,7 +255,7 @@ describe("Worker", () => {
         expect(result).toEqual({ a: "a", b: "b", attempts: 2 });
         expect(attemptCount).toBe(2);
     });
-    test("reclaims workflow run when heartbeat stops (known slow test)", async () => {
+    test("reclaims workflow run when heartbeat stops", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const workflow = client.defineWorkflow({ name: "heartbeat-test" }, () => "done");
@@ -310,7 +311,7 @@ describe("Worker", () => {
         expect(claimedAgain).toBe(0);
         await worker.stop();
     });
-    test("worker only sleeps between claims when no work is available (known slow test)", async () => {
+    test("worker only sleeps between claims when no work is available", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const workflow = client.defineWorkflow({ name: "adaptive-test" }, async ({ step }) => {
@@ -333,7 +334,7 @@ describe("Worker", () => {
         // without it (with 100ms sleep between ticks), it would take much longer
         expect(duration).toBeLessThan(3000); // should complete in under 3 seconds
     });
-    test("only failed steps re-execute on retry (known slow test)", async () => {
+    test("only failed steps re-execute on retry", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const executionCounts = {
@@ -388,7 +389,7 @@ describe("Worker", () => {
             c: "c-result",
         });
     });
-    test("step.sleep postpones workflow execution (known slow test)", async () => {
+    test("step.sleep postpones workflow execution", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         let stepCount = 0;
@@ -494,10 +495,9 @@ describe("Worker", () => {
         });
         expect(failed?.status).toBe("pending"); // should be retrying
         expect(failed?.error).toBeDefined();
-        // @ts-expect-error - test suite
         expect(failed?.error?.message).toContain("Invalid duration format");
     });
-    test("step.sleep handles multiple sequential sleeps (known slow test)", async () => {
+    test("step.sleep handles multiple sequential sleeps", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         let executionCount = 0;
@@ -579,7 +579,7 @@ describe("Worker", () => {
         expect(claimed?.status).toBe("running");
         expect(claimed?.workerId).toBe("test-worker");
     });
-    test("sleep is not skipped when worker crashes after creating sleep step but before marking workflow as sleeping (known slow test)", async () => {
+    test("sleep is not skipped when worker crashes after creating sleep step but before marking workflow as sleeping", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         let executionCount = 0;
@@ -631,7 +631,7 @@ describe("Worker", () => {
         const result = await handle.result();
         expect(result.afterSleepCount).toBe(1);
     });
-    test("version enables conditional code paths (known slow test)", async () => {
+    test("version enables conditional code paths", async () => {
         const backend = await createBackend();
         const client = new OpenWorkflow({ backend });
         const workflow = client.defineWorkflow({ name: "conditional-workflow", version: "v2" }, async ({ version, step }) => {
@@ -774,13 +774,127 @@ describe("Worker", () => {
         await handle.cancel();
         await expect(handle.result()).rejects.toThrow(/Workflow cancel-result was canceled/);
     });
+    describe("version matching", () => {
+        test("worker matches workflow runs by version", async () => {
+            const backend = await createBackend();
+            const client = new OpenWorkflow({ backend });
+            client.defineWorkflow({ name: "versioned-workflow", version: "v1" }, async ({ step }) => {
+                return await step.run({ name: "compute" }, () => "v1-result");
+            });
+            client.defineWorkflow({ name: "versioned-workflow", version: "v2" }, async ({ step }) => {
+                return await step.run({ name: "compute" }, () => "v2-result");
+            });
+            const worker = client.newWorker({ concurrency: 2 });
+            const v1Spec = defineWorkflowSpec({
+                name: "versioned-workflow",
+                version: "v1",
+            });
+            const v2Spec = defineWorkflowSpec({
+                name: "versioned-workflow",
+                version: "v2",
+            });
+            const handleV1 = await client.runWorkflow(v1Spec);
+            const handleV2 = await client.runWorkflow(v2Spec);
+            await worker.tick();
+            await sleep(100); // wait for background execution
+            const resultV1 = await handleV1.result();
+            const resultV2 = await handleV2.result();
+            expect(resultV1).toBe("v1-result");
+            expect(resultV2).toBe("v2-result");
+        });
+        test("worker fails workflow run when version is not registered", async () => {
+            const backend = await createBackend();
+            const client = new OpenWorkflow({ backend });
+            client.defineWorkflow({ name: "version-check", version: "v1" }, () => "v1-result");
+            const worker = client.newWorker();
+            const workflowRun = await backend.createWorkflowRun({
+                workflowName: "version-check",
+                version: "v2",
+                idempotencyKey: null,
+                config: {},
+                context: null,
+                input: null,
+                availableAt: null,
+                deadlineAt: null,
+            });
+            await worker.tick();
+            const updated = await backend.getWorkflowRun({
+                workflowRunId: workflowRun.id,
+            });
+            expect(updated?.status).toBe("pending");
+            expect(updated?.error).toEqual({
+                message: 'Workflow "version-check" (version: v2) is not registered',
+            });
+        });
+        test("unversioned workflow does not match versioned run", async () => {
+            const backend = await createBackend();
+            const client = new OpenWorkflow({ backend });
+            client.defineWorkflow({ name: "version-mismatch" }, () => "unversioned-result");
+            const worker = client.newWorker();
+            const workflowRun = await backend.createWorkflowRun({
+                workflowName: "version-mismatch",
+                version: "v1",
+                idempotencyKey: null,
+                config: {},
+                context: null,
+                input: null,
+                availableAt: null,
+                deadlineAt: null,
+            });
+            await worker.tick();
+            const updated = await backend.getWorkflowRun({
+                workflowRunId: workflowRun.id,
+            });
+            expect(updated?.status).toBe("pending");
+            expect(updated?.error).toEqual({
+                message: 'Workflow "version-mismatch" (version: v1) is not registered',
+            });
+        });
+        test("versioned workflow does not match unversioned run", async () => {
+            const backend = await createBackend();
+            const client = new OpenWorkflow({ backend });
+            client.defineWorkflow({ name: "version-required", version: "v1" }, () => "v1-result");
+            const worker = client.newWorker();
+            const workflowRun = await backend.createWorkflowRun({
+                workflowName: "version-required",
+                version: null,
+                idempotencyKey: null,
+                config: {},
+                context: null,
+                input: null,
+                availableAt: null,
+                deadlineAt: null,
+            });
+            await worker.tick();
+            const updated = await backend.getWorkflowRun({
+                workflowRunId: workflowRun.id,
+            });
+            expect(updated?.status).toBe("pending");
+            expect(updated?.error).toEqual({
+                message: 'Workflow "version-required" is not registered',
+            });
+        });
+        test("workflow receives run's version, not registered version", async () => {
+            // this test verifies that the version passed to the workflow function
+            // is the one from the workflow run, not the registered workflow
+            const backend = await createBackend();
+            const client = new OpenWorkflow({ backend });
+            const workflow = client.defineWorkflow({ name: "version-in-handler", version: "v1" }, async ({ version, step }) => {
+                return await step.run({ name: "get-version" }, () => version);
+            });
+            const worker = client.newWorker();
+            const handle = await workflow.run();
+            await worker.tick();
+            const result = await handle.result();
+            expect(result).toBe("v1");
+        });
+    });
 });
 async function createBackend() {
-    return await BackendPostgres.connect(DEFAULT_DATABASE_URL, {
+    return await BackendPostgres.connect(DEFAULT_POSTGRES_URL, {
         namespaceId: randomUUID(), // unique namespace per test
     });
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=worker.test.js.map

package/dist/workflow.d.ts

@@ -0,0 +1,60 @@
+import type { StandardSchemaV1 } from "./core/schema.js";
+import { WorkflowFunction } from "./execution.js";
+/**
+ * A workflow spec.
+ */
+export interface WorkflowSpec<Input, Output, RawInput> {
+    /** The name of the workflow. */
+    readonly name: string;
+    /** The version of the workflow. */
+    readonly version?: string;
+    /** The schema used to validate inputs. */
+    readonly schema?: StandardSchemaV1<RawInput, Input>;
+    /** Phantom type carrier - won't exist at runtime. */
+    readonly __types?: {
+        output: Output;
+    };
+}
+/**
+ * Define a workflow spec.
+ * @param spec - The workflow spec
+ * @returns The workflow spec
+ */
+export declare function defineWorkflowSpec<Input, Output = unknown, RawInput = Input>(spec: WorkflowSpec<Input, Output, RawInput>): WorkflowSpec<Input, Output, RawInput>;
+/**
+ * Define a workflow spec.
+ * @param spec - The workflow spec
+ * @returns The workflow spec
+ * @deprecated use `defineWorkflowSpec` instead
+ */
+export declare const declareWorkflow: typeof defineWorkflowSpec;
+/**
+ * A workflow spec and implementation.
+ */
+export interface Workflow<Input, Output, RawInput> {
+    /** The workflow spec. */
+    readonly spec: WorkflowSpec<Input, Output, RawInput>;
+    /** The workflow implementation function. */
+    readonly fn: WorkflowFunction<Input, Output>;
+}
+/**
+ * Define a workflow.
+ * @param spec - The workflow spec
+ * @param fn - The workflow implementation function
+ * @returns The workflow
+ */
+export declare function defineWorkflow<Input, Output, RawInput = Input>(spec: WorkflowSpec<Input, Output, RawInput>, fn: WorkflowFunction<Input, Output>): Workflow<Input, Output, RawInput>;
+/**
+ * Define a workflow.
+ * @param spec - The workflow spec
+ * @param fn - The workflow implementation function
+ * @returns The workflow
+ */
+export declare function defineWorkflow<Input, WorkflowFn extends WorkflowFunction<Input, unknown> = WorkflowFunction<Input, unknown>, RawInput = Input>(spec: WorkflowSpec<Input, Awaited<ReturnType<WorkflowFn>>, RawInput>, fn: WorkflowFn): Workflow<Input, Awaited<ReturnType<WorkflowFn>>, RawInput>;
+/**
+ * Type guard to check if a value is a Workflow object.
+ * @param value - The value to check
+ * @returns True if the value is a Workflow
+ */
+export declare function isWorkflow(value: unknown): boolean;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../workflow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ;IACnD,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mCAAmC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACpD,qDAAqD;IACrD,QAAQ,CAAC,OAAO,CAAC,EAAE;QACjB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,QAAQ,GAAG,KAAK,EAC1E,IAAI,EAAE,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,GAC1C,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAEvC;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,2BAAqB,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ;IAC/C,yBAAyB;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IACrD,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC9C;AAED;;;;;GAKG;AAIH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAG,KAAK,EAC5D,IAAI,EAAE,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAC3C,EAAE,EAAE,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,GAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;AAErC;;;;;GAKG;AAGH,wBAAgB,cAAc,CAC5B,KAAK,EACL,UAAU,SAAS,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,CACpE,KAAK,EACL,OAAO,CACR,EACD,QAAQ,GAAG,KAAK,EAEhB,IAAI,EAAE,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,EACpE,EAAE,EAAE,UAAU,GACb,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;AAmB9D;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,WAkBxC"}

package/dist/workflow.js

@@ -0,0 +1,48 @@
+/**
+ * Define a workflow spec.
+ * @param spec - The workflow spec
+ * @returns The workflow spec
+ */
+export function defineWorkflowSpec(spec) {
+    return spec;
+}
+/**
+ * Define a workflow spec.
+ * @param spec - The workflow spec
+ * @returns The workflow spec
+ * @deprecated use `defineWorkflowSpec` instead
+ */
+export const declareWorkflow = defineWorkflowSpec;
+/**
+ * Define a workflow.
+ * @internal
+ * @param spec - The workflow spec
+ * @param fn - The workflow implementation function
+ * @returns The workflow
+ */
+export function defineWorkflow(spec, fn) {
+    return {
+        spec,
+        fn,
+    };
+}
+/**
+ * Type guard to check if a value is a Workflow object.
+ * @param value - The value to check
+ * @returns True if the value is a Workflow
+ */
+export function isWorkflow(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const maybeWorkflow = value;
+    if (!("spec" in maybeWorkflow) || !("fn" in maybeWorkflow)) {
+        return false;
+    }
+    const { spec, fn } = maybeWorkflow;
+    return (typeof spec === "object" &&
+        spec !== null &&
+        "name" in spec &&
+        typeof spec.name === "string" &&
+        typeof fn === "function");
+}

package/dist/workflow.test.d.ts

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

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

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

package/dist/workflow.test.js

@@ -0,0 +1,84 @@
+import { defineWorkflow, defineWorkflowSpec, isWorkflow } from "./workflow.js";
+import { describe, expect, test } from "vitest";
+describe("defineWorkflowSpec", () => {
+    test("returns spec (passthrough)", () => {
+        const spec = { name: "test-workflow" };
+        const definedSpec = defineWorkflowSpec(spec);
+        expect(definedSpec).toStrictEqual(spec);
+    });
+});
+describe("defineWorkflow", () => {
+    test("returns workflow with spec and fn", () => {
+        // eslint-disable-next-line unicorn/consistent-function-scoping
+        function fn() {
+            return { result: "done" };
+        }
+        const spec = { name: "test-workflow" };
+        const workflow = defineWorkflow(spec, fn);
+        expect(workflow).toStrictEqual({
+            spec,
+            fn,
+        });
+    });
+});
+describe("isWorkflow", () => {
+    test("returns true for valid workflow objects", () => {
+        const workflow = defineWorkflow({ name: "test" }, () => "done");
+        expect(isWorkflow(workflow)).toBe(true);
+    });
+    test("returns false for null", () => {
+        expect(isWorkflow(null)).toBe(false);
+    });
+    test("returns false for undefined", () => {
+        // eslint-disable-next-line unicorn/no-useless-undefined
+        expect(isWorkflow(undefined)).toBe(false);
+    });
+    test("returns false for primitives", () => {
+        expect(isWorkflow("string")).toBe(false);
+        expect(isWorkflow(123)).toBe(false);
+        expect(isWorkflow(true)).toBe(false);
+    });
+    test("returns false for objects without spec", () => {
+        expect(isWorkflow({ fn: () => "result" })).toBe(false);
+    });
+    test("returns false for objects without fn", () => {
+        expect(isWorkflow({ spec: { name: "test" } })).toBe(false);
+    });
+    test("returns false for objects with invalid spec", () => {
+        expect(isWorkflow({ spec: null, fn: () => "result" })).toBe(false);
+        expect(isWorkflow({ spec: "invalid", fn: () => "result" })).toBe(false);
+    });
+    test("returns false for objects with invalid fn", () => {
+        expect(isWorkflow({ spec: { name: "test" }, fn: "not-a-function" })).toBe(false);
+    });
+});
+// --- type checks below -------------------------------------------------------
+// they're unused but useful to ensure that the types work as expected for both
+// defineWorkflowSpec and defineWorkflow
+const inferredTypesSpec = defineWorkflowSpec({
+    name: "inferred-types",
+});
+defineWorkflow(inferredTypesSpec, async ({ step }) => {
+    await step.run({ name: "step-1" }, () => {
+        return "success";
+    });
+    return { result: "done" };
+});
+const explicitInputTypeSpec = defineWorkflowSpec({
+    name: "explicit-input-type",
+});
+defineWorkflow(explicitInputTypeSpec, async ({ step }) => {
+    await step.run({ name: "step-1" }, () => {
+        return "success";
+    });
+    return { result: "done" };
+});
+const explicitInputAndOutputTypesSpec = defineWorkflowSpec({
+    name: "explicit-input-and-output-types",
+});
+defineWorkflow(explicitInputAndOutputTypesSpec, async ({ step }) => {
+    await step.run({ name: "step-1" }, () => {
+        return "success";
+    });
+    return { result: "done" };
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openworkflow",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Open-source TypeScript framework for building durable, resumable workflows",
   "keywords": [
     "durable execution",
@@ -28,10 +28,25 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "development": "./index.ts",
       "default": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    },
+    "./postgres": {
+      "types": "./dist/postgres.d.ts",
+      "default": "./dist/postgres.js"
+    },
+    "./sqlite": {
+      "types": "./dist/sqlite.d.ts",
+      "default": "./dist/sqlite.js"
     }
   },
+  "bin": {
+    "openworkflow": "./dist/bin/openworkflow.js",
+    "ow": "./dist/bin/openworkflow.js"
+  },
   "files": [
     "dist"
   ],
@@ -40,10 +55,19 @@
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
-    "arktype": "^2.1.28",
+    "arktype": "^2.1.29",
     "valibot": "^1.2.0",
+    "vitest": "^4.0.18",
     "yup": "^1.7.1",
-    "zod": "^4.1.13"
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "postgres": ">=3"
+  },
+  "peerDependenciesMeta": {
+    "postgres": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=20"

package/dist/backend-sqlite/backend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../backend-sqlite/backend.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,OAAO,EACP,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,4BAA4B,EAC5B,sBAAsB,EACtB,sBAAsB,EACtB,iBAAiB,EACjB,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,WAAW,EACX,WAAW,EAGZ,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAEhD,UAAU,oBAAoB;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,qBAAa,aAAc,YAAW,OAAO;IAC3C,OAAO,CAAC,EAAE,CAAW;IACrB,OAAO,CAAC,WAAW,CAAS;IAE5B,OAAO;IAKP;;;;OAIG;IACH,MAAM,CAAC,OAAO,CACZ,IAAI,GAAE,MAA8B,EACpC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa;IAgBhB,IAAI,IAAI,IAAI;IAIN,iBAAiB,CACrB,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,WAAW,CAAC;IAgDvB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAenE,gBAAgB,CACpB,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IA0FxB,sBAAsB,CAC1B,MAAM,EAAE,4BAA4B,GACnC,OAAO,CAAC,WAAW,CAAC;IAmCjB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,WAAW,CAAC;IAoCtE,mBAAmB,CACvB,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,WAAW,CAAC;IAyCjB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,WAAW,CAAC;IA+DpE,iBAAiB,CACrB,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,WAAW,CAAC;IAuDvB,gBAAgB,CACd,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAgE1C,gBAAgB,CACd,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAmE1C,OAAO,CAAC,wBAAwB;IAyC1B,iBAAiB,CACrB,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,WAAW,CAAC;IAwCvB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAenE,mBAAmB,CACvB,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,WAAW,CAAC;IA0DjB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,WAAW,CAAC;CAyD3E"}