@cloudnux/local-cloud-provider 0.16.0 → 0.18.0

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

@@ -0,0 +1,24 @@
+import { FastifyPluginOptions, FastifyPluginAsync } from 'fastify';
+
+type InvokeHandlerFn = (envelop: {
+    payload?: any;
+    calledModule: string;
+    invokeTriggerName: string;
+}) => Promise<any>;
+interface InvokeManager {
+    register(module: string, name: string, handler: InvokeHandlerFn): void;
+    get(module: string, name: string): InvokeHandlerFn | undefined;
+    list(): string[];
+}
+interface InvokePluginOptions extends FastifyPluginOptions {
+    prefix?: string;
+}
+declare module 'fastify' {
+    interface FastifyInstance {
+        invokes: InvokeManager;
+    }
+}
+
+declare const invokesPlugin: FastifyPluginAsync<InvokePluginOptions>;
+
+export { type InvokeHandlerFn, type InvokeManager, type InvokePluginOptions, invokesPlugin };

package/dist/invoke-plugin/index.js

@@ -0,0 +1,23 @@
+// src/invoke-plugin/plugin.ts
+import fsPlugin from "fastify-plugin";
+var invokesPlugin = fsPlugin(async (app) => {
+  const registry = /* @__PURE__ */ new Map();
+  const invokeManager = {
+    register(module, name, handler) {
+      const key = `${module}:${name}`;
+      registry.set(key, handler);
+    },
+    get(module, name) {
+      const key = `${module}:${name}`;
+      return registry.get(key);
+    },
+    list() {
+      return Array.from(registry.keys());
+    }
+  };
+  app.decorate("invokes", invokeManager);
+});
+export {
+  invokesPlugin
+};
+//# sourceMappingURL=index.js.map

package/dist/invoke-plugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/invoke-plugin/plugin.ts"],"sourcesContent":["import { FastifyInstance, FastifyPluginAsync } from \"fastify\";\nimport fsPlugin from \"fastify-plugin\";\n\nimport { InvokePluginOptions, InvokeManager, InvokeHandlerFn } from \"./types\";\n\nexport const invokesPlugin: FastifyPluginAsync<InvokePluginOptions> =\n    fsPlugin(async (app: FastifyInstance) => {\n        const registry = new Map<string, InvokeHandlerFn>();\n        const invokeManager: InvokeManager = {\n            register(module, name, handler) {\n                const key = `${module}:${name}`;\n                registry.set(key, handler);\n            },\n            get(module, name) {\n                const key = `${module}:${name}`;\n                return registry.get(key);\n            },\n            list() {\n                return Array.from(registry.keys());\n            },\n        };\n\n        app.decorate('invokes', invokeManager);\n    });\n"],"mappings":";AACA,OAAO,cAAc;AAId,IAAM,gBACT,SAAS,OAAO,QAAyB;AACrC,QAAM,WAAW,oBAAI,IAA6B;AAClD,QAAM,gBAA+B;AAAA,IACjC,SAAS,QAAQ,MAAM,SAAS;AAC5B,YAAM,MAAM,GAAG,MAAM,IAAI,IAAI;AAC7B,eAAS,IAAI,KAAK,OAAO;AAAA,IAC7B;AAAA,IACA,IAAI,QAAQ,MAAM;AACd,YAAM,MAAM,GAAG,MAAM,IAAI,IAAI;AAC7B,aAAO,SAAS,IAAI,GAAG;AAAA,IAC3B;AAAA,IACA,OAAO;AACH,aAAO,MAAM,KAAK,SAAS,KAAK,CAAC;AAAA,IACrC;AAAA,EACJ;AAEA,MAAI,SAAS,WAAW,aAAa;AACzC,CAAC;","names":[]}

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

@@ -31,11 +31,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 {
@@ -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) => {
@@ -1227,7 +1254,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) {
@@ -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,