@navios/core 0.1.14 → 0.1.15

package/src/metadata/controller.metadata.mts

@@ -4,14 +4,14 @@ import type {
   ClassTypeWithInstance,
   InjectionToken,
 } from '../service-locator/index.mjs'
-import type { EndpointMetadata } from './endpoint.metadata.mjs'
+import type { HandlerMetadata } from './handler.metadata.mjs'
 
-import { getAllEndpointMetadata } from './endpoint.metadata.mjs'
+import { getAllEndpointMetadata } from './handler.metadata.mjs'
 
 export const ControllerMetadataKey = Symbol('ControllerMetadataKey')
 
 export interface ControllerMetadata {
-  endpoints: Set<EndpointMetadata>
+  endpoints: Set<HandlerMetadata>
   guards: Set<
     ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
   >

package/src/metadata/{endpoint.metadata.mts → handler.metadata.mts}

@@ -1,10 +1,7 @@
-import type {
-  BaseEndpointConfig,
-  BaseStreamConfig,
-  HttpMethod,
-} from '@navios/common'
+import type { HttpMethod } from '@navios/common'
 import type { HttpHeader } from 'fastify/types/utils.js'
 
+import type { HandlerAdapterInterface } from '../adapters/index.mjs'
 import type { CanActivate } from '../interfaces/index.mjs'
 import type {
   ClassTypeWithInstance,
@@ -13,22 +10,17 @@ import type {
 
 export const EndpointMetadataKey = Symbol('EndpointMetadataKey')
 
-export enum EndpointType {
-  Unknown = 'unknown',
-  Endpoint = 'endpoint',
-  Stream = 'stream',
-  Multipart = 'multipart',
-  Handler = 'handler',
-}
-
-export interface EndpointMetadata {
+export interface HandlerMetadata<Config = null> {
   classMethod: string
   url: string
   successStatusCode: number
-  type: EndpointType
+  adapterToken:
+    | InjectionToken<HandlerAdapterInterface, undefined>
+    | ClassTypeWithInstance<HandlerAdapterInterface>
+    | null
   headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>
   httpMethod: HttpMethod
-  config: BaseEndpointConfig | BaseStreamConfig | null
+  config: Config
   guards: Set<
     ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
   >
@@ -37,25 +29,25 @@ export interface EndpointMetadata {
 
 export function getAllEndpointMetadata(
   context: ClassMethodDecoratorContext | ClassDecoratorContext,
-): Set<EndpointMetadata> {
+): Set<HandlerMetadata<any>> {
   if (context.metadata) {
     const metadata = context.metadata[EndpointMetadataKey] as
-      | Set<EndpointMetadata>
+      | Set<HandlerMetadata>
       | undefined
     if (metadata) {
       return metadata
     } else {
-      context.metadata[EndpointMetadataKey] = new Set<EndpointMetadata>()
-      return context.metadata[EndpointMetadataKey] as Set<EndpointMetadata>
+      context.metadata[EndpointMetadataKey] = new Set<HandlerMetadata<any>>()
+      return context.metadata[EndpointMetadataKey] as Set<HandlerMetadata<any>>
     }
   }
   throw new Error('[Navios] Wrong environment.')
 }
 
-export function getEndpointMetadata(
+export function getEndpointMetadata<Config = any>(
   target: Function,
   context: ClassMethodDecoratorContext,
-): EndpointMetadata {
+): HandlerMetadata<Config> {
   if (context.metadata) {
     const metadata = getAllEndpointMetadata(context)
     if (metadata) {
@@ -65,13 +57,14 @@ export function getEndpointMetadata(
       if (endpointMetadata) {
         return endpointMetadata
       } else {
-        const newMetadata: EndpointMetadata = {
+        const newMetadata: HandlerMetadata<Config> = {
           classMethod: target.name,
           url: '',
           successStatusCode: 200,
+          adapterToken: null,
           headers: {},
-          type: EndpointType.Unknown,
           httpMethod: 'GET',
+          // @ts-expect-error We are using a generic type here
           config: null,
           guards: new Set<
             | ClassTypeWithInstance<CanActivate>

package/src/metadata/index.mts

@@ -1,4 +1,4 @@
 export * from './controller.metadata.mjs'
-export * from './endpoint.metadata.mjs'
+export * from './handler.metadata.mjs'
 export * from './injectable.metadata.mjs'
 export * from './module.metadata.mjs'

package/src/navios.application.mts

@@ -149,7 +149,7 @@ export class NaviosApplication {
         message: 'Not Found',
         error: 'NotFound',
       }
-      this.logger.error(`Route not found: ${req.url}`)
+      this.logger.error(`Route not found: [${req.method}] ${req.url}`)
       return reply.status(404).send(response)
     })
   }
@@ -178,15 +178,14 @@ export class NaviosApplication {
       }
       promises.push(
         this.server!.register(
-          (instance, opts, done) => {
+          async (instance, opts) => {
             for (const controller of moduleMetadata.controllers) {
-              this.controllerAdapter.setupController(
+              await this.controllerAdapter.setupController(
                 controller,
                 instance,
                 moduleMetadata,
               )
             }
-            done()
           },
           {
             prefix: this.globalPrefix ?? '',

package/src/service-locator/__tests__/injection-token.spec.mts

@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import { z } from 'zod'
 
+import type {
+  Factory,
+  FactoryWithArgs,
+} from '../interfaces/factory.interface.mjs'
+
 import { Injectable, InjectableType } from '../decorators/index.mjs'
 import { inject } from '../inject.mjs'
 import { InjectionToken } from '../injection-token.mjs'
@@ -39,13 +44,13 @@ describe('InjectToken', () => {
   })
 
   it('should work with factory', async () => {
-    const token = InjectionToken.create('Test')
+    const token = InjectionToken.create<string>('Test')
     @Injectable({
       token,
       type: InjectableType.Factory,
     })
-    class Test {
-      create() {
+    class Test implements Factory<string> {
+      async create() {
         return 'foo'
       }
     }
@@ -64,8 +69,8 @@ describe('InjectToken', () => {
       token,
       type: InjectableType.Factory,
     })
-    class Test {
-      create(ctx: any, args: { test: string }) {
+    class Test implements FactoryWithArgs<string, typeof schema> {
+      async create(ctx: any, args: { test: string }) {
         return args.test
       }
     }

package/src/service-locator/decorators/injectable.decorator.mts

@@ -1,6 +1,12 @@
+import type { AnyZodObject } from 'zod'
+
 import { NaviosException } from '@navios/common'
 
-import type { ClassType } from '../injection-token.mjs'
+import type { ClassType, ClassTypeWithInstance } from '../injection-token.mjs'
+import type {
+  Factory,
+  FactoryWithArgs,
+} from '../interfaces/factory.interface.mjs'
 
 import { InjectableScope } from '../enums/index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
@@ -18,14 +24,55 @@ export interface InjectableOptions {
   token?: InjectionToken<any, any>
 }
 
-export const InjectableTokenMeta = Symbol('InjectableTokenMeta')
+export const InjectableTokenMeta = Symbol.for('InjectableTokenMeta')
 
+export function Injectable(): <T extends ClassType>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined> }
+export function Injectable<T extends ClassType>(options: {
+  scope?: InjectableScope
+  token: InjectionToken<T, undefined>
+}): (
+  target: T,
+  context: ClassDecoratorContext,
+) => T & {
+  [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>
+}
+export function Injectable<R>(options: {
+  scope?: InjectableScope
+  type: InjectableType.Factory
+}): <T extends ClassTypeWithInstance<Factory<R>>>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
+export function Injectable<R, S extends AnyZodObject>(options: {
+  scope?: InjectableScope
+  type: InjectableType.Factory
+  token: InjectionToken<R, S>
+}): <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<R, S> }
+export function Injectable<R>(options: {
+  scope?: InjectableScope
+  type: InjectableType.Factory
+  token: InjectionToken<R, undefined>
+}): <T extends ClassTypeWithInstance<Factory<R>>>(
+  target: T,
+  context: ClassDecoratorContext,
+) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
 export function Injectable({
   scope = InjectableScope.Singleton,
   type = InjectableType.Class,
   token,
 }: InjectableOptions = {}) {
-  return (target: ClassType, context: ClassDecoratorContext) => {
+  return <T extends ClassType>(
+    target: T,
+    context: ClassDecoratorContext,
+  ): T & {
+    [InjectableTokenMeta]: InjectionToken<any, any>
+  } => {
     if (context.kind !== 'class') {
       throw new Error(
         '[ServiceLocator] @Injectable decorator can only be used on classes.',
@@ -59,6 +106,8 @@ export function Injectable({
     // @ts-expect-error
     target[InjectableTokenMeta] = injectableToken
 
-    return target
+    return target as T & {
+      [InjectableTokenMeta]: InjectionToken<any, any>
+    }
   }
 }

package/src/service-locator/inject.mts

@@ -7,6 +7,20 @@ import { InjectionToken } from './injection-token.mjs'
 import { getServiceLocator } from './injector.mjs'
 
 export function inject<T extends ClassType>(token: T): Promise<InstanceType<T>>
+// Not supported by TypeScript yet
+// export function inject<
+//   R,
+//   T extends ClassType & {
+//     [InjectableTokenMeta]: InjectionToken<R, undefined>
+//   },
+// >(token: T): Promise<R>
+// export function inject<
+//   R,
+//   S extends AnyZodObject,
+//   T extends ClassType & {
+//     [InjectableTokenMeta]: InjectionToken<R, S>
+//   },
+// >(token: T, args: z.input<S>): Promise<R>
 export function inject<T, S extends AnyZodObject>(
   token: InjectionToken<T, S>,
   args: z.input<S>,

package/src/service-locator/interfaces/factory.interface.mts

@@ -1,3 +1,11 @@
+import type { AnyZodObject } from 'zod'
+
+import { z } from 'zod'
+
 export interface Factory<T> {
-  create(ctx: any): Promise<T>
+  create(ctx?: any): Promise<T> | T
+}
+
+export interface FactoryWithArgs<T, A extends AnyZodObject> {
+  create(ctx: any, args: z.output<A>): Promise<T> | T
 }

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

@@ -9,6 +9,20 @@ import { getServiceLocator } from './injector.mjs'
 let promiseCollector: null | ((promise: Promise<any>) => void) = null
 
 export function syncInject<T extends ClassType>(token: T): InstanceType<T>
+// Not supported by TypeScript yet
+// export function syncInject<
+//   R,
+//   T extends ClassType & {
+//     [InjectableTokenMeta]: InjectionToken<R, undefined>
+//   },
+// >(token: T): R
+// export function syncInject<
+//   R,
+//   S extends AnyZodObject,
+//   T extends ClassType & {
+//     [InjectableTokenMeta]: InjectionToken<R, S>
+//   },
+// >(token: T, args: z.input<S>): R
 export function syncInject<T, S extends AnyZodObject>(
   token: InjectionToken<T, S>,
   args: z.input<S>,

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

@@ -1,21 +1,17 @@
-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 { HandlerAdapterInterface } from '../adapters/index.mjs'
+import type { ModuleMetadata } from '../metadata/index.mjs'
 import type { ClassType } from '../service-locator/index.mjs'
 
 import { Logger } from '../logger/index.mjs'
-import { EndpointType, extractControllerMetadata } from '../metadata/index.mjs'
+import { extractControllerMetadata } from '../metadata/index.mjs'
 import {
   getServiceLocator,
   inject,
   Injectable,
+  InjectionToken,
   syncInject,
 } from '../service-locator/index.mjs'
 import { ExecutionContextToken, Reply, Request } from '../tokens/index.mjs'
@@ -29,32 +25,51 @@ export class ControllerAdapterService {
     context: ControllerAdapterService.name,
   })
 
-  setupController(
+  async setupController(
     controller: ClassType,
     instance: FastifyInstance,
     moduleMetadata: ModuleMetadata,
-  ): void {
+  ) {
     const controllerMetadata = extractControllerMetadata(controller)
     for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod } = endpoint
+      const { classMethod, url, httpMethod, adapterToken } = endpoint
 
-      if (!url) {
+      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,
       )
-      instance.withTypeProvider<ZodTypeProvider>().route({
-        method: httpMethod,
-        url: url.replaceAll('$', ':'),
-        schema: this.provideSchemaForConfig(endpoint),
-        preHandler: this.providePreHandler(executionContext),
-        handler: this.provideHandler(controller, executionContext, 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}`,
@@ -65,239 +80,43 @@ export class ControllerAdapterService {
   providePreHandler(executionContext: ExecutionContext) {
     const guards = this.guardRunner.makeContext(executionContext)
     return guards.size > 0
-      ? async (request: FastifyRequest, reply: FastifyReply) => {
-          getServiceLocator().registerInstance(Request, request)
-          getServiceLocator().registerInstance(Reply, reply)
-          getServiceLocator().registerInstance(
-            ExecutionContextToken,
-            executionContext,
-          )
-          executionContext.provideRequest(request)
-          executionContext.provideReply(reply)
-          let canActivate = true
-          try {
+      ? this.wrapHandler(
+          executionContext,
+          async (request: FastifyRequest, reply: FastifyReply) => {
+            let canActivate = true
             canActivate = await this.guardRunner.runGuards(
               guards,
               executionContext,
             )
-          } finally {
-            getServiceLocator().removeInstance(Request)
-            getServiceLocator().removeInstance(Reply)
-            getServiceLocator().removeInstance(ExecutionContextToken)
-          }
-          if (!canActivate) {
-            return reply
-          }
-        }
-      : undefined
-  }
-
-  private provideSchemaForConfig(endpointMetadata: EndpointMetadata) {
-    if (!endpointMetadata.config) {
-      this.logger.warn(`No config found for endpoint ${endpointMetadata.url}`)
-      return {}
-    }
-    const { querySchema, requestSchema, responseSchema } =
-      endpointMetadata.config as BaseEndpointConfig
-    const schema: Record<string, any> = {}
-    if (querySchema) {
-      schema.querystring = querySchema
-    }
-    if (requestSchema && endpointMetadata.type !== EndpointType.Multipart) {
-      schema.body = requestSchema
-    }
-    if (responseSchema) {
-      schema.response = {
-        200: responseSchema,
-      }
-    }
-
-    return schema
-  }
-
-  private provideHandler(
-    controller: ClassType,
-    executionContext: ExecutionContext,
-    endpointMetadata: EndpointMetadata,
-  ): (request: FastifyRequest, reply: FastifyReply) => Promise<void> {
-    switch (endpointMetadata.type) {
-      case EndpointType.Unknown:
-        this.logger.error(
-          `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`,
-        )
-        throw new NaviosException('Unknown endpoint type')
-      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,
+            if (!canActivate) {
+              return reply
+            }
+          },
         )
-      case EndpointType.Handler:
-        this.logger.error('Not implemented yet')
-        throw new NaviosException('Not implemented yet')
-    }
-  }
-
-  private provideHandlerForConfig(
-    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
-        }
-        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)
-      }
-    }
-  }
-
-  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)
-      }
-    }
+      : undefined
   }
 
-  private provideHandlerForMultipart(
-    controller: ClassType,
+  private wrapHandler(
     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,
-      )
+    handler: (request: FastifyRequest, reply: FastifyReply) => Promise<void>,
+  ) {
+    const locator = getServiceLocator()
+    return async (request: FastifyRequest, reply: FastifyReply) => {
+      locator.registerInstance(Request, request)
+      locator.registerInstance(Reply, reply)
+      locator.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.data = requestSchema.parse(req)
-        const result =
-          await controllerInstance[endpointMetadata.classMethod](argument)
-        reply
-          .status(endpointMetadata.successStatusCode)
-          .headers(endpointMetadata.headers)
-          .send(result)
+        return await handler(request, reply)
       } finally {
-        getServiceLocator().removeInstance(Request)
-        getServiceLocator().removeInstance(Reply)
-        getServiceLocator().removeInstance(ExecutionContextToken)
+        Promise.all([
+          locator.removeInstance(Request),
+          locator.removeInstance(Reply),
+          locator.removeInstance(ExecutionContextToken),
+        ]).catch((err) => {
+          this.logger.warn(`Error removing instances: ${err}`)
+        })
       }
     }
   }