@navios/core 0.1.2 → 0.1.4

package/package.json

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

package/src/config/config.provider.mts

@@ -4,8 +4,6 @@ import type { ConfigService } from './config-service.interface.mjs'
 
 import { Logger } from '../logger/index.mjs'
 import {
-  getInjectableToken,
-  inject,
   Injectable,
   InjectableType,
   InjectionToken,
@@ -13,28 +11,27 @@ import {
 } from '../service-locator/index.mjs'
 import { ConfigServiceInstance } from './config.service.mjs'
 
-export const ConfigProviderInjectionToken = 'ConfigProvider'
-
 export const ConfigProviderOptions = z.object({
   load: z.function(),
 })
+
 export const ConfigProvider = InjectionToken.create<
   ConfigService,
   typeof ConfigProviderOptions
->(ConfigProviderInjectionToken, ConfigProviderOptions)
+>(ConfigServiceInstance, ConfigProviderOptions)
 
 @Injectable({
   token: ConfigProvider,
   type: InjectableType.Factory,
 })
 export class ConfigProviderFactory {
-  logger = inject(Logger, {
+  logger = syncInject(Logger, {
     context: 'ConfigService',
   })
 
   async create(ctx: any, args: z.infer<typeof ConfigProviderOptions>) {
     const { load } = args
-    const logger = await this.logger
+    const logger = this.logger
     try {
       const config = await load()
 
@@ -46,18 +43,11 @@ export class ConfigProviderFactory {
   }
 }
 
-export function makeConfigToken<Config extends Record<string, unknown>>(
+export function provideConfig<ConfigMap extends Record<string, unknown>>(
   options: z.input<typeof ConfigProviderOptions>,
-): InjectionToken<ConfigService<Config>> {
-  @Injectable({
-    type: InjectableType.Factory,
-  })
-  class ConfigServiceImpl {
-    configService = inject(ConfigProvider, options)
-
-    create() {
-      return this.configService
-    }
-  }
-  return getInjectableToken(ConfigServiceImpl)
+) {
+  return InjectionToken.bound(ConfigProvider, options) as InjectionToken<
+    ConfigServiceInstance<ConfigMap>,
+    undefined
+  >
 }

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/service-locator/__tests__/injectable.spec.mts

@@ -2,11 +2,12 @@ import { describe, expect, it } from 'vitest'
 import { z } from 'zod'
 
 import {
+  getInjectableToken,
   Injectable,
   InjectableType,
 } from '../decorators/index.mjs'
 import { InjectableScope } from '../enums/index.mjs'
-import { getInjectableToken, syncInject } from '../index.mjs'
+import { syncInject } from '../index.mjs'
 import { inject } from '../inject.mjs'
 import { InjectionToken } from '../injection-token.mjs'
 import { getServiceLocator } from '../injector.mjs'

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

@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod'
+
+import { Injectable, InjectableType } from '../decorators/index.mjs'
+import { inject } from '../inject.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+
+describe('InjectToken', () => {
+  it('should work with class', async () => {
+    const token = InjectionToken.create('Test')
+    @Injectable({
+      token,
+    })
+    class Test {}
+
+    const value = await inject(Test)
+    expect(value).toBeInstanceOf(Test)
+  })
+
+  it('should work with class and schema', async () => {
+    const schema = z.object({
+      test: z.string(),
+    })
+    const token = InjectionToken.create('Test', schema)
+
+    @Injectable({
+      token,
+    })
+    class Test {
+      makeFoo() {
+        return 'foo'
+      }
+    }
+    const value = await inject(token, {
+      test: 'test',
+    })
+
+    expect(value).toBeInstanceOf(Test)
+  })
+
+  it('should work with factory', async () => {
+    const token = InjectionToken.create('Test')
+    @Injectable({
+      token,
+      type: InjectableType.Factory,
+    })
+    class Test {
+      create() {
+        return 'foo'
+      }
+    }
+
+    const value = await inject(Test)
+    expect(value).toBe('foo')
+  })
+
+  it('should work with factory and schema', async () => {
+    const schema = z.object({
+      test: z.string(),
+    })
+    const token = InjectionToken.create<string, typeof schema>('Test', schema)
+
+    @Injectable({
+      token,
+      type: InjectableType.Factory,
+    })
+    class Test {
+      create(ctx: any, args: { test: string }) {
+        return args.test
+      }
+    }
+    const value = await inject(token, {
+      test: 'test',
+    })
+
+    expect(value).toBe('test')
+  })
+
+  it('should work with bound token', async () => {
+    const schema = z.object({
+      test: z.string(),
+    })
+    const token = InjectionToken.create('Test', schema)
+    const boundToken = InjectionToken.bound(token, {
+      test: 'test',
+    })
+
+    @Injectable({
+      token,
+    })
+    class Test {
+      makeFoo() {
+        return 'foo'
+      }
+    }
+    const value = await inject(boundToken)
+
+    expect(value).toBeInstanceOf(Test)
+  })
+
+  it('should work with factory token', async () => {
+    const schema = z.object({
+      test: z.string(),
+    })
+    const token = InjectionToken.create('Test', schema)
+    const factoryInjectionToken = InjectionToken.factory(token, () =>
+      Promise.resolve({
+        test: 'test',
+      }),
+    )
+
+    @Injectable({
+      token,
+    })
+    class Test {
+      makeFoo() {
+        return 'foo'
+      }
+    }
+    const value = await inject(factoryInjectionToken)
+
+    expect(value).toBeInstanceOf(Test)
+  })
+})

package/src/service-locator/decorators/get-injectable-token.mts

@@ -1,12 +1,8 @@
-import type {
-  ClassType,
-  ClassTypeWithInstance,
-  InjectionToken,
-} from '../injection-token.mjs'
+import type { ClassType, InjectionToken } from '../injection-token.mjs'
 
 import { InjectableTokenMeta } from './injectable.decorator.mjs'
 
-export function getInjectableToken<R, T extends ClassTypeWithInstance<R>>(
+export function getInjectableToken<R>(
   target: ClassType,
 ): R extends { create(...args: any[]): infer V }
   ? InjectionToken<V>

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

@@ -1,10 +1,11 @@
+import { NaviosException } from '@navios/common'
+
 import type { ClassType } from '../injection-token.mjs'
 
 import { InjectableScope } from '../enums/index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
-import { getServiceLocator, provideServiceLocator } from '../injector.mjs'
-import { makeProxyServiceLocator } from '../proxy-service-locator.mjs'
-import { setPromiseCollector } from '../sync-injector.mjs'
+import { getServiceLocator } from '../injector.mjs'
+import { resolveService } from '../resolve-service.mjs'
 
 export enum InjectableType {
   Class = 'Class',
@@ -33,62 +34,22 @@ export function Injectable({
     let injectableToken: InjectionToken<any, any> =
       token ?? InjectionToken.create(target)
     const locator = getServiceLocator()
-    if (!locator) {
-      throw new Error(
-        '[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.',
-      )
-    }
     if (type === InjectableType.Class) {
       locator.registerAbstractFactory(
         injectableToken,
-        async (ctx) => {
-          if (scope === InjectableScope.Instance) {
-            ctx.setTtl(0)
-          }
-          const proxyServiceLocator = makeProxyServiceLocator(
-            getServiceLocator(),
-            ctx,
-          )
-          const promises: Promise<any>[] = []
-          const promiseCollector = (promise: Promise<any>) => {
-            promises.push(promise)
-          }
-          const originalPromiseCollector = setPromiseCollector(promiseCollector)
-          const tryInit = () => {
-            const original = provideServiceLocator(proxyServiceLocator)
-            let result = new target()
-            provideServiceLocator(original)
-            return result
-          }
-          const result = tryInit()
-          setPromiseCollector(originalPromiseCollector)
-          if (promises.length > 0) {
-            await Promise.all(promises)
-            return tryInit()
-          }
-          return result
-        },
+        async (ctx) => resolveService(ctx, target),
         scope,
       )
     } else if (type === InjectableType.Factory) {
       locator.registerAbstractFactory(
         injectableToken,
         async (ctx, args: any) => {
-          if (scope === InjectableScope.Instance) {
-            ctx.setTtl(0)
-          }
-          const proxyServiceLocator = makeProxyServiceLocator(
-            getServiceLocator(),
-            ctx,
-          )
-          const original = provideServiceLocator(proxyServiceLocator)
-          const builder = new target()
+          const builder = await resolveService(ctx, target)
           if (typeof builder.create !== 'function') {
-            throw new Error(
+            throw new NaviosException(
               `[ServiceLocator] Factory ${target.name} does not implement the create method.`,
             )
           }
-          provideServiceLocator(original)
           return builder.create(ctx, args)
         },
         scope,

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

@@ -4,4 +4,5 @@ export enum ErrorsEnum {
   InstanceDestroying = 'InstanceDestroying',
   UnknownError = 'UnknownError',
   FactoryNotFound = 'FactoryNotFound',
+  FactoryTokenNotResolved = 'FactoryTokenNotResolved',
 }

package/src/service-locator/errors/factory-token-not-resolved.mts

@@ -0,0 +1,10 @@
+import type { ClassType } from '../injection-token.mjs'
+
+import { ErrorsEnum } from './errors.enum.mjs'
+
+export class FactoryTokenNotResolved extends Error {
+  code = ErrorsEnum.FactoryTokenNotResolved
+  constructor(name: string | symbol | ClassType) {
+    super(`Factory token not resolved: ${name.toString()}`)
+  }
+}

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

@@ -1,5 +1,6 @@
 export * from './errors.enum.mjs'
 export * from './factory-not-found.mjs'
+export * from './factory-token-not-resolved.mjs'
 export * from './instance-destroying.mjs'
 export * from './instance-expired.mjs'
 export * from './instance-not-found.mjs'

package/src/service-locator/index.mts

@@ -12,3 +12,4 @@ export * from './service-locator-event-bus.mjs'
 export * from './service-locator-instance-holder.mjs'
 export * from './service-locator-manager.mjs'
 export * from './sync-injector.mjs'
+export * from './resolve-service.mjs'

package/src/service-locator/inject.mts

@@ -17,26 +17,12 @@ export function inject<T, S extends ZodOptional<AnyZodObject>>(
 ): Promise<T>
 
 export function inject<T>(token: InjectionToken<T, undefined>): Promise<T>
-export function inject<
-  T,
-  Token extends InjectionToken<T>,
-  S extends AnyZodObject | unknown = Token['schema'],
->(
-  token: Token,
-  args?: S extends AnyZodObject ? z.input<S> : never,
-): Promise<T> {
-  if (token.schema) {
-    const parsed = token.schema.safeParse(args)
-    if (!parsed.success) {
-      throw new Error(
-        `[ServiceLocator] Invalid arguments for ${token.name.toString()}: ${parsed.error}`,
-      )
-    }
-  }
-  let realToken: InjectionToken<T, S> = token
+export function inject(token: InjectionToken<any>, args?: unknown) {
+  let realToken = token
   if (!(token instanceof InjectionToken)) {
-    realToken = getInjectableToken(token) as InjectionToken<T, S>
+    realToken = getInjectableToken(token)
   }
 
+  // @ts-expect-error We chek the type in overload
   return getServiceLocator().getOrThrowInstance(realToken, args)
 }

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

@@ -2,7 +2,7 @@ import type { AnyZodObject } from 'zod'
 
 import { randomUUID } from 'crypto'
 
-import { ZodOptional } from 'zod'
+import { z, ZodOptional } from 'zod'
 
 export type ClassType = new (...args: any[]) => any
 
@@ -25,17 +25,68 @@ export class InjectionToken<
     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>(name: string | symbol): InjectionToken<T, undefined>
   static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(
-    name: string,
+    name: string | any,
     schema: Schema,
   ): InjectionToken<T, Schema>
-  static create(name: string, schema?: unknown) {
+  static create(name: string | symbol, schema?: unknown) {
     // @ts-expect-error
     return new InjectionToken(name, schema)
   }
 
-  toString() {
-    return this.name
+  static bound<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(
+    token: InjectionToken<T, S>,
+    value: z.input<S>,
+  ): BoundInjectionToken<T, S> {
+    return new BoundInjectionToken(token, value)
+  }
+
+  static factory<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(
+    token: InjectionToken<T, S>,
+    factory: () => Promise<z.input<S>>,
+  ): FactoryInjectionToken<T, S> {
+    return new FactoryInjectionToken(token, factory)
+  }
+
+  static refineType<T>(
+    token: BoundInjectionToken<any, any>,
+  ): BoundInjectionToken<T, any> {
+    return token as BoundInjectionToken<T, any>
+  }
+}
+
+export class BoundInjectionToken<
+  T,
+  S extends AnyZodObject | ZodOptional<AnyZodObject>,
+> extends InjectionToken<T, undefined> {
+  constructor(
+    public readonly token: InjectionToken<T, S>,
+    public readonly value: z.input<S>,
+  ) {
+    super(token.name, token.schema)
+    this.id = token.id
+  }
+}
+
+export class FactoryInjectionToken<
+  T,
+  S extends AnyZodObject | ZodOptional<AnyZodObject>,
+> extends InjectionToken<T, S> {
+  public value?: z.input<S>
+  public resolved = false
+  constructor(
+    public readonly token: InjectionToken<T, S>,
+    public readonly factory: () => Promise<z.input<S>>,
+  ) {
+    super(token.name, token.schema)
+  }
+
+  async resolve(): Promise<z.input<S>> {
+    if (!this.value) {
+      this.value = await this.factory()
+      this.resolved = true
+    }
+    return this.value
   }
 }