@dangao/bun-server 3.2.0 → 3.3.0

package/tests/controller/context-decorator.test.ts

@@ -155,7 +155,7 @@ describe('@Context() Decorator', () => {
     // 这个测试验证 ContextService 可以在服务层使用
     const { ContextService, CONTEXT_SERVICE_TOKEN } = await import('../../src/core/context-service');
     const container = app.getContainer();
-    const contextService = container.resolve<ContextService>(CONTEXT_SERVICE_TOKEN);
+    const contextService = container.resolve<InstanceType<typeof ContextService>>(CONTEXT_SERVICE_TOKEN);
 
     @Controller('/api/test')
     class TestController {
@@ -180,4 +180,3 @@ describe('@Context() Decorator', () => {
     expect(data.method).toBe('GET');
   });
 });
-

package/tests/di/module.test.ts

@@ -5,6 +5,7 @@ import { Controller, ControllerRegistry } from '../../src/controller/controller'
 import { GET } from '../../src/router/decorators';
 import { Module } from '../../src/di/module';
 import { ModuleRegistry } from '../../src/di/module-registry';
+import { Container } from '../../src/di/container';
 import { RouteRegistry } from '../../src/router/registry';
 import { Injectable, Inject } from '../../src/di/decorators';
 import { Context } from '../../src/core/context';
@@ -177,6 +178,204 @@ describe('ModuleRegistry', () => {
     expect(() => ref.container.resolve(ALIAS)).toThrow(/Provider not found/);
   });
 
+  test('FactoryProvider inject passes resolved dependencies to useFactory', () => {
+    const TOKEN = Symbol.for('test.factory.inject.basic');
+
+    @Injectable()
+    class Dep {
+      public greet(): string {
+        return 'hello';
+      }
+    }
+
+    @Module({
+      providers: [
+        Dep,
+        {
+          provide: TOKEN,
+          useFactory: (dep: Dep) => ({
+            dep,
+            message: dep.greet(),
+          }),
+          inject: [Dep],
+        },
+      ],
+    })
+    class TestModule {}
+
+    const app = new Application();
+    app.registerModule(TestModule);
+
+    const ref = ModuleRegistry.getInstance().getModuleRef(TestModule)!;
+    const dep = ref.container.resolve(Dep);
+    const result = ref.container.resolve<{ dep: Dep; message: string }>(TOKEN);
+
+    expect(result.dep).toBe(dep);
+    expect(result.message).toBe('hello');
+  });
+
+  test('FactoryProvider without inject or with empty inject still passes Container to useFactory', () => {
+    const TOKEN = Symbol.for('test.factory.inject.compat');
+    const EMPTY_INJECT_TOKEN = Symbol.for('test.factory.inject.compat.empty');
+
+    @Injectable()
+    class Dep {
+      public readonly value = 'manual';
+    }
+
+    @Module({
+      providers: [
+        Dep,
+        {
+          provide: TOKEN,
+          useFactory: (container: Container) => ({
+            isContainer: container instanceof Container,
+            dep: container.resolve(Dep),
+          }),
+        },
+        {
+          provide: EMPTY_INJECT_TOKEN,
+          useFactory: (container: Container) => ({
+            isContainer: container instanceof Container,
+            dep: container.resolve(Dep),
+          }),
+          inject: [],
+        },
+      ],
+    })
+    class TestModule {}
+
+    const app = new Application();
+    app.registerModule(TestModule);
+
+    const ref = ModuleRegistry.getInstance().getModuleRef(TestModule)!;
+    const dep = ref.container.resolve(Dep);
+    const result = ref.container.resolve<{ isContainer: boolean; dep: Dep }>(TOKEN);
+    const emptyInjectResult = ref.container.resolve<{ isContainer: boolean; dep: Dep }>(
+      EMPTY_INJECT_TOKEN,
+    );
+
+    expect(result.isContainer).toBe(true);
+    expect(result.dep).toBe(dep);
+    expect(emptyInjectResult.isContainer).toBe(true);
+    expect(emptyInjectResult.dep).toBe(dep);
+  });
+
+  test('FactoryProvider inject resolves tokens exported from imported modules', () => {
+    const DEP_TOKEN = Symbol.for('test.factory.inject.exported.dep');
+    const TOKEN = Symbol.for('test.factory.inject.exported.result');
+
+    interface DepContract {
+      label(): string;
+    }
+
+    const exportedDep: DepContract = {
+      label: () => 'from-export',
+    };
+
+    @Module({
+      providers: [{ provide: DEP_TOKEN, useValue: exportedDep }],
+      exports: [DEP_TOKEN],
+    })
+    class SharedModule {}
+
+    @Module({
+      imports: [SharedModule],
+      providers: [
+        {
+          provide: TOKEN,
+          useFactory: (dep: DepContract) => ({
+            dep,
+            label: dep.label(),
+          }),
+          inject: [DEP_TOKEN],
+        },
+      ],
+    })
+    class AppModule {}
+
+    const app = new Application();
+    app.registerModule(AppModule);
+
+    const ref = ModuleRegistry.getInstance().getModuleRef(AppModule)!;
+    const result = ref.container.resolve<{ dep: DepContract; label: string }>(TOKEN);
+
+    expect(result.dep).toBe(exportedDep);
+    expect(result.label).toBe('from-export');
+  });
+
+  test('FactoryProvider inject preserves token order for factory arguments', () => {
+    const FIRST = Symbol.for('test.factory.inject.order.first');
+    const SECOND = Symbol.for('test.factory.inject.order.second');
+    const TOKEN = Symbol.for('test.factory.inject.order.result');
+
+    @Module({
+      providers: [
+        { provide: FIRST, useValue: 'first' },
+        { provide: SECOND, useValue: 'second' },
+        {
+          provide: TOKEN,
+          useFactory: (second: string, first: string) => [second, first],
+          inject: [SECOND, FIRST],
+        },
+      ],
+    })
+    class TestModule {}
+
+    const app = new Application();
+    app.registerModule(TestModule);
+
+    const ref = ModuleRegistry.getInstance().getModuleRef(TestModule)!;
+    const result = ref.container.resolve<string[]>(TOKEN);
+
+    expect(result).toEqual(['second', 'first']);
+  });
+
+  test('FactoryProvider inject works when mixed with useExisting useValue and useClass providers', () => {
+    const CLASS_TOKEN = Symbol.for('test.factory.inject.mix.class');
+    const VALUE_TOKEN = Symbol.for('test.factory.inject.mix.value');
+    const ALIAS_TOKEN = Symbol.for('test.factory.inject.mix.alias');
+    const TOKEN = Symbol.for('test.factory.inject.mix.result');
+
+    class Impl {
+      public readonly kind = 'impl';
+    }
+
+    const value = { kind: 'value' };
+
+    @Module({
+      providers: [
+        { provide: CLASS_TOKEN, useClass: Impl },
+        { provide: VALUE_TOKEN, useValue: value },
+        { provide: ALIAS_TOKEN, useExisting: CLASS_TOKEN },
+        {
+          provide: TOKEN,
+          useFactory: (aliased: Impl, injectedValue: typeof value) => ({
+            aliased,
+            injectedValue,
+          }),
+          inject: [ALIAS_TOKEN, VALUE_TOKEN],
+        },
+      ],
+    })
+    class TestModule {}
+
+    const app = new Application();
+    app.registerModule(TestModule);
+
+    const ref = ModuleRegistry.getInstance().getModuleRef(TestModule)!;
+    const classInstance = ref.container.resolve<Impl>(CLASS_TOKEN);
+    const aliasInstance = ref.container.resolve<Impl>(ALIAS_TOKEN);
+    const valueInstance = ref.container.resolve<typeof value>(VALUE_TOKEN);
+    const result = ref.container.resolve<{ aliased: Impl; injectedValue: typeof value }>(TOKEN);
+
+    expect(classInstance).toBeInstanceOf(Impl);
+    expect(aliasInstance).toBe(classInstance);
+    expect(valueInstance).toBe(value);
+    expect(result.aliased).toBe(classInstance);
+    expect(result.injectedValue).toBe(value);
+  });
+
   test('should throw error for circular module dependencies', () => {
     @Module({
       imports: [],
@@ -199,4 +398,3 @@ describe('ModuleRegistry', () => {
     );
   });
 });
-

package/tests/events/event-emitter.test.ts

@@ -257,7 +257,7 @@ describe('EventEmitterService', () => {
     });
 
     test('should use custom error handler when provided', () => {
-      const errorHandler = mock(() => {});
+      const errorHandler = mock((_error: Error) => {});
       const emitterWithErrorHandler = new EventEmitterService({
         onError: errorHandler,
       });
@@ -274,7 +274,7 @@ describe('EventEmitterService', () => {
 
   describe('maxListeners warning', () => {
     test('should warn when exceeding maxListeners', () => {
-      const consoleSpy = mock(() => {});
+      const consoleSpy = mock((_message: string) => {});
       const originalWarn = console.warn;
       console.warn = consoleSpy;
 

package/tests/global.d.ts

@@ -0,0 +1,30 @@
+declare global {
+  interface Body {
+    json(): Promise<any>;
+  }
+
+  interface Response {
+    json(): Promise<any>;
+  }
+}
+
+declare module 'bun:test' {
+  export function expect(actual?: any): any;
+  export function mock(fn?: (...args: any[]) => any): any;
+
+  interface MatchersBuiltin<T = unknown> {
+    toBe(expected: any): void;
+  }
+
+  interface Matchers<T = unknown> {
+    toBe(expected: any): void;
+  }
+}
+
+declare module '@dangao/logsmith' {
+  interface LogEntry {
+    data?: unknown;
+  }
+}
+
+export {};

package/tests/queue/queue-service.test.ts

@@ -47,6 +47,16 @@ function createMockStore(): QueueStore {
       return first as Job<T> | undefined;
     },
 
+    async updateStatus(queueName: string, jobId: string, status: Job['status']): Promise<boolean> {
+      const job = queues.get(queueName)?.get(jobId);
+      if (!job) {
+        return false;
+      }
+      job.status = status;
+      job.updatedAt = Date.now();
+      return true;
+    },
+
     async complete(queueName: string, jobId: string, result?: any): Promise<boolean> {
       const job = queues.get(queueName)?.get(jobId);
       if (job) {
@@ -84,6 +94,10 @@ function createMockStore(): QueueStore {
       }
       return { waiting, active, completed, failed };
     },
+
+    async count(queueName: string): Promise<number> {
+      return queues.get(queueName)?.size ?? 0;
+    },
   };
 }
 

package/tests/testing/testing-module.test.ts

@@ -126,4 +126,24 @@ describe('TestingModule', () => {
     const greeter = module.get<Greeter>(GREETER_TOKEN);
     expect(greeter.greet('X')).toBe('Factory: X');
   });
+
+  test('should inject dependencies into provider factories', async () => {
+    const FACTORY_TOKEN = Symbol('FactoryGreeter');
+
+    const module = await Test.createTestingModule({
+      providers: [
+        { provide: GREETER_TOKEN, useClass: RealGreeter },
+        {
+          provide: FACTORY_TOKEN,
+          useFactory: (greeter: Greeter) => ({
+            greet: (name: string) => greeter.greet(name).toUpperCase(),
+          }),
+          inject: [GREETER_TOKEN],
+        },
+      ],
+    }).compile();
+
+    const greeter = module.get<Greeter>(FACTORY_TOKEN);
+    expect(greeter.greet('Test')).toBe('HELLO, TEST!');
+  });
 });