nuxt-cf-jobs 0.0.2

package/dist/module.mjs

@@ -0,0 +1,380 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, sep, relative } from 'node:path';
+import { defineNuxtModule, createResolver, addServerImports, addTemplate, updateTemplates, useLogger, addServerPlugin, resolveFiles } from '@nuxt/kit';
+
+const WRANGLER_FILES = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
+function findWranglerConfig(rootDir) {
+  for (const name of WRANGLER_FILES) {
+    const full = resolve(rootDir, name);
+    if (existsSync(full))
+      return full;
+  }
+  return void 0;
+}
+function stripJsoncComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:"'\\])\/\/.*$/gm, (_match, prefix) => prefix);
+}
+function camelCase(key) {
+  return key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function parseTomlQueueBlocks(source) {
+  const producers = [];
+  const consumers = [];
+  const blockRe = /^\s*\[\[\s*queues\.(producers|consumers)\s*\]\]\s*$/gm;
+  const matches = [];
+  let m;
+  while ((m = blockRe.exec(source)) !== null)
+    matches.push({ kind: m[1], index: m.index + m[0].length });
+  const stopRe = /^\s*\[\[?[^\]]+\]\]?\s*$/m;
+  for (let i = 0; i < matches.length; i++) {
+    const start = matches[i].index;
+    const end = i + 1 < matches.length ? matches[i + 1].index - (matches[i + 1]?.kind.length ?? 0) : source.length;
+    const slice = source.slice(start, end);
+    const nextHeader = stopRe.exec(slice);
+    const body = nextHeader ? slice.slice(0, nextHeader.index) : slice;
+    const entry = {};
+    for (const line of body.split("\n")) {
+      const kv = line.match(/^\s*([a-z_]+)\s*=\s*(.+?)\s*(?:#.*)?$/i);
+      if (!kv)
+        continue;
+      const key = camelCase(kv[1]);
+      const raw = kv[2].trim();
+      if (raw.startsWith('"') || raw.startsWith("'"))
+        entry[key] = raw.slice(1, -1);
+      else if (/^-?\d+(?:\.\d+)?$/.test(raw))
+        entry[key] = Number(raw);
+      else
+        entry[key] = raw;
+    }
+    if (matches[i].kind === "producers" && typeof entry.binding === "string" && typeof entry.queue === "string")
+      producers.push({ binding: entry.binding, queue: entry.queue });
+    if (matches[i].kind === "consumers" && typeof entry.queue === "string") {
+      const consumer = { queue: entry.queue };
+      for (const [k, v] of Object.entries(entry)) {
+        if (k === "queue")
+          continue;
+        consumer[k] = v;
+      }
+      consumers.push(consumer);
+    }
+  }
+  return { producers, consumers };
+}
+function parseJsoncQueues(source) {
+  const stripped = stripJsoncComments(source);
+  let parsed = {};
+  try {
+    parsed = JSON.parse(stripped);
+  } catch {
+    return { producers: [], consumers: [] };
+  }
+  const queues = parsed.queues ?? {};
+  const producers = Array.isArray(queues.producers) ? queues.producers : [];
+  const consumers = Array.isArray(queues.consumers) ? queues.consumers : [];
+  return {
+    producers: producers.filter((p) => !!p && typeof p === "object" && typeof p.binding === "string" && typeof p.queue === "string").map((p) => ({ binding: p.binding, queue: p.queue })),
+    consumers: consumers.filter((c) => !!c && typeof c === "object").map((c) => {
+      const out = { queue: String(c.queue ?? "") };
+      for (const [k, v] of Object.entries(c)) {
+        if (k === "queue")
+          continue;
+        out[camelCase(k)] = v;
+      }
+      return out;
+    }).filter((c) => c.queue.length > 0)
+  };
+}
+function parseWranglerConfig(path) {
+  const source = readFileSync(path, "utf8");
+  const isJson = path.endsWith(".jsonc") || path.endsWith(".json");
+  const parsed = isJson ? parseJsoncQueues(source) : parseTomlQueueBlocks(source);
+  return { path, producers: parsed.producers, consumers: parsed.consumers };
+}
+function crossCheckWrangler(wrangler, expectations) {
+  if (!wrangler)
+    return [];
+  const issues = [];
+  const producersByBinding = new Map(wrangler.producers.map((p) => [p.binding, p]));
+  const consumersByQueue = new Map(wrangler.consumers.map((c) => [c.queue, c]));
+  for (const exp of expectations) {
+    const producer = producersByBinding.get(exp.binding);
+    if (!producer) {
+      issues.push({
+        reason: "missing-producer",
+        logical: exp.logical,
+        detail: `no [[queues.producers]] with binding="${exp.binding}" in ${wrangler.path}`
+      });
+    } else if (exp.explicitQueueName && producer.queue !== exp.cfQueueName) {
+      issues.push({
+        reason: "producer-queue-mismatch",
+        logical: exp.logical,
+        detail: `producer binding="${exp.binding}" points at queue="${producer.queue}" but module expects "${exp.cfQueueName}"`
+      });
+    }
+    if (exp.hasConsumer !== false) {
+      const effectiveQueueName = producer && !exp.explicitQueueName ? producer.queue : exp.cfQueueName;
+      const consumer = consumersByQueue.get(effectiveQueueName);
+      if (!consumer) {
+        issues.push({
+          reason: "missing-consumer",
+          logical: exp.logical,
+          detail: `no [[queues.consumers]] for queue="${effectiveQueueName}" (handler is registered but wrangler won't deliver to it)`
+        });
+      } else if (exp.maxRetries !== void 0 && consumer.maxRetries !== void 0 && consumer.maxRetries < exp.maxRetries - 1) {
+        issues.push({
+          reason: "max-retries-too-low",
+          logical: exp.logical,
+          detail: `consumer max_retries=${consumer.maxRetries} is below tries=${exp.maxRetries} from job definitions (allows only ${consumer.maxRetries + 1} deliveries)`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function renderSuggestedWranglerToml(expectations) {
+  const lines = ["# Suggested wrangler.toml snippet for nuxt-cf-jobs queues.", "# Generated; merge into your existing wrangler config.", ""];
+  for (const exp of expectations) {
+    lines.push("[[queues.producers]]");
+    lines.push(`binding = "${exp.binding}"`);
+    lines.push(`queue = "${exp.cfQueueName}"`);
+    lines.push("");
+  }
+  for (const exp of expectations) {
+    if (exp.hasConsumer === false)
+      continue;
+    lines.push("[[queues.consumers]]");
+    lines.push(`queue = "${exp.cfQueueName}"`);
+    if (exp.maxRetries !== void 0)
+      lines.push(`max_retries = ${exp.maxRetries}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-cf-jobs",
+    configKey: "cfJobs"
+  },
+  defaults: {
+    queues: {},
+    jobsDir: "server/jobs",
+    jobsPattern: "**/*.ts",
+    jobsIgnore: ["**/_*.ts", "**/*.d.ts", "**/*.test.ts", "**/*.spec.ts"],
+    registryAlias: "#cf-jobs/app"
+  },
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.alias["#cf-jobs/server"] = resolver.resolve("./runtime/server");
+    addServerImports([
+      { name: "defineJob", from: resolver.resolve("./runtime/server/registry") }
+    ]);
+    const registryTemplate = addTemplate({
+      filename: "cf-jobs/registry.ts",
+      write: true,
+      getContents: async () => generateRegistryTemplate(options, nuxt.options.rootDir, resolve(nuxt.options.buildDir, "cf-jobs"))
+    });
+    nuxt.options.alias[options.registryAlias ?? "#cf-jobs/app"] = registryTemplate.dst;
+    nuxt.hooks.hook("builder:watch", (async (_event, path) => {
+      if (!isWatchedJobPath(path, options, nuxt.options.rootDir))
+        return;
+      await updateTemplates({ filter: (template) => template.dst === registryTemplate.dst });
+    }));
+    if (options.defaultQueue && !options.queues[options.defaultQueue])
+      useLogger("nuxt-cf-jobs").warn(`cfJobs.defaultQueue="${options.defaultQueue}" is not a key of cfJobs.queues`);
+    nuxt.options.runtimeConfig.cfJobs = {
+      ...nuxt.options.runtimeConfig.cfJobs ?? {},
+      queues: nuxt.options.runtimeConfig.cfJobs?.queues ?? options.queues,
+      defaultQueue: nuxt.options.runtimeConfig.cfJobs?.defaultQueue ?? options.defaultQueue
+    };
+    if (nuxt.options.dev)
+      addServerPlugin(resolver.resolve("./runtime/server/plugins/dev-queues"));
+    if (options.validateWrangler !== false)
+      runWranglerCrossCheck(options, nuxt.options.rootDir, resolve(nuxt.options.buildDir, "cf-jobs"), nuxt.options.nitro);
+  }
+});
+function runWranglerCrossCheck(options, rootDir, templateDir, nitroOptions) {
+  const logger = useLogger("nuxt-cf-jobs");
+  const wranglerPath = options.wranglerPath ? resolve(rootDir, options.wranglerPath) : findWranglerConfig(rootDir);
+  const expectations = [];
+  for (const [logical, config] of Object.entries(options.queues ?? {})) {
+    const binding = typeof config === "string" ? config : config?.binding;
+    if (!binding)
+      continue;
+    const explicitQueueName = typeof config === "object" && !!config?.queueName;
+    const cfQueueName = explicitQueueName ? config.queueName : logical;
+    expectations.push({ logical, binding, cfQueueName, explicitQueueName });
+  }
+  if (expectations.length === 0)
+    return;
+  const suggested = renderSuggestedWranglerToml(expectations);
+  addTemplate({
+    filename: "cf-jobs/wrangler.suggested.toml",
+    write: true,
+    getContents: () => suggested
+  });
+  const nitroQueues = readNitroCloudflareQueues(nitroOptions);
+  const fileWrangler = wranglerPath ? parseWranglerConfig(wranglerPath) : void 0;
+  const merged = mergeWranglerSources(fileWrangler, nitroQueues, wranglerPath ?? rootDir);
+  if (!merged) {
+    logger.warn(`No wrangler.{toml,jsonc,json} found in ${rootDir} and no queues declared via nitro.cloudflare.wrangler. See ${resolve(templateDir, "wrangler.suggested.toml")} for the expected [[queues.producers]] / [[queues.consumers]] blocks.`);
+    return;
+  }
+  const issues = crossCheckWrangler(merged, expectations);
+  if (issues.length === 0)
+    return;
+  const lines = issues.map((i) => `  - [${i.logical}] ${i.reason}: ${i.detail}`);
+  logger.warn(`nuxt-cf-jobs / wrangler config drift in ${merged.path}:
+${lines.join("\n")}
+See ${resolve(templateDir, "wrangler.suggested.toml")} for the expected blocks.`);
+}
+function readNitroCloudflareQueues(nitroOptions) {
+  const cf = nitroOptions?.cloudflare;
+  const queues = cf?.wrangler?.queues ?? cf?.deploy?.configuration?.queues;
+  if (!queues)
+    return void 0;
+  const producers = [];
+  const consumers = [];
+  for (const p of queues.producers ?? []) {
+    if (!p || typeof p !== "object")
+      continue;
+    const obj = p;
+    if (typeof obj.binding === "string" && typeof obj.queue === "string")
+      producers.push({ binding: obj.binding, queue: obj.queue });
+  }
+  for (const c of queues.consumers ?? []) {
+    if (!c || typeof c !== "object")
+      continue;
+    const obj = c;
+    if (typeof obj.queue !== "string")
+      continue;
+    const consumer = { queue: obj.queue };
+    for (const [k, v] of Object.entries(obj)) {
+      if (k === "queue")
+        continue;
+      consumer[k.replace(/_([a-z])/g, (_, c2) => c2.toUpperCase())] = v;
+    }
+    consumers.push(consumer);
+  }
+  return { producers, consumers };
+}
+function mergeWranglerSources(fileWrangler, nitroQueues, fallbackPath) {
+  if (!fileWrangler && !nitroQueues)
+    return void 0;
+  const producerKey = (p) => `${p.binding}::${p.queue}`;
+  const consumerKey = (c) => c.queue;
+  const producers = /* @__PURE__ */ new Map();
+  const consumers = /* @__PURE__ */ new Map();
+  for (const p of fileWrangler?.producers ?? [])
+    producers.set(producerKey(p), p);
+  for (const c of fileWrangler?.consumers ?? [])
+    consumers.set(consumerKey(c), c);
+  for (const p of nitroQueues?.producers ?? [])
+    producers.set(producerKey(p), p);
+  for (const c of nitroQueues?.consumers ?? [])
+    consumers.set(consumerKey(c), c);
+  return {
+    path: fileWrangler?.path ?? `${fallbackPath} (nitro.cloudflare.deploy.configuration)`,
+    producers: [...producers.values()],
+    consumers: [...consumers.values()]
+  };
+}
+async function generateRegistryTemplate(options, rootDir, templateDir) {
+  const files = await resolveJobFiles(options, rootDir);
+  assertUniqueGeneratedJobNames(files, options, rootDir);
+  const imports = files.map((file, index) => {
+    return `import job${index} from ${JSON.stringify(toImportPath(templateDir, file))}`;
+  });
+  const loaders = files.map((file) => {
+    return `  ${JSON.stringify(toJobName(file, options, rootDir))}: () => import(${JSON.stringify(toImportPath(templateDir, file))}).then(m => m.default),`;
+  });
+  const jobItems = files.map((_, index) => `job${index}`).join(", ");
+  return [
+    "/* This file is generated by nuxt-cf-jobs. Do not edit directly. */",
+    `import { createCfJobsApp } from '#cf-jobs/server'`,
+    `import { useRuntimeConfig } from '#imports'`,
+    `import type { JobDefinitionsByNameOfLoaders, JobMessageByName, JobMessageByQueue, JobNameOf, JobPayloadByName, JobPayloadOf, JobQueueByName, QueueNameOf } from '#cf-jobs/server'`,
+    `export type { QueueConsumerOptions } from '#cf-jobs/server'`,
+    ...imports,
+    "",
+    "export const jobLoaders = {",
+    ...loaders,
+    "} as const",
+    `export const jobs = [${jobItems}] as const`,
+    `export const app = createCfJobsApp(jobs, useRuntimeConfig as never, { defaultQueue: ${options.defaultQueue ? JSON.stringify(options.defaultQueue) : "undefined"} })`,
+    "export const jobRegistry = app.jobRegistry",
+    "",
+    "export type Jobs = typeof jobs",
+    "export type JobsByName = JobDefinitionsByNameOfLoaders<typeof jobLoaders>",
+    "export type JobName = keyof JobsByName & JobNameOf<Jobs>",
+    "export type JobDefinitionOf<Name extends JobName> = JobsByName[Name]",
+    "export type QueueName = QueueNameOf<Jobs>",
+    "export type JobPayload<Name extends JobName> = JobPayloadOf<JobDefinitionOf<Name>>",
+    "export type JobQueue<Name extends JobName> = JobQueueByName<Jobs, Name>",
+    "export type JobMessage<Name extends JobName> = JobMessageByName<Jobs, Name>",
+    "export type QueueMessage<Queue extends QueueName> = JobMessageByQueue<Jobs, Queue>",
+    "",
+    "export const {",
+    "  getHandler,",
+    "  getJobDefinition,",
+    "  getJobQueue,",
+    "  getJobRoute,",
+    "  validateRegistry,",
+    "  validateQueueBindings,",
+    "  assertQueueBindings,",
+    "  getQueue,",
+    "  buildJobPayload,",
+    "  prepareJob,",
+    "  registerQueueConsumer,",
+    "} = app",
+    ""
+  ].join("\n");
+}
+async function resolveJobFiles(options, rootDir) {
+  const dirs = toArray(options.jobsDir ?? "server/jobs");
+  const pattern = options.jobsPattern ?? "**/*.ts";
+  const ignore = options.jobsIgnore ?? [];
+  const files = await Promise.all(dirs.map((dir) => {
+    const resolvedDir = resolve(rootDir, dir);
+    if (!existsSync(resolvedDir))
+      return [];
+    return resolveFiles(resolvedDir, pattern, { ignore });
+  }));
+  return files.flat();
+}
+function assertUniqueGeneratedJobNames(files, options, rootDir) {
+  const seen = /* @__PURE__ */ new Map();
+  const duplicates = [];
+  for (const file of files) {
+    const name = toJobName(file, options, rootDir);
+    const previous = seen.get(name);
+    if (previous)
+      duplicates.push(`${name} (${previous}, ${file})`);
+    else
+      seen.set(name, file);
+  }
+  if (duplicates.length > 0)
+    throw new Error(`Duplicate nuxt-cf-jobs generated job names: ${duplicates.join(", ")}`);
+}
+function isWatchedJobPath(path, options, rootDir) {
+  const dirs = toArray(options.jobsDir ?? "server/jobs").map((dir) => resolve(rootDir, dir));
+  const absolutePath = resolve(rootDir, path);
+  return dirs.some((dir) => absolutePath === dir || absolutePath.startsWith(dir + sep));
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function toImportPath(fromDir, file) {
+  const path = relative(fromDir, file).replace(/\\/g, "/").replace(/\.[cm]?tsx?$/, "");
+  return path.startsWith(".") ? path : `./${path}`;
+}
+function toJobName(file, options, rootDir) {
+  const jobDirs = toArray(options.jobsDir ?? "server/jobs");
+  const dirs = jobDirs.map((dir2) => resolve(rootDir, dir2)).sort((a, b) => b.length - a.length);
+  const dir = dirs.find((dir2) => file.startsWith(`${dir2}/`) || file === dir2);
+  const fallbackDir = jobDirs[0] ?? "server/jobs";
+  const path = relative(dir ?? resolve(rootDir, fallbackDir), file).replace(/\\/g, "/").replace(/\.[cm]?tsx?$/, "");
+  return path.replace(/\/index$/, "");
+}
+
+export { module$1 as default };

package/dist/runtime/server/app.d.ts

@@ -0,0 +1,80 @@
+import type { AnyJobDefinition, JobNameOf, JobPayloadByName, JobQueueByName } from './registry.js';
+import type { PrepareRegisteredDurableJobOptions } from './outbox.js';
+import type { QueueSource, RegisterRegisteredQueueConsumerOptions } from './queue.js';
+import type { QueueBindingsConfig } from './types.js';
+import { createJobQueue } from './queue.js';
+export interface CfJobsRuntimeConfig {
+    cfJobs: {
+        queues: QueueBindingsConfig;
+    };
+}
+export type CfJobsQueueConsumerOptions<Env extends Record<string, unknown>, Db, Logger> = Omit<RegisterRegisteredQueueConsumerOptions<Env, Db, Logger>, 'registry' | 'queues'>;
+export interface CreateCfJobsAppOptions {
+    /** Fallback queue applied to jobs whose `defineJob` omits `queue`. */
+    defaultQueue?: string;
+}
+export declare function createCfJobsApp<const Jobs extends readonly AnyJobDefinition[]>(jobs: Jobs, useRuntimeConfig: (event?: unknown) => CfJobsRuntimeConfig, appOpts?: CreateCfJobsAppOptions): {
+    jobs: Jobs;
+    jobRegistry: {
+        jobs: Jobs;
+        handlers: Map<string, import("./types.js").JobHandler<unknown, unknown, unknown, unknown>>;
+        getHandler(name: string): import("./types.js").JobHandler<unknown, unknown, unknown, unknown> | undefined;
+        getJobDefinition: {
+            <Name extends JobNameOf<Jobs>>(name: Name): Extract<Jobs[number], {
+                name: Name;
+            }> | undefined;
+            (name: string): AnyJobDefinition | undefined;
+        };
+        getJobQueue: {
+            <Name extends JobNameOf<Jobs>>(name: Name): JobQueueByName<Jobs, Name> | undefined;
+            (name: string): string | undefined;
+        };
+        buildPayload<Name extends JobNameOf<Jobs>>(name: Name, payload: JobPayloadByName<Jobs, Name>): {
+            _task: Name;
+        } & JobPayloadByName<Jobs, Name>;
+        getJobRoute(name: string): {
+            queue: string;
+            jobType: string;
+        } | undefined;
+        validate(expectedTasks: readonly string[]): {
+            missing: string[];
+            extra: string[];
+        };
+    };
+    getHandler: (name: string) => import("./types.js").JobHandler<unknown, unknown, unknown, unknown> | undefined;
+    getJobDefinition: {
+        <Name extends JobNameOf<Jobs>>(name: Name): Extract<Jobs[number], {
+            name: Name;
+        }> | undefined;
+        (name: string): AnyJobDefinition | undefined;
+    };
+    getJobQueue: {
+        <Name extends JobNameOf<Jobs>>(name: Name): JobQueueByName<Jobs, Name> | undefined;
+        (name: string): string | undefined;
+    };
+    getJobRoute: (name: string) => {
+        queue: string;
+        jobType: string;
+    } | undefined;
+    validateRegistry: (expectedTasks: readonly string[]) => {
+        missing: string[];
+        extra: string[];
+    };
+    validateQueueBindings: (queues?: QueueBindingsConfig) => import("./queue.js").QueueBindingValidationIssue[];
+    assertQueueBindings: (queues?: QueueBindingsConfig) => void;
+    getQueue: {
+        <const Job extends Jobs[number]>(job: Job): ReturnType<typeof createJobQueue<Job>>;
+        <const Job extends Jobs[number]>(source: QueueSource | undefined, job: Job): ReturnType<typeof createJobQueue<Job>>;
+    };
+    buildJobPayload: <Name extends JobNameOf<Jobs>>(name: Name, payload: JobPayloadByName<Jobs, Name>) => {
+        _task: Name;
+    } & JobPayloadByName<Jobs, Name>;
+    prepareJob: <Name extends JobNameOf<Jobs>>(opts: PrepareRegisteredDurableJobOptions<Jobs, Name>) => Promise<import("./outbox.js").DurableJobRecord<JobQueueByName<Jobs, Name>>>;
+    registerQueueConsumer: <Env extends Record<string, unknown>, Db, Logger>(nitroApp: {
+        hooks: {
+            hook: (name: any, handler: any) => void;
+        };
+    }, opts: CfJobsQueueConsumerOptions<Env, Db, Logger>) => void;
+};
+export type CfJobsApp<Jobs extends readonly AnyJobDefinition[]> = ReturnType<typeof createCfJobsApp<Jobs>>;
+export type QueueConsumerOptions<Env extends Record<string, unknown>, Db, Logger> = CfJobsQueueConsumerOptions<Env, Db, Logger>;

package/dist/runtime/server/app.js

@@ -0,0 +1,81 @@
+import { defineJobRegistry } from "./registry.js";
+import { prepareRegisteredDurableJob } from "./outbox.js";
+import {
+  assertJobQueueBindings,
+  createJobQueue,
+  registerRegisteredQueueConsumer,
+  resolveNitroTaskEnv,
+  validateJobQueueBindings,
+  validateQueueBindingShape,
+  validateQueueConsumerConfig
+} from "./queue.js";
+import { validateJobDefinitions } from "./registry.js";
+export function createCfJobsApp(jobs, useRuntimeConfig, appOpts = {}) {
+  const effectiveJobs = appOpts.defaultQueue ? jobs.map((job) => job.queue ? job : { ...job, queue: appOpts.defaultQueue }) : jobs;
+  const jobRegistry = defineJobRegistry(effectiveJobs);
+  function getQueue(sourceOrJob, maybeJob) {
+    const isJobOnly = maybeJob === void 0 && isJobDefinition(sourceOrJob);
+    const job = isJobOnly ? sourceOrJob : maybeJob;
+    const source = isJobOnly ? void 0 : sourceOrJob;
+    const resolvedSource = source ?? (() => {
+      const env = resolveNitroTaskEnv();
+      return env ? { context: { cloudflare: { env } } } : void 0;
+    })();
+    const runtimeConfig = resolvedSource && typeof resolvedSource === "object" && "context" in resolvedSource ? useRuntimeConfig(resolvedSource) : useRuntimeConfig();
+    return createJobQueue(resolvedSource, runtimeConfig.cfJobs.queues, job);
+  }
+  function buildJobPayload(name, payload) {
+    return jobRegistry.buildPayload(name, payload);
+  }
+  function prepareJob(opts) {
+    return prepareRegisteredDurableJob(jobRegistry, opts);
+  }
+  let startupLogged = false;
+  function logStartupWarnings(queues) {
+    if (startupLogged)
+      return;
+    startupLogged = true;
+    const issues = [];
+    for (const issue of validateJobDefinitions(effectiveJobs))
+      issues.push(`[job:${issue.name}] ${issue.reason}`);
+    for (const issue of validateQueueBindingShape(queues))
+      issues.push(`[queue:${issue.queue}] ${issue.reason}: ${issue.detail}`);
+    for (const issue of validateJobQueueBindings(queues, effectiveJobs))
+      issues.push(`[job:${issue.jobName}] missing binding for queue "${issue.queue}"`);
+    for (const issue of validateQueueConsumerConfig(queues, effectiveJobs))
+      issues.push(`[job:${issue.jobName ?? "?"}@${issue.queue}] ${issue.reason}: ${issue.detail}`);
+    if (issues.length === 0)
+      return;
+    console.warn(`[nuxt-cf-jobs] configuration warnings:
+${issues.map((i) => `  - ${i}`).join("\n")}`);
+  }
+  function registerQueueConsumer(nitroApp, opts) {
+    const queues = useRuntimeConfig().cfJobs.queues;
+    logStartupWarnings(queues);
+    return registerRegisteredQueueConsumer(nitroApp, {
+      ...opts,
+      registry: jobRegistry,
+      queues: () => useRuntimeConfig().cfJobs.queues
+    });
+  }
+  const validateQueueBindings = (queues = useRuntimeConfig().cfJobs.queues) => validateJobQueueBindings(queues, effectiveJobs);
+  const assertQueueBindings = (queues = useRuntimeConfig().cfJobs.queues) => assertJobQueueBindings(queues, effectiveJobs);
+  return {
+    jobs: effectiveJobs,
+    jobRegistry,
+    getHandler: jobRegistry.getHandler,
+    getJobDefinition: jobRegistry.getJobDefinition,
+    getJobQueue: jobRegistry.getJobQueue,
+    getJobRoute: jobRegistry.getJobRoute,
+    validateRegistry: jobRegistry.validate,
+    validateQueueBindings,
+    assertQueueBindings,
+    getQueue,
+    buildJobPayload,
+    prepareJob,
+    registerQueueConsumer
+  };
+}
+function isJobDefinition(value) {
+  return !!value && typeof value === "object" && typeof value.name === "string" && typeof value.handle === "function";
+}

package/dist/runtime/server/d1.d.ts

@@ -0,0 +1,119 @@
+import type { DurableJobFailureRepository, DurableJobLifecycle, DurableJobRecord, DurableJobRecoveryRepository, DurableJobRepository, ReleaseDurableJobOptions } from './outbox.js';
+export interface D1PreparedStatementLike<T = unknown> {
+    bind: (...values: unknown[]) => D1PreparedStatementLike<T>;
+    run: () => Promise<{
+        success?: boolean;
+        meta?: {
+            changes?: number;
+        };
+    }>;
+    first: <Result = T>() => Promise<Result | null>;
+    all?: <Result = T>() => Promise<{
+        results?: Result[];
+    }>;
+}
+export interface D1DatabaseLike {
+    exec: (query: string) => Promise<unknown>;
+    prepare: <T = unknown>(query: string) => D1PreparedStatementLike<T>;
+    /** Optional batch API matching `D1Database.batch`. When absent, batched ops fall back to sequential `.run()`. */
+    batch?: (statements: D1PreparedStatementLike<unknown>[]) => Promise<Array<{
+        success?: boolean;
+        meta?: {
+            changes?: number;
+        };
+    }>>;
+}
+export interface D1DurableJobRecord<Queue extends string = string> {
+    id: string;
+    queue: Queue;
+    job_type: string;
+    batch_id: string | null;
+    user_id: number | null;
+    site_id: string | null;
+    partner_id: string | null;
+    trace_id: string | null;
+    unique_key: string | null;
+    payload: string;
+    attempts: number;
+    max_attempts: number;
+    reserved_at: number | null;
+    available_at: number;
+    created_at: number;
+    completed_at: number | null;
+    failed_at: number | null;
+    last_error: string | null;
+    retry_reasons?: string | null;
+    rows_fetched?: number | null;
+    rows_inserted?: number | null;
+    d1_rows_read?: number | null;
+    d1_rows_written?: number | null;
+    duration_ms?: number | null;
+}
+export interface D1FailedDurableJobRecord<Queue extends string = string> {
+    id: string;
+    queue: Queue;
+    job_type: string;
+    batch_id: string | null;
+    user_id: number | null;
+    site_id: string | null;
+    partner_id: string | null;
+    trace_id: string | null;
+    unique_key: string | null;
+    payload: string;
+    exception: string;
+    attempts: number;
+    max_attempts: number;
+    failed_at: number;
+}
+export interface D1DurableJobRepositoryOptions<Queue extends string = string> {
+    jobsTable?: string;
+    failedJobsTable?: string;
+    batchesTable?: string;
+    /** Fire-and-forget hook invoked after a successful claim. Errors are swallowed. */
+    onJobClaimed?: (input: {
+        job: D1DurableJobRecord<Queue>;
+    }) => void;
+    /** Fire-and-forget hook invoked after `completeJob` writes succeed. Errors are swallowed. */
+    onJobCompleted?: (input: {
+        job: D1DurableJobRecord<Queue>;
+        durationMs: number | null;
+        result?: unknown;
+    }) => void;
+    /** Fire-and-forget hook invoked after `failJob` writes succeed. Errors are swallowed. */
+    onJobFailed?: (input: {
+        job: D1DurableJobRecord<Queue>;
+        error: string;
+    }) => void;
+    /** Fire-and-forget hook invoked after `releaseJob` writes succeed. Errors are swallowed. */
+    onJobReleased?: (input: {
+        job: D1DurableJobRecord<Queue>;
+        opts: ReleaseDurableJobOptions | undefined;
+    }) => void;
+}
+export interface D1InsertJobsChunkResult {
+    ok: boolean;
+    ids: string[];
+    changes: number;
+    error?: unknown;
+}
+export interface D1InsertJobsResult<Queue extends string = string> {
+    inserted: Array<DurableJobRecord<Queue>>;
+    chunks: D1InsertJobsChunkResult[];
+}
+export type D1DurableJobRepository<Queue extends string = string> = DurableJobRepository<Queue, DurableJobRecord<Queue>> & DurableJobRecoveryRepository<Queue, D1DurableJobRecord<Queue>> & DurableJobLifecycle<D1DurableJobRecord<Queue>> & DurableJobFailureRepository & {
+    migrate: () => Promise<void>;
+    insertJobs: (records: readonly DurableJobRecord<Queue>[], opts?: {
+        batchSize?: number;
+    }) => Promise<D1InsertJobsResult<Queue>>;
+    toDispatchableJob: (job: D1DurableJobRecord<Queue>) => {
+        id: string;
+        queue: Queue;
+        payload: Record<string, unknown>;
+        attempts: number;
+        batchId: string | null;
+        siteId: string | null;
+        userId: number | null;
+    };
+};
+export declare const d1DurableJobMigrationSql: string[];
+export declare function createD1DurableJobRepository<Queue extends string = string>(db: D1DatabaseLike, opts?: D1DurableJobRepositoryOptions<Queue>): D1DurableJobRepository<Queue>;