@navios/core 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/core",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"
@@ -15,7 +15,7 @@
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "peerDependencies": {
-    "@navios/common": "^0.1.1",
+    "@navios/common": "^0.1.3",
     "zod": "^3.23.8"
   },
   "exports": {
@@ -32,7 +32,8 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@navios/common": "^0.1.1",
+    "@fastify/multipart": "^9.0.3",
+    "@navios/common": "^0.1.3",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "zod": "^3.24.4"

package/src/decorators/endpoint.decorator.mts

@@ -90,7 +90,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.type = EndpointType.Endpoint
       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 { getEndpointMetadata } from '../metadata/index.mjs'
+import { EndpointType, getEndpointMetadata } from '../metadata/index.mjs'
 
 export function Header(name: HttpHeader, value: string | number | string[]) {
   return <T extends Function>(
@@ -11,6 +11,12 @@ 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
 
     return target

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

@@ -1,4 +1,4 @@
-import { getEndpointMetadata } from '../metadata/index.mjs'
+import { EndpointType, getEndpointMetadata } from '../metadata/index.mjs'
 
 export function HttpCode(code: number) {
   return <T extends Function>(
@@ -11,6 +11,11 @@ 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/index.mts

@@ -3,4 +3,6 @@ export * from './endpoint.decorator.mjs'
 export * from './header.decorator.mjs'
 export * from './http-code.decorator.mjs'
 export * from './module.decorator.mjs'
+export * from './multipart.decorator.mjs'
+export * from './stream.decorator.mjs'
 export * from './use-guards.decorator.mjs'

package/src/decorators/multipart.decorator.mts

@@ -0,0 +1,100 @@
+import type {
+  BaseEndpointConfig,
+  EndpointFunctionArgs,
+  HttpMethod,
+} from '@navios/common'
+import type { AnyZodObject, z, ZodType } from 'zod'
+
+import { ZodDiscriminatedUnion } from 'zod'
+
+import { EndpointType, getEndpointMetadata } from '../metadata/index.mjs'
+
+export type MultipartParams<
+  EndpointDeclaration extends {
+    config: BaseEndpointConfig<any, any, any, any, any>
+  },
+  Url extends string = EndpointDeclaration['config']['url'],
+  QuerySchema = EndpointDeclaration['config']['querySchema'],
+> = QuerySchema extends AnyZodObject
+  ? EndpointDeclaration['config']['requestSchema'] extends ZodType
+    ? EndpointFunctionArgs<
+        Url,
+        QuerySchema,
+        EndpointDeclaration['config']['requestSchema']
+      >
+    : EndpointFunctionArgs<Url, QuerySchema, undefined>
+  : EndpointDeclaration['config']['requestSchema'] extends ZodType
+    ? EndpointFunctionArgs<
+        Url,
+        undefined,
+        EndpointDeclaration['config']['requestSchema']
+      >
+    : EndpointFunctionArgs<Url, undefined, undefined>
+
+export type MultipartResult<
+  EndpointDeclaration extends {
+    config: BaseEndpointConfig<any, any, any, any, any>
+  },
+> =
+  EndpointDeclaration['config']['responseSchema'] extends ZodDiscriminatedUnion<
+    any,
+    infer Options
+  >
+    ? Promise<z.input<Options[number]>>
+    : Promise<z.input<EndpointDeclaration['config']['responseSchema']>>
+
+export function Multipart<
+  Method extends HttpMethod = HttpMethod,
+  Url extends string = string,
+  QuerySchema = undefined,
+  ResponseSchema extends ZodType = ZodType,
+  RequestSchema = ZodType,
+>(endpoint: {
+  config: BaseEndpointConfig<
+    Method,
+    Url,
+    QuerySchema,
+    ResponseSchema,
+    RequestSchema
+  >
+}) {
+  return (
+    target: (
+      params: QuerySchema extends AnyZodObject
+        ? RequestSchema extends ZodType
+          ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema>
+          : EndpointFunctionArgs<Url, QuerySchema, undefined>
+        : RequestSchema extends ZodType
+          ? EndpointFunctionArgs<Url, undefined, RequestSchema>
+          : EndpointFunctionArgs<Url, undefined, undefined>,
+    ) => Promise<z.input<ResponseSchema>>,
+    context: ClassMethodDecoratorContext,
+  ) => {
+    if (typeof target !== 'function') {
+      throw new Error(
+        '[Navios] Endpoint decorator can only be used on functions.',
+      )
+    }
+    if (context.kind !== 'method') {
+      throw new Error(
+        '[Navios] Endpoint decorator can only be used on methods.',
+      )
+    }
+    const config = endpoint.config
+    if (context.metadata) {
+      let endpointMetadata = getEndpointMetadata(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.`,
+        )
+      }
+      // @ts-expect-error We don't need to set correctly in the metadata
+      endpointMetadata.config = config
+      endpointMetadata.type = EndpointType.Multipart
+      endpointMetadata.classMethod = target.name
+      endpointMetadata.httpMethod = config.method
+      endpointMetadata.url = config.url
+    }
+    return target
+  }
+}

package/src/decorators/stream.decorator.mts

@@ -0,0 +1,81 @@
+import type {
+  BaseStreamConfig,
+  EndpointFunctionArgs,
+  HttpMethod,
+} from '@navios/common'
+import type { FastifyReply } from 'fastify'
+import type { AnyZodObject, ZodType } from 'zod'
+
+import { EndpointType, getEndpointMetadata } from '../metadata/index.mjs'
+
+export type StreamParams<
+  EndpointDeclaration extends {
+    config: BaseStreamConfig<any, any, any, any>
+  },
+  Url extends string = EndpointDeclaration['config']['url'],
+  QuerySchema = EndpointDeclaration['config']['querySchema'],
+> = QuerySchema extends AnyZodObject
+  ? EndpointDeclaration['config']['requestSchema'] extends ZodType
+    ? EndpointFunctionArgs<
+        Url,
+        QuerySchema,
+        EndpointDeclaration['config']['requestSchema']
+      >
+    : EndpointFunctionArgs<Url, QuerySchema, undefined>
+  : EndpointDeclaration['config']['requestSchema'] extends ZodType
+    ? EndpointFunctionArgs<
+        Url,
+        undefined,
+        EndpointDeclaration['config']['requestSchema']
+      >
+    : EndpointFunctionArgs<Url, undefined, undefined>
+
+export function Stream<
+  Method extends HttpMethod = HttpMethod,
+  Url extends string = string,
+  QuerySchema = undefined,
+  RequestSchema = ZodType,
+>(endpoint: {
+  config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>
+}) {
+  return (
+    target: (
+      params: QuerySchema extends AnyZodObject
+        ? RequestSchema extends ZodType
+          ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema>
+          : EndpointFunctionArgs<Url, QuerySchema, undefined>
+        : RequestSchema extends ZodType
+          ? EndpointFunctionArgs<Url, undefined, RequestSchema>
+          : EndpointFunctionArgs<Url, undefined, undefined>,
+      reply: FastifyReply,
+    ) => Promise<void>,
+    context: ClassMethodDecoratorContext,
+  ) => {
+    if (typeof target !== 'function') {
+      throw new Error(
+        '[Navios] Endpoint decorator can only be used on functions.',
+      )
+    }
+    if (context.kind !== 'method') {
+      throw new Error(
+        '[Navios] Endpoint decorator can only be used on methods.',
+      )
+    }
+    const config = endpoint.config
+    if (context.metadata) {
+      let endpointMetadata = getEndpointMetadata(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.`,
+        )
+      }
+      // @ts-expect-error We don't need to set correctly in the metadata
+      endpointMetadata.config = config
+      endpointMetadata.type = EndpointType.Stream
+      endpointMetadata.classMethod = target.name
+      endpointMetadata.httpMethod = config.method
+      endpointMetadata.url = config.url
+    }
+    return target
+  }
+}

package/src/metadata/endpoint.metadata.mts

@@ -1,4 +1,8 @@
-import type { BaseEndpointConfig, HttpMethod } from '@navios/common'
+import type {
+  BaseEndpointConfig,
+  BaseStreamConfig,
+  HttpMethod,
+} from '@navios/common'
 import type { HttpHeader } from 'fastify/types/utils.js'
 
 import type { CanActivate } from '../interfaces/index.mjs'
@@ -11,7 +15,9 @@ export const EndpointMetadataKey = Symbol('EndpointMetadataKey')
 
 export enum EndpointType {
   Unknown = 'unknown',
-  Config = 'config',
+  Endpoint = 'endpoint',
+  Stream = 'stream',
+  Multipart = 'multipart',
   Handler = 'handler',
 }
 
@@ -22,7 +28,7 @@ export interface EndpointMetadata {
   type: EndpointType
   headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>
   httpMethod: HttpMethod
-  config: BaseEndpointConfig | null
+  config: BaseEndpointConfig | BaseStreamConfig | null
   guards: Set<
     ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
   >

package/src/metadata/module.metadata.mts

@@ -50,7 +50,7 @@ export function extractModuleMetadata(target: ClassType): ModuleMetadata {
   const metadata = target[ModuleMetadataKey] as ModuleMetadata | undefined
   if (!metadata) {
     throw new Error(
-      '[Navios] Module metadata not found. Make sure to use @Module decorator.',
+      `[Navios] Module metadata not found for ${target.name}. Make sure to use @Module decorator.`,
     )
   }
   return metadata

package/src/navios.application.mts

@@ -1,4 +1,5 @@
 import type { FastifyCorsOptions } from '@fastify/cors'
+import type { FastifyMultipartOptions } from '@fastify/multipart'
 import type {
   FastifyInstance,
   FastifyListenOptions,
@@ -50,6 +51,7 @@ export class NaviosApplication {
   })
   private server: FastifyInstance | null = null
   private corsOptions: FastifyCorsOptions | null = null
+  private multipartOptions: FastifyMultipartOptions | true | null = null
   private globalPrefix: string | null = null
 
   private appModule: ClassTypeWithInstance<NaviosModule> | null = null
@@ -81,6 +83,10 @@ export class NaviosApplication {
       await this.server.register(cors, this.corsOptions)
     }
 
+    if (this.multipartOptions) {
+      await this.configureMultipart(this.server, this.multipartOptions)
+    }
+
     await this.initModules()
     await this.server.ready()
 
@@ -147,6 +153,26 @@ export class NaviosApplication {
     })
   }
 
+  async configureMultipart(
+    server: FastifyInstance,
+    options: FastifyMultipartOptions | true,
+  ): Promise<void> {
+    if (options) {
+      try {
+        const multipartModule = await import('@fastify/multipart')
+        await server.register(
+          multipartModule.default,
+          typeof options === 'object' ? options : {},
+        )
+      } catch (error) {
+        this.logger.error(
+          `@fastify/multipart is not installed. Please install it.`,
+        )
+        throw error
+      }
+    }
+  }
+
   private async initModules() {
     const modules = this.moduleLoader.getAllModules()
     const promises: PromiseLike<any>[] = []
@@ -183,6 +209,10 @@ export class NaviosApplication {
     this.corsOptions = options
   }
 
+  enableMultipart(options: FastifyMultipartOptions) {
+    this.multipartOptions = options
+  }
+
   setGlobalPrefix(prefix: string) {
     this.globalPrefix = prefix
   }

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

@@ -1,8 +1,12 @@
+import type { BaseEndpointConfig } from '@navios/common'
 import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
 import type { ZodTypeProvider } from 'fastify-type-provider-zod'
+import type { AnyZodObject } from 'zod'
 
 import { NaviosException } from '@navios/common'
 
+import { ZodArray } from 'zod'
+
 import type { EndpointMetadata, ModuleMetadata } from '../metadata/index.mjs'
 import type { ClassType } from '../service-locator/index.mjs'
 
@@ -94,12 +98,12 @@ export class ControllerAdapterService {
       return {}
     }
     const { querySchema, requestSchema, responseSchema } =
-      endpointMetadata.config
+      endpointMetadata.config as BaseEndpointConfig
     const schema: Record<string, any> = {}
     if (querySchema) {
       schema.querystring = querySchema
     }
-    if (requestSchema) {
+    if (requestSchema && endpointMetadata.type !== EndpointType.Multipart) {
       schema.body = requestSchema
     }
     if (responseSchema) {
@@ -122,12 +126,24 @@ export class ControllerAdapterService {
           `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`,
         )
         throw new NaviosException('Unknown endpoint type')
-      case EndpointType.Config:
+      case EndpointType.Endpoint:
         return this.provideHandlerForConfig(
           controller,
           executionContext,
           endpointMetadata,
         )
+      case EndpointType.Stream:
+        return this.provideHandlerForStream(
+          controller,
+          executionContext,
+          endpointMetadata,
+        )
+      case EndpointType.Multipart:
+        return this.provideHandlerForMultipart(
+          controller,
+          executionContext,
+          endpointMetadata,
+        )
       case EndpointType.Handler:
         this.logger.error('Not implemented yet')
         throw new NaviosException('Not implemented yet')
@@ -174,4 +190,115 @@ export class ControllerAdapterService {
       }
     }
   }
+
+  private provideHandlerForStream(
+    controller: ClassType,
+    executionContext: ExecutionContext,
+    endpointMetadata: EndpointMetadata,
+  ): (request: FastifyRequest, reply: FastifyReply) => Promise<void> {
+    return async (request, reply) => {
+      getServiceLocator().registerInstance(Request, request)
+      getServiceLocator().registerInstance(Reply, reply)
+      getServiceLocator().registerInstance(
+        ExecutionContextToken,
+        executionContext,
+      )
+      executionContext.provideRequest(request)
+      executionContext.provideReply(reply)
+      const controllerInstance = await inject(controller)
+      try {
+        const { query, params, body } = request
+        const argument: Record<string, any> = {}
+        if (query && Object.keys(query).length > 0) {
+          argument.params = query
+        }
+        if (params && Object.keys(params).length > 0) {
+          argument.urlParams = params
+        }
+        if (body) {
+          argument.data = body
+        }
+
+        await controllerInstance[endpointMetadata.classMethod](argument, reply)
+      } finally {
+        getServiceLocator().removeInstance(Request)
+        getServiceLocator().removeInstance(Reply)
+        getServiceLocator().removeInstance(ExecutionContextToken)
+      }
+    }
+  }
+
+  private provideHandlerForMultipart(
+    controller: ClassType,
+    executionContext: ExecutionContext,
+    endpointMetadata: EndpointMetadata,
+  ): (request: FastifyRequest, reply: FastifyReply) => Promise<void> {
+    const config = endpointMetadata.config as BaseEndpointConfig
+    const requestSchema = config.requestSchema as unknown as AnyZodObject
+    const shape = requestSchema._def.shape()
+    return async (request, reply) => {
+      getServiceLocator().registerInstance(Request, request)
+      getServiceLocator().registerInstance(Reply, reply)
+      getServiceLocator().registerInstance(
+        ExecutionContextToken,
+        executionContext,
+      )
+      executionContext.provideRequest(request)
+      executionContext.provideReply(reply)
+      const controllerInstance = await inject(controller)
+      try {
+        const parts = request.parts()
+        const { query, params } = request
+        const argument: Record<string, any> = {}
+        if (query && Object.keys(query).length > 0) {
+          argument.params = query
+        }
+        if (params && Object.keys(params).length > 0) {
+          argument.urlParams = params
+        }
+        const req: Record<string, any> = {}
+        for await (const part of parts) {
+          if (!shape[part.fieldname]) {
+            throw new NaviosException(
+              `Invalid field name ${part.fieldname} for multipart request`,
+            )
+          }
+          const schema = shape[part.fieldname]
+          if (part.type === 'file') {
+            const file = new File([await part.toBuffer()], part.filename, {
+              type: part.mimetype,
+            })
+            if (schema instanceof ZodArray) {
+              if (!req[part.fieldname]) {
+                req[part.fieldname] = []
+              }
+              req[part.fieldname].push(file)
+            } else {
+              req[part.fieldname] = file
+            }
+          } else {
+            if (schema instanceof ZodArray) {
+              if (!req[part.fieldname]) {
+                req[part.fieldname] = []
+              }
+              req[part.fieldname].push(part.value)
+            } else {
+              req[part.fieldname] = part.value
+            }
+          }
+        }
+        argument.body = requestSchema.parse(req)
+        const result =
+          await controllerInstance[endpointMetadata.classMethod](argument)
+        reply
+          .status(endpointMetadata.successStatusCode)
+          .headers(endpointMetadata.headers)
+          .send(result)
+      } finally {
+        getServiceLocator().removeInstance(Request)
+        getServiceLocator().removeInstance(Reply)
+        getServiceLocator().removeInstance(ExecutionContextToken)
+      }
+    }
+  }
 }