@navios/core 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -57,7 +57,7 @@ function envString(key, defaultValue) {
 }
 
 // packages/core/src/config/config.provider.mts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // packages/core/src/logger/utils/cli-colors.util.mts
 var isColorAllowed = () => !process.env.NO_COLOR;
@@ -157,6 +157,9 @@ var isSymbol = (val) => typeof val === "symbol";
 // packages/core/src/logger/console-logger.service.mts
 import { inspect } from "util";
 
+// packages/core/src/service-locator/decorators/injectable.decorator.mts
+import { NaviosException as NaviosException2 } from "@navios/common";
+
 // packages/core/src/service-locator/enums/injectable-scope.enum.mts
 var InjectableScope = /* @__PURE__ */ ((InjectableScope2) => {
   InjectableScope2["Singleton"] = "Singleton";
@@ -176,8 +179,38 @@ var InjectionToken = class _InjectionToken {
   static create(name2, schema) {
     return new _InjectionToken(name2, schema);
   }
-  toString() {
-    return this.name;
+  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;
   }
 };
 
@@ -188,6 +221,7 @@ var ErrorsEnum = /* @__PURE__ */ ((ErrorsEnum2) => {
   ErrorsEnum2["InstanceDestroying"] = "InstanceDestroying";
   ErrorsEnum2["UnknownError"] = "UnknownError";
   ErrorsEnum2["FactoryNotFound"] = "FactoryNotFound";
+  ErrorsEnum2["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
   return ErrorsEnum2;
 })(ErrorsEnum || {});
 
@@ -200,6 +234,14 @@ var FactoryNotFound = class extends Error {
   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) {
@@ -442,29 +484,48 @@ var ServiceLocator = class {
       this.instanceFactories.delete(token);
     }
   }
-  getInstanceIdentifier(token, args) {
-    var _a;
-    const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
-    if (validatedArgs && !validatedArgs.success) {
-      (_a = this.logger) == null ? void 0 : _a.error(
-        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
-        validatedArgs.error
-      );
-      throw new UnknownError(validatedArgs.error);
+  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)];
+      }
     }
-    return this.makeInstanceName(token, validatedArgs);
-  }
-  async getInstance(token, args) {
-    var _a, _b, _c;
-    const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
+    if (!token.schema) {
+      return [void 0, realArgs];
+    }
+    const validatedArgs = (_a = token.schema) == null ? void 0 : _a.safeParse(realArgs);
     if (validatedArgs && !validatedArgs.success) {
-      (_a = this.logger) == null ? void 0 : _a.error(
+      (_b = this.logger) == null ? void 0 : _b.error(
         `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
         validatedArgs.error
       );
       return [new UnknownError(validatedArgs.error)];
     }
-    const instanceName = this.makeInstanceName(token, validatedArgs);
+    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 */) {
@@ -476,13 +537,13 @@ var ServiceLocator = class {
     }
     switch (error.code) {
       case "InstanceDestroying" /* InstanceDestroying */:
-        (_b = this.logger) == null ? void 0 : _b.log(
+        (_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 */:
-        (_c = this.logger) == null ? void 0 : _c.log(
+        (_b = this.logger) == null ? void 0 : _b.log(
           `[ServiceLocator]#getInstance() TTL expired for ${holder == null ? void 0 : holder.name}`
         );
         await this.invalidate(instanceName);
@@ -492,7 +553,7 @@ var ServiceLocator = class {
       default:
         return [error];
     }
-    return this.createInstance(instanceName, token, args);
+    return this.createInstance(instanceName, token, realArgs);
   }
   async getOrThrowInstance(token, args) {
     const [error, instance] = await this.getInstance(token, args);
@@ -513,10 +574,15 @@ var ServiceLocator = class {
     (_a = this.logger) == null ? void 0 : _a.log(
       `[ServiceLocator]#createInstance() Creating instance for ${instanceName}`
     );
-    if (this.abstractFactories.has(token) || this.instanceFactories.has(token)) {
-      return this.createInstanceFromAbstractFactory(instanceName, token, args);
+    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(token.name.toString())];
+      return [new FactoryNotFound(realToken.name.toString())];
     }
   }
   async createInstanceFromAbstractFactory(instanceName, token, args) {
@@ -563,7 +629,7 @@ var ServiceLocator = class {
             );
           });
         }
-        if (holder.ttl === 0) {
+        if (holder.ttl === 0 || !shouldStore) {
           await this.invalidate(instanceName);
         }
         await this.notifyListeners(instanceName);
@@ -635,16 +701,11 @@ var ServiceLocator = class {
     };
   }
   getSyncInstance(token, args) {
-    var _a;
-    const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
-    if (validatedArgs && !validatedArgs.success) {
-      (_a = this.logger) == null ? void 0 : _a.error(
-        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
-        validatedArgs.error
-      );
-      throw new UnknownError(validatedArgs.error);
+    const [err, realArgs] = this.resolveTokenArgs(token, args);
+    if (err) {
+      return null;
     }
-    const instanceName = this.makeInstanceName(token, validatedArgs);
+    const instanceName = this.makeInstanceName(token, realArgs);
     const [error, holder] = this.manager.get(instanceName);
     if (error) {
       return null;
@@ -752,6 +813,9 @@ function getServiceLocator() {
   return serviceLocator;
 }
 
+// packages/core/src/service-locator/resolve-service.mts
+import { NaviosException } from "@navios/common";
+
 // packages/core/src/service-locator/proxy-service-locator.mts
 var ProxyServiceLocator = class {
   constructor(serviceLocator2, ctx) {
@@ -800,14 +864,6 @@ function makeProxyServiceLocator(serviceLocator2, ctx) {
 // packages/core/src/service-locator/sync-injector.mts
 var promiseCollector = null;
 function syncInject(token, args) {
-  if (token.schema) {
-    const parsed = token.schema.safeParse(args);
-    if (!parsed.success) {
-      throw new Error(
-        `[ServiceLocator] Invalid arguments for ${token.name.toString()}: ${parsed.error}`
-      );
-    }
-  }
   let realToken = token;
   if (!(token instanceof InjectionToken)) {
     realToken = getInjectableToken(token);
@@ -831,6 +887,40 @@ function setPromiseCollector(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 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";
@@ -851,62 +941,22 @@ function Injectable({
     }
     let injectableToken = token ?? InjectionToken.create(target);
     const locator = getServiceLocator();
-    if (!locator) {
-      throw new Error(
-        "[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator."
-      );
-    }
     if (type === "Class" /* Class */) {
       locator.registerAbstractFactory(
         injectableToken,
-        async (ctx) => {
-          if (scope === "Instance" /* Instance */) {
-            ctx.setTtl(0);
-          }
-          const proxyServiceLocator = makeProxyServiceLocator(
-            getServiceLocator(),
-            ctx
-          );
-          const promises = [];
-          const promiseCollector2 = (promise) => {
-            promises.push(promise);
-          };
-          const originalPromiseCollector = setPromiseCollector(promiseCollector2);
-          const tryInit = () => {
-            const original = provideServiceLocator(proxyServiceLocator);
-            let result2 = new target();
-            provideServiceLocator(original);
-            return result2;
-          };
-          const result = tryInit();
-          setPromiseCollector(originalPromiseCollector);
-          if (promises.length > 0) {
-            await Promise.all(promises);
-            return tryInit();
-          }
-          return result;
-        },
+        async (ctx) => resolveService(ctx, target),
         scope
       );
     } else if (type === "Factory" /* Factory */) {
       locator.registerAbstractFactory(
         injectableToken,
         async (ctx, args) => {
-          if (scope === "Instance" /* Instance */) {
-            ctx.setTtl(0);
-          }
-          const proxyServiceLocator = makeProxyServiceLocator(
-            getServiceLocator(),
-            ctx
-          );
-          const original = provideServiceLocator(proxyServiceLocator);
-          const builder = new target();
+          const builder = await resolveService(ctx, target);
           if (typeof builder.create !== "function") {
-            throw new Error(
+            throw new NaviosException2(
               `[ServiceLocator] Factory ${target.name} does not implement the create method.`
             );
           }
-          provideServiceLocator(original);
           return builder.create(ctx, args);
         },
         scope
@@ -969,14 +1019,6 @@ var EventEmitter = class {
 
 // packages/core/src/service-locator/inject.mts
 function inject(token, args) {
-  if (token.schema) {
-    const parsed = token.schema.safeParse(args);
-    if (!parsed.success) {
-      throw new Error(
-        `[ServiceLocator] Invalid arguments for ${token.name.toString()}: ${parsed.error}`
-      );
-    }
-  }
   let realToken = token;
   if (!(token instanceof InjectionToken)) {
     realToken = getInjectableToken(token);
@@ -1350,7 +1392,7 @@ __runInitializers(_init, 1, _ConsoleLogger);
 var ConsoleLogger = _ConsoleLogger;
 
 // packages/core/src/logger/logger.factory.mts
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // packages/core/src/logger/logger.service.mts
 var DEFAULT_LOGGER = new ConsoleLogger();
@@ -1444,7 +1486,6 @@ var _LoggerInstance = class _LoggerInstance {
   }
   static overrideLogger(logger) {
     var _a, _b;
-    console.log(logger);
     if (Array.isArray(logger)) {
       _LoggerInstance.logLevels = logger;
       return (_b = (_a = this.staticInstanceRef) == null ? void 0 : _a.setLogLevels) == null ? void 0 : _b.call(_a, logger);
@@ -1478,10 +1519,10 @@ var LoggerInstance = _LoggerInstance;
 
 // packages/core/src/logger/logger.factory.mts
 var LoggerInjectionToken = "LoggerInjectionToken";
-var LoggerOptions = z.object({
-  context: z.string().optional(),
-  options: z.object({
-    timestamp: z.boolean().optional()
+var LoggerOptions = z2.object({
+  context: z2.string().optional(),
+  options: z2.object({
+    timestamp: z2.boolean().optional()
   }).optional()
 }).optional();
 var Logger = InjectionToken.create(LoggerInjectionToken, LoggerOptions);
@@ -1516,8 +1557,7 @@ var PinoWrapper = class _PinoWrapper {
   warn(message, ...optionalParams) {
     this.logger.warn(message, ...optionalParams);
   }
-  info(message, ...optionalParams) {
-    this.logger.log(message, ...optionalParams);
+  info() {
   }
   debug(message, ...optionalParams) {
     var _a, _b;
@@ -1527,7 +1567,7 @@ var PinoWrapper = class _PinoWrapper {
     var _a, _b;
     (_b = (_a = this.logger).verbose) == null ? void 0 : _b.call(_a, message, ...optionalParams);
   }
-  silent(message, ...optionalParams) {
+  silent() {
   }
   child(options) {
     const keys = Object.keys(options);
@@ -1546,14 +1586,14 @@ var PinoWrapper = class _PinoWrapper {
     }
     const levels = LoggerInstance["logLevels"];
     if (levels) {
-      return levels[0];
+      return levels.find((level) => level !== "verbose");
     }
-    return "info";
+    return "warn";
   }
 };
 
 // packages/core/src/config/config.service.mts
-import { NaviosException } from "@navios/common";
+import { NaviosException as NaviosException3 } from "@navios/common";
 var ConfigServiceInstance = class {
   constructor(config = {}, logger) {
     this.config = config;
@@ -1592,30 +1632,29 @@ var ConfigServiceInstance = class {
     if (value === null) {
       const message = errorMessage || `Configuration value for key "${String(key)}" is not defined`;
       this.logger.error(message);
-      throw new NaviosException(message);
+      throw new NaviosException3(message);
     }
     return value;
   }
 };
 
 // packages/core/src/config/config.provider.mts
-var ConfigProviderInjectionToken = "ConfigProvider";
-var ConfigProviderOptions = z2.object({
-  load: z2.function()
+var ConfigProviderOptions = z3.object({
+  load: z3.function()
 });
-var ConfigProvider = InjectionToken.create(ConfigProviderInjectionToken, ConfigProviderOptions);
+var ConfigProvider = InjectionToken.create(ConfigServiceInstance, ConfigProviderOptions);
 var _ConfigProviderFactory_decorators, _init4;
 _ConfigProviderFactory_decorators = [Injectable({
   token: ConfigProvider,
   type: "Factory" /* Factory */
 })];
 var ConfigProviderFactory = class {
-  logger = inject(Logger, {
+  logger = syncInject(Logger, {
     context: "ConfigService"
   });
   async create(ctx, args) {
     const { load } = args;
-    const logger = await this.logger;
+    const logger = this.logger;
     try {
       const config = await load();
       return new ConfigServiceInstance(config, logger);
@@ -1628,25 +1667,18 @@ var ConfigProviderFactory = class {
 _init4 = __decoratorStart(null);
 ConfigProviderFactory = __decorateElement(_init4, 0, "ConfigProviderFactory", _ConfigProviderFactory_decorators, ConfigProviderFactory);
 __runInitializers(_init4, 1, ConfigProviderFactory);
-function makeConfigToken(options) {
-  var _ConfigServiceImpl_decorators, _init9;
-  _ConfigServiceImpl_decorators = [Injectable({
-    type: "Factory" /* Factory */
-  })];
-  class ConfigServiceImpl {
-    configService = inject(ConfigProvider, options);
-    create() {
-      return this.configService;
-    }
-  }
-  _init9 = __decoratorStart(null);
-  ConfigServiceImpl = __decorateElement(_init9, 0, "ConfigServiceImpl", _ConfigServiceImpl_decorators, ConfigServiceImpl);
-  __runInitializers(_init9, 1, ConfigServiceImpl);
-  return getInjectableToken(ConfigServiceImpl);
+function provideConfig(options) {
+  return InjectionToken.bound(ConfigProvider, options);
 }
 
 // packages/core/src/metadata/endpoint.metadata.mts
 var EndpointMetadataKey = Symbol("EndpointMetadataKey");
+var EndpointType = /* @__PURE__ */ ((EndpointType2) => {
+  EndpointType2["Unknown"] = "unknown";
+  EndpointType2["Config"] = "config";
+  EndpointType2["Handler"] = "handler";
+  return EndpointType2;
+})(EndpointType || {});
 function getAllEndpointMetadata(context) {
   if (context.metadata) {
     const metadata = context.metadata[EndpointMetadataKey];
@@ -1672,6 +1704,9 @@ function getEndpointMetadata(target, context) {
         const newMetadata = {
           classMethod: target.name,
           url: "",
+          successStatusCode: 200,
+          headers: {},
+          type: "unknown" /* Unknown */,
           httpMethod: "GET",
           config: null,
           guards: /* @__PURE__ */ new Set(),
@@ -1801,6 +1836,7 @@ function Endpoint(endpoint) {
         );
       }
       endpointMetadata.config = config;
+      endpointMetadata.type = "config" /* Config */;
       endpointMetadata.classMethod = target.name;
       endpointMetadata.httpMethod = config.method;
       endpointMetadata.url = config.url;
@@ -1809,6 +1845,32 @@ function Endpoint(endpoint) {
   };
 }
 
+// packages/core/src/decorators/header.decorator.mts
+function Header(name2, value) {
+  return (target, context) => {
+    if (context.kind !== "method") {
+      throw new Error("[Navios] Header decorator can only be used on methods.");
+    }
+    const metadata = getEndpointMetadata(target, context);
+    metadata.headers[name2] = value;
+    return target;
+  };
+}
+
+// packages/core/src/decorators/http-code.decorator.mts
+function HttpCode(code) {
+  return (target, context) => {
+    if (context.kind !== "method") {
+      throw new Error(
+        "[Navios] HttpCode decorator can only be used on methods."
+      );
+    }
+    const metadata = getEndpointMetadata(target, context);
+    metadata.successStatusCode = code;
+    return target;
+  };
+}
+
 // packages/core/src/decorators/module.decorator.mts
 function Module(metadata) {
   return (target, context) => {
@@ -1918,6 +1980,9 @@ var ConflictException = class extends HttpException {
   }
 };
 
+// packages/core/src/services/controller-adapter.service.mts
+import { NaviosException as NaviosException4 } from "@navios/common";
+
 // packages/core/src/tokens/application.token.mts
 var ApplicationInjectionToken = "ApplicationInjectionToken";
 var Application = InjectionToken.create(
@@ -2061,8 +2126,8 @@ var _ControllerAdapterService = class _ControllerAdapterService {
   setupController(controller, instance, moduleMetadata) {
     const controllerMetadata = extractControllerMetadata(controller);
     for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod, config } = endpoint;
-      if (!url || !config) {
+      const { classMethod, url, httpMethod } = endpoint;
+      if (!url) {
         throw new Error(
           `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`
         );
@@ -2072,91 +2137,115 @@ var _ControllerAdapterService = class _ControllerAdapterService {
         controllerMetadata,
         endpoint
       );
-      const guards = this.guardRunner.makeContext(executionContext);
-      const { querySchema, requestSchema, responseSchema } = config;
-      const schema = {};
-      if (querySchema) {
-        schema.querystring = querySchema;
-      }
-      if (requestSchema) {
-        schema.body = requestSchema;
-      }
-      if (responseSchema) {
-        schema.response = {
-          200: responseSchema
-        };
-      }
       instance.withTypeProvider().route({
         method: httpMethod,
         url: url.replaceAll("$", ":"),
-        schema,
-        preHandler: async (request, reply) => {
-          if (guards.size > 0) {
-            getServiceLocator().registerInstance(Request, request);
-            getServiceLocator().registerInstance(Reply, reply);
-            getServiceLocator().registerInstance(
-              ExecutionContextToken,
-              executionContext
-            );
-            executionContext.provideRequest(request);
-            executionContext.provideReply(reply);
-            const canActivate = await this.guardRunner.runGuards(
-              guards,
-              executionContext
-            );
-            getServiceLocator().removeInstance(Request);
-            getServiceLocator().removeInstance(Reply);
-            getServiceLocator().removeInstance(ExecutionContextToken);
-            if (!canActivate) {
-              return reply;
-            }
-          }
-        },
-        handler: async (request, reply) => {
-          getServiceLocator().registerInstance(Request, request);
-          getServiceLocator().registerInstance(Reply, reply);
-          getServiceLocator().registerInstance(
-            ExecutionContextToken,
-            executionContext
-          );
-          executionContext.provideRequest(request);
-          executionContext.provideReply(reply);
-          const controllerInstance = await inject(controller);
-          try {
-            const { query, params, body } = request;
-            const argument = {};
-            if (query && Object.keys(query).length > 0) {
-              argument.params = query;
-            }
-            if (params && Object.keys(params).length > 0) {
-              argument.urlParams = params;
-            }
-            if (body) {
-              argument.data = body;
-            }
-            const result = await controllerInstance[classMethod](argument);
-            reply.status(200).send(result);
-          } catch (error) {
-            if (error instanceof HttpException) {
-              reply.status(error.statusCode).send(error.response);
-            } else {
-              reply.status(500).send({
-                message: "Internal server error",
-                error: error.message
-              });
-            }
-          } finally {
-            getServiceLocator().removeInstance(Request);
-            getServiceLocator().removeInstance(Reply);
-            getServiceLocator().removeInstance(ExecutionContextToken);
-          }
-        }
+        schema: this.provideSchemaForConfig(endpoint),
+        preHandler: this.providePreHandler(executionContext),
+        handler: this.provideHandler(controller, executionContext, endpoint)
       });
       this.logger.debug(
         `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`
       );
     }
   }
+  providePreHandler(executionContext) {
+    const guards = this.guardRunner.makeContext(executionContext);
+    return guards.size > 0 ? async (request, reply) => {
+      getServiceLocator().registerInstance(Request, request);
+      getServiceLocator().registerInstance(Reply, reply);
+      getServiceLocator().registerInstance(
+        ExecutionContextToken,
+        executionContext
+      );
+      executionContext.provideRequest(request);
+      executionContext.provideReply(reply);
+      let canActivate = true;
+      try {
+        canActivate = await this.guardRunner.runGuards(
+          guards,
+          executionContext
+        );
+      } finally {
+        getServiceLocator().removeInstance(Request);
+        getServiceLocator().removeInstance(Reply);
+        getServiceLocator().removeInstance(ExecutionContextToken);
+      }
+      if (!canActivate) {
+        return reply;
+      }
+    } : void 0;
+  }
+  provideSchemaForConfig(endpointMetadata) {
+    if (!endpointMetadata.config) {
+      this.logger.warn(`No config found for endpoint ${endpointMetadata.url}`);
+      return {};
+    }
+    const { querySchema, requestSchema, responseSchema } = endpointMetadata.config;
+    const schema = {};
+    if (querySchema) {
+      schema.querystring = querySchema;
+    }
+    if (requestSchema) {
+      schema.body = requestSchema;
+    }
+    if (responseSchema) {
+      schema.response = {
+        200: responseSchema
+      };
+    }
+    return schema;
+  }
+  provideHandler(controller, executionContext, endpointMetadata) {
+    switch (endpointMetadata.type) {
+      case "unknown" /* Unknown */:
+        this.logger.error(
+          `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`
+        );
+        throw new NaviosException4("Unknown endpoint type");
+      case "config" /* Config */:
+        return this.provideHandlerForConfig(
+          controller,
+          executionContext,
+          endpointMetadata
+        );
+      case "handler" /* Handler */:
+        this.logger.error("Not implemented yet");
+        throw new NaviosException4("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);
+      }
+    };
+  }
 };
 _init6 = __decoratorStart(null);
 _ControllerAdapterService = __decorateElement(_init6, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, _ControllerAdapterService);
@@ -2313,6 +2402,7 @@ var _NaviosApplication = class _NaviosApplication {
     }
     await this.moduleLoader.loadModules(this.appModule);
     this.server = await this.getFastifyInstance(this.options);
+    this.configureFastifyInstance(this.server);
     getServiceLocator().registerInstance(Application, this.server);
     this.server.setValidatorCompiler(validatorCompiler);
     this.server.setSerializerCompiler(serializerCompiler);
@@ -2320,6 +2410,7 @@ var _NaviosApplication = class _NaviosApplication {
       await this.server.register(cors, this.corsOptions);
     }
     await this.initModules();
+    await this.server.ready();
     this.logger.debug("Navios application initialized");
   }
   async getFastifyInstance(rawOptions) {
@@ -2349,6 +2440,35 @@ var _NaviosApplication = class _NaviosApplication {
       });
     }
   }
+  configureFastifyInstance(fastifyInstance) {
+    fastifyInstance.setErrorHandler((error, request, reply) => {
+      if (error instanceof HttpException) {
+        return reply.status(error.statusCode).send(error.response);
+      } else {
+        const statusCode = error.statusCode || 500;
+        const message = error.message || "Internal Server Error";
+        const response = {
+          statusCode,
+          message,
+          error: error.name || "InternalServerError"
+        };
+        this.logger.error(
+          `Error occurred: ${error.message} on ${request.url}`,
+          error
+        );
+        return reply.status(statusCode).send(response);
+      }
+    });
+    fastifyInstance.setNotFoundHandler((req, reply) => {
+      const response = {
+        statusCode: 404,
+        message: "Not Found",
+        error: "NotFound"
+      };
+      this.logger.error(`Route not found: ${req.url}`);
+      return reply.status(404).send(response);
+    });
+  }
   async initModules() {
     const modules = this.moduleLoader.getAllModules();
     const promises = [];
@@ -2392,7 +2512,8 @@ var _NaviosApplication = class _NaviosApplication {
     if (!this.server) {
       throw new Error("Server is not initialized. Call init() first.");
     }
-    await this.server.listen(options);
+    const res = await this.server.listen(options);
+    this.logger.debug(`Navios is listening on ${res}`);
   }
 };
 _init8 = __decoratorStart(null);
@@ -2422,9 +2543,9 @@ export {
   Application,
   AttributeFactory,
   BadRequestException,
+  BoundInjectionToken,
   ConfigProvider,
   ConfigProviderFactory,
-  ConfigProviderInjectionToken,
   ConfigProviderOptions,
   ConfigServiceInstance,
   ConflictException,
@@ -2434,14 +2555,19 @@ export {
   ControllerMetadataKey,
   Endpoint,
   EndpointMetadataKey,
+  EndpointType,
   ErrorsEnum,
   EventEmitter,
   ExecutionContext2 as ExecutionContext,
   ExecutionContextInjectionToken,
   ExecutionContextToken,
+  FactoryInjectionToken,
   FactoryNotFound,
+  FactoryTokenNotResolved,
   ForbiddenException,
   GuardRunnerService,
+  Header,
+  HttpCode,
   HttpException,
   Injectable,
   InjectableScope,
@@ -2503,10 +2629,11 @@ export {
   isString,
   isSymbol,
   isUndefined,
-  makeConfigToken,
   normalizePath,
   override,
+  provideConfig,
   provideServiceLocator,
+  resolveService,
   setPromiseCollector,
   stripEndSlash,
   syncInject,