@navios/core 0.3.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/tsconfig.json

@@ -4,8 +4,13 @@
     "module": "Node18",
     "outDir": "dist"
   },
-  "include": ["src/**/*"],
   "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    },
     {
       "path": "../builder"
     },

package/tsconfig.lib.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.spec.mts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*.spec.mts", "e2e/**/*.mts", "vitest.config.mts"],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/tsup.config.mts

@@ -5,6 +5,7 @@ export default defineConfig({
   outDir: 'lib',
   format: ['esm', 'cjs'],
   clean: true,
+  tsconfig: 'tsconfig.lib.json',
   treeshake: 'smallest',
   sourcemap: true,
   platform: 'node',

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/examples/simple-test/api/index.mts

@@ -1,64 +0,0 @@
-import { builder } from '@navios/builder'
-
-import { z } from 'zod'
-
-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()

package/examples/simple-test/src/acl/acl-modern.guard.mts

@@ -1,15 +0,0 @@
-import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
-
-import { Injectable, Logger, syncInject } from '../../../../src/index.mjs'
-
-@Injectable()
-export class AclModernGuard implements CanActivate {
-  logger = syncInject(Logger, {
-    context: AclModernGuard.name,
-  })
-
-  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
-    this.logger.log('ACL Modern Guard activated')
-    return true
-  }
-}

package/examples/simple-test/src/acl/acl.guard.mts

@@ -1,14 +0,0 @@
-import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
-
-import { Injectable, Logger, syncInject } from '../../../../src/index.mjs'
-
-@Injectable()
-export class AclGuard implements CanActivate {
-  logger = syncInject(Logger, {
-    context: AclGuard.name,
-  })
-  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
-    this.logger.log('ACL Guard activated')
-    return true
-  }
-}

package/examples/simple-test/src/acl/app.guard.mts

@@ -1,27 +0,0 @@
-import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
-
-import {
-  AttributeFactory,
-  Injectable,
-  Logger,
-  syncInject,
-} from '../../../../src/index.mjs'
-import { Public } from './public.attribute.mjs'
-
-@Injectable()
-export class AppGuard implements CanActivate {
-  logger = syncInject(Logger, {
-    context: AppGuard.name,
-  })
-
-  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
-    const isPublic = AttributeFactory.getLast(Public, [
-      executionContext.getModule(),
-      executionContext.getController(),
-      executionContext.getHandler(),
-    ])
-    this.logger.log('App Guard activated')
-    this.logger.log('isPublic', isPublic)
-    return true
-  }
-}

package/examples/simple-test/src/acl/one-more.guard.mts

@@ -1,15 +0,0 @@
-import type { CanActivate, ExecutionContext } from '../../../../src/index.mjs'
-
-import { Injectable, Logger, syncInject } from '../../../../src/index.mjs'
-
-@Injectable()
-export class OneMoreGuard implements CanActivate {
-  logger = syncInject(Logger, {
-    context: OneMoreGuard.name,
-  })
-
-  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean {
-    this.logger.log('One More Guard activated')
-    return true
-  }
-}

package/examples/simple-test/src/acl/public.attribute.mts

@@ -1,21 +0,0 @@
-import { z } from 'zod'
-
-import { AttributeFactory } from '../../../../src/index.mjs'
-
-export const PublicSymbol = Symbol.for('Public')
-
-export const Public = AttributeFactory.createAttribute(PublicSymbol)
-export const RolesSymbol = Symbol.for('Roles')
-
-export const RolesSchema = z.object({
-  roles: z.array(
-    z.union([
-      z.literal('VIEWER'),
-      z.literal('USER'),
-      z.literal('ADMIN'),
-      z.literal('OWNER'),
-    ]),
-  ),
-})
-
-export const Roles = AttributeFactory.createAttribute(RolesSymbol, RolesSchema)

package/examples/simple-test/src/app.module.mts

@@ -1,9 +0,0 @@
-import { Module } from '../../../src/index.mjs'
-import { AppGuard } from './acl/app.guard.mjs'
-import { UserModule } from './user/user.module.mjs'
-
-@Module({
-  imports: [UserModule],
-  guards: [AppGuard],
-})
-export class AppModule {}