@navios/core 0.4.0 → 0.5.0

package/src/logger/console-logger.service.mts

@@ -2,12 +2,12 @@ import type { InspectOptions } from 'util'
 
 import { inspect } from 'util'
 
-import { getGlobalServiceLocator, Injectable } from '@navios/di'
+import { Injectable } from '@navios/di'
 
 import type { LogLevel } from './log-levels.mjs'
 import type { LoggerService } from './logger-service.interface.mjs'
 
-import { Request } from '../tokens/index.mjs'
+import { LoggerOutput } from './logger.tokens.mjs'
 import {
   clc,
   isFunction,
@@ -124,20 +124,18 @@ const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
 /**
  * @publicApi
  */
-@Injectable()
+@Injectable({
+  token: LoggerOutput,
+})
 export class ConsoleLogger implements LoggerService {
   /**
    * The options of the logger.
    */
-  protected options: ConsoleLoggerOptions
+  protected options: ConsoleLoggerOptions = {}
   /**
    * The context of the logger (can be set manually or automatically inferred).
    */
   protected context?: string
-  /**
-   * Request ID (if enabled).
-   */
-  protected requestId: string | null = null
   /**
    * The original context of the logger (set in the constructor).
    */
@@ -145,17 +143,17 @@ export class ConsoleLogger implements LoggerService {
   /**
    * The options used for the "inspect" method.
    */
-  protected inspectOptions: InspectOptions
+  protected inspectOptions: InspectOptions = this.getInspectOptions()
   /**
    * The last timestamp at which the log message was printed.
    */
-  protected static lastTimestampAt?: number
+  protected lastTimestampAt?: number
 
-  constructor()
-  constructor(context: string)
-  constructor(options: ConsoleLoggerOptions)
-  constructor(context: string, options: ConsoleLoggerOptions)
-  constructor(
+  setup(): void
+  setup(context: string): void
+  setup(options: ConsoleLoggerOptions): void
+  setup(context: string, options: ConsoleLoggerOptions): void
+  setup(
     contextOrOptions?: string | ConsoleLoggerOptions,
     options?: ConsoleLoggerOptions,
   ) {
@@ -178,24 +176,6 @@ export class ConsoleLogger implements LoggerService {
       this.context = context
       this.originalContext = context
     }
-    if (opts?.requestId) {
-      const locator = getGlobalServiceLocator()
-      locator
-        .getEventBus()
-        .on(locator.getInstanceIdentifier(Request, undefined), 'create', () => {
-          const request = locator.getSyncInstance(Request, undefined)
-          this.requestId = request?.id ?? null
-        })
-      locator
-        .getEventBus()
-        .on(
-          locator.getInstanceIdentifier(Request, undefined),
-          'destroy',
-          () => {
-            this.requestId = null
-          },
-        )
-    }
   }
 
   /**
@@ -229,7 +209,7 @@ export class ConsoleLogger implements LoggerService {
     const { messages, context, stack } =
       this.getContextAndStackAndMessagesToPrint([message, ...optionalParams])
 
-    this.printMessages(messages, context, 'error', 'stderr', stack)
+    this.printMessages(messages, context, 'error', undefined, 'stderr', stack)
     this.printStackTrace(stack!)
   }
 
@@ -340,6 +320,7 @@ export class ConsoleLogger implements LoggerService {
     messages: unknown[],
     context = '',
     logLevel: LogLevel = 'log',
+    requestId?: string,
     writeStreamType?: 'stdout' | 'stderr',
     errorStack?: unknown,
   ) {
@@ -350,6 +331,7 @@ export class ConsoleLogger implements LoggerService {
           logLevel,
           writeStreamType,
           errorStack,
+          requestId,
         })
         return
       }
@@ -364,6 +346,7 @@ export class ConsoleLogger implements LoggerService {
         formattedLogLevel,
         contextMessage,
         timestampDiff,
+        requestId,
       )
 
       process[writeStreamType ?? 'stdout'].write(formattedMessage)
@@ -377,6 +360,7 @@ export class ConsoleLogger implements LoggerService {
       logLevel: LogLevel
       writeStreamType?: 'stdout' | 'stderr'
       errorStack?: unknown
+      requestId?: string
     },
   ) {
     type JsonLogObject = {
@@ -403,8 +387,8 @@ export class ConsoleLogger implements LoggerService {
     if (options.errorStack) {
       logObject.stack = options.errorStack
     }
-    if (this.options.requestId && this.requestId) {
-      logObject.requestId = this.requestId
+    if (this.options.requestId && options.requestId) {
+      logObject.requestId = options.requestId
     }
 
     const formattedMessage =
@@ -434,16 +418,17 @@ export class ConsoleLogger implements LoggerService {
     formattedLogLevel: string,
     contextMessage: string,
     timestampDiff: string,
+    requestId?: string,
   ) {
     const output = this.stringifyMessage(message, logLevel)
     pidMessage = this.colorize(pidMessage, logLevel)
     formattedLogLevel = this.colorize(formattedLogLevel, logLevel)
-    return `${pidMessage}${this.getRequestId()}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}\n`
+    return `${pidMessage}${this.getRequestId(requestId)}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}\n`
   }
 
-  protected getRequestId() {
-    if (this.options.requestId && this.requestId) {
-      return `(${this.colorize(this.requestId, 'log')}) `
+  protected getRequestId(requestId?: string) {
+    if (this.options.requestId && requestId) {
+      return `(${this.colorize(requestId, 'log')}) `
     }
     return ''
   }
@@ -490,12 +475,11 @@ export class ConsoleLogger implements LoggerService {
   }
 
   protected updateAndGetTimestampDiff(): string {
-    const includeTimestamp =
-      ConsoleLogger.lastTimestampAt && this.options?.timestamp
+    const includeTimestamp = this.lastTimestampAt && this.options?.timestamp
     const result = includeTimestamp
-      ? this.formatTimestampDiff(Date.now() - ConsoleLogger.lastTimestampAt!)
+      ? this.formatTimestampDiff(Date.now() - this.lastTimestampAt!)
       : ''
-    ConsoleLogger.lastTimestampAt = Date.now()
+    this.lastTimestampAt = Date.now()
     return result
   }
 

package/src/logger/index.mts

@@ -1,7 +1,6 @@
 export * from './utils/index.mjs'
 export * from './console-logger.service.mjs'
 export * from './log-levels.mjs'
-export * from './logger.factory.mjs'
+export * from './logger.tokens.mjs'
 export * from './logger.service.mjs'
 export * from './logger-service.interface.mjs'
-export * from './pino-wrapper.mjs'

package/src/logger/logger.service.mts

@@ -1,47 +1,20 @@
-import { Injectable } from '@navios/di'
+import { inject, Injectable } from '@navios/di'
 
-import type { LogLevel } from './log-levels.mjs'
 import type { LoggerService } from './logger-service.interface.mjs'
+import type { LoggerOptions } from './logger.tokens.mjs'
 
-import { ConsoleLogger } from './console-logger.service.mjs'
-import { isLogLevelEnabled, isObject } from './utils/index.mjs'
+import { Logger, LoggerOutput } from './logger.tokens.mjs'
 
-const DEFAULT_LOGGER = new ConsoleLogger()
-
-const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
-  year: 'numeric',
-  hour: 'numeric',
-  minute: 'numeric',
-  second: 'numeric',
-  day: '2-digit',
-  month: '2-digit',
+@Injectable({
+  token: Logger,
 })
-
-@Injectable()
 export class LoggerInstance implements LoggerService {
-  protected static staticInstanceRef?: LoggerService = DEFAULT_LOGGER
-  protected static logLevels?: LogLevel[]
-
-  protected localInstanceRef?: LoggerService
+  protected localInstance = inject(LoggerOutput)
 
-  constructor()
-  constructor(context: string)
-  constructor(context: string, options?: { timestamp?: boolean })
-  constructor(
-    protected context?: string,
-    protected options: { timestamp?: boolean } = {},
-  ) {}
+  protected context?: string
 
-  get localInstance(): LoggerService {
-    if (LoggerInstance.staticInstanceRef === DEFAULT_LOGGER) {
-      return this.registerLocalInstanceRef()
-    } else if (LoggerInstance.staticInstanceRef instanceof LoggerInstance) {
-      const prototype = Object.getPrototypeOf(LoggerInstance.staticInstanceRef)
-      if (prototype.constructor === LoggerInstance) {
-        return this.registerLocalInstanceRef()
-      }
-    }
-    return LoggerInstance.staticInstanceRef!
+  constructor(config: LoggerOptions = {}) {
+    this.context = config.context
   }
 
   /**
@@ -118,96 +91,4 @@ export class LoggerInstance implements LoggerService {
       : optionalParams
     this.localInstance?.fatal?.(message, ...optionalParams)
   }
-
-  /**
-   * Write an 'error' level log.
-   */
-  static error(message: any, stackOrContext?: string): void
-  static error(message: any, context?: string): void
-  static error(message: any, stack?: string, context?: string): void
-  static error(
-    message: any,
-    ...optionalParams: [...any, string?, string?]
-  ): void
-  static error(message: any, ...optionalParams: any[]) {
-    this.staticInstanceRef?.error(message, ...optionalParams)
-  }
-
-  /**
-   * Write a 'log' level log.
-   */
-  static log(message: any, context?: string): void
-  static log(message: any, ...optionalParams: [...any, string?]): void
-  static log(message: any, ...optionalParams: any[]) {
-    this.staticInstanceRef?.log(message, ...optionalParams)
-  }
-
-  /**
-   * Write a 'warn' level log.
-   */
-  static warn(message: any, context?: string): void
-  static warn(message: any, ...optionalParams: [...any, string?]): void
-  static warn(message: any, ...optionalParams: any[]) {
-    this.staticInstanceRef?.warn(message, ...optionalParams)
-  }
-
-  /**
-   * Write a 'debug' level log, if the configured level allows for it.
-   * Prints to `stdout` with newline.
-   */
-  static debug(message: any, context?: string): void
-  static debug(message: any, ...optionalParams: [...any, string?]): void
-  static debug(message: any, ...optionalParams: any[]) {
-    this.staticInstanceRef?.debug?.(message, ...optionalParams)
-  }
-
-  /**
-   * Write a 'verbose' level log.
-   */
-  static verbose(message: any, context?: string): void
-  static verbose(message: any, ...optionalParams: [...any, string?]): void
-  static verbose(message: any, ...optionalParams: any[]) {
-    this.staticInstanceRef?.verbose?.(message, ...optionalParams)
-  }
-
-  /**
-   * Write a 'fatal' level log.
-   */
-  static fatal(message: any, context?: string): void
-  static fatal(message: any, ...optionalParams: [...any, string?]): void
-  static fatal(message: any, ...optionalParams: any[]) {
-    this.staticInstanceRef?.fatal?.(message, ...optionalParams)
-  }
-
-  static getTimestamp() {
-    return dateTimeFormatter.format(Date.now())
-  }
-
-  static overrideLogger(logger: LoggerService | LogLevel[] | boolean) {
-    if (Array.isArray(logger)) {
-      LoggerInstance.logLevels = logger
-      return this.staticInstanceRef?.setLogLevels?.(logger)
-    }
-    if (isObject(logger)) {
-      this.staticInstanceRef = logger as LoggerService
-    } else {
-      this.staticInstanceRef = undefined
-    }
-  }
-
-  static isLevelEnabled(level: LogLevel): boolean {
-    const logLevels = LoggerInstance.logLevels
-    return isLogLevelEnabled(level, logLevels)
-  }
-
-  private registerLocalInstanceRef() {
-    if (this.localInstanceRef) {
-      return this.localInstanceRef
-    }
-    this.localInstanceRef = new ConsoleLogger(this.context!, {
-      timestamp: this.options?.timestamp,
-      logLevels: LoggerInstance.logLevels,
-    })
-    return this.localInstanceRef
-  }
 }

package/src/logger/logger.tokens.mts

@@ -0,0 +1,21 @@
+import { InjectionToken } from '@navios/di'
+
+import z from 'zod/v4'
+
+import type { LoggerService } from './logger-service.interface.mjs'
+import type { LoggerInstance } from './logger.service.mjs'
+
+export const LoggerOutput = InjectionToken.create<LoggerService>('LoggerOutput')
+
+export const loggerOptionsSchema = z
+  .object({
+    context: z.string().optional(),
+  })
+  .optional()
+
+export type LoggerOptions = z.infer<typeof loggerOptionsSchema>
+
+export const Logger = InjectionToken.create<
+  LoggerInstance,
+  typeof loggerOptionsSchema
+>('Logger', loggerOptionsSchema)

package/src/metadata/handler.metadata.mts

@@ -1,9 +1,11 @@
 import type { HttpMethod } from '@navios/builder'
 import type { ClassTypeWithInstance, InjectionToken } from '@navios/di'
-import type { HttpHeader } from 'fastify/types/utils.js'
 
-import type { HandlerAdapterInterface } from '../adapters/index.mjs'
-import type { CanActivate } from '../interfaces/index.mjs'
+import type {
+  AbstractHttpHandlerAdapterInterface,
+  CanActivate,
+  HttpHeader,
+} from '../interfaces/index.mjs'
 
 export const EndpointMetadataKey = Symbol('EndpointMetadataKey')
 
@@ -12,8 +14,8 @@ export interface HandlerMetadata<Config = null> {
   url: string
   successStatusCode: number
   adapterToken:
-    | InjectionToken<HandlerAdapterInterface, undefined>
-    | ClassTypeWithInstance<HandlerAdapterInterface>
+    | InjectionToken<AbstractHttpHandlerAdapterInterface, undefined>
+    | ClassTypeWithInstance<AbstractHttpHandlerAdapterInterface>
     | null
   headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>
   httpMethod: HttpMethod

package/src/navios.application.mts

@@ -1,37 +1,19 @@
-import type { FastifyCorsOptions } from '@fastify/cors'
-import type { FastifyMultipartOptions } from '@fastify/multipart'
 import type { ClassTypeWithInstance } from '@navios/di'
+
+import { Container, inject, Injectable } from '@navios/di'
+
 import type {
-  FastifyInstance,
-  FastifyListenOptions,
-  FastifyServerOptions,
-} from 'fastify'
-
-import {
-  getGlobalServiceLocator,
-  inject,
-  Injectable,
-  syncInject,
-} from '@navios/di'
-
-import cors from '@fastify/cors'
-import multipart from '@fastify/multipart'
-import { fastify } from 'fastify'
-import {
-  serializerCompiler,
-  validatorCompiler,
-} from 'fastify-type-provider-zod'
-
-import type { NaviosModule } from './interfaces/index.mjs'
+  AbstractHttpAdapterInterface,
+  AbstractHttpListenOptions,
+  NaviosModule,
+} from './interfaces/index.mjs'
 import type { LoggerService, LogLevel } from './logger/index.mjs'
+import type { NaviosEnvironmentOptions } from './navios.environment.mjs'
 
-import { HttpException } from './exceptions/index.mjs'
-import { Logger, PinoWrapper } from './logger/index.mjs'
-import {
-  ControllerAdapterService,
-  ModuleLoaderService,
-} from './services/index.mjs'
-import { Application } from './tokens/index.mjs'
+import { HttpAdapterToken } from './index.mjs'
+import { Logger } from './logger/index.mjs'
+import { NaviosEnvironment } from './navios.environment.mjs'
+import { ModuleLoaderService } from './services/index.mjs'
 
 export interface NaviosApplicationContextOptions {
   /**
@@ -41,32 +23,43 @@ export interface NaviosApplicationContextOptions {
 }
 
 export interface NaviosApplicationOptions
-  extends Omit<FastifyServerOptions, 'logger'>,
-    NaviosApplicationContextOptions {}
+  extends NaviosApplicationContextOptions {
+  // Fastify server options will be handled by FastifyApplicationService
+  adapter: NaviosEnvironmentOptions | NaviosEnvironmentOptions[]
+}
 
 @Injectable()
 export class NaviosApplication {
-  private moduleLoader = syncInject(ModuleLoaderService)
-  private controllerAdapter = syncInject(ControllerAdapterService)
-  private logger = syncInject(Logger, {
+  private environment = inject(NaviosEnvironment)
+  private moduleLoader = inject(ModuleLoaderService)
+  private httpApplication: AbstractHttpAdapterInterface<any> | null = null
+  private logger = inject(Logger, {
     context: NaviosApplication.name,
   })
-  private server: FastifyInstance | null = null
-  private corsOptions: FastifyCorsOptions | null = null
-  private multipartOptions: FastifyMultipartOptions | true | null = null
-  private globalPrefix: string | null = null
+  protected container = inject(Container)
 
   private appModule: ClassTypeWithInstance<NaviosModule> | null = null
-  private options: NaviosApplicationOptions = {}
+  private options: NaviosApplicationOptions = {
+    adapter: [],
+  }
 
   isInitialized = false
 
-  setup(
+  async setup(
     appModule: ClassTypeWithInstance<NaviosModule>,
-    options: NaviosApplicationOptions = {},
+    options: NaviosApplicationOptions = {
+      adapter: [],
+    },
   ) {
     this.appModule = appModule
     this.options = options
+    if (this.environment.hasHttpSetup()) {
+      this.httpApplication = await this.container.get(HttpAdapterToken)
+    }
+  }
+
+  getContainer() {
+    return this.container
   }
 
   async init() {
@@ -74,161 +67,61 @@ export class NaviosApplication {
       throw new Error('App module is not set. Call setAppModule() first.')
     }
     await this.moduleLoader.loadModules(this.appModule)
-    this.server = await this.getFastifyInstance(this.options)
-    this.configureFastifyInstance(this.server)
-    getGlobalServiceLocator().storeInstance(this.server, Application)
-    // Add schema validator and serializer
-    this.server.setValidatorCompiler(validatorCompiler)
-    this.server.setSerializerCompiler(serializerCompiler)
-
-    if (this.corsOptions) {
-      await this.server.register(cors, this.corsOptions)
-    }
-
-    if (this.multipartOptions) {
-      await this.configureMultipart(this.server, this.multipartOptions)
+    if (this.environment.hasHttpSetup()) {
+      await this.httpApplication?.setupHttpServer(this.options)
     }
-
     await this.initModules()
-    await this.server.ready()
+    if (this.environment.hasHttpSetup()) {
+      await this.httpApplication?.ready()
+    }
 
     this.isInitialized = true
     this.logger.debug('Navios application initialized')
   }
 
-  private async getFastifyInstance(rawOptions: NaviosApplicationOptions) {
-    const { logger, ...options } = rawOptions
-    if (logger) {
-      const fastifyOptions = options as FastifyServerOptions
-      if (typeof logger === 'boolean') {
-        if (!logger) {
-          fastifyOptions.logger = false
-        }
-      } else {
-        fastifyOptions.loggerInstance = new PinoWrapper(
-          await inject(Logger, {
-            context: 'FastifyAdapter',
-          }),
-        )
-      }
-      return fastify(fastifyOptions)
-    } else {
-      return fastify({
-        ...options,
-        loggerInstance: new PinoWrapper(
-          await inject(Logger, {
-            context: 'FastifyAdapter',
-          }),
-        ),
-      } as FastifyServerOptions)
-    }
-  }
-
-  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.method}] ${req.url}`)
-      return reply.status(404).send(response)
-    })
-  }
-
-  async configureMultipart(
-    server: FastifyInstance,
-    options: FastifyMultipartOptions | true,
-  ): Promise<void> {
-    if (options) {
-      await server.register(
-        multipart,
-        typeof options === 'object' ? options : {},
-      )
-    }
-  }
-
   private async initModules() {
     const modules = this.moduleLoader.getAllModules()
-    const promises: PromiseLike<any>[] = []
-    for (const [moduleName, moduleMetadata] of modules) {
-      if (
-        !moduleMetadata.controllers ||
-        moduleMetadata.controllers.size === 0
-      ) {
-        continue
-      }
-      promises.push(
-        this.server!.register(
-          async (instance, opts) => {
-            for (const controller of moduleMetadata.controllers) {
-              await this.controllerAdapter.setupController(
-                controller,
-                instance,
-                moduleMetadata,
-              )
-            }
-          },
-          {
-            prefix: this.globalPrefix ?? '',
-          },
-        ),
-      )
-    }
-
-    await Promise.all(promises)
+    await this.httpApplication?.onModulesInit(modules)
   }
 
-  enableCors(options: FastifyCorsOptions) {
-    this.corsOptions = options
+  enableCors(options: any) {
+    if (!this.httpApplication) {
+      throw new Error('HTTP application is not set')
+    }
+    this.httpApplication.enableCors(options)
   }
 
-  enableMultipart(options: FastifyMultipartOptions) {
-    this.multipartOptions = options
+  enableMultipart(options: any) {
+    if (!this.httpApplication) {
+      throw new Error('HTTP application is not set')
+    }
+    this.httpApplication.enableMultipart(options)
   }
 
   setGlobalPrefix(prefix: string) {
-    this.globalPrefix = prefix
+    if (!this.httpApplication) {
+      throw new Error('HTTP application is not set')
+    }
+    this.httpApplication.setGlobalPrefix(prefix)
   }
 
-  getServer(): FastifyInstance {
-    if (!this.server) {
-      throw new Error('Server is not initialized. Call init() first.')
+  getServer() {
+    if (!this.httpApplication) {
+      throw new Error('HTTP application is not set')
     }
-    return this.server
+    return this.httpApplication.getServer()
   }
 
-  async listen(options: FastifyListenOptions) {
-    if (!this.server) {
-      throw new Error('Server is not initialized. Call init() first.')
+  async listen(options: AbstractHttpListenOptions) {
+    if (!this.httpApplication) {
+      throw new Error('HTTP application is not set')
     }
-    const res = await this.server.listen(options)
-    this.logger.debug(`Navios is listening on ${res}`)
+    await this.httpApplication.listen(options)
   }
 
   async dispose() {
-    if (this.server) {
-      await this.server.close()
-      this.server = null
+    if (this.httpApplication) {
+      await this.httpApplication.dispose()
     }
     if (this.moduleLoader) {
       this.moduleLoader.dispose()