@navios/core 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -46,115 +46,117 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
-// packages/core/src/metadata/endpoint.metadata.mts
-var EndpointMetadataKey = Symbol("EndpointMetadataKey");
-function getAllEndpointMetadata(context) {
-  if (context.metadata) {
-    const metadata = context.metadata[EndpointMetadataKey];
-    if (metadata) {
-      return metadata;
-    } else {
-      context.metadata[EndpointMetadataKey] = /* @__PURE__ */ new Set();
-      return context.metadata[EndpointMetadataKey];
-    }
-  }
-  throw new Error("[Navios] Wrong environment.");
+// packages/core/src/config/utils/helpers.mts
+import { env } from "node:process";
+function envInt(key, defaultValue) {
+  const envKey = env[key] || process.env[key];
+  return envKey ? parseInt(envKey, 10) : defaultValue;
 }
-function getEndpointMetadata(target, context) {
-  if (context.metadata) {
-    const metadata = getAllEndpointMetadata(context);
-    if (metadata) {
-      const endpointMetadata = Array.from(metadata).find(
-        (item) => item.classMethod === target.name
-      );
-      if (endpointMetadata) {
-        return endpointMetadata;
-      } else {
-        const newMetadata = {
-          classMethod: target.name,
-          url: "",
-          httpMethod: "GET",
-          config: null,
-          guards: /* @__PURE__ */ new Set(),
-          customAttributes: /* @__PURE__ */ new Map()
-        };
-        metadata.add(newMetadata);
-        return newMetadata;
-      }
-    }
-  }
-  throw new Error("[Navios] Wrong environment.");
+function envString(key, defaultValue) {
+  return env[key] || process.env[key] || defaultValue || void 0;
 }
 
-// packages/core/src/metadata/controller.metadata.mts
-var ControllerMetadataKey = Symbol("ControllerMetadataKey");
-function getControllerMetadata(target, context) {
-  if (context.metadata) {
-    const metadata = context.metadata[ControllerMetadataKey];
-    if (metadata) {
-      return metadata;
-    } else {
-      const endpointsMetadata = getAllEndpointMetadata(context);
-      const newMetadata = {
-        endpoints: endpointsMetadata,
-        guards: /* @__PURE__ */ new Set(),
-        customAttributes: /* @__PURE__ */ new Map()
-      };
-      context.metadata[ControllerMetadataKey] = newMetadata;
-      target[ControllerMetadataKey] = newMetadata;
-      return newMetadata;
-    }
-  }
-  throw new Error("[Navios] Wrong environment.");
+// packages/core/src/config/config.provider.mts
+import { z as z2 } from "zod";
+
+// 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);
 }
-function extractControllerMetadata(target) {
-  const metadata = target[ControllerMetadataKey];
-  if (!metadata) {
-    throw new Error(
-      "[Navios] Controller metadata not found. Make sure to use @Controller decorator."
+
+// 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 metadata;
-}
-function hasControllerMetadata(target) {
-  const metadata = target[ControllerMetadataKey];
-  return !!metadata;
+  return isLogLevel(sanitizedString) ? [sanitizedString] : LOG_LEVELS;
 }
 
-// packages/core/src/metadata/module.metadata.mts
-var ModuleMetadataKey = Symbol("ControllerMetadataKey");
-function getModuleMetadata(target, context) {
-  if (context.metadata) {
-    const metadata = context.metadata[ModuleMetadataKey];
-    if (metadata) {
-      return metadata;
-    } else {
-      const newMetadata = {
-        controllers: /* @__PURE__ */ new Set(),
-        imports: /* @__PURE__ */ new Set(),
-        guards: /* @__PURE__ */ new Set(),
-        customAttributes: /* @__PURE__ */ new Map()
-      };
-      context.metadata[ModuleMetadataKey] = newMetadata;
-      target[ModuleMetadataKey] = newMetadata;
-      return newMetadata;
-    }
+// 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;
   }
-  throw new Error("[Navios] Wrong environment.");
-}
-function extractModuleMetadata(target) {
-  const metadata = target[ModuleMetadataKey];
-  if (!metadata) {
-    throw new Error(
-      "[Navios] Module metadata not found. Make sure to use @Module decorator."
-    );
+  if (logLevels.includes(targetLevel)) {
+    return true;
   }
-  return metadata;
-}
-function hasModuleMetadata(target) {
-  return !!target[ModuleMetadataKey];
+  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";
+
 // packages/core/src/service-locator/enums/injectable-scope.enum.mts
 var InjectableScope = /* @__PURE__ */ ((InjectableScope2) => {
   InjectableScope2["Singleton"] = "Singleton";
@@ -164,6 +166,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;
@@ -712,7 +715,15 @@ var ServiceLocator = class {
     ).then(() => null);
   }
   makeInstanceName(token, args) {
-    let stringifiedArgs = args ? ":" + JSON.stringify(args).replaceAll(/"/g, "").replaceAll(/:/g, "=").replaceAll(/,/g, "|") : "";
+    let stringifiedArgs = args ? ":" + JSON.stringify(args, (_, value) => {
+      if (typeof value === "function") {
+        return `function:${value.name}(${value.length})`;
+      }
+      if (typeof value === "symbol") {
+        return value.toString();
+      }
+      return value;
+    }).replaceAll(/"/g, "").replaceAll(/:/g, "=").replaceAll(/,/g, "|") : "";
     const { name: name2 } = token;
     if (typeof name2 === "function") {
       const className = name2.name;
@@ -988,6 +999,761 @@ function override(token, target) {
   };
 }
 
+// packages/core/src/logger/console-logger.service.mts
+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/config/config.service.mts
+import { NaviosException } from "@navios/common";
+var ConfigServiceInstance = class {
+  constructor(config = {}, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  getConfig() {
+    return this.config;
+  }
+  get(key) {
+    var _a, _b;
+    try {
+      const parts = String(key).split(".");
+      let value = this.config;
+      for (const part of parts) {
+        if (value === null || value === void 0 || typeof value !== "object") {
+          return null;
+        }
+        value = value[part];
+      }
+      return value ?? null;
+    } catch (error) {
+      (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(
+        _a,
+        `Failed to get config value for key ${String(key)}`,
+        error
+      );
+      return null;
+    }
+  }
+  getOrDefault(key, defaultValue) {
+    const value = this.get(key);
+    return value !== null ? value : defaultValue;
+  }
+  getOrThrow(key, errorMessage) {
+    const value = this.get(key);
+    if (value === null) {
+      const message = errorMessage || `Configuration value for key "${String(key)}" is not defined`;
+      this.logger.error(message);
+      throw new NaviosException(message);
+    }
+    return value;
+  }
+};
+
+// packages/core/src/config/config.provider.mts
+var ConfigProviderInjectionToken = "ConfigProvider";
+var ConfigProviderOptions = z2.object({
+  load: z2.function()
+});
+var ConfigProvider = InjectionToken.create(ConfigProviderInjectionToken, ConfigProviderOptions);
+var _ConfigProviderFactory_decorators, _init4;
+_ConfigProviderFactory_decorators = [Injectable({
+  token: ConfigProvider,
+  type: "Factory" /* Factory */
+})];
+var ConfigProviderFactory = class {
+  logger = inject(Logger, {
+    context: "ConfigService"
+  });
+  async create(ctx, args) {
+    const { load } = args;
+    const logger = await this.logger;
+    try {
+      const config = await load();
+      return new ConfigServiceInstance(config, logger);
+    } catch (error) {
+      logger.error("Error loading config", error);
+      throw error;
+    }
+  }
+};
+_init4 = __decoratorStart(null);
+ConfigProviderFactory = __decorateElement(_init4, 0, "ConfigProviderFactory", _ConfigProviderFactory_decorators, ConfigProviderFactory);
+__runInitializers(_init4, 1, ConfigProviderFactory);
+function makeConfigToken(options) {
+  var _ConfigServiceImpl_decorators, _init9;
+  _ConfigServiceImpl_decorators = [Injectable({
+    type: "Factory" /* Factory */
+  })];
+  class ConfigServiceImpl {
+    configService = inject(ConfigProvider, options);
+    create() {
+      return this.configService;
+    }
+  }
+  _init9 = __decoratorStart(null);
+  ConfigServiceImpl = __decorateElement(_init9, 0, "ConfigServiceImpl", _ConfigServiceImpl_decorators, ConfigServiceImpl);
+  __runInitializers(_init9, 1, ConfigServiceImpl);
+  return getInjectableToken(ConfigServiceImpl);
+}
+
+// packages/core/src/metadata/endpoint.metadata.mts
+var EndpointMetadataKey = Symbol("EndpointMetadataKey");
+function getAllEndpointMetadata(context) {
+  if (context.metadata) {
+    const metadata = context.metadata[EndpointMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      context.metadata[EndpointMetadataKey] = /* @__PURE__ */ new Set();
+      return context.metadata[EndpointMetadataKey];
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function getEndpointMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = getAllEndpointMetadata(context);
+    if (metadata) {
+      const endpointMetadata = Array.from(metadata).find(
+        (item) => item.classMethod === target.name
+      );
+      if (endpointMetadata) {
+        return endpointMetadata;
+      } else {
+        const newMetadata = {
+          classMethod: target.name,
+          url: "",
+          httpMethod: "GET",
+          config: null,
+          guards: /* @__PURE__ */ new Set(),
+          customAttributes: /* @__PURE__ */ new Map()
+        };
+        metadata.add(newMetadata);
+        return newMetadata;
+      }
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+
+// packages/core/src/metadata/controller.metadata.mts
+var ControllerMetadataKey = Symbol("ControllerMetadataKey");
+function getControllerMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = context.metadata[ControllerMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      const endpointsMetadata = getAllEndpointMetadata(context);
+      const newMetadata = {
+        endpoints: endpointsMetadata,
+        guards: /* @__PURE__ */ new Set(),
+        customAttributes: /* @__PURE__ */ new Map()
+      };
+      context.metadata[ControllerMetadataKey] = newMetadata;
+      target[ControllerMetadataKey] = newMetadata;
+      return newMetadata;
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function extractControllerMetadata(target) {
+  const metadata = target[ControllerMetadataKey];
+  if (!metadata) {
+    throw new Error(
+      "[Navios] Controller metadata not found. Make sure to use @Controller decorator."
+    );
+  }
+  return metadata;
+}
+function hasControllerMetadata(target) {
+  const metadata = target[ControllerMetadataKey];
+  return !!metadata;
+}
+
+// packages/core/src/metadata/module.metadata.mts
+var ModuleMetadataKey = Symbol("ControllerMetadataKey");
+function getModuleMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = context.metadata[ModuleMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      const newMetadata = {
+        controllers: /* @__PURE__ */ new Set(),
+        imports: /* @__PURE__ */ new Set(),
+        guards: /* @__PURE__ */ new Set(),
+        customAttributes: /* @__PURE__ */ new Map()
+      };
+      context.metadata[ModuleMetadataKey] = newMetadata;
+      target[ModuleMetadataKey] = newMetadata;
+      return newMetadata;
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function extractModuleMetadata(target) {
+  const metadata = target[ModuleMetadataKey];
+  if (!metadata) {
+    throw new Error(
+      "[Navios] Module metadata not found. Make sure to use @Module decorator."
+    );
+  }
+  return metadata;
+}
+function hasModuleMetadata(target) {
+  return !!target[ModuleMetadataKey];
+}
+
 // packages/core/src/decorators/controller.decorator.mts
 function Controller({ guards } = {}) {
   return function(target, context) {
@@ -1217,7 +1983,7 @@ var ExecutionContext2 = class {
 };
 
 // packages/core/src/services/guard-runner.service.mts
-var _GuardRunnerService_decorators, _init;
+var _GuardRunnerService_decorators, _init5;
 _GuardRunnerService_decorators = [Injectable()];
 var GuardRunnerService = class {
   async runGuards(allGuards, executionContext) {
@@ -1280,15 +2046,18 @@ var GuardRunnerService = class {
     return guards;
   }
 };
-_init = __decoratorStart(null);
-GuardRunnerService = __decorateElement(_init, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
-__runInitializers(_init, 1, GuardRunnerService);
+_init5 = __decoratorStart(null);
+GuardRunnerService = __decorateElement(_init5, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
+__runInitializers(_init5, 1, GuardRunnerService);
 
 // packages/core/src/services/controller-adapter.service.mts
-var _ControllerAdapterService_decorators, _init2;
+var _ControllerAdapterService_decorators, _init6;
 _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 +2152,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);
+_init6 = __decoratorStart(null);
+_ControllerAdapterService = __decorateElement(_init6, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
+__runInitializers(_init6, 1, _ControllerAdapterService);
+var ControllerAdapterService = _ControllerAdapterService;
 
 // packages/core/src/services/module-loader.service.mts
-var _ModuleLoaderService_decorators, _init3;
+var _ModuleLoaderService_decorators, _init7;
 _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 +2199,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 +2221,10 @@ var ModuleLoaderService = class {
     return this.modulesMetadata;
   }
 };
-_init3 = __decoratorStart(null);
-ModuleLoaderService = __decorateElement(_init3, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, ModuleLoaderService);
-__runInitializers(_init3, 1, ModuleLoaderService);
+_init7 = __decoratorStart(null);
+_ModuleLoaderService = __decorateElement(_init7, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
+__runInitializers(_init7, 1, _ModuleLoaderService);
+var ModuleLoaderService = _ModuleLoaderService;
 
 // packages/core/src/attribute.factory.mts
 var AttributeFactory = class {
@@ -1512,11 +2290,14 @@ import {
   serializerCompiler,
   validatorCompiler
 } from "fastify-type-provider-zod";
-var _NaviosApplication_decorators, _init4;
+var _NaviosApplication_decorators, _init8;
 _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 +2312,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 +2395,40 @@ var NaviosApplication = class {
     await this.server.listen(options);
   }
 };
-_init4 = __decoratorStart(null);
-NaviosApplication = __decorateElement(_init4, 0, "NaviosApplication", _NaviosApplication_decorators, NaviosApplication);
-__runInitializers(_init4, 1, NaviosApplication);
+_init8 = __decoratorStart(null);
+_NaviosApplication = __decorateElement(_init8, 0, "NaviosApplication", _NaviosApplication_decorators, _NaviosApplication);
+__runInitializers(_init8, 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,
+  ConfigProvider,
+  ConfigProviderFactory,
+  ConfigProviderInjectionToken,
+  ConfigProviderOptions,
+  ConfigServiceInstance,
   ConflictException,
+  ConsoleLogger,
   Controller,
   ControllerAdapterService,
   ControllerMetadataKey,
@@ -1622,12 +2452,19 @@ export {
   InstanceExpired,
   InstanceNotFound,
   InternalServerErrorException,
+  LOG_LEVELS,
+  Logger,
+  LoggerFactory,
+  LoggerInjectionToken,
+  LoggerInstance,
+  LoggerOptions,
   Module,
   ModuleLoaderService,
   ModuleMetadataKey,
   NaviosApplication,
   NaviosFactory,
   NotFoundException,
+  PinoWrapper,
   Reply,
   Request,
   ServiceLocator,
@@ -1638,8 +2475,13 @@ export {
   UnauthorizedException,
   UnknownError,
   UseGuards,
+  addLeadingSlash,
+  clc,
+  envInt,
+  envString,
   extractControllerMetadata,
   extractModuleMetadata,
+  filterLogLevels,
   getAllEndpointMetadata,
   getControllerMetadata,
   getEndpointMetadata,
@@ -1649,9 +2491,25 @@ export {
   hasControllerMetadata,
   hasModuleMetadata,
   inject,
+  isConstructor,
+  isEmpty,
+  isFunction,
+  isLogLevel,
+  isLogLevelEnabled,
+  isNil,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isString,
+  isSymbol,
+  isUndefined,
+  makeConfigToken,
+  normalizePath,
   override,
   provideServiceLocator,
   setPromiseCollector,
-  syncInject
+  stripEndSlash,
+  syncInject,
+  yellow
 };
 //# sourceMappingURL=index.mjs.map