@cloudnux/local-cloud-provider 0.11.0 → 0.14.0

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

@@ -1,4 +1,5 @@
 import { FastifyPluginOptions, FastifyPluginAsync } from 'fastify';
+import { EventBatchItemResult } from '@cloudnux/core-cloud-provider';
 
 interface QueueMessage {
     id: string;
@@ -12,7 +13,7 @@ interface QueueMessage {
     reprocessed?: boolean;
     originalId?: string;
 }
-type EventHandler = (message: QueueMessage) => Promise<void>;
+type EventHandler = (message: QueueMessage) => Promise<EventBatchItemResult>;
 interface QueueService {
     handler: EventHandler;
     incoming: QueueMessage[];

package/dist/queue-plugin/index.js

@@ -1,9 +1,6 @@
-// src/queue-plugin/plugin.ts
-import fsPlugin from "fastify-plugin";
-
-// src/queue-plugin/core.ts
-import chalk2 from "chalk";
-import logSymbols from "log-symbols";
+// src/logging/pretty-writer.ts
+import chalk from "chalk";
+import { EOL as EOL2 } from "os";
 
 // ../../../node_modules/lodash-es/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
@@ -827,20 +824,32 @@ var utils = {
 };
 var env = Object.assign(_env, utils);
 
-// ../../utils/src/logging/index.ts
-import chalk from "chalk";
-import { EOL } from "os";
-
 // ../../utils/src/logging/types.ts
 var logLevels = {
   fatal: -1,
   error: 0,
   warn: 1,
   info: 2,
-  debug: 3
+  debug: 3,
+  trace: 4
 };
 
 // ../../utils/src/logging/error-to-string.ts
+var safeJsonStringify = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, (key, currentValue) => {
+    if (key === "constructor") return void 0;
+    if (typeof currentValue === "object" && currentValue !== null) {
+      if (seen.has(currentValue)) return "[Circular]";
+      seen.add(currentValue);
+    }
+    return currentValue;
+  });
+};
+var hasOwnConstructorProp = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  return Object.prototype.hasOwnProperty.call(value, "constructor");
+};
 var errorToString = (error) => {
   if (error === null) return "Null error";
   if (error === void 0) return "Undefined error";
@@ -850,13 +859,22 @@ var errorToString = (error) => {
       `Message: ${error.message}`,
       `Stack: ${error.stack || "No stack trace available"}`,
       // Handle additional properties that might exist on custom errors
-      ...Object.entries(error).filter(([key]) => !["name", "message", "stack"].includes(key)).map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+      ...Object.entries(error).filter(
+        ([key, value]) => !["name", "message", "stack"].includes(key) && !hasOwnConstructorProp(value)
+      ).map(([key, value]) => `${key}: ${safeJsonStringify(value)}`)
     ].join("\n");
   }
   if (typeof error === "string") return error;
   if (typeof error === "object") {
     try {
-      return JSON.stringify(error, null, 2);
+      return JSON.stringify(
+        error,
+        (key, value) => {
+          if (key === "constructor") return void 0;
+          return value;
+        },
+        2
+      );
     } catch {
       return `[Object that cannot be stringified: ${Object.prototype.toString.call(error)}]`;
     }
@@ -864,62 +882,130 @@ var errorToString = (error) => {
   return String(error);
 };
 
+// ../../utils/src/logging/writer.ts
+import { EOL } from "os";
+var jsonWriter = (entry) => {
+  process.stdout.write(JSON.stringify(entry) + EOL);
+};
+var _writer = jsonWriter;
+function setWriter(writer) {
+  _writer = writer;
+}
+function getWriter() {
+  return _writer;
+}
+
 // ../../utils/src/logging/index.ts
-var currentLogLevel = logLevels[env("LOG_LEVEL")?.toLowerCase()] ?? logLevels.info;
-var module = "default";
-var requestId = "";
-var logger = {
-  fatal: (message, meta) => {
-    if (currentLogLevel >= logLevels.fatal) {
-      console.error(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgRed.white(" fatal ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        errorToString(message),
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  },
-  error: (message, meta) => {
-    if (currentLogLevel >= logLevels.error) {
-      console.error(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgRed.white(" error ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        errorToString(message),
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  },
-  warn: (message, meta) => {
-    if (currentLogLevel >= logLevels.warn) {
-      console.warn(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgYellow.black(" warn ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        errorToString(message),
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  },
-  info: (message, meta) => {
-    if (currentLogLevel >= logLevels.info) {
-      console.info(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgBlue.white(" info ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        message,
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  },
-  debug: (message, meta) => {
-    if (currentLogLevel >= logLevels.debug) {
-      console.debug(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgWhite.black(" debug ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        message,
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  }
+var levelValues = {
+  fatal: 70,
+  error: 60,
+  warn: 50,
+  info: 40,
+  debug: 30,
+  trace: 20
 };
+var currentLogLevel = 2;
+var _module = "default";
+var _requestId = "";
+function writeLine(level, mergeObject, msg, bindings) {
+  getWriter()({
+    level: levelValues[level],
+    levelName: level,
+    time: Date.now(),
+    module: bindings.module || _module,
+    reqId: bindings.reqId || _requestId,
+    msg: level === "error" || level === "fatal" ? errorToString(msg) : msg,
+    ...mergeObject ? { meta: mergeObject } : {}
+  });
+}
+function createLogger(bindings = {}) {
+  const currentLogLevelName = env("LOG_LEVEL")?.toLowerCase() ?? "info";
+  currentLogLevel = logLevels[currentLogLevelName] ?? logLevels.info;
+  return {
+    level: currentLogLevelName,
+    fatal: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.fatal) {
+        typeof mergeObject === "string" || mergeObject instanceof Error ? writeLine("fatal", null, mergeObject, bindings) : writeLine("fatal", mergeObject, msg ?? "", bindings);
+      }
+    },
+    error: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.error) {
+        typeof mergeObject === "string" || mergeObject instanceof Error ? writeLine("error", null, mergeObject, bindings) : writeLine("error", mergeObject, msg ?? "", bindings);
+      }
+    },
+    warn: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.warn) {
+        typeof mergeObject === "string" ? writeLine("warn", null, mergeObject, bindings) : writeLine("warn", mergeObject, msg ?? "", bindings);
+      }
+    },
+    info: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.info) {
+        typeof mergeObject === "string" ? writeLine("info", null, mergeObject, bindings) : writeLine("info", mergeObject, msg ?? "", bindings);
+      }
+    },
+    debug: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.debug) {
+        typeof mergeObject === "string" ? writeLine("debug", null, mergeObject, bindings) : writeLine("debug", mergeObject, msg ?? "", bindings);
+      }
+    },
+    trace: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.trace) {
+        typeof mergeObject === "string" ? writeLine("trace", null, mergeObject, bindings) : writeLine("trace", mergeObject, msg ?? "", bindings);
+      }
+    },
+    silent: () => {
+    },
+    child: (childBindings) => createLogger({ ...bindings, ...childBindings })
+  };
+}
+var logger = createLogger();
+
+// src/logging/pretty-writer.ts
+var levelColor = {
+  fatal: chalk.bgRed.white,
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.cyan,
+  debug: chalk.gray,
+  trace: chalk.white
+};
+function formatTime(ms) {
+  return new Date(ms).toTimeString().slice(0, 8);
+}
+function formatMeta(meta) {
+  const { req, res, ...rest } = meta;
+  const lines = [];
+  if (req) {
+    const reqParts = [`${req.method} ${req.url}`];
+    if (req.remoteAddress) reqParts.push(`from ${req.remoteAddress}:${req.remotePort ?? ""}`);
+    if (req.headers) reqParts.push(`headers=${JSON.stringify(req.headers, null, 2)}`);
+    if (req.body !== void 0) reqParts.push(`body=${typeof req.body === "string" ? req.body : JSON.stringify(req.body, null, 2)}`);
+    lines.push(chalk.dim("  req: " + reqParts.join(" ")));
+  }
+  if (res) {
+    const resParts = [`${res.statusCode}`];
+    if (res.headers) resParts.push(`headers=${JSON.stringify(res.headers, null, 2)}`);
+    if (res.body !== void 0) resParts.push(`body=${typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2)}`);
+    lines.push(chalk.dim("  res: " + resParts.join(" ")));
+  }
+  if (Object.keys(rest).length) {
+    lines.push(chalk.dim("  " + JSON.stringify(rest, null, 2)));
+  }
+  return lines.length ? EOL2 + lines.join(EOL2) : "";
+}
+var prettyWriter = (entry) => {
+  const color = levelColor[entry.levelName] ?? chalk.white;
+  const time = chalk.dim(formatTime(entry.time));
+  const level = color(entry.levelName.toUpperCase().padEnd(5));
+  const module = chalk.magenta(entry.module);
+  const reqId = entry.reqId ? chalk.dim(`[${entry.reqId}]`) + " " : "";
+  const meta = entry.meta ? formatMeta(entry.meta) : "";
+  process.stdout.write(`${time} ${level} ${module} ${reqId}- ${entry.msg}${meta}${EOL2}`);
+};
+setWriter(prettyWriter);
+
+// src/queue-plugin/plugin.ts
+import fsPlugin from "fastify-plugin";
 
 // src/queue-plugin/core.ts
 var DEFAULT_CONFIG = {
@@ -945,14 +1031,14 @@ var mergeConfig = (defaultConfig, userConfig) => ({
     ...userConfig?.persistence || {}
   }
 });
-var createQueueService = (handler, module2) => ({
+var createQueueService = (handler, module) => ({
   handler,
   incoming: [],
   processing: [],
   dlq: [],
   timeoutId: null,
   processingBatch: false,
-  module: module2
+  module
 });
 var createQueueMessage = (body, headers) => {
   const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
@@ -1033,32 +1119,36 @@ var purgeDLQ = (queueService) => {
   return dlqCount;
 };
 var logSuccess = (message, messageId, queueName) => {
-  logger.debug(`${logSymbols.success} ${chalk2.green(message)} ${chalk2.yellow(messageId)} in queue ${chalk2.magenta(queueName)}`);
+  logger.debug(`Success: ${message} ${messageId} in queue ${queueName}`);
 };
 var logError = (message, messageId, queueName, error) => {
-  logger.error(`${logSymbols.error} ${chalk2.red(message)} ${chalk2.yellow(messageId)} in queue ${chalk2.magenta(queueName)}: ${error}`);
+  logger.error(`Error: ${message} ${messageId} in queue ${queueName}: ${error}`);
 };
 var logRetryScheduled = (messageId, delayMs) => {
-  logger.debug(`${chalk2.blue("\u23F1\uFE0F Scheduling retry")} for message ${chalk2.yellow(messageId)} in ${chalk2.cyan(delayMs)}ms`);
+  logger.debug(`Scheduling retry for message ${messageId} in ${delayMs}ms`);
 };
 var logDLQOperation = (operation, count, queueName) => {
-  logger.warn(`${logSymbols.warning} ${chalk2.yellow(operation)} ${chalk2.red(count)} messages from DLQ for ${chalk2.green(queueName)}`);
+  logger.warn(`${operation} ${count} messages from DLQ for ${queueName}`);
 };
 
 // src/queue-plugin/processing.ts
 var createProcessMessageHandler = (config) => async (queueName, message, queueService) => {
   try {
-    await queueService.handler(message);
-    removeFromProcessing(queueService, message.id);
-    logSuccess("Successfully processed message", message.id, queueName);
-  } catch (error) {
-    await handleProcessingError(queueName, message, queueService, error, config);
+    const result = await queueService.handler(message);
+    if (result?.failureId) {
+      await handleProcessingError(queueName, message, queueService, config);
+    } else {
+      removeFromProcessing(queueService, message.id);
+      logSuccess("Successfully processed message", message.id, queueName);
+    }
+  } catch {
+    await handleProcessingError(queueName, message, queueService, config);
   }
 };
-var handleProcessingError = async (queueName, message, queueService, error, config) => {
-  logError("Error processing message", message.id, queueName, error.message);
+var handleProcessingError = async (queueName, message, queueService, config) => {
+  logError("Error processing message", message.id, queueName, "handler returned failure");
   if (message.attempts >= config.maxRetries) {
-    moveToDLQ(queueService, message, error.message);
+    moveToDLQ(queueService, message, "max retries exceeded");
     return;
   }
   const updatedMessage = incrementAttempts(queueService, message.id);
@@ -1118,8 +1208,6 @@ var handleImmediateProcessing = (queueService, config, processBatch, queueName)
 // src/queue-plugin/persistence.ts
 import * as fs from "fs/promises";
 import * as path from "path";
-import chalk3 from "chalk";
-import logSymbols2 from "log-symbols";
 var createQueueData = (queueService) => ({
   incoming: queueService.incoming,
   processing: queueService.processing,
@@ -1154,10 +1242,9 @@ var createPersistenceInitializer = (config, loadAllQueueStates, saveDirtyQueueSt
       process.on("SIGINT", shutdownHandler);
       process.on("SIGTERM", shutdownHandler);
     }
-    logger.debug(`${logSymbols2.success} ${chalk3.green("Queue persistence initialized:")} ${chalk3.yellow(config.persistence.directory)}`);
+    logger.debug(`Queue persistence initialized: ${config.persistence.directory}`);
   } catch (error) {
-    console.log("[logger]", logger);
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to initialize queue persistence:")} ${chalk3.yellow(error?.message)}`);
+    logger.error(`Failed to initialize queue persistence: ${error?.message}`);
   }
 };
 var createQueueStateSaver = (config) => async (queueName, queueService) => {
@@ -1169,7 +1256,7 @@ var createQueueStateSaver = (config) => async (queueName, queueService) => {
     const tempFilePath = path.join(config.persistence.directory, `${queueName}.${now}temp.json`);
     await fs.writeFile(tempFilePath, JSON.stringify(queueData, null, 2), "utf8");
     await fs.rename(tempFilePath, queueFilePath);
-    logger.debug(`${logSymbols2.info} ${chalk3.blue("Queue state saved:")} ${chalk3.green(queueName)}`);
+    logger.debug(`Queue state saved: ${queueName}`);
   } catch (error) {
     logger.error(`Failed to save queue state for ${queueName}:`, error?.message);
   }
@@ -1179,9 +1266,9 @@ var createAllQueuesStateSaver = (config, saveQueueState) => (queues) => async ()
     for (const [queueName, queueService] of Object.entries(queues)) {
       await saveQueueState(queueName, queueService);
     }
-    logger.debug(`${logSymbols2.success} ${chalk3.green("All queue states saved to")} ${chalk3.yellow(config.persistence.directory)}`);
+    logger.debug(`All queue states saved to ${config.persistence.directory}`);
   } catch (error) {
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save all queue states:")} ${chalk3.yellow(error?.message)}`);
+    logger.error(`Failed to save all queue states: ${error?.message}`);
   }
 };
 var createDirtyQueuesStateSaver = (saveQueueState, dirtyQueues) => (queues) => async () => {
@@ -1195,7 +1282,7 @@ var createDirtyQueuesStateSaver = (saveQueueState, dirtyQueues) => (queues) => a
       }
     }
   } catch (error) {
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save dirty queue states:")} ${chalk3.yellow(error?.message)}`);
+    logger.error(`Failed to save dirty queue states: ${error?.message}`);
   }
 };
 var createQueueStateLoader = (config, scheduleProcessing, processMessage) => (queues) => async (queueName) => {
@@ -1307,8 +1394,6 @@ var registerQueueRoutes = (app, prefix = "") => {
 };
 
 // src/queue-plugin/decorator.ts
-import chalk4 from "chalk";
-import logSymbols3 from "log-symbols";
 var isValidQueueName = (queueName) => {
   return typeof queueName === "string" && queueName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(queueName);
 };
@@ -1334,21 +1419,21 @@ var createQueueManager = ({
       throw new Error("Handler must be a function");
     }
   };
-  const addQueue = async (queueName, handler, module2) => {
+  const addQueue = async (queueName, handler, module) => {
     try {
       validateQueueName(queueName);
       validateHandler(handler);
       if (queues[queueName]) {
-        logger.warn(`${logSymbols3.warning} ${chalk4.yellow("Queue already exists:")} ${chalk4.magenta(queueName)}.`);
+        logger.warn(`Queue already exists: ${queueName}.`);
         return;
       }
-      queues[queueName] = createQueueService(handler, module2);
+      queues[queueName] = createQueueService(handler, module);
       if (config.persistence.enabled && loadQueueState) {
         await loadQueueState(queueName);
       }
-      logger.info(`${logSymbols3.success} ${chalk4.green("Queue added:")} ${chalk4.magenta(queueName)}`);
+      logger.info(`Queue added: ${queueName}`);
     } catch (error) {
-      logger.error(`${logSymbols3.error} ${chalk4.red("Failed to add queue")} ${chalk4.magenta(queueName)}: ${error.message}`);
+      logger.error(`Failed to add queue ${queueName}: ${error.message}`);
       throw error;
     }
   };
@@ -1361,7 +1446,7 @@ var createQueueManager = ({
       const queueService = queues[queueName];
       const totalMessages = queueService.incoming.length + queueService.processing.length;
       if (totalMessages > 0) {
-        logger.warn(`${logSymbols3.warning} ${chalk4.yellow("Removing queue with")} ${chalk4.red(totalMessages)} ${chalk4.yellow("pending messages:")} ${chalk4.magenta(queueName)}`);
+        logger.warn(`Removing queue with ${totalMessages} pending messages: ${queueName}`);
       }
       if (queueService.timeoutId) {
         clearTimeout(queueService.timeoutId);
@@ -1370,9 +1455,9 @@ var createQueueManager = ({
         await saveQueueState(queueName, queueService);
       }
       delete queues[queueName];
-      logger.info(`${logSymbols3.success} ${chalk4.green("Queue removed:")} ${chalk4.magenta(queueName)}`);
+      logger.info(`Queue removed: ${queueName}`);
     } catch (error) {
-      logger.error(`${logSymbols3.error} ${chalk4.red("Failed to remove queue")} ${chalk4.magenta(queueName)}: ${error.message}`);
+      logger.error(`Failed to remove queue ${queueName}: ${error.message}`);
       throw error;
     }
   };
@@ -1384,10 +1469,10 @@ var createQueueManager = ({
       return false;
     }
   };
-  const listQueues = (module2) => {
+  const listQueues = (module) => {
     return Object.keys(queues).filter((queueName) => {
       const queueService = queues[queueName];
-      return !module2 || queueService.module === module2;
+      return !module || queueService.module === module;
     }).sort();
   };
   const getQueueStats = (queueName) => {