openworkflow 0.4.1 → 0.6.0

package/dist/postgres/driver.js

@@ -0,0 +1,63 @@
+/**
+ * Creates a PostgreSQL driver for OpenWorkflow.
+ *
+ * This function follows the Drizzle ORM pattern and supports multiple
+ * calling conventions:
+ * @param config - Connection string or configuration object
+ * @returns A PostgresDriver instance
+ * @example
+ * ```ts
+ * // With connection string
+ * postgres(process.env.DATABASE_URL)
+ *
+ * // With config object
+ * postgres({
+ *   connection: process.env.DATABASE_URL,
+ *   namespace: 'my-app',
+ * })
+ *
+ * // With existing client
+ * postgres({ client: existingPostgresClient })
+ * ```
+ */
+export function postgres(config) {
+    // Normalize config
+    const normalizedConfig = typeof config === "string" ? { connection: config } : config;
+    // Store the client reference (will be set on createBackend)
+    let clientRef = normalizedConfig.client;
+    return {
+        dialect: "postgres",
+        get $client() {
+            return clientRef;
+        },
+        async createBackend() {
+            // Dynamically import BackendPostgres to avoid requiring the postgres
+            // package as a direct dependency of the openworkflow package
+            const { BackendPostgres } = await import("@openworkflow/backend-postgres");
+            // Determine the connection URL
+            const connectionUrl = normalizedConfig.connection;
+            if (!connectionUrl && !normalizedConfig.client) {
+                throw new Error("PostgreSQL driver requires either a connection string or an existing client. " +
+                    "Provide `connection` URL or `client` in the config.");
+            }
+            // If we have an existing client, we need to handle it differently
+            // For now, we use the BackendPostgres.connect which creates its own client
+            if (!connectionUrl) {
+                throw new Error("Using an existing postgres.js client is not yet supported. " +
+                    "Please provide a connection string via the `connection` option.");
+            }
+            const options = {
+                runMigrations: normalizedConfig.runMigrations ?? true,
+            };
+            if (normalizedConfig.namespace) {
+                options.namespaceId = normalizedConfig.namespace;
+            }
+            const backend = await BackendPostgres.connect(connectionUrl, options);
+            // Store client reference for $client getter
+            // Note: BackendPostgres doesn't expose the client, so this remains undefined
+            // In the future, we could extend BackendPostgres to expose the client
+            clientRef = undefined;
+            return backend;
+        },
+    };
+}

package/dist/postgres/index.d.ts

@@ -0,0 +1,11 @@
+import { BackendPostgres } from "./backend.js";
+import type { Postgres } from "./postgres.js";
+/**
+ * Create a Postgres-backed OpenWorkflow backend using postgres.js.
+ * @param client - postgres.js client or connection URL
+ * @param options - Backend options
+ * @returns A connected backend instance
+ */
+export declare function openworkflow(client: Postgres, options?: Parameters<typeof BackendPostgres.fromClient>[1]): Promise<BackendPostgres>;
+export declare function openworkflow(url: string, options?: Parameters<typeof BackendPostgres.connect>[1]): Promise<BackendPostgres>;
+//# sourceMappingURL=index.d.ts.map

package/dist/postgres/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../postgres/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,QAAQ,EAChB,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,eAAe,CAAC,CAAC;AAC5B,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACtD,OAAO,CAAC,eAAe,CAAC,CAAC"}

package/dist/postgres/index.js

@@ -0,0 +1,7 @@
+import { BackendPostgres } from "./backend.js";
+export async function openworkflow(clientOrUrl, options) {
+    if (typeof clientOrUrl === "string") {
+        return BackendPostgres.connect(clientOrUrl, options);
+    }
+    return BackendPostgres.fromClient(clientOrUrl, options);
+}

package/dist/postgres/internal.d.ts

@@ -0,0 +1,2 @@
+export * from "./postgres.js";
+//# sourceMappingURL=internal.d.ts.map

package/dist/postgres/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../postgres/internal.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/postgres/internal.js

@@ -0,0 +1 @@
+export * from "./postgres.js";

package/dist/postgres/postgres.d.ts

@@ -0,0 +1,42 @@
+import postgres from "postgres";
+export declare const DEFAULT_POSTGRES_URL = "postgresql://postgres:postgres@localhost:5432/postgres";
+export declare const DEFAULT_SCHEMA = "openworkflow";
+export type Postgres = ReturnType<typeof postgres>;
+export type PostgresOptions = Parameters<typeof postgres>[1];
+/**
+ * newPostgres creates a new Postgres client.
+ * @param url - Database connection URL
+ * @param options - Postgres client options
+ * @returns A Postgres client
+ */
+export declare function newPostgres(url: string, options?: PostgresOptions): postgres.Sql<{}>;
+/**
+ * newPostgresMaxOne creates a new Postgres client with a maximum pool size of
+ * one, which is useful for migrations.
+ * @param url - Database connection URL
+ * @param options - Postgres client options
+ * @returns A Postgres client
+ */
+export declare function newPostgresMaxOne(url: string, options?: PostgresOptions): postgres.Sql<{}>;
+/**
+ * migrations returns the list of migration SQL statements.
+ * @param schema - Schema name
+ * @returns Migration SQL statements
+ */
+export declare function migrations(schema: string): string[];
+/**
+ * migrate applies pending migrations to the database. Does nothing if the
+ * database is already up to date.
+ * @param pg - Postgres client
+ * @param schema - Schema name
+ * @returns Promise resolved when migrations complete
+ */
+export declare function migrate(pg: Postgres, schema: string): Promise<void>;
+/**
+ * dropSchema drops the specified schema from the database.
+ * @param pg - Postgres client
+ * @param schema - Schema name
+ * @returns Promise resolved when the schema is dropped
+ */
+export declare function dropSchema(pg: Postgres, schema: string): Promise<void>;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/postgres/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../postgres/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,eAAO,MAAM,oBAAoB,2DACyB,CAAC;AAO3D,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;AACnD,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAE7D;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,oBAEjE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,oBAEvE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CA+JnD;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,iBAQzD;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,iBAE5D"}

package/dist/postgres/postgres.js

@@ -0,0 +1,233 @@
+import postgres from "postgres";
+export const DEFAULT_POSTGRES_URL = "postgresql://postgres:postgres@localhost:5432/postgres";
+// The default schema to use for OpenWorkflow data. This type is more for
+// documentation than for practical use. The only time we allow schema
+// customization is during testing, specifically for testing migrations.
+// Everywhere else uses the "openworkflow" schema directly for prepared
+// statements.
+export const DEFAULT_SCHEMA = "openworkflow";
+/**
+ * newPostgres creates a new Postgres client.
+ * @param url - Database connection URL
+ * @param options - Postgres client options
+ * @returns A Postgres client
+ */
+export function newPostgres(url, options) {
+    return postgres(url, { ...options, transform: postgres.toCamel });
+}
+/**
+ * newPostgresMaxOne creates a new Postgres client with a maximum pool size of
+ * one, which is useful for migrations.
+ * @param url - Database connection URL
+ * @param options - Postgres client options
+ * @returns A Postgres client
+ */
+export function newPostgresMaxOne(url, options) {
+    return newPostgres(url, { ...options, max: 1 });
+}
+/**
+ * migrations returns the list of migration SQL statements.
+ * @param schema - Schema name
+ * @returns Migration SQL statements
+ */
+export function migrations(schema) {
+    return [
+        // 0 - init
+        `BEGIN;
+
+    CREATE SCHEMA IF NOT EXISTS ${schema};
+
+    CREATE TABLE IF NOT EXISTS "${schema}"."openworkflow_migrations" (
+      "version" BIGINT NOT NULL PRIMARY KEY
+    );
+
+    INSERT INTO "${schema}"."openworkflow_migrations" ("version")
+    VALUES (0)
+    ON CONFLICT DO NOTHING;
+
+    COMMIT;`,
+        // 1 - add workflow_runs and step_attempts tables
+        `BEGIN;
+
+    CREATE TABLE IF NOT EXISTS "${schema}"."workflow_runs" (
+      "namespace_id" TEXT NOT NULL,
+      "id" TEXT NOT NULL,
+      --
+      "workflow_name" TEXT NOT NULL,
+      "version" TEXT,
+      "status" TEXT NOT NULL,
+      "idempotency_key" TEXT,
+      "config" JSONB NOT NULL,
+      "context" JSONB,
+      "input" JSONB,
+      "output" JSONB,
+      "error" JSONB,
+      "attempts" INTEGER NOT NULL,
+      "parent_step_attempt_namespace_id" TEXT,
+      "parent_step_attempt_id" TEXT,
+      "worker_id" TEXT,
+      "available_at" TIMESTAMPTZ,
+      "deadline_at" TIMESTAMPTZ,
+      "started_at" TIMESTAMPTZ,
+      "finished_at" TIMESTAMPTZ,
+      "created_at" TIMESTAMPTZ NOT NULL,
+      "updated_at" TIMESTAMPTZ NOT NULL,
+      PRIMARY KEY ("namespace_id", "id")
+    );
+
+    CREATE TABLE IF NOT EXISTS "${schema}"."step_attempts" (
+      "namespace_id" TEXT NOT NULL,
+      "id" TEXT NOT NULL,
+      --
+      "workflow_run_id" TEXT NOT NULL,
+      "step_name" TEXT NOT NULL,
+      "kind" TEXT NOT NULL,
+      "status" TEXT NOT NULL,
+      "config" JSONB NOT NULL,
+      "context" JSONB,
+      "output" JSONB,
+      "error" JSONB,
+      "child_workflow_run_namespace_id" TEXT,
+      "child_workflow_run_id" TEXT,
+      "started_at" TIMESTAMPTZ,
+      "finished_at" TIMESTAMPTZ,
+      "created_at" TIMESTAMPTZ NOT NULL,
+      "updated_at" TIMESTAMPTZ NOT NULL,
+      PRIMARY KEY ("namespace_id", "id")
+    );
+
+    INSERT INTO "${schema}"."openworkflow_migrations" ("version")
+    VALUES (1)
+    ON CONFLICT DO NOTHING;
+    
+    COMMIT;`,
+        // 2 - foreign keys
+        `BEGIN;
+
+    ALTER TABLE "${schema}"."step_attempts"
+    ADD CONSTRAINT "step_attempts_workflow_run_fk"
+    FOREIGN KEY ("namespace_id", "workflow_run_id")
+    REFERENCES "${schema}"."workflow_runs" ("namespace_id", "id")
+    ON DELETE CASCADE
+    NOT VALID;
+
+    ALTER TABLE "${schema}"."workflow_runs"
+    ADD CONSTRAINT "workflow_runs_parent_step_attempt_fk"
+    FOREIGN KEY ("parent_step_attempt_namespace_id", "parent_step_attempt_id")
+    REFERENCES "${schema}"."step_attempts" ("namespace_id", "id")
+    ON DELETE SET NULL
+    NOT VALID;
+
+    ALTER TABLE "${schema}"."step_attempts"
+    ADD CONSTRAINT "step_attempts_child_workflow_run_fk"
+    FOREIGN KEY ("child_workflow_run_namespace_id", "child_workflow_run_id")
+    REFERENCES "${schema}"."workflow_runs" ("namespace_id", "id")
+    ON DELETE SET NULL
+    NOT VALID;
+
+    INSERT INTO "${schema}"."openworkflow_migrations" ("version")
+    VALUES (2)
+    ON CONFLICT DO NOTHING;
+
+    COMMIT;`,
+        // 3 - validate foreign keys
+        `BEGIN;
+
+    ALTER TABLE "${schema}"."step_attempts"
+    VALIDATE CONSTRAINT "step_attempts_workflow_run_fk";
+    
+    ALTER TABLE "${schema}"."workflow_runs" VALIDATE CONSTRAINT
+    "workflow_runs_parent_step_attempt_fk";
+
+    ALTER TABLE "${schema}"."step_attempts"
+    VALIDATE CONSTRAINT "step_attempts_child_workflow_run_fk";
+
+    INSERT INTO "${schema}"."openworkflow_migrations" ("version")
+    VALUES (3)
+    ON CONFLICT DO NOTHING;
+
+    COMMIT;`,
+        // 4 - indexes
+        `BEGIN;
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_status_available_at_created_at_idx"
+    ON "${schema}"."workflow_runs" ("namespace_id", "status", "available_at", "created_at");
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_workflow_name_idempotency_key_created_at_idx"
+    ON "${schema}"."workflow_runs" ("namespace_id", "workflow_name", "idempotency_key", "created_at");
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_parent_step_idx"
+    ON "${schema}"."workflow_runs" ("parent_step_attempt_namespace_id", "parent_step_attempt_id")
+    WHERE parent_step_attempt_namespace_id IS NOT NULL AND parent_step_attempt_id IS NOT NULL;
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_created_at_desc_idx"
+    ON "${schema}"."workflow_runs" ("namespace_id", "created_at" DESC);
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_status_created_at_desc_idx"
+    ON "${schema}"."workflow_runs" ("namespace_id", "status", "created_at" DESC);
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_workflow_name_status_created_at_desc_idx"
+    ON "${schema}"."workflow_runs" ("namespace_id", "workflow_name", "status", "created_at" DESC);
+
+    CREATE INDEX IF NOT EXISTS "step_attempts_workflow_run_created_at_idx"
+    ON "${schema}"."step_attempts" ("namespace_id", "workflow_run_id", "created_at");
+
+    CREATE INDEX IF NOT EXISTS "step_attempts_workflow_run_step_name_created_at_idx"
+    ON "${schema}"."step_attempts" ("namespace_id", "workflow_run_id", "step_name", "created_at");
+
+    CREATE INDEX IF NOT EXISTS "step_attempts_child_workflow_run_idx"
+    ON "${schema}"."step_attempts" ("child_workflow_run_namespace_id", "child_workflow_run_id")
+    WHERE child_workflow_run_namespace_id IS NOT NULL AND child_workflow_run_id IS NOT NULL;
+
+    INSERT INTO "${schema}"."openworkflow_migrations"("version")
+    VALUES (4)
+    ON CONFLICT DO NOTHING;
+
+    COMMIT;`,
+    ];
+}
+/**
+ * migrate applies pending migrations to the database. Does nothing if the
+ * database is already up to date.
+ * @param pg - Postgres client
+ * @param schema - Schema name
+ * @returns Promise resolved when migrations complete
+ */
+export async function migrate(pg, schema) {
+    const currentMigrationVersion = await getCurrentMigrationVersion(pg, schema);
+    for (const [i, migrationSql] of migrations(schema).entries()) {
+        if (i <= currentMigrationVersion)
+            continue; // already applied
+        await pg.unsafe(migrationSql);
+    }
+}
+/**
+ * dropSchema drops the specified schema from the database.
+ * @param pg - Postgres client
+ * @param schema - Schema name
+ * @returns Promise resolved when the schema is dropped
+ */
+export async function dropSchema(pg, schema) {
+    await pg.unsafe(`DROP SCHEMA IF EXISTS ${schema} CASCADE;`);
+}
+/**
+ * getCurrentVersion returns the current migration version of the database.
+ * @param pg - Postgres client
+ * @param schema - Schema name
+ * @returns Current migration version
+ */
+async function getCurrentMigrationVersion(pg, schema) {
+    // check if migrations table exists
+    const existsRes = await pg.unsafe(`
+    SELECT EXISTS (
+      SELECT 1
+      FROM information_schema.tables
+      WHERE table_schema = '${schema}'
+      AND table_name = 'openworkflow_migrations'
+    )`);
+    if (!existsRes[0]?.exists)
+        return -1;
+    // get current version
+    const currentVersionRes = await pg.unsafe(`SELECT MAX("version") AS "version" FROM "${schema}"."openworkflow_migrations";`);
+    return currentVersionRes[0]?.version ?? -1;
+}

package/dist/postgres/postgres.test.d.ts

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

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

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

package/dist/postgres/postgres.test.js

@@ -0,0 +1,45 @@
+import { DEFAULT_POSTGRES_URL, DEFAULT_SCHEMA, newPostgresMaxOne, migrations, migrate, dropSchema, } from "./postgres.js";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+describe("postgres", () => {
+    let pg;
+    beforeAll(() => {
+        // maxOne since we use SQL-based transactions instead of the postgres
+        // driver's built-in transactions
+        pg = newPostgresMaxOne(DEFAULT_POSTGRES_URL);
+    });
+    afterAll(async () => {
+        await pg.end();
+    });
+    describe("migrations()", () => {
+        test("returns migrations in 'openworkflow' schema when no schema is specified", () => {
+            const migs = migrations(DEFAULT_SCHEMA);
+            for (const mig of migs) {
+                expect(mig).toContain(`"openworkflow"`);
+            }
+        });
+        test("returns migration in the specified schema when one is specified", () => {
+            const schema = "test_custom_schema";
+            const migs = migrations(schema);
+            for (const mig of migs) {
+                expect(mig).toContain(`"${schema}"`);
+                expect(mig).not.toContain(`"openworkflow"`);
+            }
+        });
+    });
+    describe("migrate()", () => {
+        test("runs database migrations idempotently", async () => {
+            const schema = "test_migrate_idempotent";
+            await dropSchema(pg, schema);
+            await migrate(pg, schema);
+            await migrate(pg, schema);
+        });
+    });
+    describe("dropSchema()", () => {
+        test("drops the schema idempotently", async () => {
+            const testSchema = "test_drop_schema_idempotent";
+            await migrate(pg, testSchema);
+            await dropSchema(pg, testSchema);
+            await dropSchema(pg, testSchema);
+        });
+    });
+});

package/dist/postgres/scripts/db-migrate.d.ts

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

package/dist/postgres/scripts/db-migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-migrate.d.ts","sourceRoot":"","sources":["../../../postgres/scripts/db-migrate.ts"],"names":[],"mappings":""}

package/dist/postgres/scripts/db-migrate.js

@@ -0,0 +1,4 @@
+import { DEFAULT_POSTGRES_URL, DEFAULT_SCHEMA, newPostgresMaxOne, migrate, } from "../postgres.js";
+const pg = newPostgresMaxOne(DEFAULT_POSTGRES_URL);
+await migrate(pg, DEFAULT_SCHEMA);
+await pg.end();

package/dist/postgres/scripts/db-reset.d.ts

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

package/dist/postgres/scripts/db-reset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-reset.d.ts","sourceRoot":"","sources":["../../../postgres/scripts/db-reset.ts"],"names":[],"mappings":""}

package/dist/postgres/scripts/db-reset.js

@@ -0,0 +1,5 @@
+import { DEFAULT_POSTGRES_URL, DEFAULT_SCHEMA, newPostgresMaxOne, dropSchema, migrate, } from "../postgres.js";
+const pg = newPostgresMaxOne(DEFAULT_POSTGRES_URL);
+await dropSchema(pg, DEFAULT_SCHEMA);
+await migrate(pg, DEFAULT_SCHEMA);
+await pg.end();

package/dist/postgres/scripts/squawk.d.ts

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

package/dist/postgres/scripts/squawk.d.ts.map

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

package/dist/postgres/scripts/squawk.js

@@ -0,0 +1,16 @@
+import { DEFAULT_SCHEMA, migrations } from "../postgres.js";
+import { execSync } from "node:child_process";
+import { unlinkSync, writeFileSync } from "node:fs";
+const sql = migrations(DEFAULT_SCHEMA).join("\n\n");
+writeFileSync("squawk.sql", sql);
+try {
+    // eslint-disable-next-line sonarjs/no-os-command-from-path
+    execSync("npx squawk squawk.sql", { stdio: "inherit" });
+}
+catch {
+    // ignore - squawk will produce its own error output
+}
+finally {
+    unlinkSync("squawk.sql");
+    console.log("");
+}

package/dist/postgres/vitest.global-setup.d.ts

@@ -0,0 +1,3 @@
+/** Run database migrations once before Postgres backend tests. */
+export declare function setup(): Promise<void>;
+//# sourceMappingURL=vitest.global-setup.d.ts.map

package/dist/postgres/vitest.global-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.global-setup.d.ts","sourceRoot":"","sources":["../../postgres/vitest.global-setup.ts"],"names":[],"mappings":"AAOA,kEAAkE;AAClE,wBAAsB,KAAK,kBAI1B"}

package/dist/postgres/vitest.global-setup.js

@@ -0,0 +1,7 @@
+import { migrate, newPostgresMaxOne, DEFAULT_SCHEMA, DEFAULT_POSTGRES_URL, } from "./postgres.js";
+/** Run database migrations once before Postgres backend tests. */
+export async function setup() {
+    const pg = newPostgresMaxOne(DEFAULT_POSTGRES_URL);
+    await migrate(pg, DEFAULT_SCHEMA);
+    await pg.end();
+}

package/dist/postgres.d.ts

@@ -0,0 +1,2 @@
+export { BackendPostgres } from "./postgres/backend.js";
+//# sourceMappingURL=postgres.d.ts.map

package/dist/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../postgres.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/postgres.js

@@ -0,0 +1 @@
+export { BackendPostgres } from "./postgres/backend.js";

package/dist/registry.d.ts

@@ -0,0 +1,27 @@
+import type { Workflow } from "./workflow.js";
+/**
+ * A registry for storing and retrieving workflows by name and version.
+ * Provides a centralized way to manage workflow registrations.
+ */
+export declare class WorkflowRegistry {
+    private readonly workflows;
+    /**
+     * Register a workflow in the registry.
+     * @param workflow - The workflow to register
+     * @throws {Error} If a workflow with the same name and version is already registered
+     */
+    register(workflow: Workflow<unknown, unknown, unknown>): void;
+    /**
+     * Get a workflow from the registry by name and version.
+     * @param name - The workflow name
+     * @param version - The workflow version (null for unversioned)
+     * @returns The workflow if found, undefined otherwise
+     */
+    get(name: string, version: string | null): Workflow<unknown, unknown, unknown> | undefined;
+    /**
+     * Get all registered workflows.
+     * @returns Array of all registered workflows
+     */
+    getAll(): Workflow<unknown, unknown, unknown>[];
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAGtB;IAEJ;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI;IAW7D;;;;;OAKG;IACH,GAAG,CACD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GAAG,IAAI,GACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS;IAKlD;;;OAGG;IACH,MAAM,IAAI,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;CAGhD"}

package/dist/registry.js

@@ -0,0 +1,48 @@
+/**
+ * A registry for storing and retrieving workflows by name and version.
+ * Provides a centralized way to manage workflow registrations.
+ */
+export class WorkflowRegistry {
+    workflows = new Map();
+    /**
+     * Register a workflow in the registry.
+     * @param workflow - The workflow to register
+     * @throws {Error} If a workflow with the same name and version is already registered
+     */
+    register(workflow) {
+        const name = workflow.spec.name;
+        const version = workflow.spec.version ?? null;
+        const key = registryKey(name, version);
+        if (this.workflows.has(key)) {
+            const versionStr = version ? ` (version: ${version})` : "";
+            throw new Error(`Workflow "${name}"${versionStr} is already registered`);
+        }
+        this.workflows.set(key, workflow);
+    }
+    /**
+     * Get a workflow from the registry by name and version.
+     * @param name - The workflow name
+     * @param version - The workflow version (null for unversioned)
+     * @returns The workflow if found, undefined otherwise
+     */
+    get(name, version) {
+        const key = registryKey(name, version);
+        return this.workflows.get(key);
+    }
+    /**
+     * Get all registered workflows.
+     * @returns Array of all registered workflows
+     */
+    getAll() {
+        return [...this.workflows.values()];
+    }
+}
+/**
+ * Build a registry key from name and version.
+ * @param name - Workflow name
+ * @param version - Workflow version (or null)
+ * @returns Registry key
+ */
+function registryKey(name, version) {
+    return version ? `${name}@${version}` : name;
+}

package/dist/registry.test.d.ts

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

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

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