openworkflow 0.4.1 → 0.6.0

package/dist/sqlite/sqlite.js

@@ -0,0 +1,246 @@
+import { randomUUID } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+/**
+ * newDatabase creates a new SQLite database connection.
+ * @param path - Database file path (or ":memory:") for testing
+ * @returns SQLite database connection
+ */
+export function newDatabase(path) {
+    const db = new DatabaseSync(path);
+    // Only enable WAL mode for file-based databases
+    if (path !== ":memory:") {
+        db.exec("PRAGMA journal_mode = WAL;");
+    }
+    db.exec("PRAGMA foreign_keys = ON;");
+    return db;
+}
+/**
+ * migrations returns the list of migration SQL statements.
+ * @returns Migration SQL statements
+ */
+export function migrations() {
+    return [
+        // 0 - init
+        `BEGIN;
+
+    CREATE TABLE IF NOT EXISTS "openworkflow_migrations" (
+      "version" INTEGER NOT NULL PRIMARY KEY
+    );
+
+    INSERT OR IGNORE INTO "openworkflow_migrations" ("version")
+    VALUES (0);
+
+    COMMIT;`,
+        // 1 - add workflow_runs and step_attempts tables
+        `BEGIN;
+
+    PRAGMA defer_foreign_keys = ON;
+
+    CREATE TABLE IF NOT EXISTS "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" TEXT NOT NULL,
+      "context" TEXT,
+      "input" TEXT,
+      "output" TEXT,
+      "error" TEXT,
+      "attempts" INTEGER NOT NULL,
+      "parent_step_attempt_namespace_id" TEXT,
+      "parent_step_attempt_id" TEXT,
+      "worker_id" TEXT,
+      "available_at" TEXT,
+      "deadline_at" TEXT,
+      "started_at" TEXT,
+      "finished_at" TEXT,
+      "created_at" TEXT NOT NULL,
+      "updated_at" TEXT NOT NULL,
+      PRIMARY KEY ("namespace_id", "id"),
+      FOREIGN KEY ("parent_step_attempt_namespace_id", "parent_step_attempt_id")
+        REFERENCES "step_attempts" ("namespace_id", "id")
+        ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS "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" TEXT NOT NULL,
+      "context" TEXT,
+      "output" TEXT,
+      "error" TEXT,
+      "child_workflow_run_namespace_id" TEXT,
+      "child_workflow_run_id" TEXT,
+      "started_at" TEXT,
+      "finished_at" TEXT,
+      "created_at" TEXT NOT NULL,
+      "updated_at" TEXT NOT NULL,
+      PRIMARY KEY ("namespace_id", "id"),
+      FOREIGN KEY ("namespace_id", "workflow_run_id")
+        REFERENCES "workflow_runs" ("namespace_id", "id")
+        ON DELETE CASCADE,
+      FOREIGN KEY ("child_workflow_run_namespace_id", "child_workflow_run_id")
+        REFERENCES "workflow_runs" ("namespace_id", "id")
+        ON DELETE SET NULL
+    );
+
+    INSERT OR IGNORE INTO "openworkflow_migrations" ("version")
+    VALUES (1);
+
+    COMMIT;`,
+        // 2 - foreign keys
+        `BEGIN;
+
+    -- Foreign keys are defined in migration 1 since SQLite requires them during table creation
+    -- This migration exists for version parity with PostgreSQL backend
+
+    INSERT OR IGNORE INTO "openworkflow_migrations" ("version")
+    VALUES (2);
+
+    COMMIT;`,
+        // 3 - validate foreign keys
+        `BEGIN;
+
+    -- Foreign key validation happens automatically in SQLite when PRAGMA foreign_keys = ON
+    -- This migration exists for version parity with PostgreSQL backend
+
+    INSERT OR IGNORE INTO "openworkflow_migrations" ("version")
+    VALUES (3);
+
+    COMMIT;`,
+        // 4 - indexes
+        `BEGIN;
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_status_available_at_created_at_idx"
+    ON "workflow_runs" ("namespace_id", "status", "available_at", "created_at");
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_workflow_name_idempotency_key_created_at_idx"
+    ON "workflow_runs" ("namespace_id", "workflow_name", "idempotency_key", "created_at");
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_parent_step_idx"
+    ON "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 "workflow_runs" ("namespace_id", "created_at" DESC);
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_status_created_at_desc_idx"
+    ON "workflow_runs" ("namespace_id", "status", "created_at" DESC);
+
+    CREATE INDEX IF NOT EXISTS "workflow_runs_workflow_name_status_created_at_desc_idx"
+    ON "workflow_runs" ("namespace_id", "workflow_name", "status", "created_at" DESC);
+
+    CREATE INDEX IF NOT EXISTS "step_attempts_workflow_run_created_at_idx"
+    ON "step_attempts" ("namespace_id", "workflow_run_id", "created_at");
+
+    CREATE INDEX IF NOT EXISTS "step_attempts_workflow_run_step_name_created_at_idx"
+    ON "step_attempts" ("namespace_id", "workflow_run_id", "step_name", "created_at");
+
+    CREATE INDEX IF NOT EXISTS "step_attempts_child_workflow_run_idx"
+    ON "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 OR IGNORE INTO "openworkflow_migrations" ("version")
+    VALUES (4);
+
+    COMMIT;`,
+    ];
+}
+/**
+ * migrate applies pending migrations to the database. Does nothing if the
+ * database is already up to date.
+ * @param db - SQLite database
+ */
+export function migrate(db) {
+    const currentMigrationVersion = getCurrentMigrationVersion(db);
+    for (const [i, migrationSql] of migrations().entries()) {
+        if (i <= currentMigrationVersion)
+            continue; // already applied
+        db.exec(migrationSql);
+    }
+}
+/**
+ * getCurrentMigrationVersion returns the current migration version of the database.
+ * @param db - SQLite database
+ * @returns Current migration version
+ */
+function getCurrentMigrationVersion(db) {
+    // check if migrations table exists
+    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;
+    // get current version
+    const versionStmt = db.prepare(`SELECT MAX("version") AS "version" FROM "openworkflow_migrations";`);
+    const versionResult = versionStmt.get();
+    return versionResult?.version ?? -1;
+}
+/**
+ * Helper to generate UUIDs (SQLite doesn't have built-in UUID generation)
+ * @returns A UUID string
+ */
+export function generateUUID() {
+    return randomUUID();
+}
+/**
+ * Helper to get current timestamp in ISO8601 format
+ * @returns ISO8601 timestamp string
+ */
+export function now() {
+    return new Date().toISOString();
+}
+/**
+ * Helper to add milliseconds to a date and return ISO8601 string
+ * @param date - ISO8601 date string
+ * @param ms - Milliseconds to add
+ * @returns Updated ISO8601 date string
+ */
+export function addMilliseconds(date, ms) {
+    const d = new Date(date);
+    d.setMilliseconds(d.getMilliseconds() + ms);
+    return d.toISOString();
+}
+/**
+ * Helper to serialize JSON for SQLite storage
+ * @param value - Value to serialize
+ * @returns JSON string or null
+ */
+export function toJSON(value) {
+    return value === null || value === undefined ? null : JSON.stringify(value);
+}
+/**
+ * Helper to deserialize JSON from SQLite storage
+ * @param value - JSON string or null
+ * @returns Parsed value
+ */
+export function fromJSON(value) {
+    return value === null ? null : JSON.parse(value);
+}
+/**
+ * Helper to convert Date to ISO8601 string for SQLite
+ * @param date - Date or null
+ * @returns ISO8601 date string or null
+ */
+export function toISO(date) {
+    return date ? date.toISOString() : null;
+}
+/**
+ * Helper to convert ISO8601 string from SQLite to Date
+ * @param dateStr - ISO8601 date string or null
+ * @returns Date or null
+ */
+export function fromISO(dateStr) {
+    return dateStr ? new Date(dateStr) : null;
+}

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

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

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

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

package/dist/sqlite/sqlite.test.js

@@ -0,0 +1,171 @@
+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);
+        });
+    });
+});

package/dist/sqlite.d.ts

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

package/dist/sqlite.d.ts.map

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

package/dist/sqlite.js

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