@navios/core 0.4.0 → 0.5.0

package/examples/simple-test/src/acl/acl-modern.guard.mts

@@ -1,15 +0,0 @@
-import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
-
-import { Injectable, Logger, syncInject } from '../../../../src/index.mjs'
-
-@Injectable()
-export class AclModernGuard implements CanActivate {
-  logger = syncInject(Logger, {
-    context: AclModernGuard.name,
-  })
-
-  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
-    this.logger.log('ACL Modern Guard activated')
-    return true
-  }
-}

package/examples/simple-test/src/acl/acl.guard.mts

@@ -1,14 +0,0 @@
-import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
-
-import { Injectable, Logger, syncInject } from '../../../../src/index.mjs'
-
-@Injectable()
-export class AclGuard implements CanActivate {
-  logger = syncInject(Logger, {
-    context: AclGuard.name,
-  })
-  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
-    this.logger.log('ACL Guard activated')
-    return true
-  }
-}

package/examples/simple-test/src/acl/app.guard.mts

@@ -1,27 +0,0 @@
-import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
-
-import {
-  AttributeFactory,
-  Injectable,
-  Logger,
-  syncInject,
-} from '../../../../src/index.mjs'
-import { Public } from './public.attribute.mjs'
-
-@Injectable()
-export class AppGuard implements CanActivate {
-  logger = syncInject(Logger, {
-    context: AppGuard.name,
-  })
-
-  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
-    const isPublic = AttributeFactory.getLast(Public, [
-      executionContext.getModule(),
-      executionContext.getController(),
-      executionContext.getHandler(),
-    ])
-    this.logger.log('App Guard activated')
-    this.logger.log('isPublic', isPublic)
-    return true
-  }
-}

package/examples/simple-test/src/acl/one-more.guard.mts

@@ -1,15 +0,0 @@
-import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
-
-import { Injectable, Logger, syncInject } from '../../../../src/index.mjs'
-
-@Injectable()
-export class OneMoreGuard implements CanActivate {
-  logger = syncInject(Logger, {
-    context: OneMoreGuard.name,
-  })
-
-  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
-    this.logger.log('One More Guard activated')
-    return true
-  }
-}

package/examples/simple-test/src/acl/public.attribute.mts

@@ -1,21 +0,0 @@
-import { z } from 'zod/v4'
-
-import { AttributeFactory } from '../../../../src/index.mjs'
-
-export const PublicSymbol = Symbol.for('Public')
-
-export const Public = AttributeFactory.createAttribute(PublicSymbol)
-export const RolesSymbol = Symbol.for('Roles')
-
-export const RolesSchema = z.object({
-  roles: z.array(
-    z.union([
-      z.literal('VIEWER'),
-      z.literal('USER'),
-      z.literal('ADMIN'),
-      z.literal('OWNER'),
-    ]),
-  ),
-})
-
-export const Roles = AttributeFactory.createAttribute(RolesSymbol, RolesSchema)

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

@@ -1,9 +0,0 @@
-import { Module } from '../../../src/index.mjs'
-import { AppGuard } from './acl/app.guard.mjs'
-import { UserModule } from './user/user.module.mjs'
-
-@Module({
-  imports: [UserModule],
-  guards: [AppGuard],
-})
-export class AppModule {}

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,135 +0,0 @@
-import type { MultipartFile, MultipartValue } from '@fastify/multipart'
-import type { BaseEndpointConfig } from '@navios/builder'
-import type { FastifyRequest } from 'fastify'
-import type { ZodRawShape } from 'zod/v4'
-
-import { Injectable, InjectionToken } from '@navios/di'
-
-import { ZodArray, ZodObject, ZodOptional } from 'zod/v4'
-
-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 ZodObject
-    const shape = requestSchema._zod.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()) as unknown as ArrayBuffer],
-        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/v4'
-
-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'
-  }
-}