@cloudnux/local-cloud-provider 0.16.0 → 0.18.0

package/dist/dev-console-plugin/index.d.ts

@@ -32,11 +32,11 @@ interface QueueConfig {
     maxConcurrent: number;
     retryBackoff: boolean;
     persistence: {
-        enabled: boolean;
+        enabled?: boolean;
         directory: string;
-        saveInterval: number;
-        saveOnShutdown: boolean;
-        loadOnStartup: boolean;
+        saveInterval?: number;
+        saveOnShutdown?: boolean;
+        loadOnStartup?: boolean;
     };
 }
 interface QueueSummary {

package/dist/dev-console-plugin/index.js

@@ -1009,6 +1009,7 @@ import path3 from "path";
 import fastifyStatic from "@fastify/static";
 import fsPlugin4 from "fastify-plugin";
 import { createRequire } from "module";
+import { WebSocketConnectionGoneError as WebSocketConnectionGoneError2 } from "@cloudnux/core-cloud-provider";
 
 // src/queue-plugin/plugin.ts
 import fsPlugin from "fastify-plugin";
@@ -1048,16 +1049,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);
@@ -1168,7 +1193,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;
@@ -1179,18 +1204,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) => {
@@ -1233,7 +1261,7 @@ var createPersistenceInitializer = (config, loadAllQueueStates, saveDirtyQueueSt
     if (config.persistence.loadOnStartup) {
       await loadAllQueueStates();
     }
-    if (config.persistence.saveInterval > 0) {
+    if (config.persistence.saveInterval && config.persistence.saveInterval > 0) {
       intervalIdHolder.id = setInterval(saveDirtyQueueStates, config.persistence.saveInterval);
     }
     if (config.persistence.saveOnShutdown) {
@@ -1601,12 +1629,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,
@@ -2300,7 +2331,7 @@ var initializeScheduler = async (state, scheduleJobFn) => {
       state.schedulers = schedulers;
       state.executionHistory = executionHistory;
     }
-    const tickInterval = state.config.persistence.saveInterval > 0 ? state.config.persistence.saveInterval : state.config.cleanup.cleanupInterval;
+    const tickInterval = (state.config.persistence.saveInterval || 0) > 0 ? state.config.persistence.saveInterval : state.config.cleanup.cleanupInterval;
     state.tickInterval = setInterval(async () => {
       if (state.isDirty && state.config.persistence.enabled) {
         state.isDirty = false;
@@ -2646,6 +2677,7 @@ var schedulerPlugin = fsPlugin2(async (app, options) => {
 import crypto from "crypto";
 import fsPlugin3 from "fastify-plugin";
 import websocketPlugin from "@fastify/websocket";
+import { WebSocketConnectionGoneError } from "@cloudnux/core-cloud-provider";
 var DEFAULT_CONFIG3 = {
   routeKeyField: "action"
 };
@@ -2752,7 +2784,7 @@ var websocketsPlugin = fsPlugin3(async (app, options) => {
     async sendToClient(connectionId, data) {
       const connection = connections.get(connectionId);
       if (!connection) {
-        throw new Error(`WebSocket connection ${connectionId} not found`);
+        throw new WebSocketConnectionGoneError(connectionId);
       }
       const payload = typeof data === "string" ? data : JSON.stringify(data);
       connection.socket.send(payload);
@@ -2760,7 +2792,7 @@ var websocketsPlugin = fsPlugin3(async (app, options) => {
     async disconnect(connectionId) {
       const connection = connections.get(connectionId);
       if (!connection) {
-        throw new Error(`WebSocket connection ${connectionId} not found`);
+        throw new WebSocketConnectionGoneError(connectionId);
       }
       connection.socket.close();
     }
@@ -2782,7 +2814,7 @@ var RouteRegistry = class _RouteRegistry {
       url: routeOptions.url,
       handler: routeOptions.handler?.name || "anonymous",
       registeredAt: /* @__PURE__ */ new Date(),
-      module: routeOptions.module
+      module: routeOptions.config?.module
     };
     this.routes.push(routeInfo);
   }
@@ -3222,6 +3254,9 @@ async function devConsolePluginFunction(fastify, options = {}) {
       await wsManager.sendToClient(connectionId, request.body);
       return reply.status(200).send({ status: "success", message: `Message sent to ${connectionId}` });
     } catch (error) {
+      if (error instanceof WebSocketConnectionGoneError2) {
+        return reply.status(410).send({ error: error.message });
+      }
       return reply.status(404).send({ error: error.message });
     }
   });