create-windy 0.1.0

package/template/apps/server/src/jobs/drizzle-artifact.ts

@@ -0,0 +1,63 @@
+import {
+  durableJobArtifacts,
+  durableJobLeases,
+  durableJobs,
+} from "@windy/database";
+import { eq } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type {
+  DurableExecutionRepository,
+  LeaseResult,
+} from "./execution-repository.js";
+import { activeLeaseWhere } from "./drizzle-lease.js";
+import type { DurableLeaseIdentity } from "./types.js";
+
+type Artifact = Parameters<DurableExecutionRepository["publishArtifact"]>[1];
+
+export function publishDrizzleArtifact(
+  db: NodePgDatabase,
+  identity: DurableLeaseIdentity,
+  artifact: Artifact,
+  now: Date,
+  leaseFailure: () => Promise<LeaseResult>,
+) {
+  return db.transaction(async (tx) => {
+    const [lease] = await tx
+      .select()
+      .from(durableJobLeases)
+      .where(activeLeaseWhere(identity, now))
+      .for("update")
+      .limit(1);
+    if (!lease) return leaseFailure();
+    const [job] = await tx
+      .select({ cancelRequestedAt: durableJobs.cancelRequestedAt })
+      .from(durableJobs)
+      .where(eq(durableJobs.id, identity.jobId))
+      .for("update")
+      .limit(1);
+    if (!job) return { ok: false, reason: "not-found" } as const;
+    const leaseResult = {
+      ok: true,
+      cancelRequested: Boolean(job.cancelRequestedAt),
+      expiresAt: lease.expiresAt.toISOString(),
+    } as const;
+    if (leaseResult.cancelRequested) return leaseResult;
+    await tx
+      .insert(durableJobArtifacts)
+      .values(toDatabaseArtifact(artifact))
+      .onConflictDoUpdate({
+        target: [durableJobArtifacts.jobId, durableJobArtifacts.kind],
+        set: toDatabaseArtifact(artifact),
+      });
+    return leaseResult;
+  });
+}
+
+function toDatabaseArtifact(artifact: Artifact) {
+  return {
+    ...artifact,
+    artifactRef: artifact.artifactRef.toString(),
+    expiresAt: artifact.expiresAt ? new Date(artifact.expiresAt) : null,
+    createdAt: new Date(artifact.createdAt),
+  };
+}

package/template/apps/server/src/jobs/drizzle-claim.ts

@@ -0,0 +1,111 @@
+import {
+  durableJobAttempts,
+  durableJobLeases,
+  durableJobStages,
+  durableJobs,
+} from "@windy/database";
+import { and, asc, desc, eq, isNull, lte } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { ClaimDurableJob } from "./execution-repository.js";
+import { mapJob, mapStage } from "./drizzle-mappers.js";
+
+export function claimDurableJob(db: NodePgDatabase, input: ClaimDurableJob) {
+  return db.transaction(async (tx) => {
+    const [job] = await tx
+      .select()
+      .from(durableJobs)
+      .where(
+        and(
+          eq(durableJobs.queue, input.queue),
+          eq(durableJobs.status, "queued"),
+          isNull(durableJobs.cancelRequestedAt),
+          lte(durableJobs.availableAt, input.now),
+        ),
+      )
+      .orderBy(desc(durableJobs.priority), asc(durableJobs.availableAt))
+      .for("update", { skipLocked: true })
+      .limit(1);
+    if (!job) return undefined;
+    const [stage] = await tx
+      .select()
+      .from(durableJobStages)
+      .where(
+        and(
+          eq(durableJobStages.jobId, job.id),
+          eq(durableJobStages.status, "pending"),
+        ),
+      )
+      .orderBy(asc(durableJobStages.ordinal))
+      .for("update")
+      .limit(1);
+    if (!stage) return undefined;
+    const attemptNumber = stage.currentAttempt + 1;
+    const attemptId = Bun.randomUUIDv7();
+    const leaseId = Bun.randomUUIDv7();
+    const leaseToken = crypto.randomUUID().replaceAll("-", "");
+    const leaseExpiresAt = new Date(
+      input.now.getTime() + input.leaseDurationMs,
+    );
+    const [claimedJob] = await tx
+      .update(durableJobs)
+      .set({
+        status: "running",
+        startedAt: job.startedAt || input.now,
+        updatedAt: input.now,
+      })
+      .where(eq(durableJobs.id, job.id))
+      .returning();
+    const [claimedStage] = await tx
+      .update(durableJobStages)
+      .set({
+        status: "running",
+        currentAttempt: attemptNumber,
+        startedAt: stage.startedAt || input.now,
+        updatedAt: input.now,
+      })
+      .where(eq(durableJobStages.id, stage.id))
+      .returning();
+    await tx.insert(durableJobAttempts).values({
+      id: attemptId,
+      jobId: job.id,
+      stageId: stage.id,
+      attemptNumber,
+      status: "running",
+      handlerKey: job.handlerKey,
+      workerId: input.workerId,
+      startedAt: input.now,
+      timeoutAt: new Date(input.now.getTime() + job.timeoutSeconds * 1_000),
+      createdAt: input.now,
+    });
+    await tx.insert(durableJobLeases).values({
+      id: leaseId,
+      jobId: job.id,
+      stageId: stage.id,
+      attemptId,
+      workerId: input.workerId,
+      tokenHash: hashToken(leaseToken),
+      fencingToken: attemptNumber,
+      status: "active",
+      acquiredAt: input.now,
+      heartbeatAt: input.now,
+      expiresAt: leaseExpiresAt,
+    });
+    if (!claimedJob || !claimedStage) throw new Error("任务领取状态写入失败");
+    return {
+      job: mapJob(claimedJob),
+      stage: mapStage(claimedStage),
+      workerId: input.workerId,
+      jobId: job.id,
+      stageId: stage.id,
+      attemptId,
+      leaseId,
+      leaseToken,
+      fencingToken: attemptNumber,
+      leaseExpiresAt: leaseExpiresAt.toISOString(),
+    };
+  });
+}
+
+function hashToken(value: string) {
+  return new Bun.CryptoHasher("sha256").update(value).digest("hex");
+}

package/template/apps/server/src/jobs/drizzle-execution-repository.ts

@@ -0,0 +1,299 @@
+import {
+  durableJobAttempts,
+  durableJobFailures,
+  durableJobLeases,
+  durableJobProgress,
+  durableJobStages,
+  durableJobs,
+} from "@windy/database";
+import { and, eq, max, notInArray } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type {
+  ClaimDurableJob,
+  DurableExecutionRepository,
+  FailDurableJob,
+  LeaseResult,
+  ManualJobRecovery,
+} from "./execution-repository.js";
+import { DrizzleDurableRecoveryRepository } from "./drizzle-recovery-repository.js";
+import { claimDurableJob } from "./drizzle-claim.js";
+import { publishDrizzleArtifact } from "./drizzle-artifact.js";
+import { activeLeaseWhere } from "./drizzle-lease.js";
+import type { DurableLeaseIdentity } from "./types.js";
+
+export class DrizzleDurableExecutionRepository implements DurableExecutionRepository {
+  private readonly recovery: DrizzleDurableRecoveryRepository;
+
+  constructor(private readonly db: NodePgDatabase) {
+    this.recovery = new DrizzleDurableRecoveryRepository(db);
+  }
+
+  async claim(input: ClaimDurableJob) {
+    return claimDurableJob(this.db, input);
+  }
+
+  async heartbeat(
+    identity: DurableLeaseIdentity,
+    now: Date,
+    leaseDurationMs: number,
+  ) {
+    const expiresAt = new Date(now.getTime() + leaseDurationMs);
+    const [lease] = await this.db
+      .update(durableJobLeases)
+      .set({ heartbeatAt: now, expiresAt })
+      .where(activeLeaseWhere(identity, now))
+      .returning();
+    if (!lease) return this.leaseFailure(identity, now);
+    return this.success(identity.jobId, expiresAt);
+  }
+
+  async recordProgress(
+    identity: DurableLeaseIdentity,
+    completedUnits: number,
+    totalUnits: number | undefined,
+    message: string | undefined,
+    metadata: Record<string, unknown> | undefined,
+    now: Date,
+  ) {
+    return this.db.transaction(async (tx) => {
+      const [lease] = await tx
+        .select()
+        .from(durableJobLeases)
+        .where(activeLeaseWhere(identity, now))
+        .for("update")
+        .limit(1);
+      if (!lease) return this.leaseFailure(identity, now);
+      const [{ sequence = 0 } = { sequence: 0 }] = await tx
+        .select({ sequence: max(durableJobProgress.sequence) })
+        .from(durableJobProgress)
+        .where(eq(durableJobProgress.attemptId, identity.attemptId));
+      await tx.insert(durableJobProgress).values({
+        id: Bun.randomUUIDv7(),
+        jobId: identity.jobId,
+        stageId: identity.stageId,
+        attemptId: identity.attemptId,
+        sequence: (sequence || 0) + 1,
+        completedUnits,
+        totalUnits,
+        message,
+        metadata,
+        recordedAt: now,
+      });
+      return this.success(identity.jobId, lease.expiresAt);
+    });
+  }
+
+  async publishArtifact(
+    identity: DurableLeaseIdentity,
+    artifact: Parameters<DurableExecutionRepository["publishArtifact"]>[1],
+    now: Date,
+  ) {
+    return publishDrizzleArtifact(this.db, identity, artifact, now, () =>
+      this.leaseFailure(identity, now),
+    );
+  }
+
+  async complete(identity: DurableLeaseIdentity, now: Date) {
+    return this.db.transaction(async (tx) => {
+      const [lease] = await tx
+        .update(durableJobLeases)
+        .set({ status: "released", releasedAt: now })
+        .where(activeLeaseWhere(identity, now))
+        .returning();
+      if (!lease) return this.leaseFailure(identity, now);
+      const [job] = await tx
+        .select()
+        .from(durableJobs)
+        .where(eq(durableJobs.id, identity.jobId))
+        .for("update")
+        .limit(1);
+      if (!job) return { ok: false, reason: "not-found" } as const;
+      await tx
+        .update(durableJobAttempts)
+        .set({ status: "succeeded", finishedAt: now })
+        .where(eq(durableJobAttempts.id, identity.attemptId));
+      await tx
+        .update(durableJobStages)
+        .set({
+          status: job.cancelRequestedAt ? "cancelled" : "succeeded",
+          finishedAt: now,
+          updatedAt: now,
+        })
+        .where(eq(durableJobStages.id, identity.stageId));
+      if (job.cancelRequestedAt) {
+        await cancelRemaining(tx, job.id, now);
+      } else {
+        const [next] = await tx
+          .select({ id: durableJobStages.id })
+          .from(durableJobStages)
+          .where(
+            and(
+              eq(durableJobStages.jobId, job.id),
+              eq(durableJobStages.status, "pending"),
+            ),
+          )
+          .limit(1);
+        await tx
+          .update(durableJobs)
+          .set(
+            next
+              ? { status: "queued", availableAt: now, updatedAt: now }
+              : { status: "succeeded", finishedAt: now, updatedAt: now },
+          )
+          .where(eq(durableJobs.id, job.id));
+      }
+      return this.success(job.id, lease.expiresAt);
+    });
+  }
+
+  async fail(
+    identity: DurableLeaseIdentity,
+    failure: FailDurableJob,
+    now: Date,
+  ) {
+    return this.db.transaction(async (tx) => {
+      const [lease] = await tx
+        .update(durableJobLeases)
+        .set({
+          status: ["lease-expired", "timed-out"].includes(
+            failure.attemptStatus || "",
+          )
+            ? "expired"
+            : "released",
+          releasedAt: now,
+        })
+        .where(activeLeaseWhere(identity, now))
+        .returning();
+      if (!lease) return this.leaseFailure(identity, now);
+      const [job] = await tx
+        .select()
+        .from(durableJobs)
+        .where(eq(durableJobs.id, identity.jobId))
+        .for("update")
+        .limit(1);
+      const [stage] = await tx
+        .select()
+        .from(durableJobStages)
+        .where(eq(durableJobStages.id, identity.stageId))
+        .for("update")
+        .limit(1);
+      if (!job || !stage) return { ok: false, reason: "not-found" } as const;
+      await tx
+        .update(durableJobAttempts)
+        .set({ status: failure.attemptStatus || "failed", finishedAt: now })
+        .where(eq(durableJobAttempts.id, identity.attemptId));
+      await tx.insert(durableJobFailures).values({
+        id: Bun.randomUUIDv7(),
+        jobId: job.id,
+        stageId: stage.id,
+        attemptId: identity.attemptId,
+        code: failure.code,
+        message: failure.message,
+        retryable: failure.retryable,
+        details: failure.details,
+        occurredAt: now,
+      });
+      if (job.cancelRequestedAt || failure.attemptStatus === "cancelled") {
+        await cancelRemaining(tx, job.id, now);
+      } else {
+        const retry =
+          failure.retryable && stage.currentAttempt < job.maxAttempts;
+        await tx
+          .update(durableJobStages)
+          .set({
+            status: retry ? "pending" : "failed",
+            finishedAt: retry ? null : now,
+            updatedAt: now,
+          })
+          .where(eq(durableJobStages.id, stage.id));
+        await tx
+          .update(durableJobs)
+          .set({
+            status: retry ? "queued" : "failed",
+            availableAt: failure.retryAt || now,
+            finishedAt: retry ? null : now,
+            updatedAt: now,
+          })
+          .where(eq(durableJobs.id, job.id));
+      }
+      return this.success(job.id, lease.expiresAt);
+    });
+  }
+
+  async requestCancel(jobId: string, now: Date) {
+    return this.db.transaction(async (tx) => {
+      const [job] = await tx
+        .select()
+        .from(durableJobs)
+        .where(eq(durableJobs.id, jobId))
+        .for("update")
+        .limit(1);
+      if (!job || !["queued", "running"].includes(job.status)) return false;
+      if (job.status === "queued") await cancelRemaining(tx, job.id, now);
+      else {
+        await tx
+          .update(durableJobs)
+          .set({ cancelRequestedAt: now, updatedAt: now })
+          .where(eq(durableJobs.id, job.id));
+      }
+      return true;
+    });
+  }
+
+  sweepExpired(now: Date, retryDelayMs: number) {
+    return this.recovery.sweepExpired(now, retryDelayMs);
+  }
+
+  recover(input: ManualJobRecovery) {
+    return this.recovery.recover(input);
+  }
+
+  private async leaseFailure(
+    identity: DurableLeaseIdentity,
+    now: Date,
+  ): Promise<LeaseResult> {
+    const [lease] = await this.db
+      .select()
+      .from(durableJobLeases)
+      .where(eq(durableJobLeases.id, identity.leaseId))
+      .limit(1);
+    if (!lease) return { ok: false, reason: "not-found" };
+    if (lease.status !== "active") return { ok: false, reason: "not-active" };
+    if (lease.expiresAt <= now) return { ok: false, reason: "expired" };
+    return { ok: false, reason: "fenced" };
+  }
+
+  private async success(jobId: string, expiresAt: Date): Promise<LeaseResult> {
+    const [job] = await this.db
+      .select({ cancelRequestedAt: durableJobs.cancelRequestedAt })
+      .from(durableJobs)
+      .where(eq(durableJobs.id, jobId))
+      .limit(1);
+    return {
+      ok: true,
+      cancelRequested: Boolean(job?.cancelRequestedAt),
+      expiresAt: expiresAt.toISOString(),
+    };
+  }
+}
+
+async function cancelRemaining(tx: NodePgDatabase, jobId: string, now: Date) {
+  await tx
+    .update(durableJobStages)
+    .set({ status: "cancelled", finishedAt: now, updatedAt: now })
+    .where(
+      and(
+        eq(durableJobStages.jobId, jobId),
+        notInArray(durableJobStages.status, ["succeeded"]),
+      ),
+    );
+  await tx
+    .update(durableJobs)
+    .set({
+      status: "cancelled",
+      cancelRequestedAt: now,
+      finishedAt: now,
+      updatedAt: now,
+    })
+    .where(eq(durableJobs.id, jobId));
+}

package/template/apps/server/src/jobs/drizzle-execution.integration.test.ts

@@ -0,0 +1,232 @@
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+import { resolve } from "node:path";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { Pool } from "pg";
+import { artifactRef } from "@windy/storage";
+import { DrizzleDurableExecutionRepository } from "./drizzle-execution-repository.js";
+import { DrizzleDurableJobRepository } from "./drizzle-repository.js";
+import { DurableJobService } from "./service.js";
+
+const databaseUrl = process.env.JOBS_TEST_DATABASE_URL;
+const describePostgres = databaseUrl ? describe : describe.skip;
+const base = new Date("2026-07-16T12:00:00.000Z");
+
+describePostgres("PostgreSQL durable execution", () => {
+  let pool: Pool;
+
+  beforeAll(async () => {
+    pool = new Pool({ connectionString: databaseUrl });
+    await migrate(drizzle(pool), {
+      migrationsFolder: resolve(
+        import.meta.dir,
+        "../../../../packages/database/drizzle",
+      ),
+      migrationsSchema: "public",
+      migrationsTable: "__durable_execution_test_migrations",
+    });
+  });
+
+  beforeEach(async () => {
+    await pool.query(`truncate table
+      governed_export_requests,
+      bulk_data_artifacts, bulk_data_jobs, scheduled_task_runs,
+      durable_job_recoveries, durable_job_failures, durable_job_artifacts,
+      durable_job_progress, durable_job_leases, durable_job_attempts,
+      durable_job_stages, durable_jobs`);
+  });
+
+  afterAll(async () => {
+    await pool?.end();
+  });
+
+  test("多实例并发只领取一次且伪造 token 不能心跳或完成", async () => {
+    const service = jobService(pool);
+    const submitted = await service.submit(jobInput("pg-claim"));
+    const first = new DrizzleDurableExecutionRepository(drizzle(pool));
+    const second = new DrizzleDurableExecutionRepository(drizzle(pool));
+    const claims = await Promise.all([
+      first.claim(claimInput("worker-a", base)),
+      second.claim(claimInput("worker-b", base)),
+    ]);
+    expect(claims.filter(Boolean)).toHaveLength(1);
+    const claim = claims.find(Boolean);
+    if (!claim) throw new Error("任务未领取");
+    expect(
+      await second.heartbeat(
+        { ...claim, leaseToken: "forged-token" },
+        base,
+        30_000,
+      ),
+    ).toEqual({ ok: false, reason: "fenced" });
+    expect(await first.complete(claim, base)).toMatchObject({ ok: true });
+    expect(await second.complete(claim, base)).toEqual({
+      ok: false,
+      reason: "not-active",
+    });
+    expect((await service.get(submitted.job.id))?.job.status).toBe("succeeded");
+  });
+
+  test("进程重建后回收过期租约并由新 worker 重试", async () => {
+    const service = jobService(pool);
+    const submitted = await service.submit({
+      ...jobInput("pg-restart"),
+      maxAttempts: 2,
+    });
+    const crashed = new DrizzleDurableExecutionRepository(drizzle(pool));
+    const first = await crashed.claim(claimInput("crashed-worker", base, 100));
+    if (!first) throw new Error("崩溃 worker 未领取任务");
+
+    const restarted = new DrizzleDurableExecutionRepository(drizzle(pool));
+    const recoveredAt = new Date(base.getTime() + 101);
+    expect(await restarted.sweepExpired(recoveredAt, 50)).toBe(1);
+    expect(
+      await restarted.claim(claimInput("new-worker", recoveredAt)),
+    ).toBeUndefined();
+    const retry = await restarted.claim(
+      claimInput("new-worker", new Date(recoveredAt.getTime() + 50)),
+    );
+    expect(retry).toMatchObject({ fencingToken: 2, workerId: "new-worker" });
+    if (!retry) throw new Error("恢复后未能重试");
+    await restarted.complete(retry, new Date(recoveredAt.getTime() + 51));
+
+    expect(await service.get(submitted.job.id)).toMatchObject({
+      job: { status: "succeeded" },
+      attempts: [
+        { status: "lease-expired", workerId: "crashed-worker" },
+        { status: "succeeded", workerId: "new-worker" },
+      ],
+      failures: [{ code: "LEASE_EXPIRED" }],
+    });
+  });
+
+  test("artifact publish 与 active owner、attempt、token 在事务内绑定", async () => {
+    const service = jobService(pool);
+    const submitted = await service.submit(jobInput("pg-artifact-fence"));
+    const execution = new DrizzleDurableExecutionRepository(drizzle(pool));
+    const claim = await execution.claim(claimInput("artifact-worker", base));
+    if (!claim) throw new Error("artifact worker 未领取任务");
+    const artifact = {
+      id: Bun.randomUUIDv7(),
+      jobId: claim.jobId,
+      stageId: claim.stageId,
+      kind: "result",
+      artifactRef: artifactRef("blob_0123456789abcdef0123456789abcdef"),
+      filename: "result.ndjson",
+      contentType: "application/x-ndjson",
+      byteSize: 10,
+      sha256: "a".repeat(64),
+      ownerId: "user_pg",
+      createdAt: base.toISOString(),
+    };
+    for (const forged of [
+      { ...claim, workerId: "old-worker" },
+      { ...claim, attemptId: "old-attempt" },
+      { ...claim, leaseToken: "old-token" },
+    ]) {
+      expect(await execution.publishArtifact(forged, artifact, base)).toEqual({
+        ok: false,
+        reason: "fenced",
+      });
+    }
+    expect((await service.get(submitted.job.id))?.artifacts).toEqual([]);
+    expect(
+      await execution.publishArtifact(claim, artifact, base),
+    ).toMatchObject({ ok: true });
+    expect(
+      await execution.publishArtifact(
+        claim,
+        { ...artifact, id: Bun.randomUUIDv7() },
+        base,
+      ),
+    ).toMatchObject({ ok: true });
+    expect((await service.get(submitted.job.id))?.artifacts).toHaveLength(1);
+
+    const cancelled = await service.submit(jobInput("pg-artifact-cancelled"));
+    const cancelledClaim = await execution.claim(
+      claimInput("artifact-cancelled-worker", base),
+    );
+    if (!cancelledClaim) throw new Error("取消任务领取失败");
+    await execution.requestCancel(cancelled.job.id, base);
+    expect(
+      await execution.publishArtifact(
+        cancelledClaim,
+        {
+          ...artifact,
+          id: Bun.randomUUIDv7(),
+          jobId: cancelledClaim.jobId,
+          stageId: cancelledClaim.stageId,
+        },
+        base,
+      ),
+    ).toMatchObject({ ok: true, cancelRequested: true });
+    expect((await service.get(cancelled.job.id))?.artifacts).toEqual([]);
+  });
+
+  test("timeout、running cancel 与人工恢复保留最终事实", async () => {
+    const service = jobService(pool);
+    const submitted = await service.submit({
+      ...jobInput("pg-recover"),
+      maxAttempts: 1,
+      timeoutSeconds: 1,
+    });
+    const execution = new DrizzleDurableExecutionRepository(drizzle(pool));
+    const claim = await execution.claim(claimInput("worker-a", base, 10_000));
+    if (!claim) throw new Error("任务未领取");
+    expect(await execution.requestCancel(submitted.job.id, base)).toBe(true);
+    expect(await execution.heartbeat(claim, base, 10_000)).toMatchObject({
+      ok: true,
+      cancelRequested: true,
+    });
+    expect(
+      await execution.sweepExpired(new Date(base.getTime() + 1_001), 0),
+    ).toBe(1);
+    expect((await service.get(submitted.job.id))?.job.status).toBe("cancelled");
+
+    const recovery = {
+      jobId: submitted.job.id,
+      requestedBy: "ops_user",
+      reason: "确认下游依赖已经恢复",
+      idempotencyKey: "pg-recovery-1",
+      now: new Date(base.getTime() + 2_000),
+    };
+    const results = await Promise.all([
+      execution.recover(recovery),
+      new DrizzleDurableExecutionRepository(drizzle(pool)).recover(recovery),
+    ]);
+    expect(results.filter(({ recovered }) => recovered)).toHaveLength(1);
+    expect(await service.get(submitted.job.id)).toMatchObject({
+      job: { status: "queued", cancelRequestedAt: undefined },
+      attempts: [{ status: "timed-out" }],
+      failures: [{ code: "JOB_TIMEOUT" }],
+      recoveries: [{ fromStatus: "cancelled", requestedBy: "ops_user" }],
+    });
+  });
+});
+
+function jobService(pool: Pool) {
+  return new DurableJobService(
+    new DrizzleDurableJobRepository(drizzle(pool)),
+    () => base,
+  );
+}
+
+function jobInput(idempotencyKey: string) {
+  return {
+    handlerKey: "test.handler",
+    idempotencyKey,
+    payload: {},
+    requestedBy: "user_pg",
+  };
+}
+
+function claimInput(workerId: string, now: Date, leaseDurationMs = 30_000) {
+  return { queue: "default", workerId, now, leaseDurationMs };
+}