@navios/core 0.3.0 → 0.5.0

package/lib/index.js

@@ -1,19 +1,14 @@
 'use strict';
 
 var di = require('@navios/di');
-var zod = require('zod');
 var process$1 = require('process');
+var z = require('zod/v4');
 var builder = require('@navios/builder');
 var util = require('util');
-var cors = require('@fastify/cors');
-var multipart = require('@fastify/multipart');
-var fastify = require('fastify');
-var fastifyTypeProviderZod = require('fastify-type-provider-zod');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var cors__default = /*#__PURE__*/_interopDefault(cors);
-var multipart__default = /*#__PURE__*/_interopDefault(multipart);
+var z__default = /*#__PURE__*/_interopDefault(z);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -24,7 +19,7 @@ var __typeError = (msg) => {
 };
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStart = (base) => [, , , __create(null)];
 var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
 var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
 var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
@@ -46,219 +41,6 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
   }
   return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
-var StreamAdapterToken = di.InjectionToken.create(
-  Symbol.for("StreamAdapterService")
-);
-var _StreamAdapterService_decorators, _init;
-_StreamAdapterService_decorators = [di.Injectable({
-  token: StreamAdapterToken
-})];
-exports.StreamAdapterService = class StreamAdapterService {
-  hasSchema(handlerMetadata) {
-    const config = handlerMetadata.config;
-    return !!config.requestSchema || !!config.querySchema;
-  }
-  prepareArguments(handlerMetadata) {
-    const config = handlerMetadata.config;
-    const getters = [];
-    if (config.querySchema) {
-      getters.push((target, request) => {
-        target.params = request.query;
-      });
-    }
-    if (config.requestSchema) {
-      getters.push((target, request) => {
-        target.data = request.body;
-      });
-    }
-    if (config.url.includes("$")) {
-      getters.push((target, request) => {
-        target.urlParams = request.params;
-      });
-    }
-    return getters;
-  }
-  provideHandler(controller, executionContext, handlerMetadata) {
-    const getters = this.prepareArguments(handlerMetadata);
-    const formatArguments = async (request) => {
-      const argument = {};
-      const promises = [];
-      for (const getter of getters) {
-        const res = getter(argument, request);
-        if (res instanceof Promise) {
-          promises.push(res);
-        }
-      }
-      await Promise.all(promises);
-      return argument;
-    };
-    return async function(request, reply) {
-      const controllerInstance = await di.inject(controller);
-      const argument = await formatArguments(request);
-      await controllerInstance[handlerMetadata.classMethod](argument, reply);
-    };
-  }
-  provideSchema(handlerMetadata) {
-    const schema = {};
-    const { querySchema, requestSchema } = handlerMetadata.config;
-    if (querySchema) {
-      schema.querystring = querySchema;
-    }
-    if (requestSchema) {
-      schema.body = requestSchema;
-    }
-    return schema;
-  }
-};
-_init = __decoratorStart(null);
-exports.StreamAdapterService = __decorateElement(_init, 0, "StreamAdapterService", _StreamAdapterService_decorators, exports.StreamAdapterService);
-__runInitializers(_init, 1, exports.StreamAdapterService);
-
-// src/adapters/endpoint-adapter.service.mts
-var EndpointAdapterToken = di.InjectionToken.create(
-  Symbol.for("EndpointAdapterService")
-);
-var _EndpointAdapterService_decorators, _init2, _a;
-_EndpointAdapterService_decorators = [di.Injectable({
-  token: EndpointAdapterToken
-})];
-exports.EndpointAdapterService = class EndpointAdapterService extends (_a = exports.StreamAdapterService) {
-  hasSchema(handlerMetadata) {
-    const config = handlerMetadata.config;
-    return super.hasSchema(handlerMetadata) || !!config.responseSchema;
-  }
-  provideSchema(handlerMetadata) {
-    const config = handlerMetadata.config;
-    const schema = super.provideSchema(handlerMetadata);
-    if (config.responseSchema) {
-      schema.response = {
-        200: config.responseSchema
-      };
-    }
-    return schema;
-  }
-  provideHandler(controller, executionContext, handlerMetadata) {
-    const getters = this.prepareArguments(handlerMetadata);
-    const formatArguments = async (request) => {
-      const argument = {};
-      const promises = [];
-      for (const getter of getters) {
-        const res = getter(argument, request);
-        if (res instanceof Promise) {
-          promises.push(res);
-        }
-      }
-      await Promise.all(promises);
-      return argument;
-    };
-    return async function(request, reply) {
-      const controllerInstance = await di.inject(controller);
-      const argument = await formatArguments(request);
-      const result = await controllerInstance[handlerMetadata.classMethod](argument);
-      reply.status(handlerMetadata.successStatusCode).headers(handlerMetadata.headers).send(result);
-    };
-  }
-};
-_init2 = __decoratorStart(_a);
-exports.EndpointAdapterService = __decorateElement(_init2, 0, "EndpointAdapterService", _EndpointAdapterService_decorators, exports.EndpointAdapterService);
-__runInitializers(_init2, 1, exports.EndpointAdapterService);
-var MultipartAdapterToken = di.InjectionToken.create(
-  Symbol.for("MultipartAdapterService")
-);
-var _MultipartAdapterService_decorators, _init3, _a2;
-_MultipartAdapterService_decorators = [di.Injectable({
-  token: MultipartAdapterToken
-})];
-exports.MultipartAdapterService = class MultipartAdapterService extends (_a2 = exports.EndpointAdapterService) {
-  prepareArguments(handlerMetadata) {
-    const config = handlerMetadata.config;
-    const getters = [];
-    if (config.querySchema) {
-      getters.push((target, request) => {
-        target.params = request.query;
-      });
-    }
-    if (config.url.includes("$")) {
-      getters.push((target, request) => {
-        target.urlParams = request.params;
-      });
-    }
-    const requestSchema = config.requestSchema;
-    const shape = requestSchema._def.shape();
-    const structure = this.analyzeSchema(shape);
-    getters.push(async (target, request) => {
-      const req = {};
-      for await (const part of request.parts()) {
-        await this.populateRequest(structure, part, req);
-      }
-      target.data = requestSchema.parse(req);
-    });
-    return getters;
-  }
-  async populateRequest(structure, part, req) {
-    const { isArray, isObject: isObject2 } = structure[part.fieldname] ?? {};
-    if (isArray && !req[part.fieldname]) {
-      req[part.fieldname] = [];
-    }
-    let value;
-    if (part.type === "file") {
-      value = new File([await part.toBuffer()], part.filename, {
-        type: part.mimetype
-      });
-    } else {
-      value = part.value;
-      if (isObject2 && typeof value === "string") {
-        value = JSON.parse(value);
-      }
-    }
-    if (isArray) {
-      req[part.fieldname].push(value);
-    } else {
-      req[part.fieldname] = value;
-    }
-  }
-  analyzeSchema(shape) {
-    return Object.keys(shape).reduce(
-      (target, key) => {
-        let schema = shape[key];
-        const isOptional = schema instanceof zod.ZodOptional;
-        if (isOptional) {
-          schema = schema.unwrap();
-        }
-        const isArray = schema instanceof zod.ZodArray;
-        if (isArray) {
-          schema = schema.element;
-        }
-        const isObject2 = schema instanceof zod.ZodObject;
-        return {
-          ...target,
-          [key]: {
-            isArray,
-            isOptional,
-            isObject: isObject2
-          }
-        };
-      },
-      {}
-    );
-  }
-  provideSchema(handlerMetadata) {
-    const schema = {};
-    const { querySchema, responseSchema } = handlerMetadata.config;
-    if (querySchema) {
-      schema.querystring = querySchema;
-    }
-    if (responseSchema) {
-      schema.response = {
-        200: responseSchema
-      };
-    }
-    return schema;
-  }
-};
-_init3 = __decoratorStart(_a2);
-exports.MultipartAdapterService = __decorateElement(_init3, 0, "MultipartAdapterService", _MultipartAdapterService_decorators, exports.MultipartAdapterService);
-__runInitializers(_init3, 1, exports.MultipartAdapterService);
 function envInt(key, defaultValue) {
   const envKey = process$1.env[key] || process.env[key];
   return envKey ? parseInt(envKey, 10) : defaultValue;
@@ -305,515 +87,66 @@ function filterLogLevels(parseableString = "") {
     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;
-}
-
-// 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) {
-  if (!logLevels || Array.isArray(logLevels) && logLevels?.length === 0) {
-    return false;
-  }
-  if (logLevels.includes(targetLevel)) {
-    return true;
-  }
-  const highestLogLevelValue = logLevels.map((level) => LOG_LEVEL_VALUES[level]).sort((a, b) => b - a)?.[0];
-  const targetLevelValue = LOG_LEVEL_VALUES[targetLevel];
-  return targetLevelValue >= highestLogLevelValue;
-}
-
-// 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";
-var ApplicationInjectionToken = "ApplicationInjectionToken";
-var Application = di.InjectionToken.create(
-  ApplicationInjectionToken
-);
-
-// src/metadata/handler.metadata.mts
-var EndpointMetadataKey = Symbol("EndpointMetadataKey");
-function getAllEndpointMetadata(context) {
-  if (context.metadata) {
-    const metadata = context.metadata[EndpointMetadataKey];
-    if (metadata) {
-      return metadata;
-    } else {
-      context.metadata[EndpointMetadataKey] = /* @__PURE__ */ new Set();
-      return context.metadata[EndpointMetadataKey];
-    }
-  }
-  throw new Error("[Navios] Wrong environment.");
-}
-function getEndpointMetadata(target, context) {
-  if (context.metadata) {
-    const metadata = getAllEndpointMetadata(context);
-    if (metadata) {
-      const endpointMetadata = Array.from(metadata).find(
-        (item) => item.classMethod === target.name
-      );
-      if (endpointMetadata) {
-        return endpointMetadata;
-      } else {
-        const newMetadata = {
-          classMethod: target.name,
-          url: "",
-          successStatusCode: 200,
-          adapterToken: null,
-          headers: {},
-          httpMethod: "GET",
-          // @ts-expect-error We are using a generic type here
-          config: null,
-          guards: /* @__PURE__ */ new Set(),
-          customAttributes: /* @__PURE__ */ new Map()
-        };
-        metadata.add(newMetadata);
-        return newMetadata;
-      }
-    }
-  }
-  throw new Error("[Navios] Wrong environment.");
-}
-
-// 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;
-}
-
-// 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 for ${target.name}. Make sure to use @Module decorator.`
-    );
-  }
-  return metadata;
-}
-function hasModuleMetadata(target) {
-  return !!target[ModuleMetadataKey];
-}
-
-// src/services/execution-context.mts
-var ExecutionContext = class {
-  constructor(module, controller, handler) {
-    this.module = module;
-    this.controller = controller;
-    this.handler = handler;
-  }
-  request;
-  reply;
-  getModule() {
-    return this.module;
-  }
-  getController() {
-    return this.controller;
-  }
-  getHandler() {
-    return this.handler;
-  }
-  getRequest() {
-    if (!this.request) {
-      throw new Error(
-        "[Navios] Request is not set. Make sure to set it before using it."
-      );
-    }
-    return this.request;
-  }
-  getReply() {
-    if (!this.reply) {
-      throw new Error(
-        "[Navios] Reply is not set. Make sure to set it before using it."
-      );
-    }
-    return this.reply;
-  }
-  provideRequest(request) {
-    this.request = request;
-  }
-  provideReply(reply) {
-    this.reply = reply;
-  }
-};
-
-// src/exceptions/http.exception.mts
-var HttpException = class {
-  constructor(statusCode, response, error) {
-    this.statusCode = statusCode;
-    this.response = response;
-    this.error = error;
-  }
-};
-
-// src/exceptions/bad-request.exception.mts
-var BadRequestException = class extends HttpException {
-  constructor(message) {
-    super(400, message);
-  }
-};
-
-// src/exceptions/forbidden.exception.mts
-var ForbiddenException = class extends HttpException {
-  constructor(message) {
-    super(403, message);
-  }
-};
-
-// src/exceptions/internal-server-error.exception.mts
-var InternalServerErrorException = class extends HttpException {
-  constructor(message, error) {
-    super(500, message, error);
-  }
-};
-
-// src/exceptions/not-found.exception.mts
-var NotFoundException = class extends HttpException {
-  constructor(response, error) {
-    super(404, response, error);
-    this.response = response;
-    this.error = error;
-  }
-};
-
-// src/exceptions/unauthorized.exception.mts
-var UnauthorizedException = class extends HttpException {
-  constructor(message, error) {
-    super(401, message, error);
-  }
-};
-
-// src/exceptions/conflict.exception.mts
-var ConflictException = class extends HttpException {
-  constructor(message, error) {
-    super(409, message, error);
-  }
-};
-
-// src/services/guard-runner.service.mts
-var _GuardRunnerService_decorators, _init4;
-_GuardRunnerService_decorators = [di.Injectable()];
-exports.GuardRunnerService = class GuardRunnerService {
-  async runGuards(allGuards, executionContext) {
-    let canActivate = true;
-    for (const guard of Array.from(allGuards).reverse()) {
-      const guardInstance = await di.inject(
-        guard
-      );
-      if (!guardInstance.canActivate) {
-        throw new Error(
-          `[Navios] Guard ${guard.name} does not implement canActivate()`
-        );
-      }
-      try {
-        canActivate = await guardInstance.canActivate(executionContext);
-        if (!canActivate) {
-          break;
-        }
-      } catch (error) {
-        if (error instanceof HttpException) {
-          executionContext.getReply().status(error.statusCode).send(error.response);
-          return false;
-        } else {
-          executionContext.getReply().status(500).send({
-            message: "Internal server error",
-            error: error.message
-          });
-          return false;
-        }
-      }
-    }
-    if (!canActivate) {
-      executionContext.getReply().status(403).send({
-        message: "Forbidden"
-      });
-      return false;
-    }
-    return canActivate;
-  }
-  makeContext(executionContext) {
-    const guards = /* @__PURE__ */ new Set();
-    const endpointGuards = executionContext.getHandler().guards;
-    const controllerGuards = executionContext.getController().guards;
-    const moduleGuards = executionContext.getModule().guards;
-    if (endpointGuards.size > 0) {
-      for (const guard of endpointGuards) {
-        guards.add(guard);
-      }
-    }
-    if (controllerGuards.size > 0) {
-      for (const guard of controllerGuards) {
-        guards.add(guard);
-      }
-    }
-    if (moduleGuards.size > 0) {
-      for (const guard of moduleGuards) {
-        guards.add(guard);
-      }
-    }
-    return guards;
-  }
-};
-_init4 = __decoratorStart(null);
-exports.GuardRunnerService = __decorateElement(_init4, 0, "GuardRunnerService", _GuardRunnerService_decorators, exports.GuardRunnerService);
-__runInitializers(_init4, 1, exports.GuardRunnerService);
-
-// src/services/controller-adapter.service.mts
-var _ControllerAdapterService_decorators, _init5;
-_ControllerAdapterService_decorators = [di.Injectable()];
-var _ControllerAdapterService = class _ControllerAdapterService {
-  guardRunner = di.syncInject(exports.GuardRunnerService);
-  logger = di.syncInject(Logger, {
-    context: _ControllerAdapterService.name
-  });
-  async setupController(controller, instance, moduleMetadata) {
-    const controllerMetadata = extractControllerMetadata(controller);
-    for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod, adapterToken } = endpoint;
-      if (!url || !adapterToken) {
-        throw new Error(
-          `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`
-        );
-      }
-      const adapter = await di.inject(
-        adapterToken
-      );
-      const executionContext = new ExecutionContext(
-        moduleMetadata,
-        controllerMetadata,
-        endpoint
-      );
-      const hasSchema = adapter.hasSchema?.(endpoint) ?? false;
-      if (hasSchema) {
-        instance.withTypeProvider().route({
-          method: httpMethod,
-          url: url.replaceAll("$", ":"),
-          schema: adapter.provideSchema?.(endpoint) ?? {},
-          preHandler: this.providePreHandler(executionContext),
-          handler: this.wrapHandler(
-            executionContext,
-            adapter.provideHandler(controller, executionContext, endpoint)
-          )
-        });
-      } else {
-        instance.route({
-          method: httpMethod,
-          url: url.replaceAll("$", ":"),
-          preHandler: this.providePreHandler(executionContext),
-          handler: this.wrapHandler(
-            executionContext,
-            adapter.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 ? this.wrapHandler(
-      executionContext,
-      async (request, reply) => {
-        let canActivate = true;
-        canActivate = await this.guardRunner.runGuards(
-          guards,
-          executionContext
-        );
-        if (!canActivate) {
-          return reply;
-        }
-      }
-    ) : void 0;
-  }
-  wrapHandler(executionContext, handler) {
-    const locator = di.getGlobalServiceLocator();
-    return async (request, reply) => {
-      locator.storeInstance(request, Request);
-      locator.storeInstance(reply, Reply);
-      locator.storeInstance(executionContext, ExecutionContextToken);
-      executionContext.provideRequest(request);
-      executionContext.provideReply(reply);
-      try {
-        return await handler(request, reply);
-      } finally {
-        Promise.all([
-          locator.removeInstance(Request),
-          locator.removeInstance(Reply),
-          locator.removeInstance(ExecutionContextToken)
-        ]).catch((err) => {
-          this.logger.warn(`Error removing instances: ${err}`);
-        });
-      }
-    };
-  }
-};
-_init5 = __decoratorStart(null);
-_ControllerAdapterService = __decorateElement(_init5, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
-__runInitializers(_init5, 1, _ControllerAdapterService);
-var ControllerAdapterService = _ControllerAdapterService;
-var _ModuleLoaderService_decorators, _init6;
-_ModuleLoaderService_decorators = [di.Injectable()];
-var _ModuleLoaderService = class _ModuleLoaderService {
-  logger = di.syncInject(Logger, {
-    context: _ModuleLoaderService.name
-  });
-  modulesMetadata = /* @__PURE__ */ new Map();
-  loadedModules = /* @__PURE__ */ new Map();
-  initialized = false;
-  async loadModules(appModule) {
-    if (this.initialized) {
-      return;
-    }
-    await this.traverseModules(appModule);
-    this.initialized = true;
-  }
-  async traverseModules(module, parentMetadata) {
-    const metadata = extractModuleMetadata(module);
-    if (parentMetadata) {
-      this.mergeMetadata(metadata, parentMetadata);
-    }
-    const moduleName = module.name;
-    if (this.modulesMetadata.has(moduleName)) {
-      return;
-    }
-    this.modulesMetadata.set(moduleName, metadata);
-    const imports = metadata.imports ?? /* @__PURE__ */ new Set();
-    const loadingPromises = Array.from(imports).map(
-      async (importedModule) => this.traverseModules(importedModule, metadata)
-    );
-    await Promise.all(loadingPromises);
-    const instance = await di.inject(module);
-    if (instance.onModuleInit) {
-      await instance.onModuleInit();
+    if (logLevelIndex === -1) {
+      throw new Error(`parse error (unknown log level): ${sanitizedString}`);
     }
-    this.logger.debug(`Module ${moduleName} loaded`);
-    this.loadedModules.set(moduleName, instance);
+    return LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1);
+  } else if (sanitizedString.includes(",")) {
+    return sanitizedString.split(",").filter(isLogLevel);
   }
-  mergeMetadata(metadata, parentMetadata) {
-    if (parentMetadata.guards) {
-      for (const guard of parentMetadata.guards) {
-        metadata.guards.add(guard);
-      }
-    }
-    if (parentMetadata.customAttributes) {
-      for (const [key, value] of parentMetadata.customAttributes) {
-        if (metadata.customAttributes.has(key)) {
-          continue;
-        }
-        metadata.customAttributes.set(key, value);
-      }
-    }
+  return isLogLevel(sanitizedString) ? [sanitizedString] : LOG_LEVELS;
+}
+
+// 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) {
+  if (!logLevels || Array.isArray(logLevels) && logLevels?.length === 0) {
+    return false;
   }
-  getAllModules() {
-    return this.modulesMetadata;
+  if (logLevels.includes(targetLevel)) {
+    return true;
   }
-  dispose() {
-    this.modulesMetadata.clear();
-    this.loadedModules.clear();
-    this.initialized = false;
+  const highestLogLevelValue = logLevels.map((level) => LOG_LEVEL_VALUES[level]).sort((a, b) => b - a)?.[0];
+  const targetLevelValue = LOG_LEVEL_VALUES[targetLevel];
+  return targetLevelValue >= highestLogLevelValue;
+}
+
+// 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);
 };
-_init6 = __decoratorStart(null);
-_ModuleLoaderService = __decorateElement(_init6, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
-__runInitializers(_init6, 1, _ModuleLoaderService);
-var ModuleLoaderService = _ModuleLoaderService;
-
-// src/tokens/execution-context.token.mts
-var ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
-var ExecutionContextToken = di.InjectionToken.create(
-  ExecutionContextInjectionToken
-);
-var ReplyInjectionToken = "ReplyInjectionToken";
-var Reply = di.InjectionToken.create(ReplyInjectionToken);
-var RequestInjectionToken = "RequestInjectionToken";
-var Request = di.InjectionToken.create(
-  RequestInjectionToken
-);
+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";
+var LoggerOutput = di.InjectionToken.create("LoggerOutput");
+var loggerOptionsSchema = z__default.default.object({
+  context: z__default.default.string().optional()
+}).optional();
+var Logger = di.InjectionToken.create("Logger", loggerOptionsSchema);
 
 // src/logger/console-logger.service.mts
 var DEFAULT_DEPTH = 5;
@@ -833,21 +166,19 @@ var dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
   day: "2-digit",
   month: "2-digit"
 });
-var _ConsoleLogger_decorators, _init7;
-_ConsoleLogger_decorators = [di.Injectable()];
-var _ConsoleLogger = class _ConsoleLogger {
+var _ConsoleLogger_decorators, _init;
+_ConsoleLogger_decorators = [di.Injectable({
+  token: LoggerOutput
+})];
+exports.ConsoleLogger = class ConsoleLogger {
   /**
    * The options of the logger.
    */
-  options;
+  options = {};
   /**
    * The context of the logger (can be set manually or automatically inferred).
    */
   context;
-  /**
-   * Request ID (if enabled).
-   */
-  requestId = null;
   /**
    * The original context of the logger (set in the constructor).
    */
@@ -855,12 +186,12 @@ var _ConsoleLogger = class _ConsoleLogger {
   /**
    * The options used for the "inspect" method.
    */
-  inspectOptions;
+  inspectOptions = this.getInspectOptions();
   /**
    * The last timestamp at which the log message was printed.
    */
-  static lastTimestampAt;
-  constructor(contextOrOptions, options) {
+  lastTimestampAt;
+  setup(contextOrOptions, options) {
     let [context, opts] = isString(contextOrOptions) ? [contextOrOptions, options] : options ? [void 0, options] : [contextOrOptions?.context, contextOrOptions];
     opts = opts ?? {};
     opts.logLevels ??= DEFAULT_LOG_LEVELS;
@@ -872,20 +203,6 @@ var _ConsoleLogger = class _ConsoleLogger {
       this.context = context;
       this.originalContext = context;
     }
-    if (opts?.requestId) {
-      const locator = di.getGlobalServiceLocator();
-      locator.getEventBus().on(locator.getInstanceIdentifier(Request, void 0), "create", () => {
-        const request = locator.getSyncInstance(Request, void 0);
-        this.requestId = request?.id ?? null;
-      });
-      locator.getEventBus().on(
-        locator.getInstanceIdentifier(Request, void 0),
-        "destroy",
-        () => {
-          this.requestId = null;
-        }
-      );
-    }
   }
   log(message, ...optionalParams) {
     if (!this.isLevelEnabled("log")) {
@@ -902,7 +219,7 @@ var _ConsoleLogger = class _ConsoleLogger {
       return;
     }
     const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
-    this.printMessages(messages, context, "error", "stderr", stack);
+    this.printMessages(messages, context, "error", void 0, "stderr", stack);
     this.printStackTrace(stack);
   }
   warn(message, ...optionalParams) {
@@ -975,14 +292,15 @@ var _ConsoleLogger = class _ConsoleLogger {
   getTimestamp() {
     return dateTimeFormatter.format(Date.now());
   }
-  printMessages(messages, context = "", logLevel = "log", writeStreamType, errorStack) {
+  printMessages(messages, context = "", logLevel = "log", requestId, writeStreamType, errorStack) {
     messages.forEach((message) => {
       if (this.options.json) {
         this.printAsJson(message, {
           context,
           logLevel,
           writeStreamType,
-          errorStack
+          errorStack,
+          requestId
         });
         return;
       }
@@ -996,7 +314,8 @@ var _ConsoleLogger = class _ConsoleLogger {
         pidMessage,
         formattedLogLevel,
         contextMessage,
-        timestampDiff
+        timestampDiff,
+        requestId
       );
       process[writeStreamType ?? "stdout"].write(formattedMessage);
     });
@@ -1014,8 +333,8 @@ var _ConsoleLogger = class _ConsoleLogger {
     if (options.errorStack) {
       logObject.stack = options.errorStack;
     }
-    if (this.options.requestId && this.requestId) {
-      logObject.requestId = this.requestId;
+    if (this.options.requestId && options.requestId) {
+      logObject.requestId = options.requestId;
     }
     const formattedMessage = !this.options.colors && this.inspectOptions.compact === true ? JSON.stringify(logObject, this.stringifyReplacer) : util.inspect(logObject, this.inspectOptions);
     process[options.writeStreamType ?? "stdout"].write(`${formattedMessage}
@@ -1031,16 +350,16 @@ var _ConsoleLogger = class _ConsoleLogger {
     context = `[${context}] `;
     return this.options.colors ? yellow(context) : context;
   }
-  formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
+  formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff, requestId) {
     const output = this.stringifyMessage(message, logLevel);
     pidMessage = this.colorize(pidMessage, logLevel);
     formattedLogLevel = this.colorize(formattedLogLevel, logLevel);
-    return `${pidMessage}${this.getRequestId()}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}
+    return `${pidMessage}${this.getRequestId(requestId)}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}
 `;
   }
-  getRequestId() {
-    if (this.options.requestId && this.requestId) {
-      return `(${this.colorize(this.requestId, "log")}) `;
+  getRequestId(requestId) {
+    if (this.options.requestId && requestId) {
+      return `(${this.colorize(requestId, "log")}) `;
     }
     return "";
   }
@@ -1080,9 +399,9 @@ var _ConsoleLogger = class _ConsoleLogger {
 `);
   }
   updateAndGetTimestampDiff() {
-    const includeTimestamp = _ConsoleLogger.lastTimestampAt && this.options?.timestamp;
-    const result = includeTimestamp ? this.formatTimestampDiff(Date.now() - _ConsoleLogger.lastTimestampAt) : "";
-    _ConsoleLogger.lastTimestampAt = Date.now();
+    const includeTimestamp = this.lastTimestampAt && this.options?.timestamp;
+    const result = includeTimestamp ? this.formatTimestampDiff(Date.now() - this.lastTimestampAt) : "";
+    this.lastTimestampAt = Date.now();
     return result;
   }
   formatTimestampDiff(timestampDiff) {
@@ -1185,39 +504,18 @@ var _ConsoleLogger = class _ConsoleLogger {
     }
   }
 };
-_init7 = __decoratorStart(null);
-_ConsoleLogger = __decorateElement(_init7, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
-__runInitializers(_init7, 1, _ConsoleLogger);
-var ConsoleLogger = _ConsoleLogger;
-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, _init8;
-_LoggerInstance_decorators = [di.Injectable()];
-var _LoggerInstance = class _LoggerInstance {
-  constructor(context, options = {}) {
-    this.context = context;
-    this.options = options;
-  }
-  static staticInstanceRef = DEFAULT_LOGGER;
-  static logLevels;
-  localInstanceRef;
-  get localInstance() {
-    if (_LoggerInstance.staticInstanceRef === DEFAULT_LOGGER) {
-      return this.registerLocalInstanceRef();
-    } else if (_LoggerInstance.staticInstanceRef instanceof _LoggerInstance) {
-      const prototype = Object.getPrototypeOf(_LoggerInstance.staticInstanceRef);
-      if (prototype.constructor === _LoggerInstance) {
-        return this.registerLocalInstanceRef();
-      }
-    }
-    return _LoggerInstance.staticInstanceRef;
+_init = __decoratorStart();
+exports.ConsoleLogger = __decorateElement(_init, 0, "ConsoleLogger", _ConsoleLogger_decorators, exports.ConsoleLogger);
+__runInitializers(_init, 1, exports.ConsoleLogger);
+var _LoggerInstance_decorators, _init2;
+_LoggerInstance_decorators = [di.Injectable({
+  token: Logger
+})];
+exports.LoggerInstance = class LoggerInstance {
+  localInstance = di.inject(LoggerOutput);
+  context;
+  constructor(config = {}) {
+    this.context = config.context;
   }
   error(message, ...optionalParams) {
     optionalParams = this.context ? (optionalParams.length ? optionalParams : [void 0]).concat(
@@ -1245,135 +543,15 @@ var _LoggerInstance = class _LoggerInstance {
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
     this.localInstance?.fatal?.(message, ...optionalParams);
   }
-  static error(message, ...optionalParams) {
-    this.staticInstanceRef?.error(message, ...optionalParams);
-  }
-  static log(message, ...optionalParams) {
-    this.staticInstanceRef?.log(message, ...optionalParams);
-  }
-  static warn(message, ...optionalParams) {
-    this.staticInstanceRef?.warn(message, ...optionalParams);
-  }
-  static debug(message, ...optionalParams) {
-    this.staticInstanceRef?.debug?.(message, ...optionalParams);
-  }
-  static verbose(message, ...optionalParams) {
-    this.staticInstanceRef?.verbose?.(message, ...optionalParams);
-  }
-  static fatal(message, ...optionalParams) {
-    this.staticInstanceRef?.fatal?.(message, ...optionalParams);
-  }
-  static getTimestamp() {
-    return dateTimeFormatter2.format(Date.now());
-  }
-  static overrideLogger(logger) {
-    if (Array.isArray(logger)) {
-      _LoggerInstance.logLevels = logger;
-      return this.staticInstanceRef?.setLogLevels?.(logger);
-    }
-    if (isObject(logger)) {
-      this.staticInstanceRef = logger;
-    } else {
-      this.staticInstanceRef = void 0;
-    }
-  }
-  static isLevelEnabled(level) {
-    const logLevels = _LoggerInstance.logLevels;
-    return isLogLevelEnabled(level, logLevels);
-  }
-  registerLocalInstanceRef() {
-    if (this.localInstanceRef) {
-      return this.localInstanceRef;
-    }
-    this.localInstanceRef = new ConsoleLogger(this.context, {
-      timestamp: this.options?.timestamp,
-      logLevels: _LoggerInstance.logLevels
-    });
-    return this.localInstanceRef;
-  }
-};
-_init8 = __decoratorStart(null);
-_LoggerInstance = __decorateElement(_init8, 0, "LoggerInstance", _LoggerInstance_decorators, _LoggerInstance);
-__runInitializers(_init8, 1, _LoggerInstance);
-var LoggerInstance = _LoggerInstance;
-
-// src/logger/logger.factory.mts
-var LoggerInjectionToken = "LoggerInjectionToken";
-var LoggerOptions = zod.z.object({
-  context: zod.z.string().optional(),
-  options: zod.z.object({
-    timestamp: zod.z.boolean().optional()
-  }).optional()
-}).optional();
-var Logger = di.InjectionToken.create(LoggerInjectionToken, LoggerOptions);
-var _LoggerFactory_decorators, _init9;
-_LoggerFactory_decorators = [di.Injectable({
-  type: di.InjectableType.Factory,
-  token: Logger
-})];
-exports.LoggerFactory = class LoggerFactory {
-  create(ctx, args) {
-    return new LoggerInstance(args?.context, args?.options);
-  }
-};
-_init9 = __decoratorStart(null);
-exports.LoggerFactory = __decorateElement(_init9, 0, "LoggerFactory", _LoggerFactory_decorators, exports.LoggerFactory);
-__runInitializers(_init9, 1, exports.LoggerFactory);
-
-// 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() {
-  }
-  debug(message, ...optionalParams) {
-    this.logger.debug?.(message, ...optionalParams);
-  }
-  trace(message, ...optionalParams) {
-    this.logger.verbose?.(message, ...optionalParams);
-  }
-  silent() {
-  }
-  child(options) {
-    const keys = Object.keys(options);
-    let newContext = this.logger["context"] ?? "";
-    if (keys.length > 1) {
-      newContext = `${this.logger["context"] ?? ""}:${JSON.stringify(options)}`;
-    }
-    return new _PinoWrapper(
-      // @ts-expect-error We don't need to support this in the current version
-      new LoggerInstance(newContext, this.logger["options"])
-    );
-  }
-  get level() {
-    if ("level" in this.logger && this.logger.level) {
-      return this.logger.level;
-    }
-    const levels = LoggerInstance["logLevels"];
-    if (levels) {
-      return levels.find((level) => level !== "verbose");
-    }
-    return "warn";
-  }
 };
+_init2 = __decoratorStart();
+exports.LoggerInstance = __decorateElement(_init2, 0, "LoggerInstance", _LoggerInstance_decorators, exports.LoggerInstance);
+__runInitializers(_init2, 1, exports.LoggerInstance);
 
 // src/config/config.service.mts
-var ConfigServiceOptionsSchema = zod.z.record(zod.z.unknown());
+var ConfigServiceOptionsSchema = z.z.record(z.z.string(), z.z.unknown());
 var ConfigServiceToken = di.InjectionToken.create(Symbol.for("ConfigService"), ConfigServiceOptionsSchema);
-var _ConfigService_decorators, _init10;
+var _ConfigService_decorators, _init3;
 _ConfigService_decorators = [di.Injectable({
   token: ConfigServiceToken
 })];
@@ -1381,7 +559,7 @@ var _ConfigService = class _ConfigService {
   constructor(config = {}) {
     this.config = config;
   }
-  logger = di.syncInject(Logger, {
+  logger = di.inject(Logger, {
     context: _ConfigService.name
   });
   getConfig() {
@@ -1420,14 +598,14 @@ var _ConfigService = class _ConfigService {
     return value;
   }
 };
-_init10 = __decoratorStart(null);
-_ConfigService = __decorateElement(_init10, 0, "ConfigService", _ConfigService_decorators, _ConfigService);
-__runInitializers(_init10, 1, _ConfigService);
+_init3 = __decoratorStart();
+_ConfigService = __decorateElement(_init3, 0, "ConfigService", _ConfigService_decorators, _ConfigService);
+__runInitializers(_init3, 1, _ConfigService);
 var ConfigService = _ConfigService;
 
 // src/config/config.provider.mts
-var ConfigProviderOptions = zod.z.object({
-  load: zod.z.function().returns(ConfigServiceOptionsSchema)
+var ConfigProviderOptions = z.z.object({
+  load: z.z.function({ output: ConfigServiceOptionsSchema })
 });
 function provideConfig(options) {
   return di.InjectionToken.factory(ConfigServiceToken, async () => options.load());
@@ -1435,6 +613,121 @@ function provideConfig(options) {
 var EnvConfigProvider = di.InjectionToken.bound(ConfigServiceToken, {
   ...process$1.env
 });
+
+// src/metadata/handler.metadata.mts
+var EndpointMetadataKey = Symbol("EndpointMetadataKey");
+function getAllEndpointMetadata(context) {
+  if (context.metadata) {
+    const metadata = context.metadata[EndpointMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      context.metadata[EndpointMetadataKey] = /* @__PURE__ */ new Set();
+      return context.metadata[EndpointMetadataKey];
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function getEndpointMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = getAllEndpointMetadata(context);
+    if (metadata) {
+      const endpointMetadata = Array.from(metadata).find(
+        (item) => item.classMethod === target.name
+      );
+      if (endpointMetadata) {
+        return endpointMetadata;
+      } else {
+        const newMetadata = {
+          classMethod: target.name,
+          url: "",
+          successStatusCode: 200,
+          adapterToken: null,
+          headers: {},
+          httpMethod: "GET",
+          // @ts-expect-error We are using a generic type here
+          config: null,
+          guards: /* @__PURE__ */ new Set(),
+          customAttributes: /* @__PURE__ */ new Map()
+        };
+        metadata.add(newMetadata);
+        return newMetadata;
+      }
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+
+// 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;
+}
+
+// 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 for ${target.name}. Make sure to use @Module decorator.`
+    );
+  }
+  return metadata;
+}
+function hasModuleMetadata(target) {
+  return !!target[ModuleMetadataKey];
+}
+
+// src/decorators/controller.decorator.mts
 function Controller({ guards } = {}) {
   return function(target, context) {
     if (context.kind !== "class") {
@@ -1453,10 +746,30 @@ function Controller({ guards } = {}) {
     }
     return di.Injectable({
       token,
-      scope: di.InjectableScope.Instance
+      scope: di.InjectableScope.Request
     })(target, context);
   };
 }
+var EndpointAdapterToken = di.InjectionToken.create(
+  "EndpointAdapterToken"
+);
+var ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+var ExecutionContext = di.InjectionToken.create(
+  ExecutionContextInjectionToken
+);
+var HttpAdapterToken = di.InjectionToken.create(
+  "HttpAdapterToken"
+);
+var MultipartAdapterToken = di.InjectionToken.create(
+  "MultipartAdapterToken"
+);
+var Reply = di.InjectionToken.create("ReplyToken");
+var Request = di.InjectionToken.create("RequestToken");
+var StreamAdapterToken = di.InjectionToken.create(
+  "StreamAdapterToken"
+);
+
+// src/decorators/endpoint.decorator.mts
 function Endpoint(endpoint) {
   return (target, context) => {
     if (context.kind !== "method") {
@@ -1628,6 +941,193 @@ function UseGuards(...guards) {
   };
 }
 
+// src/exceptions/http.exception.mts
+var HttpException = class {
+  constructor(statusCode, response, error) {
+    this.statusCode = statusCode;
+    this.response = response;
+    this.error = error;
+  }
+};
+
+// src/exceptions/bad-request.exception.mts
+var BadRequestException = class extends HttpException {
+  constructor(message) {
+    super(400, message);
+  }
+};
+
+// src/exceptions/forbidden.exception.mts
+var ForbiddenException = class extends HttpException {
+  constructor(message) {
+    super(403, message);
+  }
+};
+
+// src/exceptions/internal-server-error.exception.mts
+var InternalServerErrorException = class extends HttpException {
+  constructor(message, error) {
+    super(500, message, error);
+  }
+};
+
+// src/exceptions/not-found.exception.mts
+var NotFoundException = class extends HttpException {
+  constructor(response, error) {
+    super(404, response, error);
+    this.response = response;
+    this.error = error;
+  }
+};
+
+// src/exceptions/unauthorized.exception.mts
+var UnauthorizedException = class extends HttpException {
+  constructor(message, error) {
+    super(401, message, error);
+  }
+};
+
+// src/exceptions/conflict.exception.mts
+var ConflictException = class extends HttpException {
+  constructor(message, error) {
+    super(409, message, error);
+  }
+};
+var _GuardRunnerService_decorators, _init4;
+_GuardRunnerService_decorators = [di.Injectable()];
+exports.GuardRunnerService = class GuardRunnerService {
+  container = di.inject(di.Container);
+  async runGuards(allGuards, executionContext) {
+    let canActivate = true;
+    for (const guard of Array.from(allGuards).reverse()) {
+      const guardInstance = await this.container.get(
+        guard
+      );
+      if (!guardInstance.canActivate) {
+        throw new Error(
+          `[Navios] Guard ${guard.name} does not implement canActivate()`
+        );
+      }
+      try {
+        canActivate = await guardInstance.canActivate(executionContext);
+        if (!canActivate) {
+          break;
+        }
+      } catch (error) {
+        if (error instanceof HttpException) {
+          executionContext.getReply().status(error.statusCode).send(error.response);
+          return false;
+        } else {
+          executionContext.getReply().status(500).send({
+            message: "Internal server error",
+            error: error.message
+          });
+          return false;
+        }
+      }
+    }
+    if (!canActivate) {
+      executionContext.getReply().status(403).send({
+        message: "Forbidden"
+      });
+      return false;
+    }
+    return canActivate;
+  }
+  makeContext(moduleMetadata, controllerMetadata, endpoint) {
+    const guards = /* @__PURE__ */ new Set();
+    const endpointGuards = endpoint.guards;
+    const controllerGuards = controllerMetadata.guards;
+    const moduleGuards = moduleMetadata.guards;
+    if (endpointGuards.size > 0) {
+      for (const guard of endpointGuards) {
+        guards.add(guard);
+      }
+    }
+    if (controllerGuards.size > 0) {
+      for (const guard of controllerGuards) {
+        guards.add(guard);
+      }
+    }
+    if (moduleGuards.size > 0) {
+      for (const guard of moduleGuards) {
+        guards.add(guard);
+      }
+    }
+    return guards;
+  }
+};
+_init4 = __decoratorStart();
+exports.GuardRunnerService = __decorateElement(_init4, 0, "GuardRunnerService", _GuardRunnerService_decorators, exports.GuardRunnerService);
+__runInitializers(_init4, 1, exports.GuardRunnerService);
+var _ModuleLoaderService_decorators, _init5;
+_ModuleLoaderService_decorators = [di.Injectable()];
+var _ModuleLoaderService = class _ModuleLoaderService {
+  logger = di.inject(Logger, {
+    context: _ModuleLoaderService.name
+  });
+  container = di.inject(di.Container);
+  modulesMetadata = /* @__PURE__ */ new Map();
+  loadedModules = /* @__PURE__ */ new Map();
+  initialized = false;
+  async loadModules(appModule) {
+    if (this.initialized) {
+      return;
+    }
+    await this.traverseModules(appModule);
+    this.initialized = true;
+  }
+  async traverseModules(module, parentMetadata) {
+    const metadata = extractModuleMetadata(module);
+    if (parentMetadata) {
+      this.mergeMetadata(metadata, parentMetadata);
+    }
+    const moduleName = module.name;
+    if (this.modulesMetadata.has(moduleName)) {
+      return;
+    }
+    this.modulesMetadata.set(moduleName, metadata);
+    const imports = metadata.imports ?? /* @__PURE__ */ new Set();
+    const loadingPromises = Array.from(imports).map(
+      async (importedModule) => this.traverseModules(importedModule, metadata)
+    );
+    await Promise.all(loadingPromises);
+    const instance = await this.container.get(module);
+    if (instance.onModuleInit) {
+      await instance.onModuleInit();
+    }
+    this.logger.debug(`Module ${moduleName} loaded`);
+    this.loadedModules.set(moduleName, instance);
+  }
+  mergeMetadata(metadata, parentMetadata) {
+    if (parentMetadata.guards) {
+      for (const guard of parentMetadata.guards) {
+        metadata.guards.add(guard);
+      }
+    }
+    if (parentMetadata.customAttributes) {
+      for (const [key, value] of parentMetadata.customAttributes) {
+        if (metadata.customAttributes.has(key)) {
+          continue;
+        }
+        metadata.customAttributes.set(key, value);
+      }
+    }
+  }
+  getAllModules() {
+    return this.modulesMetadata;
+  }
+  dispose() {
+    this.modulesMetadata.clear();
+    this.loadedModules.clear();
+    this.initialized = false;
+  }
+};
+_init5 = __decoratorStart();
+_ModuleLoaderService = __decorateElement(_init5, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
+__runInitializers(_init5, 1, _ModuleLoaderService);
+var ModuleLoaderService = _ModuleLoaderService;
+
 // src/attribute.factory.mts
 var AttributeFactory = class {
   static createAttribute(token, schema) {
@@ -1684,162 +1184,208 @@ var AttributeFactory = class {
     return target.customAttributes.has(attribute.token);
   }
 };
-var _NaviosApplication_decorators, _init11;
+var _NaviosEnvironment_decorators, _init6;
+_NaviosEnvironment_decorators = [di.Injectable()];
+var NaviosEnvironment = class {
+  httpTokens = /* @__PURE__ */ new Map();
+  setupHttpEnvironment(tokens) {
+    this.httpTokens = tokens;
+  }
+  getHttpToken(token) {
+    return this.httpTokens.get(token);
+  }
+  hasHttpSetup() {
+    return this.httpTokens.size > 0;
+  }
+};
+_init6 = __decoratorStart();
+NaviosEnvironment = __decorateElement(_init6, 0, "NaviosEnvironment", _NaviosEnvironment_decorators, NaviosEnvironment);
+__runInitializers(_init6, 1, NaviosEnvironment);
+
+// src/factories/endpoint-adapter.factory.mts
+var _EndpointAdapterFactory_decorators, _init7;
+_EndpointAdapterFactory_decorators = [di.Factory({
+  token: EndpointAdapterToken
+})];
+exports.EndpointAdapterFactory = class EndpointAdapterFactory {
+  environment = di.inject(NaviosEnvironment);
+  create(ctx) {
+    const service = this.environment.getHttpToken(EndpointAdapterToken);
+    if (!service) {
+      throw new Error("EndpointAdapterToken service not found in environment");
+    }
+    return ctx.inject(service);
+  }
+};
+_init7 = __decoratorStart();
+exports.EndpointAdapterFactory = __decorateElement(_init7, 0, "EndpointAdapterFactory", _EndpointAdapterFactory_decorators, exports.EndpointAdapterFactory);
+__runInitializers(_init7, 1, exports.EndpointAdapterFactory);
+var _HttpAdapterFactory_decorators, _init8;
+_HttpAdapterFactory_decorators = [di.Factory({
+  token: HttpAdapterToken
+})];
+exports.HttpAdapterFactory = class HttpAdapterFactory {
+  environment = di.inject(NaviosEnvironment);
+  create(ctx) {
+    const service = this.environment.getHttpToken(HttpAdapterToken);
+    if (!service) {
+      throw new Error("HttpAdapterToken service not found in environment");
+    }
+    return ctx.inject(service);
+  }
+};
+_init8 = __decoratorStart();
+exports.HttpAdapterFactory = __decorateElement(_init8, 0, "HttpAdapterFactory", _HttpAdapterFactory_decorators, exports.HttpAdapterFactory);
+__runInitializers(_init8, 1, exports.HttpAdapterFactory);
+var _MultipartAdapterFactory_decorators, _init9;
+_MultipartAdapterFactory_decorators = [di.Factory({
+  token: MultipartAdapterToken
+})];
+exports.MultipartAdapterFactory = class MultipartAdapterFactory {
+  environment = di.inject(NaviosEnvironment);
+  create(ctx) {
+    const service = this.environment.getHttpToken(MultipartAdapterToken);
+    if (!service) {
+      throw new Error("MultipartAdapterToken service not found in environment");
+    }
+    return ctx.inject(service);
+  }
+};
+_init9 = __decoratorStart();
+exports.MultipartAdapterFactory = __decorateElement(_init9, 0, "MultipartAdapterFactory", _MultipartAdapterFactory_decorators, exports.MultipartAdapterFactory);
+__runInitializers(_init9, 1, exports.MultipartAdapterFactory);
+var _RequestFactory_decorators, _init10;
+_RequestFactory_decorators = [di.Factory({
+  token: Request,
+  scope: di.InjectableScope.Request
+})];
+exports.RequestFactory = class RequestFactory {
+  environment = di.inject(NaviosEnvironment);
+  create(ctx) {
+    const service = this.environment.getHttpToken(Request);
+    if (!service) {
+      throw new Error("RequestToken service not found in environment");
+    }
+    return ctx.inject(service);
+  }
+};
+_init10 = __decoratorStart();
+exports.RequestFactory = __decorateElement(_init10, 0, "RequestFactory", _RequestFactory_decorators, exports.RequestFactory);
+__runInitializers(_init10, 1, exports.RequestFactory);
+var _ReplyFactory_decorators, _init11;
+_ReplyFactory_decorators = [di.Factory({
+  token: Reply,
+  scope: di.InjectableScope.Request
+})];
+exports.ReplyFactory = class ReplyFactory {
+  environment = di.inject(NaviosEnvironment);
+  create(ctx) {
+    const service = this.environment.getHttpToken(Reply);
+    if (!service) {
+      throw new Error("ReplyToken service not found in environment");
+    }
+    return ctx.inject(service);
+  }
+};
+_init11 = __decoratorStart();
+exports.ReplyFactory = __decorateElement(_init11, 0, "ReplyFactory", _ReplyFactory_decorators, exports.ReplyFactory);
+__runInitializers(_init11, 1, exports.ReplyFactory);
+var _StreamAdapterFactory_decorators, _init12;
+_StreamAdapterFactory_decorators = [di.Factory({
+  token: StreamAdapterToken
+})];
+exports.StreamAdapterFactory = class StreamAdapterFactory {
+  environment = di.inject(NaviosEnvironment);
+  create(ctx) {
+    const service = this.environment.getHttpToken(StreamAdapterToken);
+    if (!service) {
+      throw new Error("StreamAdapterToken service not found in environment");
+    }
+    return ctx.inject(service);
+  }
+};
+_init12 = __decoratorStart();
+exports.StreamAdapterFactory = __decorateElement(_init12, 0, "StreamAdapterFactory", _StreamAdapterFactory_decorators, exports.StreamAdapterFactory);
+__runInitializers(_init12, 1, exports.StreamAdapterFactory);
+var _NaviosApplication_decorators, _init13;
 _NaviosApplication_decorators = [di.Injectable()];
 var _NaviosApplication = class _NaviosApplication {
-  moduleLoader = di.syncInject(ModuleLoaderService);
-  controllerAdapter = di.syncInject(ControllerAdapterService);
-  logger = di.syncInject(Logger, {
+  environment = di.inject(NaviosEnvironment);
+  moduleLoader = di.inject(ModuleLoaderService);
+  httpApplication = null;
+  logger = di.inject(Logger, {
     context: _NaviosApplication.name
   });
-  server = null;
-  corsOptions = null;
-  multipartOptions = null;
-  globalPrefix = null;
+  container = di.inject(di.Container);
   appModule = null;
-  options = {};
+  options = {
+    adapter: []
+  };
   isInitialized = false;
-  setup(appModule, options = {}) {
+  async setup(appModule, options = {
+    adapter: []
+  }) {
     this.appModule = appModule;
     this.options = options;
+    if (this.environment.hasHttpSetup()) {
+      this.httpApplication = await this.container.get(HttpAdapterToken);
+    }
+  }
+  getContainer() {
+    return this.container;
   }
   async init() {
     if (!this.appModule) {
       throw new Error("App module is not set. Call setAppModule() first.");
     }
     await this.moduleLoader.loadModules(this.appModule);
-    this.server = await this.getFastifyInstance(this.options);
-    this.configureFastifyInstance(this.server);
-    di.getGlobalServiceLocator().storeInstance(this.server, Application);
-    this.server.setValidatorCompiler(fastifyTypeProviderZod.validatorCompiler);
-    this.server.setSerializerCompiler(fastifyTypeProviderZod.serializerCompiler);
-    if (this.corsOptions) {
-      await this.server.register(cors__default.default, this.corsOptions);
-    }
-    if (this.multipartOptions) {
-      await this.configureMultipart(this.server, this.multipartOptions);
+    if (this.environment.hasHttpSetup()) {
+      await this.httpApplication?.setupHttpServer(this.options);
     }
     await this.initModules();
-    await this.server.ready();
+    if (this.environment.hasHttpSetup()) {
+      await this.httpApplication?.ready();
+    }
     this.isInitialized = true;
     this.logger.debug("Navios application initialized");
   }
-  async getFastifyInstance(rawOptions) {
-    const { logger, ...options } = rawOptions;
-    if (logger) {
-      const fastifyOptions = options;
-      if (typeof logger === "boolean") {
-        if (!logger) {
-          fastifyOptions.logger = false;
-        }
-      } else {
-        fastifyOptions.loggerInstance = new PinoWrapper(
-          await di.inject(Logger, {
-            context: "FastifyAdapter"
-          })
-        );
-      }
-      return fastify.fastify(fastifyOptions);
-    } else {
-      return fastify.fastify({
-        ...options,
-        loggerInstance: new PinoWrapper(
-          await di.inject(Logger, {
-            context: "FastifyAdapter"
-          })
-        )
-      });
-    }
-  }
-  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.method}] ${req.url}`);
-      return reply.status(404).send(response);
-    });
-  }
-  async configureMultipart(server, options) {
-    if (options) {
-      await server.register(
-        multipart__default.default,
-        typeof options === "object" ? options : {}
-      );
-    }
-  }
   async initModules() {
     const modules = this.moduleLoader.getAllModules();
-    const promises = [];
-    for (const [moduleName, moduleMetadata] of modules) {
-      if (!moduleMetadata.controllers || moduleMetadata.controllers.size === 0) {
-        continue;
-      }
-      promises.push(
-        this.server.register(
-          async (instance, opts) => {
-            for (const controller of moduleMetadata.controllers) {
-              await this.controllerAdapter.setupController(
-                controller,
-                instance,
-                moduleMetadata
-              );
-            }
-          },
-          {
-            prefix: this.globalPrefix ?? ""
-          }
-        )
-      );
-    }
-    await Promise.all(promises);
+    await this.httpApplication?.onModulesInit(modules);
   }
   enableCors(options) {
-    this.corsOptions = options;
+    if (!this.httpApplication) {
+      throw new Error("HTTP application is not set");
+    }
+    this.httpApplication.enableCors(options);
   }
   enableMultipart(options) {
-    this.multipartOptions = options;
+    if (!this.httpApplication) {
+      throw new Error("HTTP application is not set");
+    }
+    this.httpApplication.enableMultipart(options);
   }
   setGlobalPrefix(prefix) {
-    this.globalPrefix = prefix;
+    if (!this.httpApplication) {
+      throw new Error("HTTP application is not set");
+    }
+    this.httpApplication.setGlobalPrefix(prefix);
   }
   getServer() {
-    if (!this.server) {
-      throw new Error("Server is not initialized. Call init() first.");
+    if (!this.httpApplication) {
+      throw new Error("HTTP application is not set");
     }
-    return this.server;
+    return this.httpApplication.getServer();
   }
   async listen(options) {
-    if (!this.server) {
-      throw new Error("Server is not initialized. Call init() first.");
+    if (!this.httpApplication) {
+      throw new Error("HTTP application is not set");
     }
-    const res = await this.server.listen(options);
-    this.logger.debug(`Navios is listening on ${res}`);
+    await this.httpApplication.listen(options);
   }
   async dispose() {
-    if (this.server) {
-      await this.server.close();
-      this.server = null;
+    if (this.httpApplication) {
+      await this.httpApplication.dispose();
     }
     if (this.moduleLoader) {
       this.moduleLoader.dispose();
@@ -1849,29 +1395,52 @@ var _NaviosApplication = class _NaviosApplication {
     await this.dispose();
   }
 };
-_init11 = __decoratorStart(null);
-_NaviosApplication = __decorateElement(_init11, 0, "NaviosApplication", _NaviosApplication_decorators, _NaviosApplication);
-__runInitializers(_init11, 1, _NaviosApplication);
+_init13 = __decoratorStart();
+_NaviosApplication = __decorateElement(_init13, 0, "NaviosApplication", _NaviosApplication_decorators, _NaviosApplication);
+__runInitializers(_init13, 1, _NaviosApplication);
 var NaviosApplication = _NaviosApplication;
 var NaviosFactory = class {
-  static async create(appModule, options = {}) {
-    const app = await di.inject(NaviosApplication);
-    this.registerLoggerConfiguration(options);
-    app.setup(appModule, options);
+  static async create(appModule, options = {
+    adapter: []
+  }) {
+    const container = new di.Container();
+    await this.registerLoggerConfiguration(container, options);
+    const adapters = Array.isArray(options.adapter) ? options.adapter : [options.adapter];
+    for (const adapter of adapters) {
+      await this.registerEnvironment(container, adapter);
+    }
+    const app = await container.get(NaviosApplication);
+    await app.setup(appModule, options);
     return app;
   }
-  static registerLoggerConfiguration(options) {
-    if (!options) {
-      return;
+  static async registerEnvironment(container, environment = {}) {
+    const naviosEnvironment = await container.get(NaviosEnvironment);
+    const { httpTokens } = environment;
+    if (httpTokens) {
+      naviosEnvironment.setupHttpEnvironment(httpTokens);
     }
+  }
+  static async registerLoggerConfiguration(container, options) {
     const { logger } = options;
+    if (Array.isArray(logger) || isNil(logger)) {
+      const loggerInstance = await container.get(
+        LoggerOutput
+      );
+      loggerInstance?.setup({
+        logLevels: logger
+      });
+    }
     if (logger !== true && !isNil(logger)) {
-      LoggerInstance.overrideLogger(logger);
+      container.getServiceLocator().getManager().storeCreatedHolder(
+        LoggerOutput.toString(),
+        logger,
+        di.InjectableType.Class,
+        di.InjectableScope.Singleton
+      );
     }
   }
 };
 
-exports.Application = Application;
 exports.AttributeFactory = AttributeFactory;
 exports.BadRequestException = BadRequestException;
 exports.ConfigProviderOptions = ConfigProviderOptions;
@@ -1879,9 +1448,7 @@ exports.ConfigService = ConfigService;
 exports.ConfigServiceOptionsSchema = ConfigServiceOptionsSchema;
 exports.ConfigServiceToken = ConfigServiceToken;
 exports.ConflictException = ConflictException;
-exports.ConsoleLogger = ConsoleLogger;
 exports.Controller = Controller;
-exports.ControllerAdapterService = ControllerAdapterService;
 exports.ControllerMetadataKey = ControllerMetadataKey;
 exports.Endpoint = Endpoint;
 exports.EndpointAdapterToken = EndpointAdapterToken;
@@ -1889,17 +1456,15 @@ exports.EndpointMetadataKey = EndpointMetadataKey;
 exports.EnvConfigProvider = EnvConfigProvider;
 exports.ExecutionContext = ExecutionContext;
 exports.ExecutionContextInjectionToken = ExecutionContextInjectionToken;
-exports.ExecutionContextToken = ExecutionContextToken;
 exports.ForbiddenException = ForbiddenException;
 exports.Header = Header;
+exports.HttpAdapterToken = HttpAdapterToken;
 exports.HttpCode = HttpCode;
 exports.HttpException = HttpException;
 exports.InternalServerErrorException = InternalServerErrorException;
 exports.LOG_LEVELS = LOG_LEVELS;
 exports.Logger = Logger;
-exports.LoggerInjectionToken = LoggerInjectionToken;
-exports.LoggerInstance = LoggerInstance;
-exports.LoggerOptions = LoggerOptions;
+exports.LoggerOutput = LoggerOutput;
 exports.Module = Module;
 exports.ModuleLoaderService = ModuleLoaderService;
 exports.ModuleMetadataKey = ModuleMetadataKey;
@@ -1908,7 +1473,6 @@ exports.MultipartAdapterToken = MultipartAdapterToken;
 exports.NaviosApplication = NaviosApplication;
 exports.NaviosFactory = NaviosFactory;
 exports.NotFoundException = NotFoundException;
-exports.PinoWrapper = PinoWrapper;
 exports.Reply = Reply;
 exports.Request = Request;
 exports.Stream = Stream;
@@ -1940,6 +1504,7 @@ exports.isPlainObject = isPlainObject;
 exports.isString = isString;
 exports.isSymbol = isSymbol;
 exports.isUndefined = isUndefined;
+exports.loggerOptionsSchema = loggerOptionsSchema;
 exports.normalizePath = normalizePath;
 exports.provideConfig = provideConfig;
 exports.stripEndSlash = stripEndSlash;