@tanstack/workflow-store-drizzle-postgres 0.0.1

package/dist/store.js

@@ -0,0 +1,934 @@
+import { LogConflictError } from "@tanstack/workflow-core";
+import { sql } from "drizzle-orm";
+
+//#region src/store.ts
+const defaultDrizzlePostgresWorkflowStoreTables = {
+	runs: "workflow_runs",
+	runStates: "workflow_run_states",
+	eventLocks: "workflow_event_locks",
+	events: "workflow_events",
+	timers: "workflow_timers",
+	signalDeliveries: "workflow_signal_deliveries",
+	schedules: "workflow_schedules",
+	scheduleBuckets: "workflow_schedule_buckets"
+};
+function createDrizzlePostgresWorkflowStore(options) {
+	const tableNames = {
+		...defaultDrizzlePostgresWorkflowStoreTables,
+		...options.tables
+	};
+	const tableSql = tableSqls(options.schema, tableNames);
+	const db = options.db;
+	return {
+		async ensureSchema() {
+			for (const statement of schemaStatements(options.schema, tableNames)) await db.execute(sql.raw(statement));
+		},
+		async createRun(args) {
+			const rows = await queryRows(db, sql`
+          insert into ${tableSql.runs} (
+            run_id,
+            workflow_id,
+            workflow_version,
+            status,
+            input,
+            created_at,
+            updated_at
+          )
+          values (
+            ${args.runId},
+            ${args.workflowId},
+            ${args.workflowVersion ?? null},
+            'queued',
+            ${encodeJson(args.input)}::jsonb,
+            ${args.now},
+            ${args.now}
+          )
+          on conflict (run_id) do nothing
+          returning *
+        `);
+			if (rows[0]) return {
+				kind: "created",
+				run: runFromRow(rows[0])
+			};
+			const existing = await loadRunById(db, tableSql, args.runId);
+			if (!existing) throw new Error(`Run "${args.runId}" was not inserted or loaded.`);
+			return {
+				kind: "existing",
+				run: existing
+			};
+		},
+		loadRun(runId) {
+			return loadRunById(db, tableSql, runId);
+		},
+		async loadExecution(runId) {
+			const run = await loadRunById(db, tableSql, runId);
+			if (!run) return void 0;
+			return {
+				run,
+				events: await readStoredEvents(db, tableSql, { runId })
+			};
+		},
+		async loadRunState(runId) {
+			return loadRunStateById(db, tableSql, runId);
+		},
+		async saveRunState(args) {
+			const state = args.state;
+			await withTransaction(db, async (tx) => {
+				await tx.execute(sql`
+          insert into ${tableSql.runStates} (
+            run_id,
+            workflow_id,
+            workflow_version,
+            status,
+            input,
+            output,
+            error,
+            waiting_for,
+            pending_approval,
+            created_at,
+            updated_at
+          )
+          values (
+            ${state.runId},
+            ${state.workflowId},
+            ${state.workflowVersion ?? null},
+            ${state.status},
+            ${encodeJson(state.input)}::jsonb,
+            ${encodeJsonOrNull(state.output)}::jsonb,
+            ${encodeJsonOrNull(state.error)}::jsonb,
+            ${encodeJsonOrNull(state.waitingFor)}::jsonb,
+            ${encodeJsonOrNull(state.pendingApproval)}::jsonb,
+            ${state.createdAt},
+            ${state.updatedAt}
+          )
+          on conflict (run_id) do update set
+            workflow_id = excluded.workflow_id,
+            workflow_version = excluded.workflow_version,
+            status = excluded.status,
+            input = excluded.input,
+            output = excluded.output,
+            error = excluded.error,
+            waiting_for = excluded.waiting_for,
+            pending_approval = excluded.pending_approval,
+            created_at = excluded.created_at,
+            updated_at = excluded.updated_at
+        `);
+				await tx.execute(sql`
+          insert into ${tableSql.runs} (
+            run_id,
+            workflow_id,
+            workflow_version,
+            status,
+            input,
+            output,
+            error,
+            waiting_for,
+            pending_approval,
+            wake_at,
+            created_at,
+            updated_at
+          )
+          values (
+            ${state.runId},
+            ${state.workflowId},
+            ${state.workflowVersion ?? null},
+            ${state.status},
+            ${encodeJson(state.input)}::jsonb,
+            ${encodeJsonOrNull(state.output)}::jsonb,
+            ${encodeJsonOrNull(state.error)}::jsonb,
+            ${encodeJsonOrNull(state.waitingFor)}::jsonb,
+            ${encodeJsonOrNull(state.pendingApproval)}::jsonb,
+            ${state.waitingFor?.signalName === "__timer" ? state.waitingFor.deadline : null},
+            ${state.createdAt},
+            ${state.updatedAt}
+          )
+          on conflict (run_id) do update set
+            workflow_id = excluded.workflow_id,
+            workflow_version = excluded.workflow_version,
+            status = excluded.status,
+            input = excluded.input,
+            output = excluded.output,
+            error = excluded.error,
+            waiting_for = excluded.waiting_for,
+            pending_approval = excluded.pending_approval,
+            wake_at = excluded.wake_at,
+            created_at = excluded.created_at,
+            updated_at = excluded.updated_at
+        `);
+			});
+		},
+		async deleteRun(runId, _reason) {
+			await withTransaction(db, async (tx) => {
+				await tx.execute(sql`
+          delete from ${tableSql.runStates}
+          where run_id = ${runId}
+        `);
+				await tx.execute(sql`
+          delete from ${tableSql.eventLocks}
+          where run_id = ${runId}
+        `);
+				await tx.execute(sql`
+          delete from ${tableSql.signalDeliveries}
+          where run_id = ${runId}
+        `);
+				await tx.execute(sql`
+          delete from ${tableSql.timers}
+          where run_id = ${runId}
+        `);
+				await tx.execute(sql`
+          delete from ${tableSql.events}
+          where run_id = ${runId}
+        `);
+				await tx.execute(sql`
+          delete from ${tableSql.runs}
+          where run_id = ${runId}
+        `);
+			});
+		},
+		async appendEvents(args) {
+			return withTransaction(db, async (tx) => {
+				await tx.execute(sql`
+          insert into ${tableSql.eventLocks} (run_id, created_at)
+          values (${args.runId}, ${Date.now()})
+          on conflict (run_id) do nothing
+        `);
+				await queryRows(tx, sql`
+            select run_id
+            from ${tableSql.eventLocks}
+            where run_id = ${args.runId}
+            for update
+          `);
+				const countRows = await queryRows(tx, sql`
+            select count(*)::int as count
+            from ${tableSql.events}
+            where run_id = ${args.runId}
+          `);
+				if (Number(countRows[0]?.count ?? 0) !== args.expectedNextIndex) {
+					const conflict = await queryRows(tx, sql`
+              select *
+              from ${tableSql.events}
+              where run_id = ${args.runId}
+                and event_index = ${args.expectedNextIndex}
+              limit 1
+            `);
+					throw new LogConflictError(args.runId, args.expectedNextIndex, conflict[0] ? eventFromRow(conflict[0]).event : void 0);
+				}
+				let nextIndex = args.expectedNextIndex;
+				for (const event of args.events) {
+					await tx.execute(sql`
+            insert into ${tableSql.events} (
+              run_id,
+              event_index,
+              event_type,
+              step_id,
+              event,
+              created_at
+            )
+            values (
+              ${args.runId},
+              ${nextIndex},
+              ${event.type},
+              ${getStepId(event) ?? null},
+              ${encodeJson(event)}::jsonb,
+              ${event.ts}
+            )
+          `);
+					nextIndex++;
+				}
+				return { nextIndex };
+			});
+		},
+		readEvents(args) {
+			return readStoredEvents(db, tableSql, args);
+		},
+		async claimRun(args) {
+			const rows = await queryRows(db, sql`
+          update ${tableSql.runs}
+          set
+            status = 'running',
+            lease_owner = ${args.leaseOwner},
+            lease_expires_at = ${args.now + args.leaseMs},
+            updated_at = ${args.now}
+          where run_id = ${args.runId}
+            and status not in ('finished', 'errored', 'aborted')
+            and (
+              lease_owner is null
+              or lease_owner = ${args.leaseOwner}
+              or lease_expires_at <= ${args.now}
+            )
+          returning *
+        `);
+			if (rows[0]) return {
+				kind: "claimed",
+				run: runFromRow(rows[0])
+			};
+			const run = await loadRunById(db, tableSql, args.runId);
+			return run ? {
+				kind: "not-claimable",
+				run
+			} : { kind: "not-found" };
+		},
+		async heartbeatRunLease(args) {
+			await db.execute(sql`
+        update ${tableSql.runs}
+        set
+          lease_expires_at = ${args.now + args.leaseMs},
+          updated_at = ${args.now}
+        where run_id = ${args.runId}
+          and lease_owner = ${args.leaseOwner}
+      `);
+		},
+		async releaseRunLease(args) {
+			await db.execute(sql`
+        update ${tableSql.runs}
+        set
+          lease_owner = null,
+          lease_expires_at = null
+        where run_id = ${args.runId}
+          and lease_owner = ${args.leaseOwner}
+      `);
+		},
+		async markRunPaused(args) {
+			await db.execute(sql`
+        update ${tableSql.runs}
+        set
+          status = 'paused',
+          waiting_for = ${encodeJsonOrNull(args.waitingFor)}::jsonb,
+          pending_approval = ${encodeJsonOrNull(args.pendingApproval)}::jsonb,
+          wake_at = ${args.wakeAt ?? null},
+          lease_owner = null,
+          lease_expires_at = null,
+          updated_at = ${args.now}
+        where run_id = ${args.runId}
+      `);
+		},
+		async markRunFinished(args) {
+			await db.execute(sql`
+        update ${tableSql.runs}
+        set
+          status = 'finished',
+          output = ${encodeJson(args.output)}::jsonb,
+          waiting_for = null,
+          pending_approval = null,
+          wake_at = null,
+          lease_owner = null,
+          lease_expires_at = null,
+          updated_at = ${args.now}
+        where run_id = ${args.runId}
+      `);
+		},
+		async markRunErrored(args) {
+			args.code;
+			await db.execute(sql`
+        update ${tableSql.runs}
+        set
+          status = 'errored',
+          error = ${encodeJson(args.error)}::jsonb,
+          waiting_for = null,
+          pending_approval = null,
+          wake_at = null,
+          lease_owner = null,
+          lease_expires_at = null,
+          updated_at = ${args.now}
+        where run_id = ${args.runId}
+      `);
+		},
+		async scheduleTimer(args) {
+			await withTransaction(db, async (tx) => {
+				await tx.execute(sql`
+          insert into ${tableSql.timers} (
+            run_id,
+            signal_id,
+            workflow_id,
+            workflow_version,
+            wake_at
+          )
+          values (
+            ${args.runId},
+            ${args.signalId},
+            ${args.workflowId},
+            ${args.workflowVersion ?? null},
+            ${args.wakeAt}
+          )
+          on conflict (run_id, signal_id) do update set
+            workflow_id = excluded.workflow_id,
+            workflow_version = excluded.workflow_version,
+            wake_at = excluded.wake_at,
+            lease_owner = null,
+            lease_expires_at = null
+        `);
+				await tx.execute(sql`
+          update ${tableSql.runs}
+          set
+            wake_at = ${args.wakeAt},
+            updated_at = ${args.now}
+          where run_id = ${args.runId}
+        `);
+			});
+		},
+		async claimDueTimers(args) {
+			return (await queryRows(db, sql`
+          with due as (
+            select run_id, signal_id
+            from ${tableSql.timers}
+            where wake_at <= ${args.now}
+              and (
+                lease_owner is null
+                or lease_owner = ${args.leaseOwner}
+                or lease_expires_at <= ${args.now}
+              )
+            order by wake_at asc, run_id asc, signal_id asc
+            limit ${args.limit}
+            for update skip locked
+          )
+          update ${tableSql.timers} timer
+          set
+            lease_owner = ${args.leaseOwner},
+            lease_expires_at = ${args.now + args.leaseMs}
+          from due
+          where timer.run_id = due.run_id
+            and timer.signal_id = due.signal_id
+          returning timer.*
+        `)).map(timerFromRow);
+		},
+		async deliverSignal(args) {
+			return withTransaction(db, async (tx) => {
+				const run = await loadRunById(tx, tableSql, args.runId);
+				if (!run) return { kind: "not-found" };
+				if (await loadSignalDelivery(tx, tableSql, args.runId, args.delivery.signalId)) return {
+					kind: "duplicate",
+					run
+				};
+				if (run.waitingFor?.signalName !== args.delivery.name) return {
+					kind: "not-waiting",
+					run
+				};
+				if (!await insertSignalDelivery(tx, tableSql, args.runId, args.delivery.signalId, args.now)) return {
+					kind: "duplicate",
+					run
+				};
+				await tx.execute(sql`
+          delete from ${tableSql.timers}
+          where run_id = ${args.runId}
+            and signal_id = ${args.delivery.signalId}
+        `);
+				return {
+					kind: "delivered",
+					run: runFromRow((await queryRows(tx, sql`
+            update ${tableSql.runs}
+            set
+              status = 'queued',
+              waiting_for = null,
+              pending_approval = null,
+              wake_at = null,
+              updated_at = ${args.now}
+            where run_id = ${args.runId}
+            returning *
+          `))[0])
+				};
+			});
+		},
+		async deliverApproval(args) {
+			return withTransaction(db, async (tx) => {
+				const run = await loadRunById(tx, tableSql, args.runId);
+				if (!run) return { kind: "not-found" };
+				const signalId = `approval:${args.approval.approvalId}`;
+				if (await loadSignalDelivery(tx, tableSql, args.runId, signalId)) return {
+					kind: "duplicate",
+					run
+				};
+				if (run.pendingApproval?.approvalId !== args.approval.approvalId) return {
+					kind: "not-waiting",
+					run
+				};
+				if (!await insertSignalDelivery(tx, tableSql, args.runId, signalId, args.now)) return {
+					kind: "duplicate",
+					run
+				};
+				return {
+					kind: "delivered",
+					run: runFromRow((await queryRows(tx, sql`
+            update ${tableSql.runs}
+            set
+              status = 'queued',
+              waiting_for = null,
+              pending_approval = null,
+              wake_at = null,
+              updated_at = ${args.now}
+            where run_id = ${args.runId}
+            returning *
+          `))[0])
+				};
+			});
+		},
+		async upsertSchedule(args) {
+			await db.execute(sql`
+        insert into ${tableSql.schedules} (
+          schedule_id,
+          workflow_id,
+          workflow_version,
+          schedule,
+          overlap_policy,
+          input,
+          next_fire_at,
+          enabled,
+          updated_at
+        )
+        values (
+          ${args.scheduleId},
+          ${args.workflowId},
+          ${args.workflowVersion ?? null},
+          ${encodeJson(args.schedule)}::jsonb,
+          ${args.overlapPolicy},
+          ${encodeJsonOrNull(args.input)}::jsonb,
+          ${args.nextFireAt ?? null},
+          ${args.enabled},
+          ${args.now}
+        )
+        on conflict (schedule_id) do update set
+          workflow_id = excluded.workflow_id,
+          workflow_version = excluded.workflow_version,
+          schedule = excluded.schedule,
+          overlap_policy = excluded.overlap_policy,
+          input = excluded.input,
+          next_fire_at = excluded.next_fire_at,
+          enabled = excluded.enabled,
+          updated_at = excluded.updated_at
+      `);
+		},
+		async claimDueScheduleBuckets(args) {
+			const schedules = await queryRows(db, sql`
+          select *
+          from ${tableSql.schedules}
+          where enabled = true
+            and next_fire_at is not null
+            and next_fire_at <= ${args.now}
+          order by next_fire_at asc, schedule_id asc
+          limit ${args.limit}
+        `);
+			const buckets = [];
+			for (const scheduleRow of schedules) {
+				if (buckets.length >= args.limit) break;
+				const schedule = scheduleFromRow(scheduleRow);
+				const bucketId = `${schedule.nextFireAt}`;
+				const runId = `${schedule.workflowId}:${schedule.scheduleId}:${bucketId}`;
+				await db.execute(sql`
+          insert into ${tableSql.scheduleBuckets} (
+            schedule_id,
+            bucket_id,
+            workflow_id,
+            workflow_version,
+            run_id,
+            fire_at,
+            input,
+            overlap_policy,
+            status
+          )
+          values (
+            ${schedule.scheduleId},
+            ${bucketId},
+            ${schedule.workflowId},
+            ${schedule.workflowVersion ?? null},
+            ${runId},
+            ${schedule.nextFireAt},
+            ${encodeJsonOrNull(schedule.input)}::jsonb,
+            ${schedule.overlapPolicy},
+            'claimed'
+          )
+          on conflict (schedule_id, bucket_id) do nothing
+        `);
+				const rows = await queryRows(db, sql`
+            update ${tableSql.scheduleBuckets}
+            set
+              lease_owner = ${args.leaseOwner},
+              lease_expires_at = ${args.now + args.leaseMs}
+            where schedule_id = ${schedule.scheduleId}
+              and bucket_id = ${bucketId}
+              and status <> 'started'
+              and (
+                lease_owner is null
+                or lease_owner = ${args.leaseOwner}
+                or lease_expires_at <= ${args.now}
+              )
+            returning *
+          `);
+				if (rows[0]) buckets.push(scheduleBucketFromRow(rows[0]));
+			}
+			return buckets;
+		},
+		async markScheduleBucketStarted(args) {
+			await db.execute(sql`
+        update ${tableSql.scheduleBuckets}
+        set
+          run_id = ${args.runId},
+          status = 'started',
+          started_at = ${args.now}
+        where schedule_id = ${args.scheduleId}
+          and bucket_id = ${args.bucketId}
+      `);
+		},
+		async claimStaleRuns(args) {
+			return (await queryRows(db, sql`
+          with stale as (
+            select run_id
+            from ${tableSql.runs}
+            where status = 'running'
+              and lease_expires_at is not null
+              and lease_expires_at <= ${args.now}
+            order by updated_at asc, run_id asc
+            limit ${args.limit}
+            for update skip locked
+          )
+          update ${tableSql.runs} run
+          set
+            lease_owner = ${args.leaseOwner},
+            lease_expires_at = ${args.now + args.leaseMs},
+            updated_at = ${args.now}
+          from stale
+          where run.run_id = stale.run_id
+          returning run.*
+        `)).map((row) => {
+				const run = runFromRow(row);
+				return {
+					run,
+					lease: run.lease
+				};
+			});
+		},
+		async listRuns(args) {
+			const offset = args.cursor ? Number(args.cursor) : 0;
+			const start = Number.isFinite(offset) && offset > 0 ? offset : 0;
+			return (await queryRows(db, sql`
+          select *
+          from ${tableSql.runs}
+          where (${args.workflowId ?? null}::text is null or workflow_id = ${args.workflowId ?? null})
+            and (${args.status ?? null}::text is null or status = ${args.status ?? null})
+          order by updated_at desc, run_id asc
+          limit ${args.limit}
+          offset ${start}
+        `)).map(toRunSummary);
+		},
+		async getRunTimeline(runId) {
+			const run = await loadRunById(db, tableSql, runId);
+			if (!run) return void 0;
+			return {
+				run,
+				events: await readStoredEvents(db, tableSql, { runId })
+			};
+		}
+	};
+}
+function tableSqls(schema, tables) {
+	return {
+		runs: sql.raw(qualifiedTableName(schema, tables.runs)),
+		runStates: sql.raw(qualifiedTableName(schema, tables.runStates)),
+		eventLocks: sql.raw(qualifiedTableName(schema, tables.eventLocks)),
+		events: sql.raw(qualifiedTableName(schema, tables.events)),
+		timers: sql.raw(qualifiedTableName(schema, tables.timers)),
+		signalDeliveries: sql.raw(qualifiedTableName(schema, tables.signalDeliveries)),
+		schedules: sql.raw(qualifiedTableName(schema, tables.schedules)),
+		scheduleBuckets: sql.raw(qualifiedTableName(schema, tables.scheduleBuckets))
+	};
+}
+function schemaStatements(schema, tables) {
+	const runs = qualifiedTableName(schema, tables.runs);
+	const runStates = qualifiedTableName(schema, tables.runStates);
+	const eventLocks = qualifiedTableName(schema, tables.eventLocks);
+	const events = qualifiedTableName(schema, tables.events);
+	const timers = qualifiedTableName(schema, tables.timers);
+	const signalDeliveries = qualifiedTableName(schema, tables.signalDeliveries);
+	const schedules = qualifiedTableName(schema, tables.schedules);
+	const scheduleBuckets = qualifiedTableName(schema, tables.scheduleBuckets);
+	return [
+		...schema ? [`create schema if not exists ${quoteIdent(schema)}`] : [],
+		`create table if not exists ${runs} (
+      run_id text primary key,
+      workflow_id text not null,
+      workflow_version text,
+      status text not null,
+      input jsonb not null,
+      output jsonb,
+      error jsonb,
+      waiting_for jsonb,
+      pending_approval jsonb,
+      wake_at bigint,
+      lease_owner text,
+      lease_expires_at bigint,
+      created_at bigint not null,
+      updated_at bigint not null
+    )`,
+		`create index if not exists ${quoteIdent(`${tables.runs}_status_idx`)}
+      on ${runs} (status, updated_at)`,
+		`create index if not exists ${quoteIdent(`${tables.runs}_lease_idx`)}
+      on ${runs} (status, lease_expires_at)`,
+		`create table if not exists ${runStates} (
+      run_id text primary key,
+      workflow_id text not null,
+      workflow_version text,
+      status text not null,
+      input jsonb not null,
+      output jsonb,
+      error jsonb,
+      waiting_for jsonb,
+      pending_approval jsonb,
+      created_at bigint not null,
+      updated_at bigint not null
+    )`,
+		`create table if not exists ${eventLocks} (
+      run_id text primary key,
+      created_at bigint not null
+    )`,
+		`create table if not exists ${events} (
+      run_id text not null,
+      event_index integer not null,
+      event_type text not null,
+      step_id text,
+      event jsonb not null,
+      created_at bigint not null,
+      primary key (run_id, event_index)
+    )`,
+		`create index if not exists ${quoteIdent(`${tables.events}_type_idx`)}
+      on ${events} (run_id, event_type)`,
+		`create table if not exists ${timers} (
+      run_id text not null,
+      signal_id text not null,
+      workflow_id text not null,
+      workflow_version text,
+      wake_at bigint not null,
+      lease_owner text,
+      lease_expires_at bigint,
+      primary key (run_id, signal_id)
+    )`,
+		`create index if not exists ${quoteIdent(`${tables.timers}_due_idx`)}
+      on ${timers} (wake_at, lease_expires_at)`,
+		`create table if not exists ${signalDeliveries} (
+      run_id text not null,
+      signal_id text not null,
+      created_at bigint not null,
+      primary key (run_id, signal_id)
+    )`,
+		`create table if not exists ${schedules} (
+      schedule_id text primary key,
+      workflow_id text not null,
+      workflow_version text,
+      schedule jsonb not null,
+      overlap_policy text not null,
+      input jsonb,
+      next_fire_at bigint,
+      enabled boolean not null,
+      updated_at bigint not null
+    )`,
+		`create index if not exists ${quoteIdent(`${tables.schedules}_due_idx`)}
+      on ${schedules} (enabled, next_fire_at)`,
+		`create table if not exists ${scheduleBuckets} (
+      schedule_id text not null,
+      bucket_id text not null,
+      workflow_id text not null,
+      workflow_version text,
+      run_id text not null,
+      fire_at bigint not null,
+      input jsonb,
+      overlap_policy text not null,
+      status text not null,
+      lease_owner text,
+      lease_expires_at bigint,
+      started_at bigint,
+      primary key (schedule_id, bucket_id)
+    )`,
+		`create index if not exists ${quoteIdent(`${tables.scheduleBuckets}_lease_idx`)}
+      on ${scheduleBuckets} (status, fire_at, lease_expires_at)`
+	];
+}
+async function loadRunById(db, tables, runId) {
+	const rows = await queryRows(db, sql`
+      select *
+      from ${tables.runs}
+      where run_id = ${runId}
+      limit 1
+    `);
+	return rows[0] ? runFromRow(rows[0]) : void 0;
+}
+async function loadRunStateById(db, tables, runId) {
+	const rows = await queryRows(db, sql`
+      select *
+      from ${tables.runStates}
+      where run_id = ${runId}
+      limit 1
+    `);
+	return rows[0] ? runStateFromRow(rows[0]) : void 0;
+}
+async function readStoredEvents(db, tables, args) {
+	return (await queryRows(db, sql`
+      select *
+      from ${tables.events}
+      where run_id = ${args.runId}
+        and event_index >= ${args.fromIndex ?? 0}
+      order by event_index asc
+    `)).map(eventFromRow);
+}
+async function loadSignalDelivery(db, tables, runId, signalId) {
+	const rows = await queryRows(db, sql`
+      select run_id
+      from ${tables.signalDeliveries}
+      where run_id = ${runId}
+        and signal_id = ${signalId}
+      limit 1
+    `);
+	return Boolean(rows[0]);
+}
+async function insertSignalDelivery(db, tables, runId, signalId, now) {
+	const rows = await queryRows(db, sql`
+      insert into ${tables.signalDeliveries} (run_id, signal_id, created_at)
+      values (${runId}, ${signalId}, ${now})
+      on conflict (run_id, signal_id) do nothing
+      returning run_id
+    `);
+	return Boolean(rows[0]);
+}
+async function withTransaction(db, callback) {
+	if (db.transaction) return db.transaction(callback);
+	await db.execute(sql.raw("begin"));
+	try {
+		const result = await callback(db);
+		await db.execute(sql.raw("commit"));
+		return result;
+	} catch (error) {
+		await db.execute(sql.raw("rollback"));
+		throw error;
+	}
+}
+async function queryRows(db, query) {
+	return rowsFromResult(await db.execute(query));
+}
+function rowsFromResult(result) {
+	if (Array.isArray(result)) return result;
+	if (isObjectWithRows(result) && Array.isArray(result.rows)) return result.rows;
+	return [];
+}
+function isObjectWithRows(value) {
+	return typeof value === "object" && value !== null && "rows" in value;
+}
+function runFromRow(row) {
+	return {
+		runId: row.run_id,
+		workflowId: row.workflow_id,
+		workflowVersion: row.workflow_version ?? void 0,
+		status: row.status,
+		input: decodeJson(row.input),
+		output: decodeJsonOrUndefined(row.output),
+		error: decodeJsonOrUndefined(row.error),
+		waitingFor: decodeJsonOrUndefined(row.waiting_for),
+		pendingApproval: decodeJsonOrUndefined(row.pending_approval),
+		wakeAt: numberOrUndefined(row.wake_at),
+		lease: row.lease_owner && row.lease_expires_at !== null ? {
+			owner: row.lease_owner,
+			expiresAt: Number(row.lease_expires_at)
+		} : void 0,
+		createdAt: Number(row.created_at),
+		updatedAt: Number(row.updated_at)
+	};
+}
+function runStateFromRow(row) {
+	return {
+		runId: row.run_id,
+		workflowId: row.workflow_id,
+		workflowVersion: row.workflow_version ?? void 0,
+		status: row.status,
+		input: decodeJson(row.input),
+		output: decodeJsonOrUndefined(row.output),
+		error: decodeJsonOrUndefined(row.error),
+		waitingFor: decodeJsonOrUndefined(row.waiting_for),
+		pendingApproval: decodeJsonOrUndefined(row.pending_approval),
+		createdAt: Number(row.created_at),
+		updatedAt: Number(row.updated_at)
+	};
+}
+function eventFromRow(row) {
+	return {
+		runId: row.run_id,
+		eventIndex: Number(row.event_index),
+		eventType: row.event_type,
+		stepId: row.step_id ?? void 0,
+		event: decodeJson(row.event),
+		createdAt: Number(row.created_at)
+	};
+}
+function timerFromRow(row) {
+	return {
+		runId: row.run_id,
+		workflowId: row.workflow_id,
+		workflowVersion: row.workflow_version ?? void 0,
+		wakeAt: Number(row.wake_at),
+		signalId: row.signal_id
+	};
+}
+function scheduleFromRow(row) {
+	return {
+		scheduleId: row.schedule_id,
+		workflowId: row.workflow_id,
+		workflowVersion: row.workflow_version ?? void 0,
+		input: decodeJsonOrUndefined(row.input),
+		overlapPolicy: row.overlap_policy,
+		nextFireAt: Number(row.next_fire_at)
+	};
+}
+function scheduleBucketFromRow(row) {
+	return {
+		scheduleId: row.schedule_id,
+		bucketId: row.bucket_id,
+		workflowId: row.workflow_id,
+		workflowVersion: row.workflow_version ?? void 0,
+		runId: row.run_id,
+		fireAt: Number(row.fire_at),
+		input: decodeJsonOrUndefined(row.input),
+		overlapPolicy: row.overlap_policy
+	};
+}
+function toRunSummary(row) {
+	const run = runFromRow(row);
+	return {
+		runId: run.runId,
+		workflowId: run.workflowId,
+		workflowVersion: run.workflowVersion,
+		status: run.status,
+		waitingFor: run.waitingFor,
+		pendingApproval: run.pendingApproval,
+		wakeAt: run.wakeAt,
+		createdAt: run.createdAt,
+		updatedAt: run.updatedAt
+	};
+}
+function encodeJson(value) {
+	return JSON.stringify(value ?? null);
+}
+function encodeJsonOrNull(value) {
+	return value === void 0 ? null : JSON.stringify(value);
+}
+function decodeJson(value) {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function decodeJsonOrUndefined(value) {
+	if (value === null || value === void 0) return void 0;
+	return decodeJson(value);
+}
+function numberOrUndefined(value) {
+	return value === null ? void 0 : Number(value);
+}
+function getStepId(event) {
+	return "stepId" in event ? event.stepId : void 0;
+}
+function qualifiedTableName(schema, table) {
+	return schema ? `${quoteIdent(schema)}.${quoteIdent(table)}` : quoteIdent(table);
+}
+function quoteIdent(identifier) {
+	return `"${identifier.replaceAll("\"", "\"\"")}"`;
+}
+
+//#endregion
+export { createDrizzlePostgresWorkflowStore, defaultDrizzlePostgresWorkflowStoreTables };
+//# sourceMappingURL=store.js.map