@navios/core 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -164,6 +164,7 @@ var InjectableScope = /* @__PURE__ */ ((InjectableScope2) => {
 
 // packages/core/src/service-locator/injection-token.mts
 import { randomUUID } from "crypto";
+import "zod";
 var InjectionToken = class _InjectionToken {
   constructor(name2, schema) {
     this.name = name2;
@@ -1152,6 +1153,655 @@ var ConflictException = class extends HttpException {
   }
 };
 
+// packages/core/src/logger/utils/cli-colors.util.mts
+var isColorAllowed = () => !process.env.NO_COLOR;
+var colorIfAllowed = (colorFn) => (text) => isColorAllowed() ? colorFn(text) : text;
+var clc = {
+  bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
+  green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
+  yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
+  red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
+  magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
+  cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
+};
+var yellow = colorIfAllowed(
+  (text) => `\x1B[38;5;3m${text}\x1B[39m`
+);
+
+// packages/core/src/logger/log-levels.mts
+var LOG_LEVELS = [
+  "verbose",
+  "debug",
+  "log",
+  "warn",
+  "error",
+  "fatal"
+];
+
+// packages/core/src/logger/utils/is-log-level.util.mts
+function isLogLevel(maybeLogLevel) {
+  return LOG_LEVELS.includes(maybeLogLevel);
+}
+
+// packages/core/src/logger/utils/filter-log-levelts.util.mts
+function filterLogLevels(parseableString = "") {
+  const sanitizedString = parseableString.replaceAll(" ", "").toLowerCase();
+  if (sanitizedString[0] === ">") {
+    const orEqual = sanitizedString[1] === "=";
+    const logLevelIndex = LOG_LEVELS.indexOf(
+      sanitizedString.substring(orEqual ? 2 : 1)
+    );
+    if (logLevelIndex === -1) {
+      throw new Error(`parse error (unknown log level): ${sanitizedString}`);
+    }
+    return LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1);
+  } else if (sanitizedString.includes(",")) {
+    return sanitizedString.split(",").filter(isLogLevel);
+  }
+  return isLogLevel(sanitizedString) ? [sanitizedString] : LOG_LEVELS;
+}
+
+// packages/core/src/logger/utils/is-log-level-enabled.mts
+var LOG_LEVEL_VALUES = {
+  verbose: 0,
+  debug: 1,
+  log: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5
+};
+function isLogLevelEnabled(targetLevel, logLevels) {
+  var _a;
+  if (!logLevels || Array.isArray(logLevels) && (logLevels == null ? void 0 : logLevels.length) === 0) {
+    return false;
+  }
+  if (logLevels.includes(targetLevel)) {
+    return true;
+  }
+  const highestLogLevelValue = (_a = logLevels.map((level) => LOG_LEVEL_VALUES[level]).sort((a, b) => b - a)) == null ? void 0 : _a[0];
+  const targetLevelValue = LOG_LEVEL_VALUES[targetLevel];
+  return targetLevelValue >= highestLogLevelValue;
+}
+
+// packages/core/src/logger/utils/shared.utils.mts
+var isUndefined = (obj) => typeof obj === "undefined";
+var isObject = (fn) => !isNil(fn) && typeof fn === "object";
+var isPlainObject = (fn) => {
+  if (!isObject(fn)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(fn);
+  if (proto === null) {
+    return true;
+  }
+  const ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
+};
+var addLeadingSlash = (path) => path && typeof path === "string" ? path.charAt(0) !== "/" && path.substring(0, 2) !== "{/" ? "/" + path : path : "";
+var normalizePath = (path) => path ? path.startsWith("/") ? ("/" + path.replace(/\/+$/, "")).replace(/\/+/g, "/") : "/" + path.replace(/\/+$/, "") : "/";
+var stripEndSlash = (path) => path[path.length - 1] === "/" ? path.slice(0, path.length - 1) : path;
+var isFunction = (val) => typeof val === "function";
+var isString = (val) => typeof val === "string";
+var isNumber = (val) => typeof val === "number";
+var isConstructor = (val) => val === "constructor";
+var isNil = (val) => isUndefined(val) || val === null;
+var isEmpty = (array) => !(array && array.length > 0);
+var isSymbol = (val) => typeof val === "symbol";
+
+// packages/core/src/logger/console-logger.service.mts
+import { inspect } from "util";
+var DEFAULT_DEPTH = 5;
+var DEFAULT_LOG_LEVELS = [
+  "log",
+  "error",
+  "warn",
+  "debug",
+  "verbose",
+  "fatal"
+];
+var dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  day: "2-digit",
+  month: "2-digit"
+});
+var _ConsoleLogger_decorators, _init;
+_ConsoleLogger_decorators = [Injectable()];
+var _ConsoleLogger = class _ConsoleLogger {
+  /**
+   * The options of the logger.
+   */
+  options;
+  /**
+   * The context of the logger (can be set manually or automatically inferred).
+   */
+  context;
+  /**
+   * The original context of the logger (set in the constructor).
+   */
+  originalContext;
+  /**
+   * The options used for the "inspect" method.
+   */
+  inspectOptions;
+  /**
+   * The last timestamp at which the log message was printed.
+   */
+  static lastTimestampAt;
+  constructor(contextOrOptions, options) {
+    let [context, opts] = isString(contextOrOptions) ? [contextOrOptions, options] : options ? [void 0, options] : [contextOrOptions == null ? void 0 : contextOrOptions.context, contextOrOptions];
+    opts = opts ?? {};
+    opts.logLevels ??= DEFAULT_LOG_LEVELS;
+    opts.colors ??= opts.colors ?? (opts.json ? false : true);
+    opts.prefix ??= "Navios";
+    this.options = opts;
+    this.inspectOptions = this.getInspectOptions();
+    if (context) {
+      this.context = context;
+      this.originalContext = context;
+    }
+  }
+  log(message, ...optionalParams) {
+    if (!this.isLevelEnabled("log")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "log");
+  }
+  error(message, ...optionalParams) {
+    if (!this.isLevelEnabled("error")) {
+      return;
+    }
+    const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
+    this.printMessages(messages, context, "error", "stderr", stack);
+    this.printStackTrace(stack);
+  }
+  warn(message, ...optionalParams) {
+    if (!this.isLevelEnabled("warn")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "warn");
+  }
+  debug(message, ...optionalParams) {
+    if (!this.isLevelEnabled("debug")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "debug");
+  }
+  verbose(message, ...optionalParams) {
+    if (!this.isLevelEnabled("verbose")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "verbose");
+  }
+  fatal(message, ...optionalParams) {
+    if (!this.isLevelEnabled("fatal")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "fatal");
+  }
+  /**
+   * Set log levels
+   * @param levels log levels
+   */
+  setLogLevels(levels) {
+    if (!this.options) {
+      this.options = {};
+    }
+    this.options.logLevels = levels;
+  }
+  /**
+   * Set logger context
+   * @param context context
+   */
+  setContext(context) {
+    this.context = context;
+  }
+  /**
+   * Resets the logger context to the value that was passed in the constructor.
+   */
+  resetContext() {
+    this.context = this.originalContext;
+  }
+  isLevelEnabled(level) {
+    var _a;
+    const logLevels = (_a = this.options) == null ? void 0 : _a.logLevels;
+    return isLogLevelEnabled(level, logLevels);
+  }
+  getTimestamp() {
+    return dateTimeFormatter.format(Date.now());
+  }
+  printMessages(messages, context = "", logLevel = "log", writeStreamType, errorStack) {
+    messages.forEach((message) => {
+      if (this.options.json) {
+        this.printAsJson(message, {
+          context,
+          logLevel,
+          writeStreamType,
+          errorStack
+        });
+        return;
+      }
+      const pidMessage = this.formatPid(process.pid);
+      const contextMessage = this.formatContext(context);
+      const timestampDiff = this.updateAndGetTimestampDiff();
+      const formattedLogLevel = logLevel.toUpperCase().padStart(7, " ");
+      const formattedMessage = this.formatMessage(
+        logLevel,
+        message,
+        pidMessage,
+        formattedLogLevel,
+        contextMessage,
+        timestampDiff
+      );
+      process[writeStreamType ?? "stdout"].write(formattedMessage);
+    });
+  }
+  printAsJson(message, options) {
+    const logObject = {
+      level: options.logLevel,
+      pid: process.pid,
+      timestamp: Date.now(),
+      message
+    };
+    if (options.context) {
+      logObject.context = options.context;
+    }
+    if (options.errorStack) {
+      logObject.stack = options.errorStack;
+    }
+    const formattedMessage = !this.options.colors && this.inspectOptions.compact === true ? JSON.stringify(logObject, this.stringifyReplacer) : inspect(logObject, this.inspectOptions);
+    process[options.writeStreamType ?? "stdout"].write(`${formattedMessage}
+`);
+  }
+  formatPid(pid) {
+    return `[${this.options.prefix}] ${pid}  - `;
+  }
+  formatContext(context) {
+    if (!context) {
+      return "";
+    }
+    context = `[${context}] `;
+    return this.options.colors ? yellow(context) : context;
+  }
+  formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
+    const output = this.stringifyMessage(message, logLevel);
+    pidMessage = this.colorize(pidMessage, logLevel);
+    formattedLogLevel = this.colorize(formattedLogLevel, logLevel);
+    return `${pidMessage}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}
+`;
+  }
+  stringifyMessage(message, logLevel) {
+    if (isFunction(message)) {
+      const messageAsStr = Function.prototype.toString.call(message);
+      const isClass = messageAsStr.startsWith("class ");
+      if (isClass) {
+        return this.stringifyMessage(message.name, logLevel);
+      }
+      return this.stringifyMessage(message(), logLevel);
+    }
+    if (typeof message === "string") {
+      return this.colorize(message, logLevel);
+    }
+    const outputText = inspect(message, this.inspectOptions);
+    if (isPlainObject(message)) {
+      return `Object(${Object.keys(message).length}) ${outputText}`;
+    }
+    if (Array.isArray(message)) {
+      return `Array(${message.length}) ${outputText}`;
+    }
+    return outputText;
+  }
+  colorize(message, logLevel) {
+    if (!this.options.colors || this.options.json) {
+      return message;
+    }
+    const color = this.getColorByLogLevel(logLevel);
+    return color(message);
+  }
+  printStackTrace(stack) {
+    if (!stack || this.options.json) {
+      return;
+    }
+    process.stderr.write(`${stack}
+`);
+  }
+  updateAndGetTimestampDiff() {
+    var _a;
+    const includeTimestamp = _ConsoleLogger.lastTimestampAt && ((_a = this.options) == null ? void 0 : _a.timestamp);
+    const result = includeTimestamp ? this.formatTimestampDiff(Date.now() - _ConsoleLogger.lastTimestampAt) : "";
+    _ConsoleLogger.lastTimestampAt = Date.now();
+    return result;
+  }
+  formatTimestampDiff(timestampDiff) {
+    const formattedDiff = ` +${timestampDiff}ms`;
+    return this.options.colors ? yellow(formattedDiff) : formattedDiff;
+  }
+  getInspectOptions() {
+    let breakLength = this.options.breakLength;
+    if (typeof breakLength === "undefined") {
+      breakLength = this.options.colors ? this.options.compact ? Infinity : void 0 : this.options.compact === false ? void 0 : Infinity;
+    }
+    const inspectOptions = {
+      depth: this.options.depth ?? DEFAULT_DEPTH,
+      sorted: this.options.sorted,
+      showHidden: this.options.showHidden,
+      compact: this.options.compact ?? (this.options.json ? true : false),
+      colors: this.options.colors,
+      breakLength
+    };
+    if (this.options.maxArrayLength) {
+      inspectOptions.maxArrayLength = this.options.maxArrayLength;
+    }
+    if (this.options.maxStringLength) {
+      inspectOptions.maxStringLength = this.options.maxStringLength;
+    }
+    return inspectOptions;
+  }
+  stringifyReplacer(key, value) {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    if (value instanceof Map || value instanceof Set || value instanceof Error) {
+      return `${inspect(value, this.inspectOptions)}`;
+    }
+    return value;
+  }
+  getContextAndMessagesToPrint(args) {
+    if ((args == null ? void 0 : args.length) <= 1) {
+      return { messages: args, context: this.context };
+    }
+    const lastElement = args[args.length - 1];
+    const isContext = isString(lastElement);
+    if (!isContext) {
+      return { messages: args, context: this.context };
+    }
+    return {
+      context: lastElement,
+      messages: args.slice(0, args.length - 1)
+    };
+  }
+  getContextAndStackAndMessagesToPrint(args) {
+    if (args.length === 2) {
+      return this.isStackFormat(args[1]) ? {
+        messages: [args[0]],
+        stack: args[1],
+        context: this.context
+      } : {
+        messages: [args[0]],
+        context: args[1]
+      };
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint(args);
+    if ((messages == null ? void 0 : messages.length) <= 1) {
+      return { messages, context };
+    }
+    const lastElement = messages[messages.length - 1];
+    const isStack = isString(lastElement);
+    if (!isStack && !isUndefined(lastElement)) {
+      return { messages, context };
+    }
+    return {
+      stack: lastElement,
+      messages: messages.slice(0, messages.length - 1),
+      context
+    };
+  }
+  isStackFormat(stack) {
+    if (!isString(stack) && !isUndefined(stack)) {
+      return false;
+    }
+    return /^(.)+\n\s+at .+:\d+:\d+/.test(stack);
+  }
+  getColorByLogLevel(level) {
+    switch (level) {
+      case "debug":
+        return clc.magentaBright;
+      case "warn":
+        return clc.yellow;
+      case "error":
+        return clc.red;
+      case "verbose":
+        return clc.cyanBright;
+      case "fatal":
+        return clc.bold;
+      default:
+        return clc.green;
+    }
+  }
+};
+_init = __decoratorStart(null);
+_ConsoleLogger = __decorateElement(_init, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
+__runInitializers(_init, 1, _ConsoleLogger);
+var ConsoleLogger = _ConsoleLogger;
+
+// packages/core/src/logger/logger.factory.mts
+import { z } from "zod";
+
+// packages/core/src/logger/logger.service.mts
+var DEFAULT_LOGGER = new ConsoleLogger();
+var dateTimeFormatter2 = new Intl.DateTimeFormat(void 0, {
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  day: "2-digit",
+  month: "2-digit"
+});
+var _LoggerInstance_decorators, _init2;
+_LoggerInstance_decorators = [Injectable()];
+var _LoggerInstance = class _LoggerInstance {
+  constructor(context, options = {}) {
+    this.context = context;
+    this.options = options;
+  }
+  static staticInstanceRef = DEFAULT_LOGGER;
+  static logLevels;
+  localInstanceRef;
+  get localInstance() {
+    if (_LoggerInstance.staticInstanceRef === DEFAULT_LOGGER) {
+      return this.registerLocalInstanceRef();
+    } else if (_LoggerInstance.staticInstanceRef instanceof _LoggerInstance) {
+      const prototype = Object.getPrototypeOf(_LoggerInstance.staticInstanceRef);
+      if (prototype.constructor === _LoggerInstance) {
+        return this.registerLocalInstanceRef();
+      }
+    }
+    return _LoggerInstance.staticInstanceRef;
+  }
+  error(message, ...optionalParams) {
+    var _a;
+    optionalParams = this.context ? (optionalParams.length ? optionalParams : [void 0]).concat(
+      this.context
+    ) : optionalParams;
+    (_a = this.localInstance) == null ? void 0 : _a.error(message, ...optionalParams);
+  }
+  log(message, ...optionalParams) {
+    var _a;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_a = this.localInstance) == null ? void 0 : _a.log(message, ...optionalParams);
+  }
+  warn(message, ...optionalParams) {
+    var _a;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_a = this.localInstance) == null ? void 0 : _a.warn(message, ...optionalParams);
+  }
+  debug(message, ...optionalParams) {
+    var _a, _b;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_b = (_a = this.localInstance) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  verbose(message, ...optionalParams) {
+    var _a, _b;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_b = (_a = this.localInstance) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  fatal(message, ...optionalParams) {
+    var _a, _b;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_b = (_a = this.localInstance) == null ? void 0 : _a.fatal) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  static error(message, ...optionalParams) {
+    var _a;
+    (_a = this.staticInstanceRef) == null ? void 0 : _a.error(message, ...optionalParams);
+  }
+  static log(message, ...optionalParams) {
+    var _a;
+    (_a = this.staticInstanceRef) == null ? void 0 : _a.log(message, ...optionalParams);
+  }
+  static warn(message, ...optionalParams) {
+    var _a;
+    (_a = this.staticInstanceRef) == null ? void 0 : _a.warn(message, ...optionalParams);
+  }
+  static debug(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  static verbose(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  static fatal(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.fatal) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  static getTimestamp() {
+    return dateTimeFormatter2.format(Date.now());
+  }
+  static overrideLogger(logger) {
+    var _a, _b;
+    console.log(logger);
+    if (Array.isArray(logger)) {
+      _LoggerInstance.logLevels = logger;
+      return (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.setLogLevels) == null ? void 0 : _b.call(_a, logger);
+    }
+    if (isObject(logger)) {
+      this.staticInstanceRef = logger;
+    } else {
+      this.staticInstanceRef = void 0;
+    }
+  }
+  static isLevelEnabled(level) {
+    const logLevels = _LoggerInstance.logLevels;
+    return isLogLevelEnabled(level, logLevels);
+  }
+  registerLocalInstanceRef() {
+    var _a;
+    if (this.localInstanceRef) {
+      return this.localInstanceRef;
+    }
+    this.localInstanceRef = new ConsoleLogger(this.context, {
+      timestamp: (_a = this.options) == null ? void 0 : _a.timestamp,
+      logLevels: _LoggerInstance.logLevels
+    });
+    return this.localInstanceRef;
+  }
+};
+_init2 = __decoratorStart(null);
+_LoggerInstance = __decorateElement(_init2, 0, "LoggerInstance", _LoggerInstance_decorators, _LoggerInstance);
+__runInitializers(_init2, 1, _LoggerInstance);
+var LoggerInstance = _LoggerInstance;
+
+// packages/core/src/logger/logger.factory.mts
+var LoggerInjectionToken = "LoggerInjectionToken";
+var LoggerOptions = z.object({
+  context: z.string().optional(),
+  options: z.object({
+    timestamp: z.boolean().optional()
+  }).optional()
+}).optional();
+var Logger = InjectionToken.create(LoggerInjectionToken, LoggerOptions);
+var _LoggerFactory_decorators, _init3;
+_LoggerFactory_decorators = [Injectable({
+  type: "Factory" /* Factory */,
+  token: Logger
+})];
+var LoggerFactory = class {
+  create(ctx, args) {
+    return new LoggerInstance(args == null ? void 0 : args.context, args == null ? void 0 : args.options);
+  }
+};
+_init3 = __decoratorStart(null);
+LoggerFactory = __decorateElement(_init3, 0, "LoggerFactory", _LoggerFactory_decorators, LoggerFactory);
+__runInitializers(_init3, 1, LoggerFactory);
+
+// packages/core/src/logger/pino-wrapper.mts
+var PinoWrapper = class _PinoWrapper {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  fatal(message, ...optionalParams) {
+    if (this.logger.fatal === void 0) {
+      return this.error(message, ...optionalParams);
+    }
+    this.logger.fatal(message, ...optionalParams);
+  }
+  error(message, ...optionalParams) {
+    this.logger.error(message, ...optionalParams);
+  }
+  warn(message, ...optionalParams) {
+    this.logger.warn(message, ...optionalParams);
+  }
+  info(message, ...optionalParams) {
+    this.logger.log(message, ...optionalParams);
+  }
+  debug(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  trace(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.logger).verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  silent(message, ...optionalParams) {
+  }
+  child(options) {
+    const keys = Object.keys(options);
+    let newContext = this.logger["context"] ?? "";
+    if (keys.length > 1) {
+      newContext = `${this.logger["context"] ?? ""}:${JSON.stringify(options)}`;
+    }
+    return new _PinoWrapper(
+      // @ts-expect-error We don't need to support this in the current version
+      new LoggerInstance(newContext, this.logger["options"])
+    );
+  }
+  get level() {
+    if ("level" in this.logger && this.logger.level) {
+      return this.logger.level;
+    }
+    const levels = LoggerInstance["logLevels"];
+    if (levels) {
+      return levels[0];
+    }
+    return "info";
+  }
+};
+
 // packages/core/src/tokens/application.token.mts
 var ApplicationInjectionToken = "ApplicationInjectionToken";
 var Application = InjectionToken.create(
@@ -1217,7 +1867,7 @@ var ExecutionContext2 = class {
 };
 
 // packages/core/src/services/guard-runner.service.mts
-var _GuardRunnerService_decorators, _init;
+var _GuardRunnerService_decorators, _init4;
 _GuardRunnerService_decorators = [Injectable()];
 var GuardRunnerService = class {
   async runGuards(allGuards, executionContext) {
@@ -1280,15 +1930,18 @@ var GuardRunnerService = class {
     return guards;
   }
 };
-_init = __decoratorStart(null);
-GuardRunnerService = __decorateElement(_init, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
-__runInitializers(_init, 1, GuardRunnerService);
+_init4 = __decoratorStart(null);
+GuardRunnerService = __decorateElement(_init4, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
+__runInitializers(_init4, 1, GuardRunnerService);
 
 // packages/core/src/services/controller-adapter.service.mts
-var _ControllerAdapterService_decorators, _init2;
+var _ControllerAdapterService_decorators, _init5;
 _ControllerAdapterService_decorators = [Injectable()];
-var ControllerAdapterService = class {
+var _ControllerAdapterService = class _ControllerAdapterService {
   guardRunner = syncInject(GuardRunnerService);
+  logger = syncInject(Logger, {
+    context: _ControllerAdapterService.name
+  });
   setupController(controller, instance, moduleMetadata) {
     const controllerMetadata = extractControllerMetadata(controller);
     for (const endpoint of controllerMetadata.endpoints) {
@@ -1383,17 +2036,24 @@ var ControllerAdapterService = class {
           }
         }
       });
+      this.logger.debug(
+        `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`
+      );
     }
   }
 };
-_init2 = __decoratorStart(null);
-ControllerAdapterService = __decorateElement(_init2, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, ControllerAdapterService);
-__runInitializers(_init2, 1, ControllerAdapterService);
+_init5 = __decoratorStart(null);
+_ControllerAdapterService = __decorateElement(_init5, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
+__runInitializers(_init5, 1, _ControllerAdapterService);
+var ControllerAdapterService = _ControllerAdapterService;
 
 // packages/core/src/services/module-loader.service.mts
-var _ModuleLoaderService_decorators, _init3;
+var _ModuleLoaderService_decorators, _init6;
 _ModuleLoaderService_decorators = [Injectable()];
-var ModuleLoaderService = class {
+var _ModuleLoaderService = class _ModuleLoaderService {
+  logger = syncInject(Logger, {
+    context: _ModuleLoaderService.name
+  });
   modulesMetadata = /* @__PURE__ */ new Map();
   loadedModules = /* @__PURE__ */ new Map();
   initialized = false;
@@ -1423,6 +2083,7 @@ var ModuleLoaderService = class {
     if (instance.onModuleInit) {
       await instance.onModuleInit();
     }
+    this.logger.debug(`Module ${moduleName} loaded`);
     this.loadedModules.set(moduleName, instance);
   }
   mergeMetadata(metadata, parentMetadata) {
@@ -1444,9 +2105,10 @@ var ModuleLoaderService = class {
     return this.modulesMetadata;
   }
 };
-_init3 = __decoratorStart(null);
-ModuleLoaderService = __decorateElement(_init3, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, ModuleLoaderService);
-__runInitializers(_init3, 1, ModuleLoaderService);
+_init6 = __decoratorStart(null);
+_ModuleLoaderService = __decorateElement(_init6, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
+__runInitializers(_init6, 1, _ModuleLoaderService);
+var ModuleLoaderService = _ModuleLoaderService;
 
 // packages/core/src/attribute.factory.mts
 var AttributeFactory = class {
@@ -1512,11 +2174,14 @@ import {
   serializerCompiler,
   validatorCompiler
 } from "fastify-type-provider-zod";
-var _NaviosApplication_decorators, _init4;
+var _NaviosApplication_decorators, _init7;
 _NaviosApplication_decorators = [Injectable()];
-var NaviosApplication = class {
+var _NaviosApplication = class _NaviosApplication {
   moduleLoader = syncInject(ModuleLoaderService);
   controllerAdapter = syncInject(ControllerAdapterService);
+  logger = syncInject(Logger, {
+    context: _NaviosApplication.name
+  });
   server = null;
   corsOptions = null;
   globalPrefix = null;
@@ -1531,40 +2196,72 @@ var NaviosApplication = class {
       throw new Error("App module is not set. Call setAppModule() first.");
     }
     await this.moduleLoader.loadModules(this.appModule);
-    this.server = fastify(this.options);
+    this.server = await this.getFastifyInstance(this.options);
     getServiceLocator().registerInstance(Application, this.server);
     this.server.setValidatorCompiler(validatorCompiler);
     this.server.setSerializerCompiler(serializerCompiler);
     if (this.corsOptions) {
       await this.server.register(cors, this.corsOptions);
     }
+    await this.initModules();
+    this.logger.debug("Navios application initialized");
+  }
+  async getFastifyInstance(rawOptions) {
+    const { logger, ...options } = rawOptions;
+    if (logger) {
+      const fastifyOptions = options;
+      if (typeof logger === "boolean") {
+        if (!logger) {
+          fastifyOptions.logger = false;
+        }
+      } else {
+        fastifyOptions.loggerInstance = new PinoWrapper(
+          await inject(Logger, {
+            context: "FastifyAdapter"
+          })
+        );
+      }
+      return fastify(fastifyOptions);
+    } else {
+      return fastify({
+        ...options,
+        loggerInstance: new PinoWrapper(
+          await inject(Logger, {
+            context: "FastifyAdapter"
+          })
+        )
+      });
+    }
+  }
+  async initModules() {
     const modules = this.moduleLoader.getAllModules();
-    const globalPrefix = this.globalPrefix ?? "";
+    const promises = [];
     for (const [moduleName, moduleMetadata] of modules) {
       if (!moduleMetadata.controllers || moduleMetadata.controllers.size === 0) {
         continue;
       }
-      this.server.register(
-        (instance, opts, done) => {
-          for (const controller of moduleMetadata.controllers) {
-            this.controllerAdapter.setupController(
-              controller,
-              instance,
-              moduleMetadata
-            );
+      promises.push(
+        this.server.register(
+          (instance, opts, done) => {
+            for (const controller of moduleMetadata.controllers) {
+              this.controllerAdapter.setupController(
+                controller,
+                instance,
+                moduleMetadata
+              );
+            }
+            done();
+          },
+          {
+            prefix: this.globalPrefix ?? ""
           }
-          done();
-        },
-        {
-          prefix: globalPrefix
-        }
+        )
       );
     }
+    await Promise.all(promises);
   }
   enableCors(options) {
-    var _a;
     this.corsOptions = options;
-    (_a = this.server) == null ? void 0 : _a.register;
   }
   setGlobalPrefix(prefix) {
     this.globalPrefix = prefix;
@@ -1582,23 +2279,35 @@ var NaviosApplication = class {
     await this.server.listen(options);
   }
 };
-_init4 = __decoratorStart(null);
-NaviosApplication = __decorateElement(_init4, 0, "NaviosApplication", _NaviosApplication_decorators, NaviosApplication);
-__runInitializers(_init4, 1, NaviosApplication);
+_init7 = __decoratorStart(null);
+_NaviosApplication = __decorateElement(_init7, 0, "NaviosApplication", _NaviosApplication_decorators, _NaviosApplication);
+__runInitializers(_init7, 1, _NaviosApplication);
+var NaviosApplication = _NaviosApplication;
 
 // packages/core/src/navios.factory.mts
 var NaviosFactory = class {
   static async create(appModule, options = {}) {
     const app = await inject(NaviosApplication);
+    this.registerLoggerConfiguration(options);
     app.setup(appModule, options);
     return app;
   }
+  static registerLoggerConfiguration(options) {
+    if (!options) {
+      return;
+    }
+    const { logger } = options;
+    if (logger !== true && !isNil(logger)) {
+      LoggerInstance.overrideLogger(logger);
+    }
+  }
 };
 export {
   Application,
   AttributeFactory,
   BadRequestException,
   ConflictException,
+  ConsoleLogger,
   Controller,
   ControllerAdapterService,
   ControllerMetadataKey,
@@ -1622,12 +2331,19 @@ export {
   InstanceExpired,
   InstanceNotFound,
   InternalServerErrorException,
+  LOG_LEVELS,
+  Logger,
+  LoggerFactory,
+  LoggerInjectionToken,
+  LoggerInstance,
+  LoggerOptions,
   Module,
   ModuleLoaderService,
   ModuleMetadataKey,
   NaviosApplication,
   NaviosFactory,
   NotFoundException,
+  PinoWrapper,
   Reply,
   Request,
   ServiceLocator,
@@ -1638,8 +2354,11 @@ export {
   UnauthorizedException,
   UnknownError,
   UseGuards,
+  addLeadingSlash,
+  clc,
   extractControllerMetadata,
   extractModuleMetadata,
+  filterLogLevels,
   getAllEndpointMetadata,
   getControllerMetadata,
   getEndpointMetadata,
@@ -1649,9 +2368,24 @@ export {
   hasControllerMetadata,
   hasModuleMetadata,
   inject,
+  isConstructor,
+  isEmpty,
+  isFunction,
+  isLogLevel,
+  isLogLevelEnabled,
+  isNil,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isString,
+  isSymbol,
+  isUndefined,
+  normalizePath,
   override,
   provideServiceLocator,
   setPromiseCollector,
-  syncInject
+  stripEndSlash,
+  syncInject,
+  yellow
 };
 //# sourceMappingURL=index.mjs.map