@navios/core 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -1444,7 +1444,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);
@@ -1516,8 +1515,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 +1525,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,9 +1544,9 @@ var PinoWrapper = class _PinoWrapper {
     }
     const levels = LoggerInstance["logLevels"];
     if (levels) {
-      return levels[0];
+      return levels.find((level) => level !== "verbose");
     }
-    return "info";
+    return "warn";
   }
 };
 
@@ -1647,6 +1645,12 @@ function makeConfigToken(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 +1676,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 +1808,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 +1817,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 +1952,9 @@ var ConflictException = class extends HttpException {
   }
 };
 
+// packages/core/src/services/controller-adapter.service.mts
+import { NaviosException as NaviosException2 } from "@navios/common";
+
 // packages/core/src/tokens/application.token.mts
 var ApplicationInjectionToken = "ApplicationInjectionToken";
 var Application = InjectionToken.create(
@@ -2061,8 +2098,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 +2109,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 NaviosException2("Unknown endpoint type");
+      case "config" /* Config */:
+        return this.provideHandlerForConfig(
+          controller,
+          executionContext,
+          endpointMetadata
+        );
+      case "handler" /* Handler */:
+        this.logger.error("Not implemented yet");
+        throw new NaviosException2("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 +2374,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 +2382,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 +2412,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 +2484,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);
@@ -2434,6 +2527,7 @@ export {
   ControllerMetadataKey,
   Endpoint,
   EndpointMetadataKey,
+  EndpointType,
   ErrorsEnum,
   EventEmitter,
   ExecutionContext2 as ExecutionContext,
@@ -2442,6 +2536,8 @@ export {
   FactoryNotFound,
   ForbiddenException,
   GuardRunnerService,
+  Header,
+  HttpCode,
   HttpException,
   Injectable,
   InjectableScope,