@navios/core 0.1.14 → 0.2.0

package/dist/index.js

@@ -5,15 +5,15 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : Symbol.for("Symbol." + name2);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -23,6 +23,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -35,35 +36,35 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var __decoratorStart = (base) => [, , , __create((base == null ? void 0 : base[__knownSymbol("metadata")]) ?? null)];
 var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
 var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name2, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name: name2, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
 var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
 var __runInitializers = (array, flags, self, value) => {
   for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
   return value;
 };
-var __decorateElement = (array, flags, name2, decorators, target, extra) => {
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
   var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
   var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
   var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
-  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name2]() {
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
     return __privateGet(this, extra);
-  }, set [name2](x) {
+  }, set [name](x) {
     return __privateSet(this, extra, x);
-  } }, name2));
-  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name2) : __name(target, name2);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
   for (var i = decorators.length - 1; i >= 0; i--) {
-    ctx = __decoratorContext(k, name2, done = {}, array[3], extraInitializers);
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
     if (k) {
-      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name2 in x };
-      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name2];
-      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name2] = y;
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
     }
     it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
     if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
     else if (typeof it !== "object" || it === null) __typeError("Object expected");
     else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
   }
-  return k || __decoratorMetadata(array, target), desc && __defProp(target, name2, desc), p ? k ^ 4 ? extra : desc : target;
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
@@ -77,7 +78,6 @@ __export(src_exports, {
   Application: () => Application,
   AttributeFactory: () => AttributeFactory,
   BadRequestException: () => BadRequestException,
-  BoundInjectionToken: () => BoundInjectionToken,
   ConfigProvider: () => ConfigProvider,
   ConfigProviderFactory: () => ConfigProviderFactory,
   ConfigProviderOptions: () => ConfigProviderOptions,
@@ -88,29 +88,17 @@ __export(src_exports, {
   ControllerAdapterService: () => ControllerAdapterService,
   ControllerMetadataKey: () => ControllerMetadataKey,
   Endpoint: () => Endpoint,
+  EndpointAdapterService: () => EndpointAdapterService,
+  EndpointAdapterToken: () => EndpointAdapterToken,
   EndpointMetadataKey: () => EndpointMetadataKey,
-  EndpointType: () => EndpointType,
-  ErrorsEnum: () => ErrorsEnum,
-  EventEmitter: () => EventEmitter,
   ExecutionContext: () => ExecutionContext,
   ExecutionContextInjectionToken: () => ExecutionContextInjectionToken,
   ExecutionContextToken: () => ExecutionContextToken,
-  FactoryInjectionToken: () => FactoryInjectionToken,
-  FactoryNotFound: () => FactoryNotFound,
-  FactoryTokenNotResolved: () => FactoryTokenNotResolved,
   ForbiddenException: () => ForbiddenException,
   GuardRunnerService: () => GuardRunnerService,
   Header: () => Header,
   HttpCode: () => HttpCode,
   HttpException: () => HttpException,
-  Injectable: () => Injectable,
-  InjectableScope: () => InjectableScope,
-  InjectableTokenMeta: () => InjectableTokenMeta,
-  InjectableType: () => InjectableType,
-  InjectionToken: () => InjectionToken,
-  InstanceDestroying: () => InstanceDestroying,
-  InstanceExpired: () => InstanceExpired,
-  InstanceNotFound: () => InstanceNotFound,
   InternalServerErrorException: () => InternalServerErrorException,
   LOG_LEVELS: () => LOG_LEVELS,
   Logger: () => Logger,
@@ -122,20 +110,18 @@ __export(src_exports, {
   ModuleLoaderService: () => ModuleLoaderService,
   ModuleMetadataKey: () => ModuleMetadataKey,
   Multipart: () => Multipart,
+  MultipartAdapterService: () => MultipartAdapterService,
+  MultipartAdapterToken: () => MultipartAdapterToken,
   NaviosApplication: () => NaviosApplication,
   NaviosFactory: () => NaviosFactory,
   NotFoundException: () => NotFoundException,
   PinoWrapper: () => PinoWrapper,
   Reply: () => Reply,
   Request: () => Request,
-  ServiceLocator: () => ServiceLocator,
-  ServiceLocatorEventBus: () => ServiceLocatorEventBus,
-  ServiceLocatorInstanceHolderKind: () => ServiceLocatorInstanceHolderKind,
-  ServiceLocatorInstanceHolderStatus: () => ServiceLocatorInstanceHolderStatus,
-  ServiceLocatorManager: () => ServiceLocatorManager,
   Stream: () => Stream,
+  StreamAdapterService: () => StreamAdapterService,
+  StreamAdapterToken: () => StreamAdapterToken,
   UnauthorizedException: () => UnauthorizedException,
-  UnknownError: () => UnknownError,
   UseGuards: () => UseGuards,
   addLeadingSlash: () => addLeadingSlash,
   clc: () => clc,
@@ -147,12 +133,9 @@ __export(src_exports, {
   getAllEndpointMetadata: () => getAllEndpointMetadata,
   getControllerMetadata: () => getControllerMetadata,
   getEndpointMetadata: () => getEndpointMetadata,
-  getInjectableToken: () => getInjectableToken,
   getModuleMetadata: () => getModuleMetadata,
-  getServiceLocator: () => getServiceLocator,
   hasControllerMetadata: () => hasControllerMetadata,
   hasModuleMetadata: () => hasModuleMetadata,
-  inject: () => inject,
   isConstructor: () => isConstructor,
   isEmpty: () => isEmpty,
   isFunction: () => isFunction,
@@ -166,16 +149,235 @@ __export(src_exports, {
   isSymbol: () => isSymbol,
   isUndefined: () => isUndefined,
   normalizePath: () => normalizePath,
-  override: () => override,
   provideConfig: () => provideConfig,
-  provideServiceLocator: () => provideServiceLocator,
-  resolveService: () => resolveService,
-  setPromiseCollector: () => setPromiseCollector,
   stripEndSlash: () => stripEndSlash,
-  syncInject: () => syncInject,
   yellow: () => yellow
 });
 module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("@navios/di"), module.exports);
+
+// packages/core/src/adapters/endpoint-adapter.service.mts
+var import_di2 = require("@navios/di");
+
+// packages/core/src/adapters/stream-adapter.service.mts
+var import_di = require("@navios/di");
+var StreamAdapterToken = import_di.InjectionToken.create(
+  Symbol.for("StreamAdapterService")
+);
+var _StreamAdapterService_decorators, _init;
+_StreamAdapterService_decorators = [(0, import_di.Injectable)({
+  token: StreamAdapterToken
+})];
+var StreamAdapterService = class {
+  hasSchema(handlerMetadata) {
+    const config = handlerMetadata.config;
+    return !!config.requestSchema || !!config.querySchema;
+  }
+  prepareArguments(handlerMetadata) {
+    const config = handlerMetadata.config;
+    const getters = [];
+    if (config.querySchema) {
+      getters.push((target, request) => {
+        target.params = request.query;
+      });
+    }
+    if (config.requestSchema) {
+      getters.push((target, request) => {
+        target.data = request.body;
+      });
+    }
+    if (config.url.includes("$")) {
+      getters.push((target, request) => {
+        target.urlParams = request.params;
+      });
+    }
+    return getters;
+  }
+  provideHandler(controller, executionContext, handlerMetadata) {
+    const getters = this.prepareArguments(handlerMetadata);
+    const formatArguments = async (request) => {
+      const argument = {};
+      const promises = [];
+      for (const getter of getters) {
+        const res = getter(argument, request);
+        if (res instanceof Promise) {
+          promises.push(res);
+        }
+      }
+      await Promise.all(promises);
+      return argument;
+    };
+    return async function(request, reply) {
+      const controllerInstance = await (0, import_di.inject)(controller);
+      const argument = await formatArguments(request);
+      await controllerInstance[handlerMetadata.classMethod](argument, reply);
+    };
+  }
+  provideSchema(handlerMetadata) {
+    const schema = {};
+    const { querySchema, requestSchema } = handlerMetadata.config;
+    if (querySchema) {
+      schema.querystring = querySchema;
+    }
+    if (requestSchema) {
+      schema.body = requestSchema;
+    }
+    return schema;
+  }
+};
+_init = __decoratorStart(null);
+StreamAdapterService = __decorateElement(_init, 0, "StreamAdapterService", _StreamAdapterService_decorators, StreamAdapterService);
+__runInitializers(_init, 1, StreamAdapterService);
+
+// packages/core/src/adapters/endpoint-adapter.service.mts
+var EndpointAdapterToken = import_di2.InjectionToken.create(
+  Symbol.for("EndpointAdapterService")
+);
+var _EndpointAdapterService_decorators, _init2, _a;
+_EndpointAdapterService_decorators = [(0, import_di2.Injectable)({
+  token: EndpointAdapterToken
+})];
+var EndpointAdapterService = class extends (_a = StreamAdapterService) {
+  hasSchema(handlerMetadata) {
+    const config = handlerMetadata.config;
+    return super.hasSchema(handlerMetadata) || !!config.responseSchema;
+  }
+  provideSchema(handlerMetadata) {
+    const config = handlerMetadata.config;
+    const schema = super.provideSchema(handlerMetadata);
+    if (config.responseSchema) {
+      schema.response = {
+        200: config.responseSchema
+      };
+    }
+    return schema;
+  }
+  provideHandler(controller, executionContext, handlerMetadata) {
+    const getters = this.prepareArguments(handlerMetadata);
+    const formatArguments = async (request) => {
+      const argument = {};
+      const promises = [];
+      for (const getter of getters) {
+        const res = getter(argument, request);
+        if (res instanceof Promise) {
+          promises.push(res);
+        }
+      }
+      await Promise.all(promises);
+      return argument;
+    };
+    return async function(request, reply) {
+      const controllerInstance = await (0, import_di2.inject)(controller);
+      const argument = await formatArguments(request);
+      const result = await controllerInstance[handlerMetadata.classMethod](argument);
+      reply.status(handlerMetadata.successStatusCode).headers(handlerMetadata.headers).send(result);
+    };
+  }
+};
+_init2 = __decoratorStart(_a);
+EndpointAdapterService = __decorateElement(_init2, 0, "EndpointAdapterService", _EndpointAdapterService_decorators, EndpointAdapterService);
+__runInitializers(_init2, 1, EndpointAdapterService);
+
+// packages/core/src/adapters/multipart-adapter.service.mts
+var import_di3 = require("@navios/di");
+var import_zod = require("zod");
+var MultipartAdapterToken = import_di3.InjectionToken.create(
+  Symbol.for("MultipartAdapterService")
+);
+var _MultipartAdapterService_decorators, _init3, _a2;
+_MultipartAdapterService_decorators = [(0, import_di3.Injectable)({
+  token: MultipartAdapterToken
+})];
+var MultipartAdapterService = class extends (_a2 = EndpointAdapterService) {
+  prepareArguments(handlerMetadata) {
+    const config = handlerMetadata.config;
+    const getters = [];
+    if (config.querySchema) {
+      getters.push((target, request) => {
+        target.params = request.query;
+      });
+    }
+    if (config.url.includes("$")) {
+      getters.push((target, request) => {
+        target.urlParams = request.params;
+      });
+    }
+    const requestSchema = config.requestSchema;
+    const shape = requestSchema._def.shape();
+    const structure = this.analyzeSchema(shape);
+    getters.push(async (target, request) => {
+      const req = {};
+      for await (const part of request.parts()) {
+        await this.populateRequest(structure, part, req);
+      }
+      target.data = requestSchema.parse(req);
+    });
+    return getters;
+  }
+  async populateRequest(structure, part, req) {
+    const { isArray, isObject: isObject2 } = structure[part.fieldname] ?? {};
+    if (isArray && !req[part.fieldname]) {
+      req[part.fieldname] = [];
+    }
+    let value;
+    if (part.type === "file") {
+      value = new File([await part.toBuffer()], part.filename, {
+        type: part.mimetype
+      });
+    } else {
+      value = part.value;
+      if (isObject2 && typeof value === "string") {
+        value = JSON.parse(value);
+      }
+    }
+    if (isArray) {
+      req[part.fieldname].push(value);
+    } else {
+      req[part.fieldname] = value;
+    }
+  }
+  analyzeSchema(shape) {
+    return Object.keys(shape).reduce(
+      (target, key) => {
+        let schema = shape[key];
+        const isOptional = schema instanceof import_zod.ZodOptional;
+        if (isOptional) {
+          schema = schema.unwrap();
+        }
+        const isArray = schema instanceof import_zod.ZodArray;
+        if (isArray) {
+          schema = schema.element;
+        }
+        const isObject2 = schema instanceof import_zod.ZodObject;
+        return {
+          ...target,
+          [key]: {
+            isArray,
+            isOptional,
+            isObject: isObject2
+          }
+        };
+      },
+      {}
+    );
+  }
+  provideSchema(handlerMetadata) {
+    const schema = {};
+    const { querySchema, responseSchema } = handlerMetadata.config;
+    if (querySchema) {
+      schema.querystring = querySchema;
+    }
+    if (responseSchema) {
+      schema.response = {
+        200: responseSchema
+      };
+    }
+    return schema;
+  }
+};
+_init3 = __decoratorStart(_a2);
+MultipartAdapterService = __decorateElement(_init3, 0, "MultipartAdapterService", _MultipartAdapterService_decorators, MultipartAdapterService);
+__runInitializers(_init3, 1, MultipartAdapterService);
 
 // packages/core/src/config/utils/helpers.mts
 var import_node_process = require("process");
@@ -188,7 +390,8 @@ function envString(key, defaultValue) {
 }
 
 // packages/core/src/config/config.provider.mts
-var import_zod4 = require("zod");
+var import_di14 = require("@navios/di");
+var import_zod3 = require("zod");
 
 // packages/core/src/logger/utils/cli-colors.util.mts
 var isColorAllowed = () => !process.env.NO_COLOR;
@@ -248,14 +451,14 @@ var LOG_LEVEL_VALUES = {
   fatal: 5
 };
 function isLogLevelEnabled(targetLevel, logLevels) {
-  var _a;
+  var _a3;
   if (!logLevels || Array.isArray(logLevels) && (logLevels == null ? void 0 : logLevels.length) === 0) {
     return false;
   }
   if (logLevels.includes(targetLevel)) {
     return true;
   }
-  const highestLogLevelValue = (_a = logLevels.map((level) => LOG_LEVEL_VALUES[level]).sort((a, b) => b - a)) == null ? void 0 : _a[0];
+  const highestLogLevelValue = (_a3 = logLevels.map((level) => LOG_LEVEL_VALUES[level]).sort((a, b) => b - a)) == null ? void 0 : _a3[0];
   const targetLevelValue = LOG_LEVEL_VALUES[targetLevel];
   return targetLevelValue >= highestLogLevelValue;
 }
@@ -287,912 +490,23 @@ var isSymbol = (val) => typeof val === "symbol";
 
 // packages/core/src/logger/console-logger.service.mts
 var import_util = require("util");
-
-// packages/core/src/service-locator/decorators/injectable.decorator.mts
-var import_common2 = require("@navios/common");
-
-// packages/core/src/service-locator/enums/injectable-scope.enum.mts
-var InjectableScope = /* @__PURE__ */ ((InjectableScope2) => {
-  InjectableScope2["Singleton"] = "Singleton";
-  InjectableScope2["Instance"] = "Instance";
-  return InjectableScope2;
-})(InjectableScope || {});
-
-// packages/core/src/service-locator/injection-token.mts
-var import_crypto = require("crypto");
-var import_zod = require("zod");
-var InjectionToken = class _InjectionToken {
-  constructor(name2, schema) {
-    this.name = name2;
-    this.schema = schema;
-  }
-  id = (0, import_crypto.randomUUID)();
-  static create(name2, schema) {
-    return new _InjectionToken(name2, schema);
-  }
-  static bound(token, value) {
-    return new BoundInjectionToken(token, value);
-  }
-  static factory(token, factory) {
-    return new FactoryInjectionToken(token, factory);
-  }
-  static refineType(token) {
-    return token;
-  }
-};
-var BoundInjectionToken = class extends InjectionToken {
-  constructor(token, value) {
-    super(token.name, token.schema);
-    this.token = token;
-    this.value = value;
-    this.id = token.id;
-  }
-};
-var FactoryInjectionToken = class extends InjectionToken {
-  constructor(token, factory) {
-    super(token.name, token.schema);
-    this.token = token;
-    this.factory = factory;
-  }
-  value;
-  resolved = false;
-  async resolve() {
-    if (!this.value) {
-      this.value = await this.factory();
-      this.resolved = true;
-    }
-    return this.value;
-  }
-};
-
-// packages/core/src/service-locator/errors/errors.enum.mts
-var ErrorsEnum = /* @__PURE__ */ ((ErrorsEnum2) => {
-  ErrorsEnum2["InstanceExpired"] = "InstanceExpired";
-  ErrorsEnum2["InstanceNotFound"] = "InstanceNotFound";
-  ErrorsEnum2["InstanceDestroying"] = "InstanceDestroying";
-  ErrorsEnum2["UnknownError"] = "UnknownError";
-  ErrorsEnum2["FactoryNotFound"] = "FactoryNotFound";
-  ErrorsEnum2["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
-  return ErrorsEnum2;
-})(ErrorsEnum || {});
-
-// packages/core/src/service-locator/errors/factory-not-found.mts
-var FactoryNotFound = class extends Error {
-  constructor(name2) {
-    super(`Factory ${name2} not found`);
-    this.name = name2;
-  }
-  code = "FactoryNotFound" /* FactoryNotFound */;
-};
-
-// packages/core/src/service-locator/errors/factory-token-not-resolved.mts
-var FactoryTokenNotResolved = class extends Error {
-  code = "FactoryTokenNotResolved" /* FactoryTokenNotResolved */;
-  constructor(name2) {
-    super(`Factory token not resolved: ${name2.toString()}`);
-  }
-};
-
-// packages/core/src/service-locator/errors/instance-destroying.mts
-var InstanceDestroying = class extends Error {
-  constructor(name2) {
-    super(`Instance ${name2} destroying`);
-    this.name = name2;
-  }
-  code = "InstanceDestroying" /* InstanceDestroying */;
-};
-
-// packages/core/src/service-locator/errors/instance-expired.mts
-var InstanceExpired = class extends Error {
-  constructor(name2) {
-    super(`Instance ${name2} expired`);
-    this.name = name2;
-  }
-  code = "InstanceExpired" /* InstanceExpired */;
-};
-
-// packages/core/src/service-locator/errors/instance-not-found.mts
-var InstanceNotFound = class extends Error {
-  constructor(name2) {
-    super(`Instance ${name2} not found`);
-    this.name = name2;
-  }
-  code = "InstanceNotFound" /* InstanceNotFound */;
-};
-
-// packages/core/src/service-locator/errors/unknown-error.mts
-var UnknownError = class extends Error {
-  code = "UnknownError" /* UnknownError */;
-  parent;
-  constructor(message) {
-    if (message instanceof Error) {
-      super(message.message);
-      this.parent = message;
-      return;
-    }
-    super(message);
-  }
-};
-
-// packages/core/src/service-locator/service-locator-event-bus.mts
-var ServiceLocatorEventBus = class {
-  constructor(logger = null) {
-    this.logger = logger;
-  }
-  listeners = /* @__PURE__ */ new Map();
-  on(ns, event, listener) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
-    if (!this.listeners.has(ns)) {
-      this.listeners.set(ns, /* @__PURE__ */ new Map());
-    }
-    const nsEvents = this.listeners.get(ns);
-    if (!nsEvents.has(event)) {
-      nsEvents.set(event, /* @__PURE__ */ new Set());
-    }
-    nsEvents.get(event).add(listener);
-    return () => {
-      var _a2;
-      nsEvents.get(event).delete(listener);
-      if (((_a2 = nsEvents.get(event)) == null ? void 0 : _a2.size) === 0) {
-        nsEvents.delete(event);
-      }
-      if (nsEvents.size === 0) {
-        this.listeners.delete(ns);
-      }
-    };
-  }
-  async emit(key, event) {
-    var _a, _b, _c;
-    if (!this.listeners.has(key)) {
-      return;
-    }
-    const events = this.listeners.get(key);
-    const preEvent = `pre:${event}`;
-    const postEvent = `post:${event}`;
-    (_a = this.logger) == null ? void 0 : _a.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`);
-    await Promise.allSettled(
-      [...events.get(preEvent) ?? []].map((listener) => listener(preEvent))
-    ).then((results) => {
-      results.filter((result) => result.status === "rejected").forEach((result) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.warn(
-          `[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`,
-          result.reason
-        );
-      });
-    });
-    (_b = this.logger) == null ? void 0 : _b.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`);
-    const res = await Promise.allSettled(
-      [...events.get(event) ?? []].map((listener) => listener(event))
-    ).then((results) => {
-      const res2 = results.filter((result) => result.status === "rejected").map((result) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.warn(
-          `[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`,
-          result.reason
-        );
-        return result;
-      });
-      if (res2.length > 0) {
-        return Promise.reject(res2);
-      }
-      return results;
-    });
-    (_c = this.logger) == null ? void 0 : _c.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent}`);
-    await Promise.allSettled(
-      [...events.get(postEvent) ?? []].map((listener) => listener(postEvent))
-    ).then((results) => {
-      results.filter((result) => result.status === "rejected").forEach((result) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.warn(
-          `[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`,
-          result.reason
-        );
-      });
-    });
-    return res;
-  }
-};
-
-// packages/core/src/service-locator/service-locator-instance-holder.mts
-var ServiceLocatorInstanceHolderKind = /* @__PURE__ */ ((ServiceLocatorInstanceHolderKind2) => {
-  ServiceLocatorInstanceHolderKind2["Instance"] = "instance";
-  ServiceLocatorInstanceHolderKind2["Factory"] = "factory";
-  ServiceLocatorInstanceHolderKind2["AbstractFactory"] = "abstractFactory";
-  return ServiceLocatorInstanceHolderKind2;
-})(ServiceLocatorInstanceHolderKind || {});
-var ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ ((ServiceLocatorInstanceHolderStatus2) => {
-  ServiceLocatorInstanceHolderStatus2["Created"] = "created";
-  ServiceLocatorInstanceHolderStatus2["Creating"] = "creating";
-  ServiceLocatorInstanceHolderStatus2["Destroying"] = "destroying";
-  return ServiceLocatorInstanceHolderStatus2;
-})(ServiceLocatorInstanceHolderStatus || {});
-
-// packages/core/src/service-locator/service-locator-manager.mts
-var ServiceLocatorManager = class {
-  constructor(logger = null) {
-    this.logger = logger;
-  }
-  instancesHolders = /* @__PURE__ */ new Map();
-  get(name2) {
-    var _a, _b, _c;
-    const holder = this.instancesHolders.get(name2);
-    if (holder) {
-      if (holder.ttl !== Infinity) {
-        const now = Date.now();
-        if (now - holder.createdAt > holder.ttl) {
-          (_a = this.logger) == null ? void 0 : _a.log(
-            `[ServiceLocatorManager]#getInstanceHolder() TTL expired for ${holder.name}`
-          );
-          return [new InstanceExpired(holder.name), holder];
-        }
-      } else if (holder.status === "destroying" /* Destroying */) {
-        (_b = this.logger) == null ? void 0 : _b.log(
-          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`
-        );
-        return [new InstanceDestroying(holder.name), holder];
-      }
-      return [void 0, holder];
-    } else {
-      (_c = this.logger) == null ? void 0 : _c.log(
-        `[ServiceLocatorManager]#getInstanceHolder() Instance ${name2} not found`
-      );
-      return [new InstanceNotFound(name2)];
-    }
-  }
-  set(name2, holder) {
-    this.instancesHolders.set(name2, holder);
-  }
-  has(name2) {
-    const [error, holder] = this.get(name2);
-    if (!error) {
-      return [void 0, true];
-    }
-    if (["InstanceExpired" /* InstanceExpired */, "InstanceDestroying" /* InstanceDestroying */].includes(
-      error.code
-    )) {
-      return [error];
-    }
-    return [void 0, !!holder];
-  }
-  delete(name2) {
-    return this.instancesHolders.delete(name2);
-  }
-  filter(predicate) {
-    return new Map(
-      [...this.instancesHolders].filter(
-        ([key, value]) => predicate(value, key)
-      )
-    );
-  }
-};
-
-// packages/core/src/service-locator/service-locator.mts
-var ServiceLocator = class {
-  constructor(logger = null) {
-    this.logger = logger;
-    this.eventBus = new ServiceLocatorEventBus(logger);
-    this.manager = new ServiceLocatorManager(logger);
-  }
-  abstractFactories = /* @__PURE__ */ new Map();
-  instanceFactories = /* @__PURE__ */ new Map();
-  eventBus;
-  manager;
-  getEventBus() {
-    return this.eventBus;
-  }
-  registerInstance(token, instance) {
-    const instanceName = this.getInstanceIdentifier(token, void 0);
-    this.manager.set(instanceName, {
-      name: instanceName,
-      instance,
-      status: "created" /* Created */,
-      kind: "instance" /* Instance */,
-      createdAt: Date.now(),
-      ttl: Infinity,
-      deps: [],
-      destroyListeners: [],
-      effects: [],
-      destroyPromise: null,
-      creationPromise: null
-    });
-    this.eventBus.emit(instanceName, "create");
-  }
-  removeInstance(token) {
-    const instanceName = this.getInstanceIdentifier(token, void 0);
-    return this.invalidate(instanceName);
-  }
-  registerAbstractFactory(token, factory, type = "Singleton" /* Singleton */) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.log(
-      `[ServiceLocator]#registerAbstractFactory(): Registering abstract factory for ${name}`
-    );
-    if (type === "Instance" /* Instance */) {
-      this.instanceFactories.set(token, factory);
-      this.abstractFactories.delete(token);
-    } else {
-      this.abstractFactories.set(token, factory);
-      this.instanceFactories.delete(token);
-    }
-  }
-  resolveTokenArgs(token, args) {
-    var _a, _b;
-    let realArgs = args;
-    if (token instanceof BoundInjectionToken) {
-      realArgs = token.value;
-    } else if (token instanceof FactoryInjectionToken) {
-      if (token.resolved) {
-        realArgs = token.value;
-      } else {
-        return [new FactoryTokenNotResolved(token.name)];
-      }
-    }
-    if (!token.schema) {
-      return [void 0, realArgs];
-    }
-    const validatedArgs = (_a = token.schema) == null ? void 0 : _a.safeParse(realArgs);
-    if (validatedArgs && !validatedArgs.success) {
-      (_b = this.logger) == null ? void 0 : _b.error(
-        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
-        validatedArgs.error
-      );
-      return [new UnknownError(validatedArgs.error)];
-    }
-    return [void 0, validatedArgs == null ? void 0 : validatedArgs.data];
-  }
-  getInstanceIdentifier(token, args) {
-    const [err, realArgs] = this.resolveTokenArgs(token, args);
-    if (err) {
-      throw err;
-    }
-    return this.makeInstanceName(token, realArgs);
-  }
-  async getInstance(token, args) {
-    var _a, _b;
-    const [err, realArgs] = this.resolveTokenArgs(token, args);
-    if (err instanceof UnknownError) {
-      throw err;
-    } else if (err instanceof FactoryTokenNotResolved && token instanceof FactoryInjectionToken) {
-      await token.resolve();
-      return this.getInstance(token, args);
-    }
-    const instanceName = this.makeInstanceName(token, realArgs);
-    const [error, holder] = this.manager.get(instanceName);
-    if (!error) {
-      if (holder.status === "creating" /* Creating */) {
-        return holder.creationPromise;
-      } else if (holder.status === "destroying" /* Destroying */) {
-        return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
-      }
-      return [void 0, holder.instance];
-    }
-    switch (error.code) {
-      case "InstanceDestroying" /* InstanceDestroying */:
-        (_a = this.logger) == null ? void 0 : _a.log(
-          `[ServiceLocator]#getInstance() TTL expired for ${holder == null ? void 0 : holder.name}`
-        );
-        await (holder == null ? void 0 : holder.destroyPromise);
-        return this.getInstance(token, args);
-      case "InstanceExpired" /* InstanceExpired */:
-        (_b = this.logger) == null ? void 0 : _b.log(
-          `[ServiceLocator]#getInstance() TTL expired for ${holder == null ? void 0 : holder.name}`
-        );
-        await this.invalidate(instanceName);
-        return this.getInstance(token, args);
-      case "InstanceNotFound" /* InstanceNotFound */:
-        break;
-      default:
-        return [error];
-    }
-    return this.createInstance(instanceName, token, realArgs);
-  }
-  async getOrThrowInstance(token, args) {
-    const [error, instance] = await this.getInstance(token, args);
-    if (error) {
-      throw error;
-    }
-    return instance;
-  }
-  notifyListeners(name2, event = "create") {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.log(
-      `[ServiceLocator]#notifyListeners() Notifying listeners for ${name2} with event ${event}`
-    );
-    return this.eventBus.emit(name2, event);
-  }
-  async createInstance(instanceName, token, args) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.log(
-      `[ServiceLocator]#createInstance() Creating instance for ${instanceName}`
-    );
-    let realToken = token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken ? token.token : token;
-    if (this.abstractFactories.has(realToken) || this.instanceFactories.has(realToken)) {
-      return this.createInstanceFromAbstractFactory(
-        instanceName,
-        realToken,
-        args
-      );
-    } else {
-      return [new FactoryNotFound(realToken.name.toString())];
-    }
-  }
-  async createInstanceFromAbstractFactory(instanceName, token, args) {
-    var _a;
-    (_a = this.logger) == null ? void 0 : _a.log(
-      `[ServiceLocator]#createInstanceFromAbstractFactory(): Creating instance for ${instanceName} from abstract factory`
-    );
-    const ctx = this.createContextForAbstractFactory(instanceName);
-    let shouldStore = true;
-    let abstractFactory = this.abstractFactories.get(token);
-    if (!abstractFactory) {
-      abstractFactory = this.instanceFactories.get(token);
-      shouldStore = false;
-      if (!abstractFactory) {
-        return [new FactoryNotFound(token.name.toString())];
-      }
-    }
-    const holder = {
-      name: instanceName,
-      instance: null,
-      status: "creating" /* Creating */,
-      kind: "abstractFactory" /* AbstractFactory */,
-      // @ts-expect-error TS2322 This is correct type
-      creationPromise: abstractFactory(ctx, args).then(async (instance) => {
-        var _a2;
-        holder.instance = instance;
-        holder.status = "created" /* Created */;
-        holder.deps = ctx.getDependencies();
-        holder.destroyListeners = ctx.getDestroyListeners();
-        holder.ttl = ctx.getTtl();
-        if (holder.deps.length > 0) {
-          (_a2 = this.logger) == null ? void 0 : _a2.log(
-            `[ServiceLocator]#createInstanceFromAbstractFactory(): Adding subscriptions for ${instanceName} dependencies for their invalidations: ${holder.deps.join(
-              ", "
-            )}`
-          );
-          holder.deps.forEach((dependency) => {
-            holder.destroyListeners.push(
-              this.eventBus.on(
-                dependency,
-                "destroy",
-                () => this.invalidate(instanceName)
-              )
-            );
-          });
-        }
-        if (holder.ttl === 0 || !shouldStore) {
-          await this.invalidate(instanceName);
-        }
-        await this.notifyListeners(instanceName);
-        return [void 0, instance];
-      }).catch((error) => {
-        var _a2;
-        (_a2 = this.logger) == null ? void 0 : _a2.error(
-          `[ServiceLocator]#createInstanceFromAbstractFactory(): Error creating instance for ${instanceName}`,
-          error
-        );
-        return [new UnknownError(error)];
-      }),
-      effects: [],
-      deps: [],
-      destroyListeners: [],
-      createdAt: Date.now(),
-      ttl: Infinity
-    };
-    if (shouldStore) {
-      this.manager.set(instanceName, holder);
-    }
-    return holder.creationPromise;
-  }
-  createContextForAbstractFactory(instanceName) {
-    const dependencies = /* @__PURE__ */ new Set();
-    const destroyListeners = /* @__PURE__ */ new Set();
-    const self = this;
-    function invalidate(name2 = instanceName) {
-      return self.invalidate(name2);
-    }
-    function addEffect(listener) {
-      destroyListeners.add(listener);
-    }
-    let ttl = Infinity;
-    function setTtl(value) {
-      ttl = value;
-    }
-    function getTtl() {
-      return ttl;
-    }
-    function on(key, event, listener) {
-      destroyListeners.add(self.eventBus.on(key, event, listener));
-    }
-    return {
-      // @ts-expect-error This is correct type
-      async inject(token, args) {
-        let injectionToken = token;
-        if (typeof token === "function") {
-          injectionToken = getInjectableToken(token);
-        }
-        if (injectionToken instanceof InjectionToken) {
-          const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
-          const instanceName2 = self.makeInstanceName(token, validatedArgs);
-          dependencies.add(instanceName2);
-          return self.getOrThrowInstance(injectionToken, args);
-        }
-        throw new Error(
-          `[ServiceLocator]#inject(): Invalid token type: ${typeof token}. Expected a class or an InjectionToken.`
-        );
-      },
-      invalidate,
-      eventBus: self.eventBus,
-      on,
-      getDependencies: () => Array.from(dependencies),
-      addEffect,
-      getDestroyListeners: () => Array.from(destroyListeners),
-      setTtl,
-      getTtl
-    };
-  }
-  getSyncInstance(token, args) {
-    const [err, realArgs] = this.resolveTokenArgs(token, args);
-    if (err) {
-      return null;
-    }
-    const instanceName = this.makeInstanceName(token, realArgs);
-    const [error, holder] = this.manager.get(instanceName);
-    if (error) {
-      return null;
-    }
-    return holder.instance;
-  }
-  invalidate(service, round = 1) {
-    var _a, _b, _c, _d, _e;
-    (_a = this.logger) == null ? void 0 : _a.log(
-      `[ServiceLocator]#invalidate(): Starting Invalidating process of ${service}`
-    );
-    const toInvalidate = this.manager.filter(
-      (holder) => holder.name === service || holder.deps.includes(service)
-    );
-    const promises = [];
-    for (const [key, holder] of toInvalidate.entries()) {
-      if (holder.status === "destroying" /* Destroying */) {
-        (_b = this.logger) == null ? void 0 : _b.trace(
-          `[ServiceLocator]#invalidate(): ${key} is already being destroyed`
-        );
-        promises.push(holder.destroyPromise);
-        continue;
-      }
-      if (holder.status === "creating" /* Creating */) {
-        (_c = this.logger) == null ? void 0 : _c.trace(
-          `[ServiceLocator]#invalidate(): ${key} is being created, waiting for creation to finish`
-        );
-        promises.push(
-          (_d = holder.creationPromise) == null ? void 0 : _d.then(() => {
-            var _a2;
-            if (round > 3) {
-              (_a2 = this.logger) == null ? void 0 : _a2.error(
-                `[ServiceLocator]#invalidate(): ${key} creation is triggering a new invalidation round, but it is still not created`
-              );
-              return;
-            }
-            return this.invalidate(key, round + 1);
-          })
-        );
-        continue;
-      }
-      holder.status = "destroying" /* Destroying */;
-      (_e = this.logger) == null ? void 0 : _e.log(
-        `[ServiceLocator]#invalidate(): Invalidating ${key} and notifying listeners`
-      );
-      holder.destroyPromise = Promise.all(
-        holder.destroyListeners.map((listener) => listener())
-      ).then(async () => {
-        this.manager.delete(key);
-        await this.notifyListeners(key, "destroy");
-      });
-      promises.push(holder.destroyPromise);
-    }
-    return Promise.all(promises);
-  }
-  async ready() {
-    return Promise.all(
-      Array.from(this.manager.filter(() => true)).map(([, holder]) => {
-        var _a;
-        if (holder.status === "creating" /* Creating */) {
-          return (_a = holder.creationPromise) == null ? void 0 : _a.then(() => null);
-        }
-        if (holder.status === "destroying" /* Destroying */) {
-          return holder.destroyPromise.then(() => null);
-        }
-        return Promise.resolve(null);
-      })
-    ).then(() => null);
-  }
-  makeInstanceName(token, args) {
-    let stringifiedArgs = args ? ":" + JSON.stringify(args, (_, value) => {
-      if (typeof value === "function") {
-        return `function:${value.name}(${value.length})`;
-      }
-      if (typeof value === "symbol") {
-        return value.toString();
-      }
-      return value;
-    }).replaceAll(/"/g, "").replaceAll(/:/g, "=").replaceAll(/,/g, "|") : "";
-    const { name: name2 } = token;
-    if (typeof name2 === "function") {
-      const className = name2.name;
-      return `${className}(${token.id})${stringifiedArgs}`;
-    } else if (typeof name2 === "symbol") {
-      return `${name2.toString()}(${token.id})${stringifiedArgs}`;
-    } else {
-      return `${name2}(${token.id})${stringifiedArgs}`;
-    }
-  }
-};
-
-// packages/core/src/service-locator/injector.mts
-var serviceLocator = new ServiceLocator();
-function provideServiceLocator(locator) {
-  const original = serviceLocator;
-  serviceLocator = locator;
-  return original;
-}
-function getServiceLocator() {
-  if (!serviceLocator) {
-    throw new Error(
-      "[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator."
-    );
-  }
-  return serviceLocator;
-}
-
-// packages/core/src/service-locator/resolve-service.mts
-var import_common = require("@navios/common");
-
-// packages/core/src/service-locator/proxy-service-locator.mts
-var ProxyServiceLocator = class {
-  constructor(serviceLocator2, ctx) {
-    this.serviceLocator = serviceLocator2;
-    this.ctx = ctx;
-  }
-  get abstractFactories() {
-    return this.serviceLocator["abstractFactories"];
-  }
-  getEventBus() {
-    return this.serviceLocator.getEventBus();
-  }
-  registerAbstractFactory(token, factory) {
-    return this.serviceLocator.registerAbstractFactory(token, factory);
-  }
-  getInstance(token, args) {
-    return this.ctx.inject(token, args).then(
-      (instance) => {
-        return [void 0, instance];
-      },
-      (error) => {
-        return [error];
-      }
-    );
-  }
-  getOrThrowInstance(token, args) {
-    return this.ctx.inject(token, args);
-  }
-  getSyncInstance(token, args) {
-    return this.serviceLocator.getSyncInstance(token, args);
-  }
-  invalidate(service, round) {
-    return this.serviceLocator.invalidate(service, round);
-  }
-  ready() {
-    return this.serviceLocator.ready();
-  }
-  makeInstanceName(token, args) {
-    return this.serviceLocator.makeInstanceName(token, args);
-  }
-};
-function makeProxyServiceLocator(serviceLocator2, ctx) {
-  return new ProxyServiceLocator(serviceLocator2, ctx);
-}
-
-// packages/core/src/service-locator/sync-injector.mts
-var promiseCollector = null;
-function syncInject(token, args) {
-  let realToken = token;
-  if (!(token instanceof InjectionToken)) {
-    realToken = getInjectableToken(token);
-  }
-  const instance = getServiceLocator().getSyncInstance(realToken, args);
-  if (!instance) {
-    if (promiseCollector) {
-      const promise = getServiceLocator().getInstance(realToken, args);
-      promiseCollector(promise);
-    } else {
-      throw new Error(
-        `[ServiceLocator] No instance found for ${realToken.name.toString()}`
-      );
-    }
-  }
-  return instance;
-}
-function setPromiseCollector(collector) {
-  const original = promiseCollector;
-  promiseCollector = collector;
-  return original;
-}
-
-// packages/core/src/service-locator/resolve-service.mts
-async function resolveService(ctx, target, args = []) {
-  const proxyServiceLocator = makeProxyServiceLocator(getServiceLocator(), ctx);
-  let promises = [];
-  const promiseCollector2 = (promise) => {
-    promises.push(promise);
-  };
-  const originalPromiseCollector = setPromiseCollector(promiseCollector2);
-  const tryLoad = () => {
-    const original = provideServiceLocator(proxyServiceLocator);
-    let result = new target(...args);
-    provideServiceLocator(original);
-    return result;
-  };
-  let instance = tryLoad();
-  setPromiseCollector(originalPromiseCollector);
-  if (promises.length > 0) {
-    await Promise.all(promises);
-    promises = [];
-    instance = tryLoad();
-  }
-  if (promises.length > 0) {
-    console.error(`[ServiceLocator] ${target.name} has problem with it's definition.
-     
-     One or more of the dependencies are registered as a InjectableScope.Instance and are used with syncInject.
-     
-     Please use inject instead of syncInject to load those dependencies.`);
-    throw new import_common.NaviosException(
-      `[ServiceLocator] Service ${target.name} cannot be instantiated.`
-    );
-  }
-  return instance;
-}
-
-// packages/core/src/service-locator/decorators/injectable.decorator.mts
-var InjectableType = /* @__PURE__ */ ((InjectableType2) => {
-  InjectableType2["Class"] = "Class";
-  InjectableType2["Factory"] = "Factory";
-  return InjectableType2;
-})(InjectableType || {});
-var InjectableTokenMeta = Symbol("InjectableTokenMeta");
-function Injectable({
-  scope = "Singleton" /* Singleton */,
-  type = "Class" /* Class */,
-  token
-} = {}) {
-  return (target, context) => {
-    if (context.kind !== "class") {
-      throw new Error(
-        "[ServiceLocator] @Injectable decorator can only be used on classes."
-      );
-    }
-    let injectableToken = token ?? InjectionToken.create(target);
-    const locator = getServiceLocator();
-    if (type === "Class" /* Class */) {
-      locator.registerAbstractFactory(
-        injectableToken,
-        async (ctx) => resolveService(ctx, target),
-        scope
-      );
-    } else if (type === "Factory" /* Factory */) {
-      locator.registerAbstractFactory(
-        injectableToken,
-        async (ctx, args) => {
-          const builder = await resolveService(ctx, target);
-          if (typeof builder.create !== "function") {
-            throw new import_common2.NaviosException(
-              `[ServiceLocator] Factory ${target.name} does not implement the create method.`
-            );
-          }
-          return builder.create(ctx, args);
-        },
-        scope
-      );
-    }
-    target[InjectableTokenMeta] = injectableToken;
-    return target;
-  };
-}
-
-// packages/core/src/service-locator/decorators/get-injectable-token.mts
-function getInjectableToken(target) {
-  const token = target[InjectableTokenMeta];
-  if (!token) {
-    throw new Error(
-      `[ServiceLocator] Class ${target.name} is not decorated with @Injectable.`
-    );
-  }
-  return token;
-}
-
-// packages/core/src/service-locator/event-emitter.mts
-var EventEmitter = class {
-  listeners = /* @__PURE__ */ new Map();
-  on(event, listener) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(event).add(listener);
-    return () => {
-      this.off(event, listener);
-    };
-  }
-  off(event, listener) {
-    if (!this.listeners.has(event)) {
-      return;
-    }
-    this.listeners.get(event).delete(listener);
-    if (this.listeners.get(event).size === 0) {
-      this.listeners.delete(event);
-    }
-  }
-  once(event, listener) {
-    const off = this.on(event, (...args) => {
-      off();
-      listener(...args);
-    });
-    return off;
-  }
-  async emit(event, ...args) {
-    if (!this.listeners.has(event)) {
-      return;
-    }
-    return Promise.all(Array.from(this.listeners.get(event)).map((listener) => listener(...args)));
-  }
-  addChannel(ns, event, target) {
-    return this.on(event, (...args) => target.emit(ns, event, ...args));
-  }
-};
-
-// packages/core/src/service-locator/inject.mts
-function inject(token, args) {
-  let realToken = token;
-  if (!(token instanceof InjectionToken)) {
-    realToken = getInjectableToken(token);
-  }
-  return getServiceLocator().getOrThrowInstance(realToken, args);
-}
-
-// packages/core/src/service-locator/override.mts
-function override(token, target) {
-  const serviceLocator2 = getServiceLocator();
-  const originalDefinition = serviceLocator2["abstractFactories"].get(token);
-  serviceLocator2.registerAbstractFactory(token, async (ctx, args) => {
-    const builder = new target();
-    return builder.create(ctx, args);
-  });
-  return () => {
-    if (originalDefinition) {
-      serviceLocator2.registerAbstractFactory(token, originalDefinition);
-    }
-  };
-}
+var import_di11 = require("@navios/di");
 
 // packages/core/src/tokens/application.token.mts
+var import_di4 = require("@navios/di");
 var ApplicationInjectionToken = "ApplicationInjectionToken";
-var Application = InjectionToken.create(
+var Application = import_di4.InjectionToken.create(
   ApplicationInjectionToken
 );
 
+// packages/core/src/tokens/execution-context.token.mts
+var import_di8 = require("@navios/di");
+
 // packages/core/src/services/controller-adapter.service.mts
-var import_common3 = require("@navios/common");
-var import_zod2 = require("zod");
+var import_di6 = require("@navios/di");
 
-// packages/core/src/metadata/endpoint.metadata.mts
+// packages/core/src/metadata/handler.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];
@@ -1219,9 +533,10 @@ function getEndpointMetadata(target, context) {
           classMethod: target.name,
           url: "",
           successStatusCode: 200,
+          adapterToken: null,
           headers: {},
-          type: "unknown" /* Unknown */,
           httpMethod: "GET",
+          // @ts-expect-error We are using a generic type here
           config: null,
           guards: /* @__PURE__ */ new Set(),
           customAttributes: /* @__PURE__ */ new Map()
@@ -1345,6 +660,9 @@ var ExecutionContext = class {
   }
 };
 
+// packages/core/src/services/guard-runner.service.mts
+var import_di5 = require("@navios/di");
+
 // packages/core/src/exceptions/http.exception.mts
 var HttpException = class {
   constructor(statusCode, response, error) {
@@ -1399,13 +717,13 @@ var ConflictException = class extends HttpException {
 };
 
 // packages/core/src/services/guard-runner.service.mts
-var _GuardRunnerService_decorators, _init;
-_GuardRunnerService_decorators = [Injectable()];
+var _GuardRunnerService_decorators, _init4;
+_GuardRunnerService_decorators = [(0, import_di5.Injectable)()];
 var GuardRunnerService = class {
   async runGuards(allGuards, executionContext) {
     let canActivate = true;
     for (const guard of Array.from(allGuards).reverse()) {
-      const guardInstance = await inject(
+      const guardInstance = await (0, import_di5.inject)(
         guard
       );
       if (!guardInstance.canActivate) {
@@ -1462,39 +780,59 @@ var GuardRunnerService = class {
     return guards;
   }
 };
-_init = __decoratorStart(null);
-GuardRunnerService = __decorateElement(_init, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
-__runInitializers(_init, 1, GuardRunnerService);
+_init4 = __decoratorStart(null);
+GuardRunnerService = __decorateElement(_init4, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
+__runInitializers(_init4, 1, GuardRunnerService);
 
 // packages/core/src/services/controller-adapter.service.mts
-var _ControllerAdapterService_decorators, _init2;
-_ControllerAdapterService_decorators = [Injectable()];
+var _ControllerAdapterService_decorators, _init5;
+_ControllerAdapterService_decorators = [(0, import_di6.Injectable)()];
 var _ControllerAdapterService = class _ControllerAdapterService {
-  guardRunner = syncInject(GuardRunnerService);
-  logger = syncInject(Logger, {
+  guardRunner = (0, import_di6.syncInject)(GuardRunnerService);
+  logger = (0, import_di6.syncInject)(Logger, {
     context: _ControllerAdapterService.name
   });
-  setupController(controller, instance, moduleMetadata) {
+  async setupController(controller, instance, moduleMetadata) {
+    var _a3, _b;
     const controllerMetadata = extractControllerMetadata(controller);
     for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod } = endpoint;
-      if (!url) {
+      const { classMethod, url, httpMethod, adapterToken } = endpoint;
+      if (!url || !adapterToken) {
         throw new Error(
           `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`
         );
       }
+      const adapter = await (0, import_di6.inject)(
+        adapterToken
+      );
       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)
-      });
+      const hasSchema = ((_a3 = adapter.hasSchema) == null ? void 0 : _a3.call(adapter, endpoint)) ?? false;
+      if (hasSchema) {
+        instance.withTypeProvider().route({
+          method: httpMethod,
+          url: url.replaceAll("$", ":"),
+          schema: ((_b = adapter.provideSchema) == null ? void 0 : _b.call(adapter, endpoint)) ?? {},
+          preHandler: this.providePreHandler(executionContext),
+          handler: this.wrapHandler(
+            executionContext,
+            adapter.provideHandler(controller, executionContext, endpoint)
+          )
+        });
+      } else {
+        instance.route({
+          method: httpMethod,
+          url: url.replaceAll("$", ":"),
+          preHandler: this.providePreHandler(executionContext),
+          handler: this.wrapHandler(
+            executionContext,
+            adapter.provideHandler(controller, executionContext, endpoint)
+          )
+        });
+      }
       this.logger.debug(
         `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`
       );
@@ -1502,220 +840,53 @@ var _ControllerAdapterService = class _ControllerAdapterService {
   }
   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 {
+    return guards.size > 0 ? this.wrapHandler(
+      executionContext,
+      async (request, reply) => {
+        let canActivate = true;
         canActivate = await this.guardRunner.runGuards(
           guards,
           executionContext
         );
-      } finally {
-        getServiceLocator().removeInstance(Request);
-        getServiceLocator().removeInstance(Reply);
-        getServiceLocator().removeInstance(ExecutionContextToken);
-      }
-      if (!canActivate) {
-        return reply;
-      }
-    } : void 0;
-  }
-  provideSchemaForConfig(endpointMetadata) {
-    if (!endpointMetadata.config) {
-      this.logger.warn(`No config found for endpoint ${endpointMetadata.url}`);
-      return {};
-    }
-    const { querySchema, requestSchema, responseSchema } = endpointMetadata.config;
-    const schema = {};
-    if (querySchema) {
-      schema.querystring = querySchema;
-    }
-    if (requestSchema && endpointMetadata.type !== "multipart" /* Multipart */) {
-      schema.body = requestSchema;
-    }
-    if (responseSchema) {
-      schema.response = {
-        200: responseSchema
-      };
-    }
-    return schema;
-  }
-  provideHandler(controller, executionContext, endpointMetadata) {
-    switch (endpointMetadata.type) {
-      case "unknown" /* Unknown */:
-        this.logger.error(
-          `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`
-        );
-        throw new import_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);
-      }
-    };
-  }
-  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;
+        if (!canActivate) {
+          return reply;
         }
-        await controllerInstance[endpointMetadata.classMethod](argument, reply);
-      } finally {
-        getServiceLocator().removeInstance(Request);
-        getServiceLocator().removeInstance(Reply);
-        getServiceLocator().removeInstance(ExecutionContextToken);
       }
-    };
+    ) : void 0;
   }
-  provideHandlerForMultipart(controller, executionContext, endpointMetadata) {
-    const config = endpointMetadata.config;
-    const requestSchema = config.requestSchema;
-    const shape = requestSchema._def.shape();
+  wrapHandler(executionContext, handler) {
+    const locator = (0, import_di6.getGlobalServiceLocator)();
     return async (request, reply) => {
-      getServiceLocator().registerInstance(Request, request);
-      getServiceLocator().registerInstance(Reply, reply);
-      getServiceLocator().registerInstance(
-        ExecutionContextToken,
-        executionContext
-      );
+      locator.storeInstance(request, Request);
+      locator.storeInstance(reply, Reply);
+      locator.storeInstance(executionContext, ExecutionContextToken);
       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);
+        return await handler(request, reply);
       } finally {
-        getServiceLocator().removeInstance(Request);
-        getServiceLocator().removeInstance(Reply);
-        getServiceLocator().removeInstance(ExecutionContextToken);
+        Promise.all([
+          locator.removeInstance(Request),
+          locator.removeInstance(Reply),
+          locator.removeInstance(ExecutionContextToken)
+        ]).catch((err) => {
+          this.logger.warn(`Error removing instances: ${err}`);
+        });
       }
     };
   }
 };
-_init2 = __decoratorStart(null);
-_ControllerAdapterService = __decorateElement(_init2, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
-__runInitializers(_init2, 1, _ControllerAdapterService);
+_init5 = __decoratorStart(null);
+_ControllerAdapterService = __decorateElement(_init5, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
+__runInitializers(_init5, 1, _ControllerAdapterService);
 var ControllerAdapterService = _ControllerAdapterService;
 
 // packages/core/src/services/module-loader.service.mts
-var _ModuleLoaderService_decorators, _init3;
-_ModuleLoaderService_decorators = [Injectable()];
+var import_di7 = require("@navios/di");
+var _ModuleLoaderService_decorators, _init6;
+_ModuleLoaderService_decorators = [(0, import_di7.Injectable)()];
 var _ModuleLoaderService = class _ModuleLoaderService {
-  logger = syncInject(Logger, {
+  logger = (0, import_di7.syncInject)(Logger, {
     context: _ModuleLoaderService.name
   });
   modulesMetadata = /* @__PURE__ */ new Map();
@@ -1743,7 +914,7 @@ var _ModuleLoaderService = class _ModuleLoaderService {
       async (importedModule) => this.traverseModules(importedModule, metadata)
     );
     await Promise.all(loadingPromises);
-    const instance = await inject(module2);
+    const instance = await (0, import_di7.inject)(module2);
     if (instance.onModuleInit) {
       await instance.onModuleInit();
     }
@@ -1774,24 +945,26 @@ var _ModuleLoaderService = class _ModuleLoaderService {
     this.initialized = false;
   }
 };
-_init3 = __decoratorStart(null);
-_ModuleLoaderService = __decorateElement(_init3, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
-__runInitializers(_init3, 1, _ModuleLoaderService);
+_init6 = __decoratorStart(null);
+_ModuleLoaderService = __decorateElement(_init6, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, _ModuleLoaderService);
+__runInitializers(_init6, 1, _ModuleLoaderService);
 var ModuleLoaderService = _ModuleLoaderService;
 
 // packages/core/src/tokens/execution-context.token.mts
 var ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
-var ExecutionContextToken = InjectionToken.create(
+var ExecutionContextToken = import_di8.InjectionToken.create(
   ExecutionContextInjectionToken
 );
 
 // packages/core/src/tokens/reply.token.mts
+var import_di9 = require("@navios/di");
 var ReplyInjectionToken = "ReplyInjectionToken";
-var Reply = InjectionToken.create(ReplyInjectionToken);
+var Reply = import_di9.InjectionToken.create(ReplyInjectionToken);
 
 // packages/core/src/tokens/request.token.mts
+var import_di10 = require("@navios/di");
 var RequestInjectionToken = "RequestInjectionToken";
-var Request = InjectionToken.create(
+var Request = import_di10.InjectionToken.create(
   RequestInjectionToken
 );
 
@@ -1813,8 +986,8 @@ var dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
   day: "2-digit",
   month: "2-digit"
 });
-var _ConsoleLogger_decorators, _init4;
-_ConsoleLogger_decorators = [Injectable()];
+var _ConsoleLogger_decorators, _init7;
+_ConsoleLogger_decorators = [(0, import_di11.Injectable)()];
 var _ConsoleLogger = class _ConsoleLogger {
   /**
    * The options of the logger.
@@ -1853,7 +1026,7 @@ var _ConsoleLogger = class _ConsoleLogger {
       this.originalContext = context;
     }
     if (opts == null ? void 0 : opts.requestId) {
-      const locator = getServiceLocator();
+      const locator = (0, import_di11.getGlobalServiceLocator)();
       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;
@@ -1949,8 +1122,8 @@ var _ConsoleLogger = class _ConsoleLogger {
     this.context = this.originalContext;
   }
   isLevelEnabled(level) {
-    var _a;
-    const logLevels = (_a = this.options) == null ? void 0 : _a.logLevels;
+    var _a3;
+    const logLevels = (_a3 = this.options) == null ? void 0 : _a3.logLevels;
     return isLogLevelEnabled(level, logLevels);
   }
   getTimestamp() {
@@ -2061,8 +1234,8 @@ var _ConsoleLogger = class _ConsoleLogger {
 `);
   }
   updateAndGetTimestampDiff() {
-    var _a;
-    const includeTimestamp = _ConsoleLogger.lastTimestampAt && ((_a = this.options) == null ? void 0 : _a.timestamp);
+    var _a3;
+    const includeTimestamp = _ConsoleLogger.lastTimestampAt && ((_a3 = this.options) == null ? void 0 : _a3.timestamp);
     const result = includeTimestamp ? this.formatTimestampDiff(Date.now() - _ConsoleLogger.lastTimestampAt) : "";
     _ConsoleLogger.lastTimestampAt = Date.now();
     return result;
@@ -2167,15 +1340,17 @@ var _ConsoleLogger = class _ConsoleLogger {
     }
   }
 };
-_init4 = __decoratorStart(null);
-_ConsoleLogger = __decorateElement(_init4, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
-__runInitializers(_init4, 1, _ConsoleLogger);
+_init7 = __decoratorStart(null);
+_ConsoleLogger = __decorateElement(_init7, 0, "ConsoleLogger", _ConsoleLogger_decorators, _ConsoleLogger);
+__runInitializers(_init7, 1, _ConsoleLogger);
 var ConsoleLogger = _ConsoleLogger;
 
 // packages/core/src/logger/logger.factory.mts
-var import_zod3 = require("zod");
+var import_di13 = require("@navios/di");
+var import_zod2 = require("zod");
 
 // packages/core/src/logger/logger.service.mts
+var import_di12 = require("@navios/di");
 var DEFAULT_LOGGER = new ConsoleLogger();
 var dateTimeFormatter2 = new Intl.DateTimeFormat(void 0, {
   year: "numeric",
@@ -2185,8 +1360,8 @@ var dateTimeFormatter2 = new Intl.DateTimeFormat(void 0, {
   day: "2-digit",
   month: "2-digit"
 });
-var _LoggerInstance_decorators, _init5;
-_LoggerInstance_decorators = [Injectable()];
+var _LoggerInstance_decorators, _init8;
+_LoggerInstance_decorators = [(0, import_di12.Injectable)()];
 var _LoggerInstance = class _LoggerInstance {
   constructor(context, options = {}) {
     this.context = context;
@@ -2207,69 +1382,69 @@ var _LoggerInstance = class _LoggerInstance {
     return _LoggerInstance.staticInstanceRef;
   }
   error(message, ...optionalParams) {
-    var _a;
+    var _a3;
     optionalParams = this.context ? (optionalParams.length ? optionalParams : [void 0]).concat(
       this.context
     ) : optionalParams;
-    (_a = this.localInstance) == null ? void 0 : _a.error(message, ...optionalParams);
+    (_a3 = this.localInstance) == null ? void 0 : _a3.error(message, ...optionalParams);
   }
   log(message, ...optionalParams) {
-    var _a;
+    var _a3;
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_a = this.localInstance) == null ? void 0 : _a.log(message, ...optionalParams);
+    (_a3 = this.localInstance) == null ? void 0 : _a3.log(message, ...optionalParams);
   }
   warn(message, ...optionalParams) {
-    var _a;
+    var _a3;
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_a = this.localInstance) == null ? void 0 : _a.warn(message, ...optionalParams);
+    (_a3 = this.localInstance) == null ? void 0 : _a3.warn(message, ...optionalParams);
   }
   debug(message, ...optionalParams) {
-    var _a, _b;
+    var _a3, _b;
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_b = (_a = this.localInstance) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    (_b = (_a3 = this.localInstance) == null ? void 0 : _a3.debug) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   verbose(message, ...optionalParams) {
-    var _a, _b;
+    var _a3, _b;
     optionalParams = this.context ? optionalParams.concat(this.context) : optionalParams;
-    (_b = (_a = this.localInstance) == null ? void 0 : _a.verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    (_b = (_a3 = this.localInstance) == null ? void 0 : _a3.verbose) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   fatal(message, ...optionalParams) {
-    var _a, _b;
+    var _a3, _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);
+    (_b = (_a3 = this.localInstance) == null ? void 0 : _a3.fatal) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   static error(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.error(message, ...optionalParams);
+    var _a3;
+    (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.error(message, ...optionalParams);
   }
   static log(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.log(message, ...optionalParams);
+    var _a3;
+    (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.log(message, ...optionalParams);
   }
   static warn(message, ...optionalParams) {
-    var _a;
-    (_a = this.staticInstanceRef) == null ? void 0 : _a.warn(message, ...optionalParams);
+    var _a3;
+    (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.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);
+    var _a3, _b;
+    (_b = (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.debug) == null ? void 0 : _b.call(_a3, 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);
+    var _a3, _b;
+    (_b = (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.verbose) == null ? void 0 : _b.call(_a3, 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);
+    var _a3, _b;
+    (_b = (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.fatal) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   static getTimestamp() {
     return dateTimeFormatter2.format(Date.now());
   }
   static overrideLogger(logger) {
-    var _a, _b;
+    var _a3, _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);
+      return (_b = (_a3 = this.staticInstanceRef) == null ? void 0 : _a3.setLogLevels) == null ? void 0 : _b.call(_a3, logger);
     }
     if (isObject(logger)) {
       this.staticInstanceRef = logger;
@@ -2282,34 +1457,34 @@ var _LoggerInstance = class _LoggerInstance {
     return isLogLevelEnabled(level, logLevels);
   }
   registerLocalInstanceRef() {
-    var _a;
+    var _a3;
     if (this.localInstanceRef) {
       return this.localInstanceRef;
     }
     this.localInstanceRef = new ConsoleLogger(this.context, {
-      timestamp: (_a = this.options) == null ? void 0 : _a.timestamp,
+      timestamp: (_a3 = this.options) == null ? void 0 : _a3.timestamp,
       logLevels: _LoggerInstance.logLevels
     });
     return this.localInstanceRef;
   }
 };
-_init5 = __decoratorStart(null);
-_LoggerInstance = __decorateElement(_init5, 0, "LoggerInstance", _LoggerInstance_decorators, _LoggerInstance);
-__runInitializers(_init5, 1, _LoggerInstance);
+_init8 = __decoratorStart(null);
+_LoggerInstance = __decorateElement(_init8, 0, "LoggerInstance", _LoggerInstance_decorators, _LoggerInstance);
+__runInitializers(_init8, 1, _LoggerInstance);
 var LoggerInstance = _LoggerInstance;
 
 // 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()
+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, _init6;
-_LoggerFactory_decorators = [Injectable({
-  type: "Factory" /* Factory */,
+var Logger = import_di13.InjectionToken.create(LoggerInjectionToken, LoggerOptions);
+var _LoggerFactory_decorators, _init9;
+_LoggerFactory_decorators = [(0, import_di13.Injectable)({
+  type: import_di13.InjectableType.Factory,
   token: Logger
 })];
 var LoggerFactory = class {
@@ -2317,9 +1492,9 @@ var LoggerFactory = class {
     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);
+_init9 = __decoratorStart(null);
+LoggerFactory = __decorateElement(_init9, 0, "LoggerFactory", _LoggerFactory_decorators, LoggerFactory);
+__runInitializers(_init9, 1, LoggerFactory);
 
 // packages/core/src/logger/pino-wrapper.mts
 var PinoWrapper = class _PinoWrapper {
@@ -2341,12 +1516,12 @@ var PinoWrapper = class _PinoWrapper {
   info() {
   }
   debug(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    var _a3, _b;
+    (_b = (_a3 = this.logger).debug) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   trace(message, ...optionalParams) {
-    var _a, _b;
-    (_b = (_a = this.logger).verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
+    var _a3, _b;
+    (_b = (_a3 = this.logger).verbose) == null ? void 0 : _b.call(_a3, message, ...optionalParams);
   }
   silent() {
   }
@@ -2374,7 +1549,7 @@ var PinoWrapper = class _PinoWrapper {
 };
 
 // packages/core/src/config/config.service.mts
-var import_common4 = require("@navios/common");
+var import_common = require("@navios/common");
 var ConfigServiceInstance = class {
   constructor(config = {}, logger) {
     this.config = config;
@@ -2384,7 +1559,7 @@ var ConfigServiceInstance = class {
     return this.config;
   }
   get(key) {
-    var _a, _b;
+    var _a3, _b;
     try {
       const parts = String(key).split(".");
       let value = this.config;
@@ -2396,8 +1571,8 @@ var ConfigServiceInstance = class {
       }
       return value ?? null;
     } catch (error) {
-      (_b = (_a = this.logger).debug) == null ? void 0 : _b.call(
-        _a,
+      (_b = (_a3 = this.logger).debug) == null ? void 0 : _b.call(
+        _a3,
         `Failed to get config value for key ${String(key)}`,
         error
       );
@@ -2413,24 +1588,24 @@ var ConfigServiceInstance = class {
     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);
+      throw new import_common.NaviosException(message);
     }
     return value;
   }
 };
 
 // packages/core/src/config/config.provider.mts
-var ConfigProviderOptions = import_zod4.z.object({
-  load: import_zod4.z.function()
+var ConfigProviderOptions = import_zod3.z.object({
+  load: import_zod3.z.function()
 });
-var ConfigProvider = InjectionToken.create(ConfigServiceInstance, ConfigProviderOptions);
-var _ConfigProviderFactory_decorators, _init7;
-_ConfigProviderFactory_decorators = [Injectable({
+var ConfigProvider = import_di14.InjectionToken.create(ConfigServiceInstance, ConfigProviderOptions);
+var _ConfigProviderFactory_decorators, _init10;
+_ConfigProviderFactory_decorators = [(0, import_di14.Injectable)({
   token: ConfigProvider,
-  type: "Factory" /* Factory */
+  type: import_di14.InjectableType.Factory
 })];
 var ConfigProviderFactory = class {
-  logger = syncInject(Logger, {
+  logger = (0, import_di14.syncInject)(Logger, {
     context: "ConfigService"
   });
   async create(ctx, args) {
@@ -2438,21 +1613,25 @@ var ConfigProviderFactory = class {
     const logger = this.logger;
     try {
       const config = await load();
-      return new ConfigServiceInstance(config, logger);
+      return new ConfigServiceInstance(
+        config,
+        logger
+      );
     } catch (error) {
       logger.error("Error loading config", error);
       throw error;
     }
   }
 };
-_init7 = __decoratorStart(null);
-ConfigProviderFactory = __decorateElement(_init7, 0, "ConfigProviderFactory", _ConfigProviderFactory_decorators, ConfigProviderFactory);
-__runInitializers(_init7, 1, ConfigProviderFactory);
+_init10 = __decoratorStart(null);
+ConfigProviderFactory = __decorateElement(_init10, 0, "ConfigProviderFactory", _ConfigProviderFactory_decorators, ConfigProviderFactory);
+__runInitializers(_init10, 1, ConfigProviderFactory);
 function provideConfig(options) {
-  return InjectionToken.bound(ConfigProvider, options);
+  return import_di14.InjectionToken.bound(ConfigProvider, options);
 }
 
 // packages/core/src/decorators/controller.decorator.mts
+var import_di15 = require("@navios/di");
 function Controller({ guards } = {}) {
   return function(target, context) {
     if (context.kind !== "class") {
@@ -2460,7 +1639,7 @@ function Controller({ guards } = {}) {
         "[Navios] @Controller decorator can only be used on classes."
       );
     }
-    const token = InjectionToken.create(target);
+    const token = import_di15.InjectionToken.create(target);
     if (context.metadata) {
       const controllerMetadata = getControllerMetadata(target, context);
       if (guards) {
@@ -2469,16 +1648,15 @@ function Controller({ guards } = {}) {
         }
       }
     }
-    return Injectable({
+    return (0, import_di15.Injectable)({
       token,
-      type: "Class" /* Class */,
-      scope: "Instance" /* Instance */
+      scope: import_di15.InjectableScope.Instance
     })(target, context);
   };
 }
 
 // packages/core/src/decorators/endpoint.decorator.mts
-var import_zod5 = require("zod");
+var import_zod4 = require("zod");
 function Endpoint(endpoint) {
   return (target, context) => {
     if (typeof target !== "function") {
@@ -2493,14 +1671,17 @@ function Endpoint(endpoint) {
     }
     const config = endpoint.config;
     if (context.metadata) {
-      let endpointMetadata = getEndpointMetadata(target, context);
+      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.adapterToken = EndpointAdapterToken;
       endpointMetadata.classMethod = target.name;
       endpointMetadata.httpMethod = config.method;
       endpointMetadata.url = config.url;
@@ -2510,18 +1691,13 @@ function Endpoint(endpoint) {
 }
 
 // packages/core/src/decorators/header.decorator.mts
-function Header(name2, value) {
+function Header(name, 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."
-      );
-    }
-    metadata.headers[name2] = value;
+    metadata.headers[name] = value;
     return target;
   };
 }
@@ -2535,49 +1711,42 @@ function HttpCode(code) {
       );
     }
     const metadata = getEndpointMetadata(target, context);
-    if (metadata.type === "stream" /* Stream */) {
-      throw new Error(
-        "[Navios] HttpCode decorator cannot be used on stream endpoints."
-      );
-    }
     metadata.successStatusCode = code;
     return target;
   };
 }
 
 // packages/core/src/decorators/module.decorator.mts
-function Module(metadata) {
+var import_di16 = require("@navios/di");
+function Module({ controllers = [], imports = [], guards = [] } = {
+  controllers: [],
+  imports: [],
+  guards: []
+}) {
   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 token = import_di16.InjectionToken.create(target);
     const moduleMetadata = getModuleMetadata(target, context);
-    if (metadata.controllers) {
-      for (const controller of metadata.controllers) {
-        moduleMetadata.controllers.add(controller);
-      }
+    for (const controller of controllers) {
+      moduleMetadata.controllers.add(controller);
     }
-    if (metadata.imports) {
-      for (const importedModule of metadata.imports) {
-        moduleMetadata.imports.add(importedModule);
-      }
+    for (const importedModule of imports) {
+      moduleMetadata.imports.add(importedModule);
     }
-    if (metadata.guards) {
-      for (const guard of Array.from(metadata.guards).reverse()) {
-        moduleMetadata.guards.add(guard);
-      }
+    for (const guard of Array.from(guards).reverse()) {
+      moduleMetadata.guards.add(guard);
     }
-    return Injectable({
+    return (0, import_di16.Injectable)({
       token,
-      type: "Class" /* Class */,
-      scope: "Singleton" /* Singleton */
+      scope: import_di16.InjectableScope.Singleton
     })(target, context);
   };
 }
 
 // packages/core/src/decorators/multipart.decorator.mts
-var import_zod6 = require("zod");
+var import_zod5 = require("zod");
 function Multipart(endpoint) {
   return (target, context) => {
     if (typeof target !== "function") {
@@ -2592,14 +1761,17 @@ function Multipart(endpoint) {
     }
     const config = endpoint.config;
     if (context.metadata) {
-      let endpointMetadata = getEndpointMetadata(target, context);
+      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.adapterToken = MultipartAdapterToken;
       endpointMetadata.classMethod = target.name;
       endpointMetadata.httpMethod = config.method;
       endpointMetadata.url = config.url;
@@ -2623,14 +1795,17 @@ function Stream(endpoint) {
     }
     const config = endpoint.config;
     if (context.metadata) {
-      let endpointMetadata = getEndpointMetadata(target, context);
+      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.adapterToken = StreamAdapterToken;
       endpointMetadata.classMethod = target.name;
       endpointMetadata.httpMethod = config.method;
       endpointMetadata.url = config.url;
@@ -2722,16 +1897,17 @@ var AttributeFactory = class {
 };
 
 // packages/core/src/navios.application.mts
+var import_di17 = require("@navios/di");
 var import_cors = __toESM(require("@fastify/cors"), 1);
 var import_multipart = __toESM(require("@fastify/multipart"), 1);
 var import_fastify = require("fastify");
 var import_fastify_type_provider_zod = require("fastify-type-provider-zod");
-var _NaviosApplication_decorators, _init8;
-_NaviosApplication_decorators = [Injectable()];
+var _NaviosApplication_decorators, _init11;
+_NaviosApplication_decorators = [(0, import_di17.Injectable)()];
 var _NaviosApplication = class _NaviosApplication {
-  moduleLoader = syncInject(ModuleLoaderService);
-  controllerAdapter = syncInject(ControllerAdapterService);
-  logger = syncInject(Logger, {
+  moduleLoader = (0, import_di17.syncInject)(ModuleLoaderService);
+  controllerAdapter = (0, import_di17.syncInject)(ControllerAdapterService);
+  logger = (0, import_di17.syncInject)(Logger, {
     context: _NaviosApplication.name
   });
   server = null;
@@ -2752,7 +1928,7 @@ var _NaviosApplication = class _NaviosApplication {
     await this.moduleLoader.loadModules(this.appModule);
     this.server = await this.getFastifyInstance(this.options);
     this.configureFastifyInstance(this.server);
-    getServiceLocator().registerInstance(Application, this.server);
+    (0, import_di17.getGlobalServiceLocator)().storeInstance(this.server, Application);
     this.server.setValidatorCompiler(import_fastify_type_provider_zod.validatorCompiler);
     this.server.setSerializerCompiler(import_fastify_type_provider_zod.serializerCompiler);
     if (this.corsOptions) {
@@ -2776,7 +1952,7 @@ var _NaviosApplication = class _NaviosApplication {
         }
       } else {
         fastifyOptions.loggerInstance = new PinoWrapper(
-          await inject(Logger, {
+          await (0, import_di17.inject)(Logger, {
             context: "FastifyAdapter"
           })
         );
@@ -2786,7 +1962,7 @@ var _NaviosApplication = class _NaviosApplication {
       return (0, import_fastify.fastify)({
         ...options,
         loggerInstance: new PinoWrapper(
-          await inject(Logger, {
+          await (0, import_di17.inject)(Logger, {
             context: "FastifyAdapter"
           })
         )
@@ -2818,7 +1994,7 @@ var _NaviosApplication = class _NaviosApplication {
         message: "Not Found",
         error: "NotFound"
       };
-      this.logger.error(`Route not found: ${req.url}`);
+      this.logger.error(`Route not found: [${req.method}] ${req.url}`);
       return reply.status(404).send(response);
     });
   }
@@ -2839,15 +2015,14 @@ var _NaviosApplication = class _NaviosApplication {
       }
       promises.push(
         this.server.register(
-          (instance, opts, done) => {
+          async (instance, opts) => {
             for (const controller of moduleMetadata.controllers) {
-              this.controllerAdapter.setupController(
+              await this.controllerAdapter.setupController(
                 controller,
                 instance,
                 moduleMetadata
               );
             }
-            done();
           },
           {
             prefix: this.globalPrefix ?? ""
@@ -2892,15 +2067,16 @@ var _NaviosApplication = class _NaviosApplication {
     await this.dispose();
   }
 };
-_init8 = __decoratorStart(null);
-_NaviosApplication = __decorateElement(_init8, 0, "NaviosApplication", _NaviosApplication_decorators, _NaviosApplication);
-__runInitializers(_init8, 1, _NaviosApplication);
+_init11 = __decoratorStart(null);
+_NaviosApplication = __decorateElement(_init11, 0, "NaviosApplication", _NaviosApplication_decorators, _NaviosApplication);
+__runInitializers(_init11, 1, _NaviosApplication);
 var NaviosApplication = _NaviosApplication;
 
 // packages/core/src/navios.factory.mts
+var import_di18 = require("@navios/di");
 var NaviosFactory = class {
   static async create(appModule, options = {}) {
-    const app = await inject(NaviosApplication);
+    const app = await (0, import_di18.inject)(NaviosApplication);
     this.registerLoggerConfiguration(options);
     app.setup(appModule, options);
     return app;
@@ -2920,7 +2096,6 @@ var NaviosFactory = class {
   Application,
   AttributeFactory,
   BadRequestException,
-  BoundInjectionToken,
   ConfigProvider,
   ConfigProviderFactory,
   ConfigProviderOptions,
@@ -2931,29 +2106,17 @@ var NaviosFactory = class {
   ControllerAdapterService,
   ControllerMetadataKey,
   Endpoint,
+  EndpointAdapterService,
+  EndpointAdapterToken,
   EndpointMetadataKey,
-  EndpointType,
-  ErrorsEnum,
-  EventEmitter,
   ExecutionContext,
   ExecutionContextInjectionToken,
   ExecutionContextToken,
-  FactoryInjectionToken,
-  FactoryNotFound,
-  FactoryTokenNotResolved,
   ForbiddenException,
   GuardRunnerService,
   Header,
   HttpCode,
   HttpException,
-  Injectable,
-  InjectableScope,
-  InjectableTokenMeta,
-  InjectableType,
-  InjectionToken,
-  InstanceDestroying,
-  InstanceExpired,
-  InstanceNotFound,
   InternalServerErrorException,
   LOG_LEVELS,
   Logger,
@@ -2965,20 +2128,18 @@ var NaviosFactory = class {
   ModuleLoaderService,
   ModuleMetadataKey,
   Multipart,
+  MultipartAdapterService,
+  MultipartAdapterToken,
   NaviosApplication,
   NaviosFactory,
   NotFoundException,
   PinoWrapper,
   Reply,
   Request,
-  ServiceLocator,
-  ServiceLocatorEventBus,
-  ServiceLocatorInstanceHolderKind,
-  ServiceLocatorInstanceHolderStatus,
-  ServiceLocatorManager,
   Stream,
+  StreamAdapterService,
+  StreamAdapterToken,
   UnauthorizedException,
-  UnknownError,
   UseGuards,
   addLeadingSlash,
   clc,
@@ -2990,12 +2151,9 @@ var NaviosFactory = class {
   getAllEndpointMetadata,
   getControllerMetadata,
   getEndpointMetadata,
-  getInjectableToken,
   getModuleMetadata,
-  getServiceLocator,
   hasControllerMetadata,
   hasModuleMetadata,
-  inject,
   isConstructor,
   isEmpty,
   isFunction,
@@ -3009,12 +2167,8 @@ var NaviosFactory = class {
   isSymbol,
   isUndefined,
   normalizePath,
-  override,
   provideConfig,
-  provideServiceLocator,
-  resolveService,
-  setPromiseCollector,
   stripEndSlash,
-  syncInject,
-  yellow
+  yellow,
+  ...require("@navios/di")
 });