openworkflow 0.6.0 → 0.6.2

package/dist/registry.test.js

@@ -1,109 +0,0 @@
-import { WorkflowRegistry } from "./registry.js";
-import { defineWorkflow } from "./workflow.js";
-import { describe, expect, test } from "vitest";
-describe("WorkflowRegistry", () => {
-    describe("register", () => {
-        test("registers a workflow without version", () => {
-            const registry = new WorkflowRegistry();
-            const workflow = createMockWorkflow("my-workflow");
-            registry.register(workflow);
-            expect(registry.get("my-workflow", null)).toBe(workflow);
-        });
-        test("registers a workflow with version", () => {
-            const registry = new WorkflowRegistry();
-            const workflow = createMockWorkflow("my-workflow", "v1");
-            registry.register(workflow);
-            expect(registry.get("my-workflow", "v1")).toBe(workflow);
-        });
-        test("registers multiple versions of the same workflow", () => {
-            const registry = new WorkflowRegistry();
-            const v1 = createMockWorkflow("my-workflow", "v1");
-            const v2 = createMockWorkflow("my-workflow", "v2");
-            registry.register(v1);
-            registry.register(v2);
-            expect(registry.get("my-workflow", "v1")).toBe(v1);
-            expect(registry.get("my-workflow", "v2")).toBe(v2);
-        });
-        test("registers different workflows with same version", () => {
-            const registry = new WorkflowRegistry();
-            const workflow1 = createMockWorkflow("workflow-a", "v1");
-            const workflow2 = createMockWorkflow("workflow-b", "v1");
-            registry.register(workflow1);
-            registry.register(workflow2);
-            expect(registry.get("workflow-a", "v1")).toBe(workflow1);
-            expect(registry.get("workflow-b", "v1")).toBe(workflow2);
-        });
-        test("throws when registering duplicate unversioned workflow", () => {
-            const registry = new WorkflowRegistry();
-            registry.register(createMockWorkflow("my-workflow"));
-            expect(() => {
-                registry.register(createMockWorkflow("my-workflow"));
-            }).toThrow('Workflow "my-workflow" is already registered');
-        });
-        test("throws when registering duplicate versioned workflow", () => {
-            const registry = new WorkflowRegistry();
-            registry.register(createMockWorkflow("my-workflow", "v1"));
-            expect(() => {
-                registry.register(createMockWorkflow("my-workflow", "v1"));
-            }).toThrow('Workflow "my-workflow" (version: v1) is already registered');
-        });
-        test("allows same name with different versions", () => {
-            const registry = new WorkflowRegistry();
-            const versioned = createMockWorkflow("my-workflow", "v1");
-            const unversioned = createMockWorkflow("my-workflow");
-            registry.register(versioned);
-            registry.register(unversioned);
-            expect(registry.get("my-workflow", "v1")).toBe(versioned);
-            expect(registry.get("my-workflow", null)).toBe(unversioned);
-        });
-    });
-    describe("get", () => {
-        test("returns undefined for non-existent workflow", () => {
-            const registry = new WorkflowRegistry();
-            expect(registry.get("non-existent", null)).toBeUndefined();
-        });
-        test("returns undefined for wrong version", () => {
-            const registry = new WorkflowRegistry();
-            registry.register(createMockWorkflow("my-workflow", "v1"));
-            expect(registry.get("my-workflow", "v2")).toBeUndefined();
-            expect(registry.get("my-workflow", null)).toBeUndefined();
-        });
-        test("returns undefined for versioned lookup on unversioned workflow", () => {
-            const registry = new WorkflowRegistry();
-            registry.register(createMockWorkflow("my-workflow"));
-            expect(registry.get("my-workflow", "v1")).toBeUndefined();
-        });
-        test("returns the registered workflow", () => {
-            const registry = new WorkflowRegistry();
-            const workflow = createMockWorkflow("my-workflow");
-            registry.register(workflow);
-            expect(registry.get("my-workflow", null)).toBe(workflow);
-        });
-    });
-    describe("getAll", () => {
-        test("returns all registered workflows", () => {
-            const registry = new WorkflowRegistry();
-            const a = createMockWorkflow("workflow-a");
-            const b = createMockWorkflow("workflow-b", "v1");
-            const c = createMockWorkflow("workflow-a", "v2");
-            registry.register(a);
-            registry.register(b);
-            registry.register(c);
-            const all = registry.getAll();
-            expect(all).toHaveLength(3);
-            expect(all).toEqual(expect.arrayContaining([a, b, c]));
-        });
-        test("returns empty array when none registered", () => {
-            const registry = new WorkflowRegistry();
-            expect(registry.getAll()).toEqual([]);
-        });
-    });
-});
-function createMockWorkflow(name, version) {
-    return defineWorkflow({
-        name,
-        ...(version && { version }),
-    }, async () => {
-        // no-op
-    });
-}

package/dist/sqlite/backend.test.d.ts

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

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

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

package/dist/sqlite/backend.test.js

@@ -1,50 +0,0 @@
-import { testBackend } from "../internal.js";
-import { BackendSqlite } from "./backend.js";
-import assert from "node:assert";
-import { randomUUID } from "node:crypto";
-import { unlinkSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { test, describe, afterAll } from "vitest";
-test("it is a test file (workaround for sonarjs/no-empty-test-file linter)", () => {
-    assert.ok(true);
-});
-describe("BackendSqlite (in-memory)", () => {
-    testBackend({
-        setup: () => {
-            return Promise.resolve(BackendSqlite.connect(":memory:", {
-                namespaceId: randomUUID(),
-            }));
-        },
-        teardown: async (backend) => {
-            await backend.stop();
-        },
-    });
-});
-describe("BackendSqlite (file-based)", () => {
-    const testDbPath = path.join(tmpdir(), `openworkflow-test-${randomUUID()}.db`);
-    afterAll(() => {
-        const walPath = `${testDbPath}-wal`;
-        const shmPath = `${testDbPath}-shm`;
-        // clean up the test database, WAL, and SHM files if they exist
-        if (existsSync(testDbPath)) {
-            unlinkSync(testDbPath);
-        }
-        if (existsSync(walPath)) {
-            unlinkSync(walPath);
-        }
-        if (existsSync(shmPath)) {
-            unlinkSync(shmPath);
-        }
-    });
-    testBackend({
-        setup: () => {
-            return Promise.resolve(BackendSqlite.connect(testDbPath, {
-                namespaceId: randomUUID(),
-            }));
-        },
-        teardown: async (backend) => {
-            await backend.stop();
-        },
-    });
-});

package/dist/sqlite/driver.d.ts

@@ -1,79 +0,0 @@
-/**
- * SQLite driver for OpenWorkflow using the Drizzle-style API.
- *
- * This module provides a `sqlite()` function that creates a driver
- * for connecting to SQLite databases.
- * @example
- * ```ts
- * import { openworkflow } from 'openworkflow';
- * import { sqlite } from 'openworkflow/sqlite';
- *
- * // In-memory database (great for testing)
- * const ow = await openworkflow(sqlite(':memory:'));
- *
- * // File-based database
- * const ow = await openworkflow(sqlite('./data/workflow.db'));
- *
- * // With configuration options
- * const ow = await openworkflow(sqlite({
- *   path: './data/workflow.db',
- *   namespace: 'my-app',
- *   runMigrations: true,
- * }));
- * ```
- */
-import type { Backend, Driver, DriverConfig } from "openworkflow/internal";
-/**
- * SQLite-specific driver configuration.
- */
-export interface SqliteDriverConfig extends DriverConfig {
-    /**
-     * Path to the SQLite database file.
-     * Use ':memory:' for an in-memory database.
-     */
-    path?: string;
-    /**
-     * Existing SQLite database instance.
-     * If provided, the driver will use this database instead of creating a new one.
-     */
-    database?: SqliteDatabase;
-}
-/**
- * Interface for SQLite database instance.
- * This matches the node:sqlite DatabaseSync interface.
- */
-export interface SqliteDatabase {
-    close(): void;
-    exec(sql: string): void;
-    prepare(sql: string): any;
-}
-/**
- * SQLite driver instance.
- */
-export interface SqliteDriver extends Driver {
-    readonly dialect: "sqlite";
-    readonly $client: SqliteDatabase | undefined;
-    createBackend(): Backend;
-}
-/**
- * Creates a SQLite driver for OpenWorkflow.
- *
- * This function follows the Drizzle ORM pattern and supports multiple
- * calling conventions:
- * @param config - Database path or configuration object
- * @returns A SqliteDriver instance
- * @example
- * ```ts
- * // With database path
- * sqlite('./data/workflow.db')
- * sqlite(':memory:')
- *
- * // With config object
- * sqlite({
- *   path: './data/workflow.db',
- *   namespace: 'my-app',
- * })
- * ```
- */
-export declare function sqlite(config: string | SqliteDriverConfig): SqliteDriver;
-//# sourceMappingURL=driver.d.ts.map

package/dist/sqlite/driver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../sqlite/driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE3E;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACtD;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,YAAa,SAAQ,MAAM;IAC1C,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,SAAS,CAAC;IAC7C,aAAa,IAAI,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,GAAG,YAAY,CAqExE"}

package/dist/sqlite/driver.js

@@ -1,62 +0,0 @@
-/**
- * Creates a SQLite driver for OpenWorkflow.
- *
- * This function follows the Drizzle ORM pattern and supports multiple
- * calling conventions:
- * @param config - Database path or configuration object
- * @returns A SqliteDriver instance
- * @example
- * ```ts
- * // With database path
- * sqlite('./data/workflow.db')
- * sqlite(':memory:')
- *
- * // With config object
- * sqlite({
- *   path: './data/workflow.db',
- *   namespace: 'my-app',
- * })
- * ```
- */
-export function sqlite(config) {
-    // Normalize config
-    const normalizedConfig = typeof config === "string" ? { path: config } : config;
-    // Store the database reference (will be set on createBackend)
-    let databaseRef = normalizedConfig.database;
-    return {
-        dialect: "sqlite",
-        get $client() {
-            return databaseRef;
-        },
-        createBackend() {
-            // Dynamically import BackendSqlite to avoid requiring the sqlite
-            // package as a direct dependency of the openworkflow package
-            // Note: We use require here because sqlite is synchronous
-            // Determine the database path
-            const databasePath = normalizedConfig.path;
-            if (!databasePath && !normalizedConfig.database) {
-                throw new Error("SQLite driver requires either a database path or an existing database. " +
-                    "Provide `path` or `database` in the config.");
-            }
-            // If we have an existing database, we need to handle it differently
-            if (!databasePath) {
-                throw new Error("Using an existing SQLite database is not yet supported. " +
-                    "Please provide a database path via the `path` option.");
-            }
-            // Import and create the backend synchronously
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const { BackendSqlite } = require("@openworkflow/backend-sqlite");
-            const options = {
-                runMigrations: normalizedConfig.runMigrations ?? true,
-            };
-            if (normalizedConfig.namespace) {
-                options.namespaceId = normalizedConfig.namespace;
-            }
-            const backend = BackendSqlite.connect(databasePath, options);
-            // Store database reference for $client getter
-            // Note: BackendSqlite doesn't expose the database, so this remains undefined
-            databaseRef = undefined;
-            return backend;
-        },
-    };
-}

package/dist/sqlite/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * SQLite driver for OpenWorkflow.
- * @example
- * ```ts
- * import { openworkflow } from 'openworkflow';
- * import { sqlite } from 'openworkflow/sqlite';
- *
- * const ow = await openworkflow(sqlite(':memory:'));
- * ```
- */
-export { sqlite } from "./driver.js";
-export type { SqliteDriver, SqliteDriverConfig, SqliteDatabase, } from "./driver.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../sqlite/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,cAAc,GACf,MAAM,aAAa,CAAC"}

package/dist/sqlite/index.js

@@ -1,11 +0,0 @@
-/**
- * SQLite driver for OpenWorkflow.
- * @example
- * ```ts
- * import { openworkflow } from 'openworkflow';
- * import { sqlite } from 'openworkflow/sqlite';
- *
- * const ow = await openworkflow(sqlite(':memory:'));
- * ```
- */
-export { sqlite } from "./driver.js";

package/dist/sqlite/internal.d.ts

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

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

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

package/dist/sqlite/internal.js

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

package/dist/sqlite/sqlite.test.d.ts

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

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

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

package/dist/sqlite/sqlite.test.js

@@ -1,171 +0,0 @@
-import { migrate, migrations, newDatabase } from "./sqlite.js";
-import { randomUUID } from "node:crypto";
-import { existsSync, unlinkSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-// Helper to get the current migration version (exported for testing)
-// Note: This function exists in sqlite.ts but isn't exported, so we'll
-// test it indirectly through migrate() and by checking the migrations table
-function getMigrationVersion(db) {
-    const existsStmt = db.prepare(`
-    SELECT COUNT(*) as count
-    FROM sqlite_master
-    WHERE type = 'table' AND name = 'openworkflow_migrations'
-  `);
-    const existsResult = existsStmt.get();
-    if (!existsResult || existsResult.count === 0)
-        return -1;
-    const versionStmt = db.prepare(`SELECT MAX("version") AS "version" FROM "openworkflow_migrations";`);
-    const versionResult = versionStmt.get();
-    return versionResult?.version ?? -1;
-}
-describe("sqlite", () => {
-    let db;
-    let dbPath;
-    beforeEach(() => {
-        // Use a unique file path for each test to ensure isolation
-        dbPath = path.join(tmpdir(), `test_${randomUUID()}.db`);
-        db = newDatabase(dbPath);
-    });
-    afterEach(() => {
-        db.close();
-        const walPath = `${dbPath}-wal`;
-        const shmPath = `${dbPath}-shm`;
-        // clean up the test database, WAL, and SHM files if they exist
-        if (existsSync(dbPath)) {
-            unlinkSync(dbPath);
-        }
-        if (existsSync(walPath)) {
-            unlinkSync(walPath);
-        }
-        if (existsSync(shmPath)) {
-            unlinkSync(shmPath);
-        }
-    });
-    describe("migrations()", () => {
-        test("returns migration SQL statements with correct table names", () => {
-            const migs = migrations();
-            expect(migs.length).toBeGreaterThan(0);
-            // Check that migrations reference the openworkflow_migrations table
-            for (const mig of migs) {
-                expect(mig).toContain("openworkflow_migrations");
-            }
-            // Verify first migration creates the migrations table
-            expect(migs[0]).toContain('CREATE TABLE IF NOT EXISTS "openworkflow_migrations"');
-            expect(migs[0]).toContain('"version"');
-        });
-        test("migrations create workflow_runs and step_attempts tables", () => {
-            const migs = migrations();
-            // Migration 1 should create workflow_runs and step_attempts
-            const migration1 = migs[1];
-            expect(migration1).toContain('CREATE TABLE IF NOT EXISTS "workflow_runs"');
-            expect(migration1).toContain('CREATE TABLE IF NOT EXISTS "step_attempts"');
-        });
-    });
-    describe("migrate()", () => {
-        test("runs database migrations idempotently", () => {
-            // First migration
-            migrate(db);
-            const version1 = getMigrationVersion(db);
-            expect(version1).toBeGreaterThanOrEqual(0);
-            // Second migration - should not cause errors
-            migrate(db);
-            const version2 = getMigrationVersion(db);
-            expect(version2).toBe(version1); // Version should not change
-            // Third migration - should still work
-            migrate(db);
-            const version3 = getMigrationVersion(db);
-            expect(version3).toBe(version1);
-        });
-        test("tracks migration versions correctly", () => {
-            // Before migration, version should be -1 (table doesn't exist)
-            let version = getMigrationVersion(db);
-            expect(version).toBe(-1);
-            // After migration, version should be the latest migration version
-            migrate(db);
-            version = getMigrationVersion(db);
-            const allMigrations = migrations();
-            const expectedLatestVersion = allMigrations.length - 1;
-            expect(version).toBe(expectedLatestVersion);
-        });
-        test("applies migrations incrementally", () => {
-            // Create the migrations table manually with version 0
-            db.exec(`
-        CREATE TABLE IF NOT EXISTS "openworkflow_migrations" (
-          "version" INTEGER NOT NULL PRIMARY KEY
-        );
-        INSERT OR IGNORE INTO "openworkflow_migrations" ("version")
-        VALUES (0);
-      `);
-            let version = getMigrationVersion(db);
-            expect(version).toBe(0);
-            // Run migrate - should apply remaining migrations
-            migrate(db);
-            version = getMigrationVersion(db);
-            const allMigrations = migrations();
-            const expectedLatestVersion = allMigrations.length - 1;
-            expect(version).toBe(expectedLatestVersion);
-        });
-        test("creates all required tables after migration", () => {
-            migrate(db);
-            // Check that migrations table exists
-            const migrationsCheck = db
-                .prepare(`
-        SELECT COUNT(*) as count
-        FROM sqlite_master
-        WHERE type = 'table' AND name = 'openworkflow_migrations'
-      `)
-                .get();
-            expect(migrationsCheck.count).toBe(1);
-            // Check that workflow_runs table exists
-            const workflowRunsCheck = db
-                .prepare(`
-        SELECT COUNT(*) as count
-        FROM sqlite_master
-        WHERE type = 'table' AND name = 'workflow_runs'
-      `)
-                .get();
-            expect(workflowRunsCheck.count).toBe(1);
-            // Check that step_attempts table exists
-            const stepAttemptsCheck = db
-                .prepare(`
-        SELECT COUNT(*) as count
-        FROM sqlite_master
-        WHERE type = 'table' AND name = 'step_attempts'
-      `)
-                .get();
-            expect(stepAttemptsCheck.count).toBe(1);
-        });
-    });
-    describe("migration version tracking", () => {
-        test("migrations table stores version numbers correctly", () => {
-            migrate(db);
-            const versionStmt = db.prepare(`SELECT "version" FROM "openworkflow_migrations" ORDER BY "version";`);
-            const versions = versionStmt.all();
-            // Should have all migration versions from 0 to latest
-            const allMigrations = migrations();
-            const expectedLatestVersion = allMigrations.length - 1;
-            expect(versions.length).toBe(expectedLatestVersion + 1);
-            for (let i = 0; i <= expectedLatestVersion; i++) {
-                const version = versions[i];
-                expect(version).toBeDefined();
-                expect(version?.version).toBe(i);
-            }
-        });
-        test("migrations can be run multiple times safely with INSERT OR IGNORE", () => {
-            migrate(db);
-            const versionAfterFirst = getMigrationVersion(db);
-            // Run migrations again
-            migrate(db);
-            const versionAfterSecond = getMigrationVersion(db);
-            expect(versionAfterSecond).toBe(versionAfterFirst);
-            // Check that version entries aren't duplicated
-            const versionStmt = db.prepare(`SELECT COUNT(*) as count FROM "openworkflow_migrations";`);
-            const countResult = versionStmt.get();
-            const allMigrations = migrations();
-            const expectedCount = allMigrations.length;
-            expect(countResult.count).toBe(expectedCount);
-        });
-    });
-});