@navios/core 0.1.12 → 0.1.14

package/dist/index.js

@@ -92,7 +92,7 @@ __export(src_exports, {
   EndpointType: () => EndpointType,
   ErrorsEnum: () => ErrorsEnum,
   EventEmitter: () => EventEmitter,
-  ExecutionContext: () => ExecutionContext2,
+  ExecutionContext: () => ExecutionContext,
   ExecutionContextInjectionToken: () => ExecutionContextInjectionToken,
   ExecutionContextToken: () => ExecutionContextToken,
   FactoryInjectionToken: () => FactoryInjectionToken,
@@ -188,7 +188,7 @@ function envString(key, defaultValue) {
 }
 
 // packages/core/src/config/config.provider.mts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // packages/core/src/logger/utils/cli-colors.util.mts
 var isColorAllowed = () => !process.env.NO_COLOR;
@@ -597,6 +597,7 @@ var ServiceLocator = class {
       destroyPromise: null,
       creationPromise: null
     });
+    this.eventBus.emit(instanceName, "create");
   }
   removeInstance(token) {
     const instanceName = this.getInstanceIdentifier(token, void 0);
@@ -1172,362 +1173,639 @@ function override(token, target) {
   };
 }
 
-// packages/core/src/logger/console-logger.service.mts
-var DEFAULT_DEPTH = 5;
-var DEFAULT_LOG_LEVELS = [
-  "log",
-  "error",
-  "warn",
-  "debug",
-  "verbose",
-  "fatal"
-];
-var dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
-  year: "numeric",
-  hour: "numeric",
-  minute: "numeric",
-  second: "numeric",
-  day: "2-digit",
-  month: "2-digit"
-});
-var _ConsoleLogger_decorators, _init;
-_ConsoleLogger_decorators = [Injectable()];
-var _ConsoleLogger = class _ConsoleLogger {
-  /**
-   * The options of the logger.
-   */
-  options;
-  /**
-   * The context of the logger (can be set manually or automatically inferred).
-   */
-  context;
-  /**
-   * The original context of the logger (set in the constructor).
-   */
-  originalContext;
-  /**
-   * The options used for the "inspect" method.
-   */
-  inspectOptions;
-  /**
-   * The last timestamp at which the log message was printed.
-   */
-  static lastTimestampAt;
-  constructor(contextOrOptions, options) {
-    let [context, opts] = isString(contextOrOptions) ? [contextOrOptions, options] : options ? [void 0, options] : [contextOrOptions == null ? void 0 : contextOrOptions.context, contextOrOptions];
-    opts = opts ?? {};
-    opts.logLevels ??= DEFAULT_LOG_LEVELS;
-    opts.colors ??= opts.colors ?? (opts.json ? false : true);
-    opts.prefix ??= "Navios";
-    this.options = opts;
-    this.inspectOptions = this.getInspectOptions();
-    if (context) {
-      this.context = context;
-      this.originalContext = context;
+// packages/core/src/tokens/application.token.mts
+var ApplicationInjectionToken = "ApplicationInjectionToken";
+var Application = InjectionToken.create(
+  ApplicationInjectionToken
+);
+
+// packages/core/src/services/controller-adapter.service.mts
+var import_common3 = require("@navios/common");
+var import_zod2 = require("zod");
+
+// packages/core/src/metadata/endpoint.metadata.mts
+var EndpointMetadataKey = Symbol("EndpointMetadataKey");
+var EndpointType = /* @__PURE__ */ ((EndpointType2) => {
+  EndpointType2["Unknown"] = "unknown";
+  EndpointType2["Endpoint"] = "endpoint";
+  EndpointType2["Stream"] = "stream";
+  EndpointType2["Multipart"] = "multipart";
+  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];
     }
   }
-  log(message, ...optionalParams) {
-    if (!this.isLevelEnabled("log")) {
-      return;
+  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;
+      }
     }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "log");
   }
-  error(message, ...optionalParams) {
-    if (!this.isLevelEnabled("error")) {
-      return;
+  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;
     }
-    const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
-    this.printMessages(messages, context, "error", "stderr", stack);
-    this.printStackTrace(stack);
   }
-  warn(message, ...optionalParams) {
-    if (!this.isLevelEnabled("warn")) {
-      return;
-    }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "warn");
+  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."
+    );
   }
-  debug(message, ...optionalParams) {
-    if (!this.isLevelEnabled("debug")) {
-      return;
+  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;
     }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "debug");
   }
-  verbose(message, ...optionalParams) {
-    if (!this.isLevelEnabled("verbose")) {
-      return;
-    }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "verbose");
+  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.`
+    );
   }
-  fatal(message, ...optionalParams) {
-    if (!this.isLevelEnabled("fatal")) {
-      return;
-    }
-    const { messages, context } = this.getContextAndMessagesToPrint([
-      message,
-      ...optionalParams
-    ]);
-    this.printMessages(messages, context, "fatal");
+  return metadata;
+}
+function hasModuleMetadata(target) {
+  return !!target[ModuleMetadataKey];
+}
+
+// packages/core/src/services/execution-context.mts
+var ExecutionContext = class {
+  constructor(module2, controller, handler) {
+    this.module = module2;
+    this.controller = controller;
+    this.handler = handler;
   }
-  /**
-   * Set log levels
-   * @param levels log levels
-   */
-  setLogLevels(levels) {
-    if (!this.options) {
-      this.options = {};
-    }
-    this.options.logLevels = levels;
+  request;
+  reply;
+  getModule() {
+    return this.module;
   }
-  /**
-   * Set logger context
-   * @param context context
-   */
-  setContext(context) {
-    this.context = context;
+  getController() {
+    return this.controller;
   }
-  /**
-   * Resets the logger context to the value that was passed in the constructor.
-   */
-  resetContext() {
-    this.context = this.originalContext;
+  getHandler() {
+    return this.handler;
   }
-  isLevelEnabled(level) {
-    var _a;
-    const logLevels = (_a = this.options) == null ? void 0 : _a.logLevels;
-    return isLogLevelEnabled(level, logLevels);
-  }
-  getTimestamp() {
-    return dateTimeFormatter.format(Date.now());
-  }
-  printMessages(messages, context = "", logLevel = "log", writeStreamType, errorStack) {
-    messages.forEach((message) => {
-      if (this.options.json) {
-        this.printAsJson(message, {
-          context,
-          logLevel,
-          writeStreamType,
-          errorStack
-        });
-        return;
-      }
-      const pidMessage = this.formatPid(process.pid);
-      const contextMessage = this.formatContext(context);
-      const timestampDiff = this.updateAndGetTimestampDiff();
-      const formattedLogLevel = logLevel.toUpperCase().padStart(7, " ");
-      const formattedMessage = this.formatMessage(
-        logLevel,
-        message,
-        pidMessage,
-        formattedLogLevel,
-        contextMessage,
-        timestampDiff
+  getRequest() {
+    if (!this.request) {
+      throw new Error(
+        "[Navios] Request is not set. Make sure to set it before using it."
       );
-      process[writeStreamType ?? "stdout"].write(formattedMessage);
-    });
-  }
-  printAsJson(message, options) {
-    const logObject = {
-      level: options.logLevel,
-      pid: process.pid,
-      timestamp: Date.now(),
-      message
-    };
-    if (options.context) {
-      logObject.context = options.context;
     }
-    if (options.errorStack) {
-      logObject.stack = options.errorStack;
+    return this.request;
+  }
+  getReply() {
+    if (!this.reply) {
+      throw new Error(
+        "[Navios] Reply is not set. Make sure to set it before using it."
+      );
     }
-    const formattedMessage = !this.options.colors && this.inspectOptions.compact === true ? JSON.stringify(logObject, this.stringifyReplacer) : (0, import_util.inspect)(logObject, this.inspectOptions);
-    process[options.writeStreamType ?? "stdout"].write(`${formattedMessage}
-`);
+    return this.reply;
   }
-  formatPid(pid) {
-    return `[${this.options.prefix}] ${pid}  - `;
+  provideRequest(request) {
+    this.request = request;
   }
-  formatContext(context) {
-    if (!context) {
-      return "";
-    }
-    context = `[${context}] `;
-    return this.options.colors ? yellow(context) : context;
+  provideReply(reply) {
+    this.reply = reply;
   }
-  formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
-    const output = this.stringifyMessage(message, logLevel);
-    pidMessage = this.colorize(pidMessage, logLevel);
-    formattedLogLevel = this.colorize(formattedLogLevel, logLevel);
-    return `${pidMessage}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}
-`;
+};
+
+// packages/core/src/exceptions/http.exception.mts
+var HttpException = class {
+  constructor(statusCode, response, error) {
+    this.statusCode = statusCode;
+    this.response = response;
+    this.error = error;
   }
-  stringifyMessage(message, logLevel) {
-    if (isFunction(message)) {
-      const messageAsStr = Function.prototype.toString.call(message);
-      const isClass = messageAsStr.startsWith("class ");
-      if (isClass) {
-        return this.stringifyMessage(message.name, logLevel);
-      }
-      return this.stringifyMessage(message(), logLevel);
-    }
-    if (typeof message === "string") {
-      return this.colorize(message, logLevel);
-    }
-    const outputText = (0, import_util.inspect)(message, this.inspectOptions);
-    if (isPlainObject(message)) {
-      return `Object(${Object.keys(message).length}) ${outputText}`;
-    }
-    if (Array.isArray(message)) {
-      return `Array(${message.length}) ${outputText}`;
-    }
-    return outputText;
+};
+
+// packages/core/src/exceptions/bad-request.exception.mts
+var BadRequestException = class extends HttpException {
+  constructor(message) {
+    super(400, message);
   }
-  colorize(message, logLevel) {
-    if (!this.options.colors || this.options.json) {
-      return message;
-    }
-    const color = this.getColorByLogLevel(logLevel);
-    return color(message);
+};
+
+// packages/core/src/exceptions/forbidden.exception.mts
+var ForbiddenException = class extends HttpException {
+  constructor(message) {
+    super(403, message);
   }
-  printStackTrace(stack) {
-    if (!stack || this.options.json) {
-      return;
-    }
-    process.stderr.write(`${stack}
-`);
+};
+
+// packages/core/src/exceptions/internal-server-error.exception.mts
+var InternalServerErrorException = class extends HttpException {
+  constructor(message, error) {
+    super(500, message, error);
   }
-  updateAndGetTimestampDiff() {
-    var _a;
-    const includeTimestamp = _ConsoleLogger.lastTimestampAt && ((_a = this.options) == null ? void 0 : _a.timestamp);
-    const result = includeTimestamp ? this.formatTimestampDiff(Date.now() - _ConsoleLogger.lastTimestampAt) : "";
-    _ConsoleLogger.lastTimestampAt = Date.now();
-    return result;
+};
+
+// 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;
   }
-  formatTimestampDiff(timestampDiff) {
-    const formattedDiff = ` +${timestampDiff}ms`;
-    return this.options.colors ? yellow(formattedDiff) : formattedDiff;
+};
+
+// packages/core/src/exceptions/unauthorized.exception.mts
+var UnauthorizedException = class extends HttpException {
+  constructor(message, error) {
+    super(401, message, error);
   }
-  getInspectOptions() {
-    let breakLength = this.options.breakLength;
-    if (typeof breakLength === "undefined") {
-      breakLength = this.options.colors ? this.options.compact ? Infinity : void 0 : this.options.compact === false ? void 0 : Infinity;
-    }
-    const inspectOptions = {
-      depth: this.options.depth ?? DEFAULT_DEPTH,
-      sorted: this.options.sorted,
-      showHidden: this.options.showHidden,
-      compact: this.options.compact ?? (this.options.json ? true : false),
-      colors: this.options.colors,
-      breakLength
-    };
-    if (this.options.maxArrayLength) {
-      inspectOptions.maxArrayLength = this.options.maxArrayLength;
+};
+
+// packages/core/src/exceptions/conflict.exception.mts
+var ConflictException = class extends HttpException {
+  constructor(message, error) {
+    super(409, message, error);
+  }
+};
+
+// packages/core/src/services/guard-runner.service.mts
+var _GuardRunnerService_decorators, _init;
+_GuardRunnerService_decorators = [Injectable()];
+var GuardRunnerService = class {
+  async runGuards(allGuards, executionContext) {
+    let canActivate = true;
+    for (const guard of Array.from(allGuards).reverse()) {
+      const guardInstance = await 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 (this.options.maxStringLength) {
-      inspectOptions.maxStringLength = this.options.maxStringLength;
+    if (!canActivate) {
+      executionContext.getReply().status(403).send({
+        message: "Forbidden"
+      });
+      return false;
     }
-    return inspectOptions;
+    return canActivate;
   }
-  stringifyReplacer(key, value) {
-    if (typeof value === "bigint") {
-      return value.toString();
+  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 (typeof value === "symbol") {
-      return value.toString();
+    if (controllerGuards.size > 0) {
+      for (const guard of controllerGuards) {
+        guards.add(guard);
+      }
     }
-    if (value instanceof Map || value instanceof Set || value instanceof Error) {
-      return `${(0, import_util.inspect)(value, this.inspectOptions)}`;
+    if (moduleGuards.size > 0) {
+      for (const guard of moduleGuards) {
+        guards.add(guard);
+      }
     }
-    return value;
+    return guards;
   }
-  getContextAndMessagesToPrint(args) {
-    if ((args == null ? void 0 : args.length) <= 1) {
-      return { messages: args, context: this.context };
-    }
-    const lastElement = args[args.length - 1];
-    const isContext = isString(lastElement);
-    if (!isContext) {
-      return { messages: args, context: this.context };
-    }
-    return {
-      context: lastElement,
-      messages: args.slice(0, args.length - 1)
-    };
+};
+_init = __decoratorStart(null);
+GuardRunnerService = __decorateElement(_init, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
+__runInitializers(_init, 1, GuardRunnerService);
+
+// packages/core/src/services/controller-adapter.service.mts
+var _ControllerAdapterService_decorators, _init2;
+_ControllerAdapterService_decorators = [Injectable()];
+var _ControllerAdapterService = class _ControllerAdapterService {
+  guardRunner = syncInject(GuardRunnerService);
+  logger = syncInject(Logger, {
+    context: _ControllerAdapterService.name
+  });
+  setupController(controller, instance, moduleMetadata) {
+    const controllerMetadata = extractControllerMetadata(controller);
+    for (const endpoint of controllerMetadata.endpoints) {
+      const { classMethod, url, httpMethod } = endpoint;
+      if (!url) {
+        throw new Error(
+          `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`
+        );
+      }
+      const executionContext = new ExecutionContext(
+        moduleMetadata,
+        controllerMetadata,
+        endpoint
+      );
+      instance.withTypeProvider().route({
+        method: httpMethod,
+        url: url.replaceAll("$", ":"),
+        schema: this.provideSchemaForConfig(endpoint),
+        preHandler: this.providePreHandler(executionContext),
+        handler: this.provideHandler(controller, executionContext, endpoint)
+      });
+      this.logger.debug(
+        `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`
+      );
+    }
   }
-  getContextAndStackAndMessagesToPrint(args) {
-    if (args.length === 2) {
-      return this.isStackFormat(args[1]) ? {
-        messages: [args[0]],
-        stack: args[1],
-        context: this.context
-      } : {
-        messages: [args[0]],
-        context: args[1]
-      };
+  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 { messages, context } = this.getContextAndMessagesToPrint(args);
-    if ((messages == null ? void 0 : messages.length) <= 1) {
-      return { messages, context };
+    const { querySchema, requestSchema, responseSchema } = endpointMetadata.config;
+    const schema = {};
+    if (querySchema) {
+      schema.querystring = querySchema;
     }
-    const lastElement = messages[messages.length - 1];
-    const isStack = isString(lastElement);
-    if (!isStack && !isUndefined(lastElement)) {
-      return { messages, context };
+    if (requestSchema && endpointMetadata.type !== "multipart" /* Multipart */) {
+      schema.body = requestSchema;
     }
-    return {
-      stack: lastElement,
-      messages: messages.slice(0, messages.length - 1),
-      context
+    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_common3.NaviosException("Unknown endpoint type");
+      case "endpoint" /* Endpoint */:
+        return this.provideHandlerForConfig(
+          controller,
+          executionContext,
+          endpointMetadata
+        );
+      case "stream" /* Stream */:
+        return this.provideHandlerForStream(
+          controller,
+          executionContext,
+          endpointMetadata
+        );
+      case "multipart" /* Multipart */:
+        return this.provideHandlerForMultipart(
+          controller,
+          executionContext,
+          endpointMetadata
+        );
+      case "handler" /* Handler */:
+        this.logger.error("Not implemented yet");
+        throw new import_common3.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);
+      }
     };
   }
-  isStackFormat(stack) {
-    if (!isString(stack) && !isUndefined(stack)) {
-      return false;
+  provideHandlerForStream(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;
+        }
+        await controllerInstance[endpointMetadata.classMethod](argument, reply);
+      } finally {
+        getServiceLocator().removeInstance(Request);
+        getServiceLocator().removeInstance(Reply);
+        getServiceLocator().removeInstance(ExecutionContextToken);
+      }
+    };
+  }
+  provideHandlerForMultipart(controller, executionContext, endpointMetadata) {
+    const config = endpointMetadata.config;
+    const requestSchema = config.requestSchema;
+    const shape = requestSchema._def.shape();
+    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 parts = request.parts();
+        const { query, params } = request;
+        const argument = {};
+        if (query && Object.keys(query).length > 0) {
+          argument.params = query;
+        }
+        if (params && Object.keys(params).length > 0) {
+          argument.urlParams = params;
+        }
+        const req = {};
+        for await (const part of parts) {
+          if (!shape[part.fieldname]) {
+            throw new import_common3.NaviosException(
+              `Invalid field name ${part.fieldname} for multipart request`
+            );
+          }
+          const schema = shape[part.fieldname];
+          if (part.type === "file") {
+            const file = new File([await part.toBuffer()], part.filename, {
+              type: part.mimetype
+            });
+            if (schema instanceof import_zod2.ZodArray) {
+              if (!req[part.fieldname]) {
+                req[part.fieldname] = [];
+              }
+              req[part.fieldname].push(file);
+            } else {
+              req[part.fieldname] = file;
+            }
+          } else {
+            if (schema instanceof import_zod2.ZodArray) {
+              if (!req[part.fieldname]) {
+                req[part.fieldname] = [];
+              }
+              req[part.fieldname].push(part.value);
+            } else {
+              req[part.fieldname] = part.value;
+            }
+          }
+        }
+        argument.data = requestSchema.parse(req);
+        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);
+      }
+    };
+  }
+};
+_init2 = __decoratorStart(null);
+_ControllerAdapterService = __decorateElement(_init2, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
+__runInitializers(_init2, 1, _ControllerAdapterService);
+var ControllerAdapterService = _ControllerAdapterService;
+
+// packages/core/src/services/module-loader.service.mts
+var _ModuleLoaderService_decorators, _init3;
+_ModuleLoaderService_decorators = [Injectable()];
+var _ModuleLoaderService = class _ModuleLoaderService {
+  logger = syncInject(Logger, {
+    context: _ModuleLoaderService.name
+  });
+  modulesMetadata = /* @__PURE__ */ new Map();
+  loadedModules = /* @__PURE__ */ new Map();
+  initialized = false;
+  async loadModules(appModule) {
+    if (this.initialized) {
+      return;
     }
-    return /^(.)+\n\s+at .+:\d+:\d+/.test(stack);
+    await this.traverseModules(appModule);
+    this.initialized = true;
   }
-  getColorByLogLevel(level) {
-    switch (level) {
-      case "debug":
-        return clc.magentaBright;
-      case "warn":
-        return clc.yellow;
-      case "error":
-        return clc.red;
-      case "verbose":
-        return clc.cyanBright;
-      case "fatal":
-        return clc.bold;
-      default:
-        return clc.green;
+  async traverseModules(module2, parentMetadata) {
+    const metadata = extractModuleMetadata(module2);
+    if (parentMetadata) {
+      this.mergeMetadata(metadata, parentMetadata);
+    }
+    const moduleName = module2.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 inject(module2);
+    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;
   }
 };
-_init = __decoratorStart(null);
-_ConsoleLogger = __decorateElement(_init, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
-__runInitializers(_init, 1, _ConsoleLogger);
-var ConsoleLogger = _ConsoleLogger;
+_init3 = __decoratorStart(null);
+_ModuleLoaderService = __decorateElement(_init3, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
+__runInitializers(_init3, 1, _ModuleLoaderService);
+var ModuleLoaderService = _ModuleLoaderService;
 
-// packages/core/src/logger/logger.factory.mts
-var import_zod2 = require("zod");
+// packages/core/src/tokens/execution-context.token.mts
+var ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+var ExecutionContextToken = InjectionToken.create(
+  ExecutionContextInjectionToken
+);
 
-// packages/core/src/logger/logger.service.mts
-var DEFAULT_LOGGER = new ConsoleLogger();
-var dateTimeFormatter2 = new Intl.DateTimeFormat(void 0, {
+// packages/core/src/tokens/reply.token.mts
+var ReplyInjectionToken = "ReplyInjectionToken";
+var Reply = InjectionToken.create(ReplyInjectionToken);
+
+// packages/core/src/tokens/request.token.mts
+var RequestInjectionToken = "RequestInjectionToken";
+var Request = InjectionToken.create(
+  RequestInjectionToken
+);
+
+// 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",
@@ -1535,1106 +1813,856 @@ var dateTimeFormatter2 = new Intl.DateTimeFormat(void 0, {
   day: "2-digit",
   month: "2-digit"
 });
-var _LoggerInstance_decorators, _init2;
-_LoggerInstance_decorators = [Injectable()];
-var _LoggerInstance = class _LoggerInstance {
-  constructor(context, options = {}) {
-    this.context = context;
-    this.options = options;
-  }
-  static staticInstanceRef = DEFAULT_LOGGER;
-  static logLevels;
-  localInstanceRef;
-  get localInstance() {
-    if (_LoggerInstance.staticInstanceRef === DEFAULT_LOGGER) {
-      return this.registerLocalInstanceRef();
-    } else if (_LoggerInstance.staticInstanceRef instanceof _LoggerInstance) {
-      const prototype = Object.getPrototypeOf(_LoggerInstance.staticInstanceRef);
-      if (prototype.constructor === _LoggerInstance) {
-        return this.registerLocalInstanceRef();
-      }
-    }
-    return _LoggerInstance.staticInstanceRef;
-  }
-  error(message, ...optionalParams) {
-    var _a;
-    optionalParams = this.context ? (optionalParams.length ? optionalParams : [void 0]).concat(
-      this.context
-    ) : optionalParams;
-    (_a = this.localInstance) == null ? void 0 : _a.error(message, ...optionalParams);
-  }
-  log(message, ...optionalParams) {
-    var _a;
-    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_a = this.localInstance) == null ? void 0 : _a.log(message, ...optionalParams);
-  }
-  warn(message, ...optionalParams) {
-    var _a;
-    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_a = this.localInstance) == null ? void 0 : _a.warn(message, ...optionalParams);
-  }
-  debug(message, ...optionalParams) {
-    var _a, _b;
-    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_b = (_a = this.localInstance) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
-  }
-  verbose(message, ...optionalParams) {
-    var _a, _b;
-    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_b = (_a = this.localInstance) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
-  }
-  fatal(message, ...optionalParams) {
-    var _a, _b;
-    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_b = (_a = this.localInstance) == null ? void 0 : _a.fatal) == null ? void 0 : _b.call(_a, message, ...optionalParams);
-  }
-  static error(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.error(message, ...optionalParams);
-  }
-  static log(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.log(message, ...optionalParams);
-  }
-  static warn(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.warn(message, ...optionalParams);
-  }
-  static debug(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
-  }
-  static verbose(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
-  }
-  static fatal(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.fatal) == null ? void 0 : _b.call(_a, message, ...optionalParams);
-  }
-  static getTimestamp() {
-    return dateTimeFormatter2.format(Date.now());
-  }
-  static overrideLogger(logger) {
-    var _a, _b;
-    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;
+var _ConsoleLogger_decorators, _init4;
+_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;
+  /**
+   * Request ID (if enabled).
+   */
+  requestId = null;
+  /**
+   * 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;
     }
-  }
-  static isLevelEnabled(level) {
-    const logLevels = _LoggerInstance.logLevels;
-    return isLogLevelEnabled(level, logLevels);
-  }
-  registerLocalInstanceRef() {
-    var _a;
-    if (this.localInstanceRef) {
-      return this.localInstanceRef;
+    if (opts == null ? void 0 : opts.requestId) {
+      const locator = getServiceLocator();
+      locator.getEventBus().on(locator.getInstanceIdentifier(Request, void 0), "create", () => {
+        const request = locator.getSyncInstance(Request, void 0);
+        this.requestId = (request == null ? void 0 : request.id) ?? null;
+      });
+      locator.getEventBus().on(
+        locator.getInstanceIdentifier(Request, void 0),
+        "destroy",
+        () => {
+          this.requestId = null;
+        }
+      );
     }
-    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);
+  log(message, ...optionalParams) {
+    if (!this.isLevelEnabled("log")) {
+      return;
     }
-    this.logger.fatal(message, ...optionalParams);
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "log");
   }
   error(message, ...optionalParams) {
-    this.logger.error(message, ...optionalParams);
+    if (!this.isLevelEnabled("error")) {
+      return;
+    }
+    const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
+    this.printMessages(messages, context, "error", "stderr", stack);
+    this.printStackTrace(stack);
   }
   warn(message, ...optionalParams) {
-    this.logger.warn(message, ...optionalParams);
-  }
-  info() {
+    if (!this.isLevelEnabled("warn")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "warn");
   }
   debug(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
-  }
-  trace(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.logger).verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
-  }
-  silent() {
-  }
-  child(options) {
-    const keys = Object.keys(options);
-    let newContext = this.logger["context"] ?? "";
-    if (keys.length > 1) {
-      newContext = `${this.logger["context"] ?? ""}:${JSON.stringify(options)}`;
+    if (!this.isLevelEnabled("debug")) {
+      return;
     }
-    return new _PinoWrapper(
-      // @ts-expect-error We don't need to support this in the current version
-      new LoggerInstance(newContext, this.logger["options"])
-    );
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "debug");
   }
-  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");
+  verbose(message, ...optionalParams) {
+    if (!this.isLevelEnabled("verbose")) {
+      return;
     }
-    return "warn";
-  }
-};
-
-// packages/core/src/config/config.service.mts
-var import_common3 = require("@navios/common");
-var ConfigServiceInstance = class {
-  constructor(config = {}, logger) {
-    this.config = config;
-    this.logger = logger;
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "verbose");
   }
-  getConfig() {
-    return this.config;
+  fatal(message, ...optionalParams) {
+    if (!this.isLevelEnabled("fatal")) {
+      return;
+    }
+    const { messages, context } = this.getContextAndMessagesToPrint([
+      message,
+      ...optionalParams
+    ]);
+    this.printMessages(messages, context, "fatal");
   }
-  get(key) {
-    var _a, _b;
-    try {
-      const parts = String(key).split(".");
-      let value = this.config;
-      for (const part of parts) {
-        if (value === null || value === void 0 || typeof value !== "object") {
-          return null;
-        }
-        value = value[part];
-      }
-      return value ?? null;
-    } catch (error) {
-      (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(
-        _a,
-        `Failed to get config value for key ${String(key)}`,
-        error
-      );
-      return null;
+  /**
+   * Set log levels
+   * @param levels log levels
+   */
+  setLogLevels(levels) {
+    if (!this.options) {
+      this.options = {};
     }
+    this.options.logLevels = levels;
   }
-  getOrDefault(key, defaultValue) {
-    const value = this.get(key);
-    return value !== null ? value : defaultValue;
+  /**
+   * Set logger context
+   * @param context context
+   */
+  setContext(context) {
+    this.context = context;
   }
-  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_common3.NaviosException(message);
-    }
-    return value;
+  /**
+   * Resets the logger context to the value that was passed in the constructor.
+   */
+  resetContext() {
+    this.context = this.originalContext;
   }
-};
-
-// packages/core/src/config/config.provider.mts
-var ConfigProviderOptions = import_zod3.z.object({
-  load: import_zod3.z.function()
-});
-var ConfigProvider = InjectionToken.create(ConfigServiceInstance, ConfigProviderOptions);
-var _ConfigProviderFactory_decorators, _init4;
-_ConfigProviderFactory_decorators = [Injectable({
-  token: ConfigProvider,
-  type: "Factory" /* Factory */
-})];
-var ConfigProviderFactory = class {
-  logger = syncInject(Logger, {
-    context: "ConfigService"
-  });
-  async create(ctx, args) {
-    const { load } = args;
-    const logger = this.logger;
-    try {
-      const config = await load();
-      return new ConfigServiceInstance(config, logger);
-    } catch (error) {
-      logger.error("Error loading config", error);
-      throw error;
-    }
+  isLevelEnabled(level) {
+    var _a;
+    const logLevels = (_a = this.options) == null ? void 0 : _a.logLevels;
+    return isLogLevelEnabled(level, logLevels);
   }
-};
-_init4 = __decoratorStart(null);
-ConfigProviderFactory = __decorateElement(_init4, 0, "ConfigProviderFactory", _ConfigProviderFactory_decorators, ConfigProviderFactory);
-__runInitializers(_init4, 1, ConfigProviderFactory);
-function provideConfig(options) {
-  return InjectionToken.bound(ConfigProvider, options);
-}
-
-// packages/core/src/metadata/endpoint.metadata.mts
-var EndpointMetadataKey = Symbol("EndpointMetadataKey");
-var EndpointType = /* @__PURE__ */ ((EndpointType2) => {
-  EndpointType2["Unknown"] = "unknown";
-  EndpointType2["Endpoint"] = "endpoint";
-  EndpointType2["Stream"] = "stream";
-  EndpointType2["Multipart"] = "multipart";
-  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];
-    }
+  getTimestamp() {
+    return dateTimeFormatter.format(Date.now());
   }
-  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;
+  printMessages(messages, context = "", logLevel = "log", writeStreamType, errorStack) {
+    messages.forEach((message) => {
+      if (this.options.json) {
+        this.printAsJson(message, {
+          context,
+          logLevel,
+          writeStreamType,
+          errorStack
+        });
+        return;
       }
-    }
+      const pidMessage = this.formatPid(process.pid);
+      const contextMessage = this.formatContext(context);
+      const timestampDiff = this.updateAndGetTimestampDiff();
+      const formattedLogLevel = logLevel.toUpperCase().padStart(7, " ");
+      const formattedMessage = this.formatMessage(
+        logLevel,
+        message,
+        pidMessage,
+        formattedLogLevel,
+        contextMessage,
+        timestampDiff
+      );
+      process[writeStreamType ?? "stdout"].write(formattedMessage);
+    });
   }
-  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;
+  printAsJson(message, options) {
+    const logObject = {
+      level: options.logLevel,
+      pid: process.pid,
+      timestamp: Date.now(),
+      message
+    };
+    if (options.context) {
+      logObject.context = options.context;
     }
+    if (options.errorStack) {
+      logObject.stack = options.errorStack;
+    }
+    if (this.options.requestId && this.requestId) {
+      logObject.requestId = this.requestId;
+    }
+    const formattedMessage = !this.options.colors && this.inspectOptions.compact === true ? JSON.stringify(logObject, this.stringifyReplacer) : (0, import_util.inspect)(logObject, this.inspectOptions);
+    process[options.writeStreamType ?? "stdout"].write(`${formattedMessage}
+`);
   }
-  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."
-    );
+  formatPid(pid) {
+    return `[${this.options.prefix}] ${pid} - `;
   }
-  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;
+  formatContext(context) {
+    if (!context) {
+      return "";
     }
+    context = `[${context}] `;
+    return this.options.colors ? yellow(context) : context;
   }
-  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.`
-    );
+  formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
+    const output = this.stringifyMessage(message, logLevel);
+    pidMessage = this.colorize(pidMessage, logLevel);
+    formattedLogLevel = this.colorize(formattedLogLevel, logLevel);
+    return `${pidMessage}${this.getRequestId()}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}
+`;
   }
-  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."
-      );
+  getRequestId() {
+    if (this.options.requestId && this.requestId) {
+      return `(${this.colorize(this.requestId, "log")}) `;
     }
-    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 "";
+  }
+  stringifyMessage(message, logLevel) {
+    if (isFunction(message)) {
+      const messageAsStr = Function.prototype.toString.call(message);
+      const isClass = messageAsStr.startsWith("class ");
+      if (isClass) {
+        return this.stringifyMessage(message.name, logLevel);
       }
+      return this.stringifyMessage(message(), logLevel);
     }
-    return Injectable({
-      token,
-      type: "Class" /* Class */,
-      scope: "Instance" /* Instance */
-    })(target, context);
-  };
-}
-
-// packages/core/src/decorators/endpoint.decorator.mts
-var import_zod4 = require("zod");
-function Endpoint(endpoint) {
-  return (target, context) => {
-    if (typeof target !== "function") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on functions."
-      );
+    if (typeof message === "string") {
+      return this.colorize(message, logLevel);
     }
-    if (context.kind !== "method") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on methods."
-      );
+    const outputText = (0, import_util.inspect)(message, this.inspectOptions);
+    if (isPlainObject(message)) {
+      return `Object(${Object.keys(message).length}) ${outputText}`;
     }
-    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 = "endpoint" /* Endpoint */;
-      endpointMetadata.classMethod = target.name;
-      endpointMetadata.httpMethod = config.method;
-      endpointMetadata.url = config.url;
+    if (Array.isArray(message)) {
+      return `Array(${message.length}) ${outputText}`;
     }
-    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.");
+    return outputText;
+  }
+  colorize(message, logLevel) {
+    if (!this.options.colors || this.options.json) {
+      return message;
     }
-    const metadata = getEndpointMetadata(target, context);
-    if (metadata.type === "stream" /* Stream */) {
-      throw new Error(
-        "[Navios] HttpCode decorator cannot be used on stream endpoints."
-      );
+    const color = this.getColorByLogLevel(logLevel);
+    return color(message);
+  }
+  printStackTrace(stack) {
+    if (!stack || this.options.json) {
+      return;
     }
-    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."
-      );
+    process.stderr.write(`${stack}
+`);
+  }
+  updateAndGetTimestampDiff() {
+    var _a;
+    const includeTimestamp = _ConsoleLogger.lastTimestampAt && ((_a = this.options) == null ? void 0 : _a.timestamp);
+    const result = includeTimestamp ? this.formatTimestampDiff(Date.now() - _ConsoleLogger.lastTimestampAt) : "";
+    _ConsoleLogger.lastTimestampAt = Date.now();
+    return result;
+  }
+  formatTimestampDiff(timestampDiff) {
+    const formattedDiff = ` +${timestampDiff}ms`;
+    return this.options.colors ? yellow(formattedDiff) : formattedDiff;
+  }
+  getInspectOptions() {
+    let breakLength = this.options.breakLength;
+    if (typeof breakLength === "undefined") {
+      breakLength = this.options.colors ? this.options.compact ? Infinity : void 0 : this.options.compact === false ? void 0 : Infinity;
     }
-    const metadata = getEndpointMetadata(target, context);
-    if (metadata.type === "stream" /* Stream */) {
-      throw new Error(
-        "[Navios] HttpCode decorator cannot be used on stream endpoints."
-      );
+    const inspectOptions = {
+      depth: this.options.depth ?? DEFAULT_DEPTH,
+      sorted: this.options.sorted,
+      showHidden: this.options.showHidden,
+      compact: this.options.compact ?? (this.options.json ? true : false),
+      colors: this.options.colors,
+      breakLength
+    };
+    if (this.options.maxArrayLength) {
+      inspectOptions.maxArrayLength = this.options.maxArrayLength;
     }
-    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.");
+    if (this.options.maxStringLength) {
+      inspectOptions.maxStringLength = this.options.maxStringLength;
     }
-    const token = InjectionToken.create(target);
-    const moduleMetadata = getModuleMetadata(target, context);
-    if (metadata.controllers) {
-      for (const controller of metadata.controllers) {
-        moduleMetadata.controllers.add(controller);
-      }
+    return inspectOptions;
+  }
+  stringifyReplacer(key, value) {
+    if (typeof value === "bigint") {
+      return value.toString();
     }
-    if (metadata.imports) {
-      for (const importedModule of metadata.imports) {
-        moduleMetadata.imports.add(importedModule);
-      }
+    if (typeof value === "symbol") {
+      return value.toString();
     }
-    if (metadata.guards) {
-      for (const guard of Array.from(metadata.guards).reverse()) {
-        moduleMetadata.guards.add(guard);
-      }
+    if (value instanceof Map || value instanceof Set || value instanceof Error) {
+      return `${(0, import_util.inspect)(value, this.inspectOptions)}`;
     }
-    return Injectable({
-      token,
-      type: "Class" /* Class */,
-      scope: "Singleton" /* Singleton */
-    })(target, context);
-  };
-}
-
-// packages/core/src/decorators/multipart.decorator.mts
-var import_zod5 = require("zod");
-function Multipart(endpoint) {
-  return (target, context) => {
-    if (typeof target !== "function") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on functions."
-      );
+    return value;
+  }
+  getContextAndMessagesToPrint(args) {
+    if ((args == null ? void 0 : args.length) <= 1) {
+      return { messages: args, context: this.context };
     }
-    if (context.kind !== "method") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on methods."
-      );
+    const lastElement = args[args.length - 1];
+    const isContext = isString(lastElement);
+    if (!isContext) {
+      return { messages: args, context: this.context };
     }
-    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 = "multipart" /* Multipart */;
-      endpointMetadata.classMethod = target.name;
-      endpointMetadata.httpMethod = config.method;
-      endpointMetadata.url = config.url;
+    return {
+      context: lastElement,
+      messages: args.slice(0, args.length - 1)
+    };
+  }
+  getContextAndStackAndMessagesToPrint(args) {
+    if (args.length === 2) {
+      return this.isStackFormat(args[1]) ? {
+        messages: [args[0]],
+        stack: args[1],
+        context: this.context
+      } : {
+        messages: [args[0]],
+        context: args[1]
+      };
     }
-    return target;
-  };
-}
-
-// packages/core/src/decorators/stream.decorator.mts
-function Stream(endpoint) {
-  return (target, context) => {
-    if (typeof target !== "function") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on functions."
-      );
+    const { messages, context } = this.getContextAndMessagesToPrint(args);
+    if ((messages == null ? void 0 : messages.length) <= 1) {
+      return { messages, context };
     }
-    if (context.kind !== "method") {
-      throw new Error(
-        "[Navios] Endpoint decorator can only be used on methods."
-      );
+    const lastElement = messages[messages.length - 1];
+    const isStack = isString(lastElement);
+    if (!isStack && !isUndefined(lastElement)) {
+      return { messages, context };
     }
-    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 = "stream" /* Stream */;
-      endpointMetadata.classMethod = target.name;
-      endpointMetadata.httpMethod = config.method;
-      endpointMetadata.url = config.url;
+    return {
+      stack: lastElement,
+      messages: messages.slice(0, messages.length - 1),
+      context
+    };
+  }
+  isStackFormat(stack) {
+    if (!isString(stack) && !isUndefined(stack)) {
+      return false;
     }
-    return target;
-  };
-}
+    return /^(.)+\n\s+at .+:\d+:\d+/.test(stack);
+  }
+  getColorByLogLevel(level) {
+    switch (level) {
+      case "debug":
+        return clc.magentaBright;
+      case "warn":
+        return clc.yellow;
+      case "error":
+        return clc.red;
+      case "verbose":
+        return clc.cyanBright;
+      case "fatal":
+        return clc.bold;
+      default:
+        return clc.green;
+    }
+  }
+};
+_init4 = __decoratorStart(null);
+_ConsoleLogger = __decorateElement(_init4, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
+__runInitializers(_init4, 1, _ConsoleLogger);
+var ConsoleLogger = _ConsoleLogger;
 
-// 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);
+// packages/core/src/logger/logger.factory.mts
+var import_zod3 = require("zod");
+
+// packages/core/src/logger/logger.service.mts
+var DEFAULT_LOGGER = new ConsoleLogger();
+var dateTimeFormatter2 = new Intl.DateTimeFormat(void 0, {
+  year: "numeric",
+  hour: "numeric",
+  minute: "numeric",
+  second: "numeric",
+  day: "2-digit",
+  month: "2-digit"
+});
+var _LoggerInstance_decorators, _init5;
+_LoggerInstance_decorators = [Injectable()];
+var _LoggerInstance = class _LoggerInstance {
+  constructor(context, options = {}) {
+    this.context = context;
+    this.options = options;
+  }
+  static staticInstanceRef = DEFAULT_LOGGER;
+  static logLevels;
+  localInstanceRef;
+  get localInstance() {
+    if (_LoggerInstance.staticInstanceRef === DEFAULT_LOGGER) {
+      return this.registerLocalInstanceRef();
+    } else if (_LoggerInstance.staticInstanceRef instanceof _LoggerInstance) {
+      const prototype = Object.getPrototypeOf(_LoggerInstance.staticInstanceRef);
+      if (prototype.constructor === _LoggerInstance) {
+        return this.registerLocalInstanceRef();
       }
+    }
+    return _LoggerInstance.staticInstanceRef;
+  }
+  error(message, ...optionalParams) {
+    var _a;
+    optionalParams = this.context ? (optionalParams.length ? optionalParams : [void 0]).concat(
+      this.context
+    ) : optionalParams;
+    (_a = this.localInstance) == null ? void 0 : _a.error(message, ...optionalParams);
+  }
+  log(message, ...optionalParams) {
+    var _a;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_a = this.localInstance) == null ? void 0 : _a.log(message, ...optionalParams);
+  }
+  warn(message, ...optionalParams) {
+    var _a;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_a = this.localInstance) == null ? void 0 : _a.warn(message, ...optionalParams);
+  }
+  debug(message, ...optionalParams) {
+    var _a, _b;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_b = (_a = this.localInstance) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  verbose(message, ...optionalParams) {
+    var _a, _b;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_b = (_a = this.localInstance) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  fatal(message, ...optionalParams) {
+    var _a, _b;
+    optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
+    (_b = (_a = this.localInstance) == null ? void 0 : _a.fatal) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  static error(message, ...optionalParams) {
+    var _a;
+    (_a = this.staticInstanceRef) == null ? void 0 : _a.error(message, ...optionalParams);
+  }
+  static log(message, ...optionalParams) {
+    var _a;
+    (_a = this.staticInstanceRef) == null ? void 0 : _a.log(message, ...optionalParams);
+  }
+  static warn(message, ...optionalParams) {
+    var _a;
+    (_a = this.staticInstanceRef) == null ? void 0 : _a.warn(message, ...optionalParams);
+  }
+  static debug(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  static verbose(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  static fatal(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.fatal) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+  }
+  static getTimestamp() {
+    return dateTimeFormatter2.format(Date.now());
+  }
+  static overrideLogger(logger) {
+    var _a, _b;
+    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 {
-      throw new Error(
-        "[Navios] @UseGuards decorator can only be used on classes or methods."
-      );
+      this.staticInstanceRef = void 0;
     }
-    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);
+  static isLevelEnabled(level) {
+    const logLevels = _LoggerInstance.logLevels;
+    return isLogLevelEnabled(level, logLevels);
   }
-};
-
-// packages/core/src/exceptions/forbidden.exception.mts
-var ForbiddenException = class extends HttpException {
-  constructor(message) {
-    super(403, message);
+  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;
   }
 };
+_init5 = __decoratorStart(null);
+_LoggerInstance = __decorateElement(_init5, 0, "LoggerInstance", _LoggerInstance_decorators, _LoggerInstance);
+__runInitializers(_init5, 1, _LoggerInstance);
+var LoggerInstance = _LoggerInstance;
 
-// packages/core/src/exceptions/internal-server-error.exception.mts
-var InternalServerErrorException = class extends HttpException {
-  constructor(message, error) {
-    super(500, message, error);
+// packages/core/src/logger/logger.factory.mts
+var LoggerInjectionToken = "LoggerInjectionToken";
+var LoggerOptions = import_zod3.z.object({
+  context: import_zod3.z.string().optional(),
+  options: import_zod3.z.object({
+    timestamp: import_zod3.z.boolean().optional()
+  }).optional()
+}).optional();
+var Logger = InjectionToken.create(LoggerInjectionToken, LoggerOptions);
+var _LoggerFactory_decorators, _init6;
+_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);
   }
 };
+_init6 = __decoratorStart(null);
+LoggerFactory = __decorateElement(_init6, 0, "LoggerFactory", _LoggerFactory_decorators, LoggerFactory);
+__runInitializers(_init6, 1, LoggerFactory);
 
-// 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/logger/pino-wrapper.mts
+var PinoWrapper = class _PinoWrapper {
+  constructor(logger) {
+    this.logger = logger;
   }
-};
-
-// packages/core/src/exceptions/unauthorized.exception.mts
-var UnauthorizedException = class extends HttpException {
-  constructor(message, error) {
-    super(401, message, error);
+  fatal(message, ...optionalParams) {
+    if (this.logger.fatal === void 0) {
+      return this.error(message, ...optionalParams);
+    }
+    this.logger.fatal(message, ...optionalParams);
   }
-};
-
-// packages/core/src/exceptions/conflict.exception.mts
-var ConflictException = class extends HttpException {
-  constructor(message, error) {
-    super(409, message, error);
+  error(message, ...optionalParams) {
+    this.logger.error(message, ...optionalParams);
   }
-};
-
-// packages/core/src/services/controller-adapter.service.mts
-var import_common4 = require("@navios/common");
-var import_zod6 = require("zod");
-
-// packages/core/src/tokens/application.token.mts
-var ApplicationInjectionToken = "ApplicationInjectionToken";
-var Application = InjectionToken.create(
-  ApplicationInjectionToken
-);
-
-// packages/core/src/tokens/execution-context.token.mts
-var ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
-var ExecutionContextToken = InjectionToken.create(
-  ExecutionContextInjectionToken
-);
-
-// packages/core/src/tokens/reply.token.mts
-var ReplyInjectionToken = "ReplyInjectionToken";
-var Reply = InjectionToken.create(ReplyInjectionToken);
-
-// packages/core/src/tokens/request.token.mts
-var RequestInjectionToken = "RequestInjectionToken";
-var Request = InjectionToken.create(
-  RequestInjectionToken
-);
-
-// packages/core/src/services/execution-context.mts
-var ExecutionContext2 = class {
-  constructor(module2, controller, handler) {
-    this.module = module2;
-    this.controller = controller;
-    this.handler = handler;
+  warn(message, ...optionalParams) {
+    this.logger.warn(message, ...optionalParams);
   }
-  request;
-  reply;
-  getModule() {
-    return this.module;
+  info() {
   }
-  getController() {
-    return this.controller;
+  debug(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
   }
-  getHandler() {
-    return this.handler;
+  trace(message, ...optionalParams) {
+    var _a, _b;
+    (_b = (_a = this.logger).verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
   }
-  getRequest() {
-    if (!this.request) {
-      throw new Error(
-        "[Navios] Request is not set. Make sure to set it before using it."
-      );
-    }
-    return this.request;
+  silent() {
   }
-  getReply() {
-    if (!this.reply) {
-      throw new Error(
-        "[Navios] Reply is not set. Make sure to set it before using it."
-      );
+  child(options) {
+    const keys = Object.keys(options);
+    let newContext = this.logger["context"] ?? "";
+    if (keys.length > 1) {
+      newContext = `${this.logger["context"] ?? ""}:${JSON.stringify(options)}`;
     }
-    return this.reply;
-  }
-  provideRequest(request) {
-    this.request = request;
+    return new _PinoWrapper(
+      // @ts-expect-error We don't need to support this in the current version
+      new LoggerInstance(newContext, this.logger["options"])
+    );
   }
-  provideReply(reply) {
-    this.reply = reply;
+  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";
   }
 };
 
-// packages/core/src/services/guard-runner.service.mts
-var _GuardRunnerService_decorators, _init5;
-_GuardRunnerService_decorators = [Injectable()];
-var GuardRunnerService = class {
-  async runGuards(allGuards, executionContext) {
-    let canActivate = true;
-    for (const guard of Array.from(allGuards).reverse()) {
-      const guardInstance = await 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;
+// packages/core/src/config/config.service.mts
+var import_common4 = require("@navios/common");
+var ConfigServiceInstance = class {
+  constructor(config = {}, logger) {
+    this.config = config;
+    this.logger = logger;
   }
-  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);
+  getConfig() {
+    return this.config;
+  }
+  get(key) {
+    var _a, _b;
+    try {
+      const parts = String(key).split(".");
+      let value = this.config;
+      for (const part of parts) {
+        if (value === null || value === void 0 || typeof value !== "object") {
+          return null;
+        }
+        value = value[part];
       }
+      return value ?? null;
+    } catch (error) {
+      (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(
+        _a,
+        `Failed to get config value for key ${String(key)}`,
+        error
+      );
+      return null;
     }
-    return guards;
+  }
+  getOrDefault(key, defaultValue) {
+    const value = this.get(key);
+    return value !== null ? value : defaultValue;
+  }
+  getOrThrow(key, errorMessage) {
+    const value = this.get(key);
+    if (value === null) {
+      const message = errorMessage || `Configuration value for key "${String(key)}" is not defined`;
+      this.logger.error(message);
+      throw new import_common4.NaviosException(message);
+    }
+    return value;
   }
 };
-_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, _init6;
-_ControllerAdapterService_decorators = [Injectable()];
-var _ControllerAdapterService = class _ControllerAdapterService {
-  guardRunner = syncInject(GuardRunnerService);
+// packages/core/src/config/config.provider.mts
+var ConfigProviderOptions = import_zod4.z.object({
+  load: import_zod4.z.function()
+});
+var ConfigProvider = InjectionToken.create(ConfigServiceInstance, ConfigProviderOptions);
+var _ConfigProviderFactory_decorators, _init7;
+_ConfigProviderFactory_decorators = [Injectable({
+  token: ConfigProvider,
+  type: "Factory" /* Factory */
+})];
+var ConfigProviderFactory = class {
   logger = syncInject(Logger, {
-    context: _ControllerAdapterService.name
+    context: "ConfigService"
   });
-  setupController(controller, instance, moduleMetadata) {
-    const controllerMetadata = extractControllerMetadata(controller);
-    for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod } = endpoint;
-      if (!url) {
-        throw new Error(
-          `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`
-        );
-      }
-      const executionContext = new ExecutionContext2(
-        moduleMetadata,
-        controllerMetadata,
-        endpoint
-      );
-      instance.withTypeProvider().route({
-        method: httpMethod,
-        url: url.replaceAll("$", ":"),
-        schema: this.provideSchemaForConfig(endpoint),
-        preHandler: this.providePreHandler(executionContext),
-        handler: this.provideHandler(controller, executionContext, endpoint)
-      });
-      this.logger.debug(
-        `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`
-      );
+  async create(ctx, args) {
+    const { load } = args;
+    const logger = this.logger;
+    try {
+      const config = await load();
+      return new ConfigServiceInstance(config, logger);
+    } catch (error) {
+      logger.error("Error loading config", error);
+      throw error;
     }
   }
-  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
+};
+_init7 = __decoratorStart(null);
+ConfigProviderFactory = __decorateElement(_init7, 0, "ConfigProviderFactory", _ConfigProviderFactory_decorators, ConfigProviderFactory);
+__runInitializers(_init7, 1, ConfigProviderFactory);
+function provideConfig(options) {
+  return InjectionToken.bound(ConfigProvider, options);
+}
+
+// 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."
       );
-      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;
+    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);
+        }
+      }
     }
-    if (requestSchema && endpointMetadata.type !== "multipart" /* Multipart */) {
-      schema.body = requestSchema;
+    return Injectable({
+      token,
+      type: "Class" /* Class */,
+      scope: "Instance" /* Instance */
+    })(target, context);
+  };
+}
+
+// packages/core/src/decorators/endpoint.decorator.mts
+var import_zod5 = require("zod");
+function Endpoint(endpoint) {
+  return (target, context) => {
+    if (typeof target !== "function") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on functions."
+      );
     }
-    if (responseSchema) {
-      schema.response = {
-        200: responseSchema
-      };
+    if (context.kind !== "method") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on methods."
+      );
     }
-    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_common4.NaviosException("Unknown endpoint type");
-      case "endpoint" /* Endpoint */:
-        return this.provideHandlerForConfig(
-          controller,
-          executionContext,
-          endpointMetadata
-        );
-      case "stream" /* Stream */:
-        return this.provideHandlerForStream(
-          controller,
-          executionContext,
-          endpointMetadata
-        );
-      case "multipart" /* Multipart */:
-        return this.provideHandlerForMultipart(
-          controller,
-          executionContext,
-          endpointMetadata
+    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.`
         );
-      case "handler" /* Handler */:
-        this.logger.error("Not implemented yet");
-        throw new import_common4.NaviosException("Not implemented yet");
+      }
+      endpointMetadata.config = config;
+      endpointMetadata.type = "endpoint" /* Endpoint */;
+      endpointMetadata.classMethod = target.name;
+      endpointMetadata.httpMethod = config.method;
+      endpointMetadata.url = config.url;
     }
-  }
-  provideHandlerForConfig(controller, executionContext, endpointMetadata) {
-    return async (request, reply) => {
-      getServiceLocator().registerInstance(Request, request);
-      getServiceLocator().registerInstance(Reply, reply);
-      getServiceLocator().registerInstance(
-        ExecutionContextToken,
-        executionContext
+    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.");
+    }
+    const metadata = getEndpointMetadata(target, context);
+    if (metadata.type === "stream" /* Stream */) {
+      throw new Error(
+        "[Navios] HttpCode decorator cannot be used on stream endpoints."
       );
-      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);
-      }
-    };
-  }
-  provideHandlerForStream(controller, executionContext, endpointMetadata) {
-    return async (request, reply) => {
-      getServiceLocator().registerInstance(Request, request);
-      getServiceLocator().registerInstance(Reply, reply);
-      getServiceLocator().registerInstance(
-        ExecutionContextToken,
-        executionContext
+    }
+    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."
+      );
+    }
+    const metadata = getEndpointMetadata(target, context);
+    if (metadata.type === "stream" /* Stream */) {
+      throw new Error(
+        "[Navios] HttpCode decorator cannot be used on stream endpoints."
       );
-      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;
-        }
-        await controllerInstance[endpointMetadata.classMethod](argument, reply);
-      } finally {
-        getServiceLocator().removeInstance(Request);
-        getServiceLocator().removeInstance(Reply);
-        getServiceLocator().removeInstance(ExecutionContextToken);
+    }
+    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);
       }
-    };
-  }
-  provideHandlerForMultipart(controller, executionContext, endpointMetadata) {
-    const config = endpointMetadata.config;
-    const requestSchema = config.requestSchema;
-    const shape = requestSchema._def.shape();
-    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 parts = request.parts();
-        const { query, params } = request;
-        const argument = {};
-        if (query && Object.keys(query).length > 0) {
-          argument.params = query;
-        }
-        if (params && Object.keys(params).length > 0) {
-          argument.urlParams = params;
-        }
-        const req = {};
-        for await (const part of parts) {
-          if (!shape[part.fieldname]) {
-            throw new import_common4.NaviosException(
-              `Invalid field name ${part.fieldname} for multipart request`
-            );
-          }
-          const schema = shape[part.fieldname];
-          if (part.type === "file") {
-            const file = new File([await part.toBuffer()], part.filename, {
-              type: part.mimetype
-            });
-            if (schema instanceof import_zod6.ZodArray) {
-              if (!req[part.fieldname]) {
-                req[part.fieldname] = [];
-              }
-              req[part.fieldname].push(file);
-            } else {
-              req[part.fieldname] = file;
-            }
-          } else {
-            if (schema instanceof import_zod6.ZodArray) {
-              if (!req[part.fieldname]) {
-                req[part.fieldname] = [];
-              }
-              req[part.fieldname].push(part.value);
-            } else {
-              req[part.fieldname] = part.value;
-            }
-          }
-        }
-        argument.body = requestSchema.parse(req);
-        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);
+    }
+    if (metadata.imports) {
+      for (const importedModule of metadata.imports) {
+        moduleMetadata.imports.add(importedModule);
       }
-    };
-  }
-};
-_init6 = __decoratorStart(null);
-_ControllerAdapterService = __decorateElement(_init6, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
-__runInitializers(_init6, 1, _ControllerAdapterService);
-var ControllerAdapterService = _ControllerAdapterService;
+    }
+    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/services/module-loader.service.mts
-var _ModuleLoaderService_decorators, _init7;
-_ModuleLoaderService_decorators = [Injectable()];
-var _ModuleLoaderService = class _ModuleLoaderService {
-  logger = syncInject(Logger, {
-    context: _ModuleLoaderService.name
-  });
-  modulesMetadata = /* @__PURE__ */ new Map();
-  loadedModules = /* @__PURE__ */ new Map();
-  initialized = false;
-  async loadModules(appModule) {
-    if (this.initialized) {
-      return;
+// packages/core/src/decorators/multipart.decorator.mts
+var import_zod6 = require("zod");
+function Multipart(endpoint) {
+  return (target, context) => {
+    if (typeof target !== "function") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on functions."
+      );
     }
-    await this.traverseModules(appModule);
-    this.initialized = true;
-  }
-  async traverseModules(module2, parentMetadata) {
-    const metadata = extractModuleMetadata(module2);
-    if (parentMetadata) {
-      this.mergeMetadata(metadata, parentMetadata);
+    if (context.kind !== "method") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on methods."
+      );
     }
-    const moduleName = module2.name;
-    if (this.modulesMetadata.has(moduleName)) {
-      return;
+    const config = endpoint.config;
+    if (context.metadata) {
+      let endpointMetadata = getEndpointMetadata(target, context);
+      if (endpointMetadata.config && endpointMetadata.config.url) {
+        throw new Error(
+          `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`
+        );
+      }
+      endpointMetadata.config = config;
+      endpointMetadata.type = "multipart" /* Multipart */;
+      endpointMetadata.classMethod = target.name;
+      endpointMetadata.httpMethod = config.method;
+      endpointMetadata.url = config.url;
     }
-    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 inject(module2);
-    if (instance.onModuleInit) {
-      await instance.onModuleInit();
+    return target;
+  };
+}
+
+// packages/core/src/decorators/stream.decorator.mts
+function Stream(endpoint) {
+  return (target, context) => {
+    if (typeof target !== "function") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on functions."
+      );
     }
-    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 (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 = "stream" /* Stream */;
+      endpointMetadata.classMethod = target.name;
+      endpointMetadata.httpMethod = config.method;
+      endpointMetadata.url = config.url;
     }
-    if (parentMetadata.customAttributes) {
-      for (const [key, value] of parentMetadata.customAttributes) {
-        if (metadata.customAttributes.has(key)) {
-          continue;
-        }
-        metadata.customAttributes.set(key, value);
+    return target;
+  };
+}
+
+// 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."
+      );
     }
-  }
-  getAllModules() {
-    return this.modulesMetadata;
-  }
-  dispose() {
-    this.modulesMetadata.clear();
-    this.loadedModules.clear();
-    this.initialized = false;
-  }
-};
-_init7 = __decoratorStart(null);
-_ModuleLoaderService = __decorateElement(_init7, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
-__runInitializers(_init7, 1, _ModuleLoaderService);
-var ModuleLoaderService = _ModuleLoaderService;
+    return target;
+  };
+}
 
 // packages/core/src/attribute.factory.mts
 var AttributeFactory = class {