@navios/core 0.4.0 → 0.5.0

package/src/navios.environment.mts

@@ -0,0 +1,30 @@
+import type { AnyInjectableType, InjectionToken } from '@navios/di'
+
+import { Injectable } from '@navios/di'
+
+export interface NaviosEnvironmentOptions {
+  // Future options can be added here
+  httpTokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>
+}
+
+@Injectable()
+export class NaviosEnvironment {
+  private httpTokens = new Map<
+    InjectionToken<any, undefined>,
+    AnyInjectableType
+  >()
+
+  setupHttpEnvironment(
+    tokens: Map<InjectionToken<any, undefined>, AnyInjectableType>,
+  ) {
+    this.httpTokens = tokens
+  }
+
+  getHttpToken(token: InjectionToken<any, undefined>) {
+    return this.httpTokens.get(token)
+  }
+
+  hasHttpSetup() {
+    return this.httpTokens.size > 0
+  }
+}

package/src/navios.factory.mts

@@ -1,6 +1,10 @@
-import type { ClassTypeWithInstance } from '@navios/di'
+import type {
+  AnyInjectableType,
+  ClassTypeWithInstance,
+  InjectionToken,
+} from '@navios/di'
 
-import { inject } from '@navios/di'
+import { Container, InjectableScope, InjectableType } from '@navios/di'
 
 import type { NaviosModule } from './interfaces/index.mjs'
 import type {
@@ -8,29 +12,66 @@ import type {
   NaviosApplicationOptions,
 } from './navios.application.mjs'
 
-import { isNil, LoggerInstance } from './logger/index.mjs'
+import { ConsoleLogger, isNil, LoggerOutput } from './logger/index.mjs'
 import { NaviosApplication } from './navios.application.mjs'
+import { NaviosEnvironment } from './navios.environment.mjs'
 
 export class NaviosFactory {
   static async create(
     appModule: ClassTypeWithInstance<NaviosModule>,
-    options: NaviosApplicationOptions = {},
+    options: NaviosApplicationOptions = {
+      adapter: [],
+    },
   ) {
-    const app = await inject(NaviosApplication)
-    this.registerLoggerConfiguration(options)
-    app.setup(appModule, options)
+    const container = new Container()
+    await this.registerLoggerConfiguration(container, options)
+    const adapters = Array.isArray(options.adapter)
+      ? options.adapter
+      : [options.adapter]
+    for (const adapter of adapters) {
+      await this.registerEnvironment(container, adapter)
+    }
+    const app = await container.get(NaviosApplication)
+    await app.setup(appModule, options)
     return app
   }
 
-  private static registerLoggerConfiguration(
-    options: NaviosApplicationContextOptions,
+  private static async registerEnvironment(
+    container: Container,
+    environment: {
+      httpTokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>
+    } = {},
   ) {
-    if (!options) {
-      return
+    const naviosEnvironment = await container.get(NaviosEnvironment)
+    const { httpTokens } = environment
+    if (httpTokens) {
+      naviosEnvironment.setupHttpEnvironment(httpTokens)
     }
+  }
+
+  private static async registerLoggerConfiguration(
+    container: Container,
+    options: NaviosApplicationContextOptions,
+  ) {
     const { logger } = options
+    if (Array.isArray(logger) || isNil(logger)) {
+      const loggerInstance = (await container.get(
+        LoggerOutput,
+      )) as ConsoleLogger
+      loggerInstance?.setup({
+        logLevels: logger,
+      })
+    }
     if ((logger as boolean) !== true && !isNil(logger)) {
-      LoggerInstance.overrideLogger(logger)
+      container
+        .getServiceLocator()
+        .getManager()
+        .storeCreatedHolder(
+          LoggerOutput.toString(),
+          logger,
+          InjectableType.Class,
+          InjectableScope.Singleton,
+        )
     }
   }
 }

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

@@ -1,24 +1,32 @@
 import type { ClassTypeWithInstance } from '@navios/di'
 
-import { inject, Injectable, InjectionToken } from '@navios/di'
+import { Container, inject, Injectable, InjectionToken } from '@navios/di'
 
-import type { CanActivate } from '../interfaces/index.mjs'
-import type { ExecutionContext } from './execution-context.mjs'
+import type {
+  AbstractExecutionContext,
+  CanActivate,
+} from '../interfaces/index.mjs'
+import type {
+  ControllerMetadata,
+  HandlerMetadata,
+  ModuleMetadata,
+} from '../metadata/index.mjs'
 
 import { HttpException } from '../exceptions/index.mjs'
 
 @Injectable()
 export class GuardRunnerService {
+  protected container = inject(Container)
   async runGuards(
     allGuards: Set<
       | ClassTypeWithInstance<CanActivate>
       | InjectionToken<CanActivate, undefined>
     >,
-    executionContext: ExecutionContext,
+    executionContext: AbstractExecutionContext,
   ) {
     let canActivate = true
     for (const guard of Array.from(allGuards).reverse()) {
-      const guardInstance = await inject(
+      const guardInstance = await this.container.get(
         guard as InjectionToken<CanActivate, undefined>,
       )
       if (!guardInstance.canActivate) {
@@ -60,7 +68,9 @@ export class GuardRunnerService {
   }
 
   makeContext(
-    executionContext: ExecutionContext,
+    moduleMetadata: ModuleMetadata,
+    controllerMetadata: ControllerMetadata,
+    endpoint: HandlerMetadata,
   ): Set<
     ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
   > {
@@ -68,9 +78,9 @@ export class GuardRunnerService {
       | ClassTypeWithInstance<CanActivate>
       | InjectionToken<CanActivate, undefined>
     >()
-    const endpointGuards = executionContext.getHandler().guards
-    const controllerGuards = executionContext.getController().guards
-    const moduleGuards = executionContext.getModule().guards
+    const endpointGuards = endpoint.guards
+    const controllerGuards = controllerMetadata.guards
+    const moduleGuards = moduleMetadata.guards
     if (endpointGuards.size > 0) {
       for (const guard of endpointGuards) {
         guards.add(guard)

package/src/services/index.mts

@@ -1,4 +1,2 @@
-export * from './controller-adapter.service.mjs'
-export * from './execution-context.mjs'
 export * from './guard-runner.service.mjs'
 export * from './module-loader.service.mjs'

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

@@ -1,6 +1,6 @@
 import type { ClassTypeWithInstance } from '@navios/di'
 
-import { inject, Injectable, syncInject } from '@navios/di'
+import { Container, inject, Injectable } from '@navios/di'
 
 import type { NaviosModule } from '../interfaces/index.mjs'
 import type { ModuleMetadata } from '../metadata/index.mjs'
@@ -10,9 +10,10 @@ import { extractModuleMetadata } from '../metadata/index.mjs'
 
 @Injectable()
 export class ModuleLoaderService {
-  private logger = syncInject(Logger, {
+  private logger = inject(Logger, {
     context: ModuleLoaderService.name,
   })
+  protected container = inject(Container)
   private modulesMetadata: Map<string, ModuleMetadata> = new Map()
   private loadedModules: Map<string, any> = new Map()
   private initialized = false
@@ -43,7 +44,7 @@ export class ModuleLoaderService {
       this.traverseModules(importedModule, metadata),
     )
     await Promise.all(loadingPromises)
-    const instance = await inject(module)
+    const instance = await this.container.get(module)
     if (instance.onModuleInit) {
       await instance.onModuleInit()
     }

package/src/tokens/endpoint-adapter.token.mts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@navios/di'
+
+import type { AbstractHttpHandlerAdapterInterface } from '../interfaces/index.mjs'
+
+export const EndpointAdapterToken =
+  InjectionToken.create<AbstractHttpHandlerAdapterInterface>(
+    'EndpointAdapterToken',
+  )

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

@@ -1,9 +1,9 @@
 import { InjectionToken } from '@navios/di'
 
-import { ExecutionContext } from '../services/index.mjs'
+import type { AbstractExecutionContext } from '../interfaces/index.mjs'
 
 export const ExecutionContextInjectionToken = 'ExecutionContextInjectionToken'
 
-export const ExecutionContextToken = InjectionToken.create<ExecutionContext>(
+export const ExecutionContext = InjectionToken.create<AbstractExecutionContext>(
   ExecutionContextInjectionToken,
 )

package/src/tokens/http-adapter.token.mts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@navios/di'
+
+import type { AbstractHttpAdapterInterface } from '../interfaces/index.mjs'
+
+export const HttpAdapterToken =
+  InjectionToken.create<AbstractHttpAdapterInterface<any, any, any, any>>(
+    'HttpAdapterToken',
+  )

package/src/tokens/index.mts

@@ -1,4 +1,7 @@
-export * from './application.token.mjs'
+export * from './endpoint-adapter.token.mjs'
 export * from './execution-context.token.mjs'
+export * from './http-adapter.token.mjs'
+export * from './multipart-adapter.token.mjs'
 export * from './reply.token.mjs'
 export * from './request.token.mjs'
+export * from './stream-adapter.token.mjs'

package/src/tokens/multipart-adapter.token.mts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@navios/di'
+
+import type { AbstractHttpHandlerAdapterInterface } from '../interfaces/index.mjs'
+
+export const MultipartAdapterToken =
+  InjectionToken.create<AbstractHttpHandlerAdapterInterface>(
+    'MultipartAdapterToken',
+  )

package/src/tokens/reply.token.mts

@@ -1,7 +1,3 @@
-import type { FastifyReply } from 'fastify'
-
 import { InjectionToken } from '@navios/di'
 
-const ReplyInjectionToken = 'ReplyInjectionToken'
-
-export const Reply = InjectionToken.create<FastifyReply>(ReplyInjectionToken)
+export const Reply = InjectionToken.create<any>('ReplyToken')

package/src/tokens/request.token.mts

@@ -1,9 +1,3 @@
-import type { FastifyRequest } from 'fastify'
-
 import { InjectionToken } from '@navios/di'
 
-const RequestInjectionToken = 'RequestInjectionToken'
-
-export const Request = InjectionToken.create<FastifyRequest>(
-  RequestInjectionToken,
-)
+export const Request = InjectionToken.create<any>('RequestToken')

package/src/tokens/stream-adapter.token.mts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@navios/di'
+
+import type { AbstractHttpHandlerAdapterInterface } from '../interfaces/index.mjs'
+
+export const StreamAdapterToken =
+  InjectionToken.create<AbstractHttpHandlerAdapterInterface>(
+    'StreamAdapterToken',
+  )

package/docs/recipes/prisma.md

@@ -1,60 +0,0 @@
-# Prisma ORM
-
-Prisma ORM is a modern database toolkit that simplifies database access and management. It provides a type-safe query builder, migrations, and an intuitive API for working with databases.
-
-## Installation
-
-Follow the steps from the [Prisma documentation](https://www.prisma.io/docs/getting-started/quickstart-typescript) to install Prisma in your project.
-
-## Integration
-
-The simplest way to integrate Prisma with your project is to create a factory:
-
-```typescript
-import { Injectable, InjectableType, InjectionToken } from '@navios/core'
-
-import { PrismaClient } from '@prisma/client'
-
-export const PrismaService = InjectionToken.create(PrismaClient)
-
-@Injectable({
-  token: PrismaService,
-  type: InjectableType.Factory,
-})
-export class PrismaServiceFactory {
-  async create() {
-    const client = new PrismaClient()
-    await client.$connect()
-    return client
-  }
-}
-```
-
-## Usage
-
-You can use the Prisma Service in your application by injecting it into your classes. Here's an example of how to use it in a service:
-
-```typescript
-import { Injectable, syncInject } from '@navios/core'
-
-import { PrismaService } from './prisma.service.mjs'
-
-@Injectable()
-export class UserService {
-  private readonly prisma = syncInject(PrismaService)
-
-  async getUser(id: string) {
-    return this.prisma.user.findUnique({
-      where: { id },
-    })
-  }
-
-  async createUser(data: { name: string; email: string }) {
-    return this.prisma.user.create({
-      data,
-    })
-  }
-}
-```
-
-That's it! You can now use Prisma in your application to interact with your database. You can find more information about Prisma and its features in the [Prisma documentation](https://www.prisma.io/docs/).

package/e2e/endpoints/get.spec.mts

@@ -1,97 +0,0 @@
-import { builder } from '@navios/builder'
-
-import supertest from 'supertest'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { z } from 'zod/v4'
-
-import type { EndpointParams } from '../../src/index.mjs'
-
-import {
-  Controller,
-  Endpoint,
-  Module,
-  NaviosApplication,
-  NaviosFactory,
-} from '../../src/index.mjs'
-
-describe('GET variants', () => {
-  let server: NaviosApplication
-
-  const simple = builder().declareEndpoint({
-    url: '/simple',
-    method: 'GET',
-    responseSchema: z.object({
-      message: z.string(),
-    }),
-  })
-  const withUrlParams = builder().declareEndpoint({
-    url: '/with-url-params/$id',
-    method: 'GET',
-    responseSchema: z.object({
-      id: z.string(),
-    }),
-  })
-  const withQueryParams = builder().declareEndpoint({
-    url: '/with-query-params',
-    method: 'GET',
-    responseSchema: z.object({
-      name: z.string(),
-    }),
-    querySchema: z.object({
-      name: z.string(),
-    }),
-  })
-
-  @Controller()
-  class SomethingController {
-    @Endpoint(simple)
-    async getSomething(req: EndpointParams<typeof simple>) {
-      return { message: 'Hello, world!' }
-    }
-
-    @Endpoint(withUrlParams)
-    async getWithUrlParams(req: EndpointParams<typeof withUrlParams>) {
-      return { id: req.urlParams.id as string }
-    }
-
-    @Endpoint(withQueryParams)
-    async getWithQueryParams(req: EndpointParams<typeof withQueryParams>) {
-      return { name: req.params.name as string }
-    }
-  }
-
-  @Module({
-    controllers: [SomethingController],
-  })
-  class SomethingModule {}
-
-  beforeAll(async () => {
-    server = await NaviosFactory.create(SomethingModule)
-    await server.init()
-  })
-
-  afterAll(async () => {
-    await server.close()
-  })
-
-  it('should return 200', async () => {
-    const response = await supertest(server.getServer().server).get('/simple')
-    expect(response.status).toBe(200)
-    expect(response.body.message).toBe('Hello, world!')
-  })
-
-  it('should return 200 with url params', async () => {
-    const response = await supertest(server.getServer().server).get(
-      '/with-url-params/123',
-    )
-    expect(response.status).toBe(200)
-    expect(response.body.id).toBe('123')
-  })
-
-  it('should return 200 with query params', async () => {
-    const response = await supertest(server.getServer().server).get(
-      '/with-query-params?name=John',
-    )
-    expect(response.status).toBe(200)
-  })
-})

package/e2e/endpoints/post.spec.mts

@@ -1,113 +0,0 @@
-import { builder } from '@navios/builder'
-
-import supertest from 'supertest'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { z } from 'zod/v4'
-
-import type { EndpointParams } from '../../src/index.mjs'
-
-import {
-  Controller,
-  Endpoint,
-  Module,
-  NaviosApplication,
-  NaviosFactory,
-} from '../../src/index.mjs'
-
-describe('POST variants', () => {
-  let server: NaviosApplication
-
-  const simple = builder().declareEndpoint({
-    url: '/simple',
-    method: 'POST',
-    responseSchema: z.object({
-      message: z.string(),
-    }),
-  })
-  const withUrlParams = builder().declareEndpoint({
-    url: '/with-url-params/$id',
-    method: 'POST',
-    responseSchema: z.object({
-      id: z.string(),
-    }),
-  })
-  const withRequestAndQueryParams = builder().declareEndpoint({
-    url: '/with-request-and-query-params',
-    method: 'POST',
-    requestSchema: z.object({
-      foo: z.string(),
-    }),
-    responseSchema: z.object({
-      foo: z.string(),
-      bar: z.string(),
-    }),
-    querySchema: z.object({
-      bar: z.string(),
-    }),
-  })
-
-  @Controller()
-  class SomethingController {
-    @Endpoint(simple)
-    async getSomething(req: EndpointParams<typeof simple>) {
-      return { message: 'Hello, world!' }
-    }
-
-    @Endpoint(withUrlParams)
-    async getWithUrlParams(req: EndpointParams<typeof withUrlParams>) {
-      return { id: req.urlParams.id as string }
-    }
-
-    @Endpoint(withRequestAndQueryParams)
-    async getWithQueryParams(
-      req: EndpointParams<typeof withRequestAndQueryParams>,
-    ) {
-      return {
-        foo: req.data.foo as string,
-        bar: req.params.bar as string,
-      }
-    }
-  }
-
-  @Module({
-    controllers: [SomethingController],
-  })
-  class SomethingModule {}
-
-  beforeAll(async () => {
-    server = await NaviosFactory.create(SomethingModule)
-    await server.init()
-  })
-
-  afterAll(async () => {
-    await server.close()
-  })
-
-  it('should return 200', async () => {
-    const response = await supertest(server.getServer().server).post('/simple')
-    expect(response.status).toBe(200)
-    expect(response.body.message).toBe('Hello, world!')
-  })
-
-  it('should return 200 with url params', async () => {
-    const response = await supertest(server.getServer().server).post(
-      '/with-url-params/123',
-    )
-    expect(response.status).toBe(200)
-    expect(response.body.id).toBe('123')
-  })
-
-  it('should return 200 with query params', async () => {
-    const response = await supertest(server.getServer().server)
-      .post('/with-request-and-query-params')
-      .send({
-        foo: 'John',
-      })
-      .query({
-        bar: 'Doe',
-      })
-    expect(response.status).toBe(200)
-    expect(response.body.foo).toBe('John')
-    expect(response.body.bar).toBe('Doe')
-  })
-})

package/examples/simple-test/api/index.mts

@@ -1,64 +0,0 @@
-import { builder } from '@navios/builder'
-
-import { z } from 'zod/v4'
-
-export const authApi = builder({
-  useDiscriminatorResponse: true,
-})
-
-export const userEndpoint = authApi.declareEndpoint({
-  method: 'GET',
-  url: '/user',
-  responseSchema: z.object({
-    id: z.string(),
-    name: z.string(),
-    email: z.string(),
-  }),
-})
-
-export const patchUserEndpoint = authApi.declareEndpoint({
-  method: 'PATCH',
-  url: '/user',
-  requestSchema: z.object({
-    name: z.string(),
-    email: z.string(),
-  }),
-  responseSchema: z.object({
-    id: z.string(),
-    name: z.string(),
-    email: z.string(),
-  }),
-})
-
-export const discriminatorEndpoint = authApi.declareEndpoint({
-  method: 'GET',
-  url: '/discriminator',
-  responseSchema: z.discriminatedUnion('success', [
-    z.object({
-      success: z.literal(true),
-      data: z.object({
-        id: z.string(),
-        name: z.string(),
-
-        email: z.string(),
-      }),
-    }),
-    z.object({
-      success: z.literal(false),
-      error: z.object({
-        code: z.string(),
-        message: z.string(),
-      }),
-    }),
-  ]),
-})
-
-export const multipartEndpoint = authApi.declareMultipart({
-  method: 'POST',
-  url: '/multipart',
-  requestSchema: z.object({
-    files: z.array(z.instanceof(File)),
-    something: z.string(),
-  }),
-  responseSchema: z.object({}),
-})

package/examples/simple-test/config/config.service.mts

@@ -1,14 +0,0 @@
-import type { Path, PathValue } from '../../../src/index.mjs'
-
-import { provideConfig } from '../../../src/index.mjs'
-import { configureConfig } from './configuration.mjs'
-
-export type ConfigType = ReturnType<typeof configureConfig>
-export type ConfigTypePaths = Path<ConfigType>
-export type ConfigMap = {
-  [K in ConfigTypePaths]: PathValue<ConfigType, K>
-}
-
-export const ConfigService = provideConfig<ConfigMap>({
-  load: configureConfig,
-})

package/examples/simple-test/config/configuration.mts

@@ -1,7 +0,0 @@
-import { envInt } from '../../../src/index.mjs'
-
-export function configureConfig() {
-  return {
-    port: envInt('PORT', 4250),
-  }
-}

package/examples/simple-test/index.mts

@@ -1,16 +0,0 @@
-import { inject, NaviosFactory } from '../../src/index.mjs'
-import { ConfigService } from './config/config.service.mjs'
-import { AppModule } from './src/app.module.mjs'
-
-export async function boot() {
-  const app = await NaviosFactory.create(AppModule)
-  app.enableCors({
-    methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
-  })
-  app.enableMultipart({})
-  await app.init()
-  const configService = await inject(ConfigService)
-  const port = configService.getOrThrow('port')
-  await app.listen({ port: port, host: '0.0.0.0' })
-}
-await boot()