@navios/core 0.1.1 → 0.1.3

package/package.json

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

package/src/config/config-service.interface.mts

@@ -0,0 +1,16 @@
+import type { Path, PathValue } from './types.mjs'
+
+export interface ConfigService<Config = Record<string, unknown>> {
+  getConfig: () => Config
+  get: <Key extends Path<Config>>(key: Key) => PathValue<Config, Key> | null
+
+  getOrDefault: <Key extends Path<Config>>(
+    key: Key,
+    defaultValue: PathValue<Config, Key>,
+  ) => PathValue<Config, Key>
+
+  getOrThrow: <Key extends Path<Config>>(
+    key: Key,
+    errorMessage?: string,
+  ) => PathValue<Config, Key>
+}

package/src/config/config.provider.mts

@@ -0,0 +1,62 @@
+import { z } from 'zod'
+
+import type { ConfigService } from './config-service.interface.mjs'
+
+import { Logger } from '../logger/index.mjs'
+import {
+  getInjectableToken,
+  inject,
+  Injectable,
+  InjectableType,
+  InjectionToken,
+} 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)
+
+@Injectable({
+  token: ConfigProvider,
+  type: InjectableType.Factory,
+})
+export class ConfigProviderFactory {
+  logger = inject(Logger, {
+    context: 'ConfigService',
+  })
+
+  async create(ctx: any, args: z.infer<typeof ConfigProviderOptions>) {
+    const { load } = args
+    const logger = await this.logger
+    try {
+      const config = await load()
+
+      return new ConfigServiceInstance(config, logger)
+    } catch (error) {
+      logger.error('Error loading config', error)
+      throw error
+    }
+  }
+}
+
+export function makeConfigToken<Config 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)
+}

package/src/config/config.service.mts

@@ -0,0 +1,69 @@
+import { NaviosException } from '@navios/common'
+
+import type { LoggerService } from '../logger/index.mjs'
+import type { ConfigService } from './config-service.interface.mjs'
+import type { Path, PathValue } from './types.mjs'
+
+export class ConfigServiceInstance<Config = Record<string, unknown>>
+  implements ConfigService<Config>
+{
+  constructor(
+    private config: Config = {} as Config,
+    private logger: LoggerService,
+  ) {}
+
+  getConfig(): Config {
+    return this.config
+  }
+
+  get<Key extends Path<Config>>(key: Key): PathValue<Config, Key> | null {
+    try {
+      const parts = String(key).split('.')
+      let value: any = this.config
+
+      for (const part of parts) {
+        if (
+          value === null ||
+          value === undefined ||
+          typeof value !== 'object'
+        ) {
+          return null
+        }
+        value = value[part]
+      }
+
+      return (value as PathValue<Config, Key>) ?? null
+    } catch (error) {
+      this.logger.debug?.(
+        `Failed to get config value for key ${String(key)}`,
+        error,
+      )
+      return null
+    }
+  }
+
+  getOrDefault<Key extends Path<Config>>(
+    key: Key,
+    defaultValue: PathValue<Config, Key>,
+  ): PathValue<Config, Key> {
+    const value = this.get(key)
+    return value !== null ? value : defaultValue
+  }
+
+  getOrThrow<Key extends Path<Config>>(
+    key: Key,
+    errorMessage?: string,
+  ): PathValue<Config, Key> {
+    const value = this.get(key)
+
+    if (value === null) {
+      const message =
+        errorMessage ||
+        `Configuration value for key "${String(key)}" is not defined`
+      this.logger.error(message)
+      throw new NaviosException(message)
+    }
+
+    return value
+  }
+}

package/src/config/index.mts

@@ -0,0 +1,5 @@
+export * from './utils/index.mjs'
+export * from './config.provider.mjs'
+export * from './config.service.mjs'
+export * from './config-service.interface.mjs'
+export * from './types.mjs'

package/src/config/types.mts

@@ -0,0 +1,58 @@
+/**
+ * Evaluates to `true` if `T` is `any`. `false` otherwise.
+ * (c) https://stackoverflow.com/a/68633327/5290447
+ */
+type IsAny<T> = unknown extends T
+  ? [keyof T] extends [never]
+    ? false
+    : true
+  : false
+
+type ExcludedParts =
+  | 'services'
+  | 'mailer'
+  | 'aws'
+  | 'computedTimeRates'
+  | 'aiModelsRates'
+type ExcludedKeys = 'computedTimeRates' | 'aiModelsRates' | 'aiModel'
+
+export type PathImpl<T, Key extends keyof T> = Key extends string
+  ? Key extends ExcludedKeys
+    ? never
+    : IsAny<T[Key]> extends true
+      ? never
+      : T[Key] extends string
+        ? never
+        : T[Key] extends any[]
+          ? never
+          : T[Key] extends Record<string, any>
+            ? Key extends ExcludedParts
+              ? `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}`
+              :
+                  | `${Key}.${PathImpl<T[Key], Exclude<keyof T[Key], keyof any[]>> & string}`
+                  | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}`
+            : never
+  : never
+
+export type PathImpl2<T> = PathImpl<T, keyof T> | keyof T
+
+export type Path<T> = keyof T extends string
+  ? PathImpl2<T> extends infer P
+    ? P extends string | keyof T
+      ? P
+      : keyof T
+    : keyof T
+  : never
+
+export type PathValue<
+  T,
+  P extends Path<T>,
+> = P extends `${infer Key}.${infer Rest}`
+  ? Key extends keyof T
+    ? Rest extends Path<T[Key]>
+      ? PathValue<T[Key], Rest>
+      : never
+    : never
+  : P extends keyof T
+    ? T[P]
+    : never

package/src/config/utils/helpers.mts

@@ -0,0 +1,23 @@
+import { env } from 'node:process'
+
+export function envInt(
+  key: keyof NodeJS.ProcessEnv,
+  defaultValue: number,
+): number {
+  const envKey = env[key] || process.env[key]
+
+  return envKey ? parseInt(envKey as string, 10) : defaultValue
+}
+
+export function envString<
+  DefaultValue extends string | undefined,
+  Ensured = DefaultValue extends string ? true : false,
+>(
+  key: keyof NodeJS.ProcessEnv,
+  defaultValue?: DefaultValue,
+): Ensured extends true ? string : string | undefined {
+  return (env[key] ||
+    process.env[key] ||
+    defaultValue ||
+    undefined) as Ensured extends true ? string : string | undefined
+}

package/src/config/utils/index.mts

@@ -0,0 +1 @@
+export * from './helpers.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/index.mts

@@ -1,3 +1,4 @@
+export * from './config/index.mjs'
 export * from './decorators/index.mjs'
 export * from './exceptions/index.mjs'
 export * from './interfaces/index.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/proxy-service-locator.mts

@@ -1,4 +1,4 @@
-import type { AnyZodObject, input, output } from 'zod'
+import type { AnyZodObject, output, z, ZodOptional } from 'zod'
 
 import type { FactoryNotFound, UnknownError } from './index.mjs'
 import type { InjectionToken } from './injection-token.mjs'
@@ -33,11 +33,17 @@ export class ProxyServiceLocator implements ServiceLocator {
   ): void {
     return this.serviceLocator.registerAbstractFactory(token, factory)
   }
-  public getInstance<Instance, Schema extends AnyZodObject | undefined>(
+  public getInstance<
+    Instance,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+  >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject ? input<Schema> : undefined,
+    args: Schema extends AnyZodObject
+      ? z.input<Schema>
+      : Schema extends ZodOptional<AnyZodObject>
+        ? z.input<Schema> | undefined
+        : undefined,
   ): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]> {
-    // @ts-expect-error
     return this.ctx.inject(token, args).then(
       (instance) => {
         return [undefined, instance]
@@ -47,16 +53,29 @@ export class ProxyServiceLocator implements ServiceLocator {
       },
     )
   }
-  public getOrThrowInstance<Instance, Schema extends AnyZodObject | undefined>(
+  public getOrThrowInstance<
+    Instance,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+  >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject ? input<Schema> : undefined,
+    args: Schema extends AnyZodObject
+      ? z.input<Schema>
+      : Schema extends ZodOptional<AnyZodObject>
+        ? z.input<Schema> | undefined
+        : undefined,
   ): Promise<Instance> {
-    // @ts-expect-error We need to pass the args to the ctx.inject method
     return this.ctx.inject(token, args)
   }
-  public getSyncInstance<Instance, Schema extends AnyZodObject | undefined>(
+  public getSyncInstance<
+    Instance,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+  >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject ? input<Schema> : undefined,
+    args: Schema extends AnyZodObject
+      ? z.input<Schema>
+      : Schema extends ZodOptional<AnyZodObject>
+        ? z.input<Schema> | undefined
+        : undefined,
   ): Instance | null {
     return this.serviceLocator.getSyncInstance(token, args)
   }

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

@@ -456,7 +456,15 @@ export class ServiceLocator {
   makeInstanceName(token: InjectionToken<any, any>, args: any) {
     let stringifiedArgs = args
       ? ':' +
-        JSON.stringify(args)
+        JSON.stringify(args, (_, value) => {
+          if (typeof value === 'function') {
+            return `function:${value.name}(${value.length})`
+          }
+          if (typeof value === 'symbol') {
+            return value.toString()
+          }
+          return value
+        })
           .replaceAll(/"/g, '')
           .replaceAll(/:/g, '=')
           .replaceAll(/,/g, '|')