@navios/core 0.1.1 → 0.1.3

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,
@@ -84,6 +89,7 @@ __export(src_exports, {
   ControllerMetadataKey: () => ControllerMetadataKey,
   Endpoint: () => Endpoint,
   EndpointMetadataKey: () => EndpointMetadataKey,
+  EndpointType: () => EndpointType,
   ErrorsEnum: () => ErrorsEnum,
   EventEmitter: () => EventEmitter,
   ExecutionContext: () => ExecutionContext2,
@@ -92,6 +98,8 @@ __export(src_exports, {
   FactoryNotFound: () => FactoryNotFound,
   ForbiddenException: () => ForbiddenException,
   GuardRunnerService: () => GuardRunnerService,
+  Header: () => Header,
+  HttpCode: () => HttpCode,
   HttpException: () => HttpException,
   Injectable: () => Injectable,
   InjectableScope: () => InjectableScope,
@@ -127,6 +135,8 @@ __export(src_exports, {
   UseGuards: () => UseGuards,
   addLeadingSlash: () => addLeadingSlash,
   clc: () => clc,
+  envInt: () => envInt,
+  envString: () => envString,
   extractControllerMetadata: () => extractControllerMetadata,
   extractModuleMetadata: () => extractModuleMetadata,
   filterLogLevels: () => filterLogLevels,
@@ -151,6 +161,7 @@ __export(src_exports, {
   isString: () => isString,
   isSymbol: () => isSymbol,
   isUndefined: () => isUndefined,
+  makeConfigToken: () => makeConfigToken,
   normalizePath: () => normalizePath,
   override: () => override,
   provideServiceLocator: () => provideServiceLocator,
@@ -161,115 +172,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 +841,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,318 +1125,58 @@ 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."
-      );
-    }
-    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."
-      );
-    }
-    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);
-      }
-    }
-    if (metadata.imports) {
-      for (const importedModule of metadata.imports) {
-        moduleMetadata.imports.add(importedModule);
-      }
-    }
-    if (metadata.guards) {
-      for (const guard of Array.from(metadata.guards).reverse()) {
-        moduleMetadata.guards.add(guard);
-      }
-    }
-    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."
-      );
-    }
-    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;
-  }
-};
-
-// packages/core/src/exceptions/bad-request.exception.mts
-var BadRequestException = class extends HttpException {
-  constructor(message) {
-    super(400, message);
-  }
-};
-
-// packages/core/src/exceptions/forbidden.exception.mts
-var ForbiddenException = class extends HttpException {
-  constructor(message) {
-    super(403, message);
-  }
-};
-
-// packages/core/src/exceptions/internal-server-error.exception.mts
-var InternalServerErrorException = class extends HttpException {
-  constructor(message, error) {
-    super(500, message, error);
-  }
-};
-
-// 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;
-  }
-};
-
-// packages/core/src/exceptions/unauthorized.exception.mts
-var UnauthorizedException = class extends HttpException {
-  constructor(message, error) {
-    super(401, message, error);
-  }
-};
-
-// packages/core/src/exceptions/conflict.exception.mts
-var ConflictException = class extends HttpException {
-  constructor(message, error) {
-    super(409, message, error);
-  }
-};
-
-// packages/core/src/logger/utils/cli-colors.util.mts
-var isColorAllowed = () => !process.env.NO_COLOR;
-var colorIfAllowed = (colorFn) => (text) => isColorAllowed() ? colorFn(text) : text;
-var clc = {
-  bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
-  green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
-  yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
-  red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
-  magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
-  cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
-};
-var yellow = colorIfAllowed(
-  (text) => `\x1B[38;5;3m${text}\x1B[39m`
-);
-
-// packages/core/src/logger/log-levels.mts
-var LOG_LEVELS = [
-  "verbose",
-  "debug",
-  "log",
-  "warn",
-  "error",
-  "fatal"
-];
-
-// packages/core/src/logger/utils/is-log-level.util.mts
-function isLogLevel(maybeLogLevel) {
-  return LOG_LEVELS.includes(maybeLogLevel);
-}
-
-// packages/core/src/logger/utils/filter-log-levelts.util.mts
-function filterLogLevels(parseableString = "") {
-  const sanitizedString = parseableString.replaceAll(" ", "").toLowerCase();
-  if (sanitizedString[0] === ">") {
-    const orEqual = sanitizedString[1] === "=";
-    const logLevelIndex = LOG_LEVELS.indexOf(
-      sanitizedString.substring(orEqual ? 2 : 1)
-    );
-    if (logLevelIndex === -1) {
-      throw new Error(`parse error (unknown log level): ${sanitizedString}`);
-    }
-    return LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1);
-  } else if (sanitizedString.includes(",")) {
-    return sanitizedString.split(",").filter(isLogLevel);
-  }
-  return isLogLevel(sanitizedString) ? [sanitizedString] : LOG_LEVELS;
-}
-
-// packages/core/src/logger/utils/is-log-level-enabled.mts
-var LOG_LEVEL_VALUES = {
-  verbose: 0,
-  debug: 1,
-  log: 2,
-  warn: 3,
-  error: 4,
-  fatal: 5
-};
-function isLogLevelEnabled(targetLevel, logLevels) {
-  var _a;
-  if (!logLevels || Array.isArray(logLevels) && (logLevels == null ? void 0 : logLevels.length) === 0) {
-    return false;
-  }
-  if (logLevels.includes(targetLevel)) {
-    return true;
-  }
-  const highestLogLevelValue = (_a = logLevels.map((level) => LOG_LEVEL_VALUES[level]).sort((a, b) => b - a)) == null ? void 0 : _a[0];
-  const targetLevelValue = LOG_LEVEL_VALUES[targetLevel];
-  return targetLevelValue >= highestLogLevelValue;
-}
-
-// packages/core/src/logger/utils/shared.utils.mts
-var isUndefined = (obj) => typeof obj === "undefined";
-var isObject = (fn) => !isNil(fn) && typeof fn === "object";
-var isPlainObject = (fn) => {
-  if (!isObject(fn)) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(fn);
-  if (proto === null) {
-    return true;
-  }
-  const ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  return typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
-};
-var addLeadingSlash = (path) => path && typeof path === "string" ? path.charAt(0) !== "/" && path.substring(0, 2) !== "{/" ? "/" + path : path : "";
-var normalizePath = (path) => path ? path.startsWith("/") ? ("/" + path.replace(/\/+$/, "")).replace(/\/+/g, "/") : "/" + path.replace(/\/+$/, "") : "/";
-var stripEndSlash = (path) => path[path.length - 1] === "/" ? path.slice(0, path.length - 1) : path;
-var isFunction = (val) => typeof val === "function";
-var isString = (val) => typeof val === "string";
-var isNumber = (val) => typeof val === "number";
-var isConstructor = (val) => val === "constructor";
-var isNil = (val) => isUndefined(val) || val === null;
-var isEmpty = (array) => !(array && array.length > 0);
-var isSymbol = (val) => typeof val === "symbol";
-
-// packages/core/src/logger/console-logger.service.mts
-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, {
-  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;
+// 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) {
@@ -1746,177 +1507,580 @@ var _LoggerInstance = class _LoggerInstance {
         return this.registerLocalInstanceRef();
       }
     }
-    return _LoggerInstance.staticInstanceRef;
+    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;
+    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 = 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);
+  }
+};
+_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) {
-    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);
+    this.logger.error(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);
+    this.logger.warn(message, ...optionalParams);
+  }
+  info() {
   }
   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);
+    (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
   }
-  verbose(message, ...optionalParams) {
+  trace(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);
+    (_b = (_a = this.logger).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);
+  silent() {
   }
-  static error(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.error(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"])
+    );
   }
-  static log(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.log(message, ...optionalParams);
+  get level() {
+    if ("level" in this.logger && this.logger.level) {
+      return this.logger.level;
+    }
+    const levels = LoggerInstance["logLevels"];
+    if (levels) {
+      return levels.find((level) => level !== "verbose");
+    }
+    return "warn";
   }
-  static warn(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.warn(message, ...optionalParams);
+};
+
+// 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;
   }
-  static debug(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  getConfig() {
+    return this.config;
   }
-  static verbose(message, ...optionalParams) {
+  get(key) {
     var _a, _b;
-    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    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;
+    }
   }
-  static fatal(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.fatal) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  getOrDefault(key, defaultValue) {
+    const value = this.get(key);
+    return value !== null ? value : defaultValue;
   }
-  static getTimestamp() {
-    return dateTimeFormatter2.format(Date.now());
+  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;
   }
-  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);
+};
+
+// 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;
+    }
+  }
+};
+_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");
+var EndpointType = /* @__PURE__ */ ((EndpointType2) => {
+  EndpointType2["Unknown"] = "unknown";
+  EndpointType2["Config"] = "config";
+  EndpointType2["Handler"] = "handler";
+  return EndpointType2;
+})(EndpointType || {});
+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: "",
+          successStatusCode: 200,
+          headers: {},
+          type: "unknown" /* Unknown */,
+          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) {
+    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/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.type = "config" /* Config */;
+      endpointMetadata.classMethod = target.name;
+      endpointMetadata.httpMethod = config.method;
+      endpointMetadata.url = config.url;
     }
-    if (isObject(logger)) {
-      this.staticInstanceRef = logger;
-    } else {
-      this.staticInstanceRef = void 0;
+    return target;
+  };
+}
+
+// packages/core/src/decorators/header.decorator.mts
+function Header(name2, value) {
+  return (target, context) => {
+    if (context.kind !== "method") {
+      throw new Error("[Navios] Header decorator can only be used on methods.");
     }
-  }
-  static isLevelEnabled(level) {
-    const logLevels = _LoggerInstance.logLevels;
-    return isLogLevelEnabled(level, logLevels);
-  }
-  registerLocalInstanceRef() {
-    var _a;
-    if (this.localInstanceRef) {
-      return this.localInstanceRef;
+    const metadata = getEndpointMetadata(target, context);
+    metadata.headers[name2] = value;
+    return target;
+  };
+}
+
+// packages/core/src/decorators/http-code.decorator.mts
+function HttpCode(code) {
+  return (target, context) => {
+    if (context.kind !== "method") {
+      throw new Error(
+        "[Navios] HttpCode decorator can only be used on methods."
+      );
     }
-    this.localInstanceRef = new ConsoleLogger(this.context, {
-      timestamp: (_a = this.options) == null ? void 0 : _a.timestamp,
-      logLevels: _LoggerInstance.logLevels
-    });
-    return this.localInstanceRef;
+    const metadata = getEndpointMetadata(target, context);
+    metadata.successStatusCode = code;
+    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);
+      }
+    }
+    if (metadata.imports) {
+      for (const importedModule of metadata.imports) {
+        moduleMetadata.imports.add(importedModule);
+      }
+    }
+    if (metadata.guards) {
+      for (const guard of Array.from(metadata.guards).reverse()) {
+        moduleMetadata.guards.add(guard);
+      }
+    }
+    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."
+      );
+    }
+    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);
   }
 };
 
+// packages/core/src/services/controller-adapter.service.mts
+var import_common2 = require("@navios/common");
+
 // packages/core/src/tokens/application.token.mts
 var ApplicationInjectionToken = "ApplicationInjectionToken";
 var Application = InjectionToken.create(
@@ -1982,7 +2146,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 +2209,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);
@@ -2060,8 +2224,8 @@ var _ControllerAdapterService = class _ControllerAdapterService {
   setupController(controller, instance, moduleMetadata) {
     const controllerMetadata = extractControllerMetadata(controller);
     for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod, config } = endpoint;
-      if (!url || !config) {
+      const { classMethod, url, httpMethod } = endpoint;
+      if (!url) {
         throw new Error(
           `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`
         );
@@ -2071,99 +2235,123 @@ var _ControllerAdapterService = class _ControllerAdapterService {
         controllerMetadata,
         endpoint
       );
-      const guards = this.guardRunner.makeContext(executionContext);
-      const { querySchema, requestSchema, responseSchema } = config;
-      const schema = {};
-      if (querySchema) {
-        schema.querystring = querySchema;
-      }
-      if (requestSchema) {
-        schema.body = requestSchema;
-      }
-      if (responseSchema) {
-        schema.response = {
-          200: responseSchema
-        };
-      }
       instance.withTypeProvider().route({
         method: httpMethod,
         url: url.replaceAll("$", ":"),
-        schema,
-        preHandler: async (request, reply) => {
-          if (guards.size > 0) {
-            getServiceLocator().registerInstance(Request, request);
-            getServiceLocator().registerInstance(Reply, reply);
-            getServiceLocator().registerInstance(
-              ExecutionContextToken,
-              executionContext
-            );
-            executionContext.provideRequest(request);
-            executionContext.provideReply(reply);
-            const canActivate = await this.guardRunner.runGuards(
-              guards,
-              executionContext
-            );
-            getServiceLocator().removeInstance(Request);
-            getServiceLocator().removeInstance(Reply);
-            getServiceLocator().removeInstance(ExecutionContextToken);
-            if (!canActivate) {
-              return reply;
-            }
-          }
-        },
-        handler: async (request, reply) => {
-          getServiceLocator().registerInstance(Request, request);
-          getServiceLocator().registerInstance(Reply, reply);
-          getServiceLocator().registerInstance(
-            ExecutionContextToken,
-            executionContext
-          );
-          executionContext.provideRequest(request);
-          executionContext.provideReply(reply);
-          const controllerInstance = await inject(controller);
-          try {
-            const { query, params, body } = request;
-            const argument = {};
-            if (query && Object.keys(query).length > 0) {
-              argument.params = query;
-            }
-            if (params && Object.keys(params).length > 0) {
-              argument.urlParams = params;
-            }
-            if (body) {
-              argument.data = body;
-            }
-            const result = await controllerInstance[classMethod](argument);
-            reply.status(200).send(result);
-          } catch (error) {
-            if (error instanceof HttpException) {
-              reply.status(error.statusCode).send(error.response);
-            } else {
-              reply.status(500).send({
-                message: "Internal server error",
-                error: error.message
-              });
-            }
-          } finally {
-            getServiceLocator().removeInstance(Request);
-            getServiceLocator().removeInstance(Reply);
-            getServiceLocator().removeInstance(ExecutionContextToken);
-          }
-        }
+        schema: this.provideSchemaForConfig(endpoint),
+        preHandler: this.providePreHandler(executionContext),
+        handler: this.provideHandler(controller, executionContext, endpoint)
       });
       this.logger.debug(
         `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`
       );
     }
   }
+  providePreHandler(executionContext) {
+    const guards = this.guardRunner.makeContext(executionContext);
+    return guards.size > 0 ? async (request, reply) => {
+      getServiceLocator().registerInstance(Request, request);
+      getServiceLocator().registerInstance(Reply, reply);
+      getServiceLocator().registerInstance(
+        ExecutionContextToken,
+        executionContext
+      );
+      executionContext.provideRequest(request);
+      executionContext.provideReply(reply);
+      let canActivate = true;
+      try {
+        canActivate = await this.guardRunner.runGuards(
+          guards,
+          executionContext
+        );
+      } finally {
+        getServiceLocator().removeInstance(Request);
+        getServiceLocator().removeInstance(Reply);
+        getServiceLocator().removeInstance(ExecutionContextToken);
+      }
+      if (!canActivate) {
+        return reply;
+      }
+    } : void 0;
+  }
+  provideSchemaForConfig(endpointMetadata) {
+    if (!endpointMetadata.config) {
+      this.logger.warn(`No config found for endpoint ${endpointMetadata.url}`);
+      return {};
+    }
+    const { querySchema, requestSchema, responseSchema } = endpointMetadata.config;
+    const schema = {};
+    if (querySchema) {
+      schema.querystring = querySchema;
+    }
+    if (requestSchema) {
+      schema.body = requestSchema;
+    }
+    if (responseSchema) {
+      schema.response = {
+        200: responseSchema
+      };
+    }
+    return schema;
+  }
+  provideHandler(controller, executionContext, endpointMetadata) {
+    switch (endpointMetadata.type) {
+      case "unknown" /* Unknown */:
+        this.logger.error(
+          `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`
+        );
+        throw new import_common2.NaviosException("Unknown endpoint type");
+      case "config" /* Config */:
+        return this.provideHandlerForConfig(
+          controller,
+          executionContext,
+          endpointMetadata
+        );
+      case "handler" /* Handler */:
+        this.logger.error("Not implemented yet");
+        throw new import_common2.NaviosException("Not implemented yet");
+    }
+  }
+  provideHandlerForConfig(controller, executionContext, endpointMetadata) {
+    return async (request, reply) => {
+      getServiceLocator().registerInstance(Request, request);
+      getServiceLocator().registerInstance(Reply, reply);
+      getServiceLocator().registerInstance(
+        ExecutionContextToken,
+        executionContext
+      );
+      executionContext.provideRequest(request);
+      executionContext.provideReply(reply);
+      const controllerInstance = await inject(controller);
+      try {
+        const { query, params, body } = request;
+        const argument = {};
+        if (query && Object.keys(query).length > 0) {
+          argument.params = query;
+        }
+        if (params && Object.keys(params).length > 0) {
+          argument.urlParams = params;
+        }
+        if (body) {
+          argument.data = body;
+        }
+        const result = await controllerInstance[endpointMetadata.classMethod](argument);
+        reply.status(endpointMetadata.successStatusCode).headers(endpointMetadata.headers).send(result);
+      } finally {
+        getServiceLocator().removeInstance(Request);
+        getServiceLocator().removeInstance(Reply);
+        getServiceLocator().removeInstance(ExecutionContextToken);
+      }
+    };
+  }
 };
-_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 +2408,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 +2474,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);
@@ -2309,6 +2497,7 @@ var _NaviosApplication = class _NaviosApplication {
     }
     await this.moduleLoader.loadModules(this.appModule);
     this.server = await this.getFastifyInstance(this.options);
+    this.configureFastifyInstance(this.server);
     getServiceLocator().registerInstance(Application, this.server);
     this.server.setValidatorCompiler(import_fastify_type_provider_zod.validatorCompiler);
     this.server.setSerializerCompiler(import_fastify_type_provider_zod.serializerCompiler);
@@ -2316,6 +2505,7 @@ var _NaviosApplication = class _NaviosApplication {
       await this.server.register(import_cors.default, this.corsOptions);
     }
     await this.initModules();
+    await this.server.ready();
     this.logger.debug("Navios application initialized");
   }
   async getFastifyInstance(rawOptions) {
@@ -2345,6 +2535,35 @@ var _NaviosApplication = class _NaviosApplication {
       });
     }
   }
+  configureFastifyInstance(fastifyInstance) {
+    fastifyInstance.setErrorHandler((error, request, reply) => {
+      if (error instanceof HttpException) {
+        return reply.status(error.statusCode).send(error.response);
+      } else {
+        const statusCode = error.statusCode || 500;
+        const message = error.message || "Internal Server Error";
+        const response = {
+          statusCode,
+          message,
+          error: error.name || "InternalServerError"
+        };
+        this.logger.error(
+          `Error occurred: ${error.message} on ${request.url}`,
+          error
+        );
+        return reply.status(statusCode).send(response);
+      }
+    });
+    fastifyInstance.setNotFoundHandler((req, reply) => {
+      const response = {
+        statusCode: 404,
+        message: "Not Found",
+        error: "NotFound"
+      };
+      this.logger.error(`Route not found: ${req.url}`);
+      return reply.status(404).send(response);
+    });
+  }
   async initModules() {
     const modules = this.moduleLoader.getAllModules();
     const promises = [];
@@ -2388,12 +2607,13 @@ var _NaviosApplication = class _NaviosApplication {
     if (!this.server) {
       throw new Error("Server is not initialized. Call init() first.");
     }
-    await this.server.listen(options);
+    const res = await this.server.listen(options);
+    this.logger.debug(`Navios is listening on ${res}`);
   }
 };
-_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 +2639,11 @@ var NaviosFactory = class {
   Application,
   AttributeFactory,
   BadRequestException,
+  ConfigProvider,
+  ConfigProviderFactory,
+  ConfigProviderInjectionToken,
+  ConfigProviderOptions,
+  ConfigServiceInstance,
   ConflictException,
   ConsoleLogger,
   Controller,
@@ -2426,6 +2651,7 @@ var NaviosFactory = class {
   ControllerMetadataKey,
   Endpoint,
   EndpointMetadataKey,
+  EndpointType,
   ErrorsEnum,
   EventEmitter,
   ExecutionContext,
@@ -2434,6 +2660,8 @@ var NaviosFactory = class {
   FactoryNotFound,
   ForbiddenException,
   GuardRunnerService,
+  Header,
+  HttpCode,
   HttpException,
   Injectable,
   InjectableScope,
@@ -2469,6 +2697,8 @@ var NaviosFactory = class {
   UseGuards,
   addLeadingSlash,
   clc,
+  envInt,
+  envString,
   extractControllerMetadata,
   extractModuleMetadata,
   filterLogLevels,
@@ -2493,6 +2723,7 @@ var NaviosFactory = class {
   isString,
   isSymbol,
   isUndefined,
+  makeConfigToken,
   normalizePath,
   override,
   provideServiceLocator,