@navios/core 0.6.0 → 0.7.0

package/src/navios.factory.d.mts

@@ -0,0 +1,68 @@
+import type { ClassTypeWithInstance } from '@navios/di';
+import type { NaviosModule } from './interfaces/index.mjs';
+import type { NaviosApplicationOptions } from './navios.application.mjs';
+import { NaviosApplication } from './navios.application.mjs';
+/**
+ * Factory class for creating and configuring Navios applications.
+ *
+ * This is the main entry point for bootstrapping a Navios application.
+ * It handles dependency injection container setup, adapter registration,
+ * and logger configuration.
+ *
+ * @example
+ * ```typescript
+ * import { NaviosFactory } from '@navios/core'
+ * import { defineFastifyEnvironment } from '@navios/adapter-fastify'
+ *
+ * const app = await NaviosFactory.create(AppModule, {
+ *   adapter: defineFastifyEnvironment(),
+ *   logger: ['log', 'error', 'warn'],
+ * })
+ *
+ * await app.init()
+ * await app.listen({ port: 3000 })
+ * ```
+ */
+export declare class NaviosFactory {
+    /**
+     * Creates a new Navios application instance.
+     *
+     * This method sets up the dependency injection container, registers the HTTP adapter,
+     * configures logging, and initializes the application with the provided module.
+     *
+     * @param appModule - The root application module class decorated with @Module()
+     * @param options - Configuration options for the application
+     * @param options.adapter - HTTP adapter environment (required for HTTP server functionality)
+     * @param options.logger - Logger configuration. Can be:
+     *   - A LoggerService instance for custom logging
+     *   - An array of LogLevel strings to enable specific log levels
+     *   - `false` to disable logging
+     * @param options.container - Optional custom dependency injection container (useful for testing)
+     * @returns A configured NaviosApplication instance ready to be initialized
+     *
+     * @example
+     * ```typescript
+     * // Basic setup with Fastify adapter
+     * const app = await NaviosFactory.create(AppModule, {
+     *   adapter: defineFastifyEnvironment(),
+     * })
+     *
+     * // With custom logger configuration
+     * const app = await NaviosFactory.create(AppModule, {
+     *   adapter: defineFastifyEnvironment(),
+     *   logger: ['error', 'warn', 'log'],
+     * })
+     *
+     * // With custom container for testing
+     * const container = new Container()
+     * const app = await NaviosFactory.create(AppModule, {
+     *   adapter: defineFastifyEnvironment(),
+     *   container,
+     * })
+     * ```
+     */
+    static create(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<NaviosApplication>;
+    private static registerEnvironment;
+    private static registerLoggerConfiguration;
+}
+//# sourceMappingURL=navios.factory.d.mts.map

package/src/navios.factory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navios.factory.d.mts","sourceRoot":"","sources":["navios.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,qBAAqB,EAEtB,MAAM,YAAY,CAAA;AAInB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,KAAK,EAEV,wBAAwB,EACzB,MAAM,0BAA0B,CAAA;AAGjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAG5D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,aAAa;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;WACU,MAAM,CACjB,SAAS,EAAE,qBAAqB,CAAC,YAAY,CAAC,EAC9C,OAAO,GAAE,wBAER;mBAekB,mBAAmB;mBAanB,2BAA2B;CAyBjD"}

package/src/navios.factory.mts

@@ -16,14 +16,72 @@ import { ConsoleLogger, isNil, LoggerOutput } from './logger/index.mjs'
 import { NaviosApplication } from './navios.application.mjs'
 import { NaviosEnvironment } from './navios.environment.mjs'
 
+/**
+ * Factory class for creating and configuring Navios applications.
+ * 
+ * This is the main entry point for bootstrapping a Navios application.
+ * It handles dependency injection container setup, adapter registration,
+ * and logger configuration.
+ * 
+ * @example
+ * ```typescript
+ * import { NaviosFactory } from '@navios/core'
+ * import { defineFastifyEnvironment } from '@navios/adapter-fastify'
+ * 
+ * const app = await NaviosFactory.create(AppModule, {
+ *   adapter: defineFastifyEnvironment(),
+ *   logger: ['log', 'error', 'warn'],
+ * })
+ * 
+ * await app.init()
+ * await app.listen({ port: 3000 })
+ * ```
+ */
 export class NaviosFactory {
+  /**
+   * Creates a new Navios application instance.
+   * 
+   * This method sets up the dependency injection container, registers the HTTP adapter,
+   * configures logging, and initializes the application with the provided module.
+   * 
+   * @param appModule - The root application module class decorated with @Module()
+   * @param options - Configuration options for the application
+   * @param options.adapter - HTTP adapter environment (required for HTTP server functionality)
+   * @param options.logger - Logger configuration. Can be:
+   *   - A LoggerService instance for custom logging
+   *   - An array of LogLevel strings to enable specific log levels
+   *   - `false` to disable logging
+   * @param options.container - Optional custom dependency injection container (useful for testing)
+   * @returns A configured NaviosApplication instance ready to be initialized
+   * 
+   * @example
+   * ```typescript
+   * // Basic setup with Fastify adapter
+   * const app = await NaviosFactory.create(AppModule, {
+   *   adapter: defineFastifyEnvironment(),
+   * })
+   * 
+   * // With custom logger configuration
+   * const app = await NaviosFactory.create(AppModule, {
+   *   adapter: defineFastifyEnvironment(),
+   *   logger: ['error', 'warn', 'log'],
+   * })
+   * 
+   * // With custom container for testing
+   * const container = new Container()
+   * const app = await NaviosFactory.create(AppModule, {
+   *   adapter: defineFastifyEnvironment(),
+   *   container,
+   * })
+   * ```
+   */
   static async create(
     appModule: ClassTypeWithInstance<NaviosModule>,
     options: NaviosApplicationOptions = {
       adapter: [],
     },
   ) {
-    const container = new Container()
+    const container = options.container ?? new Container()
     await this.registerLoggerConfiguration(container, options)
     const adapters = Array.isArray(options.adapter)
       ? options.adapter

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

@@ -0,0 +1,10 @@
+import type { ClassTypeWithInstance, ScopedContainer } from '@navios/di';
+import { InjectionToken } from '@navios/di';
+import type { AbstractExecutionContext, CanActivate } from '../interfaces/index.mjs';
+import type { ControllerMetadata, HandlerMetadata, ModuleMetadata } from '../metadata/index.mjs';
+export declare class GuardRunnerService {
+    private readonly logger;
+    runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: AbstractExecutionContext, context: ScopedContainer): Promise<boolean>;
+    makeContext(moduleMetadata: ModuleMetadata, controllerMetadata: ControllerMetadata, endpoint: HandlerMetadata): Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+}
+//# sourceMappingURL=guard-runner.service.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guard-runner.service.d.mts","sourceRoot":"","sources":["guard-runner.service.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAExE,OAAO,EAAsB,cAAc,EAAE,MAAM,YAAY,CAAA;AAE/D,OAAO,KAAK,EACV,wBAAwB,EACxB,WAAW,EACZ,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EACV,kBAAkB,EAClB,eAAe,EACf,cAAc,EACf,MAAM,uBAAuB,CAAA;AAK9B,qBACa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAErB;IACI,SAAS,CACb,SAAS,EAAE,GAAG,CACV,qBAAqB,CAAC,WAAW,CAAC,GAClC,cAAc,CAAC,WAAW,EAAE,SAAS,CAAC,CACzC,EACD,gBAAgB,EAAE,wBAAwB,EAC1C,OAAO,EAAE,eAAe;IA0C1B,WAAW,CACT,cAAc,EAAE,cAAc,EAC9B,kBAAkB,EAAE,kBAAkB,EACtC,QAAQ,EAAE,eAAe,GACxB,GAAG,CACJ,qBAAqB,CAAC,WAAW,CAAC,GAAG,cAAc,CAAC,WAAW,EAAE,SAAS,CAAC,CAC5E;CAyBF"}

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

@@ -1,6 +1,6 @@
-import type { ClassTypeWithInstance } from '@navios/di'
+import type { ClassTypeWithInstance, ScopedContainer } from '@navios/di'
 
-import { Container, inject, Injectable, InjectionToken } from '@navios/di'
+import { inject, Injectable, InjectionToken } from '@navios/di'
 
 import type {
   AbstractExecutionContext,
@@ -13,20 +13,24 @@ import type {
 } from '../metadata/index.mjs'
 
 import { HttpException } from '../exceptions/index.mjs'
+import { Logger } from '../logger/index.mjs'
 
 @Injectable()
 export class GuardRunnerService {
-  protected container = inject(Container)
+  private readonly logger = inject(Logger, {
+    context: GuardRunnerService.name,
+  })
   async runGuards(
     allGuards: Set<
       | ClassTypeWithInstance<CanActivate>
       | InjectionToken<CanActivate, undefined>
     >,
     executionContext: AbstractExecutionContext,
+    context: ScopedContainer,
   ) {
     let canActivate = true
     for (const guard of Array.from(allGuards).reverse()) {
-      const guardInstance = await this.container.get(
+      const guardInstance = await context.get(
         guard as InjectionToken<CanActivate, undefined>,
       )
       if (!guardInstance.canActivate) {
@@ -47,13 +51,10 @@ export class GuardRunnerService {
             .send(error.response)
           return false
         } else {
-          executionContext
-            .getReply()
-            .status(500)
-            .send({
-              message: 'Internal server error',
-              error: (error as Error).message,
-            })
+          this.logger.error('Error running guard', error)
+          executionContext.getReply().status(500).send({
+            message: 'Internal server error',
+          })
           return false
         }
       }

package/src/services/index.d.mts

@@ -0,0 +1,3 @@
+export * from './guard-runner.service.mjs';
+export * from './module-loader.service.mjs';
+//# sourceMappingURL=index.d.mts.map

package/src/services/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,6BAA6B,CAAA"}

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

@@ -0,0 +1,17 @@
+import type { ClassTypeWithInstance } from '@navios/di';
+import { Container } from '@navios/di';
+import type { NaviosModule } from '../interfaces/index.mjs';
+import type { ModuleMetadata } from '../metadata/index.mjs';
+export declare class ModuleLoaderService {
+    private logger;
+    protected container: Container;
+    private modulesMetadata;
+    private loadedModules;
+    private initialized;
+    loadModules(appModule: ClassTypeWithInstance<NaviosModule>): Promise<void>;
+    private traverseModules;
+    private mergeMetadata;
+    getAllModules(): Map<string, ModuleMetadata>;
+    dispose(): void;
+}
+//# sourceMappingURL=module-loader.service.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module-loader.service.d.mts","sourceRoot":"","sources":["module-loader.service.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAEvD,OAAO,EAAE,SAAS,EAAsB,MAAM,YAAY,CAAA;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAK3D,qBACa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAEZ;IACF,SAAS,CAAC,SAAS,YAAoB;IACvC,OAAO,CAAC,eAAe,CAAyC;IAChE,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,WAAW,CAAQ;IAErB,WAAW,CAAC,SAAS,EAAE,qBAAqB,CAAC,YAAY,CAAC;YAQlD,eAAe;IA+B7B,OAAO,CAAC,aAAa;IAkBrB,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC;IAG5C,OAAO;CAKR"}

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

@@ -38,18 +38,23 @@ export class ModuleLoaderService {
     if (this.modulesMetadata.has(moduleName)) {
       return
     }
-    this.modulesMetadata.set(moduleName, metadata)
-    const imports = metadata.imports ?? new Set()
-    const loadingPromises = Array.from(imports).map(async (importedModule) =>
-      this.traverseModules(importedModule, metadata),
-    )
-    await Promise.all(loadingPromises)
-    const instance = await this.container.get(module)
-    if (instance.onModuleInit) {
-      await instance.onModuleInit()
+    try {
+      this.modulesMetadata.set(moduleName, metadata)
+      const imports = metadata.imports ?? new Set()
+      const loadingPromises = Array.from(imports).map(async (importedModule) =>
+        this.traverseModules(importedModule, metadata),
+      )
+      await Promise.all(loadingPromises)
+      const instance = await this.container.get(module)
+      if (instance.onModuleInit) {
+        await instance.onModuleInit()
+      }
+      this.logger.debug(`Module ${moduleName} loaded`)
+      this.loadedModules.set(moduleName, instance)
+    } catch (error) {
+      this.logger.error(`Error loading module ${moduleName}`, error)
+      throw error
     }
-    this.logger.debug(`Module ${moduleName} loaded`)
-    this.loadedModules.set(moduleName, instance)
   }
 
   private mergeMetadata(

package/src/stores/index.d.mts

@@ -0,0 +1,2 @@
+export * from './request-id.store.mjs';
+//# sourceMappingURL=index.d.mts.map

package/src/stores/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA"}

package/src/stores/index.mts

@@ -0,0 +1 @@
+export * from './request-id.store.mjs'

package/src/stores/request-id.store.d.mts

@@ -0,0 +1,37 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * AsyncLocalStorage store for the current request ID.
+ *
+ * This allows logging and other services to access the current request ID
+ * without explicitly passing it through the call stack.
+ *
+ * @example
+ * ```typescript
+ * import { requestIdStore, runWithRequestId, getRequestId } from '@navios/core'
+ *
+ * // Run code with a request ID in context
+ * runWithRequestId('req-123', () => {
+ *   // Inside this callback, getRequestId() returns 'req-123'
+ *   logger.log('Processing request') // Will include request ID if logger is configured
+ * })
+ *
+ * // Get current request ID (returns undefined if not in a request context)
+ * const currentId = getRequestId()
+ * ```
+ */
+export declare const requestIdStore: AsyncLocalStorage<string>;
+/**
+ * Runs a function with a request ID in the async local storage context.
+ *
+ * @param requestId - The request ID to set for this context
+ * @param fn - The function to run within this context
+ * @returns The return value of the function
+ */
+export declare function runWithRequestId<R>(requestId: string, fn: () => R): R;
+/**
+ * Gets the current request ID from the async local storage context.
+ *
+ * @returns The current request ID, or undefined if not in a request context
+ */
+export declare function getRequestId(): string | undefined;
+//# sourceMappingURL=request-id.store.d.mts.map

package/src/stores/request-id.store.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-id.store.d.mts","sourceRoot":"","sources":["request-id.store.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,2BAAkC,CAAA;AAE7D;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAErE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,MAAM,GAAG,SAAS,CAEjD"}

package/src/stores/request-id.store.mts

@@ -0,0 +1,43 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+/**
+ * AsyncLocalStorage store for the current request ID.
+ *
+ * This allows logging and other services to access the current request ID
+ * without explicitly passing it through the call stack.
+ *
+ * @example
+ * ```typescript
+ * import { requestIdStore, runWithRequestId, getRequestId } from '@navios/core'
+ *
+ * // Run code with a request ID in context
+ * runWithRequestId('req-123', () => {
+ *   // Inside this callback, getRequestId() returns 'req-123'
+ *   logger.log('Processing request') // Will include request ID if logger is configured
+ * })
+ *
+ * // Get current request ID (returns undefined if not in a request context)
+ * const currentId = getRequestId()
+ * ```
+ */
+export const requestIdStore = new AsyncLocalStorage<string>()
+
+/**
+ * Runs a function with a request ID in the async local storage context.
+ *
+ * @param requestId - The request ID to set for this context
+ * @param fn - The function to run within this context
+ * @returns The return value of the function
+ */
+export function runWithRequestId<R>(requestId: string, fn: () => R): R {
+  return requestIdStore.run(requestId, fn)
+}
+
+/**
+ * Gets the current request ID from the async local storage context.
+ *
+ * @returns The current request ID, or undefined if not in a request context
+ */
+export function getRequestId(): string | undefined {
+  return requestIdStore.getStore()
+}

package/src/testing/index.mts

@@ -0,0 +1,2 @@
+export * from '@navios/di/testing'
+export * from './testing-module.mjs'

package/src/testing/testing-module.mts

@@ -0,0 +1,231 @@
+import type { ClassType, ClassTypeWithInstance, InjectionToken } from '@navios/di'
+import type { NaviosModule } from '../interfaces/index.mjs'
+import type { NaviosApplicationOptions } from '../navios.application.mjs'
+
+import { TestContainer } from '@navios/di/testing'
+
+import { NaviosApplication } from '../navios.application.mjs'
+import { NaviosFactory } from '../navios.factory.mjs'
+
+/**
+ * Configuration for overriding a provider in the testing module.
+ * 
+ * @typeParam T - The type of the provider being overridden
+ */
+export interface TestingModuleOverride<T = any> {
+  /**
+   * The injection token or class to override.
+   */
+  token: ClassType | InjectionToken<T, any>
+  /**
+   * Value to use instead of the original provider.
+   */
+  useValue?: T
+  /**
+   * Class to use instead of the original provider.
+   */
+  useClass?: ClassType
+}
+
+/**
+ * Options for creating a testing module.
+ * 
+ * Extends NaviosApplicationOptions but excludes the container option,
+ * as TestingModule manages its own TestContainer.
+ */
+export interface TestingModuleOptions
+  extends Omit<NaviosApplicationOptions, 'container'> {
+  /**
+   * Initial provider overrides to apply when creating the testing module.
+   * 
+   * You can also use `overrideProvider()` method for a fluent API.
+   */
+  overrides?: TestingModuleOverride[]
+}
+
+/**
+ * A testing-optimized wrapper around NaviosApplication.
+ * Provides utilities for setting up test environments with mock dependencies.
+ */
+export class TestingModule {
+  private app: NaviosApplication | null = null
+
+  constructor(
+    private readonly appModule: ClassTypeWithInstance<NaviosModule>,
+    private readonly container: TestContainer,
+    private readonly options: TestingModuleOptions,
+  ) {}
+
+  /**
+   * Compiles the testing module and returns the NaviosApplication.
+   * Call this after setting up all overrides.
+   */
+  async compile(): Promise<NaviosApplication> {
+    this.app = await NaviosFactory.create(this.appModule, {
+      ...this.options,
+      container: this.container,
+    })
+    return this.app
+  }
+
+  /**
+   * Initializes the application (loads modules, sets up HTTP if configured).
+   * This is equivalent to calling app.init() on the compiled application.
+   */
+  async init(): Promise<NaviosApplication> {
+    if (!this.app) {
+      await this.compile()
+    }
+    await this.app!.init()
+    return this.app!
+  }
+
+  /**
+   * Gets the underlying TestContainer for direct manipulation.
+   */
+  getContainer(): TestContainer {
+    return this.container
+  }
+
+  /**
+   * Gets the compiled application. Throws if not yet compiled.
+   */
+  getApplication(): NaviosApplication {
+    if (!this.app) {
+      throw new Error(
+        'TestingModule not compiled. Call compile() or init() first.',
+      )
+    }
+    return this.app
+  }
+
+  /**
+   * Override a provider with a mock value.
+   */
+  overrideProvider<T>(token: ClassType | InjectionToken<T, any>): {
+    useValue: (value: T) => TestingModule
+    useClass: (target: ClassType) => TestingModule
+  } {
+    return {
+      useValue: (value: T) => {
+        this.container.bind(token as any).toValue(value)
+        return this
+      },
+      useClass: (target: ClassType) => {
+        this.container.bind(token as any).toClass(target)
+        return this
+      },
+    }
+  }
+
+  /**
+   * Gets an instance from the container.
+   */
+  async get<T>(token: ClassTypeWithInstance<T> | InjectionToken<T, any>): Promise<T> {
+    return this.container.get(token as any)
+  }
+
+  /**
+   * Disposes the testing module and cleans up resources.
+   */
+  async close(): Promise<void> {
+    if (this.app) {
+      await this.app.close()
+    }
+    await this.container.dispose()
+  }
+}
+
+/**
+ * Fluent builder interface for TestingModule.
+ * 
+ * Provides a chainable API for configuring and using a testing module.
+ */
+export interface TestingModuleBuilder {
+  /**
+   * Override a provider with a mock value or class.
+   * 
+   * @param token - The injection token or class to override
+   * @returns An object with `useValue` and `useClass` methods for chaining
+   * 
+   * @example
+   * ```typescript
+   * const testingModule = await createTestingModule(AppModule)
+   *   .overrideProvider(DatabaseService)
+   *   .useValue(mockDatabaseService)
+   *   .compile()
+   * ```
+   */
+  overrideProvider<T>(token: ClassType | InjectionToken<T, any>): {
+    useValue: (value: T) => TestingModuleBuilder
+    useClass: (target: ClassType) => TestingModuleBuilder
+  }
+
+  /**
+   * Compiles the testing module and returns the NaviosApplication.
+   * 
+   * This creates the application instance but does not initialize it.
+   * Call `init()` if you need the application to be fully initialized.
+   */
+  compile(): Promise<NaviosApplication>
+
+  /**
+   * Initializes the application (loads modules, sets up HTTP if configured).
+   * 
+   * This is equivalent to calling `compile()` followed by `app.init()`.
+   */
+  init(): Promise<NaviosApplication>
+
+  /**
+   * Gets the underlying TestContainer for direct manipulation.
+   */
+  getContainer(): TestContainer
+
+  /**
+   * Gets an instance from the container.
+   * 
+   * @typeParam T - The type of the instance to retrieve
+   * @param token - The injection token or class
+   * @returns The resolved instance
+   */
+  get<T>(token: ClassTypeWithInstance<T> | InjectionToken<T, any>): Promise<T>
+
+  /**
+   * Disposes the testing module and cleans up resources.
+   */
+  close(): Promise<void>
+}
+
+/**
+ * Creates a testing module for the given app module.
+ * This is the main entry point for setting up tests.
+ *
+ * @example
+ * ```typescript
+ * const testingModule = await createTestingModule(AppModule, {
+ *   adapter: [],
+ * })
+ *   .overrideProvider(DatabaseService)
+ *   .useValue(mockDatabaseService)
+ *   .compile()
+ * ```
+ */
+export function createTestingModule(
+  appModule: ClassTypeWithInstance<NaviosModule>,
+  options: TestingModuleOptions = { adapter: [] },
+): TestingModule {
+  const container = new TestContainer()
+
+  // Apply initial overrides if provided
+  if (options.overrides) {
+    for (const override of options.overrides) {
+      if (override.useValue !== undefined) {
+        container.bind(override.token as any).toValue(override.useValue)
+      } else if (override.useClass) {
+        container.bind(override.token as any).toClass(override.useClass)
+      }
+    }
+  }
+
+  return new TestingModule(appModule, container, options)
+}

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

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@navios/di';
+import type { AbstractHttpHandlerAdapterInterface } from '../interfaces/index.mjs';
+export declare const EndpointAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+//# sourceMappingURL=endpoint-adapter.token.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-adapter.token.d.mts","sourceRoot":"","sources":["endpoint-adapter.token.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,yBAAyB,CAAA;AAElF,eAAO,MAAM,oBAAoB,uEAG9B,CAAA"}

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

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@navios/di';
+import type { AbstractExecutionContext } from '../interfaces/index.mjs';
+export declare const ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+export declare const ExecutionContext: InjectionToken<AbstractExecutionContext, undefined, false>;
+//# sourceMappingURL=execution-context.token.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"execution-context.token.d.mts","sourceRoot":"","sources":["execution-context.token.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAEvE,eAAO,MAAM,8BAA8B,mCAAmC,CAAA;AAE9E,eAAO,MAAM,gBAAgB,4DAE5B,CAAA"}

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

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@navios/di';
+import type { AbstractHttpAdapterInterface } from '../interfaces/index.mjs';
+export declare const HttpAdapterToken: InjectionToken<AbstractHttpAdapterInterface<any, any, any, any>, undefined, false>;
+//# sourceMappingURL=http-adapter.token.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-adapter.token.d.mts","sourceRoot":"","sources":["http-adapter.token.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAA;AAE3E,eAAO,MAAM,gBAAgB,oFAG1B,CAAA"}

package/src/tokens/index.d.mts

@@ -0,0 +1,9 @@
+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';
+export * from './xml-stream-adapter.token.mjs';
+//# sourceMappingURL=index.d.mts.map

package/src/tokens/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,0BAA0B,CAAA;AACxC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,gCAAgC,CAAA"}

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

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@navios/di';
+import type { AbstractHttpHandlerAdapterInterface } from '../interfaces/index.mjs';
+export declare const MultipartAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+//# sourceMappingURL=multipart-adapter.token.d.mts.map