@navios/core 0.1.1 → 0.1.2

package/dist/index.js

@@ -77,6 +77,11 @@ __export(src_exports, {
   Application: () => Application,
   AttributeFactory: () => AttributeFactory,
   BadRequestException: () => BadRequestException,
+  ConfigProvider: () => ConfigProvider,
+  ConfigProviderFactory: () => ConfigProviderFactory,
+  ConfigProviderInjectionToken: () => ConfigProviderInjectionToken,
+  ConfigProviderOptions: () => ConfigProviderOptions,
+  ConfigServiceInstance: () => ConfigServiceInstance,
   ConflictException: () => ConflictException,
   ConsoleLogger: () => ConsoleLogger,
   Controller: () => Controller,
@@ -127,6 +132,8 @@ __export(src_exports, {
   UseGuards: () => UseGuards,
   addLeadingSlash: () => addLeadingSlash,
   clc: () => clc,
+  envInt: () => envInt,
+  envString: () => envString,
   extractControllerMetadata: () => extractControllerMetadata,
   extractModuleMetadata: () => extractModuleMetadata,
   filterLogLevels: () => filterLogLevels,
@@ -151,6 +158,7 @@ __export(src_exports, {
   isString: () => isString,
   isSymbol: () => isSymbol,
   isUndefined: () => isUndefined,
+  makeConfigToken: () => makeConfigToken,
   normalizePath: () => normalizePath,
   override: () => override,
   provideServiceLocator: () => provideServiceLocator,
@@ -161,115 +169,117 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// 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
+var import_node_process = require("process");
+function envInt(key, defaultValue) {
+  const envKey = import_node_process.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 import_node_process.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
+var import_zod3 = require("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
+var import_util = require("util");
+
 // packages/core/src/service-locator/enums/injectable-scope.enum.mts
 var InjectableScope = /* @__PURE__ */ ((InjectableScope2) => {
   InjectableScope2["Singleton"] = "Singleton";
@@ -828,7 +838,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;
@@ -1104,277 +1122,362 @@ function override(token, target) {
   };
 }
 
-// packages/core/src/decorators/controller.decorator.mts
-function Controller({ guards } = {}) {
-  return function(target, context) {
-    if (context.kind !== "class") {
-      throw new Error(
-        "[Navios] @Controller decorator can only be used on classes."
-      );
+// 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;
     }
-    const token = InjectionToken.create(target);
-    if (context.metadata) {
-      const controllerMetadata = getControllerMetadata(target, context);
-      if (guards) {
-        for (const guard of Array.from(guards).reverse()) {
-          controllerMetadata.guards.add(guard);
-        }
-      }
-    }
-    return Injectable({
-      token,
-      type: "Class" /* Class */,
-      scope: "Instance" /* Instance */
-    })(target, context);
-  };
-}
-
-// packages/core/src/decorators/endpoint.decorator.mts
-function Endpoint(endpoint) {
-  return (target, context) => {
-    if (typeof target !== "function") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on functions."
-      );
+  }
+  log(message, ...optionalParams) {
+    if (!this.isLevelEnabled("log")) {
+      return;
     }
-    if (context.kind !== "method") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on methods."
-      );
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "log");
+  }
+  error(message, ...optionalParams) {
+    if (!this.isLevelEnabled("error")) {
+      return;
     }
-    const config = endpoint.config;
-    if (context.metadata) {
-      let endpointMetadata = getEndpointMetadata(target, context);
-      if (endpointMetadata.config && endpointMetadata.config.url) {
-        throw new Error(
-          `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`
-        );
-      }
-      endpointMetadata.config = config;
-      endpointMetadata.classMethod = target.name;
-      endpointMetadata.httpMethod = config.method;
-      endpointMetadata.url = config.url;
+    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;
     }
-    return target;
-  };
-}
-
-// packages/core/src/decorators/module.decorator.mts
-function Module(metadata) {
-  return (target, context) => {
-    if (context.kind !== "class") {
-      throw new Error("[Navios] @Module decorator can only be used on classes.");
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "warn");
+  }
+  debug(message, ...optionalParams) {
+    if (!this.isLevelEnabled("debug")) {
+      return;
     }
-    const token = InjectionToken.create(target);
-    const moduleMetadata = getModuleMetadata(target, context);
-    if (metadata.controllers) {
-      for (const controller of metadata.controllers) {
-        moduleMetadata.controllers.add(controller);
-      }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "debug");
+  }
+  verbose(message, ...optionalParams) {
+    if (!this.isLevelEnabled("verbose")) {
+      return;
     }
-    if (metadata.imports) {
-      for (const importedModule of metadata.imports) {
-        moduleMetadata.imports.add(importedModule);
-      }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "verbose");
+  }
+  fatal(message, ...optionalParams) {
+    if (!this.isLevelEnabled("fatal")) {
+      return;
     }
-    if (metadata.guards) {
-      for (const guard of Array.from(metadata.guards).reverse()) {
-        moduleMetadata.guards.add(guard);
-      }
+    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 = {};
     }
-    return Injectable({
-      token,
-      type: "Class" /* Class */,
-      scope: "Singleton" /* Singleton */
-    })(target, context);
-  };
-}
-
-// packages/core/src/decorators/use-guards.decorator.mts
-function UseGuards(...guards) {
-  return function(target, context) {
-    if (context.kind === "class") {
-      const controllerMetadata = getControllerMetadata(
-        target,
-        context
-      );
-      for (const guard of guards.reverse()) {
-        controllerMetadata.guards.add(guard);
-      }
-    } else if (context.kind === "method") {
-      const endpointMetadata = getEndpointMetadata(target, context);
-      for (const guard of guards.reverse()) {
-        endpointMetadata.guards.add(guard);
+    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;
       }
-    } else {
-      throw new Error(
-        "[Navios] @UseGuards decorator can only be used on classes or methods."
+      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;
     }
-    return target;
-  };
-}
-
-// packages/core/src/exceptions/http.exception.mts
-var HttpException = class {
-  constructor(statusCode, response, error) {
-    this.statusCode = statusCode;
-    this.response = response;
-    this.error = error;
+    if (options.errorStack) {
+      logObject.stack = options.errorStack;
+    }
+    const formattedMessage = !this.options.colors && this.inspectOptions.compact === true ? JSON.stringify(logObject, this.stringifyReplacer) : (0, import_util.inspect)(logObject, this.inspectOptions);
+    process[options.writeStreamType ?? "stdout"].write(`${formattedMessage}
+`);
   }
-};
-
-// packages/core/src/exceptions/bad-request.exception.mts
-var BadRequestException = class extends HttpException {
-  constructor(message) {
-    super(400, message);
+  formatPid(pid) {
+    return `[${this.options.prefix}] ${pid}  - `;
   }
-};
-
-// packages/core/src/exceptions/forbidden.exception.mts
-var ForbiddenException = class extends HttpException {
-  constructor(message) {
-    super(403, message);
+  formatContext(context) {
+    if (!context) {
+      return "";
+    }
+    context = `[${context}] `;
+    return this.options.colors ? yellow(context) : context;
   }
-};
-
-// packages/core/src/exceptions/internal-server-error.exception.mts
-var InternalServerErrorException = class extends HttpException {
-  constructor(message, error) {
-    super(500, message, error);
+  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}
+`;
   }
-};
-
-// packages/core/src/exceptions/not-found.exception.mts
-var NotFoundException = class extends HttpException {
-  constructor(response, error) {
-    super(404, response, error);
-    this.response = response;
-    this.error = error;
+  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 = (0, import_util.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;
   }
-};
-
-// packages/core/src/exceptions/unauthorized.exception.mts
-var UnauthorizedException = class extends HttpException {
-  constructor(message, error) {
-    super(401, message, error);
+  colorize(message, logLevel) {
+    if (!this.options.colors || this.options.json) {
+      return message;
+    }
+    const color = this.getColorByLogLevel(logLevel);
+    return color(message);
   }
-};
-
-// packages/core/src/exceptions/conflict.exception.mts
-var ConflictException = class extends HttpException {
-  constructor(message, error) {
-    super(409, message, error);
+  printStackTrace(stack) {
+    if (!stack || this.options.json) {
+      return;
+    }
+    process.stderr.write(`${stack}
+`);
   }
-};
-
-// 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}`);
+  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;
     }
-    return LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1);
-  } else if (sanitizedString.includes(",")) {
-    return sanitizedString.split(",").filter(isLogLevel);
+    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 `${(0, import_util.inspect)(value, this.inspectOptions)}`;
+    }
+    return value;
   }
-  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;
+  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)
+    };
   }
-  if (logLevels.includes(targetLevel)) {
-    return true;
+  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
+    };
   }
-  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;
+  isStackFormat(stack) {
+    if (!isString(stack) && !isUndefined(stack)) {
+      return false;
+    }
+    return /^(.)+\n\s+at .+:\d+:\d+/.test(stack);
   }
-  const proto = Object.getPrototypeOf(fn);
-  if (proto === null) {
-    return true;
+  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;
+    }
   }
-  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";
+_init = __decoratorStart(null);
+_ConsoleLogger = __decorateElement(_init, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
+__runInitializers(_init, 1, _ConsoleLogger);
+var ConsoleLogger = _ConsoleLogger;
 
-// packages/core/src/logger/console-logger.service.mts
-var import_util = require("util");
-var DEFAULT_DEPTH = 5;
-var DEFAULT_LOG_LEVELS = [
-  "log",
-  "error",
-  "warn",
-  "debug",
-  "verbose",
-  "fatal"
-];
-var dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
+// packages/core/src/logger/logger.factory.mts
+var import_zod2 = require("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",
@@ -1382,538 +1485,559 @@ var dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
   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;
-    }
+var _LoggerInstance_decorators, _init2;
+_LoggerInstance_decorators = [Injectable()];
+var _LoggerInstance = class _LoggerInstance {
+  constructor(context, options = {}) {
+    this.context = context;
+    this.options = options;
   }
-  log(message, ...optionalParams) {
-    if (!this.isLevelEnabled("log")) {
-      return;
+  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();
+      }
     }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "log");
+    return _LoggerInstance.staticInstanceRef;
   }
   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);
+    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) {
-    if (!this.isLevelEnabled("warn")) {
-      return;
-    }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "warn");
+    var _a;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_a = this.localInstance) == null ? void 0 : _a.warn(message, ...optionalParams);
   }
   debug(message, ...optionalParams) {
-    if (!this.isLevelEnabled("debug")) {
-      return;
-    }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "debug");
+    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) {
-    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;
+    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);
   }
-  /**
-   * Set logger context
-   * @param context context
-   */
-  setContext(context) {
-    this.context = context;
+  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);
   }
-  /**
-   * Resets the logger context to the value that was passed in the constructor.
-   */
-  resetContext() {
-    this.context = this.originalContext;
+  static error(message, ...optionalParams) {
+    var _a;
+    (_a = this.staticInstanceRef) == null ? void 0 : _a.error(message, ...optionalParams);
   }
-  isLevelEnabled(level) {
+  static log(message, ...optionalParams) {
     var _a;
-    const logLevels = (_a = this.options) == null ? void 0 : _a.logLevels;
-    return isLogLevelEnabled(level, logLevels);
+    (_a = this.staticInstanceRef) == null ? void 0 : _a.log(message, ...optionalParams);
   }
-  getTimestamp() {
-    return dateTimeFormatter.format(Date.now());
+  static warn(message, ...optionalParams) {
+    var _a;
+    (_a = this.staticInstanceRef) == null ? void 0 : _a.warn(message, ...optionalParams);
   }
-  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);
-    });
+  static debug(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
   }
-  printAsJson(message, options) {
-    const logObject = {
-      level: options.logLevel,
-      pid: process.pid,
-      timestamp: Date.now(),
-      message
-    };
-    if (options.context) {
-      logObject.context = options.context;
+  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 (options.errorStack) {
-      logObject.stack = options.errorStack;
+    if (isObject(logger)) {
+      this.staticInstanceRef = logger;
+    } else {
+      this.staticInstanceRef = void 0;
     }
-    const formattedMessage = !this.options.colors && this.inspectOptions.compact === true ? JSON.stringify(logObject, this.stringifyReplacer) : (0, import_util.inspect)(logObject, this.inspectOptions);
-    process[options.writeStreamType ?? "stdout"].write(`${formattedMessage}
-`);
   }
-  formatPid(pid) {
-    return `[${this.options.prefix}] ${pid}  - `;
+  static isLevelEnabled(level) {
+    const logLevels = _LoggerInstance.logLevels;
+    return isLogLevelEnabled(level, logLevels);
   }
-  formatContext(context) {
-    if (!context) {
-      return "";
+  registerLocalInstanceRef() {
+    var _a;
+    if (this.localInstanceRef) {
+      return this.localInstanceRef;
     }
-    context = `[${context}] `;
-    return this.options.colors ? yellow(context) : context;
+    this.localInstanceRef = new ConsoleLogger(this.context, {
+      timestamp: (_a = this.options) == null ? void 0 : _a.timestamp,
+      logLevels: _LoggerInstance.logLevels
+    });
+    return this.localInstanceRef;
   }
-  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}
-`;
+};
+_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 = import_zod2.z.object({
+  context: import_zod2.z.string().optional(),
+  options: import_zod2.z.object({
+    timestamp: import_zod2.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);
   }
-  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 = (0, import_util.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;
+};
+_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;
   }
-  colorize(message, logLevel) {
-    if (!this.options.colors || this.options.json) {
-      return message;
+  fatal(message, ...optionalParams) {
+    if (this.logger.fatal === void 0) {
+      return this.error(message, ...optionalParams);
     }
-    const color = this.getColorByLogLevel(logLevel);
-    return color(message);
+    this.logger.fatal(message, ...optionalParams);
   }
-  printStackTrace(stack) {
-    if (!stack || this.options.json) {
-      return;
-    }
-    process.stderr.write(`${stack}
-`);
+  error(message, ...optionalParams) {
+    this.logger.error(message, ...optionalParams);
   }
-  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;
+  warn(message, ...optionalParams) {
+    this.logger.warn(message, ...optionalParams);
   }
-  formatTimestampDiff(timestampDiff) {
-    const formattedDiff = ` +${timestampDiff}ms`;
-    return this.options.colors ? yellow(formattedDiff) : formattedDiff;
+  info(message, ...optionalParams) {
+    this.logger.log(message, ...optionalParams);
   }
-  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;
+  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)}`;
     }
-    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;
+    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;
     }
-    if (this.options.maxStringLength) {
-      inspectOptions.maxStringLength = this.options.maxStringLength;
+    const levels = LoggerInstance["logLevels"];
+    if (levels) {
+      return levels[0];
     }
-    return inspectOptions;
+    return "info";
   }
-  stringifyReplacer(key, value) {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    if (typeof value === "symbol") {
-      return value.toString();
+};
+
+// packages/core/src/config/config.service.mts
+var import_common = require("@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;
     }
-    if (value instanceof Map || value instanceof Set || value instanceof Error) {
-      return `${(0, import_util.inspect)(value, this.inspectOptions)}`;
+  }
+  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 import_common.NaviosException(message);
     }
     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 };
+};
+
+// packages/core/src/config/config.provider.mts
+var ConfigProviderInjectionToken = "ConfigProvider";
+var ConfigProviderOptions = import_zod3.z.object({
+  load: import_zod3.z.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;
     }
-    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 };
+};
+_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];
     }
-    const lastElement = messages[messages.length - 1];
-    const isStack = isString(lastElement);
-    if (!isStack && !isUndefined(lastElement)) {
-      return { messages, context };
+  }
+  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;
+      }
     }
-    return {
-      stack: lastElement,
-      messages: messages.slice(0, messages.length - 1),
-      context
-    };
   }
-  isStackFormat(stack) {
-    if (!isString(stack) && !isUndefined(stack)) {
-      return false;
+  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;
     }
-    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;
+  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;
     }
   }
-};
-_init = __decoratorStart(null);
-_ConsoleLogger = __decorateElement(_init, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
-__runInitializers(_init, 1, _ConsoleLogger);
-var ConsoleLogger = _ConsoleLogger;
+  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/logger/logger.factory.mts
-var import_zod2 = require("zod");
+// packages/core/src/decorators/controller.decorator.mts
+function Controller({ guards } = {}) {
+  return function(target, context) {
+    if (context.kind !== "class") {
+      throw new Error(
+        "[Navios] @Controller decorator can only be used on classes."
+      );
+    }
+    const token = InjectionToken.create(target);
+    if (context.metadata) {
+      const controllerMetadata = getControllerMetadata(target, context);
+      if (guards) {
+        for (const guard of Array.from(guards).reverse()) {
+          controllerMetadata.guards.add(guard);
+        }
+      }
+    }
+    return Injectable({
+      token,
+      type: "Class" /* Class */,
+      scope: "Instance" /* Instance */
+    })(target, context);
+  };
+}
 
-// 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();
+// packages/core/src/decorators/endpoint.decorator.mts
+function Endpoint(endpoint) {
+  return (target, context) => {
+    if (typeof target !== "function") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on functions."
+      );
+    }
+    if (context.kind !== "method") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on methods."
+      );
+    }
+    const config = endpoint.config;
+    if (context.metadata) {
+      let endpointMetadata = getEndpointMetadata(target, context);
+      if (endpointMetadata.config && endpointMetadata.config.url) {
+        throw new Error(
+          `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`
+        );
+      }
+      endpointMetadata.config = config;
+      endpointMetadata.classMethod = target.name;
+      endpointMetadata.httpMethod = config.method;
+      endpointMetadata.url = config.url;
+    }
+    return target;
+  };
+}
+
+// packages/core/src/decorators/module.decorator.mts
+function Module(metadata) {
+  return (target, context) => {
+    if (context.kind !== "class") {
+      throw new Error("[Navios] @Module decorator can only be used on classes.");
+    }
+    const token = InjectionToken.create(target);
+    const moduleMetadata = getModuleMetadata(target, context);
+    if (metadata.controllers) {
+      for (const controller of metadata.controllers) {
+        moduleMetadata.controllers.add(controller);
       }
     }
-    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 (metadata.imports) {
+      for (const importedModule of metadata.imports) {
+        moduleMetadata.imports.add(importedModule);
+      }
     }
-    if (isObject(logger)) {
-      this.staticInstanceRef = logger;
-    } else {
-      this.staticInstanceRef = void 0;
+    if (metadata.guards) {
+      for (const guard of Array.from(metadata.guards).reverse()) {
+        moduleMetadata.guards.add(guard);
+      }
     }
-  }
-  static isLevelEnabled(level) {
-    const logLevels = _LoggerInstance.logLevels;
-    return isLogLevelEnabled(level, logLevels);
-  }
-  registerLocalInstanceRef() {
-    var _a;
-    if (this.localInstanceRef) {
-      return this.localInstanceRef;
+    return Injectable({
+      token,
+      type: "Class" /* Class */,
+      scope: "Singleton" /* Singleton */
+    })(target, context);
+  };
+}
+
+// packages/core/src/decorators/use-guards.decorator.mts
+function UseGuards(...guards) {
+  return function(target, context) {
+    if (context.kind === "class") {
+      const controllerMetadata = getControllerMetadata(
+        target,
+        context
+      );
+      for (const guard of guards.reverse()) {
+        controllerMetadata.guards.add(guard);
+      }
+    } else if (context.kind === "method") {
+      const endpointMetadata = getEndpointMetadata(target, context);
+      for (const guard of guards.reverse()) {
+        endpointMetadata.guards.add(guard);
+      }
+    } else {
+      throw new Error(
+        "[Navios] @UseGuards decorator can only be used on classes or methods."
+      );
     }
-    this.localInstanceRef = new ConsoleLogger(this.context, {
-      timestamp: (_a = this.options) == null ? void 0 : _a.timestamp,
-      logLevels: _LoggerInstance.logLevels
-    });
-    return this.localInstanceRef;
+    return target;
+  };
+}
+
+// packages/core/src/exceptions/http.exception.mts
+var HttpException = class {
+  constructor(statusCode, response, error) {
+    this.statusCode = statusCode;
+    this.response = response;
+    this.error = error;
   }
 };
-_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 = import_zod2.z.object({
-  context: import_zod2.z.string().optional(),
-  options: import_zod2.z.object({
-    timestamp: import_zod2.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);
+// packages/core/src/exceptions/bad-request.exception.mts
+var BadRequestException = class extends HttpException {
+  constructor(message) {
+    super(400, message);
   }
 };
-_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);
+// packages/core/src/exceptions/forbidden.exception.mts
+var ForbiddenException = class extends HttpException {
+  constructor(message) {
+    super(403, message);
   }
-  trace(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.logger).verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+};
+
+// packages/core/src/exceptions/internal-server-error.exception.mts
+var InternalServerErrorException = class extends HttpException {
+  constructor(message, error) {
+    super(500, message, error);
   }
-  silent(message, ...optionalParams) {
+};
+
+// packages/core/src/exceptions/not-found.exception.mts
+var NotFoundException = class extends HttpException {
+  constructor(response, error) {
+    super(404, response, error);
+    this.response = response;
+    this.error = error;
   }
-  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"])
-    );
+};
+
+// packages/core/src/exceptions/unauthorized.exception.mts
+var UnauthorizedException = class extends HttpException {
+  constructor(message, error) {
+    super(401, message, error);
   }
-  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/exceptions/conflict.exception.mts
+var ConflictException = class extends HttpException {
+  constructor(message, error) {
+    super(409, message, error);
   }
 };
 
@@ -1982,7 +2106,7 @@ var ExecutionContext2 = class {
 };
 
 // packages/core/src/services/guard-runner.service.mts
-var _GuardRunnerService_decorators, _init4;
+var _GuardRunnerService_decorators, _init5;
 _GuardRunnerService_decorators = [Injectable()];
 var GuardRunnerService = class {
   async runGuards(allGuards, executionContext) {
@@ -2045,12 +2169,12 @@ var GuardRunnerService = class {
     return guards;
   }
 };
-_init4 = __decoratorStart(null);
-GuardRunnerService = __decorateElement(_init4, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
-__runInitializers(_init4, 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, _init5;
+var _ControllerAdapterService_decorators, _init6;
 _ControllerAdapterService_decorators = [Injectable()];
 var _ControllerAdapterService = class _ControllerAdapterService {
   guardRunner = syncInject(GuardRunnerService);
@@ -2157,13 +2281,13 @@ var _ControllerAdapterService = class _ControllerAdapterService {
     }
   }
 };
-_init5 = __decoratorStart(null);
-_ControllerAdapterService = __decorateElement(_init5, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
-__runInitializers(_init5, 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, _init6;
+var _ModuleLoaderService_decorators, _init7;
 _ModuleLoaderService_decorators = [Injectable()];
 var _ModuleLoaderService = class _ModuleLoaderService {
   logger = syncInject(Logger, {
@@ -2220,9 +2344,9 @@ var _ModuleLoaderService = class _ModuleLoaderService {
     return this.modulesMetadata;
   }
 };
-_init6 = __decoratorStart(null);
-_ModuleLoaderService = __decorateElement(_init6, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
-__runInitializers(_init6, 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
@@ -2286,7 +2410,7 @@ var AttributeFactory = class {
 var import_cors = __toESM(require("@fastify/cors"), 1);
 var import_fastify = require("fastify");
 var import_fastify_type_provider_zod = require("fastify-type-provider-zod");
-var _NaviosApplication_decorators, _init7;
+var _NaviosApplication_decorators, _init8;
 _NaviosApplication_decorators = [Injectable()];
 var _NaviosApplication = class _NaviosApplication {
   moduleLoader = syncInject(ModuleLoaderService);
@@ -2391,9 +2515,9 @@ var _NaviosApplication = class _NaviosApplication {
     await this.server.listen(options);
   }
 };
-_init7 = __decoratorStart(null);
-_NaviosApplication = __decorateElement(_init7, 0, "NaviosApplication", _NaviosApplication_decorators, _NaviosApplication);
-__runInitializers(_init7, 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
@@ -2419,6 +2543,11 @@ var NaviosFactory = class {
   Application,
   AttributeFactory,
   BadRequestException,
+  ConfigProvider,
+  ConfigProviderFactory,
+  ConfigProviderInjectionToken,
+  ConfigProviderOptions,
+  ConfigServiceInstance,
   ConflictException,
   ConsoleLogger,
   Controller,
@@ -2469,6 +2598,8 @@ var NaviosFactory = class {
   UseGuards,
   addLeadingSlash,
   clc,
+  envInt,
+  envString,
   extractControllerMetadata,
   extractModuleMetadata,
   filterLogLevels,
@@ -2493,6 +2624,7 @@ var NaviosFactory = class {
   isString,
   isSymbol,
   isUndefined,
+  makeConfigToken,
   normalizePath,
   override,
   provideServiceLocator,