effect-mq 0.1.0 → 0.2.0

package/src/{drizzle → drizzle-postgres}/DrizzleJobStore.ts

@@ -21,8 +21,8 @@ import type { PgClient } from "@effect/sql-pg"
 import { asc, eq, sql } from "drizzle-orm"
 import * as PgDrizzle from "drizzle-orm/effect-postgres"
 import { getTableConfig } from "drizzle-orm/pg-core"
-import { Clock, type Context, Deferred, Effect, Layer, Option, type Scope, Stream } from "effect"
-import type { MqJobAttemptsTable, MqJobsTable } from "./schema.ts"
+import { Clock, type Context, Deferred, Duration, Effect, Layer, Option, type Scope, Stream } from "effect"
+import type { MqJobAttemptsTable, MqJobsTable, MqQueueControlTable, MqSchedulesTable } from "./schema.ts"
 
 const { JobId } = JobStore
 
@@ -34,8 +34,24 @@ export interface DrizzleJobStoreOptions<StoreId = JobStore.JobStore> {
   readonly jobs: MqJobsTable
   /** The run-ledger table instance (from `mqJobAttempts`). */
   readonly attempts: MqJobAttemptsTable
+  /** The schedules table instance (from `mqSchedules`). */
+  readonly schedules: MqSchedulesTable
+  /** The queue pause/resume flags table (from `mqQueueControl`). */
+  readonly queues: MqQueueControlTable
   /** Bind to a `JobStore.named(...)` key; default: the default `JobStore`. */
   readonly store?: Context.Key<StoreId, JobStore.Service> | undefined
+  /**
+   * Store-level retention ceiling: terminal records older than this are
+   * removed by a periodic sweep. Per-job `keep` may only be stricter.
+   */
+  readonly historyTtl?: Duration.Input | undefined
+  /** History sweep cadence (default 1 minute). */
+  readonly historySweepInterval?: Duration.Input | undefined
+  /**
+   * Generator for store-assigned job ids (e.g. `() => \`job_${ulid()}\``).
+   * Default: `j-<seq>` from the jobs sequence. See `JobStore.IdGenerator`.
+   */
+  readonly idGenerator?: JobStore.IdGenerator | undefined
   /**
    * Probe the tables at startup and fail fast when the schema is missing
    * (default true). Migrations are owned by your drizzle-kit pipeline.
@@ -74,6 +90,8 @@ type JobRow = {
   readonly stalledCount: number
   readonly backoff: JobStore.BackoffPolicy | null
   readonly keep: JobStore.KeepPolicy | null
+  readonly timeoutMs: number | string | null
+  readonly cancelRequested: boolean
   readonly runAt: Date
   readonly enqueuedAt: Date
   readonly processedAt: Date | null
@@ -82,6 +100,40 @@ type JobRow = {
   readonly failedReason: string | null
 }
 
+type ScheduleRow = {
+  readonly key: string
+  readonly jobName: string
+  readonly queue: string
+  readonly cron: string | null
+  readonly tz: string | null
+  readonly everyMs: number | string | null
+  readonly payload: unknown
+  readonly metadata: Record<string, string>
+  readonly priority: number
+  readonly attemptsMax: number
+  readonly backoff: JobStore.BackoffPolicy | null
+  readonly keep: JobStore.KeepPolicy | null
+  readonly timeoutMs: number | string | null
+  readonly nextRunAt: Date
+}
+
+const toSchedule = (row: ScheduleRow): JobStore.ScheduleRecord => ({
+  key: JobStore.ScheduleKey(row.key),
+  jobName: row.jobName,
+  queue: JobStore.QueueName(row.queue),
+  cron: row.cron ?? undefined,
+  tz: row.tz ?? undefined,
+  everyMs: row.everyMs === null ? undefined : Number(row.everyMs),
+  payload: row.payload,
+  metadata: row.metadata ?? {},
+  priority: row.priority,
+  attemptsMax: row.attemptsMax,
+  backoff: row.backoff ?? undefined,
+  keep: row.keep ?? undefined,
+  timeoutMs: row.timeoutMs === null ? undefined : Number(row.timeoutMs),
+  nextRunAt: row.nextRunAt.getTime()
+})
+
 const toRecord = (row: JobRow): JobStore.JobRecord => ({
   id: JobId(row.id),
   name: row.name,
@@ -95,6 +147,8 @@ const toRecord = (row: JobRow): JobStore.JobRecord => ({
   stalledCount: row.stalledCount,
   backoff: row.backoff ?? undefined,
   keep: row.keep ?? undefined,
+  timeoutMs: row.timeoutMs === null || row.timeoutMs === undefined ? undefined : Number(row.timeoutMs),
+  cancelRequested: row.cancelRequested,
   runAt: row.runAt.getTime(),
   enqueuedAt: row.enqueuedAt.getTime(),
   processedAt: row.processedAt?.getTime(),
@@ -117,6 +171,8 @@ export const make = (
     const client = db.$client
     const jobs = options.jobs
     const attempts = options.attempts
+    const schedules = options.schedules
+    const queues = options.queues
     const jobsName = getTableConfig(jobs).name
     const attemptsName = getTableConfig(attempts).name
     const wakeChannel = `effect_mq_wake_${jobsName}`
@@ -124,7 +180,9 @@ export const make = (
     if (options.validate ?? true) {
       yield* Effect.all([
         db.select({ id: jobs.id }).from(jobs).limit(0),
-        db.select({ jobId: attempts.jobId }).from(attempts).limit(0)
+        db.select({ jobId: attempts.jobId }).from(attempts).limit(0),
+        db.select({ key: schedules.key }).from(schedules).limit(0),
+        db.select({ queue: queues.queue }).from(queues).limit(0)
       ]).pipe(
         Effect.mapError(storeError(
           `effect-mq: tables "${jobsName}"/"${attemptsName}" are missing or mismatched — ` +
@@ -158,6 +216,24 @@ export const make = (
       Effect.forever,
       Effect.forkScoped
     )
+    if (options.historyTtl !== undefined) {
+      const ttlMs = Duration.toMillis(options.historyTtl)
+      const sweepMs = Duration.toMillis(options.historySweepInterval ?? "1 minute")
+      yield* Effect.gen(function*() {
+        yield* Effect.sleep(sweepMs)
+        const now = yield* nowDate
+        yield* db.execute(sql`
+          DELETE FROM ${jobs}
+          WHERE ${jobs.state} IN ('completed', 'failed', 'cancelled')
+            AND ${jobs.finishedAt} <= ${new Date(now.getTime() - ttlMs)}
+        `)
+      }).pipe(
+        Effect.catchCause((cause) => Effect.logWarning("effect-mq: history sweep failed", cause)),
+        Effect.forever,
+        Effect.forkScoped
+      )
+    }
+
     // Local mutation wake-up: bump synchronously, then best-effort NOTIFY so
     // workers in other processes wake promptly too.
     const wakeUp: Effect.Effect<void> = Effect.suspend(() => {
@@ -237,21 +313,31 @@ export const make = (
           const now = yield* nowDate
           const runAt = new Date(now.getTime() + Math.max(0, request.delayMs))
           const state = request.delayMs > 0 ? "delayed" : "waiting"
-          // Store-assigned ids come from the seq sequence; loop on the
-          // (unlikely) collision with a user-supplied id.
+          // Store-assigned ids come from the configured generator (or the
+          // seq sequence); loop on the (unlikely) collision with an existing
+          // id — ON CONFLICT DO NOTHING makes the retry safe.
+          const generate = options.idGenerator
           for (let i = 0; i < 5; i++) {
+            const generated = request.id === undefined && generate !== undefined
+              ? yield* Effect.suspend(() => {
+                const raw = generate(request)
+                return Effect.isEffect(raw) ? raw : Effect.succeed(raw)
+              })
+              : undefined
             const idExpr = request.id !== undefined
               ? sql`${request.id}`
+              : generated !== undefined
+              ? sql`${generated}`
               : sql`'j-' || ${seqExpr}::text`
             const rows = rowsOf(yield* db.execute<{ id: string }>(sql`
               INSERT INTO ${jobs} (id, name, queue, state, priority, payload, metadata,
-                attempts_max, backoff, keep, run_at, enqueued_at)
+                attempts_max, backoff, keep, timeout_ms, run_at, enqueued_at)
               VALUES (${idExpr}, ${request.name}, ${request.queue}, ${state}, ${request.priority},
                 ${JSON.stringify(request.payload ?? null)}::jsonb, ${JSON.stringify(request.metadata)}::jsonb,
                 ${request.attemptsMax},
                 ${request.backoff === undefined ? null : JSON.stringify(request.backoff)}::jsonb,
                 ${request.keep === undefined ? null : JSON.stringify(request.keep)}::jsonb,
-                ${runAt}, ${now})
+                ${request.timeoutMs ?? null}, ${runAt}, ${now})
               ON CONFLICT (id) DO NOTHING
               RETURNING ${jobs.id} AS id
             `).pipe(Effect.mapError(storeError("enqueue failed"))))
@@ -286,7 +372,12 @@ export const make = (
               WHERE ${jobs.queue} = ${claimOptions.queue} AND ${jobs.state} = 'delayed'
                 AND ${jobs.runAt} <= ${now}
             `)
-            const claimed = rowsOf(yield* tx.execute<JobRow>(sql`
+            const pausedRows = rowsOf(yield* tx.execute<{ paused: boolean }>(sql`
+              SELECT ${queues.paused} AS "paused" FROM ${queues}
+              WHERE ${queues.queue} = ${claimOptions.queue}
+            `))
+            const isPaused = pausedRows[0]?.paused === true
+            const claimed = isPaused ? [] : rowsOf(yield* tx.execute<JobRow>(sql`
               WITH candidate AS (
                 SELECT ${jobs.id} AS id FROM ${jobs}
                 WHERE ${jobs.queue} = ${claimOptions.queue} AND ${jobs.state} = 'waiting'
@@ -304,7 +395,9 @@ export const make = (
                 ${jobs.payload} AS "payload", ${jobs.metadata} AS "metadata",
                 ${jobs.attemptsMax} AS "attemptsMax", ${jobs.attemptsMade} AS "attemptsMade",
                 ${jobs.stalledCount} AS "stalledCount", ${jobs.backoff} AS "backoff",
-                ${jobs.keep} AS "keep", ${jobs.runAt} AS "runAt", ${jobs.enqueuedAt} AS "enqueuedAt",
+                ${jobs.keep} AS "keep", ${jobs.timeoutMs} AS "timeoutMs",
+                ${jobs.cancelRequested} AS "cancelRequested",
+                ${jobs.runAt} AS "runAt", ${jobs.enqueuedAt} AS "enqueuedAt",
                 ${jobs.processedAt} AS "processedAt", ${jobs.finishedAt} AS "finishedAt",
                 ${jobs.exit} AS "exit", ${jobs.failedReason} AS "failedReason"
             `))
@@ -335,12 +428,20 @@ export const make = (
           Effect.gen(function*() {
             const now = yield* nowDate
             const update = outcome._tag === "Complete"
-              ? sql`state = 'completed', exit = ${JSON.stringify(outcome.exit ?? null)}::jsonb, finished_at = ${now}`
+              ? sql`state = 'completed', cancel_requested = FALSE, exit = ${JSON.stringify(outcome.exit ?? null)}::jsonb, finished_at = ${now}`
               : outcome._tag === "Fail"
-              ? sql`state = 'failed', exit = ${JSON.stringify(outcome.exit ?? null)}::jsonb, finished_at = ${now}`
-              : sql`state = ${outcome.delayMs > 0 ? "delayed" : "waiting"},
-                  run_at = ${new Date(now.getTime() + Math.max(0, outcome.delayMs))},
-                  seq = ${seqExpr}`
+              ? sql`state = 'failed', cancel_requested = FALSE, exit = ${JSON.stringify(outcome.exit ?? null)}::jsonb, finished_at = ${now}`
+              : outcome._tag === "Cancelled"
+              ? sql`state = 'cancelled', cancel_requested = FALSE, finished_at = ${now}`
+              // A cancel that raced this natural failure wins over revival
+              // (mirrors release/recoverStalled).
+              : sql`state = CASE WHEN ${jobs.cancelRequested} THEN 'cancelled'
+                    ELSE ${outcome.delayMs > 0 ? "delayed" : "waiting"} END,
+                  finished_at = CASE WHEN ${jobs.cancelRequested} THEN ${now}::timestamptz ELSE NULL END,
+                  run_at = CASE WHEN ${jobs.cancelRequested} THEN ${jobs.runAt}
+                    ELSE ${new Date(now.getTime() + Math.max(0, outcome.delayMs))}::timestamptz END,
+                  seq = CASE WHEN ${jobs.cancelRequested} THEN ${jobs.seq} ELSE ${seqExpr} END,
+                  cancel_requested = FALSE`
             const rows = rowsOf(yield* tx.execute<
               { processedAt: Date | null; name: string; state: string; keep: JobStore.KeepPolicy | null }
             >(sql`
@@ -354,13 +455,23 @@ export const make = (
             if (row === undefined) {
               return yield* explainMiss(id)
             }
+            const cancelledRetry = outcome._tag === "Retry" && row.state === "cancelled"
             const ledgerOutcome = outcome._tag === "Complete"
               ? "completed" as const
               : outcome._tag === "Fail"
               ? "failed" as const
+              : outcome._tag === "Cancelled" || cancelledRetry
+              ? "cancelled" as const
               : "retried" as const
-            yield* insertAttempt(tx, id, ledgerOutcome, row.processedAt, now, outcome.exit)
-            if (outcome._tag !== "Retry") {
+            yield* insertAttempt(
+              tx,
+              id,
+              ledgerOutcome,
+              row.processedAt,
+              now,
+              outcome._tag === "Cancelled" || cancelledRetry ? undefined : outcome.exit
+            )
+            if (outcome._tag !== "Retry" || cancelledRetry) {
               yield* applyKeep(tx, row, now)
             }
           })
@@ -376,22 +487,56 @@ export const make = (
 
       release: (id, token) =>
         Effect.gen(function*() {
-          const rows = rowsOf(yield* db.execute<{ id: string }>(sql`
-            UPDATE ${jobs} SET state = 'waiting', lock_token = NULL, lock_expires_at = NULL
-            WHERE ${jobs.id} = ${id} AND ${jobs.state} = 'active' AND ${jobs.lockToken} = ${token}
-            RETURNING ${jobs.id} AS id
-          `).pipe(Effect.mapError(storeError("release failed"))))
-          if (rows.length === 0) {
+          const cancelled = yield* db.transaction((tx) =>
+            Effect.gen(function*() {
+              const now = yield* nowDate
+              // A cancel that arrived while the worker was shutting down is
+              // honoured instead of reviving the job.
+              const rows = rowsOf(yield* tx.execute<
+                {
+                  id: string
+                  cancelled: boolean
+                  processedAt: Date | null
+                  name: string
+                  keep: JobStore.KeepPolicy | null
+                }
+              >(sql`
+                UPDATE ${jobs} SET
+                  state = CASE WHEN ${jobs.cancelRequested} THEN 'cancelled' ELSE 'waiting' END,
+                  finished_at = CASE WHEN ${jobs.cancelRequested} THEN ${now}::timestamptz ELSE NULL END,
+                  cancel_requested = FALSE,
+                  lock_token = NULL, lock_expires_at = NULL
+                WHERE ${jobs.id} = ${id} AND ${jobs.state} = 'active' AND ${jobs.lockToken} = ${token}
+                RETURNING ${jobs.id} AS id, (${jobs.state} = 'cancelled') AS cancelled,
+                  ${jobs.processedAt} AS "processedAt", ${jobs.name} AS "name", ${jobs.keep} AS "keep"
+              `))
+              const row = rows[0]
+              if (row === undefined) return undefined
+              if (row.cancelled) {
+                yield* insertAttempt(tx, id, "cancelled", row.processedAt, now, undefined)
+                yield* applyKeep(tx, { name: row.name, state: "cancelled", keep: row.keep }, now)
+              }
+              return row.cancelled
+            })
+          ).pipe(Effect.mapError((error) =>
+            error instanceof JobStore.JobStoreError ? error : storeError("release failed")(error)
+          ))
+          if (cancelled === undefined) {
             return yield* explainMiss(id)
           }
-          yield* wakeUp
+          if (!cancelled) {
+            yield* wakeUp
+          }
         }),
 
       extendLocks: (locks, durationMs) =>
         Effect.gen(function*() {
-          if (locks.length === 0) return []
+          if (locks.length === 0) {
+            const empty: JobStore.ExtendLocksResult = { lost: [], cancelRequested: [] }
+            return empty
+          }
           const now = yield* nowDate
-          const rows = rowsOf(yield* db.execute<{ id: string }>(sql`
+          const rows = rowsOf(yield* db.execute<{ id: string; status: "lost" | "cancel" }>(sql`
             WITH input AS (
               SELECT ids.job_id, toks.token
               FROM unnest(${sql.param(locks.map((lock) => lock.id))}::text[]) WITH ORDINALITY AS ids(job_id, ord)
@@ -400,39 +545,78 @@ export const make = (
             updated AS (
               UPDATE ${jobs} SET lock_expires_at = ${new Date(now.getTime() + durationMs)}
               FROM input
-              WHERE ${jobs.id} = input.job_id AND ${jobs.state} = 'active' AND ${jobs.lockToken} = input.token
+              WHERE ${jobs.id} = input.job_id AND ${jobs.state} = 'active'
+                AND ${jobs.lockToken} = input.token AND ${jobs.cancelRequested} = FALSE
               RETURNING ${jobs.id} AS id
             )
-            SELECT input.job_id AS id FROM input
+            SELECT input.job_id AS id,
+              CASE WHEN ${jobs.id} IS NOT NULL AND ${jobs.state} = 'active'
+                AND ${jobs.lockToken} = input.token AND ${jobs.cancelRequested} THEN 'cancel'
+                ELSE 'lost' END AS status
+            FROM input
             LEFT JOIN updated ON updated.id = input.job_id
+            LEFT JOIN ${jobs} ON ${jobs.id} = input.job_id
             WHERE updated.id IS NULL
           `).pipe(Effect.mapError(storeError("extendLocks failed"))))
-          return rows.map((row) => JobId(row.id))
+          const result: JobStore.ExtendLocksResult = {
+            lost: rows.filter((row) => row.status === "lost").map((row) => JobId(row.id)),
+            cancelRequested: rows.filter((row) => row.status === "cancel").map((row) => JobId(row.id))
+          }
+          return result
         }),
 
       recoverStalled: (recoverOptions) =>
         db.transaction((tx) =>
           Effect.gen(function*() {
             const now = yield* nowDate
+            // A stalled job whose worker died before honouring a cancel
+            // request is finished as cancelled rather than revived.
             const rows = rowsOf(yield* tx.execute<
-              { id: string; state: string; processedAt: Date | null }
+              {
+                id: string
+                state: string
+                processedAt: Date | null
+                name: string
+                keep: JobStore.KeepPolicy | null
+              }
             >(sql`
               UPDATE ${jobs} SET
-                stalled_count = ${jobs.stalledCount} + 1,
+                stalled_count = CASE WHEN ${jobs.cancelRequested} THEN ${jobs.stalledCount}
+                  ELSE ${jobs.stalledCount} + 1 END,
                 lock_token = NULL, lock_expires_at = NULL,
-                state = CASE WHEN ${jobs.stalledCount} + 1 > ${recoverOptions.maxStalledCount}::int
-                  THEN 'failed' ELSE 'waiting' END,
-                finished_at = CASE WHEN ${jobs.stalledCount} + 1 > ${recoverOptions.maxStalledCount}::int
+                state = CASE
+                  WHEN ${jobs.cancelRequested} THEN 'cancelled'
+                  WHEN ${jobs.stalledCount} + 1 > ${recoverOptions.maxStalledCount}::int THEN 'failed'
+                  ELSE 'waiting' END,
+                finished_at = CASE
+                  WHEN ${jobs.cancelRequested} OR ${jobs.stalledCount} + 1 > ${recoverOptions.maxStalledCount}::int
                   THEN ${now}::timestamptz ELSE NULL END,
-                failed_reason = CASE WHEN ${jobs.stalledCount} + 1 > ${recoverOptions.maxStalledCount}::int
-                  THEN 'job stalled more than allowable limit' ELSE NULL END
+                failed_reason = CASE
+                  WHEN ${jobs.cancelRequested} THEN NULL
+                  WHEN ${jobs.stalledCount} + 1 > ${recoverOptions.maxStalledCount}::int
+                  THEN 'job stalled more than allowable limit' ELSE NULL END,
+                cancel_requested = FALSE
               WHERE ${jobs.state} = 'active' AND ${jobs.lockExpiresAt} <= ${now}::timestamptz
-              RETURNING ${jobs.id} AS "id", ${jobs.state} AS "state", ${jobs.processedAt} AS "processedAt"
+              RETURNING ${jobs.id} AS "id", ${jobs.state} AS "state", ${jobs.processedAt} AS "processedAt",
+                ${jobs.name} AS "name", ${jobs.keep} AS "keep"
             `))
+            const recovered: Array<{ id: JobStore.JobId; failed: boolean }> = []
             for (const row of rows) {
-              yield* insertAttempt(tx, row.id, "stalled", row.processedAt, now, undefined)
+              yield* insertAttempt(
+                tx,
+                row.id,
+                row.state === "cancelled" ? "cancelled" : "stalled",
+                row.processedAt,
+                now,
+                undefined
+              )
+              if (row.state === "cancelled") {
+                yield* applyKeep(tx, { name: row.name, state: "cancelled", keep: row.keep }, now)
+              } else {
+                recovered.push({ id: JobId(row.id), failed: row.state === "failed" })
+              }
             }
-            return rows.map((row) => ({ id: JobId(row.id), failed: row.state === "failed" }))
+            return recovered
           })
         ).pipe(
           Effect.mapError((error) =>
@@ -500,7 +684,9 @@ export const make = (
               ${jobs.payload} AS "payload", ${jobs.metadata} AS "metadata",
               ${jobs.attemptsMax} AS "attemptsMax", ${jobs.attemptsMade} AS "attemptsMade",
               ${jobs.stalledCount} AS "stalledCount", ${jobs.backoff} AS "backoff",
-              ${jobs.keep} AS "keep", ${jobs.runAt} AS "runAt", ${jobs.enqueuedAt} AS "enqueuedAt",
+              ${jobs.keep} AS "keep", ${jobs.timeoutMs} AS "timeoutMs",
+              ${jobs.cancelRequested} AS "cancelRequested",
+              ${jobs.runAt} AS "runAt", ${jobs.enqueuedAt} AS "enqueuedAt",
               ${jobs.processedAt} AS "processedAt", ${jobs.finishedAt} AS "finishedAt",
               ${jobs.exit} AS "exit", ${jobs.failedReason} AS "failedReason"
             FROM ${jobs}
@@ -523,6 +709,7 @@ export const make = (
           const now = yield* nowDate
           const rows = rowsOf(yield* db.execute<{ id: string }>(sql`
             UPDATE ${jobs} SET state = 'waiting', attempts_made = 0, stalled_count = 0,
+              cancel_requested = FALSE,
               exit = NULL, failed_reason = NULL, finished_at = NULL, processed_at = NULL,
               run_at = ${now}, seq = ${seqExpr}
             WHERE ${jobs.id} = ${id} AND ${jobs.state} = 'failed'
@@ -540,6 +727,190 @@ export const make = (
           yield* wakeUp
         }),
 
+      cancel: (id) =>
+        db.transaction((tx) =>
+          Effect.gen(function*() {
+            const now = yield* nowDate
+            // One guarded statement: waiting/delayed become terminal, active
+            // gets the cancel-request flag; anything else is reported by state.
+            const rows = rowsOf(yield* tx.execute<
+              {
+                id: string
+                state: string
+                processedAt: Date | null
+                name: string
+                keep: JobStore.KeepPolicy | null
+              }
+            >(sql`
+              UPDATE ${jobs} SET
+                state = CASE WHEN ${jobs.state} IN ('waiting', 'delayed') THEN 'cancelled' ELSE ${jobs.state} END,
+                finished_at = CASE WHEN ${jobs.state} IN ('waiting', 'delayed') THEN ${now}::timestamptz ELSE ${jobs.finishedAt} END,
+                cancel_requested = CASE WHEN ${jobs.state} = 'active' THEN TRUE ELSE ${jobs.cancelRequested} END
+              WHERE ${jobs.id} = ${id} AND ${jobs.state} IN ('waiting', 'delayed', 'active')
+              RETURNING ${jobs.id} AS id, ${jobs.state} AS state,
+                ${jobs.processedAt} AS "processedAt", ${jobs.name} AS "name", ${jobs.keep} AS "keep"
+            `))
+            const row = rows[0]
+            if (row === undefined) {
+              const existing = rowsOf(yield* tx.execute<{ state: JobStore.JobState }>(sql`
+                SELECT ${jobs.state} AS state FROM ${jobs} WHERE ${jobs.id} = ${id}
+              `))
+              const found = existing[0]
+              if (found === undefined) {
+                return yield* new JobStore.JobNotFoundError({ jobId: id })
+              }
+              return yield* new JobStore.JobNotCancellableError({ jobId: id, state: found.state })
+            }
+            if (row.state === "cancelled") {
+              yield* insertAttempt(tx, id, "cancelled", row.processedAt, now, undefined)
+              yield* applyKeep(tx, { name: row.name, state: "cancelled", keep: row.keep }, now)
+            }
+          })
+        ).pipe(
+          Effect.mapError((error) =>
+            error instanceof JobStore.JobNotFoundError ||
+              error instanceof JobStore.JobNotCancellableError ||
+              error instanceof JobStore.JobStoreError
+              ? error
+              : storeError("cancel failed")(error)
+          ),
+          Effect.asVoid
+        ),
+
+      promote: (id) =>
+        Effect.gen(function*() {
+          const now = yield* nowDate
+          const rows = rowsOf(yield* db.execute<{ id: string }>(sql`
+            UPDATE ${jobs} SET state = 'waiting', run_at = ${now}
+            WHERE ${jobs.id} = ${id} AND ${jobs.state} = 'delayed'
+            RETURNING ${jobs.id} AS id
+          `).pipe(Effect.mapError(storeError("promote failed"))))
+          if (rows.length === 0) {
+            const existing = rowsOf(yield* db.execute<{ state: JobStore.JobState }>(sql`
+              SELECT ${jobs.state} AS state FROM ${jobs} WHERE ${jobs.id} = ${id}
+            `).pipe(Effect.mapError(storeError("promote failed"))))
+            const found = existing[0]
+            if (found === undefined) {
+              return yield* new JobStore.JobNotFoundError({ jobId: id })
+            }
+            return yield* new JobStore.JobNotPromotableError({ jobId: id, state: found.state })
+          }
+          yield* wakeUp
+        }),
+
+      pause: (queue) =>
+        db.execute(sql`
+          INSERT INTO ${queues} (queue, paused) VALUES (${queue}, TRUE)
+          ON CONFLICT (queue) DO UPDATE SET paused = TRUE
+        `).pipe(
+          Effect.mapError(storeError("pause failed")),
+          Effect.asVoid
+        ),
+
+      resume: (queue) =>
+        db.execute(sql`
+          UPDATE ${queues} SET paused = FALSE WHERE ${queues.queue} = ${queue}
+        `).pipe(
+          Effect.mapError(storeError("resume failed")),
+          Effect.andThen(wakeUp)
+        ),
+
+      pausedQueues: () =>
+        db.execute<{ queue: string }>(sql`
+          SELECT ${queues.queue} AS queue FROM ${queues} WHERE ${queues.paused} = TRUE
+        `).pipe(
+          Effect.mapError(storeError("pausedQueues failed")),
+          Effect.map((result) => rowsOf(result).map((row) => JobStore.QueueName(row.queue)))
+        ),
+
+      upsertSchedule: (schedule) =>
+        db.execute(sql`
+          INSERT INTO ${schedules} (key, job_name, queue, cron, tz, every_ms, payload, metadata,
+            priority, attempts_max, backoff, keep, timeout_ms, next_run_at)
+          VALUES (${schedule.key}, ${schedule.jobName}, ${schedule.queue},
+            ${schedule.cron ?? null}, ${schedule.tz ?? null}, ${schedule.everyMs ?? null},
+            ${JSON.stringify(schedule.payload ?? null)}::jsonb, ${JSON.stringify(schedule.metadata)}::jsonb,
+            ${schedule.priority}, ${schedule.attemptsMax},
+            ${schedule.backoff === undefined ? null : JSON.stringify(schedule.backoff)}::jsonb,
+            ${schedule.keep === undefined ? null : JSON.stringify(schedule.keep)}::jsonb,
+            ${schedule.timeoutMs ?? null}, ${new Date(schedule.nextRunAt)})
+          ON CONFLICT (key) DO UPDATE SET
+            job_name = EXCLUDED.job_name, queue = EXCLUDED.queue, cron = EXCLUDED.cron,
+            tz = EXCLUDED.tz, every_ms = EXCLUDED.every_ms, payload = EXCLUDED.payload,
+            metadata = EXCLUDED.metadata, priority = EXCLUDED.priority,
+            attempts_max = EXCLUDED.attempts_max, backoff = EXCLUDED.backoff,
+            keep = EXCLUDED.keep, timeout_ms = EXCLUDED.timeout_ms,
+            next_run_at = CASE
+              WHEN ${schedules.cron} IS NOT DISTINCT FROM EXCLUDED.cron
+                AND ${schedules.tz} IS NOT DISTINCT FROM EXCLUDED.tz
+                AND ${schedules.everyMs} IS NOT DISTINCT FROM EXCLUDED.every_ms
+              THEN ${schedules.nextRunAt}
+              ELSE EXCLUDED.next_run_at END
+        `).pipe(
+          Effect.mapError(storeError("upsertSchedule failed")),
+          Effect.asVoid
+        ),
+
+      removeSchedule: (key) =>
+        db.execute<{ key: string }>(sql`
+          DELETE FROM ${schedules} WHERE ${schedules.key} = ${key}
+          RETURNING ${schedules.key} AS key
+        `).pipe(
+          Effect.mapError(storeError("removeSchedule failed")),
+          Effect.map((result) => rowsOf(result).length > 0)
+        ),
+
+      listSchedules: (listOptions) =>
+        Effect.gen(function*() {
+          const conditions = [sql`TRUE`]
+          if (listOptions?.jobName !== undefined) {
+            conditions.push(sql`${schedules.jobName} = ${listOptions.jobName}`)
+          }
+          if (listOptions?.queue !== undefined) {
+            conditions.push(sql`${schedules.queue} = ${listOptions.queue}`)
+          }
+          const rows = rowsOf(yield* db.execute<ScheduleRow>(sql`
+            SELECT ${schedules.key} AS "key", ${schedules.jobName} AS "jobName",
+              ${schedules.queue} AS "queue", ${schedules.cron} AS "cron", ${schedules.tz} AS "tz",
+              ${schedules.everyMs} AS "everyMs", ${schedules.payload} AS "payload",
+              ${schedules.metadata} AS "metadata", ${schedules.priority} AS "priority",
+              ${schedules.attemptsMax} AS "attemptsMax", ${schedules.backoff} AS "backoff",
+              ${schedules.keep} AS "keep", ${schedules.timeoutMs} AS "timeoutMs",
+              ${schedules.nextRunAt} AS "nextRunAt"
+            FROM ${schedules}
+            WHERE ${sql.join(conditions, sql` AND `)}
+            ORDER BY ${schedules.key}
+          `).pipe(Effect.mapError(storeError("listSchedules failed"))))
+          return rows.map(toSchedule)
+        }),
+
+      dueSchedules: () =>
+        Effect.gen(function*() {
+          const now = yield* nowDate
+          const rows = rowsOf(yield* db.execute<ScheduleRow>(sql`
+            SELECT ${schedules.key} AS "key", ${schedules.jobName} AS "jobName",
+              ${schedules.queue} AS "queue", ${schedules.cron} AS "cron", ${schedules.tz} AS "tz",
+              ${schedules.everyMs} AS "everyMs", ${schedules.payload} AS "payload",
+              ${schedules.metadata} AS "metadata", ${schedules.priority} AS "priority",
+              ${schedules.attemptsMax} AS "attemptsMax", ${schedules.backoff} AS "backoff",
+              ${schedules.keep} AS "keep", ${schedules.timeoutMs} AS "timeoutMs",
+              ${schedules.nextRunAt} AS "nextRunAt"
+            FROM ${schedules}
+            WHERE ${schedules.nextRunAt} <= ${now}
+            ORDER BY ${schedules.nextRunAt} ASC
+          `).pipe(Effect.mapError(storeError("dueSchedules failed"))))
+          return rows.map(toSchedule)
+        }),
+
+      advanceSchedule: (key, expectedRunAt, nextRunAt) =>
+        db.execute(sql`
+          UPDATE ${schedules} SET next_run_at = ${new Date(nextRunAt)}
+          WHERE ${schedules.key} = ${key} AND ${schedules.nextRunAt} = ${new Date(expectedRunAt)}
+        `).pipe(
+          Effect.mapError(storeError("advanceSchedule failed")),
+          Effect.asVoid
+        ),
+
       counts: (queue) =>
         db.execute<{ state: JobStore.JobState; count: number }>(sql`
           SELECT ${jobs.state} AS "state", count(*)::int AS "count" FROM ${jobs}
@@ -554,7 +925,8 @@ export const make = (
               delayed: 0,
               active: 0,
               completed: 0,
-              failed: 0
+              failed: 0,
+              cancelled: 0
             } satisfies Record<JobStore.JobState, number>
             for (const row of rows) counts[row.state] = row.count
             return counts