@navios/core 0.1.13 → 0.1.15

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

@@ -5,7 +5,8 @@ import { inspect } from 'util'
 import type { LogLevel } from './log-levels.mjs'
 import type { LoggerService } from './logger-service.interface.mjs'
 
-import { Injectable } from '../service-locator/index.mjs'
+import { getServiceLocator, Injectable } from '../service-locator/index.mjs'
+import { Request } from '../tokens/index.mjs'
 import {
   clc,
   isFunction,
@@ -36,6 +37,10 @@ export interface ConsoleLoggerOptions {
    * Note: This option is not used when `json` is enabled.
    */
   prefix?: string
+  /**
+   * If enabled, will add a request ID to the log message.
+   */
+  requestId?: boolean
   /**
    * If enabled, will print the log message in JSON format.
    */
@@ -128,6 +133,10 @@ export class ConsoleLogger implements LoggerService {
    * 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).
    */
@@ -168,6 +177,24 @@ export class ConsoleLogger implements LoggerService {
       this.context = context
       this.originalContext = context
     }
+    if (opts?.requestId) {
+      const locator = getServiceLocator()
+      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
+          },
+        )
+    }
   }
 
   /**
@@ -358,6 +385,7 @@ export class ConsoleLogger implements LoggerService {
       message: unknown
       context?: string
       stack?: unknown
+      requestId?: string
     }
 
     const logObject: JsonLogObject = {
@@ -374,6 +402,9 @@ export class ConsoleLogger implements LoggerService {
     if (options.errorStack) {
       logObject.stack = options.errorStack
     }
+    if (this.options.requestId && this.requestId) {
+      logObject.requestId = this.requestId
+    }
 
     const formattedMessage =
       !this.options.colors && this.inspectOptions.compact === true
@@ -383,7 +414,7 @@ export class ConsoleLogger implements LoggerService {
   }
 
   protected formatPid(pid: number) {
-    return `[${this.options.prefix}] ${pid}  - `
+    return `[${this.options.prefix}] ${pid} - `
   }
 
   protected formatContext(context: string): string {
@@ -406,7 +437,14 @@ export class ConsoleLogger implements LoggerService {
     const output = this.stringifyMessage(message, logLevel)
     pidMessage = this.colorize(pidMessage, logLevel)
     formattedLogLevel = this.colorize(formattedLogLevel, logLevel)
-    return `${pidMessage}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}\n`
+    return `${pidMessage}${this.getRequestId()}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}\n`
+  }
+
+  protected getRequestId() {
+    if (this.options.requestId && this.requestId) {
+      return `(${this.colorize(this.requestId, 'log')}) `
+    }
+    return ''
   }
 
   protected stringifyMessage(message: unknown, logLevel: LogLevel): string {

package/src/logger/logger.service.mts

@@ -16,7 +16,6 @@ const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
   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

package/src/metadata/controller.metadata.mts

@@ -4,14 +4,14 @@ import type {
   ClassTypeWithInstance,
   InjectionToken,
 } from '../service-locator/index.mjs'
-import type { EndpointMetadata } from './endpoint.metadata.mjs'
+import type { HandlerMetadata } from './handler.metadata.mjs'
 
-import { getAllEndpointMetadata } from './endpoint.metadata.mjs'
+import { getAllEndpointMetadata } from './handler.metadata.mjs'
 
 export const ControllerMetadataKey = Symbol('ControllerMetadataKey')
 
 export interface ControllerMetadata {
-  endpoints: Set<EndpointMetadata>
+  endpoints: Set<HandlerMetadata>
   guards: Set<
     ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
   >

package/src/metadata/{endpoint.metadata.mts → handler.metadata.mts}

@@ -1,10 +1,7 @@
-import type {
-  BaseEndpointConfig,
-  BaseStreamConfig,
-  HttpMethod,
-} from '@navios/common'
+import type { HttpMethod } from '@navios/common'
 import type { HttpHeader } from 'fastify/types/utils.js'
 
+import type { HandlerAdapterInterface } from '../adapters/index.mjs'
 import type { CanActivate } from '../interfaces/index.mjs'
 import type {
   ClassTypeWithInstance,
@@ -13,22 +10,17 @@ import type {
 
 export const EndpointMetadataKey = Symbol('EndpointMetadataKey')
 
-export enum EndpointType {
-  Unknown = 'unknown',
-  Endpoint = 'endpoint',
-  Stream = 'stream',
-  Multipart = 'multipart',
-  Handler = 'handler',
-}
-
-export interface EndpointMetadata {
+export interface HandlerMetadata<Config = null> {
   classMethod: string
   url: string
   successStatusCode: number
-  type: EndpointType
+  adapterToken:
+    | InjectionToken<HandlerAdapterInterface, undefined>
+    | ClassTypeWithInstance<HandlerAdapterInterface>
+    | null
   headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>
   httpMethod: HttpMethod
-  config: BaseEndpointConfig | BaseStreamConfig | null
+  config: Config
   guards: Set<
     ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
   >
@@ -37,25 +29,25 @@ export interface EndpointMetadata {
 
 export function getAllEndpointMetadata(
   context: ClassMethodDecoratorContext | ClassDecoratorContext,
-): Set<EndpointMetadata> {
+): Set<HandlerMetadata<any>> {
   if (context.metadata) {
     const metadata = context.metadata[EndpointMetadataKey] as
-      | Set<EndpointMetadata>
+      | Set<HandlerMetadata>
       | undefined
     if (metadata) {
       return metadata
     } else {
-      context.metadata[EndpointMetadataKey] = new Set<EndpointMetadata>()
-      return context.metadata[EndpointMetadataKey] as Set<EndpointMetadata>
+      context.metadata[EndpointMetadataKey] = new Set<HandlerMetadata<any>>()
+      return context.metadata[EndpointMetadataKey] as Set<HandlerMetadata<any>>
     }
   }
   throw new Error('[Navios] Wrong environment.')
 }
 
-export function getEndpointMetadata(
+export function getEndpointMetadata<Config = any>(
   target: Function,
   context: ClassMethodDecoratorContext,
-): EndpointMetadata {
+): HandlerMetadata<Config> {
   if (context.metadata) {
     const metadata = getAllEndpointMetadata(context)
     if (metadata) {
@@ -65,13 +57,14 @@ export function getEndpointMetadata(
       if (endpointMetadata) {
         return endpointMetadata
       } else {
-        const newMetadata: EndpointMetadata = {
+        const newMetadata: HandlerMetadata<Config> = {
           classMethod: target.name,
           url: '',
           successStatusCode: 200,
+          adapterToken: null,
           headers: {},
-          type: EndpointType.Unknown,
           httpMethod: 'GET',
+          // @ts-expect-error We are using a generic type here
           config: null,
           guards: new Set<
             | ClassTypeWithInstance<CanActivate>

package/src/metadata/index.mts

@@ -1,4 +1,4 @@
 export * from './controller.metadata.mjs'
-export * from './endpoint.metadata.mjs'
+export * from './handler.metadata.mjs'
 export * from './injectable.metadata.mjs'
 export * from './module.metadata.mjs'

package/src/navios.application.mts

@@ -149,7 +149,7 @@ export class NaviosApplication {
         message: 'Not Found',
         error: 'NotFound',
       }
-      this.logger.error(`Route not found: ${req.url}`)
+      this.logger.error(`Route not found: [${req.method}] ${req.url}`)
       return reply.status(404).send(response)
     })
   }
@@ -178,15 +178,14 @@ export class NaviosApplication {
       }
       promises.push(
         this.server!.register(
-          (instance, opts, done) => {
+          async (instance, opts) => {
             for (const controller of moduleMetadata.controllers) {
-              this.controllerAdapter.setupController(
+              await this.controllerAdapter.setupController(
                 controller,
                 instance,
                 moduleMetadata,
               )
             }
-            done()
           },
           {
             prefix: this.globalPrefix ?? '',

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

@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import { z } from 'zod'
 
+import type {
+  Factory,
+  FactoryWithArgs,
+} from '../interfaces/factory.interface.mjs'
+
 import { Injectable, InjectableType } from '../decorators/index.mjs'
 import { inject } from '../inject.mjs'
 import { InjectionToken } from '../injection-token.mjs'
@@ -39,13 +44,13 @@ describe('InjectToken', () => {
   })
 
   it('should work with factory', async () => {
-    const token = InjectionToken.create('Test')
+    const token = InjectionToken.create<string>('Test')
     @Injectable({
       token,
       type: InjectableType.Factory,
     })
-    class Test {
-      create() {
+    class Test implements Factory<string> {
+      async create() {
         return 'foo'
       }
     }
@@ -64,8 +69,8 @@ describe('InjectToken', () => {
       token,
       type: InjectableType.Factory,
     })
-    class Test {
-      create(ctx: any, args: { test: string }) {
+    class Test implements FactoryWithArgs<string, typeof schema> {
+      async create(ctx: any, args: { test: string }) {
         return args.test
       }
     }

package/src/service-locator/decorators/injectable.decorator.mts

@@ -1,6 +1,12 @@
+import type { AnyZodObject } from 'zod'
+
 import { NaviosException } from '@navios/common'
 
-import type { ClassType } from '../injection-token.mjs'
+import type { ClassType, ClassTypeWithInstance } from '../injection-token.mjs'
+import type {
+  Factory,
+  FactoryWithArgs,
+} from '../interfaces/factory.interface.mjs'
 
 import { InjectableScope } from '../enums/index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
@@ -18,14 +24,55 @@ export interface InjectableOptions {
   token?: InjectionToken<any, any>
 }
 
-export const InjectableTokenMeta = Symbol('InjectableTokenMeta')
+export const InjectableTokenMeta = Symbol.for('InjectableTokenMeta')
 
+export function Injectable(): <T extends ClassType>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined> }
+export function Injectable<T extends ClassType>(options: {
+  scope?: InjectableScope
+  token: InjectionToken<T, undefined>
+}): (
+  target: T,
+  context: ClassDecoratorContext,
+) => T & {
+  [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>
+}
+export function Injectable<R>(options: {
+  scope?: InjectableScope
+  type: InjectableType.Factory
+}): <T extends ClassTypeWithInstance<Factory<R>>>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
+export function Injectable<R, S extends AnyZodObject>(options: {
+  scope?: InjectableScope
+  type: InjectableType.Factory
+  token: InjectionToken<R, S>
+}): <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<R, S> }
+export function Injectable<R>(options: {
+  scope?: InjectableScope
+  type: InjectableType.Factory
+  token: InjectionToken<R, undefined>
+}): <T extends ClassTypeWithInstance<Factory<R>>>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
 export function Injectable({
   scope = InjectableScope.Singleton,
   type = InjectableType.Class,
   token,
 }: InjectableOptions = {}) {
-  return (target: ClassType, context: ClassDecoratorContext) => {
+  return <T extends ClassType>(
+    target: T,
+    context: ClassDecoratorContext,
+  ): T & {
+    [InjectableTokenMeta]: InjectionToken<any, any>
+  } => {
     if (context.kind !== 'class') {
       throw new Error(
         '[ServiceLocator] @Injectable decorator can only be used on classes.',
@@ -59,6 +106,8 @@ export function Injectable({
     // @ts-expect-error
     target[InjectableTokenMeta] = injectableToken
 
-    return target
+    return target as T & {
+      [InjectableTokenMeta]: InjectionToken<any, any>
+    }
   }
 }

package/src/service-locator/inject.mts

@@ -7,6 +7,20 @@ import { InjectionToken } from './injection-token.mjs'
 import { getServiceLocator } from './injector.mjs'
 
 export function inject<T extends ClassType>(token: T): Promise<InstanceType<T>>
+// Not supported by TypeScript yet
+// export function inject<
+//   R,
+//   T extends ClassType & {
+//     [InjectableTokenMeta]: InjectionToken<R, undefined>
+//   },
+// >(token: T): Promise<R>
+// export function inject<
+//   R,
+//   S extends AnyZodObject,
+//   T extends ClassType & {
+//     [InjectableTokenMeta]: InjectionToken<R, S>
+//   },
+// >(token: T, args: z.input<S>): Promise<R>
 export function inject<T, S extends AnyZodObject>(
   token: InjectionToken<T, S>,
   args: z.input<S>,

package/src/service-locator/interfaces/factory.interface.mts

@@ -1,3 +1,11 @@
+import type { AnyZodObject } from 'zod'
+
+import { z } from 'zod'
+
 export interface Factory<T> {
-  create(ctx: any): Promise<T>
+  create(ctx?: any): Promise<T> | T
+}
+
+export interface FactoryWithArgs<T, A extends AnyZodObject> {
+  create(ctx: any, args: z.output<A>): Promise<T> | T
 }

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

@@ -65,6 +65,7 @@ export class ServiceLocator {
       destroyPromise: null,
       creationPromise: null,
     })
+    this.eventBus.emit(instanceName, 'create')
   }
 
   public removeInstance<Instance>(token: InjectionToken<Instance, undefined>) {

package/src/service-locator/sync-injector.mts

@@ -9,6 +9,20 @@ import { getServiceLocator } from './injector.mjs'
 let promiseCollector: null | ((promise: Promise<any>) => void) = null
 
 export function syncInject<T extends ClassType>(token: T): InstanceType<T>
+// Not supported by TypeScript yet
+// export function syncInject<
+//   R,
+//   T extends ClassType & {
+//     [InjectableTokenMeta]: InjectionToken<R, undefined>
+//   },
+// >(token: T): R
+// export function syncInject<
+//   R,
+//   S extends AnyZodObject,
+//   T extends ClassType & {
+//     [InjectableTokenMeta]: InjectionToken<R, S>
+//   },
+// >(token: T, args: z.input<S>): R
 export function syncInject<T, S extends AnyZodObject>(
   token: InjectionToken<T, S>,
   args: z.input<S>,