@navios/core 0.8.0 → 0.9.0

package/src/__tests__/unit-testing-module.spec.mts

@@ -0,0 +1,424 @@
+import { Injectable, InjectionToken } from '@navios/di'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { UnitTestingModule } from '../testing/unit-testing-module.mjs'
+
+describe('UnitTestingModule', () => {
+  let unitTestingModule: UnitTestingModule | null = null
+
+  afterEach(async () => {
+    if (unitTestingModule) {
+      await unitTestingModule.close()
+      unitTestingModule = null
+    }
+  })
+
+  describe('create', () => {
+    it('should create a unit testing module with providers', async () => {
+      @Injectable()
+      class TestService {
+        getValue() {
+          return 'test'
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      expect(unitTestingModule).toBeInstanceOf(UnitTestingModule)
+    })
+
+    it('should create with useValue provider', async () => {
+      const TOKEN = InjectionToken.create<string>('test-token')
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TOKEN, useValue: 'test-value' }],
+      })
+
+      const value = await unitTestingModule.get(TOKEN)
+      expect(value).toBe('test-value')
+    })
+
+    it('should create with useClass provider', async () => {
+      @Injectable()
+      class OriginalService {
+        getValue() {
+          return 'original'
+        }
+      }
+
+      @Injectable()
+      class MockService {
+        getValue() {
+          return 'mock'
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: OriginalService, useClass: MockService }],
+      })
+
+      const service = await unitTestingModule.get(OriginalService)
+      expect(service.getValue()).toBe('mock')
+    })
+
+    it('should create with useFactory provider', async () => {
+      const TOKEN = InjectionToken.create<{ value: string }>('factory-token')
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [
+          {
+            token: TOKEN,
+            useFactory: () => ({ value: 'from-factory' }),
+          },
+        ],
+      })
+
+      const instance = await unitTestingModule.get(TOKEN)
+      expect(instance.value).toBe('from-factory')
+    })
+  })
+
+  describe('get', () => {
+    it('should resolve registered providers', async () => {
+      @Injectable()
+      class TestService {
+        getValue() {
+          return 'test'
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      const service = await unitTestingModule.get(TestService)
+      expect(service.getValue()).toBe('test')
+    })
+
+    it('should throw for unregistered providers in strict mode', async () => {
+      @Injectable()
+      class RegisteredService {}
+
+      @Injectable()
+      class UnregisteredService {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: RegisteredService, useClass: RegisteredService }],
+        allowUnregistered: false,
+      })
+
+      await expect(unitTestingModule.get(UnregisteredService)).rejects.toThrow()
+    })
+
+    it('should auto-mock unregistered providers when allowUnregistered is true', async () => {
+      @Injectable()
+      class RegisteredService {}
+
+      @Injectable()
+      class UnregisteredService {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: RegisteredService, useClass: RegisteredService }],
+        allowUnregistered: true,
+      })
+
+      const unregistered = await unitTestingModule.get(UnregisteredService)
+
+      // Auto-mocked service should exist but throw on method access
+      expect(unregistered).toBeDefined()
+    })
+  })
+
+  describe('auto-mocking', () => {
+    it('should enable auto-mocking with enableAutoMocking()', async () => {
+      @Injectable()
+      class UnregisteredService {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [],
+        allowUnregistered: false,
+      })
+
+      unitTestingModule.enableAutoMocking()
+
+      const service = await unitTestingModule.get(UnregisteredService)
+      expect(service).toBeDefined()
+    })
+
+    it('should disable auto-mocking with disableAutoMocking()', async () => {
+      @Injectable()
+      class UnregisteredService {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [],
+        allowUnregistered: true,
+      })
+
+      unitTestingModule.disableAutoMocking()
+
+      await expect(unitTestingModule.get(UnregisteredService)).rejects.toThrow()
+    })
+
+    it('should track auto-mocked services', async () => {
+      @Injectable()
+      class UnregisteredService {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [],
+        allowUnregistered: true,
+      })
+
+      await unitTestingModule.get(UnregisteredService)
+
+      expect(() => unitTestingModule!.expectAutoMocked(UnregisteredService)).not.toThrow()
+    })
+  })
+
+  describe('automatic method call tracking', () => {
+    it('should automatically track method calls via proxy', async () => {
+      @Injectable()
+      class TestService {
+        greet(name: string) {
+          return `Hello, ${name}!`
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      const service = await unitTestingModule.get(TestService)
+      service.greet('World')
+
+      expect(() => unitTestingModule!.expectCalled(TestService, 'greet')).not.toThrow()
+      expect(() =>
+        unitTestingModule!.expectCalledWith(TestService, 'greet', ['World']),
+      ).not.toThrow()
+    })
+
+    it('should track multiple method calls', async () => {
+      @Injectable()
+      class TestService {
+        methodA() {
+          return 'a'
+        }
+        methodB(x: number, y: number) {
+          return x + y
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      const service = await unitTestingModule.get(TestService)
+      service.methodA()
+      service.methodB(1, 2)
+      service.methodB(3, 4)
+
+      expect(() => unitTestingModule!.expectCallCount(TestService, 'methodA', 1)).not.toThrow()
+      expect(() => unitTestingModule!.expectCallCount(TestService, 'methodB', 2)).not.toThrow()
+    })
+
+    it('should track async method calls', async () => {
+      @Injectable()
+      class AsyncService {
+        async fetchData(id: string) {
+          return { id, data: 'fetched' }
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: AsyncService, useClass: AsyncService }],
+      })
+
+      const service = await unitTestingModule.get(AsyncService)
+      await service.fetchData('123')
+
+      expect(() => unitTestingModule!.expectCalled(AsyncService, 'fetchData')).not.toThrow()
+      expect(() =>
+        unitTestingModule!.expectCalledWith(AsyncService, 'fetchData', ['123']),
+      ).not.toThrow()
+    })
+
+    it('should expose getMethodCalls for custom assertions', async () => {
+      @Injectable()
+      class TestService {
+        process(value: string) {
+          return value.toUpperCase()
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      const service = await unitTestingModule.get(TestService)
+      service.process('hello')
+      service.process('world')
+
+      const calls = unitTestingModule.getMethodCalls(TestService)
+
+      expect(calls).toHaveLength(2)
+      expect(calls[0].args).toEqual(['hello'])
+      expect(calls[0].result).toBe('HELLO')
+      expect(calls[1].args).toEqual(['world'])
+      expect(calls[1].result).toBe('WORLD')
+    })
+  })
+
+  describe('assertion helpers', () => {
+    it('should expose expectResolved', async () => {
+      @Injectable()
+      class TestService {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      await unitTestingModule.get(TestService)
+
+      expect(() => unitTestingModule!.expectResolved(TestService)).not.toThrow()
+    })
+
+    it('should expose expectNotResolved', async () => {
+      @Injectable()
+      class TestService {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      expect(() => unitTestingModule!.expectNotResolved(TestService)).not.toThrow()
+    })
+
+    it('should expose expectNotCalled', async () => {
+      @Injectable()
+      class TestService {
+        method() {
+          return 'test'
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      await unitTestingModule.get(TestService)
+      // Method not called
+
+      expect(() => unitTestingModule!.expectNotCalled(TestService, 'method')).not.toThrow()
+    })
+  })
+
+  describe('service stats', () => {
+    it('should get service stats', async () => {
+      @Injectable()
+      class TestService {
+        doWork() {
+          return 'done'
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      const service = await unitTestingModule.get(TestService)
+      service.doWork()
+      service.doWork()
+
+      const stats = unitTestingModule.getServiceStats(TestService)
+
+      expect(stats.methodCalls).toHaveLength(2)
+      expect(stats.methodCalls[0].method).toBe('doWork')
+    })
+  })
+
+  describe('clearMethodCalls', () => {
+    it('should clear all method calls', async () => {
+      @Injectable()
+      class TestService {
+        method() {
+          return 'test'
+        }
+      }
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      const service = await unitTestingModule.get(TestService)
+      service.method()
+      service.method()
+
+      expect(unitTestingModule.getMethodCalls(TestService)).toHaveLength(2)
+
+      unitTestingModule.clearMethodCalls()
+
+      expect(unitTestingModule.getMethodCalls(TestService)).toHaveLength(0)
+    })
+  })
+
+  describe('registered and auto-mocked token tracking', () => {
+    it('should track registered token IDs', async () => {
+      @Injectable()
+      class ServiceA {}
+
+      @Injectable()
+      class ServiceB {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [
+          { token: ServiceA, useClass: ServiceA },
+          { token: ServiceB, useClass: ServiceB },
+        ],
+      })
+
+      const registeredIds = unitTestingModule.getRegisteredTokenIds()
+
+      expect(registeredIds.size).toBe(2)
+    })
+
+    it('should track auto-mocked token IDs', async () => {
+      @Injectable()
+      class UnregisteredA {}
+
+      @Injectable()
+      class UnregisteredB {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [],
+        allowUnregistered: true,
+      })
+
+      await unitTestingModule.get(UnregisteredA)
+      await unitTestingModule.get(UnregisteredB)
+
+      const autoMockedIds = unitTestingModule.getAutoMockedTokenIds()
+
+      expect(autoMockedIds.size).toBe(2)
+    })
+  })
+
+  describe('close', () => {
+    it('should clean up resources', async () => {
+      @Injectable()
+      class TestService {}
+
+      unitTestingModule = UnitTestingModule.create({
+        providers: [{ token: TestService, useClass: TestService }],
+      })
+
+      await unitTestingModule.get(TestService)
+      await unitTestingModule.close()
+
+      // After close, method calls should be cleared
+      expect(unitTestingModule.getMethodCalls(TestService)).toHaveLength(0)
+
+      unitTestingModule = null // Prevent afterEach from calling close again
+    })
+  })
+})

package/src/decorators/controller.decorator.mts

@@ -1,4 +1,4 @@
-import type { ClassType } from '@navios/di'
+import type { ClassType, InjectableScope } from '@navios/di'
 
 import { Injectable, InjectionToken, Registry } from '@navios/di'
 
@@ -18,6 +18,16 @@ export interface ControllerOptions {
    * Registry is used to store the controller and its endpoints.
    */
   registry?: Registry
+  /**
+   * Priority to use for the controller.
+   * Priority is used to sort the controller in the registry.
+   */
+  priority?: number
+  /**
+   * Scope to use for the controller.
+   * Scope is used to determine the scope of the controller.
+   */
+  scope?: InjectableScope
 }
 
 /**
@@ -40,7 +50,12 @@ export interface ControllerOptions {
  * }
  * ```
  */
-export function Controller({ guards, registry }: ControllerOptions = {}) {
+export function Controller({
+  guards,
+  registry,
+  priority,
+  scope,
+}: ControllerOptions = {}) {
   return function (target: ClassType, context: ClassDecoratorContext) {
     if (context.kind !== 'class') {
       throw new Error(
@@ -59,6 +74,8 @@ export function Controller({ guards, registry }: ControllerOptions = {}) {
     return Injectable({
       token,
       registry,
+      priority,
+      scope,
     })(target, context)
   }
 }

package/src/decorators/module.decorator.mts

@@ -1,4 +1,4 @@
-import type { ClassType } from '@navios/di'
+import type { ClassType, Registry } from '@navios/di'
 
 import { Injectable, InjectableScope, InjectionToken } from '@navios/di'
 
@@ -23,17 +23,27 @@ export interface ModuleOptions {
    * Guards are executed in reverse order (last guard first).
    */
   guards?: ClassType[] | Set<ClassType>
+  /**
+   * Priority to use for the module.
+   * Priority is used to sort the module in the registry.
+   */
+  priority?: number
+  /**
+   * Registry to use for the module.
+   * Registry is used to store the module and its controllers.
+   */
+  registry?: Registry
 }
 
 /**
  * Decorator that marks a class as a Navios module.
- * 
+ *
  * Modules are the basic building blocks of a Navios application.
  * They organize controllers, services, and other modules into logical units.
- * 
+ *
  * @param options - Module configuration options
  * @returns A class decorator
- * 
+ *
  * @example
  * ```typescript
  * @Module({
@@ -45,7 +55,13 @@ export interface ModuleOptions {
  * ```
  */
 export function Module(
-  { controllers = [], imports = [], guards = [] }: ModuleOptions = {
+  {
+    controllers = [],
+    imports = [],
+    guards = [],
+    priority,
+    registry,
+  }: ModuleOptions = {
     controllers: [],
     imports: [],
     guards: [],
@@ -71,6 +87,8 @@ export function Module(
     return Injectable({
       token,
       scope: InjectableScope.Singleton,
+      priority,
+      registry,
     })(target, context)
   }
 }

package/src/legacy-compat/__type-tests__/legacy-decorators.spec-d.mts

@@ -138,9 +138,7 @@ describe('Legacy Decorators Type Safety', () => {
           // - request.urlParams.userId: string | number
           // - request.params.page: number
           // - request.params.limit: number
-          expectTypeOf(request.urlParams.userId).toEqualTypeOf<
-            string | number
-          >()
+          expectTypeOf(request.urlParams.userId).toEqualTypeOf<string>()
           expectTypeOf(request.params.page).toEqualTypeOf<number>()
           expectTypeOf(request.params.limit).toEqualTypeOf<number>()
           return {
@@ -270,9 +268,7 @@ describe('Legacy Decorators Type Safety', () => {
           // - request.urlParams.fileId: string | number
           // - request.params.page: number
           // - request.params.limit: number
-          expectTypeOf(request.urlParams.fileId).toEqualTypeOf<
-            string | number
-          >()
+          expectTypeOf(request.urlParams.fileId).toEqualTypeOf<string>()
           expectTypeOf(request.params.page).toEqualTypeOf<number>()
           expectTypeOf(request.params.limit).toEqualTypeOf<number>()
         }

package/src/legacy-compat/decorators/multipart.decorator.mts

@@ -22,11 +22,11 @@ type MultipartMethodDescriptor<
   (
     params: QuerySchema extends ZodObject
       ? RequestSchema extends ZodType
-        ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema>
-        : EndpointFunctionArgs<Url, QuerySchema, undefined>
+        ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>
+        : EndpointFunctionArgs<Url, QuerySchema, undefined, true>
       : RequestSchema extends ZodType
-        ? EndpointFunctionArgs<Url, undefined, RequestSchema>
-        : EndpointFunctionArgs<Url, undefined, undefined>,
+        ? EndpointFunctionArgs<Url, undefined, RequestSchema, true>
+        : EndpointFunctionArgs<Url, undefined, undefined, true>,
   ) => Promise<z.input<ResponseSchema>>
 >
 

package/src/legacy-compat/decorators/stream.decorator.mts

@@ -21,11 +21,11 @@ type StreamMethodDescriptor<
   (
     params: QuerySchema extends ZodObject
       ? RequestSchema extends ZodType
-        ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema>
-        : EndpointFunctionArgs<Url, QuerySchema, undefined>
+        ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>
+        : EndpointFunctionArgs<Url, QuerySchema, undefined, true>
       : RequestSchema extends ZodType
-        ? EndpointFunctionArgs<Url, undefined, RequestSchema>
-        : EndpointFunctionArgs<Url, undefined, undefined>,
+        ? EndpointFunctionArgs<Url, undefined, RequestSchema, true>
+        : EndpointFunctionArgs<Url, undefined, undefined, true>,
     reply: any,
   ) => Promise<void>
 >

package/src/navios.application.mts

@@ -1,4 +1,4 @@
-import type { ClassTypeWithInstance } from '@navios/di'
+import type { ClassTypeWithInstance, Registry } from '@navios/di'
 
 import { Container, inject, Injectable } from '@navios/di'
 
@@ -19,9 +19,9 @@ import { ModuleLoaderService } from './services/index.mjs'
 
 /**
  * Options for configuring the Navios application context.
- * These options control dependency injection and logging behavior.
+ * These options control the application configuration.
  */
-export interface NaviosApplicationContextOptions {
+export interface NaviosApplicationOptions {
   /**
    * Specifies the logger to use. Pass `false` to turn off logging.
    *
@@ -31,18 +31,18 @@ export interface NaviosApplicationContextOptions {
    */
   logger?: LoggerService | LogLevel[] | false
 
+  /**
+   * Specifies a custom registry to use. Useful for testing.
+   * If not provided, a new Registry will be created.
+   */
+  registry?: Registry
+
   /**
    * Specifies a custom container to use. Useful for testing.
    * If not provided, a new Container will be created.
    */
   container?: Container
-}
 
-/**
- * Complete options for creating a Navios application.
- * Extends NaviosApplicationContextOptions with adapter configuration.
- */
-export interface NaviosApplicationOptions extends NaviosApplicationContextOptions {
   /**
    * HTTP adapter environment(s) to use for the application.
    * Can be a single adapter or an array of adapters.

package/src/navios.environment.mts

@@ -17,7 +17,9 @@ export class NaviosEnvironment {
   setupHttpEnvironment(
     tokens: Map<InjectionToken<any, undefined>, AnyInjectableType>,
   ) {
-    this.httpTokens = tokens
+    for (const [token, value] of tokens) {
+      this.httpTokens.set(token, value)
+    }
   }
 
   getHttpToken(token: InjectionToken<any, undefined>) {