@navios/core 0.3.0 → 0.5.0

package/examples/simple-test/src/user/user.controller.mts

@@ -1,72 +0,0 @@
-import type {
-  EndpointParams,
-  EndpointResult,
-  MultipartParams,
-} from '../../../../src/index.mjs'
-
-import {
-  Controller,
-  Endpoint,
-  Logger,
-  Multipart,
-  syncInject,
-  UseGuards,
-} from '../../../../src/index.mjs'
-import {
-  discriminatorEndpoint,
-  multipartEndpoint,
-  patchUserEndpoint,
-  userEndpoint,
-} from '../../api/index.mjs'
-import { AclGuard } from '../acl/acl.guard.mjs'
-import { OneMoreGuard } from '../acl/one-more.guard.mjs'
-import { Public } from '../acl/public.attribute.mjs'
-import { UserService } from './user.service.mjs'
-
-@UseGuards(AclGuard)
-@Controller()
-export class UserController {
-  userService = syncInject(UserService)
-  logger = syncInject(Logger, {
-    context: UserController.name,
-  })
-
-  @Public()
-  @UseGuards(OneMoreGuard)
-  @Endpoint(userEndpoint)
-  async me(params: EndpointParams<typeof userEndpoint>) {
-    this.logger.log(params)
-    return this.userService.getUser()
-  }
-
-  @Endpoint(patchUserEndpoint)
-  async patchMe(params: EndpointParams<typeof patchUserEndpoint>) {
-    this.logger.log(params)
-    return {
-      ...this.userService.getUser(),
-      ...params.data,
-    }
-  }
-
-  @Endpoint(discriminatorEndpoint)
-  async discriminator(
-    params: EndpointParams<typeof discriminatorEndpoint>,
-  ): EndpointResult<typeof discriminatorEndpoint> {
-    this.logger.log(params)
-    return {
-      success: true,
-      data: {
-        id: '123',
-        name: 'John Doe',
-        email: 'test@example.com',
-      },
-    }
-  }
-
-  @Multipart(multipartEndpoint)
-  async multipart(params: MultipartParams<typeof multipartEndpoint>) {
-    this.logger.log(params)
-    // params.data.
-    return {}
-  }
-}

package/examples/simple-test/src/user/user.module.mts

@@ -1,14 +0,0 @@
-import { Logger, Module, syncInject } from '../../../../src/index.mjs'
-import { AclModernGuard } from '../acl/acl-modern.guard.mjs'
-import { UserController } from './user.controller.mjs'
-
-@Module({
-  controllers: [UserController],
-  guards: [AclModernGuard],
-})
-export class UserModule {
-  logger = syncInject(Logger)
-  onModuleInit() {
-    this.logger.debug('Inside UserModule.onModuleInit')
-  }
-}

package/examples/simple-test/src/user/user.service.mts

@@ -1,14 +0,0 @@
-import { randomUUID } from 'node:crypto'
-
-import { Injectable } from '../../../../src/index.mjs'
-
-@Injectable()
-export class UserService {
-  getUser() {
-    return {
-      id: randomUUID() as string,
-      name: 'John Doe',
-      email: 'test@example.com',
-    }
-  }
-}

package/src/adapters/endpoint-adapter.service.mts

@@ -1,72 +0,0 @@
-import type { BaseEndpointConfig } from '@navios/builder'
-import type { ClassType } from '@navios/di'
-import type { FastifyReply, FastifyRequest } from 'fastify'
-
-import { inject, Injectable, InjectionToken } from '@navios/di'
-
-import type { HandlerMetadata } from '../metadata/index.mjs'
-import type { ExecutionContext } from '../services/index.mjs'
-
-import { StreamAdapterService } from './stream-adapter.service.mjs'
-
-export const EndpointAdapterToken =
-  InjectionToken.create<EndpointAdapterService>(
-    Symbol.for('EndpointAdapterService'),
-  )
-
-@Injectable({
-  token: EndpointAdapterToken,
-})
-export class EndpointAdapterService extends StreamAdapterService {
-  override hasSchema(
-    handlerMetadata: HandlerMetadata<BaseEndpointConfig>,
-  ): boolean {
-    const config = handlerMetadata.config
-    return super.hasSchema(handlerMetadata) || !!config.responseSchema
-  }
-
-  override provideSchema(
-    handlerMetadata: HandlerMetadata<BaseEndpointConfig>,
-  ): Record<string, any> {
-    const config = handlerMetadata.config
-    const schema = super.provideSchema(handlerMetadata)
-    if (config.responseSchema) {
-      schema.response = {
-        200: config.responseSchema,
-      }
-    }
-
-    return schema
-  }
-
-  override provideHandler(
-    controller: ClassType,
-    executionContext: ExecutionContext,
-    handlerMetadata: HandlerMetadata<BaseEndpointConfig>,
-  ): (request: FastifyRequest, reply: FastifyReply) => Promise<any> {
-    const getters = this.prepareArguments(handlerMetadata)
-    const formatArguments = async (request: FastifyRequest) => {
-      const argument: Record<string, any> = {}
-      const promises: Promise<void>[] = []
-      for (const getter of getters) {
-        const res = getter(argument, request)
-        if (res instanceof Promise) {
-          promises.push(res)
-        }
-      }
-      await Promise.all(promises)
-      return argument
-    }
-
-    return async function (request, reply) {
-      const controllerInstance = await inject(controller)
-      const argument = await formatArguments(request)
-      const result =
-        await controllerInstance[handlerMetadata.classMethod](argument)
-      reply
-        .status(handlerMetadata.successStatusCode)
-        .headers(handlerMetadata.headers)
-        .send(result)
-    }
-  }
-}

package/src/adapters/handler-adapter.interface.mts

@@ -1,21 +0,0 @@
-import type { ClassType } from '@navios/di'
-import type { FastifyReply, FastifyRequest } from 'fastify'
-
-import type { HandlerMetadata } from '../metadata/index.mjs'
-import type { ExecutionContext } from '../services/index.mjs'
-
-export interface HandlerAdapterInterface {
-  provideSchema?: (handlerMetadata: HandlerMetadata<any>) => Record<string, any>
-  hasSchema?: (handlerMetadata: HandlerMetadata<any>) => boolean
-  prepareArguments?: (
-    handlerMetadata: HandlerMetadata<any>,
-  ) => ((
-    target: Record<string, any>,
-    request: FastifyRequest,
-  ) => Promise<void> | void)[]
-  provideHandler: (
-    controller: ClassType,
-    executionContext: ExecutionContext,
-    handlerMetadata: HandlerMetadata<any>,
-  ) => (request: FastifyRequest, reply: FastifyReply) => Promise<any>
-}

package/src/adapters/index.mts

@@ -1,4 +0,0 @@
-export * from './endpoint-adapter.service.mjs'
-export * from './handler-adapter.interface.mjs'
-export * from './multipart-adapter.service.mjs'
-export * from './stream-adapter.service.mjs'

package/src/adapters/multipart-adapter.service.mts

@@ -1,131 +0,0 @@
-import type { MultipartFile, MultipartValue } from '@fastify/multipart'
-import type { BaseEndpointConfig } from '@navios/builder'
-import type { FastifyRequest } from 'fastify'
-import type { AnyZodObject, ZodRawShape } from 'zod'
-
-import { Injectable, InjectionToken } from '@navios/di'
-
-import { ZodArray, ZodObject, ZodOptional } from 'zod'
-
-import type { HandlerMetadata } from '../metadata/index.mjs'
-
-import { EndpointAdapterService } from './endpoint-adapter.service.mjs'
-
-export const MultipartAdapterToken =
-  InjectionToken.create<MultipartAdapterService>(
-    Symbol.for('MultipartAdapterService'),
-  )
-
-@Injectable({
-  token: MultipartAdapterToken,
-})
-export class MultipartAdapterService extends EndpointAdapterService {
-  prepareArguments(
-    handlerMetadata: HandlerMetadata<BaseEndpointConfig>,
-  ): ((target: Record<string, any>, request: FastifyRequest) => void)[] {
-    const config = handlerMetadata.config
-    const getters: ((
-      target: Record<string, any>,
-      request: FastifyRequest,
-    ) => void | Promise<void>)[] = []
-    if (config.querySchema) {
-      getters.push((target, request) => {
-        target.params = request.query
-      })
-    }
-    if (config.url.includes('$')) {
-      getters.push((target, request) => {
-        target.urlParams = request.params
-      })
-    }
-    const requestSchema = config.requestSchema as unknown as AnyZodObject
-    const shape = requestSchema._def.shape()
-    const structure = this.analyzeSchema(shape)
-    getters.push(async (target, request) => {
-      const req: Record<string, any> = {}
-      for await (const part of request.parts()) {
-        await this.populateRequest(structure, part, req)
-      }
-      target.data = requestSchema.parse(req)
-    })
-
-    return getters
-  }
-
-  private async populateRequest(
-    structure: {
-      [p: string]: { isArray: boolean; isOptional: boolean; isObject: boolean }
-    },
-    part: MultipartFile | MultipartValue<unknown>,
-    req: Record<string, any>,
-  ) {
-    const { isArray, isObject } = structure[part.fieldname] ?? {}
-    if (isArray && !req[part.fieldname]) {
-      req[part.fieldname] = []
-    }
-    let value
-    if (part.type === 'file') {
-      value = new File([await part.toBuffer()], part.filename, {
-        type: part.mimetype,
-      })
-    } else {
-      value = part.value
-      if (isObject && typeof value === 'string') {
-        value = JSON.parse(value)
-      }
-    }
-
-    if (isArray) {
-      req[part.fieldname].push(value)
-    } else {
-      req[part.fieldname] = value
-    }
-  }
-
-  private analyzeSchema(shape: ZodRawShape) {
-    return Object.keys(shape).reduce(
-      (target, key) => {
-        let schema = shape[key]
-        const isOptional = schema instanceof ZodOptional
-        if (isOptional) {
-          schema = (schema as ZodOptional<any>).unwrap()
-        }
-        const isArray = schema instanceof ZodArray
-        if (isArray) {
-          schema = (schema as ZodArray<any>).element
-        }
-        const isObject = schema instanceof ZodObject
-        return {
-          ...target,
-          [key]: {
-            isArray,
-            isOptional,
-            isObject,
-          },
-        }
-      },
-      {} as Record<
-        string,
-        { isArray: boolean; isOptional: boolean; isObject: boolean }
-      >,
-    )
-  }
-
-  override provideSchema(
-    handlerMetadata: HandlerMetadata<BaseEndpointConfig>,
-  ): Record<string, any> {
-    const schema: Record<string, any> = {}
-    const { querySchema, responseSchema } = handlerMetadata.config
-
-    if (querySchema) {
-      schema.querystring = querySchema
-    }
-    if (responseSchema) {
-      schema.response = {
-        200: responseSchema,
-      }
-    }
-
-    return schema
-  }
-}

package/src/adapters/stream-adapter.service.mts

@@ -1,91 +0,0 @@
-import type { BaseStreamConfig } from '@navios/builder'
-import type { ClassType } from '@navios/di'
-import type { FastifyReply, FastifyRequest } from 'fastify'
-
-import { inject, Injectable, InjectionToken } from '@navios/di'
-
-import type { HandlerMetadata } from '../metadata/index.mjs'
-import type { ExecutionContext } from '../services/index.mjs'
-import type { HandlerAdapterInterface } from './handler-adapter.interface.mjs'
-
-export const StreamAdapterToken = InjectionToken.create<StreamAdapterService>(
-  Symbol.for('StreamAdapterService'),
-)
-
-@Injectable({
-  token: StreamAdapterToken,
-})
-export class StreamAdapterService implements HandlerAdapterInterface {
-  hasSchema(handlerMetadata: HandlerMetadata<BaseStreamConfig>): boolean {
-    const config = handlerMetadata.config
-    return !!config.requestSchema || !!config.querySchema
-  }
-
-  prepareArguments(handlerMetadata: HandlerMetadata<BaseStreamConfig>) {
-    const config = handlerMetadata.config
-    const getters: ((
-      target: Record<string, any>,
-      request: FastifyRequest,
-    ) => void | Promise<void>)[] = []
-    if (config.querySchema) {
-      getters.push((target, request) => {
-        target.params = request.query
-      })
-    }
-    if (config.requestSchema) {
-      getters.push((target, request) => {
-        target.data = request.body
-      })
-    }
-    if (config.url.includes('$')) {
-      getters.push((target, request) => {
-        target.urlParams = request.params
-      })
-    }
-
-    return getters
-  }
-
-  provideHandler(
-    controller: ClassType,
-    executionContext: ExecutionContext,
-    handlerMetadata: HandlerMetadata<BaseStreamConfig>,
-  ): (request: FastifyRequest, reply: FastifyReply) => Promise<any> {
-    const getters = this.prepareArguments(handlerMetadata)
-    const formatArguments = async (request: FastifyRequest) => {
-      const argument: Record<string, any> = {}
-      const promises: Promise<void>[] = []
-      for (const getter of getters) {
-        const res = getter(argument, request)
-        if (res instanceof Promise) {
-          promises.push(res)
-        }
-      }
-      await Promise.all(promises)
-      return argument
-    }
-
-    return async function (request: FastifyRequest, reply: FastifyReply) {
-      const controllerInstance = await inject(controller)
-      const argument = await formatArguments(request)
-
-      await controllerInstance[handlerMetadata.classMethod](argument, reply)
-    }
-  }
-
-  provideSchema(
-    handlerMetadata: HandlerMetadata<BaseStreamConfig>,
-  ): Record<string, any> {
-    const schema: Record<string, any> = {}
-    const { querySchema, requestSchema } = handlerMetadata.config
-
-    if (querySchema) {
-      schema.querystring = querySchema
-    }
-    if (requestSchema) {
-      schema.body = requestSchema
-    }
-
-    return schema
-  }
-}

package/src/logger/logger.factory.mts

@@ -1,36 +0,0 @@
-import { Injectable, InjectableType, InjectionToken } from '@navios/di'
-
-import { z } from 'zod'
-
-import type { LoggerService } from './logger-service.interface.mjs'
-
-import { LoggerInstance } from './logger.service.mjs'
-
-export const LoggerInjectionToken = 'LoggerInjectionToken'
-
-export const LoggerOptions = z
-  .object({
-    context: z.string().optional(),
-    options: z
-      .object({
-        timestamp: z.boolean().optional(),
-      })
-      .optional(),
-  })
-  .optional()
-
-export const Logger = InjectionToken.create<
-  LoggerInstance,
-  typeof LoggerOptions
->(LoggerInjectionToken, LoggerOptions)
-
-@Injectable({
-  type: InjectableType.Factory,
-  token: Logger,
-})
-export class LoggerFactory {
-  create(ctx: any, args: z.infer<typeof LoggerOptions>) {
-    // @ts-expect-error We don't need to support this in the current version
-    return new LoggerInstance(args?.context, args?.options)
-  }
-}

package/src/logger/pino-wrapper.mts

@@ -1,64 +0,0 @@
-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() {
-    // We don't want to populate the logs with the original fastify logs
-    // this.logger.debug?.('INFO', message, ...optionalParams)
-  }
-
-  debug(message: any, ...optionalParams: any[]) {
-    this.logger.debug?.(message, ...optionalParams)
-  }
-
-  trace(message: any, ...optionalParams: any[]) {
-    this.logger.verbose?.(message, ...optionalParams)
-  }
-
-  silent() {
-    // 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.find((level) => level !== 'verbose')
-    }
-    return 'warn'
-  }
-}

package/src/services/controller-adapter.service.mts

@@ -1,124 +0,0 @@
-import type { ClassType } from '@navios/di'
-import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
-import type { ZodTypeProvider } from 'fastify-type-provider-zod'
-
-import {
-  getGlobalServiceLocator,
-  inject,
-  Injectable,
-  InjectionToken,
-  syncInject,
-} from '@navios/di'
-
-import type { HandlerAdapterInterface } from '../adapters/index.mjs'
-import type { ModuleMetadata } from '../metadata/index.mjs'
-
-import { Logger } from '../logger/index.mjs'
-import { extractControllerMetadata } from '../metadata/index.mjs'
-import { ExecutionContextToken, Reply, Request } from '../tokens/index.mjs'
-import { ExecutionContext } from './execution-context.mjs'
-import { GuardRunnerService } from './guard-runner.service.mjs'
-
-@Injectable()
-export class ControllerAdapterService {
-  guardRunner = syncInject(GuardRunnerService)
-  private logger = syncInject(Logger, {
-    context: ControllerAdapterService.name,
-  })
-
-  async setupController(
-    controller: ClassType,
-    instance: FastifyInstance,
-    moduleMetadata: ModuleMetadata,
-  ) {
-    const controllerMetadata = extractControllerMetadata(controller)
-    for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod, adapterToken } = endpoint
-
-      if (!url || !adapterToken) {
-        throw new Error(
-          `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`,
-        )
-      }
-      const adapter = await inject(
-        adapterToken as InjectionToken<HandlerAdapterInterface>,
-      )
-      const executionContext = new ExecutionContext(
-        moduleMetadata,
-        controllerMetadata,
-        endpoint,
-      )
-      const hasSchema = adapter.hasSchema?.(endpoint) ?? false
-      if (hasSchema) {
-        instance.withTypeProvider<ZodTypeProvider>().route({
-          method: httpMethod,
-          url: url.replaceAll('$', ':'),
-          schema: adapter.provideSchema?.(endpoint) ?? {},
-          preHandler: this.providePreHandler(executionContext),
-          handler: this.wrapHandler(
-            executionContext,
-            adapter.provideHandler(controller, executionContext, endpoint),
-          ),
-        })
-      } else {
-        instance.route({
-          method: httpMethod,
-          url: url.replaceAll('$', ':'),
-          preHandler: this.providePreHandler(executionContext),
-          handler: this.wrapHandler(
-            executionContext,
-            adapter.provideHandler(controller, executionContext, endpoint),
-          ),
-        })
-      }
-
-      this.logger.debug(
-        `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`,
-      )
-    }
-  }
-
-  providePreHandler(executionContext: ExecutionContext) {
-    const guards = this.guardRunner.makeContext(executionContext)
-    return guards.size > 0
-      ? this.wrapHandler(
-          executionContext,
-          async (request: FastifyRequest, reply: FastifyReply) => {
-            let canActivate = true
-            canActivate = await this.guardRunner.runGuards(
-              guards,
-              executionContext,
-            )
-            if (!canActivate) {
-              return reply
-            }
-          },
-        )
-      : undefined
-  }
-
-  private wrapHandler(
-    executionContext: ExecutionContext,
-    handler: (request: FastifyRequest, reply: FastifyReply) => Promise<void>,
-  ) {
-    const locator = getGlobalServiceLocator()
-    return async (request: FastifyRequest, reply: FastifyReply) => {
-      locator.storeInstance(request, Request)
-      locator.storeInstance(reply, Reply)
-      locator.storeInstance(executionContext, ExecutionContextToken)
-      executionContext.provideRequest(request)
-      executionContext.provideReply(reply)
-      try {
-        return await handler(request, reply)
-      } finally {
-        Promise.all([
-          locator.removeInstance(Request),
-          locator.removeInstance(Reply),
-          locator.removeInstance(ExecutionContextToken),
-        ]).catch((err) => {
-          this.logger.warn(`Error removing instances: ${err}`)
-        })
-      }
-    }
-  }
-}