nuxt-cf-jobs 0.14.2 → 0.14.3

package/README.md

@@ -221,7 +221,7 @@ const route = getJobDefinition(name)
 const fullDefinition = await loadJobDefinition(name)
 ```
 
-`getJobDefinition()` reads static routing metadata without loading the handler module. Use `loadJobDefinition()` when you need the full definition. Jobs with `broadcast` also generate `JobBroadcastMessage<Name>` and `JobBroadcastEnvelope<Name>` types.
+`getJobDefinition()` returns static routing and literal policy metadata without loading the job module. It does not include executable fields such as `handle`, `input`, or `uniqueId`. Use `loadJobDefinition()` when you need the full definition. The durable `prepareJob()` helper does this automatically. Jobs with `broadcast` also generate `JobBroadcastMessage<Name>` and `JobBroadcastEnvelope<Name>` types.
 
 Runtime validation is available when you want to fail a custom startup check:
 
@@ -357,7 +357,7 @@ export default defineEventHandler(async (event) => {
 - `not-dispatched`: the row is safe in D1, but the queue binding was unavailable.
 - `dispatch-failed`: the row is safe in D1, and `cause` contains the send error.
 
-The generated `prepareJob()` validates the payload, resolves the queue, applies attempts and uniqueness, and checks the Cloudflare message size before inserting anything.
+The generated `prepareJob()` loads the full job definition, validates the payload, resolves the queue, applies attempts and uniqueness, and checks the serialized payload against the durable D1 storage limit before inserting anything.
 
 ### Recovery
 

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-cf-jobs",
   "configKey": "cfJobs",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/server/errors.js

@@ -59,7 +59,7 @@ export const jobErrors = {
       task,
       bytes,
       limit,
-      message: `Job payload exceeds Cloudflare Queue limit of ${limit} bytes for task: ${task}`
+      message: `Job payload exceeds durable storage limit of ${limit} bytes for task: ${task}`
     };
   },
   noRoute(task) {

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

@@ -3,6 +3,14 @@ import type { SendBackpressureOptions } from './queue.js';
 import type { AnyJobDefinition, JobNameOf, JobPayloadByName, JobQueueByName } from './registry.js';
 import type { Result } from './result.js';
 import type { DispatchableJob, DispatchResult, JobContext, JobControlResult, JobDefinition, JobHandler, QueueMessage, QueueSendOptions } from './types.js';
+/**
+ * Maximum serialized durable payload size.
+ *
+ * Durable payloads live in D1. Queue messages only carry `{ jobId, queue }`, so
+ * the Cloudflare Queue message limit does not apply here. This leaves 100,000
+ * bytes below D1's 2,000,000-byte row limit for storage overhead.
+ */
+export declare const DURABLE_JOB_MAX_PAYLOAD_BYTES = 1900000;
 export interface DurableJobRoute<Queue extends string = string> {
     queue: Queue;
     jobType: string;
@@ -77,8 +85,13 @@ export interface DurableJobFailureRepository {
     recordFailure: (input: RecordDurableJobFailureInput) => Promise<void>;
 }
 export interface DurableJobRegistryLike<Env = unknown, Db = unknown, Logger = unknown> {
-    /** May resolve asynchronously for lazily-loaded jobs. Unused on the producer path. */
+    /** May resolve asynchronously for lazily-loaded jobs. */
     getHandler?: (name: string) => JobHandler<unknown, Env, Db, Logger> | undefined | Promise<JobHandler<unknown, Env, Db, Logger> | undefined>;
+    /**
+     * Loads the full definition when producer policy depends on executable fields
+     * such as `input` or `uniqueId`.
+     */
+    loadJobDefinition?: (name: string) => Promise<JobDefinition<string, unknown, string, Env, Db, Logger> | undefined>;
     getJobDefinition?: (name: string) => JobDefinition<string, unknown, string, Env, Db, Logger> | undefined;
     getJobRoute?: (name: string) => DurableJobRoute<string> | undefined;
 }

package/dist/runtime/server/outbox.js

@@ -2,12 +2,13 @@ import { dispatchRegisteredJob } from "./dispatch.js";
 import { describeCause, describeCauseWithStack, formatJobError, isDurableJobOwnershipError, jobErrors, jobErrorToException } from "./errors.js";
 import { buildJobPayload } from "./payload.js";
 import { createJobTraceId, createJobUniqueKey, resolveJobMaxAttempts } from "./policy.js";
-import { CF_QUEUE_MAX_MESSAGE_BYTES, sendBatchChunked, withSendBackpressure } from "./queue.js";
+import { sendBatchChunked, withSendBackpressure } from "./queue.js";
 import { parseJobInput } from "./registry.js";
 import { err, ok, unwrapResult } from "./result.js";
 function byteLength(value) {
   return typeof Buffer !== "undefined" ? Buffer.byteLength(value, "utf8") : new TextEncoder().encode(value).byteLength;
 }
+export const DURABLE_JOB_MAX_PAYLOAD_BYTES = 19e5;
 export async function pruneDurableJobs(repository, opts) {
   const completedJobs = typeof opts.completedBefore === "number" ? await repository.pruneCompletedJobs({ before: opts.completedBefore, limit: opts.limit }) : 0;
   const failedJobs = typeof opts.failedBefore === "number" ? await repository.pruneFailedJobs({ before: opts.failedBefore, limit: opts.limit }) : 0;
@@ -31,8 +32,8 @@ export async function prepareDurableJobResult(opts) {
   const payload = buildJobPayload(opts.name, parsedPayload.data);
   const serialized = JSON.stringify(continuations ? { ...payload, _continuations: continuations } : payload);
   const bytes = byteLength(serialized);
-  if (bytes > CF_QUEUE_MAX_MESSAGE_BYTES)
-    return err(jobErrors.payloadTooLarge(opts.name, bytes, CF_QUEUE_MAX_MESSAGE_BYTES));
+  if (bytes > DURABLE_JOB_MAX_PAYLOAD_BYTES)
+    return err(jobErrors.payloadTooLarge(opts.name, bytes, DURABLE_JOB_MAX_PAYLOAD_BYTES));
   return ok({
     id: opts.id ?? crypto.randomUUID(),
     queue: route.queue,
@@ -54,9 +55,11 @@ export async function prepareDurableJob(opts) {
   return unwrapResult(await prepareDurableJobResult(opts), jobErrorToException);
 }
 export async function prepareRegisteredDurableJob(registry, opts) {
+  const definition = registry.loadJobDefinition ? await registry.loadJobDefinition(opts.name) : registry.getJobDefinition?.(opts.name);
   return prepareDurableJob({
     ...opts,
-    registry
+    registry,
+    definition
   });
 }
 function resolveDurableJobRoute(name, route, definition, registry) {

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

@@ -28,10 +28,9 @@ interface DefineJobBaseOptions<Name extends string, Payload extends object, Queu
  * A build-time registry entry that defers loading the handler module. The
  * static routing fields are AST-extracted from the job's `defineJob({...})`
  * call so the producer/consumer can route, validate queues and resolve attempts
- * WITHOUT importing (and evaluating) the handler — `load()` pulls the full
- * definition only when a handler/`input`/`failed` is actually needed (dispatch,
- * or a producer of a job that declares `input`/`unique`). This is what keeps a
- * worker from evaluating all job modules to run one job.
+ * WITHOUT importing (and evaluating) the handler. `load()` pulls the full
+ * definition for dispatch and durable producer preparation. This keeps a worker
+ * from evaluating every job module to run or prepare one job.
  */
 export interface LazyJobEntry<Name extends string = string, Queue extends string = string> {
     name: Name;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-cf-jobs",
   "type": "module",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "description": "Nuxt module for typed Cloudflare queue jobs.",
   "author": {
     "name": "Harlan Wilton",