@navios/core 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/core",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"

package/src/config/config.provider.mts

@@ -9,7 +9,6 @@ import {
   Injectable,
   InjectableType,
   InjectionToken,
-  syncInject,
 } from '../service-locator/index.mjs'
 import { ConfigServiceInstance } from './config.service.mjs'
 

package/src/decorators/endpoint.decorator.mts

@@ -1,7 +1,11 @@
-import type { BaseEndpointConfig, EndpointFunctionArgs, HttpMethod } from '@navios/common'
+import type {
+  BaseEndpointConfig,
+  EndpointFunctionArgs,
+  HttpMethod,
+} from '@navios/common'
 import type { AnyZodObject, z, ZodType } from 'zod'
 
-import { getEndpointMetadata } from '../metadata/index.mjs'
+import { EndpointType, getEndpointMetadata } from '../metadata/index.mjs'
 
 export type EndpointParams<
   EndpointDeclaration extends {
@@ -72,6 +76,7 @@ export function Endpoint<
       }
       // @ts-expect-error We don't need to set correctly in the metadata
       endpointMetadata.config = config
+      endpointMetadata.type = EndpointType.Config
       endpointMetadata.classMethod = target.name
       endpointMetadata.httpMethod = config.method
       endpointMetadata.url = config.url

package/src/decorators/header.decorator.mts

@@ -0,0 +1,18 @@
+import type { HttpHeader } from 'fastify/types/utils.js'
+
+import { getEndpointMetadata } from '../metadata/index.mjs'
+
+export function Header(name: HttpHeader, value: string | number | string[]) {
+  return <T extends Function>(
+    target: T,
+    context: ClassMethodDecoratorContext,
+  ) => {
+    if (context.kind !== 'method') {
+      throw new Error('[Navios] Header decorator can only be used on methods.')
+    }
+    const metadata = getEndpointMetadata(target, context)
+    metadata.headers[name] = value
+
+    return target
+  }
+}

package/src/decorators/http-code.decorator.mts

@@ -0,0 +1,18 @@
+import { getEndpointMetadata } from '../metadata/index.mjs'
+
+export function HttpCode(code: number) {
+  return <T extends Function>(
+    target: T,
+    context: ClassMethodDecoratorContext,
+  ) => {
+    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
+  }
+}

package/src/decorators/index.mts

@@ -1,4 +1,6 @@
 export * from './controller.decorator.mjs'
 export * from './endpoint.decorator.mjs'
+export * from './header.decorator.mjs'
+export * from './http-code.decorator.mjs'
 export * from './module.decorator.mjs'
 export * from './use-guards.decorator.mjs'

package/src/logger/logger.service.mts

@@ -184,7 +184,6 @@ export class LoggerInstance implements LoggerService {
   }
 
   static overrideLogger(logger: LoggerService | LogLevel[] | boolean) {
-    console.log(logger)
     if (Array.isArray(logger)) {
       LoggerInstance.logLevels = logger
       return this.staticInstanceRef?.setLogLevels?.(logger)

package/src/logger/pino-wrapper.mts

@@ -20,8 +20,9 @@ export class PinoWrapper {
     this.logger.warn(message, ...optionalParams)
   }
 
-  info(message: any, ...optionalParams: any[]) {
-    this.logger.log(message, ...optionalParams)
+  info() {
+    // We don't want to populate the logs with the original fastify logs
+    // this.logger.debug?.('INFO', message, ...optionalParams)
   }
 
   debug(message: any, ...optionalParams: any[]) {
@@ -32,7 +33,7 @@ export class PinoWrapper {
     this.logger.verbose?.(message, ...optionalParams)
   }
 
-  silent(message: any, ...optionalParams: any[]) {
+  silent() {
     // noop
   }
 
@@ -56,8 +57,8 @@ export class PinoWrapper {
     }
     const levels = LoggerInstance['logLevels']
     if (levels) {
-      return levels[0]
+      return levels.find((level) => level !== 'verbose')
     }
-    return 'info'
+    return 'warn'
   }
 }

package/src/metadata/endpoint.metadata.mts

@@ -1,4 +1,5 @@
 import type { BaseEndpointConfig, HttpMethod } from '@navios/common'
+import type { HttpHeader } from 'fastify/types/utils.js'
 
 import type { CanActivate } from '../interfaces/index.mjs'
 import type {
@@ -8,9 +9,18 @@ import type {
 
 export const EndpointMetadataKey = Symbol('EndpointMetadataKey')
 
+export enum EndpointType {
+  Unknown = 'unknown',
+  Config = 'config',
+  Handler = 'handler',
+}
+
 export interface EndpointMetadata {
   classMethod: string
   url: string
+  successStatusCode: number
+  type: EndpointType
+  headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>
   httpMethod: HttpMethod
   config: BaseEndpointConfig | null
   guards: Set<
@@ -52,6 +62,9 @@ export function getEndpointMetadata(
         const newMetadata: EndpointMetadata = {
           classMethod: target.name,
           url: '',
+          successStatusCode: 200,
+          headers: {},
+          type: EndpointType.Unknown,
           httpMethod: 'GET',
           config: null,
           guards: new Set<

package/src/navios.application.mts

@@ -16,6 +16,7 @@ import type { NaviosModule } from './interfaces/index.mjs'
 import type { LoggerService, LogLevel } from './logger/index.mjs'
 import type { ClassTypeWithInstance } from './service-locator/index.mjs'
 
+import { HttpException } from './exceptions/index.mjs'
 import { Logger, PinoWrapper } from './logger/index.mjs'
 import {
   getServiceLocator,
@@ -68,6 +69,7 @@ export class NaviosApplication {
     }
     await this.moduleLoader.loadModules(this.appModule)
     this.server = await this.getFastifyInstance(this.options)
+    this.configureFastifyInstance(this.server)
     getServiceLocator().registerInstance(Application, this.server)
     // Add schema validator and serializer
     this.server.setValidatorCompiler(validatorCompiler)
@@ -78,6 +80,7 @@ export class NaviosApplication {
     }
 
     await this.initModules()
+    await this.server.ready()
 
     this.logger.debug('Navios application initialized')
   }
@@ -110,6 +113,37 @@ export class NaviosApplication {
     }
   }
 
+  private configureFastifyInstance(fastifyInstance: 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)
+    })
+  }
+
   private async initModules() {
     const modules = this.moduleLoader.getAllModules()
     const promises: PromiseLike<any>[] = []
@@ -161,6 +195,7 @@ export 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}`)
   }
 }

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)
+      }
     }
   }
 }