openworkflow 0.4.1 → 0.6.0

package/dist/node-sqlite/backend.js

@@ -0,0 +1,673 @@
+import { DEFAULT_NAMESPACE_ID, } from "../backend.js";
+import { DEFAULT_RETRY_POLICY } from "../core/retry.js";
+import { newDatabase, migrate, generateUUID, now, addMilliseconds, toJSON, fromJSON, toISO, fromISO, } from "./sqlite.js";
+const DEFAULT_PAGINATION_PAGE_SIZE = 100;
+/**
+ * Manages a connection to a SQLite database for workflow operations.
+ */
+export class BackendSqlite {
+    db;
+    namespaceId;
+    constructor(db, namespaceId) {
+        this.db = db;
+        this.namespaceId = namespaceId;
+    }
+    /**
+     * Create and initialize a new BackendSqlite instance. This will
+     * automatically run migrations on startup unless `runMigrations` is set to
+     * false.
+     * @param path - Database path
+     * @param options - Backend options
+     * @returns A connected backend instance
+     */
+    static connect(path, options) {
+        const { namespaceId, runMigrations } = {
+            namespaceId: DEFAULT_NAMESPACE_ID,
+            runMigrations: true,
+            ...options,
+        };
+        const db = newDatabase(path);
+        if (runMigrations) {
+            migrate(db);
+        }
+        return new BackendSqlite(db, namespaceId);
+    }
+    /**
+     * Create and initialize a new BackendSqlite instance from an existing
+     * SQLite database connection. This will automatically run migrations on
+     * startup unless `runMigrations` is set to false.
+     * @param db - SQLite database connection
+     * @param options - Backend options
+     * @returns A connected backend instance
+     */
+    static fromClient(db, options) {
+        const { namespaceId, runMigrations } = {
+            namespaceId: DEFAULT_NAMESPACE_ID,
+            runMigrations: true,
+            ...options,
+        };
+        if (runMigrations) {
+            migrate(db);
+        }
+        return new BackendSqlite(db, namespaceId);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async stop() {
+        this.db.close();
+    }
+    async createWorkflowRun(params) {
+        const id = generateUUID();
+        const currentTime = now();
+        const availableAt = params.availableAt
+            ? toISO(params.availableAt)
+            : currentTime;
+        const stmt = this.db.prepare(`
+      INSERT INTO "workflow_runs" (
+        "namespace_id",
+        "id",
+        "workflow_name",
+        "version",
+        "status",
+        "idempotency_key",
+        "config",
+        "context",
+        "input",
+        "attempts",
+        "available_at",
+        "deadline_at",
+        "created_at",
+        "updated_at"
+      )
+      VALUES (?, ?, ?, ?, 'pending', ?, ?, ?, ?, 0, ?, ?, ?, ?)
+    `);
+        stmt.run(this.namespaceId, id, params.workflowName, params.version, params.idempotencyKey, toJSON(params.config), toJSON(params.context), toJSON(params.input), availableAt, toISO(params.deadlineAt), currentTime, currentTime);
+        const workflowRun = await this.getWorkflowRun({ workflowRunId: id });
+        if (!workflowRun)
+            throw new Error("Failed to create workflow run");
+        return workflowRun;
+    }
+    getWorkflowRun(params) {
+        const stmt = this.db.prepare(`
+      SELECT *
+      FROM "workflow_runs"
+      WHERE "namespace_id" = ? AND "id" = ?
+      LIMIT 1
+    `);
+        const row = stmt.get(this.namespaceId, params.workflowRunId);
+        return Promise.resolve(row ? rowToWorkflowRun(row) : null);
+    }
+    async claimWorkflowRun(params) {
+        const currentTime = now();
+        const newAvailableAt = addMilliseconds(currentTime, params.leaseDurationMs);
+        // SQLite doesn't have SKIP LOCKED, so we need to handle claims differently
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            // 1. mark any deadline-expired workflow runs as failed
+            const expireStmt = this.db.prepare(`
+        UPDATE "workflow_runs"
+        SET
+          "status" = 'failed',
+          "error" = ?,
+          "worker_id" = NULL,
+          "available_at" = NULL,
+          "finished_at" = ?,
+          "updated_at" = ?
+        WHERE "namespace_id" = ?
+          AND "status" IN ('pending', 'running', 'sleeping')
+          AND "deadline_at" IS NOT NULL
+          AND "deadline_at" <= ?
+      `);
+            expireStmt.run(toJSON({ message: "Workflow run deadline exceeded" }), currentTime, currentTime, this.namespaceId, currentTime);
+            // 2. find an available workflow run to claim
+            const findStmt = this.db.prepare(`
+        SELECT "id"
+        FROM "workflow_runs"
+        WHERE "namespace_id" = ?
+          AND "status" IN ('pending', 'running', 'sleeping')
+          AND "available_at" <= ?
+          AND ("deadline_at" IS NULL OR "deadline_at" > ?)
+        ORDER BY
+          CASE WHEN "status" = 'pending' THEN 0 ELSE 1 END,
+          "available_at",
+          "created_at"
+        LIMIT 1
+      `);
+            const candidate = findStmt.get(this.namespaceId, currentTime, currentTime);
+            if (!candidate) {
+                this.db.exec("COMMIT");
+                return null;
+            }
+            // 3. claim the workflow run
+            const claimStmt = this.db.prepare(`
+        UPDATE "workflow_runs"
+        SET
+          "status" = 'running',
+          "attempts" = "attempts" + 1,
+          "worker_id" = ?,
+          "available_at" = ?,
+          "started_at" = COALESCE("started_at", ?),
+          "updated_at" = ?
+        WHERE "id" = ?
+          AND "namespace_id" = ?
+      `);
+            claimStmt.run(params.workerId, newAvailableAt, currentTime, currentTime, candidate.id, this.namespaceId);
+            this.db.exec("COMMIT");
+            return await this.getWorkflowRun({ workflowRunId: candidate.id });
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    async extendWorkflowRunLease(params) {
+        const currentTime = now();
+        const newAvailableAt = addMilliseconds(currentTime, params.leaseDurationMs);
+        const stmt = this.db.prepare(`
+      UPDATE "workflow_runs"
+      SET
+        "available_at" = ?,
+        "updated_at" = ?
+      WHERE "namespace_id" = ?
+      AND "id" = ?
+      AND "status" = 'running'
+      AND "worker_id" = ?
+    `);
+        const result = stmt.run(newAvailableAt, currentTime, this.namespaceId, params.workflowRunId, params.workerId);
+        if (result.changes === 0) {
+            throw new Error("Failed to extend lease for workflow run");
+        }
+        const updated = await this.getWorkflowRun({
+            workflowRunId: params.workflowRunId,
+        });
+        if (!updated)
+            throw new Error("Failed to extend lease for workflow run");
+        return updated;
+    }
+    async sleepWorkflowRun(params) {
+        const currentTime = now();
+        const stmt = this.db.prepare(`
+      UPDATE "workflow_runs"
+      SET
+        "status" = 'sleeping',
+        "available_at" = ?,
+        "worker_id" = NULL,
+        "updated_at" = ?
+      WHERE "namespace_id" = ?
+      AND "id" = ?
+      AND "status" NOT IN ('completed', 'failed', 'canceled')
+      AND "worker_id" = ?
+    `);
+        const result = stmt.run(toISO(params.availableAt), currentTime, this.namespaceId, params.workflowRunId, params.workerId);
+        if (result.changes === 0) {
+            throw new Error("Failed to sleep workflow run");
+        }
+        const updated = await this.getWorkflowRun({
+            workflowRunId: params.workflowRunId,
+        });
+        if (!updated)
+            throw new Error("Failed to sleep workflow run");
+        return updated;
+    }
+    async completeWorkflowRun(params) {
+        const currentTime = now();
+        const stmt = this.db.prepare(`
+      UPDATE "workflow_runs"
+      SET
+        "status" = 'completed',
+        "output" = ?,
+        "error" = NULL,
+        "worker_id" = ?,
+        "available_at" = NULL,
+        "finished_at" = ?,
+        "updated_at" = ?
+      WHERE "namespace_id" = ?
+      AND "id" = ?
+      AND "status" = 'running'
+      AND "worker_id" = ?
+    `);
+        const result = stmt.run(toJSON(params.output), params.workerId, currentTime, currentTime, this.namespaceId, params.workflowRunId, params.workerId);
+        if (result.changes === 0) {
+            throw new Error("Failed to mark workflow run completed");
+        }
+        const updated = await this.getWorkflowRun({
+            workflowRunId: params.workflowRunId,
+        });
+        if (!updated)
+            throw new Error("Failed to mark workflow run completed");
+        return updated;
+    }
+    async failWorkflowRun(params) {
+        const { workflowRunId, error } = params;
+        const { initialIntervalMs, backoffCoefficient, maximumIntervalMs } = DEFAULT_RETRY_POLICY;
+        const currentTime = now();
+        // Get the current workflow run to access attempts
+        const workflowRun = await this.getWorkflowRun({ workflowRunId });
+        if (!workflowRun)
+            throw new Error("Workflow run not found");
+        // Calculate retry delay
+        const backoffMs = initialIntervalMs *
+            Math.pow(backoffCoefficient, workflowRun.attempts - 1);
+        const retryDelayMs = Math.min(backoffMs, maximumIntervalMs);
+        // Determine if we should reschedule or permanently fail
+        const nextRetryTime = new Date(Date.now() + retryDelayMs);
+        const shouldRetry = !workflowRun.deadlineAt || nextRetryTime < workflowRun.deadlineAt;
+        const status = shouldRetry ? "pending" : "failed";
+        const availableAt = shouldRetry ? nextRetryTime.toISOString() : null;
+        const finishedAt = shouldRetry ? null : currentTime;
+        const stmt = this.db.prepare(`
+      UPDATE "workflow_runs"
+      SET
+        "status" = ?,
+        "available_at" = ?,
+        "finished_at" = ?,
+        "error" = ?,
+        "worker_id" = NULL,
+        "started_at" = NULL,
+        "updated_at" = ?
+      WHERE "namespace_id" = ?
+      AND "id" = ?
+      AND "status" = 'running'
+      AND "worker_id" = ?
+    `);
+        const result = stmt.run(status, availableAt, finishedAt, toJSON(error), currentTime, this.namespaceId, workflowRunId, params.workerId);
+        if (result.changes === 0) {
+            throw new Error("Failed to mark workflow run failed");
+        }
+        const updated = await this.getWorkflowRun({ workflowRunId });
+        if (!updated)
+            throw new Error("Failed to mark workflow run failed");
+        return updated;
+    }
+    async cancelWorkflowRun(params) {
+        const currentTime = now();
+        const stmt = this.db.prepare(`
+      UPDATE "workflow_runs"
+      SET
+        "status" = 'canceled',
+        "worker_id" = NULL,
+        "available_at" = NULL,
+        "finished_at" = ?,
+        "updated_at" = ?
+      WHERE "namespace_id" = ?
+      AND "id" = ?
+      AND "status" IN ('pending', 'running', 'sleeping')
+    `);
+        const result = stmt.run(currentTime, currentTime, this.namespaceId, params.workflowRunId);
+        if (result.changes === 0) {
+            // workflow may already be in a terminal state
+            const existing = await this.getWorkflowRun({
+                workflowRunId: params.workflowRunId,
+            });
+            if (!existing) {
+                throw new Error(`Workflow run ${params.workflowRunId} does not exist`);
+            }
+            // if already canceled, just return it
+            if (existing.status === "canceled") {
+                return existing;
+            }
+            // throw error for completed/failed workflows
+            if (["completed", "failed"].includes(existing.status)) {
+                throw new Error(`Cannot cancel workflow run ${params.workflowRunId} with status ${existing.status}`);
+            }
+            throw new Error("Failed to cancel workflow run");
+        }
+        const updated = await this.getWorkflowRun({
+            workflowRunId: params.workflowRunId,
+        });
+        if (!updated)
+            throw new Error("Failed to cancel workflow run");
+        return updated;
+    }
+    listWorkflowRuns(params) {
+        const limit = params.limit ?? DEFAULT_PAGINATION_PAGE_SIZE;
+        const { after, before } = params;
+        let cursor = null;
+        if (after) {
+            cursor = decodeCursor(after);
+        }
+        else if (before) {
+            cursor = decodeCursor(before);
+        }
+        const order = before
+            ? `ORDER BY "created_at" ASC, "id" ASC`
+            : `ORDER BY "created_at" DESC, "id" DESC`;
+        let query;
+        let queryParams;
+        if (cursor) {
+            const op = after ? "<" : ">";
+            query = `
+        SELECT *
+        FROM "workflow_runs"
+        WHERE "namespace_id" = ?
+          AND ("created_at", "id") ${op} (?, ?)
+        ${order}
+        LIMIT ?
+      `;
+            queryParams = [
+                this.namespaceId,
+                cursor.createdAt.toISOString(),
+                cursor.id,
+                limit + 1,
+            ];
+        }
+        else {
+            query = `
+        SELECT *
+        FROM "workflow_runs"
+        WHERE "namespace_id" = ?
+        ${order}
+        LIMIT ?
+      `;
+            queryParams = [this.namespaceId, limit + 1];
+        }
+        const stmt = this.db.prepare(query);
+        const rawRows = stmt.all(...queryParams);
+        if (!Array.isArray(rawRows)) {
+            return Promise.resolve({
+                data: [],
+                pagination: { next: null, prev: null },
+            });
+        }
+        const rows = rawRows.map((row) => rowToWorkflowRun(row));
+        return Promise.resolve(this.processPaginationResults(rows, limit, !!after, !!before));
+    }
+    listStepAttempts(params) {
+        const limit = params.limit ?? DEFAULT_PAGINATION_PAGE_SIZE;
+        const { after, before } = params;
+        let cursor = null;
+        if (after) {
+            cursor = decodeCursor(after);
+        }
+        else if (before) {
+            cursor = decodeCursor(before);
+        }
+        const order = before
+            ? `ORDER BY "created_at" DESC, "id" DESC`
+            : `ORDER BY "created_at" ASC, "id" ASC`;
+        let query;
+        let queryParams;
+        if (cursor) {
+            const op = after ? ">" : "<";
+            query = `
+        SELECT *
+        FROM "step_attempts"
+        WHERE "namespace_id" = ?
+          AND "workflow_run_id" = ?
+          AND ("created_at", "id") ${op} (?, ?)
+        ${order}
+        LIMIT ?
+      `;
+            queryParams = [
+                this.namespaceId,
+                params.workflowRunId,
+                cursor.createdAt.toISOString(),
+                cursor.id,
+                limit + 1,
+            ];
+        }
+        else {
+            query = `
+        SELECT *
+        FROM "step_attempts"
+        WHERE "namespace_id" = ?
+          AND "workflow_run_id" = ?
+        ${order}
+        LIMIT ?
+      `;
+            queryParams = [this.namespaceId, params.workflowRunId, limit + 1];
+        }
+        const stmt = this.db.prepare(query);
+        const rawRows = stmt.all(...queryParams);
+        if (!Array.isArray(rawRows)) {
+            return Promise.resolve({
+                data: [],
+                pagination: { next: null, prev: null },
+            });
+        }
+        const rows = rawRows.map((row) => rowToStepAttempt(row));
+        return Promise.resolve(this.processPaginationResults(rows, limit, !!after, !!before));
+    }
+    processPaginationResults(rows, limit, hasAfter, hasBefore) {
+        const data = rows;
+        let hasNext = false;
+        let hasPrev = false;
+        if (hasBefore) {
+            data.reverse();
+            if (data.length > limit) {
+                hasPrev = true;
+                data.shift();
+            }
+            hasNext = true;
+        }
+        else {
+            if (data.length > limit) {
+                hasNext = true;
+                data.pop();
+            }
+            if (hasAfter) {
+                hasPrev = true;
+            }
+        }
+        const lastItem = data.at(-1);
+        const nextCursor = hasNext && lastItem ? encodeCursor(lastItem) : null;
+        const firstItem = data[0];
+        const prevCursor = hasPrev && firstItem ? encodeCursor(firstItem) : null;
+        return {
+            data,
+            pagination: {
+                next: nextCursor,
+                prev: prevCursor,
+            },
+        };
+    }
+    async createStepAttempt(params) {
+        const id = generateUUID();
+        const currentTime = now();
+        const stmt = this.db.prepare(`
+      INSERT INTO "step_attempts" (
+        "namespace_id",
+        "id",
+        "workflow_run_id",
+        "step_name",
+        "kind",
+        "status",
+        "config",
+        "context",
+        "started_at",
+        "created_at",
+        "updated_at"
+      )
+      VALUES (?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?)
+    `);
+        stmt.run(this.namespaceId, id, params.workflowRunId, params.stepName, params.kind, toJSON(params.config), toJSON(params.context), currentTime, currentTime, currentTime);
+        const stepAttempt = await this.getStepAttempt({ stepAttemptId: id });
+        if (!stepAttempt)
+            throw new Error("Failed to create step attempt");
+        return stepAttempt;
+    }
+    getStepAttempt(params) {
+        const stmt = this.db.prepare(`
+      SELECT *
+      FROM "step_attempts"
+      WHERE "namespace_id" = ? AND "id" = ?
+      LIMIT 1
+    `);
+        const row = stmt.get(this.namespaceId, params.stepAttemptId);
+        return Promise.resolve(row ? rowToStepAttempt(row) : null);
+    }
+    async completeStepAttempt(params) {
+        const currentTime = now();
+        // Check that the workflow is running and owned by the worker
+        const workflowStmt = this.db.prepare(`
+      SELECT "id"
+      FROM "workflow_runs"
+      WHERE "namespace_id" = ?
+      AND "id" = ?
+      AND "status" = 'running'
+      AND "worker_id" = ?
+    `);
+        const workflowRow = workflowStmt.get(this.namespaceId, params.workflowRunId, params.workerId);
+        if (!workflowRow) {
+            throw new Error("Failed to mark step attempt completed");
+        }
+        const stmt = this.db.prepare(`
+      UPDATE "step_attempts"
+      SET
+        "status" = 'completed',
+        "output" = ?,
+        "error" = NULL,
+        "finished_at" = ?,
+        "updated_at" = ?
+      WHERE "namespace_id" = ?
+      AND "workflow_run_id" = ?
+      AND "id" = ?
+      AND "status" = 'running'
+    `);
+        const result = stmt.run(toJSON(params.output), currentTime, currentTime, this.namespaceId, params.workflowRunId, params.stepAttemptId);
+        if (result.changes === 0) {
+            throw new Error("Failed to mark step attempt completed");
+        }
+        const updated = await this.getStepAttempt({
+            stepAttemptId: params.stepAttemptId,
+        });
+        if (!updated)
+            throw new Error("Failed to mark step attempt completed");
+        return updated;
+    }
+    async failStepAttempt(params) {
+        const currentTime = now();
+        // Check that the workflow is running and owned by the worker
+        const workflowStmt = this.db.prepare(`
+      SELECT "id"
+      FROM "workflow_runs"
+      WHERE "namespace_id" = ?
+      AND "id" = ?
+      AND "status" = 'running'
+      AND "worker_id" = ?
+    `);
+        const workflowRow = workflowStmt.get(this.namespaceId, params.workflowRunId, params.workerId);
+        if (!workflowRow) {
+            throw new Error("Failed to mark step attempt failed");
+        }
+        const stmt = this.db.prepare(`
+      UPDATE "step_attempts"
+      SET
+        "status" = 'failed',
+        "output" = NULL,
+        "error" = ?,
+        "finished_at" = ?,
+        "updated_at" = ?
+      WHERE "namespace_id" = ?
+      AND "workflow_run_id" = ?
+      AND "id" = ?
+      AND "status" = 'running'
+    `);
+        const result = stmt.run(toJSON(params.error), currentTime, currentTime, this.namespaceId, params.workflowRunId, params.stepAttemptId);
+        if (result.changes === 0) {
+            throw new Error("Failed to mark step attempt failed");
+        }
+        const updated = await this.getStepAttempt({
+            stepAttemptId: params.stepAttemptId,
+        });
+        if (!updated)
+            throw new Error("Failed to mark step attempt failed");
+        return updated;
+    }
+}
+// Conversion functions
+/**
+ * Convert a database row to a WorkflowRun.
+ * @param row - Workflow run row
+ * @returns Workflow run
+ * @throws {Error} If required fields are missing
+ */
+function rowToWorkflowRun(row) {
+    const createdAt = fromISO(row.created_at);
+    const updatedAt = fromISO(row.updated_at);
+    const config = fromJSON(row.config);
+    if (!createdAt)
+        throw new Error("createdAt is required");
+    if (!updatedAt)
+        throw new Error("updatedAt is required");
+    if (config === null)
+        throw new Error("config is required");
+    return {
+        namespaceId: row.namespace_id,
+        id: row.id,
+        workflowName: row.workflow_name,
+        version: row.version,
+        status: row.status,
+        idempotencyKey: row.idempotency_key,
+        config: config,
+        context: fromJSON(row.context),
+        input: fromJSON(row.input),
+        output: fromJSON(row.output),
+        error: fromJSON(row.error),
+        attempts: row.attempts,
+        parentStepAttemptNamespaceId: row.parent_step_attempt_namespace_id,
+        parentStepAttemptId: row.parent_step_attempt_id,
+        workerId: row.worker_id,
+        availableAt: fromISO(row.available_at),
+        deadlineAt: fromISO(row.deadline_at),
+        startedAt: fromISO(row.started_at),
+        finishedAt: fromISO(row.finished_at),
+        createdAt,
+        updatedAt,
+    };
+}
+/**
+ * Convert a database row to a StepAttempt.
+ * @param row - Step attempt row
+ * @returns Step attempt
+ * @throws {Error} If required fields are missing
+ */
+function rowToStepAttempt(row) {
+    const createdAt = fromISO(row.created_at);
+    const updatedAt = fromISO(row.updated_at);
+    const config = fromJSON(row.config);
+    if (!createdAt)
+        throw new Error("createdAt is required");
+    if (!updatedAt)
+        throw new Error("updatedAt is required");
+    if (config === null)
+        throw new Error("config is required");
+    return {
+        namespaceId: row.namespace_id,
+        id: row.id,
+        workflowRunId: row.workflow_run_id,
+        stepName: row.step_name,
+        kind: row.kind,
+        status: row.status,
+        config: config,
+        context: fromJSON(row.context),
+        output: fromJSON(row.output),
+        error: fromJSON(row.error),
+        childWorkflowRunNamespaceId: row.child_workflow_run_namespace_id,
+        childWorkflowRunId: row.child_workflow_run_id,
+        startedAt: fromISO(row.started_at),
+        finishedAt: fromISO(row.finished_at),
+        createdAt,
+        updatedAt,
+    };
+}
+/**
+ * Encode a pagination cursor to a string.
+ * @param item - Cursor data
+ * @returns Encoded cursor
+ */
+function encodeCursor(item) {
+    return Buffer.from(JSON.stringify({ createdAt: item.createdAt, id: item.id })).toString("base64");
+}
+/**
+ * Decode a pagination cursor from a string.
+ * @param cursor - Encoded cursor
+ * @returns Cursor data
+ */
+function decodeCursor(cursor) {
+    const decoded = Buffer.from(cursor, "base64").toString("utf8");
+    const parsed = JSON.parse(decoded);
+    return {
+        createdAt: new Date(parsed.createdAt),
+        id: parsed.id,
+    };
+}

package/dist/node-sqlite/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../node-sqlite/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GACvD,aAAa,CAAC;AACjB,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GACpD,aAAa,CAAC"}

package/dist/node-sqlite/index.js

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