openworkflow 0.4.1 → 0.6.0

package/dist/bin/openworkflow.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=openworkflow.d.ts.map

package/dist/bin/openworkflow.d.ts.map

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

package/dist/bin/openworkflow.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+/**
+ * This script is a zero-dependency entrypoint for the OpenWorkflow CLI. It
+ * allows users to run `npx openworkflow <command>` without requiring the core
+ * 'openworkflow' package to have any production dependencies (like commander,
+ * consola, etc).
+ *
+ * Note: This file is transpiled to `./dist/bin/openworkflow.js`. Relative paths
+ * below are calculated based on that runtime location.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+// get the version of the current package to ensure we call the matching CLI
+const packageJsonPath = path.join(__dirname, "../../package.json");
+const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+const version = packageJson.version;
+// capture all args passed to npx openworkflow (e.g., "init", "worker start")
+const args = process.argv.slice(2);
+// build the command, using tsx to run local TypeScript CLI if in dev and
+// otherwise using npx to run the published CLI package
+const cliScriptFilePath = path.resolve(__dirname, "../../../cli/cli.ts");
+const isMonorepo = existsSync(cliScriptFilePath);
+if (isMonorepo) {
+    console.log("⚠️ Running OpenWorkflow CLI from local source (monorepo development mode)\n");
+}
+const command = isMonorepo
+    ? // `npx tsx ../../../cli/cli.ts ...args`
+        ["tsx", cliScriptFilePath, ...args]
+    : // `npx -y @openworkflow/cli@<version> ...args`
+        // uses -y to skip the "Need to install @openworkflow/cli" prompt
+        ["-y", `@openworkflow/cli@${version}`, ...args];
+// spawn the CLI the command to run the actual CLI package
+const result = spawnSync(
+// eslint-disable-next-line sonarjs/no-os-command-from-path
+"npx", command, {
+    stdio: "inherit",
+    shell: true,
+});
+// exit with the same status code as the CLI
+process.exit(result.status ?? 0);

package/dist/chaos.test.d.ts

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

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

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

package/dist/chaos.test.js

@@ -0,0 +1,88 @@
+import { OpenWorkflow } from "./client.js";
+import { BackendPostgres } from "./postgres.js";
+import { DEFAULT_POSTGRES_URL } from "./postgres/postgres.js";
+import { randomInt, randomUUID } from "node:crypto";
+import { describe, expect, test } from "vitest";
+const TOTAL_STEPS = 50;
+const WORKER_COUNT = 3;
+const WORKER_CONCURRENCY = 2;
+const STEP_DURATION_MS = 25;
+const CHAOS_DURATION_MS = 5000;
+const CHAOS_INTERVAL_MS = 200;
+const TEST_TIMEOUT_MS = 30_000;
+describe("chaos test", () => {
+    test("workflow completes despite random worker deaths", async () => {
+        const backend = await createBackend();
+        const client = new OpenWorkflow({ backend });
+        const workflow = client.defineWorkflow({ name: "chaos-workflow" }, async ({ step }) => {
+            const results = [];
+            for (let i = 0; i < TOTAL_STEPS; i++) {
+                const stepName = `step-${i.toString()}`;
+                const result = await step.run({ name: stepName }, async () => {
+                    await sleep(STEP_DURATION_MS); // fake work
+                    return i;
+                });
+                results.push(result);
+            }
+            return results;
+        });
+        const workers = await Promise.all(Array.from({ length: WORKER_COUNT }, () => createAndStartWorker(client)));
+        const handle = await workflow.run();
+        let workflowCompleted = false;
+        let chaosTask = null;
+        try {
+            chaosTask = runChaosTest({
+                client,
+                workers,
+                durationMs: CHAOS_DURATION_MS,
+                intervalMs: CHAOS_INTERVAL_MS,
+                shouldStop: () => workflowCompleted,
+            });
+            const result = await handle.result();
+            workflowCompleted = true;
+            const restarts = await chaosTask;
+            expect(result).toHaveLength(TOTAL_STEPS);
+            expect(result[TOTAL_STEPS - 1]).toBe(TOTAL_STEPS - 1);
+            expect(restarts).toBeGreaterThan(0);
+        }
+        finally {
+            workflowCompleted = true;
+            if (chaosTask)
+                await chaosTask;
+            await Promise.all(workers.map((worker) => worker.stop()));
+            await backend.stop();
+        }
+    }, TEST_TIMEOUT_MS);
+});
+async function runChaosTest(params) {
+    const { client, workers, durationMs, intervalMs, shouldStop } = params;
+    const chaosEndsAt = Date.now() + durationMs;
+    let restartCount = 0;
+    while (Date.now() < chaosEndsAt && !shouldStop()) {
+        await sleep(intervalMs);
+        if (workers.length === 0) {
+            workers.push(await createAndStartWorker(client));
+            continue;
+        }
+        const index = randomInt(workers.length);
+        const victim = workers.splice(index, 1)[0];
+        await victim?.stop();
+        const replacement = await createAndStartWorker(client);
+        workers.push(replacement);
+        restartCount++;
+    }
+    return restartCount;
+}
+async function createBackend() {
+    return await BackendPostgres.connect(DEFAULT_POSTGRES_URL, {
+        namespaceId: randomUUID(),
+    });
+}
+async function createAndStartWorker(client) {
+    const worker = client.newWorker({ concurrency: WORKER_CONCURRENCY });
+    await worker.start();
+    return worker;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/client.d.ts

@@ -0,0 +1,141 @@
+import type { Backend } from "./backend.js";
+import type { StandardSchemaV1 } from "./core/schema.js";
+import type { SchemaInput, SchemaOutput, WorkflowRun } from "./core/workflow.js";
+import type { WorkflowFunction } from "./execution.js";
+import { Worker } from "./worker.js";
+import { type Workflow, type WorkflowSpec } from "./workflow.js";
+type WorkflowHandlerInput<TSchema, Input> = SchemaOutput<TSchema, Input>;
+type WorkflowRunInput<TSchema, Input> = SchemaInput<TSchema, Input>;
+/**
+ * Options for the OpenWorkflow client.
+ */
+export interface OpenWorkflowOptions {
+    backend: Backend;
+}
+/**
+ * Client used to register workflows and start runs.
+ */
+export declare class OpenWorkflow {
+    private backend;
+    private registry;
+    constructor(options: OpenWorkflowOptions);
+    /**
+     * Create a new Worker with this client's backend and workflows.
+     * @param options - Worker options
+     * @param options.concurrency - Max concurrent workflow runs
+     * @returns Worker instance
+     */
+    newWorker(options?: {
+        concurrency?: number | undefined;
+    }): Worker;
+    /**
+     * Provide the implementation for a declared workflow. This links the workflow
+     * specification to its execution logic and registers it with this
+     * OpenWorkflow instance for worker execution.
+     * @param spec - Workflow spec
+     * @param fn - Workflow implementation
+     */
+    implementWorkflow<Input, Output, RunInput = Input>(spec: WorkflowSpec<Input, Output, RunInput>, fn: WorkflowFunction<Input, Output>): void;
+    /**
+     * Run a workflow from its specification. This is the primary way to schedule
+     * a workflow using only its WorkflowSpec.
+     * @param spec - Workflow spec
+     * @param input - Workflow input
+     * @param options - Run options
+     * @returns Handle for awaiting the result
+     * @example
+     * ```ts
+     * const handle = await ow.runWorkflow(emailWorkflow, { to: 'user@example.com' });
+     * const result = await handle.result();
+     * ```
+     */
+    runWorkflow<Input, Output, RunInput = Input>(spec: WorkflowSpec<Input, Output, RunInput>, input?: RunInput, options?: WorkflowRunOptions): Promise<WorkflowRunHandle<Output>>;
+    /**
+     * Define and register a new workflow.
+     * @param spec - Workflow spec
+     * @param fn - Workflow implementation
+     * @returns Runnable workflow
+     * @example
+     * ```ts
+     * const workflow = ow.defineWorkflow(
+     *   { name: 'my-workflow' },
+     *   async ({ input, step }) => {
+     *     // workflow implementation
+     *   },
+     * );
+     * ```
+     */
+    defineWorkflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(spec: WorkflowSpec<WorkflowHandlerInput<TSchema, Input>, Output, WorkflowRunInput<TSchema, Input>>, fn: WorkflowFunction<WorkflowHandlerInput<TSchema, Input>, Output>): RunnableWorkflow<WorkflowHandlerInput<TSchema, Input>, Output, WorkflowRunInput<TSchema, Input>>;
+}
+/**
+ * A fully defined workflow with its implementation. This class is returned by
+ * `client.defineWorkflow` and provides the `.run()` method for scheduling
+ * workflow runs.
+ */
+export declare class RunnableWorkflow<Input, Output, RunInput = Input> {
+    private readonly ow;
+    readonly workflow: Workflow<Input, Output, RunInput>;
+    constructor(ow: OpenWorkflow, workflow: Workflow<Input, Output, RunInput>);
+    /**
+     * Starts a new workflow run.
+     * @param input - Workflow input
+     * @param options - Run options
+     * @returns Workflow run handle
+     */
+    run(input?: RunInput, options?: WorkflowRunOptions): Promise<WorkflowRunHandle<Output>>;
+}
+/**
+ * Options for creating a new workflow run from a runnable workflow when calling
+ * `workflowDef.run()`.
+ */
+export interface WorkflowRunOptions {
+    /**
+     * Set a deadline for the workflow run. If the workflow exceeds this deadline,
+     * it will be marked as failed.
+     */
+    deadlineAt?: Date;
+}
+/**
+ * Options for WorkflowHandle.
+ */
+export interface WorkflowHandleOptions {
+    backend: Backend;
+    workflowRun: WorkflowRun;
+    resultPollIntervalMs: number;
+    resultTimeoutMs: number;
+}
+/**
+ * Options for result() on a WorkflowRunHandle.
+ */
+export interface WorkflowRunHandleResultOptions {
+    /**
+     * Time to wait for a workflow run to complete. Throws an error if the timeout
+     * is exceeded.
+     * @default 300000 (5 minutes)
+     */
+    timeoutMs?: number;
+}
+/**
+ * Represents a started workflow run and provides methods to await its result.
+ * Returned from `workflowDef.run()`.
+ */
+export declare class WorkflowRunHandle<Output> {
+    private backend;
+    readonly workflowRun: WorkflowRun;
+    private resultPollIntervalMs;
+    private resultTimeoutMs;
+    constructor(options: WorkflowHandleOptions);
+    /**
+     * Waits for the workflow run to complete and returns the result.
+     * @param options - Options for waiting for the result
+     * @returns Workflow output
+     */
+    result(options?: WorkflowRunHandleResultOptions): Promise<Output>;
+    /**
+     * Cancels the workflow run. Only workflows in pending, running, or sleeping
+     * status can be canceled.
+     */
+    cancel(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

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

package/dist/{sdk/sdk.js → client.js}

@@ -1,5 +1,7 @@
-import { validateInput } from "../core/workflow.js";
-import { Worker } from "../worker/worker.js";
+import { validateInput } from "./core/workflow.js";
+import { WorkflowRegistry } from "./registry.js";
+import { Worker } from "./worker.js";
+import { defineWorkflow, } from "./workflow.js";
 const DEFAULT_RESULT_POLL_INTERVAL_MS = 1000; // 1s
 const DEFAULT_RESULT_TIMEOUT_MS = 5 * 60 * 1000; // 5m
 /**
@@ -7,17 +9,20 @@ const DEFAULT_RESULT_TIMEOUT_MS = 5 * 60 * 1000; // 5m
  */
 export class OpenWorkflow {
     backend;
-    registeredWorkflows = new Map();
+    registry = new WorkflowRegistry();
     constructor(options) {
         this.backend = options.backend;
     }
     /**
      * Create a new Worker with this client's backend and workflows.
+     * @param options - Worker options
+     * @param options.concurrency - Max concurrent workflow runs
+     * @returns Worker instance
      */
     newWorker(options) {
         return new Worker({
             backend: this.backend,
-            workflows: this.registeredWorkflows,
+            workflows: this.registry.getAll(),
             concurrency: options?.concurrency,
         });
     }
@@ -25,20 +30,23 @@ export class OpenWorkflow {
      * Provide the implementation for a declared workflow. This links the workflow
      * specification to its execution logic and registers it with this
      * OpenWorkflow instance for worker execution.
+     * @param spec - Workflow spec
+     * @param fn - Workflow implementation
      */
     implementWorkflow(spec, fn) {
-        const key = getWorkflowKey(spec.name, spec.version);
-        if (this.registeredWorkflows.has(key)) {
-            const versionStr = spec.version ? ` (version: ${spec.version})` : "";
-            throw new Error(`Workflow "${spec.name}"${versionStr} is already registered`);
-        }
-        const definition = new WorkflowDefinition(this, spec, fn);
-        this.registeredWorkflows.set(key, definition);
+        const workflow = {
+            spec,
+            fn,
+        };
+        this.registry.register(workflow);
     }
     /**
      * Run a workflow from its specification. This is the primary way to schedule
      * a workflow using only its WorkflowSpec.
-     *
+     * @param spec - Workflow spec
+     * @param input - Workflow input
+     * @param options - Run options
+     * @returns Handle for awaiting the result
      * @example
      * ```ts
      * const handle = await ow.runWorkflow(emailWorkflow, { to: 'user@example.com' });
@@ -53,7 +61,7 @@ export class OpenWorkflow {
         const parsedInput = validationResult.value;
         const workflowRun = await this.backend.createWorkflowRun({
             workflowName: spec.name,
-            version: spec.version,
+            version: spec.version ?? null,
             idempotencyKey: null,
             config: {},
             context: null,
@@ -70,12 +78,9 @@ export class OpenWorkflow {
     }
     /**
      * Define and register a new workflow.
-     *
-     * This is a convenience method that combines `declareWorkflow` and
-     * `implementWorkflow` into a single call. For better code splitting and to
-     * separate declaration from implementation, consider using those methods
-     * separately.
-     *
+     * @param spec - Workflow spec
+     * @param fn - Workflow implementation
+     * @returns Runnable workflow
      * @example
      * ```ts
      * const workflow = ow.defineWorkflow(
@@ -86,67 +91,32 @@ export class OpenWorkflow {
      * );
      * ```
      */
-    defineWorkflow(config, fn) {
-        const spec = declareWorkflow(config);
-        const key = getWorkflowKey(spec.name, spec.version);
-        const definition = new WorkflowDefinition(this, spec, fn);
-        this.registeredWorkflows.set(key, definition);
-        return definition;
+    defineWorkflow(spec, fn) {
+        const workflow = defineWorkflow(spec, fn);
+        this.registry.register(workflow);
+        return new RunnableWorkflow(this, workflow);
     }
 }
-/**
- * Declare a workflow without providing its implementation (which is provided
- * separately via `implementWorkflow`). Returns a lightweight WorkflowSpec
- * that can be used to schedule workflow runs.
- *
- * @example
- * ```ts
- * export const emailWorkflow = declareWorkflow({
- *   name: 'send-email',
- *   schema: z.object({ to: z.string().email() }),
- * });
- * ```
- */
-export function declareWorkflow(config) {
-    return {
-        name: config.name,
-        version: config.version ?? null,
-        schema: config.schema ?? null,
-    };
-}
-/**
- * Generate a composite key for workflow registration that includes both name
- * and version.
- *
- * @param name - The workflow name
- * @param version - The workflow version (null for unversioned)
- * @returns A composite key string
- */
-export function getWorkflowKey(name, version) {
-    return version ? `${name}@${version}` : name;
-}
-//
-// --- Workflow Definition
-//
 /**
  * A fully defined workflow with its implementation. This class is returned by
- * `defineWorkflow` and provides the `.run()` method for scheduling workflow
- * runs.
+ * `client.defineWorkflow` and provides the `.run()` method for scheduling
+ * workflow runs.
  */
-export class WorkflowDefinition {
+export class RunnableWorkflow {
     ow;
-    spec;
-    fn;
-    constructor(ow, spec, fn) {
+    workflow;
+    constructor(ow, workflow) {
         this.ow = ow;
-        this.spec = spec;
-        this.fn = fn;
+        this.workflow = workflow;
     }
     /**
      * Starts a new workflow run.
+     * @param input - Workflow input
+     * @param options - Run options
+     * @returns Workflow run handle
      */
     async run(input, options) {
-        return this.ow.runWorkflow(this.spec, input, options);
+        return this.ow.runWorkflow(this.workflow.spec, input, options);
     }
 }
 /**
@@ -166,9 +136,12 @@ export class WorkflowRunHandle {
     }
     /**
      * Waits for the workflow run to complete and returns the result.
+     * @param options - Options for waiting for the result
+     * @returns Workflow output
      */
-    async result() {
+    async result(options) {
         const start = Date.now();
+        const timeout = options?.timeoutMs ?? this.resultTimeoutMs;
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         while (true) {
             const latest = await this.backend.getWorkflowRun({
@@ -187,7 +160,7 @@ export class WorkflowRunHandle {
             if (latest.status === "canceled") {
                 throw new Error(`Workflow ${this.workflowRun.workflowName} was canceled`);
             }
-            if (Date.now() - start > this.resultTimeoutMs) {
+            if (Date.now() - start > timeout) {
                 throw new Error(`Timed out waiting for workflow run ${this.workflowRun.id} to finish`);
             }
             await new Promise((resolve) => {
@@ -205,4 +178,3 @@ export class WorkflowRunHandle {
         });
     }
 }
-//# sourceMappingURL=sdk.js.map

package/dist/client.test.d.ts

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

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

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