@navios/core 0.1.1 → 0.1.3

package/src/services/controller-adapter.service.mts

@@ -1,12 +1,13 @@
-import type { FastifyInstance } from 'fastify'
+import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
 import type { ZodTypeProvider } from 'fastify-type-provider-zod'
 
-import type { ModuleMetadata } from '../metadata/index.mjs'
+import { NaviosException } from '@navios/common'
+
+import type { EndpointMetadata, ModuleMetadata } from '../metadata/index.mjs'
 import type { ClassType } from '../service-locator/index.mjs'
 
-import { HttpException } from '../exceptions/index.mjs'
 import { Logger } from '../logger/index.mjs'
-import { extractControllerMetadata } from '../metadata/index.mjs'
+import { EndpointType, extractControllerMetadata } from '../metadata/index.mjs'
 import {
   getServiceLocator,
   inject,
@@ -31,9 +32,9 @@ export class ControllerAdapterService {
   ): void {
     const controllerMetadata = extractControllerMetadata(controller)
     for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod, config } = endpoint
+      const { classMethod, url, httpMethod } = endpoint
 
-      if (!url || !config) {
+      if (!url) {
         throw new Error(
           `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`,
         )
@@ -43,47 +44,24 @@ export class ControllerAdapterService {
         controllerMetadata,
         endpoint,
       )
-      const guards = this.guardRunner.makeContext(executionContext)
-      const { querySchema, requestSchema, responseSchema } = config
-      const schema: Record<string, any> = {}
-      if (querySchema) {
-        schema.querystring = querySchema
-      }
-      if (requestSchema) {
-        schema.body = requestSchema
-      }
-      if (responseSchema) {
-        schema.response = {
-          200: responseSchema,
-        }
-      }
       instance.withTypeProvider<ZodTypeProvider>().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) => {
+        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: ExecutionContext) {
+    const guards = this.guardRunner.makeContext(executionContext)
+    return guards.size > 0
+      ? async (request: FastifyRequest, reply: FastifyReply) => {
           getServiceLocator().registerInstance(Request, request)
           getServiceLocator().registerInstance(Reply, reply)
           getServiceLocator().registerInstance(
@@ -92,41 +70,108 @@ export class ControllerAdapterService {
           )
           executionContext.provideRequest(request)
           executionContext.provideReply(reply)
-          const controllerInstance = await inject(controller)
+          let canActivate = true
           try {
-            const { query, params, body } = request
-            const argument: Record<string, any> = {}
-            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 as Error).message,
-              })
-            }
+            canActivate = await this.guardRunner.runGuards(
+              guards,
+              executionContext,
+            )
           } finally {
             getServiceLocator().removeInstance(Request)
             getServiceLocator().removeInstance(Reply)
             getServiceLocator().removeInstance(ExecutionContextToken)
           }
-        },
-      })
+          if (!canActivate) {
+            return reply
+          }
+        }
+      : undefined
+  }
 
-      this.logger.debug(
-        `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`,
+  private provideSchemaForConfig(endpointMetadata: EndpointMetadata) {
+    if (!endpointMetadata.config) {
+      this.logger.warn(`No config found for endpoint ${endpointMetadata.url}`)
+      return {}
+    }
+    const { querySchema, requestSchema, responseSchema } =
+      endpointMetadata.config
+    const schema: Record<string, any> = {}
+    if (querySchema) {
+      schema.querystring = querySchema
+    }
+    if (requestSchema) {
+      schema.body = requestSchema
+    }
+    if (responseSchema) {
+      schema.response = {
+        200: responseSchema,
+      }
+    }
+
+    return schema
+  }
+
+  private provideHandler(
+    controller: ClassType,
+    executionContext: ExecutionContext,
+    endpointMetadata: EndpointMetadata,
+  ): (request: FastifyRequest, reply: FastifyReply) => Promise<void> {
+    switch (endpointMetadata.type) {
+      case EndpointType.Unknown:
+        this.logger.error(
+          `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`,
+        )
+        throw new NaviosException('Unknown endpoint type')
+      case EndpointType.Config:
+        return this.provideHandlerForConfig(
+          controller,
+          executionContext,
+          endpointMetadata,
+        )
+      case EndpointType.Handler:
+        this.logger.error('Not implemented yet')
+        throw new NaviosException('Not implemented yet')
+    }
+  }
+
+  private provideHandlerForConfig(
+    controller: ClassType,
+    executionContext: ExecutionContext,
+    endpointMetadata: EndpointMetadata,
+  ): (request: FastifyRequest, reply: FastifyReply) => Promise<void> {
+    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: Record<string, any> = {}
+        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)
+      }
     }
   }
 }