@sonamu-kit/tasks 0.1.3 → 0.3.0

package/dist/database/backend.js

@@ -1,559 +1,558 @@
-import { getLogger } from "@logtape/logtape";
-import { camelize } from "inflection";
-import knex from "knex";
+import { mergeRetryPolicy } from "../core/retry.js";
 import { DEFAULT_NAMESPACE_ID } from "../backend.js";
-import { DEFAULT_RETRY_POLICY } from "../core/retry.js";
 import { DEFAULT_SCHEMA, migrate } from "./base.js";
 import { PostgresPubSub } from "./pubsub.js";
-export const DEFAULT_LISTEN_CHANNEL = "new_tasks";
+import { getLogger } from "@logtape/logtape";
+import { camelize } from "inflection";
+import knex from "knex";
+
+//#region src/database/backend.ts
+const DEFAULT_LISTEN_CHANNEL = "new_tasks";
 const DEFAULT_PAGINATION_PAGE_SIZE = 100;
 const logger = getLogger([
-    "sonamu",
-    "internal",
-    "tasks"
+	"sonamu",
+	"internal",
+	"tasks"
 ]);
 const queryLogger = getLogger([
-    "sonamu",
-    "internal",
-    "tasks",
-    "query"
+	"sonamu",
+	"internal",
+	"tasks",
+	"query"
 ]);
 /**
- * Manages a connection to a Postgres database for workflow operations.
- */ export class BackendPostgres {
-    config;
-    namespaceId;
-    usePubSub;
-    pubsub = null;
-    initialized = false;
-    runMigrations;
-    _knex = null;
-    get knex() {
-        if (!this._knex) {
-            this._knex = knex(this.config);
-            this._knex.on("query", (query)=>{
-                queryLogger.debug("SQL: {query}, Values: {bindings}", {
-                    query: query.sql,
-                    bindings: query.bindings
-                });
-            });
-        }
-        return this._knex;
-    }
-    constructor(config, options){
-        this.config = {
-            ...config,
-            postProcessResponse: (result, _queryContext)=>{
-                if (result === null || result === undefined) {
-                    return result;
-                }
-                if (config?.postProcessResponse) {
-                    result = config.postProcessResponse(result, _queryContext);
-                }
-                const camelizeRow = (row)=>Object.fromEntries(Object.entries(row).map(([key, value])=>[
-                            camelize(key, true),
-                            value
-                        ]));
-                if (Array.isArray(result)) {
-                    return result.map(camelizeRow);
-                }
-                return camelizeRow(result);
-            }
-        };
-        const { namespaceId, usePubSub, runMigrations } = {
-            namespaceId: DEFAULT_NAMESPACE_ID,
-            usePubSub: true,
-            runMigrations: true,
-            ...options
-        };
-        this.namespaceId = namespaceId;
-        this.usePubSub = usePubSub;
-        this.runMigrations = runMigrations;
-    }
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        if (this.runMigrations) {
-            await migrate(this.config, DEFAULT_SCHEMA);
-        }
-        this.initialized = true;
-    }
-    async subscribe(callback) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        if (!this.usePubSub) {
-            return;
-        }
-        if (!this.pubsub) {
-            this.pubsub = await PostgresPubSub.create(this.knex);
-        }
-        this.pubsub.listenEvent(DEFAULT_LISTEN_CHANNEL, callback);
-    }
-    async publish(payload) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        if (!this.usePubSub) {
-            return;
-        }
-        await this.knex.raw(payload ? `NOTIFY ${DEFAULT_LISTEN_CHANNEL}, '${payload}'` : `NOTIFY ${DEFAULT_LISTEN_CHANNEL}`);
-    }
-    async stop() {
-        if (!this.initialized) {
-            return;
-        }
-        await this.pubsub?.destroy();
-        this.pubsub = null;
-        await this.knex.destroy();
-    }
-    async createWorkflowRun(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Creating workflow run: {workflowName}:{version}", {
-            workflowName: params.workflowName,
-            version: params.version
-        });
-        const qb = this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").insert({
-            namespace_id: this.namespaceId,
-            id: crypto.randomUUID(),
-            workflow_name: params.workflowName,
-            version: params.version,
-            status: "pending",
-            idempotency_key: params.idempotencyKey,
-            config: params.config,
-            context: params.context,
-            input: params.input,
-            attempts: 0,
-            available_at: params.availableAt ?? this.knex.fn.now(),
-            deadline_at: params.deadlineAt,
-            created_at: this.knex.fn.now(),
-            updated_at: this.knex.fn.now()
-        }).returning("*");
-        const workflowRun = await qb;
-        if (!workflowRun[0]) {
-            logger.error("Failed to create workflow run: {params}", {
-                params
-            });
-            throw new Error("Failed to create workflow run");
-        }
-        return workflowRun[0];
-    }
-    async getWorkflowRun(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Getting workflow run: {workflowRunId}", {
-            workflowRunId: params.workflowRunId
-        });
-        const workflowRun = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).select("namespace_id", "id", "workflow_name", "version", "status", "idempotency_key", "config", "context", "input", "output", "error", "attempts", "parent_step_attempt_namespace_id", "parent_step_attempt_id", "worker_id", "available_at", "deadline_at", "started_at", "finished_at", "created_at", "updated_at").first();
-        return workflowRun ?? null;
-    }
-    async listWorkflowRuns(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Listing workflow runs: {after}, {before}", {
-            after: params.after,
-            before: params.before
-        });
-        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 qb = this.buildListWorkflowRunsWhere(params, cursor);
-        const rows = await qb.orderBy("created_at", before ? "desc" : "asc").orderBy("id", before ? "desc" : "asc").limit(limit + 1);
-        return this.processPaginationResults(rows, limit, typeof after === "string", typeof before === "string");
-    }
-    buildListWorkflowRunsWhere(params, cursor) {
-        const { after } = params;
-        const qb = this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId);
-        if (cursor) {
-            const operator = after ? ">" : "<";
-            return qb.whereRaw(`("created_at", "id") ${operator} (?, ?)`, [
-                cursor.createdAt.toISOString(),
-                cursor.id
-            ]);
-        }
-        return qb;
-    }
-    async claimWorkflowRun(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Claiming workflow run: {workerId}, {leaseDurationMs}", {
-            workerId: params.workerId,
-            leaseDurationMs: params.leaseDurationMs
-        });
-        const claimed = await this.knex.with("expired", (qb)=>qb.withSchema(DEFAULT_SCHEMA).table("workflow_runs").update({
-                status: "failed",
-                error: JSON.stringify({
-                    message: "Workflow run deadline exceeded"
-                }),
-                worker_id: null,
-                available_at: null,
-                finished_at: this.knex.raw("NOW()"),
-                updated_at: this.knex.raw("NOW()")
-            }).where("namespace_id", this.namespaceId).whereIn("status", [
-                "pending",
-                "running",
-                "sleeping"
-            ]).whereNotNull("deadline_at").where("deadline_at", "<=", this.knex.raw("NOW()")).returning("id")).with("candidate", (qb)=>qb.withSchema(DEFAULT_SCHEMA).select("id").from("workflow_runs").where("namespace_id", this.namespaceId).whereIn("status", [
-                "pending",
-                "running",
-                "sleeping"
-            ]).where("available_at", "<=", this.knex.raw("NOW()")).where((qb2)=>{
-                qb2.whereNull("deadline_at").orWhere("deadline_at", ">", this.knex.raw("NOW()"));
-            }).orderByRaw("CASE WHEN status = 'pending' THEN 0 ELSE 1 END").orderBy("available_at", "asc").orderBy("created_at", "asc").limit(1).forUpdate().skipLocked()).withSchema(DEFAULT_SCHEMA).table("workflow_runs as wr").where("wr.namespace_id", this.namespaceId).where("wr.id", this.knex.ref("candidate.id")).update({
-            status: "running",
-            attempts: this.knex.raw("wr.attempts + 1"),
-            worker_id: params.workerId,
-            available_at: this.knex.raw(`NOW() + ${params.leaseDurationMs} * INTERVAL '1 millisecond'`),
-            started_at: this.knex.raw("COALESCE(wr.started_at, NOW())"),
-            updated_at: this.knex.raw("NOW()")
-        }).updateFrom("candidate").returning("wr.*");
-        return claimed[0] ?? null;
-    }
-    async extendWorkflowRunLease(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Extending workflow run lease: {workflowRunId}, {workerId}, {leaseDurationMs}", {
-            workflowRunId: params.workflowRunId,
-            workerId: params.workerId,
-            leaseDurationMs: params.leaseDurationMs
-        });
-        const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).where("status", "running").where("worker_id", params.workerId).update({
-            available_at: this.knex.raw(`NOW() + ${params.leaseDurationMs} * INTERVAL '1 millisecond'`),
-            updated_at: this.knex.fn.now()
-        }).returning("*");
-        if (!updated) {
-            logger.error("Failed to extend lease for workflow run: {params}", {
-                params
-            });
-            throw new Error("Failed to extend lease for workflow run");
-        }
-        return updated;
-    }
-    async sleepWorkflowRun(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Sleeping workflow run: {workflowRunId}, {workerId}, {availableAt}", {
-            workflowRunId: params.workflowRunId,
-            workerId: params.workerId,
-            availableAt: params.availableAt
-        });
-        // 'succeeded' status is deprecated
-        const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).whereNotIn("status", [
-            "succeeded",
-            "completed",
-            "failed",
-            "canceled"
-        ]).where("worker_id", params.workerId).update({
-            status: "sleeping",
-            available_at: params.availableAt,
-            worker_id: null,
-            updated_at: this.knex.fn.now()
-        }).returning("*");
-        if (!updated) {
-            logger.error("Failed to sleep workflow run: {params}", {
-                params
-            });
-            throw new Error("Failed to sleep workflow run");
-        }
-        return updated;
-    }
-    async completeWorkflowRun(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Completing workflow run: {workflowRunId}, {workerId}, {output}", {
-            workflowRunId: params.workflowRunId,
-            workerId: params.workerId,
-            output: params.output
-        });
-        const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).where("status", "running").where("worker_id", params.workerId).update({
-            status: "completed",
-            output: JSON.stringify(params.output),
-            error: null,
-            worker_id: params.workerId,
-            available_at: null,
-            finished_at: this.knex.fn.now(),
-            updated_at: this.knex.fn.now()
-        }).returning("*");
-        if (!updated) {
-            logger.error("Failed to complete workflow run: {params}", {
-                params
-            });
-            throw new Error("Failed to complete workflow run");
-        }
-        return updated;
-    }
-    async failWorkflowRun(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        const { workflowRunId, error } = params;
-        const { initialIntervalMs, backoffCoefficient, maximumIntervalMs } = DEFAULT_RETRY_POLICY;
-        // this beefy query updates a workflow's status, available_at, and
-        // finished_at based on the workflow's deadline and retry policy
-        //
-        // if the next retry would exceed the deadline, the run is marked as
-        // 'failed' and finalized, otherwise, the run is rescheduled with an updated
-        // 'available_at' timestamp for the next retry
-        const retryIntervalExpr = `LEAST(${initialIntervalMs} * POWER(${backoffCoefficient}, "attempts" - 1), ${maximumIntervalMs}) * INTERVAL '1 millisecond'`;
-        const deadlineExceededCondition = `"deadline_at" IS NOT NULL AND NOW() + (${retryIntervalExpr}) >= "deadline_at"`;
-        logger.info("Failing workflow run: {workflowRunId}, {workerId}, {error}", {
-            workflowRunId: params.workflowRunId,
-            workerId: params.workerId,
-            error: params.error
-        });
-        const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", workflowRunId).where("status", "running").where("worker_id", params.workerId).update({
-            status: this.knex.raw(`CASE WHEN ${deadlineExceededCondition} THEN 'failed' ELSE 'pending' END`),
-            available_at: this.knex.raw(`CASE WHEN ${deadlineExceededCondition} THEN NULL ELSE NOW() + (${retryIntervalExpr}) END`),
-            finished_at: this.knex.raw(`CASE WHEN ${deadlineExceededCondition} THEN NOW() ELSE NULL END`),
-            error: JSON.stringify(error),
-            worker_id: null,
-            started_at: null,
-            updated_at: this.knex.fn.now()
-        }).returning("*");
-        if (!updated) {
-            logger.error("Failed to mark workflow run failed: {params}", {
-                params
-            });
-            throw new Error("Failed to mark workflow run failed");
-        }
-        return updated;
-    }
-    async cancelWorkflowRun(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Canceling workflow run: {workflowRunId}", {
-            workflowRunId: params.workflowRunId
-        });
-        const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).whereIn("status", [
-            "pending",
-            "running",
-            "sleeping"
-        ]).update({
-            status: "canceled",
-            worker_id: null,
-            available_at: null,
-            finished_at: this.knex.fn.now(),
-            updated_at: this.knex.fn.now()
-        }).returning("*");
-        if (!updated) {
-            // 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
-            // 'succeeded' status is deprecated
-            if ([
-                "succeeded",
-                "completed",
-                "failed"
-            ].includes(existing.status)) {
-                logger.error("Cannot cancel workflow run: {params} with status {status}", {
-                    params,
-                    status: existing.status
-                });
-                throw new Error(`Cannot cancel workflow run ${params.workflowRunId} with status ${existing.status}`);
-            }
-            logger.error("Failed to cancel workflow run: {params}", {
-                params
-            });
-            throw new Error("Failed to cancel workflow run");
-        }
-        return updated;
-    }
-    async createStepAttempt(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Creating step attempt: {workflowRunId}, {stepName}, {kind}", {
-            workflowRunId: params.workflowRunId,
-            stepName: params.stepName,
-            kind: params.kind
-        });
-        const [stepAttempt] = await this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts").insert({
-            namespace_id: this.namespaceId,
-            id: crypto.randomUUID(),
-            workflow_run_id: params.workflowRunId,
-            step_name: params.stepName,
-            kind: params.kind,
-            status: "running",
-            config: JSON.stringify(params.config),
-            context: JSON.stringify(params.context),
-            started_at: this.knex.fn.now(),
-            created_at: this.knex.raw("date_trunc('milliseconds', NOW())"),
-            updated_at: this.knex.fn.now()
-        }).returning("*");
-        if (!stepAttempt) {
-            logger.error("Failed to create step attempt: {params}", {
-                params
-            });
-            throw new Error("Failed to create step attempt");
-        }
-        return stepAttempt;
-    }
-    async getStepAttempt(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Getting step attempt: {stepAttemptId}", {
-            stepAttemptId: params.stepAttemptId
-        });
-        const stepAttempt = await this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts").where("namespace_id", this.namespaceId).where("id", params.stepAttemptId).first();
-        return stepAttempt ?? null;
-    }
-    async listStepAttempts(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Listing step attempts: {workflowRunId}, {after}, {before}", {
-            workflowRunId: params.workflowRunId,
-            after: params.after,
-            before: params.before
-        });
-        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 qb = this.buildListStepAttemptsWhere(params, cursor);
-        const rows = await qb.orderBy("created_at", before ? "desc" : "asc").orderBy("id", before ? "desc" : "asc").limit(limit + 1);
-        return this.processPaginationResults(rows, limit, typeof after === "string", typeof before === "string");
-    }
-    buildListStepAttemptsWhere(params, cursor) {
-        const { after } = params;
-        const qb = this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts").where("namespace_id", this.namespaceId).where("workflow_run_id", params.workflowRunId);
-        if (cursor) {
-            const operator = after ? ">" : "<";
-            return qb.whereRaw(`("created_at", "id") ${operator} (?, ?)`, [
-                cursor.createdAt.toISOString(),
-                cursor.id
-            ]);
-        }
-        return qb;
-    }
-    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
-            }
-        };
-    }
-    // NOTE: 실제 서비스에서 이게 안 되는 것 같은데, 쿼리 등을 체크할 필요가 있음.
-    async completeStepAttempt(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Marking step attempt as completed: {workflowRunId}, {stepAttemptId}, {workerId}", {
-            workflowRunId: params.workflowRunId,
-            stepAttemptId: params.stepAttemptId,
-            workerId: params.workerId
-        });
-        const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts as sa").update({
-            status: "completed",
-            output: JSON.stringify(params.output),
-            error: null,
-            finished_at: this.knex.fn.now(),
-            updated_at: this.knex.fn.now()
-        }).updateFrom(`${DEFAULT_SCHEMA}.workflow_runs as wr`).where("sa.namespace_id", this.namespaceId).where("sa.workflow_run_id", params.workflowRunId).where("sa.id", params.stepAttemptId).where("sa.status", "running").where("wr.namespace_id", this.knex.ref("sa.namespace_id")).where("wr.id", this.knex.ref("sa.workflow_run_id")).where("wr.status", "running").where("wr.worker_id", params.workerId).returning("sa.*");
-        if (!updated) {
-            logger.error("Failed to mark step attempt completed: {params}", {
-                params
-            });
-            throw new Error("Failed to mark step attempt completed");
-        }
-        return updated;
-    }
-    async failStepAttempt(params) {
-        if (!this.initialized) {
-            throw new Error("Backend not initialized");
-        }
-        logger.info("Marking step attempt as failed: {workflowRunId}, {stepAttemptId}, {workerId}", {
-            workflowRunId: params.workflowRunId,
-            stepAttemptId: params.stepAttemptId,
-            workerId: params.workerId
-        });
-        logger.info("Error: {error.message}", {
-            error: params.error.message
-        });
-        const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts as sa").update({
-            status: "failed",
-            output: null,
-            error: JSON.stringify(params.error),
-            finished_at: this.knex.fn.now(),
-            updated_at: this.knex.fn.now()
-        }).updateFrom(`${DEFAULT_SCHEMA}.workflow_runs as wr`).where("sa.namespace_id", this.namespaceId).where("sa.workflow_run_id", params.workflowRunId).where("sa.id", params.stepAttemptId).where("sa.status", "running").where("wr.namespace_id", this.knex.ref("sa.namespace_id")).where("wr.id", this.knex.ref("sa.workflow_run_id")).where("wr.status", "running").where("wr.worker_id", params.workerId).returning("sa.*");
-        if (!updated) {
-            logger.error("Failed to mark step attempt failed: {params}", {
-                params
-            });
-            throw new Error("Failed to mark step attempt failed");
-        }
-        return updated;
-    }
-}
+* Manages a connection to a Postgres database for workflow operations.
+*/
+var BackendPostgres = class {
+	config;
+	namespaceId;
+	usePubSub;
+	pubsub = null;
+	initialized = false;
+	runMigrations;
+	_knex = null;
+	get knex() {
+		if (!this._knex) {
+			this._knex = knex(this.config);
+			this._knex.on("query", (query) => {
+				queryLogger.debug("SQL: {query}, Values: {bindings}", {
+					query: query.sql,
+					bindings: query.bindings
+				});
+			});
+		}
+		return this._knex;
+	}
+	constructor(config, options) {
+		this.config = {
+			...config,
+			postProcessResponse: (result, _queryContext) => {
+				if (result === null || result === void 0) return result;
+				if (config?.postProcessResponse) result = config.postProcessResponse(result, _queryContext);
+				const camelizeRow = (row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [camelize(key, true), value]));
+				if (Array.isArray(result)) return result.map(camelizeRow);
+				return camelizeRow(result);
+			}
+		};
+		const { namespaceId, usePubSub, runMigrations } = {
+			namespaceId: DEFAULT_NAMESPACE_ID,
+			usePubSub: true,
+			runMigrations: true,
+			...options
+		};
+		this.namespaceId = namespaceId;
+		this.usePubSub = usePubSub;
+		this.runMigrations = runMigrations;
+	}
+	async initialize() {
+		if (this.initialized) return;
+		if (this.runMigrations) await migrate(this.config, DEFAULT_SCHEMA);
+		this.initialized = true;
+	}
+	async subscribe(callback) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		if (!this.usePubSub) return;
+		if (!this.pubsub) this.pubsub = await PostgresPubSub.create(this.knex);
+		this.pubsub.listenEvent(DEFAULT_LISTEN_CHANNEL, callback);
+	}
+	async publish(payload) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		if (!this.usePubSub) return;
+		await this.knex.raw(payload ? `NOTIFY ${DEFAULT_LISTEN_CHANNEL}, '${payload}'` : `NOTIFY ${DEFAULT_LISTEN_CHANNEL}`);
+	}
+	async stop() {
+		if (!this.initialized) return;
+		await this.pubsub?.destroy();
+		this.pubsub = null;
+		await this.knex.destroy();
+		this._knex = null;
+		this.initialized = false;
+	}
+	async createWorkflowRun(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Creating workflow run: {workflowName}:{version}", {
+			workflowName: params.workflowName,
+			version: params.version
+		});
+		const configWithRetryPolicy = {
+			...typeof params.config === "object" && params.config !== null ? params.config : {},
+			retryPolicy: params.retryPolicy ?? void 0
+		};
+		const workflowRun = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").insert({
+			namespace_id: this.namespaceId,
+			id: crypto.randomUUID(),
+			workflow_name: params.workflowName,
+			version: params.version,
+			status: "pending",
+			idempotency_key: params.idempotencyKey,
+			config: JSON.stringify(configWithRetryPolicy),
+			context: params.context,
+			input: params.input,
+			attempts: 0,
+			available_at: params.availableAt ?? this.knex.fn.now(),
+			deadline_at: params.deadlineAt,
+			created_at: this.knex.fn.now(),
+			updated_at: this.knex.fn.now()
+		}).returning("*");
+		if (!workflowRun[0]) {
+			logger.error("Failed to create workflow run: {params}", { params });
+			throw new Error("Failed to create workflow run");
+		}
+		return workflowRun[0];
+	}
+	async getWorkflowRun(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Getting workflow run: {workflowRunId}", { workflowRunId: params.workflowRunId });
+		return await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).select("namespace_id", "id", "workflow_name", "version", "status", "idempotency_key", "config", "context", "input", "output", "error", "attempts", "parent_step_attempt_namespace_id", "parent_step_attempt_id", "worker_id", "available_at", "deadline_at", "started_at", "finished_at", "created_at", "updated_at").first() ?? null;
+	}
+	async listWorkflowRuns(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Listing workflow runs: {after}, {before}", {
+			after: params.after,
+			before: params.before
+		});
+		const limit = params.limit ?? DEFAULT_PAGINATION_PAGE_SIZE;
+		const { after, before } = params;
+		const order = params.order ?? "asc";
+		const reverseOrder = order === "asc" ? "desc" : "asc";
+		let cursor = null;
+		if (after) cursor = decodeCursor(after);
+		else if (before) cursor = decodeCursor(before);
+		const rows = await this.buildListWorkflowRunsWhere(params, cursor, order).orderBy("created_at", before ? reverseOrder : order).orderBy("id", before ? reverseOrder : order).limit(limit + 1);
+		return this.processPaginationResults(rows, limit, typeof after === "string", typeof before === "string");
+	}
+	buildListWorkflowRunsWhere(params, cursor, order) {
+		const { after } = params;
+		const qb = this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId);
+		if (cursor) {
+			const operator = order === "asc" === !!after ? ">" : "<";
+			qb.whereRaw(`("created_at", "id") ${operator} (?, ?)`, [cursor.createdAt.toISOString(), cursor.id]);
+		}
+		if (params.status && params.status.length > 0) qb.whereIn("status", params.status);
+		if (params.workflowName) qb.where("workflow_name", params.workflowName);
+		if (params.createdAfter) qb.where("created_at", ">=", params.createdAfter);
+		if (params.createdBefore) qb.where("created_at", "<=", params.createdBefore);
+		return qb;
+	}
+	async claimWorkflowRun(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Claiming workflow run: {workerId}, {leaseDurationMs}", {
+			workerId: params.workerId,
+			leaseDurationMs: params.leaseDurationMs
+		});
+		return (await this.knex.with("expired", (qb) => qb.withSchema(DEFAULT_SCHEMA).table("workflow_runs").update({
+			status: "failed",
+			error: JSON.stringify({ message: "Workflow run deadline exceeded" }),
+			worker_id: null,
+			available_at: null,
+			finished_at: this.knex.raw("NOW()"),
+			updated_at: this.knex.raw("NOW()")
+		}).where("namespace_id", this.namespaceId).whereIn("status", [
+			"pending",
+			"running",
+			"sleeping"
+		]).whereNotNull("deadline_at").where("deadline_at", "<=", this.knex.raw("NOW()")).returning("id")).with("candidate", (qb) => qb.withSchema(DEFAULT_SCHEMA).select("id").from("workflow_runs").where("namespace_id", this.namespaceId).whereIn("status", [
+			"pending",
+			"running",
+			"sleeping"
+		]).where("available_at", "<=", this.knex.raw("NOW()")).where((qb2) => {
+			qb2.whereNull("deadline_at").orWhere("deadline_at", ">", this.knex.raw("NOW()"));
+		}).orderByRaw("CASE WHEN status = 'pending' THEN 0 ELSE 1 END").orderBy("available_at", "asc").orderBy("created_at", "asc").limit(1).forUpdate().skipLocked()).withSchema(DEFAULT_SCHEMA).table("workflow_runs as wr").where("wr.namespace_id", this.namespaceId).where("wr.id", this.knex.ref("candidate.id")).update({
+			status: "running",
+			attempts: this.knex.raw("wr.attempts + 1"),
+			worker_id: params.workerId,
+			available_at: this.knex.raw(`NOW() + ${params.leaseDurationMs} * INTERVAL '1 millisecond'`),
+			started_at: this.knex.raw("COALESCE(wr.started_at, NOW())"),
+			updated_at: this.knex.raw("NOW()")
+		}).updateFrom("candidate").returning("wr.*"))[0] ?? null;
+	}
+	async extendWorkflowRunLease(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Extending workflow run lease: {workflowRunId}, {workerId}, {leaseDurationMs}", {
+			workflowRunId: params.workflowRunId,
+			workerId: params.workerId,
+			leaseDurationMs: params.leaseDurationMs
+		});
+		const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).where("status", "running").where("worker_id", params.workerId).update({
+			available_at: this.knex.raw(`NOW() + ${params.leaseDurationMs} * INTERVAL '1 millisecond'`),
+			updated_at: this.knex.fn.now()
+		}).returning("*");
+		if (!updated) {
+			const wr = await this.getWorkflowRun({ workflowRunId: params.workflowRunId });
+			if (wr && (wr.status === "paused" || wr.status === "canceled")) throw new Error("Workflow run is paused or canceled");
+			logger.error("Failed to extend lease for workflow run: {params}", { params });
+			throw new Error("Failed to extend lease for workflow run");
+		}
+		return updated;
+	}
+	async sleepWorkflowRun(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Sleeping workflow run: {workflowRunId}, {workerId}, {availableAt}", {
+			workflowRunId: params.workflowRunId,
+			workerId: params.workerId,
+			availableAt: params.availableAt
+		});
+		const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).whereNotIn("status", [
+			"succeeded",
+			"completed",
+			"failed",
+			"canceled"
+		]).where("worker_id", params.workerId).update({
+			status: "sleeping",
+			available_at: params.availableAt,
+			worker_id: null,
+			updated_at: this.knex.fn.now()
+		}).returning("*");
+		if (!updated) {
+			logger.error("Failed to sleep workflow run: {params}", { params });
+			throw new Error("Failed to sleep workflow run");
+		}
+		return updated;
+	}
+	async completeWorkflowRun(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Completing workflow run: {workflowRunId}, {workerId}, {output}", {
+			workflowRunId: params.workflowRunId,
+			workerId: params.workerId,
+			output: params.output
+		});
+		const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).where("status", "running").where("worker_id", params.workerId).update({
+			status: "completed",
+			output: JSON.stringify(params.output),
+			error: null,
+			worker_id: params.workerId,
+			available_at: null,
+			finished_at: this.knex.fn.now(),
+			updated_at: this.knex.fn.now()
+		}).returning("*");
+		if (!updated) {
+			logger.error("Failed to complete workflow run: {params}", { params });
+			throw new Error("Failed to complete workflow run");
+		}
+		return updated;
+	}
+	async failWorkflowRun(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		const { workflowRunId, error, forceComplete, customDelayMs } = params;
+		logger.info("Failing workflow run: {workflowRunId}, {workerId}, {error}", {
+			workflowRunId: params.workflowRunId,
+			workerId: params.workerId,
+			error: params.error
+		});
+		const workflowRun = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", workflowRunId).first();
+		if (!workflowRun) throw new Error("Workflow run not found");
+		const savedRetryPolicy = (typeof workflowRun.config === "string" ? JSON.parse(workflowRun.config) : workflowRun.config)?.retryPolicy;
+		const { initialIntervalMs, backoffCoefficient, maximumIntervalMs, maxAttempts } = mergeRetryPolicy(savedRetryPolicy);
+		const currentAttempts = workflowRun.attempts ?? 0;
+		if (forceComplete || currentAttempts >= maxAttempts) {
+			const [updated$1] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", workflowRunId).where("status", "running").where("worker_id", params.workerId).update({
+				status: "failed",
+				available_at: null,
+				finished_at: this.knex.fn.now(),
+				error: JSON.stringify(error),
+				worker_id: null,
+				started_at: null,
+				updated_at: this.knex.fn.now()
+			}).returning("*");
+			if (!updated$1) {
+				logger.error("Failed to mark workflow run failed: {params}", { params });
+				throw new Error("Failed to mark workflow run failed");
+			}
+			return updated$1;
+		}
+		const retryIntervalExpr = customDelayMs ? `${customDelayMs} * INTERVAL '1 millisecond'` : `LEAST(${initialIntervalMs} * POWER(${backoffCoefficient}, "attempts" - 1), ${maximumIntervalMs}) * INTERVAL '1 millisecond'`;
+		const deadlineExceededCondition = `"deadline_at" IS NOT NULL AND NOW() + (${retryIntervalExpr}) >= "deadline_at"`;
+		const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", workflowRunId).where("status", "running").where("worker_id", params.workerId).update({
+			status: this.knex.raw(`CASE WHEN ${deadlineExceededCondition} THEN 'failed' ELSE 'pending' END`),
+			available_at: this.knex.raw(`CASE WHEN ${deadlineExceededCondition} THEN NULL ELSE NOW() + (${retryIntervalExpr}) END`),
+			finished_at: this.knex.raw(`CASE WHEN ${deadlineExceededCondition} THEN NOW() ELSE NULL END`),
+			error: JSON.stringify(error),
+			worker_id: null,
+			started_at: null,
+			updated_at: this.knex.fn.now()
+		}).returning("*");
+		if (!updated) {
+			logger.error("Failed to mark workflow run failed: {params}", { params });
+			throw new Error("Failed to mark workflow run failed");
+		}
+		return updated;
+	}
+	async cancelWorkflowRun(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Canceling workflow run: {workflowRunId}", { workflowRunId: params.workflowRunId });
+		const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).whereIn("status", [
+			"pending",
+			"running",
+			"sleeping",
+			"paused"
+		]).update({
+			status: "canceled",
+			worker_id: null,
+			available_at: null,
+			finished_at: this.knex.fn.now(),
+			updated_at: this.knex.fn.now()
+		}).returning("*");
+		if (!updated) {
+			const existing = await this.getWorkflowRun({ workflowRunId: params.workflowRunId });
+			if (!existing) throw new Error(`Workflow run ${params.workflowRunId} does not exist`);
+			if (existing.status === "canceled") return existing;
+			if ([
+				"succeeded",
+				"completed",
+				"failed"
+			].includes(existing.status)) {
+				logger.error("Cannot cancel workflow run: {params} with status {status}", {
+					params,
+					status: existing.status
+				});
+				throw new Error(`Cannot cancel workflow run ${params.workflowRunId} with status ${existing.status}`);
+			}
+			logger.error("Failed to cancel workflow run: {params}", { params });
+			throw new Error("Failed to cancel workflow run");
+		}
+		return updated;
+	}
+	async pauseWorkflowRun(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Pausing workflow run: {workflowRunId}", { workflowRunId: params.workflowRunId });
+		const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).whereIn("status", [
+			"pending",
+			"running",
+			"sleeping"
+		]).update({
+			status: "paused",
+			worker_id: null,
+			available_at: null,
+			updated_at: this.knex.fn.now()
+		}).returning("*");
+		if (!updated) {
+			const existing = await this.getWorkflowRun({ workflowRunId: params.workflowRunId });
+			if (!existing) throw new Error(`Workflow run ${params.workflowRunId} does not exist`);
+			if (existing.status === "paused") return existing;
+			if ([
+				"succeeded",
+				"completed",
+				"failed",
+				"canceled"
+			].includes(existing.status)) {
+				logger.error("Cannot pause workflow run: {params} with status {status}", {
+					params,
+					status: existing.status
+				});
+				throw new Error(`Cannot pause workflow run ${params.workflowRunId} with status ${existing.status}`);
+			}
+			logger.error("Failed to pause workflow run: {params}", { params });
+			throw new Error("Failed to pause workflow run");
+		}
+		return updated;
+	}
+	async resumeWorkflowRun(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Resuming workflow run: {workflowRunId}", { workflowRunId: params.workflowRunId });
+		const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("workflow_runs").where("namespace_id", this.namespaceId).where("id", params.workflowRunId).where("status", "paused").update({
+			status: "pending",
+			available_at: this.knex.fn.now(),
+			updated_at: this.knex.fn.now()
+		}).returning("*");
+		if (!updated) {
+			const existing = await this.getWorkflowRun({ workflowRunId: params.workflowRunId });
+			if (!existing) throw new Error(`Workflow run ${params.workflowRunId} does not exist`);
+			if (existing.status === "pending" || existing.status === "running") return existing;
+			if ([
+				"succeeded",
+				"completed",
+				"failed",
+				"canceled"
+			].includes(existing.status)) {
+				logger.error("Cannot resume workflow run: {params} with status {status}", {
+					params,
+					status: existing.status
+				});
+				throw new Error(`Cannot resume workflow run ${params.workflowRunId} with status ${existing.status}`);
+			}
+			logger.error("Failed to resume workflow run: {params}", { params });
+			throw new Error("Failed to resume workflow run");
+		}
+		return updated;
+	}
+	async createStepAttempt(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Creating step attempt: {workflowRunId}, {stepName}, {kind}", {
+			workflowRunId: params.workflowRunId,
+			stepName: params.stepName,
+			kind: params.kind
+		});
+		const [stepAttempt] = await this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts").insert({
+			namespace_id: this.namespaceId,
+			id: crypto.randomUUID(),
+			workflow_run_id: params.workflowRunId,
+			step_name: params.stepName,
+			kind: params.kind,
+			status: "running",
+			config: JSON.stringify(params.config),
+			context: JSON.stringify(params.context),
+			started_at: this.knex.fn.now(),
+			created_at: this.knex.raw("date_trunc('milliseconds', NOW())"),
+			updated_at: this.knex.fn.now()
+		}).returning("*");
+		if (!stepAttempt) {
+			logger.error("Failed to create step attempt: {params}", { params });
+			throw new Error("Failed to create step attempt");
+		}
+		return stepAttempt;
+	}
+	async getStepAttempt(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Getting step attempt: {stepAttemptId}", { stepAttemptId: params.stepAttemptId });
+		return await this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts").where("namespace_id", this.namespaceId).where("id", params.stepAttemptId).first() ?? null;
+	}
+	async listStepAttempts(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Listing step attempts: {workflowRunId}, {after}, {before}", {
+			workflowRunId: params.workflowRunId,
+			after: params.after,
+			before: params.before
+		});
+		const limit = params.limit ?? DEFAULT_PAGINATION_PAGE_SIZE;
+		const { after, before } = params;
+		const order = params.order ?? "asc";
+		const reverseOrder = order === "asc" ? "desc" : "asc";
+		let cursor = null;
+		if (after) cursor = decodeCursor(after);
+		else if (before) cursor = decodeCursor(before);
+		const rows = await this.buildListStepAttemptsWhere(params, cursor, order).orderBy("created_at", before ? reverseOrder : order).orderBy("id", before ? reverseOrder : order).limit(limit + 1);
+		return this.processPaginationResults(rows, limit, typeof after === "string", typeof before === "string");
+	}
+	buildListStepAttemptsWhere(params, cursor, order) {
+		const { after } = params;
+		const qb = this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts").where("namespace_id", this.namespaceId).where("workflow_run_id", params.workflowRunId);
+		if (cursor) {
+			const operator = order === "asc" === !!after ? ">" : "<";
+			return qb.whereRaw(`("created_at", "id") ${operator} (?, ?)`, [cursor.createdAt.toISOString(), cursor.id]);
+		}
+		return qb;
+	}
+	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];
+		return {
+			data,
+			pagination: {
+				next: nextCursor,
+				prev: hasPrev && firstItem ? encodeCursor(firstItem) : null
+			}
+		};
+	}
+	async completeStepAttempt(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Marking step attempt as completed: {workflowRunId}, {stepAttemptId}, {workerId}", {
+			workflowRunId: params.workflowRunId,
+			stepAttemptId: params.stepAttemptId,
+			workerId: params.workerId
+		});
+		const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts as sa").update({
+			status: "completed",
+			output: JSON.stringify(params.output),
+			error: null,
+			finished_at: this.knex.fn.now(),
+			updated_at: this.knex.fn.now()
+		}).updateFrom(`${DEFAULT_SCHEMA}.workflow_runs as wr`).where("sa.namespace_id", this.namespaceId).where("sa.workflow_run_id", params.workflowRunId).where("sa.id", params.stepAttemptId).where("sa.status", "running").where("wr.namespace_id", this.knex.ref("sa.namespace_id")).where("wr.id", this.knex.ref("sa.workflow_run_id")).where("wr.status", "running").where("wr.worker_id", params.workerId).returning("sa.*");
+		if (!updated) return this.handleStepAttemptUpdateMiss("completed", params);
+		return updated;
+	}
+	async failStepAttempt(params) {
+		if (!this.initialized) throw new Error("Backend not initialized");
+		logger.info("Marking step attempt as failed: {workflowRunId}, {stepAttemptId}, {workerId}", {
+			workflowRunId: params.workflowRunId,
+			stepAttemptId: params.stepAttemptId,
+			workerId: params.workerId
+		});
+		logger.info("Error: {error.message}", { error: params.error.message });
+		const [updated] = await this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts as sa").update({
+			status: "failed",
+			output: null,
+			error: JSON.stringify(params.error),
+			finished_at: this.knex.fn.now(),
+			updated_at: this.knex.fn.now()
+		}).updateFrom(`${DEFAULT_SCHEMA}.workflow_runs as wr`).where("sa.namespace_id", this.namespaceId).where("sa.workflow_run_id", params.workflowRunId).where("sa.id", params.stepAttemptId).where("sa.status", "running").where("wr.namespace_id", this.knex.ref("sa.namespace_id")).where("wr.id", this.knex.ref("sa.workflow_run_id")).where("wr.status", "running").where("wr.worker_id", params.workerId).returning("sa.*");
+		if (!updated) return this.handleStepAttemptUpdateMiss("failed", params);
+		return updated;
+	}
+	/**
+	* completeStepAttempt/failStepAttempt에서 UPDATE가 0건일 때,
+	* 외부 상태 변경(pause/cancel)에 의한 것인지 판단합니다.
+	* - 외부 상태 변경이면 해당 step의 상태도 워크플로우와 동일하게 맞추고 null을 반환합니다.
+	* - 그 외에는 예상하지 못한 상황이므로 에러를 throw합니다.
+	*/
+	async handleStepAttemptUpdateMiss(method, params) {
+		const wr = await this.getWorkflowRun({ workflowRunId: params.workflowRunId });
+		if (wr && (wr.status === "paused" || wr.status === "canceled")) {
+			await this.knex.withSchema(DEFAULT_SCHEMA).table("step_attempts").where("namespace_id", this.namespaceId).where("id", params.stepAttemptId).whereIn("status", ["running", "paused"]).update({
+				status: wr.status,
+				updated_at: this.knex.fn.now()
+			});
+			return null;
+		}
+		logger.error("Failed to mark step attempt {method}: {params}", {
+			method,
+			params
+		});
+		throw new Error(`Failed to mark step attempt ${method}`);
+	}
+};
 function encodeCursor(item) {
-    const encoded = Buffer.from(JSON.stringify({
-        createdAt: item.createdAt.toISOString(),
-        id: item.id
-    })).toString("base64");
-    return encoded;
+	return Buffer.from(JSON.stringify({
+		createdAt: item.createdAt.toISOString(),
+		id: item.id
+	})).toString("base64");
 }
-export 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
-    };
+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
+	};
 }
 
+//#endregion
+export { BackendPostgres };
 //# sourceMappingURL=backend.js.map