@navios/core 0.1.14 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/core",
-  "version": "0.1.14",
+  "version": "0.2.0",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"
@@ -11,7 +11,7 @@
     "url": "https://github.com/Arilas/navios.git"
   },
   "license": "MIT",
-  "typings": "./dist/index.d.ts",
+  "typings": "./dist/src/index.d.mts",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "peerDependencies": {
@@ -40,6 +40,7 @@
   "dependencies": {
     "@fastify/cors": "^11.0.1",
     "@fastify/multipart": "^9.0.3",
+    "@navios/di": "^0.1.2",
     "fastify": "^5.3.2",
     "fastify-type-provider-zod": "^4.0.2"
   }

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

@@ -0,0 +1,72 @@
+import type { BaseEndpointConfig } from '@navios/common'
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,131 @@
+import type { MultipartFile, MultipartValue } from '@fastify/multipart'
+import type { BaseEndpointConfig } from '@navios/common'
+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

@@ -0,0 +1,91 @@
+import type { BaseStreamConfig } from '@navios/common'
+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/attribute.factory.mts

@@ -1,11 +1,11 @@
+import type { ClassType } from '@navios/di'
 import type { z, ZodType } from 'zod'
 
 import type {
   ControllerMetadata,
-  EndpointMetadata,
+  HandlerMetadata,
   ModuleMetadata,
 } from './metadata/index.mjs'
-import type { ClassType } from './service-locator/index.mjs'
 
 import {
   getControllerMetadata,
@@ -86,30 +86,30 @@ export class AttributeFactory {
 
   static get(
     attribute: ClassAttribute,
-    target: ModuleMetadata | ControllerMetadata | EndpointMetadata,
+    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,
   ): true | null
   static get<T extends ZodType>(
     attribute: ClassSchemaAttribute<T>,
-    target: ModuleMetadata | ControllerMetadata | EndpointMetadata,
+    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,
   ): z.output<T> | null
   static get(
     attribute: ClassAttribute | ClassSchemaAttribute<any>,
-    target: ModuleMetadata | ControllerMetadata | EndpointMetadata,
+    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,
   ) {
     return target.customAttributes.get(attribute.token) ?? null
   }
 
   static getAll(
     attribute: ClassAttribute,
-    target: ModuleMetadata | ControllerMetadata | EndpointMetadata,
+    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,
   ): Array<true> | null
   static getAll<T extends ZodType>(
     attribute: ClassSchemaAttribute<T>,
-    target: ModuleMetadata | ControllerMetadata | EndpointMetadata,
+    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,
   ): Array<z.output<T>> | null
   static getAll(
     attribute: ClassAttribute | ClassSchemaAttribute<any>,
-    target: ModuleMetadata | ControllerMetadata | EndpointMetadata,
+    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,
   ) {
     const values = Array.from(target.customAttributes.entries())
       .filter(([key]) => key === attribute.token)
@@ -119,15 +119,15 @@ export class AttributeFactory {
 
   static getLast(
     attribute: ClassAttribute,
-    target: (ModuleMetadata | ControllerMetadata | EndpointMetadata)[],
+    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],
   ): true | null
   static getLast<T extends ZodType>(
     attribute: ClassSchemaAttribute<T>,
-    target: (ModuleMetadata | ControllerMetadata | EndpointMetadata)[],
+    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],
   ): z.output<T> | null
   static getLast(
     attribute: ClassAttribute | ClassSchemaAttribute<any>,
-    target: (ModuleMetadata | ControllerMetadata | EndpointMetadata)[],
+    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],
   ) {
     for (let i = target.length - 1; i >= 0; i--) {
       const value = target[i].customAttributes.get(attribute.token)
@@ -140,15 +140,15 @@ export class AttributeFactory {
 
   static has(
     attribute: ClassAttribute,
-    target: ModuleMetadata | ControllerMetadata | EndpointMetadata,
+    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,
   ): boolean
   static has<T extends ZodType>(
     attribute: ClassSchemaAttribute<T>,
-    target: ModuleMetadata | ControllerMetadata | EndpointMetadata,
+    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,
   ): boolean
   static has(
     attribute: ClassAttribute | ClassSchemaAttribute<any>,
-    target: ModuleMetadata | ControllerMetadata | EndpointMetadata,
+    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,
   ) {
     return target.customAttributes.has(attribute.token)
   }

package/src/config/config.provider.mts

@@ -1,14 +1,15 @@
-import { z } from 'zod'
-
-import type { ConfigService } from './config-service.interface.mjs'
-
-import { Logger } from '../logger/index.mjs'
 import {
   Injectable,
   InjectableType,
   InjectionToken,
   syncInject,
-} from '../service-locator/index.mjs'
+} from '@navios/di'
+
+import { z } from 'zod'
+
+import type { ConfigService } from './config-service.interface.mjs'
+
+import { Logger } from '../logger/index.mjs'
 import { ConfigServiceInstance } from './config.service.mjs'
 
 export const ConfigProviderOptions = z.object({
@@ -29,13 +30,19 @@ export class ConfigProviderFactory {
     context: 'ConfigService',
   })
 
-  async create(ctx: any, args: z.infer<typeof ConfigProviderOptions>) {
+  async create(
+    ctx: any,
+    args: z.infer<typeof ConfigProviderOptions>,
+  ): Promise<ConfigService> {
     const { load } = args
     const logger = this.logger
     try {
       const config = await load()
 
-      return new ConfigServiceInstance(config, logger)
+      return new ConfigServiceInstance(
+        config,
+        logger,
+      ) as unknown as ConfigService
     } catch (error) {
       logger.error('Error loading config', error)
       throw error
@@ -46,8 +53,5 @@ export class ConfigProviderFactory {
 export function provideConfig<ConfigMap extends Record<string, unknown>>(
   options: z.input<typeof ConfigProviderOptions>,
 ) {
-  return InjectionToken.bound(ConfigProvider, options) as InjectionToken<
-    ConfigServiceInstance<ConfigMap>,
-    undefined
-  >
+  return InjectionToken.bound(ConfigProvider, options)
 }

package/src/decorators/controller.decorator.mts

@@ -1,12 +1,8 @@
-import type { ClassType } from '../service-locator/index.mjs'
+import type { ClassType } from '@navios/di'
+
+import { Injectable, InjectableScope, InjectionToken } from '@navios/di'
 
 import { getControllerMetadata } from '../metadata/index.mjs'
-import {
-  Injectable,
-  InjectableScope,
-  InjectableType,
-  InjectionToken,
-} from '../service-locator/index.mjs'
 
 export interface ControllerOptions {
   guards?: ClassType[] | Set<ClassType>
@@ -29,7 +25,6 @@ export function Controller({ guards }: ControllerOptions = {}) {
     }
     return Injectable({
       token,
-      type: InjectableType.Class,
       scope: InjectableScope.Instance,
     })(target, context)
   }

package/src/decorators/endpoint.decorator.mts

@@ -7,7 +7,8 @@ import type { AnyZodObject, z, ZodType } from 'zod'
 
 import { ZodDiscriminatedUnion } from 'zod'
 
-import { EndpointType, getEndpointMetadata } from '../metadata/index.mjs'
+import { EndpointAdapterToken } from '../adapters/index.mjs'
+import { getEndpointMetadata } from '../metadata/index.mjs'
 
 export type EndpointParams<
   EndpointDeclaration extends {
@@ -82,7 +83,10 @@ export function Endpoint<
     }
     const config = endpoint.config
     if (context.metadata) {
-      let endpointMetadata = getEndpointMetadata(target, context)
+      let endpointMetadata = getEndpointMetadata<BaseEndpointConfig>(
+        target,
+        context,
+      )
       if (endpointMetadata.config && endpointMetadata.config.url) {
         throw new Error(
           `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`,
@@ -90,7 +94,7 @@ export function Endpoint<
       }
       // @ts-expect-error We don't need to set correctly in the metadata
       endpointMetadata.config = config
-      endpointMetadata.type = EndpointType.Endpoint
+      endpointMetadata.adapterToken = EndpointAdapterToken
       endpointMetadata.classMethod = target.name
       endpointMetadata.httpMethod = config.method
       endpointMetadata.url = config.url

package/src/decorators/header.decorator.mts

@@ -1,6 +1,6 @@
 import type { HttpHeader } from 'fastify/types/utils.js'
 
-import { EndpointType, getEndpointMetadata } from '../metadata/index.mjs'
+import { getEndpointMetadata } from '../metadata/index.mjs'
 
 export function Header(name: HttpHeader, value: string | number | string[]) {
   return <T extends Function>(
@@ -11,11 +11,6 @@ export function Header(name: HttpHeader, value: string | number | string[]) {
       throw new Error('[Navios] Header decorator can only be used on methods.')
     }
     const metadata = getEndpointMetadata(target, context)
-    if (metadata.type === EndpointType.Stream) {
-      throw new Error(
-        '[Navios] HttpCode decorator cannot be used on stream endpoints.',
-      )
-    }
 
     metadata.headers[name] = value
 

package/src/decorators/http-code.decorator.mts

@@ -1,4 +1,4 @@
-import { EndpointType, getEndpointMetadata } from '../metadata/index.mjs'
+import { getEndpointMetadata } from '../metadata/index.mjs'
 
 export function HttpCode(code: number) {
   return <T extends Function>(
@@ -11,11 +11,6 @@ export function HttpCode(code: number) {
       )
     }
     const metadata = getEndpointMetadata(target, context)
-    if (metadata.type === EndpointType.Stream) {
-      throw new Error(
-        '[Navios] HttpCode decorator cannot be used on stream endpoints.',
-      )
-    }
     metadata.successStatusCode = code
 
     return target

package/src/decorators/module.decorator.mts

@@ -1,12 +1,8 @@
-import type { ClassType } from '../service-locator/index.mjs'
+import type { ClassType } from '@navios/di'
+
+import { Injectable, InjectableScope, InjectionToken } from '@navios/di'
 
 import { getModuleMetadata } from '../metadata/index.mjs'
-import {
-  Injectable,
-  InjectableScope,
-  InjectableType,
-  InjectionToken,
-} from '../service-locator/index.mjs'
 
 export interface ModuleOptions {
   controllers?: ClassType[] | Set<ClassType>
@@ -14,7 +10,13 @@ export interface ModuleOptions {
   guards?: ClassType[] | Set<ClassType>
 }
 
-export function Module(metadata: ModuleOptions) {
+export function Module(
+  { controllers = [], imports = [], guards = [] }: ModuleOptions = {
+    controllers: [],
+    imports: [],
+    guards: [],
+  },
+) {
   return (target: ClassType, context: ClassDecoratorContext) => {
     if (context.kind !== 'class') {
       throw new Error('[Navios] @Module decorator can only be used on classes.')
@@ -22,25 +24,18 @@ export function Module(metadata: ModuleOptions) {
     // Register the module in the service locator
     const token = InjectionToken.create(target)
     const moduleMetadata = getModuleMetadata(target, context)
-    if (metadata.controllers) {
-      for (const controller of metadata.controllers) {
-        moduleMetadata.controllers.add(controller)
-      }
+    for (const controller of controllers) {
+      moduleMetadata.controllers.add(controller)
     }
-    if (metadata.imports) {
-      for (const importedModule of metadata.imports) {
-        moduleMetadata.imports.add(importedModule)
-      }
+    for (const importedModule of imports) {
+      moduleMetadata.imports.add(importedModule)
     }
-    if (metadata.guards) {
-      for (const guard of Array.from(metadata.guards).reverse()) {
-        moduleMetadata.guards.add(guard)
-      }
+    for (const guard of Array.from(guards).reverse()) {
+      moduleMetadata.guards.add(guard)
     }
 
     return Injectable({
       token,
-      type: InjectableType.Class,
       scope: InjectableScope.Singleton,
     })(target, context)
   }

package/src/decorators/multipart.decorator.mts

@@ -7,7 +7,8 @@ import type { AnyZodObject, z, ZodType } from 'zod'
 
 import { ZodDiscriminatedUnion } from 'zod'
 
-import { EndpointType, getEndpointMetadata } from '../metadata/index.mjs'
+import { MultipartAdapterToken } from '../adapters/index.mjs'
+import { getEndpointMetadata } from '../metadata/index.mjs'
 
 export type MultipartParams<
   EndpointDeclaration extends {
@@ -82,7 +83,10 @@ export function Multipart<
     }
     const config = endpoint.config
     if (context.metadata) {
-      let endpointMetadata = getEndpointMetadata(target, context)
+      let endpointMetadata = getEndpointMetadata<BaseEndpointConfig>(
+        target,
+        context,
+      )
       if (endpointMetadata.config && endpointMetadata.config.url) {
         throw new Error(
           `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`,
@@ -90,7 +94,7 @@ export function Multipart<
       }
       // @ts-expect-error We don't need to set correctly in the metadata
       endpointMetadata.config = config
-      endpointMetadata.type = EndpointType.Multipart
+      endpointMetadata.adapterToken = MultipartAdapterToken
       endpointMetadata.classMethod = target.name
       endpointMetadata.httpMethod = config.method
       endpointMetadata.url = config.url