@cloudnux/local-cloud-provider 0.17.0 → 0.18.0

package/dist/queue-plugin/index.d.ts

@@ -90,13 +90,17 @@ interface QueueManager {
         purged: number;
     } | null>;
 }
+type ScheduleProcessingFn = (queueName: string, queueService: QueueService, overrideDelay?: number | null) => void;
+interface SchedulerRef {
+    current?: ScheduleProcessingFn;
+}
 interface QueueDecoratorOptions {
     config: QueueConfig;
     queues: Record<string, QueueService>;
     dirtyQueues: Set<string>;
     saveQueueState?: (queueName: string, queueService: QueueService) => Promise<void>;
     loadQueueState?: (queueName: string) => Promise<void>;
-    scheduleProcessing: (queueName: string, queueService: QueueService) => void;
+    scheduleProcessing: ScheduleProcessingFn;
     processBatch: (queueName: string, queueService: QueueService) => Promise<void>;
 }
 declare module 'fastify' {
@@ -107,4 +111,4 @@ declare module 'fastify' {
 
 declare const queuesPlugin: FastifyPluginAsync<QueuePluginOptions>;
 
-export { type EventHandler, type QueueConfig, type QueueDecoratorOptions, type QueueManager, type QueueMessage, type QueuePluginOptions, type QueueRegistryItem, type QueueService, type QueueSummary, queuesPlugin };
+export { type EventHandler, type QueueConfig, type QueueDecoratorOptions, type QueueManager, type QueueMessage, type QueuePluginOptions, type QueueRegistryItem, type QueueService, type QueueSummary, type ScheduleProcessingFn, type SchedulerRef, queuesPlugin };

package/dist/queue-plugin/index.js

@@ -1042,16 +1042,40 @@ var createQueueService = (handler, module) => ({
 });
 var createQueueMessage = (body, headers) => {
   const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
-  return {
+  const message = {
     id,
     timestamp: /* @__PURE__ */ new Date(),
     attempts: 0,
     payload: body,
     attributes: headers
   };
+  const delaySeconds = Number(headers?.["x-delay-seconds"]);
+  if (delaySeconds > 0) {
+    message.nextAttempt = new Date(Date.now() + delaySeconds * 1e3);
+  }
+  return message;
+};
+var isMessageReady = (message, now = Date.now()) => {
+  return !message.nextAttempt || message.nextAttempt.getTime() <= now;
 };
 var moveToProcessing = (queueService, batchSize) => {
-  return queueService.incoming.splice(0, batchSize);
+  const now = Date.now();
+  const ready = [];
+  const remaining = [];
+  for (const message of queueService.incoming) {
+    if (ready.length < batchSize && isMessageReady(message, now)) {
+      ready.push(message);
+    } else {
+      remaining.push(message);
+    }
+  }
+  queueService.incoming = remaining;
+  return ready;
+};
+var getNextReadyDelay = (queueService) => {
+  const nextAttempts = queueService.incoming.filter((message) => message.nextAttempt).map((message) => message.nextAttempt.getTime());
+  if (nextAttempts.length === 0) return null;
+  return Math.max(0, Math.min(...nextAttempts) - Date.now());
 };
 var removeFromProcessing = (queueService, messageId) => {
   queueService.processing = queueService.processing.filter((msg) => msg.id !== messageId);
@@ -1162,7 +1186,7 @@ var handleProcessingError = async (queueName, message, queueService, config) =>
     }, delayMs);
   }
 };
-var createBatchProcessor = (processMessage, config, dirtyQueues) => async (queueName, queueService) => {
+var createBatchProcessor = (processMessage, config, dirtyQueues, schedulerRef) => async (queueName, queueService) => {
   if (queueService.timeoutId) {
     clearTimeout(queueService.timeoutId);
     queueService.timeoutId = null;
@@ -1173,18 +1197,21 @@ var createBatchProcessor = (processMessage, config, dirtyQueues) => async (queue
   try {
     queueService.processingBatch = true;
     const messagesToProcess = moveToProcessing(queueService, config.batchSize);
-    if (messagesToProcess.length === 0) {
-      return;
-    }
-    queueService.processing.push(...messagesToProcess);
-    await Promise.all(messagesToProcess.map((message) => {
-      return processMessage(queueName, message, queueService);
-    }));
-    if (config.persistence.enabled && dirtyQueues) {
-      dirtyQueues.add(queueName);
+    if (messagesToProcess.length > 0) {
+      queueService.processing.push(...messagesToProcess);
+      await Promise.all(messagesToProcess.map((message) => {
+        return processMessage(queueName, message, queueService);
+      }));
+      if (config.persistence.enabled && dirtyQueues) {
+        dirtyQueues.add(queueName);
+      }
     }
   } finally {
     queueService.processingBatch = false;
+    const nextReadyDelay = getNextReadyDelay(queueService);
+    if (nextReadyDelay !== null) {
+      schedulerRef?.current?.(queueName, queueService, nextReadyDelay);
+    }
   }
 };
 var createProcessingScheduler = (processBatch, config) => (queueName, queueService, overrideDelay = null) => {
@@ -1595,12 +1622,15 @@ var queuesPlugin = fsPlugin(async (app, options) => {
   };
   const saveDirtyQueueStates = config.persistence.enabled && saveQueueState ? createDirtyQueuesStateSaver(saveQueueState, dirtyQueues)(queues) : async () => {
   };
+  const schedulerRef = {};
   const processBatch = createBatchProcessor(
     processMessage,
     config,
-    config.persistence.enabled ? dirtyQueues : void 0
+    config.persistence.enabled ? dirtyQueues : void 0,
+    schedulerRef
   );
   const scheduleProcessing = createProcessingScheduler(processBatch, config);
+  schedulerRef.current = scheduleProcessing;
   const loadQueueState = config.persistence.enabled ? createQueueStateLoader(
     config,
     scheduleProcessing,