@navios/core 0.1.14 → 0.2.0

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

@@ -1,23 +1,20 @@
-import type { BaseEndpointConfig } from '@navios/common'
+import type { ClassType } from '@navios/di'
 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'
-
-import { Logger } from '../logger/index.mjs'
-import { EndpointType, extractControllerMetadata } from '../metadata/index.mjs'
 import {
-  getServiceLocator,
+  getGlobalServiceLocator,
   inject,
   Injectable,
+  InjectionToken,
   syncInject,
-} from '../service-locator/index.mjs'
+} 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'
@@ -29,32 +26,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 +81,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 = 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)
-      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}`)
+        })
       }
     }
   }

package/src/services/execution-context.mts

@@ -2,7 +2,7 @@ import type { FastifyReply, FastifyRequest } from 'fastify'
 
 import type {
   ControllerMetadata,
-  EndpointMetadata,
+  HandlerMetadata,
   ModuleMetadata,
 } from '../metadata/index.mjs'
 
@@ -12,7 +12,7 @@ export class ExecutionContext {
   constructor(
     private readonly module: ModuleMetadata,
     private readonly controller: ControllerMetadata,
-    private readonly handler: EndpointMetadata,
+    private readonly handler: HandlerMetadata,
   ) {}
   getModule(): ModuleMetadata {
     return this.module
@@ -22,7 +22,7 @@ export class ExecutionContext {
     return this.controller
   }
 
-  getHandler(): EndpointMetadata {
+  getHandler(): HandlerMetadata {
     return this.handler
   }
 
@@ -47,6 +47,7 @@ export class ExecutionContext {
   provideRequest(request: FastifyRequest): void {
     this.request = request
   }
+
   provideReply(reply: FastifyReply): void {
     this.reply = reply
   }

package/src/services/guard-runner.service.mts

@@ -1,13 +1,11 @@
+import type { ClassTypeWithInstance } from '@navios/di'
+
+import { inject, Injectable, InjectionToken } from '@navios/di'
+
 import type { CanActivate } from '../interfaces/index.mjs'
-import type { ClassTypeWithInstance } from '../service-locator/index.mjs'
 import type { ExecutionContext } from './execution-context.mjs'
 
 import { HttpException } from '../exceptions/index.mjs'
-import {
-  inject,
-  Injectable,
-  InjectionToken,
-} from '../service-locator/index.mjs'
 
 @Injectable()
 export class GuardRunnerService {

package/src/services/module-loader.service.mts

@@ -1,10 +1,12 @@
+import type { ClassTypeWithInstance } from '@navios/di'
+
+import { inject, Injectable, syncInject } from '@navios/di'
+
 import type { NaviosModule } from '../interfaces/index.mjs'
 import type { ModuleMetadata } from '../metadata/index.mjs'
-import type { ClassTypeWithInstance } from '../service-locator/index.mjs'
 
 import { Logger } from '../logger/index.mjs'
 import { extractModuleMetadata } from '../metadata/index.mjs'
-import { inject, Injectable, syncInject } from '../service-locator/index.mjs'
 
 @Injectable()
 export class ModuleLoaderService {

package/src/tokens/application.token.mts

@@ -1,6 +1,6 @@
 import type { FastifyInstance } from 'fastify'
 
-import { InjectionToken } from '../service-locator/index.mjs'
+import { InjectionToken } from '@navios/di'
 
 const ApplicationInjectionToken = 'ApplicationInjectionToken'
 

package/src/tokens/execution-context.token.mts

@@ -1,4 +1,5 @@
-import { InjectionToken } from '../service-locator/index.mjs'
+import { InjectionToken } from '@navios/di'
+
 import { ExecutionContext } from '../services/index.mjs'
 
 export const ExecutionContextInjectionToken = 'ExecutionContextInjectionToken'

package/src/tokens/reply.token.mts

@@ -1,6 +1,6 @@
 import type { FastifyReply } from 'fastify'
 
-import { InjectionToken } from '../service-locator/index.mjs'
+import { InjectionToken } from '@navios/di'
 
 const ReplyInjectionToken = 'ReplyInjectionToken'
 

package/src/tokens/request.token.mts

@@ -1,6 +1,6 @@
 import type { FastifyRequest } from 'fastify'
 
-import { InjectionToken } from '../service-locator/index.mjs'
+import { InjectionToken } from '@navios/di'
 
 const RequestInjectionToken = 'RequestInjectionToken'
 

package/src/metadata/injectable.metadata.mts

@@ -1,11 +0,0 @@
-import type {
-  InjectableScope,
-  InjectableType,
-  InjectionToken,
-} from '../index.mjs'
-
-export interface InjectableMetadata<Instance = any, Schema = any> {
-  type: InjectableType
-  scope: InjectableScope
-  token: InjectionToken<Instance, Schema>
-}

package/src/service-locator/__tests__/injectable.spec.mts

@@ -1,171 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { z } from 'zod'
-
-import {
-  getInjectableToken,
-  Injectable,
-  InjectableType,
-} from '../decorators/index.mjs'
-import { InjectableScope } from '../enums/index.mjs'
-import { syncInject } from '../index.mjs'
-import { inject } from '../inject.mjs'
-import { InjectionToken } from '../injection-token.mjs'
-import { getServiceLocator } from '../injector.mjs'
-
-describe('Injectable decorator', () => {
-  it('should work with class', async () => {
-    @Injectable()
-    class Test {}
-
-    const value = await inject(Test)
-    expect(value).toBeInstanceOf(Test)
-  })
-
-  it('should work with inner inject', async () => {
-    @Injectable()
-    class Test {
-      makeFoo() {
-        return 'foo'
-      }
-    }
-
-    @Injectable()
-    class Test2 {
-      fooMaker = inject(Test)
-
-      async makeFoo() {
-        const fooMaker = await this.fooMaker
-        return fooMaker.makeFoo()
-      }
-    }
-
-    const value = await inject(Test2)
-    expect(value).toBeInstanceOf(Test2)
-    const result = await value.makeFoo()
-    expect(result).toBe('foo')
-  })
-
-  it('should work with factory', async () => {
-    @Injectable({ type: InjectableType.Factory })
-    class Test {
-      create() {
-        return 'foo'
-      }
-    }
-
-    const value = await inject(Test)
-    expect(value).toBe('foo')
-  })
-  it('should work with request scope', async () => {
-    @Injectable({
-      scope: InjectableScope.Instance,
-      type: InjectableType.Factory,
-    })
-    class Test {
-      create() {
-        return Date.now()
-      }
-    }
-
-    const value = await inject(Test)
-    await new Promise((resolve) => setTimeout(resolve, 10))
-    const value2 = await inject(Test)
-    expect(value).not.toBe(value2)
-  })
-
-  it('should work with injection token', async () => {
-    const token = InjectionToken.create('Test')
-
-    @Injectable({ token })
-    class Test {}
-
-    const value = await inject(token)
-    expect(value).toBeInstanceOf(Test)
-  })
-
-  it('should work with injection token and schema', async () => {
-    class TestFoo {
-      constructor(public readonly foo: string) {}
-    }
-    const token = InjectionToken.create(
-      TestFoo,
-      z.object({
-        foo: z.string(),
-      }),
-    )
-
-    @Injectable({ token, type: InjectableType.Factory })
-    class Test {
-      create(ctx: any, args: { foo: string }) {
-        return new TestFoo(args.foo)
-      }
-    }
-
-    const value = await inject(token, { foo: 'bar' })
-    const differentValue = await inject(token, { foo: 'baz' })
-    const sameValue = await inject(token, { foo: 'bar' })
-    expect(value).toBeInstanceOf(TestFoo)
-    expect(value.foo).toBe('bar')
-    expect(differentValue).toBeInstanceOf(TestFoo)
-    expect(differentValue.foo).toBe('baz')
-    expect(value).not.toBe(differentValue)
-    expect(value).toBe(sameValue)
-  })
-  it('should work with invalidation', async () => {
-    @Injectable()
-    class Test {
-      value = Date.now()
-    }
-
-    @Injectable()
-    class Test2 {
-      test = inject(Test)
-
-      async makeFoo() {
-        const test = await this.test
-        return test.value
-      }
-    }
-    const identifier = getServiceLocator().getInstanceIdentifier(
-      getInjectableToken(Test),
-      undefined,
-    )
-    const inst1 = await inject(Test2)
-    expect(inst1).toBeInstanceOf(Test2)
-    const result1 = await inst1.makeFoo()
-    const inst2 = await inject(Test2)
-    expect(inst1).toBe(inst2)
-    const result2 = await inst2.makeFoo()
-    await getServiceLocator().invalidate(identifier)
-    await new Promise((resolve) => setTimeout(resolve, 10))
-    const inst3 = await inject(Test2)
-    expect(inst1).not.toBe(inst3)
-    const result3 = await inst3.makeFoo()
-    expect(result1).not.toBe(result3)
-    expect(result2).not.toBe(result3)
-    expect(result1).toBe(result2)
-  })
-
-  it('should work with syncInject', async () => {
-    @Injectable()
-    class Test {
-      value = Date.now()
-    }
-
-    @Injectable()
-    class Test2 {
-      test = syncInject(Test)
-
-      makeFoo() {
-        return this.test.value
-      }
-    }
-    const inst1 = await inject(Test2)
-    expect(inst1).toBeInstanceOf(Test2)
-    const result1 = inst1.makeFoo()
-    const inst2 = await inject(Test2)
-    expect(inst1).toBe(inst2)
-    const result2 = await inst2.makeFoo()
-    expect(result1).toBe(result2)
-  })
-})