@nicnocquee/dataqueue 1.39.0 → 1.40.0-beta.20260612032253

package/dist/index.d.cts

@@ -528,14 +528,20 @@ type JobHandlers<PayloadMap> = {
 interface ProcessorOptions {
     workerId?: string;
     /**
-     * The number of jobs to process at a time.
-     * - If not provided, the processor will process 10 jobs at a time.
-     * - In serverless functions, it's better to process less jobs at a time since serverless functions are charged by the second and have a timeout.
+     * The maximum number of jobs to claim from the queue per poll.
+     * - If not provided, up to 10 jobs are claimed per poll.
+     * - With `startInBackground`, claims are capped to the number of free
+     *   concurrency slots, so this only matters when it is below `concurrency`.
+     * - In serverless functions, it's better to claim fewer jobs at a time since serverless functions are charged by the second and have a timeout.
      */
     batchSize?: number;
     /**
-     * The maximum number of jobs to process in parallel per batch.
-     * - If not provided, all jobs in the batch are processed in parallel.
+     * The maximum number of jobs to process in parallel.
+     * - With `startInBackground`, this is the steady number of jobs kept in
+     *   flight: each slot is refilled as soon as it frees, so a slow job never
+     *   blocks the other slots.
+     * - With the one-shot `start`, this caps parallelism within the single batch.
+     * - If not provided, defaults to 3.
      * - Set to 1 to process jobs sequentially.
      * - Set to a lower value to avoid resource exhaustion.
      */
@@ -564,7 +570,8 @@ interface ProcessorOptions {
 interface Processor {
     /**
      * Start the job processor in the background.
-     * - This will run periodically (every pollInterval milliseconds or 5 seconds if not provided) and process jobs (as many as batchSize) as they become available.
+     * - Keeps up to `concurrency` jobs in flight, refilling each slot as soon as it frees instead of waiting for a whole batch to settle.
+     * - Polls every pollInterval milliseconds (5 seconds if not provided) for new work as it becomes available.
      * - **You have to call the stop method to stop the processor.**
      * - Handlers are provided per-processor when calling createProcessor.
      * - In serverless functions, it's recommended to call start instead and await it to finish.

package/dist/index.d.ts

@@ -528,14 +528,20 @@ type JobHandlers<PayloadMap> = {
 interface ProcessorOptions {
     workerId?: string;
     /**
-     * The number of jobs to process at a time.
-     * - If not provided, the processor will process 10 jobs at a time.
-     * - In serverless functions, it's better to process less jobs at a time since serverless functions are charged by the second and have a timeout.
+     * The maximum number of jobs to claim from the queue per poll.
+     * - If not provided, up to 10 jobs are claimed per poll.
+     * - With `startInBackground`, claims are capped to the number of free
+     *   concurrency slots, so this only matters when it is below `concurrency`.
+     * - In serverless functions, it's better to claim fewer jobs at a time since serverless functions are charged by the second and have a timeout.
      */
     batchSize?: number;
     /**
-     * The maximum number of jobs to process in parallel per batch.
-     * - If not provided, all jobs in the batch are processed in parallel.
+     * The maximum number of jobs to process in parallel.
+     * - With `startInBackground`, this is the steady number of jobs kept in
+     *   flight: each slot is refilled as soon as it frees, so a slow job never
+     *   blocks the other slots.
+     * - With the one-shot `start`, this caps parallelism within the single batch.
+     * - If not provided, defaults to 3.
      * - Set to 1 to process jobs sequentially.
      * - Set to a lower value to avoid resource exhaustion.
      */
@@ -564,7 +570,8 @@ interface ProcessorOptions {
 interface Processor {
     /**
      * Start the job processor in the background.
-     * - This will run periodically (every pollInterval milliseconds or 5 seconds if not provided) and process jobs (as many as batchSize) as they become available.
+     * - Keeps up to `concurrency` jobs in flight, refilling each slot as soon as it frees instead of waiting for a whole batch to settle.
+     * - Polls every pollInterval milliseconds (5 seconds if not provided) for new work as it becomes available.
      * - **You have to call the stop method to stop the processor.**
      * - Handlers are provided per-processor when calling createProcessor.
      * - In serverless functions, it's recommended to call start instead and await it to finish.

package/dist/index.js

@@ -586,8 +586,11 @@ var createProcessor = (backend, handlers, options = {}, onBeforeBatch, emit) =>
     );
   }
   let running = false;
-  let intervalId = null;
-  let currentBatchPromise = null;
+  let pollTimer = null;
+  let claimInProgress = false;
+  let pumpRequested = false;
+  let inFlight = 0;
+  const inFlightJobs = /* @__PURE__ */ new Set();
   setLogContext(options.verbose ?? false);
   const processJobs = async () => {
     if (!running) return 0;
@@ -629,29 +632,80 @@ var createProcessor = (backend, handlers, options = {}, onBeforeBatch, emit) =>
   return {
     /**
      * Start the job processor in the background.
-     * - This will run periodically (every pollInterval milliseconds or 5 seconds if not provided) and process jobs as they become available.
+     * - Keeps up to `concurrency` jobs in flight, refilling each slot as soon as
+     *   it frees instead of waiting for a whole batch to settle.
+     * - Polls every `pollInterval` milliseconds (5 seconds if not provided) for
+     *   new work and to enqueue due cron jobs.
      * - You have to call the stop method to stop the processor.
      */
     startInBackground: () => {
       if (running) return;
       log(`Starting job processor with workerId: ${workerId}`);
       running = true;
-      const scheduleNext = (immediate) => {
+      const pump = async () => {
         if (!running) return;
-        if (immediate) {
-          intervalId = setTimeout(loop, 0);
-        } else {
-          intervalId = setTimeout(loop, pollInterval);
+        if (claimInProgress) {
+          pumpRequested = true;
+          return;
+        }
+        if (inFlight >= concurrency) return;
+        claimInProgress = true;
+        pumpRequested = false;
+        let claimLimit = 0;
+        let claimed = 0;
+        try {
+          claimLimit = Math.min(concurrency - inFlight, batchSize);
+          const jobs = await backend.getNextBatch(workerId, claimLimit, jobType, groupConcurrency);
+          claimed = jobs.length;
+          for (const job of jobs) {
+            emit?.("job:processing", { jobId: job.id, jobType: job.jobType });
+            inFlight++;
+            const jobPromise = processJobWithHandlers(
+              backend,
+              job,
+              handlers,
+              emit
+            ).catch((err) => {
+              onError(err instanceof Error ? err : new Error(String(err)));
+            }).finally(() => {
+              inFlight--;
+              inFlightJobs.delete(jobPromise);
+              void pump();
+            });
+            inFlightJobs.add(jobPromise);
+          }
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          onError(err);
+          emit?.("error", err);
+        } finally {
+          claimInProgress = false;
+        }
+        const moreLikely = claimed === claimLimit || pumpRequested;
+        if (running && moreLikely && inFlight < concurrency) {
+          void pump();
         }
       };
-      const loop = async () => {
+      const tick = async () => {
         if (!running) return;
-        currentBatchPromise = processJobs();
-        const processed = await currentBatchPromise;
-        currentBatchPromise = null;
-        scheduleNext(processed === batchSize);
+        if (onBeforeBatch) {
+          try {
+            await onBeforeBatch();
+          } catch (hookError) {
+            log(`onBeforeBatch hook error: ${hookError}`);
+            const err = hookError instanceof Error ? hookError : new Error(String(hookError));
+            onError(err);
+            emit?.("error", err);
+          }
+        }
+        await pump();
+        if (running) {
+          pollTimer = setTimeout(() => {
+            void tick();
+          }, pollInterval);
+        }
       };
-      loop();
+      void tick();
     },
     /**
      * Stop the job processor that runs in the background.
@@ -660,9 +714,9 @@ var createProcessor = (backend, handlers, options = {}, onBeforeBatch, emit) =>
     stop: () => {
       log(`Stopping job processor with workerId: ${workerId}`);
       running = false;
-      if (intervalId) {
-        clearTimeout(intervalId);
-        intervalId = null;
+      if (pollTimer) {
+        clearTimeout(pollTimer);
+        pollTimer = null;
       }
     },
     /**
@@ -672,17 +726,15 @@ var createProcessor = (backend, handlers, options = {}, onBeforeBatch, emit) =>
     stopAndDrain: async (drainTimeoutMs = 3e4) => {
       log(`Stopping and draining job processor with workerId: ${workerId}`);
       running = false;
-      if (intervalId) {
-        clearTimeout(intervalId);
-        intervalId = null;
+      if (pollTimer) {
+        clearTimeout(pollTimer);
+        pollTimer = null;
       }
-      if (currentBatchPromise) {
+      if (inFlightJobs.size > 0) {
         await Promise.race([
-          currentBatchPromise.catch(() => {
-          }),
+          Promise.allSettled(Array.from(inFlightJobs)),
           new Promise((resolve) => setTimeout(resolve, drainTimeoutMs))
         ]);
-        currentBatchPromise = null;
       }
       log(`Job processor ${workerId} drained`);
     },