create-windy 0.1.0

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

@@ -0,0 +1,21 @@
+import { durableJobLeases } from "@windy/database";
+import { and, eq, gt } from "drizzle-orm";
+import type { DurableLeaseIdentity } from "./types.js";
+
+export function activeLeaseWhere(identity: DurableLeaseIdentity, now: Date) {
+  return and(
+    eq(durableJobLeases.id, identity.leaseId),
+    eq(durableJobLeases.jobId, identity.jobId),
+    eq(durableJobLeases.stageId, identity.stageId),
+    eq(durableJobLeases.attemptId, identity.attemptId),
+    eq(durableJobLeases.workerId, identity.workerId),
+    eq(durableJobLeases.fencingToken, identity.fencingToken),
+    eq(durableJobLeases.tokenHash, hashToken(identity.leaseToken)),
+    eq(durableJobLeases.status, "active"),
+    gt(durableJobLeases.expiresAt, now),
+  );
+}
+
+function hashToken(value: string) {
+  return new Bun.CryptoHasher("sha256").update(value).digest("hex");
+}

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

@@ -0,0 +1,121 @@
+import {
+  durableJobArtifacts,
+  durableJobAttempts,
+  durableJobFailures,
+  durableJobLeases,
+  durableJobProgress,
+  durableJobRecoveries,
+  durableJobStages,
+  durableJobs,
+} from "@windy/database";
+import { artifactRef } from "@windy/storage";
+import type {
+  DurableJob,
+  DurableJobArtifact,
+  DurableJobAttempt,
+  DurableJobFailure,
+  DurableJobLease,
+  DurableJobProgress,
+  DurableJobRecovery,
+  DurableJobStage,
+} from "./types.js";
+
+const iso = (value: Date | null) => value?.toISOString();
+
+export function mapJob(row: typeof durableJobs.$inferSelect): DurableJob {
+  return {
+    ...row,
+    status: row.status as DurableJob["status"],
+    availableAt: row.availableAt.toISOString(),
+    cancelRequestedAt: iso(row.cancelRequestedAt),
+    startedAt: iso(row.startedAt),
+    finishedAt: iso(row.finishedAt),
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  };
+}
+
+export function mapStage(
+  row: typeof durableJobStages.$inferSelect,
+): DurableJobStage {
+  return {
+    ...row,
+    status: row.status as DurableJobStage["status"],
+    startedAt: iso(row.startedAt),
+    finishedAt: iso(row.finishedAt),
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  };
+}
+
+export function mapAttempt(
+  row: typeof durableJobAttempts.$inferSelect,
+): DurableJobAttempt {
+  return {
+    ...row,
+    status: row.status as DurableJobAttempt["status"],
+    startedAt: row.startedAt.toISOString(),
+    timeoutAt: row.timeoutAt.toISOString(),
+    finishedAt: iso(row.finishedAt),
+    createdAt: row.createdAt.toISOString(),
+  };
+}
+
+export function mapLease(
+  row: typeof durableJobLeases.$inferSelect,
+): DurableJobLease {
+  return {
+    ...row,
+    status: row.status as DurableJobLease["status"],
+    acquiredAt: row.acquiredAt.toISOString(),
+    heartbeatAt: row.heartbeatAt.toISOString(),
+    expiresAt: row.expiresAt.toISOString(),
+    releasedAt: iso(row.releasedAt),
+  };
+}
+
+export function mapProgress(
+  row: typeof durableJobProgress.$inferSelect,
+): DurableJobProgress {
+  return {
+    ...row,
+    totalUnits: row.totalUnits ?? undefined,
+    message: row.message ?? undefined,
+    metadata: row.metadata ?? undefined,
+    recordedAt: row.recordedAt.toISOString(),
+  };
+}
+
+export function mapArtifact(
+  row: typeof durableJobArtifacts.$inferSelect,
+): DurableJobArtifact {
+  return {
+    ...row,
+    stageId: row.stageId ?? undefined,
+    artifactRef: artifactRef(row.artifactRef),
+    expiresAt: iso(row.expiresAt),
+    createdAt: row.createdAt.toISOString(),
+  };
+}
+
+export function mapFailure(
+  row: typeof durableJobFailures.$inferSelect,
+): DurableJobFailure {
+  return {
+    ...row,
+    stageId: row.stageId ?? undefined,
+    attemptId: row.attemptId ?? undefined,
+    details: row.details ?? undefined,
+    occurredAt: row.occurredAt.toISOString(),
+  };
+}
+
+export function mapRecovery(
+  row: typeof durableJobRecoveries.$inferSelect,
+): DurableJobRecovery {
+  return {
+    ...row,
+    fromStatus: row.fromStatus as DurableJobRecovery["fromStatus"],
+    createdAt: row.createdAt.toISOString(),
+  };
+}

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

@@ -0,0 +1,214 @@
+import {
+  durableJobAttempts,
+  durableJobFailures,
+  durableJobLeases,
+  durableJobRecoveries,
+  durableJobStages,
+  durableJobs,
+} from "@windy/database";
+import { and, eq, lte, notInArray, or } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { ManualJobRecovery } from "./execution-repository.js";
+import { mapRecovery } from "./drizzle-mappers.js";
+
+export class DrizzleDurableRecoveryRepository {
+  constructor(private readonly db: NodePgDatabase) {}
+
+  async sweepExpired(now: Date, retryDelayMs: number) {
+    return this.db.transaction(async (tx) => {
+      const rows = await tx
+        .select({
+          leaseId: durableJobLeases.id,
+          jobId: durableJobLeases.jobId,
+          stageId: durableJobLeases.stageId,
+          attemptId: durableJobLeases.attemptId,
+          leaseExpiresAt: durableJobLeases.expiresAt,
+          timeoutAt: durableJobAttempts.timeoutAt,
+        })
+        .from(durableJobLeases)
+        .innerJoin(
+          durableJobAttempts,
+          eq(durableJobAttempts.id, durableJobLeases.attemptId),
+        )
+        .innerJoin(
+          durableJobStages,
+          eq(durableJobStages.id, durableJobLeases.stageId),
+        )
+        .innerJoin(durableJobs, eq(durableJobs.id, durableJobLeases.jobId))
+        .where(
+          and(
+            eq(durableJobLeases.status, "active"),
+            or(
+              lte(durableJobLeases.expiresAt, now),
+              lte(durableJobAttempts.timeoutAt, now),
+            ),
+          ),
+        )
+        .for("update", { of: durableJobLeases, skipLocked: true })
+        .limit(100);
+
+      for (const row of rows) {
+        const [job] = await tx
+          .select()
+          .from(durableJobs)
+          .where(eq(durableJobs.id, row.jobId))
+          .for("update")
+          .limit(1);
+        const [stage] = await tx
+          .select()
+          .from(durableJobStages)
+          .where(eq(durableJobStages.id, row.stageId))
+          .for("update")
+          .limit(1);
+        if (!job || !stage) throw new Error("过期租约缺少任务事实");
+        const timedOut = row.timeoutAt <= now;
+        await tx
+          .update(durableJobLeases)
+          .set({ status: "expired", releasedAt: now })
+          .where(
+            and(
+              eq(durableJobLeases.id, row.leaseId),
+              eq(durableJobLeases.status, "active"),
+            ),
+          );
+        await tx
+          .update(durableJobAttempts)
+          .set({
+            status: timedOut ? "timed-out" : "lease-expired",
+            finishedAt: now,
+          })
+          .where(eq(durableJobAttempts.id, row.attemptId));
+        await tx.insert(durableJobFailures).values({
+          id: Bun.randomUUIDv7(),
+          jobId: row.jobId,
+          stageId: row.stageId,
+          attemptId: row.attemptId,
+          code: timedOut ? "JOB_TIMEOUT" : "LEASE_EXPIRED",
+          message: timedOut ? "任务执行超时" : "Worker 租约已过期",
+          retryable: true,
+          occurredAt: now,
+        });
+        if (job.cancelRequestedAt) {
+          await cancelRemaining(tx, row.jobId, now);
+          continue;
+        }
+        const retry = stage.currentAttempt < job.maxAttempts;
+        await tx
+          .update(durableJobStages)
+          .set({
+            status: retry ? "pending" : "failed",
+            finishedAt: retry ? null : now,
+            updatedAt: now,
+          })
+          .where(eq(durableJobStages.id, row.stageId));
+        await tx
+          .update(durableJobs)
+          .set({
+            status: retry ? "queued" : "failed",
+            availableAt: retry ? new Date(now.getTime() + retryDelayMs) : now,
+            finishedAt: retry ? null : now,
+            updatedAt: now,
+          })
+          .where(eq(durableJobs.id, row.jobId));
+      }
+      return rows.length;
+    });
+  }
+
+  async recover(input: ManualJobRecovery) {
+    return this.db.transaction(async (tx) => {
+      const [job] = await tx
+        .select()
+        .from(durableJobs)
+        .where(eq(durableJobs.id, input.jobId))
+        .for("update")
+        .limit(1);
+      if (!job) throw new Error("任务不存在");
+      const [existing] = await tx
+        .select()
+        .from(durableJobRecoveries)
+        .where(
+          and(
+            eq(durableJobRecoveries.jobId, input.jobId),
+            eq(durableJobRecoveries.idempotencyKey, input.idempotencyKey),
+          ),
+        )
+        .limit(1);
+      if (existing)
+        return { recovery: mapRecovery(existing), recovered: false };
+      if (!["failed", "cancelled"].includes(job.status)) {
+        throw new Error("只有失败或已取消任务可以人工恢复");
+      }
+      const [activeLease] = await tx
+        .select({ id: durableJobLeases.id })
+        .from(durableJobLeases)
+        .where(
+          and(
+            eq(durableJobLeases.jobId, job.id),
+            eq(durableJobLeases.status, "active"),
+          ),
+        )
+        .limit(1);
+      if (activeLease) throw new Error("任务仍有活跃租约，不能人工恢复");
+      const [recovery] = await tx
+        .insert(durableJobRecoveries)
+        .values({
+          id: Bun.randomUUIDv7(),
+          jobId: job.id,
+          fromStatus: job.status,
+          requestedBy: input.requestedBy,
+          reason: input.reason,
+          idempotencyKey: input.idempotencyKey,
+          createdAt: input.now,
+        })
+        .returning();
+      await tx
+        .update(durableJobStages)
+        .set({
+          status: "pending",
+          startedAt: null,
+          finishedAt: null,
+          updatedAt: input.now,
+        })
+        .where(
+          and(
+            eq(durableJobStages.jobId, job.id),
+            notInArray(durableJobStages.status, ["succeeded"]),
+          ),
+        );
+      await tx
+        .update(durableJobs)
+        .set({
+          status: "queued",
+          availableAt: input.now,
+          cancelRequestedAt: null,
+          finishedAt: null,
+          updatedAt: input.now,
+        })
+        .where(eq(durableJobs.id, job.id));
+      if (!recovery) throw new Error("任务恢复事实写入失败");
+      return { recovery: mapRecovery(recovery), recovered: true };
+    });
+  }
+}
+
+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-repository.integration.test.ts

@@ -0,0 +1,135 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { resolve } from "node:path";
+import { artifactRef } from "@windy/storage";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import { Pool } from "pg";
+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 now = new Date("2026-07-16T08:00:00.000Z");
+
+describePostgres("PostgreSQL durable job repository", () => {
+  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_job_test_migrations",
+    });
+    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("并发幂等提交只创建一个任务，重启后可读取七类事实", async () => {
+    const repository = new DrizzleDurableJobRepository(drizzle(pool));
+    const input = {
+      handlerKey: "dictionary.import",
+      idempotencyKey: "pg-idempotency-1",
+      payload: { resource: "gender" },
+      requestedBy: "user_pg",
+      stageKeys: ["validate", "apply"],
+    };
+    const submissions = await Promise.all([
+      new DurableJobService(repository, () => now).submit(input),
+      new DurableJobService(
+        new DrizzleDurableJobRepository(drizzle(pool)),
+        () => now,
+      ).submit(input),
+    ]);
+    expect(submissions.filter(({ created }) => created)).toHaveLength(1);
+    expect(new Set(submissions.map(({ job }) => job.id)).size).toBe(1);
+
+    const jobId = submissions[0]!.job.id;
+    const initial = await repository.get(jobId);
+    const stage = initial?.stages[0];
+    if (!stage) throw new Error("任务阶段未持久化");
+    const attemptId = Bun.randomUUIDv7();
+    const leaseId = Bun.randomUUIDv7();
+    await repository.putAttempt({
+      id: attemptId,
+      jobId,
+      stageId: stage.id,
+      attemptNumber: 1,
+      status: "running",
+      handlerKey: input.handlerKey,
+      workerId: "worker-a",
+      startedAt: now.toISOString(),
+      timeoutAt: new Date(now.getTime() + 60_000).toISOString(),
+      createdAt: now.toISOString(),
+    });
+    await repository.putLease({
+      id: leaseId,
+      jobId,
+      stageId: stage.id,
+      attemptId,
+      workerId: "worker-a",
+      tokenHash: "a".repeat(64),
+      fencingToken: 1,
+      status: "active",
+      acquiredAt: now.toISOString(),
+      heartbeatAt: now.toISOString(),
+      expiresAt: new Date(now.getTime() + 30_000).toISOString(),
+    });
+    await repository.appendProgress({
+      id: Bun.randomUUIDv7(),
+      jobId,
+      stageId: stage.id,
+      attemptId,
+      sequence: 1,
+      completedUnits: 5,
+      totalUnits: 10,
+      message: "处理中",
+      recordedAt: now.toISOString(),
+    });
+    await repository.putArtifact({
+      id: Bun.randomUUIDv7(),
+      jobId,
+      stageId: stage.id,
+      kind: "result",
+      artifactRef: artifactRef("blob_0123456789abcdef0123456789abcdef"),
+      filename: "result.ndjson",
+      contentType: "application/x-ndjson",
+      byteSize: 128,
+      sha256: "b".repeat(64),
+      ownerId: "user_pg",
+      createdAt: now.toISOString(),
+    });
+    await repository.appendFailure({
+      id: Bun.randomUUIDv7(),
+      jobId,
+      stageId: stage.id,
+      attemptId,
+      code: "ROW_INVALID",
+      message: "第 6 行无效",
+      retryable: false,
+      details: { row: 6 },
+      occurredAt: now.toISOString(),
+    });
+
+    const restarted = new DrizzleDurableJobRepository(drizzle(pool));
+    expect(await restarted.get(jobId)).toMatchObject({
+      job: { id: jobId, status: "queued", payload: input.payload },
+      stages: [{ key: "validate" }, { key: "apply" }],
+      attempts: [{ id: attemptId, status: "running" }],
+      leases: [{ id: leaseId, tokenHash: "a".repeat(64) }],
+      progress: [{ sequence: 1, completedUnits: 5 }],
+      artifacts: [{ kind: "result", ownerId: "user_pg" }],
+      failures: [{ code: "ROW_INVALID", retryable: false }],
+    });
+  });
+});