@cosmicdrift/kumiko-bundled-features 0.1.0

package/src/jobs/__tests__/jobs-feature.integration.ts

@@ -0,0 +1,342 @@
+import { buildServer, type JwtHelper } from "@cosmicdrift/kumiko-framework/api";
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createRegistry,
+  defineFeature,
+  type SessionUser,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import { createJobRunner, type JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
+import {
+  createTestDb,
+  createTestRedis,
+  createTestUser,
+  pushTables,
+  type TestDb,
+  type TestRedis,
+  TestUsers,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { sleep } from "@cosmicdrift/kumiko-framework/testing";
+import type { Hono } from "hono";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { JobHandlers, JobQueries } from "../constants";
+import { createJobsFeature } from "../feature";
+import { createJobRunLogger } from "../job-run-logger";
+import { jobRunLogsTable, jobRunsTable } from "../job-run-table";
+
+// --- Setup ---
+
+let testDb: TestDb;
+let testRedis: TestRedis;
+let db: DbConnection;
+let app: Hono;
+let jwt: JwtHelper;
+let jobRunner: JobRunner;
+
+const systemAdmin = TestUsers.systemAdmin;
+const normalUser = createTestUser({ id: 2, roles: ["User"] });
+const JWT_SECRET = "jobs-feature-test-secret-minimum-32-chars!!";
+
+// Track job executions
+const jobExecutions: Array<{ name: string; payload: Record<string, unknown> }> = [];
+
+// Test feature with jobs
+const appFeature = defineFeature("app", (r) => {
+  // A job that succeeds and logs
+  r.job("syncData", { trigger: { manual: true } }, async (payload, ctx) => {
+    ctx.log?.info("Starting sync...");
+    jobExecutions.push({ name: "app:job:sync-data", payload });
+    ctx.log?.info(`Synced ${Object.keys(payload).length} fields`);
+    ctx.log?.info("Sync complete");
+  });
+
+  // A job that fails
+  r.job("failingImport", { trigger: { manual: true } }, async (_payload, ctx) => {
+    ctx.log?.info("Connecting to import source...");
+    throw new Error("import source unreachable");
+  });
+
+  // A boot job
+  r.job("warmCache", { trigger: { manual: true }, runOnBoot: true }, async (payload) => {
+    jobExecutions.push({ name: "app:job:warm-cache", payload });
+  });
+});
+
+const jobsFeature = createJobsFeature();
+
+beforeAll(async () => {
+  testDb = await createTestDb();
+  testRedis = await createTestRedis();
+  db = testDb.db;
+
+  const registry = createRegistry([appFeature, jobsFeature]);
+
+  // jobRuns + jobRunLogs are projection tables (auto-pushed by
+  // pushTables via the registry-declared inline projections in jobs-feature).
+  // We need events + archived_streams for the ES writes the job-runner's
+  // logger does.
+  await pushTables(db, { jobRunsTable, jobRunLogsTable });
+  await createEventsTable(db);
+
+  const redisUrl = `redis://${testRedis.redis.options.host}:${testRedis.redis.options.port}/${testRedis.redis.options.db}`;
+  const logger = createJobRunLogger({ db, registry });
+
+  jobRunner = createJobRunner({
+    registry,
+    context: { db }, // jobRunner wired in after creation
+    redisUrl,
+    consumerLane: "worker",
+    queueNamePrefix: `kumiko-jobs-feature-test-${Date.now()}`,
+    ...logger,
+  });
+
+  // Wire jobRunner into context after creation
+  const context = { db, registry, jobRunner };
+
+  const server = buildServer({
+    registry,
+    context,
+    jwtSecret: JWT_SECRET,
+  });
+  app = server.app;
+  jwt = server.jwt;
+
+  await jobRunner.start();
+});
+
+afterAll(async () => {
+  await jobRunner.stop();
+  await testDb.cleanup();
+  await testRedis.cleanup();
+});
+
+// --- Helpers ---
+
+async function req(
+  method: string,
+  path: string,
+  user: SessionUser,
+  body?: unknown,
+): Promise<Response> {
+  const token = await jwt.sign(user);
+  const init: RequestInit = {
+    method,
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+  };
+  if (body) init.body = JSON.stringify(body);
+  return app.request(path, init);
+}
+
+async function write(user: SessionUser, type: string, payload: unknown) {
+  const res = await req("POST", "/api/write", user, { type, payload });
+  return res.json();
+}
+
+async function query(user: SessionUser, type: string, payload: unknown) {
+  const res = await req("POST", "/api/query", user, { type, payload });
+  return res.json();
+}
+
+// --- Scenario 1: Trigger a job, verify it runs and gets logged ---
+
+describe("scenario 1: trigger job → JobRun logged", () => {
+  test("SystemAdmin triggers a job via API", async () => {
+    const result = await write(systemAdmin, JobHandlers.trigger, {
+      jobName: "app:job:sync-data",
+      payload: { source: "crm" },
+    });
+    expect(result.isSuccess).toBe(true);
+    expect(result.data.jobName).toBe("app:job:sync-data");
+    expect(result.data.bullJobId).toBeDefined();
+
+    // Wait for BullMQ to process
+    await sleep(1000);
+
+    // Job actually ran
+    const executed = jobExecutions.filter((e) => e.name === "app:job:sync-data");
+    expect(executed.length).toBeGreaterThanOrEqual(1);
+    expect(executed[0]?.payload).toEqual({ source: "crm" });
+  });
+
+  test("JobRun is logged in DB with status=completed", async () => {
+    const result = await query(systemAdmin, JobQueries.list, { jobName: "app:job:sync-data" });
+    const runs = result.data.rows;
+    expect(runs.length).toBeGreaterThanOrEqual(1);
+
+    const run = runs[0];
+    expect(run.status).toBe("completed");
+    expect(run.duration).toBeGreaterThanOrEqual(0);
+    expect(run.finishedAt).toBeDefined();
+  });
+});
+
+// --- Scenario 2: Failed job → status=failed with error ---
+
+describe("scenario 2: failed job gets logged", () => {
+  test("trigger a failing job", async () => {
+    const result = await write(systemAdmin, JobHandlers.trigger, {
+      jobName: "app:job:failing-import",
+    });
+    expect(result.isSuccess).toBe(true);
+
+    // Wait for BullMQ to process and fail
+    await sleep(1500);
+  });
+
+  test("JobRun has status=failed with error message", async () => {
+    const result = await query(systemAdmin, JobQueries.list, {
+      jobName: "app:job:failing-import",
+      status: "failed",
+    });
+    const runs = result.data.rows;
+    expect(runs.length).toBeGreaterThanOrEqual(1);
+
+    const run = runs[0];
+    expect(run.status).toBe("failed");
+    expect(run.error).toContain("import source unreachable");
+  });
+});
+
+// --- Scenario 3: jobs.list with filters ---
+
+describe("scenario 3: jobs.list filters", () => {
+  test("list all runs", async () => {
+    const result = await query(systemAdmin, JobQueries.list, {});
+    expect(result.data.rows.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test("filter by status=completed", async () => {
+    const result = await query(systemAdmin, JobQueries.list, { status: "completed" });
+    for (const run of result.data.rows) {
+      expect(run.status).toBe("completed");
+    }
+  });
+
+  test("filter by jobName", async () => {
+    const result = await query(systemAdmin, JobQueries.list, { jobName: "app:job:sync-data" });
+    for (const run of result.data.rows) {
+      expect(run.jobName).toBe("app:job:sync-data");
+    }
+  });
+});
+
+// --- Scenario 4: jobs.detail ---
+
+describe("scenario 4: jobs.detail", () => {
+  test("returns single job run with all fields", async () => {
+    // Get first run from list
+    const listResult = await query(systemAdmin, JobQueries.list, { jobName: "app:job:sync-data" });
+    const runId = listResult.data.rows[0].id;
+
+    const result = await query(systemAdmin, JobQueries.details, { runId });
+    const run = result.data;
+    expect(run).not.toBeNull();
+    expect(run.id).toBe(runId);
+    expect(run.jobName).toBe("app:job:sync-data");
+    expect(run.status).toBe("completed");
+    expect(run.duration).toBeDefined();
+    expect(run.startedAt).toBeDefined();
+    expect(run.finishedAt).toBeDefined();
+  });
+
+  test("detail includes log entries from ctx.log()", async () => {
+    const listResult = await query(systemAdmin, JobQueries.list, { jobName: "app:job:sync-data" });
+    const runId = listResult.data.rows[0].id;
+
+    const result = await query(systemAdmin, JobQueries.details, { runId });
+    const run = result.data;
+
+    expect(run.logs).toBeDefined();
+    expect(run.logs.length).toBe(3);
+    expect(run.logs[0].level).toBe("info");
+    expect(run.logs[0].message).toBe("Starting sync...");
+    expect(run.logs[2].message).toBe("Sync complete");
+  });
+
+  test("failed job detail includes log entries before error", async () => {
+    const listResult = await query(systemAdmin, JobQueries.list, {
+      jobName: "app:job:failing-import",
+      status: "failed",
+    });
+    const runId = listResult.data.rows[0].id;
+
+    const result = await query(systemAdmin, JobQueries.details, { runId });
+    const run = result.data;
+
+    expect(run.logs.length).toBeGreaterThanOrEqual(2);
+    // First log is the info from before the error
+    expect(run.logs[0].message).toBe("Connecting to import source...");
+    // Last log is the error itself
+    const errorLog = run.logs.find((l: Record<string, unknown>) => l["level"] === "error");
+    expect(errorLog).toBeDefined();
+    expect(errorLog.message).toContain("import source unreachable");
+  });
+
+  test("returns null for non-existent run", async () => {
+    // Post-ES: runId is a uuid-string aggregate-id. A random v4 is
+    // guaranteed not to exist — same "miss" intent as the pre-ES `99999`.
+    const result = await query(systemAdmin, JobQueries.details, {
+      runId: "00000000-0000-4000-8000-000000099999",
+    });
+    expect(result.data).toBeNull();
+  });
+});
+
+// --- Scenario 5: jobs.retry ---
+
+describe("scenario 5: retry failed job", () => {
+  test("retry creates a new job run", async () => {
+    // Find the failed run
+    const listResult = await query(systemAdmin, JobQueries.list, {
+      jobName: "app:job:failing-import",
+      status: "failed",
+    });
+    const failedRunId = listResult.data.rows[0].id;
+
+    // Retry it
+    const result = await write(systemAdmin, JobHandlers.retry, { runId: failedRunId });
+    expect(result.isSuccess).toBe(true);
+    expect(result.data.jobName).toBe("app:job:failing-import");
+    expect(result.data.retriedFromRunId).toBe(failedRunId);
+
+    // Wait for BullMQ to process (will fail again)
+    await sleep(1500);
+
+    // Should have a new run (also failed)
+    const afterList = await query(systemAdmin, JobQueries.list, {
+      jobName: "app:job:failing-import",
+    });
+    expect(afterList.data.rows.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test("retry on non-failed job is rejected", async () => {
+    const listResult = await query(systemAdmin, JobQueries.list, { status: "completed" });
+    if (listResult.data.rows.length > 0) {
+      const completedRunId = listResult.data.rows[0].id;
+      const result = await write(systemAdmin, JobHandlers.retry, { runId: completedRunId });
+      expect(result.isSuccess).toBe(false);
+      expect(result.error.code).toBe("unprocessable");
+      expect(result.error.details).toMatchObject({ reason: "only_failed_jobs_can_be_retried" });
+    }
+  });
+});
+
+// --- Access control ---
+
+describe("access control", () => {
+  test("normal user cannot trigger jobs", async () => {
+    const res = await req("POST", "/api/write", normalUser, {
+      type: JobHandlers.trigger,
+      payload: { jobName: "app:job:sync-data" },
+    });
+    expect(res.status).toBe(403);
+  });
+
+  test("normal user cannot list job runs", async () => {
+    const res = await req("POST", "/api/query", normalUser, {
+      type: JobQueries.list,
+      payload: {},
+    });
+    expect(res.status).not.toBe(200);
+  });
+});

package/src/jobs/constants.ts

@@ -0,0 +1,21 @@
+// Feature name
+export const JOBS_FEATURE = "jobs" as const;
+
+// Qualified write handler names (QN format: scope:type:name)
+export const JobHandlers = {
+  trigger: "jobs:write:trigger",
+  retry: "jobs:write:retry",
+} as const;
+
+// Qualified query handler names (QN format: scope:type:name)
+export const JobQueries = {
+  list: "jobs:query:list",
+  details: "jobs:query:details",
+} as const;
+
+// Error codes
+export const JobErrors = {
+  unknownJob: "unknown_job",
+  notFound: "not_found",
+  onlyFailedCanRetry: "only_failed_jobs_can_be_retried",
+} as const;

package/src/jobs/events.ts

@@ -0,0 +1,39 @@
+// Event-payload schemas for the jobRun aggregate. Shared between
+// jobs-feature.ts (registers them via r.defineEvent and consumes them
+// in the inline-projections) and job-run-logger.ts (parses payloads
+// before low-level append() so out-of-dispatcher writes stay as
+// type-safe as ctx.appendEvent writes).
+//
+// Keeping them in a separate module avoids the circular import between
+// jobs-feature.ts (imports the logger) and job-run-logger.ts.
+
+import { z } from "zod";
+
+export const jobLogEntrySchema = z.object({
+  level: z.enum(["info", "warn", "error"]),
+  message: z.string(),
+  timestamp: z.string(),
+});
+
+export const runStartedSchema = z.object({
+  jobName: z.string(),
+  bullJobId: z.string(),
+  status: z.literal("running"),
+  payload: z.string().nullable(),
+  triggeredById: z.string().nullable(),
+  startedAt: z.string(),
+  attempt: z.number(),
+});
+
+export const runCompletedSchema = z.object({
+  duration: z.number(),
+  finishedAt: z.string(),
+  logs: z.array(jobLogEntrySchema),
+});
+
+export const runFailedSchema = z.object({
+  duration: z.number(),
+  finishedAt: z.string(),
+  error: z.string(),
+  logs: z.array(jobLogEntrySchema),
+});

package/src/jobs/feature.ts

@@ -0,0 +1,150 @@
+import {
+  defineApply,
+  defineFeature,
+  type FeatureDefinition,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { eq } from "drizzle-orm";
+import type { z } from "zod";
+// Event-payload schemas live in a sibling module so the logger can import
+// them without the cycle jobs-feature ↔ job-run-logger. The logger parses
+// payloads against these schemas before low-level append() — that's what
+// keeps out-of-dispatcher writes as type-safe as ctx.appendEvent.
+import { runCompletedSchema, runFailedSchema, runStartedSchema } from "./events";
+import { detailQuery } from "./handlers/detail.query";
+import { listQuery } from "./handlers/list.query";
+import { retryWrite } from "./handlers/retry.write";
+import { triggerWrite } from "./handlers/trigger.write";
+import {
+  JOB_RUN_COMPLETED_EVENT,
+  JOB_RUN_FAILED_EVENT,
+  JOB_RUN_STARTED_EVENT,
+} from "./job-run-logger";
+import { jobRunLogsTable, jobRunsTable } from "./job-run-table";
+
+export function createJobsFeature(): FeatureDefinition {
+  return defineFeature("jobs", (r) => {
+    r.systemScope();
+    // Events-only aggregate: "jobRun" has no r.entity registration, because
+    // the entire lifecycle is driven by BullMQ-callback → r.defineEvent
+    // (no executor, no CRUD). The boot-validator accepts the two
+    // projections below because every apply-key is a registered
+    // domain-event.
+    r.defineEvent("run-started", runStartedSchema);
+    r.defineEvent("run-completed", runCompletedSchema);
+    r.defineEvent("run-failed", runFailedSchema);
+
+    // Inline projection: status-row in jobRunsTable. Runs in same TX as
+    // the event-append (the logger calls runProjectionsForEvent manually
+    // because the BullMQ-callback path has no dispatcher-ctx).
+    r.projection({
+      name: "job-runs",
+      source: "jobRun",
+      table: jobRunsTable,
+      apply: {
+        [JOB_RUN_STARTED_EVENT]: defineApply<z.infer<typeof runStartedSchema>>(
+          async (event, tx) => {
+            const p = event.payload;
+            await tx.insert(jobRunsTable).values({
+              id: event.aggregateId,
+              tenantId: event.tenantId,
+              version: event.version,
+              insertedAt: event.createdAt,
+              insertedById: event.metadata?.userId ?? "system",
+              jobName: p.jobName,
+              bullJobId: p.bullJobId,
+              status: p.status,
+              payload: p.payload,
+              attempt: p.attempt,
+              startedAt: Temporal.Instant.from(p.startedAt),
+              triggeredById: p.triggeredById,
+            });
+          },
+        ),
+        [JOB_RUN_COMPLETED_EVENT]: defineApply<z.infer<typeof runCompletedSchema>>(
+          async (event, tx) => {
+            const p = event.payload;
+            await tx
+              .update(jobRunsTable)
+              .set({
+                status: "completed",
+                duration: p.duration,
+                finishedAt: Temporal.Instant.from(p.finishedAt),
+                version: event.version,
+                modifiedAt: event.createdAt,
+                modifiedById: event.metadata?.userId ?? "system",
+              })
+              .where(eq(jobRunsTable.id, event.aggregateId));
+          },
+        ),
+        [JOB_RUN_FAILED_EVENT]: defineApply<z.infer<typeof runFailedSchema>>(async (event, tx) => {
+          const p = event.payload;
+          await tx
+            .update(jobRunsTable)
+            .set({
+              status: "failed",
+              error: p.error,
+              duration: p.duration,
+              finishedAt: Temporal.Instant.from(p.finishedAt),
+              version: event.version,
+              modifiedAt: event.createdAt,
+              modifiedById: event.metadata?.userId ?? "system",
+            })
+            .where(eq(jobRunsTable.id, event.aggregateId));
+        }),
+      },
+    });
+
+    // Second inline projection — same source, different table. Expands
+    // the batched logs array from completed/failed events into N rows
+    // per run in jobRunLogsTable.
+    r.projection({
+      name: "job-run-logs",
+      source: "jobRun",
+      table: jobRunLogsTable,
+      apply: {
+        [JOB_RUN_COMPLETED_EVENT]: defineApply<z.infer<typeof runCompletedSchema>>(
+          async (event, tx) => {
+            const p = event.payload;
+            // skip: empty log batch — the worker ran silent. No child rows
+            // to insert; the completed-event alone already updated the run's
+            // status via the sibling job-runs projection.
+            if (p.logs.length === 0) return;
+            await tx.insert(jobRunLogsTable).values(
+              p.logs.map((log) => ({
+                runId: event.aggregateId,
+                level: log.level,
+                message: log.message,
+                timestamp: Temporal.Instant.from(log.timestamp),
+              })),
+            );
+          },
+        ),
+        [JOB_RUN_FAILED_EVENT]: defineApply<z.infer<typeof runFailedSchema>>(async (event, tx) => {
+          const p = event.payload;
+          // skip: empty log batch — the worker ran silent (mirror of completed)
+          if (p.logs.length === 0) return;
+          await tx.insert(jobRunLogsTable).values(
+            p.logs.map((log) => ({
+              runId: event.aggregateId,
+              level: log.level,
+              message: log.message,
+              timestamp: Temporal.Instant.from(log.timestamp),
+            })),
+          );
+        }),
+      },
+    });
+
+    const handlers = {
+      trigger: r.writeHandler(triggerWrite),
+      retry: r.writeHandler(retryWrite),
+    };
+
+    const queries = {
+      list: r.queryHandler(listQuery),
+      detail: r.queryHandler(detailQuery),
+    };
+
+    return { handlers, queries };
+  });
+}

package/src/jobs/handlers/detail.query.ts

@@ -0,0 +1,30 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/db";
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { jobRunLogsTable, jobRunsTable } from "../job-run-table";
+
+export const detailQuery = defineQueryHandler({
+  name: "details",
+  // Post-ES: runId is the uuid aggregate-id of the jobRun event-stream.
+  // Pre-ES callers passed the serial row-id; the migration is breaking
+  // for API callers (intentional — jobs is framework-ops, no external
+  // contract). z.uuid() guards against accidental number-id passing.
+  schema: z.object({ runId: z.uuid() }),
+  access: { roles: ["SystemAdmin"] },
+  handler: async (query, ctx) => {
+    const db = ctx.db;
+
+    const row = await fetchOne(db, jobRunsTable, eq(jobRunsTable.id, query.payload.runId));
+
+    if (!row) return null;
+
+    const logs = await db
+      .select()
+      .from(jobRunLogsTable)
+      .where(eq(jobRunLogsTable.runId, query.payload.runId))
+      .orderBy(jobRunLogsTable.id);
+
+    return { ...row, logs };
+  },
+});

package/src/jobs/handlers/list.query.ts

@@ -0,0 +1,36 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { and, desc, eq } from "drizzle-orm";
+import { z } from "zod";
+import { type JobRunStatus, jobRunsTable } from "../job-run-table";
+
+export const listQuery = defineQueryHandler({
+  name: "list",
+  schema: z.object({
+    jobName: z.string().optional(),
+    status: z.enum(["queued", "running", "completed", "failed"]).optional(),
+    limit: z.number().optional(),
+  }),
+  access: { roles: ["SystemAdmin"] },
+  handler: async (query, ctx) => {
+    const db = ctx.db;
+    const conditions = [];
+
+    if (query.payload.jobName) {
+      conditions.push(eq(jobRunsTable.jobName, query.payload.jobName));
+    }
+    if (query.payload.status) {
+      conditions.push(eq(jobRunsTable.status, query.payload.status as JobRunStatus));
+    }
+
+    const limit = query.payload.limit ?? 50;
+
+    const rows = await db
+      .select()
+      .from(jobRunsTable)
+      .where(conditions.length > 0 ? and(...conditions) : undefined)
+      .orderBy(desc(jobRunsTable.id))
+      .limit(limit);
+
+    return { rows };
+  },
+});

package/src/jobs/handlers/retry.write.ts

@@ -0,0 +1,69 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/db";
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  NotFoundError,
+  UnprocessableError,
+  writeFailure,
+} from "@cosmicdrift/kumiko-framework/errors";
+import type { JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
+import { parseJsonOrThrow } from "@cosmicdrift/kumiko-framework/utils";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { JobErrors } from "../constants";
+import { jobRunsTable } from "../job-run-table";
+
+type JobRunRow = {
+  readonly status: string;
+  readonly jobName: string;
+  readonly payload: string | null;
+};
+
+export const retryWrite = defineWriteHandler({
+  name: "retry",
+  // Post-ES: runId is the uuid aggregate-id. See detail.query for the
+  // rationale — jobs is framework-ops, callers are admin tooling only.
+  schema: z.object({ runId: z.uuid() }),
+  access: { roles: ["SystemAdmin"] },
+  handler: async (event, ctx) => {
+    const db = ctx.db;
+    // @cast-boundary engine-payload — JobRunner attached by app-boot via ctx-extension
+    const jobRunner = ctx["jobRunner"] as JobRunner;
+
+    const run = await fetchOne<JobRunRow>(
+      db,
+      jobRunsTable,
+      eq(jobRunsTable.id, event.payload.runId),
+    );
+
+    if (!run) {
+      return writeFailure(
+        new NotFoundError("jobRun", event.payload.runId, {
+          i18nKey: "jobs.errors.notFound",
+        }),
+      );
+    }
+
+    if (run.status !== "failed") {
+      return writeFailure(
+        new UnprocessableError(JobErrors.onlyFailedCanRetry, {
+          i18nKey: "jobs.errors.onlyFailedCanRetry",
+          details: { status: run.status },
+        }),
+      );
+    }
+
+    const payload = run.payload
+      ? parseJsonOrThrow<Record<string, unknown>>(
+          run.payload,
+          `job run ${event.payload.runId} payload`,
+        )
+      : {};
+
+    const bullJobId = await jobRunner.dispatch(run.jobName, payload);
+
+    return {
+      isSuccess: true,
+      data: { jobName: run.jobName, bullJobId, retriedFromRunId: event.payload.runId },
+    };
+  },
+});