@navios/core 0.1.0 → 0.1.1

package/src/logger/logger.service.mts

@@ -0,0 +1,214 @@
+import type { LogLevel } from './log-levels.mjs'
+import type { LoggerService } from './logger-service.interface.mjs'
+
+import { Injectable } from '../service-locator/index.mjs'
+import { ConsoleLogger } from './console-logger.service.mjs'
+import { isLogLevelEnabled, isObject } from './utils/index.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',
+})
+
+// @ts-expect-error We don't need to support this in the current version
+@Injectable()
+export class LoggerInstance implements LoggerService {
+  protected static staticInstanceRef?: LoggerService = DEFAULT_LOGGER
+  protected static logLevels?: LogLevel[]
+
+  protected localInstanceRef?: LoggerService
+
+  constructor()
+  constructor(context: string)
+  constructor(context: string, options?: { timestamp?: boolean })
+  constructor(
+    protected context?: string,
+    protected options: { timestamp?: boolean } = {},
+  ) {}
+
+  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!
+  }
+
+  /**
+   * Write an 'error' level log.
+   */
+  error(message: any, stack?: string, context?: string): void
+  error(message: any, ...optionalParams: [...any, string?, string?]): void
+  error(message: any, ...optionalParams: any[]) {
+    optionalParams = this.context
+      ? (optionalParams.length ? optionalParams : [undefined]).concat(
+          this.context,
+        )
+      : optionalParams
+
+    this.localInstance?.error(message, ...optionalParams)
+  }
+
+  /**
+   * Write a 'log' level log.
+   */
+  log(message: any, context?: string): void
+  log(message: any, ...optionalParams: [...any, string?]): void
+  log(message: any, ...optionalParams: any[]) {
+    optionalParams = this.context
+      ? optionalParams.concat(this.context)
+      : optionalParams
+    this.localInstance?.log(message, ...optionalParams)
+  }
+
+  /**
+   * Write a 'warn' level log.
+   */
+  warn(message: any, context?: string): void
+  warn(message: any, ...optionalParams: [...any, string?]): void
+  warn(message: any, ...optionalParams: any[]) {
+    optionalParams = this.context
+      ? optionalParams.concat(this.context)
+      : optionalParams
+    this.localInstance?.warn(message, ...optionalParams)
+  }
+
+  /**
+   * Write a 'debug' level log.
+   */
+  debug(message: any, context?: string): void
+  debug(message: any, ...optionalParams: [...any, string?]): void
+  debug(message: any, ...optionalParams: any[]) {
+    optionalParams = this.context
+      ? optionalParams.concat(this.context)
+      : optionalParams
+    this.localInstance?.debug?.(message, ...optionalParams)
+  }
+
+  /**
+   * Write a 'verbose' level log.
+   */
+  verbose(message: any, context?: string): void
+  verbose(message: any, ...optionalParams: [...any, string?]): void
+  verbose(message: any, ...optionalParams: any[]) {
+    optionalParams = this.context
+      ? optionalParams.concat(this.context)
+      : optionalParams
+    this.localInstance?.verbose?.(message, ...optionalParams)
+  }
+
+  /**
+   * Write a 'fatal' level log.
+   */
+  fatal(message: any, context?: string): void
+  fatal(message: any, ...optionalParams: [...any, string?]): void
+  fatal(message: any, ...optionalParams: any[]) {
+    optionalParams = this.context
+      ? optionalParams.concat(this.context)
+      : 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) {
+    console.log(logger)
+    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/pino-wrapper.mts

@@ -0,0 +1,63 @@
+import type { LoggerService } from './logger-service.interface.mjs'
+
+import { LoggerInstance } from './logger.service.mjs'
+
+export class PinoWrapper {
+  constructor(protected readonly logger: LoggerService) {}
+
+  fatal(message: any, ...optionalParams: any[]) {
+    if (this.logger.fatal === undefined) {
+      return this.error(message, ...optionalParams)
+    }
+    this.logger.fatal(message, ...optionalParams)
+  }
+
+  error(message: any, ...optionalParams: any[]) {
+    this.logger.error(message, ...optionalParams)
+  }
+
+  warn(message: any, ...optionalParams: any[]) {
+    this.logger.warn(message, ...optionalParams)
+  }
+
+  info(message: any, ...optionalParams: any[]) {
+    this.logger.log(message, ...optionalParams)
+  }
+
+  debug(message: any, ...optionalParams: any[]) {
+    this.logger.debug?.(message, ...optionalParams)
+  }
+
+  trace(message: any, ...optionalParams: any[]) {
+    this.logger.verbose?.(message, ...optionalParams)
+  }
+
+  silent(message: any, ...optionalParams: any[]) {
+    // noop
+  }
+
+  child(options: any) {
+    const keys = Object.keys(options)
+    // @ts-expect-error We don't need to support this in the current version
+    let newContext = this.logger['context'] ?? ''
+    if (keys.length > 1) {
+      // @ts-expect-error We don't need to support this in the current version
+      newContext = `${this.logger['context'] ?? ''}:${JSON.stringify(options)}`
+    }
+    return new PinoWrapper(
+      // @ts-expect-error We don't need to support this in the current version
+      new LoggerInstance(newContext, this.logger['options']),
+    )
+  }
+
+  get level(): any {
+    if ('level' in this.logger && this.logger.level) {
+      return this.logger.level
+    }
+    const levels = LoggerInstance['logLevels']
+    if (levels) {
+      return levels[0]
+    }
+    return 'info'
+  }
+}

package/src/logger/utils/cli-colors.util.mts

@@ -0,0 +1,17 @@
+type ColorTextFn = (text: string) => string
+
+const isColorAllowed = () => !process.env.NO_COLOR
+const colorIfAllowed = (colorFn: ColorTextFn) => (text: string) =>
+  isColorAllowed() ? colorFn(text) : text
+
+export const clc = {
+  bold: colorIfAllowed((text: string) => `\x1B[1m${text}\x1B[0m`),
+  green: colorIfAllowed((text: string) => `\x1B[32m${text}\x1B[39m`),
+  yellow: colorIfAllowed((text: string) => `\x1B[33m${text}\x1B[39m`),
+  red: colorIfAllowed((text: string) => `\x1B[31m${text}\x1B[39m`),
+  magentaBright: colorIfAllowed((text: string) => `\x1B[95m${text}\x1B[39m`),
+  cyanBright: colorIfAllowed((text: string) => `\x1B[96m${text}\x1B[39m`),
+}
+export const yellow = colorIfAllowed(
+  (text: string) => `\x1B[38;5;3m${text}\x1B[39m`,
+)

package/src/logger/utils/filter-log-levelts.util.mts

@@ -0,0 +1,29 @@
+import type { LogLevel } from '../log-levels.mjs'
+
+import { LOG_LEVELS } from '../log-levels.mjs'
+import { isLogLevel } from './is-log-level.util.mjs'
+
+/**
+ * @publicApi
+ */
+export function filterLogLevels(parseableString = ''): LogLevel[] {
+  const sanitizedString = parseableString.replaceAll(' ', '').toLowerCase()
+
+  if (sanitizedString[0] === '>') {
+    const orEqual = sanitizedString[1] === '='
+
+    const logLevelIndex = (LOG_LEVELS as string[]).indexOf(
+      sanitizedString.substring(orEqual ? 2 : 1),
+    )
+
+    if (logLevelIndex === -1) {
+      throw new Error(`parse error (unknown log level): ${sanitizedString}`)
+    }
+
+    return LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1)
+  } else if (sanitizedString.includes(',')) {
+    return sanitizedString.split(',').filter(isLogLevel)
+  }
+
+  return isLogLevel(sanitizedString) ? [sanitizedString] : LOG_LEVELS
+}

package/src/logger/utils/index.mts

@@ -0,0 +1,5 @@
+export * from './cli-colors.util.mjs'
+export * from './filter-log-levelts.util.mjs'
+export * from './is-log-level.util.mjs'
+export * from './is-log-level-enabled.mjs'
+export * from './shared.utils.mjs'

package/src/logger/utils/is-log-level-enabled.mts

@@ -0,0 +1,33 @@
+import type { LogLevel } from '../log-levels.mjs'
+
+const LOG_LEVEL_VALUES: Record<LogLevel, number> = {
+  verbose: 0,
+  debug: 1,
+  log: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5,
+}
+
+/**
+ * Checks if target level is enabled.
+ * @param targetLevel target level
+ * @param logLevels array of enabled log levels
+ */
+export function isLogLevelEnabled(
+  targetLevel: LogLevel,
+  logLevels: LogLevel[] | undefined,
+): boolean {
+  if (!logLevels || (Array.isArray(logLevels) && logLevels?.length === 0)) {
+    return false
+  }
+  if (logLevels.includes(targetLevel)) {
+    return true
+  }
+  const highestLogLevelValue = logLevels
+    .map((level) => LOG_LEVEL_VALUES[level])
+    .sort((a, b) => b - a)?.[0]
+
+  const targetLevelValue = LOG_LEVEL_VALUES[targetLevel]
+  return targetLevelValue >= highestLogLevelValue
+}

package/src/logger/utils/is-log-level.util.mts

@@ -0,0 +1,10 @@
+import type { LogLevel } from '../log-levels.mjs'
+
+import { LOG_LEVELS } from '../log-levels.mjs'
+
+/**
+ * @publicApi
+ */
+export function isLogLevel(maybeLogLevel: any): maybeLogLevel is LogLevel {
+  return LOG_LEVELS.includes(maybeLogLevel)
+}

package/src/logger/utils/shared.utils.mts

@@ -0,0 +1,51 @@
+export const isUndefined = (obj: any): obj is undefined =>
+  typeof obj === 'undefined'
+
+export const isObject = (fn: any): fn is object =>
+  !isNil(fn) && typeof fn === 'object'
+
+export const isPlainObject = (fn: any): fn is object => {
+  if (!isObject(fn)) {
+    return false
+  }
+  const proto = Object.getPrototypeOf(fn)
+  if (proto === null) {
+    return true
+  }
+  const ctor =
+    Object.prototype.hasOwnProperty.call(proto, 'constructor') &&
+    proto.constructor
+  return (
+    typeof ctor === 'function' &&
+    ctor instanceof ctor &&
+    Function.prototype.toString.call(ctor) ===
+      Function.prototype.toString.call(Object)
+  )
+}
+
+export const addLeadingSlash = (path?: string): string =>
+  path && typeof path === 'string'
+    ? path.charAt(0) !== '/' && path.substring(0, 2) !== '{/'
+      ? '/' + path
+      : path
+    : ''
+
+export const normalizePath = (path?: string): string =>
+  path
+    ? path.startsWith('/')
+      ? ('/' + path.replace(/\/+$/, '')).replace(/\/+/g, '/')
+      : '/' + path.replace(/\/+$/, '')
+    : '/'
+
+export const stripEndSlash = (path: string) =>
+  path[path.length - 1] === '/' ? path.slice(0, path.length - 1) : path
+
+export const isFunction = (val: any): val is Function =>
+  typeof val === 'function'
+export const isString = (val: any): val is string => typeof val === 'string'
+export const isNumber = (val: any): val is number => typeof val === 'number'
+export const isConstructor = (val: any): boolean => val === 'constructor'
+export const isNil = (val: any): val is null | undefined =>
+  isUndefined(val) || val === null
+export const isEmpty = (array: any): boolean => !(array && array.length > 0)
+export const isSymbol = (val: any): val is symbol => typeof val === 'symbol'

package/src/navios.application.mts

@@ -13,10 +13,13 @@ import {
 } from 'fastify-type-provider-zod'
 
 import type { NaviosModule } from './interfaces/index.mjs'
+import type { LoggerService, LogLevel } from './logger/index.mjs'
 import type { ClassTypeWithInstance } from './service-locator/index.mjs'
 
+import { Logger, PinoWrapper } from './logger/index.mjs'
 import {
   getServiceLocator,
+  inject,
   Injectable,
   syncInject,
 } from './service-locator/index.mjs'
@@ -26,12 +29,24 @@ import {
 } from './services/index.mjs'
 import { Application } from './tokens/index.mjs'
 
-export interface NaviosApplicationOptions extends FastifyServerOptions {}
+export interface NaviosApplicationContextOptions {
+  /**
+   * Specifies the logger to use.  Pass `false` to turn off logging.
+   */
+  logger?: LoggerService | LogLevel[] | false
+}
+
+export interface NaviosApplicationOptions
+  extends Omit<FastifyServerOptions, 'logger'>,
+    NaviosApplicationContextOptions {}
 
 @Injectable()
 export class NaviosApplication {
   private moduleLoader = syncInject(ModuleLoaderService)
   private controllerAdapter = syncInject(ControllerAdapterService)
+  private logger = syncInject(Logger, {
+    context: NaviosApplication.name,
+  })
   private server: FastifyInstance | null = null
   private corsOptions: FastifyCorsOptions | null = null
   private globalPrefix: string | null = null
@@ -52,7 +67,7 @@ export class NaviosApplication {
       throw new Error('App module is not set. Call setAppModule() first.')
     }
     await this.moduleLoader.loadModules(this.appModule)
-    this.server = fastify(this.options)
+    this.server = await this.getFastifyInstance(this.options)
     getServiceLocator().registerInstance(Application, this.server)
     // Add schema validator and serializer
     this.server.setValidatorCompiler(validatorCompiler)
@@ -61,8 +76,43 @@ export class NaviosApplication {
     if (this.corsOptions) {
       await this.server.register(cors, this.corsOptions)
     }
+
+    await this.initModules()
+
+    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 async initModules() {
     const modules = this.moduleLoader.getAllModules()
-    const globalPrefix = this.globalPrefix ?? ''
+    const promises: PromiseLike<any>[] = []
     for (const [moduleName, moduleMetadata] of modules) {
       if (
         !moduleMetadata.controllers ||
@@ -70,27 +120,30 @@ export class NaviosApplication {
       ) {
         continue
       }
-      this.server.register(
-        (instance, opts, done) => {
-          for (const controller of moduleMetadata.controllers) {
-            this.controllerAdapter.setupController(
-              controller,
-              instance,
-              moduleMetadata,
-            )
-          }
-          done()
-        },
-        {
-          prefix: globalPrefix,
-        },
+      promises.push(
+        this.server!.register(
+          (instance, opts, done) => {
+            for (const controller of moduleMetadata.controllers) {
+              this.controllerAdapter.setupController(
+                controller,
+                instance,
+                moduleMetadata,
+              )
+            }
+            done()
+          },
+          {
+            prefix: this.globalPrefix ?? '',
+          },
+        ),
       )
     }
+
+    await Promise.all(promises)
   }
 
   enableCors(options: FastifyCorsOptions) {
     this.corsOptions = options
-    this.server?.register
   }
 
   setGlobalPrefix(prefix: string) {

package/src/navios.factory.mts

@@ -1,7 +1,11 @@
 import type { NaviosModule } from './interfaces/index.mjs'
-import type { NaviosApplicationOptions } from './navios.application.mjs'
+import type {
+  NaviosApplicationContextOptions,
+  NaviosApplicationOptions,
+} from './navios.application.mjs'
 import type { ClassTypeWithInstance } from './service-locator/index.mjs'
 
+import { isNil, LoggerInstance } from './logger/index.mjs'
 import { NaviosApplication } from './navios.application.mjs'
 import { inject } from './service-locator/index.mjs'
 
@@ -11,7 +15,20 @@ export class NaviosFactory {
     options: NaviosApplicationOptions = {},
   ) {
     const app = await inject(NaviosApplication)
+    this.registerLoggerConfiguration(options)
     app.setup(appModule, options)
     return app
   }
+
+  private static registerLoggerConfiguration(
+    options: NaviosApplicationContextOptions,
+  ) {
+    if (!options) {
+      return
+    }
+    const { logger } = options
+    if ((logger as boolean) !== true && !isNil(logger)) {
+      LoggerInstance.overrideLogger(logger)
+    }
+  }
 }

package/src/service-locator/inject.mts

@@ -1,4 +1,4 @@
-import type { AnyZodObject, z } from 'zod'
+import type { AnyZodObject, z, ZodOptional } from 'zod'
 
 import type { ClassType } from './injection-token.mjs'
 
@@ -11,6 +11,11 @@ export function inject<T, S extends AnyZodObject>(
   token: InjectionToken<T, S>,
   args: z.input<S>,
 ): Promise<T>
+export function inject<T, S extends ZodOptional<AnyZodObject>>(
+  token: InjectionToken<T, S>,
+  args?: z.input<S>,
+): Promise<T>
+
 export function inject<T>(token: InjectionToken<T, undefined>): Promise<T>
 export function inject<
   T,

package/src/service-locator/injection-token.mts

@@ -2,11 +2,16 @@ import type { AnyZodObject } from 'zod'
 
 import { randomUUID } from 'crypto'
 
+import { ZodOptional } from 'zod'
+
 export type ClassType = new (...args: any[]) => any
 
 export type ClassTypeWithInstance<T> = new (...args: any[]) => T
 
-export class InjectionToken<T, S extends AnyZodObject | unknown = unknown> {
+export class InjectionToken<
+  T,
+  S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown,
+> {
   public id = randomUUID()
   constructor(
     public readonly name: string | symbol | ClassType,
@@ -16,12 +21,12 @@ export class InjectionToken<T, S extends AnyZodObject | unknown = unknown> {
   static create<T extends ClassType>(
     name: T,
   ): InjectionToken<InstanceType<T>, undefined>
-  static create<T extends ClassType, Schema extends AnyZodObject>(
-    name: T,
-    schema: Schema,
-  ): InjectionToken<InstanceType<T>, Schema>
+  static create<
+    T extends ClassType,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject>,
+  >(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>
   static create<T>(name: string): InjectionToken<T, undefined>
-  static create<T, Schema extends AnyZodObject>(
+  static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(
     name: string,
     schema: Schema,
   ): InjectionToken<T, Schema>