@dangao/bun-server 3.1.0 → 3.3.0

package/tests/database/driver.test.ts

@@ -0,0 +1,234 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  closeViaDriver,
+  getConnectionDriver,
+  healthCheckViaDriver,
+  queryViaDriver,
+  resolveDriver,
+  tagConnection,
+  templateQueryViaDriver,
+} from '../../src/database/driver';
+
+describe('resolveDriver', () => {
+  test("'auto' on bun resolves to bun-sql for mysql and postgres", () => {
+    expect(resolveDriver('mysql', 'auto', 'bun')).toBe('bun-sql');
+    expect(resolveDriver('postgres', 'auto', 'bun')).toBe('bun-sql');
+    expect(resolveDriver('mysql', undefined, 'bun')).toBe('bun-sql');
+  });
+
+  test("'auto' on node resolves to js drivers", () => {
+    expect(resolveDriver('mysql', 'auto', 'node')).toBe('mysql2');
+    expect(resolveDriver('postgres', 'auto', 'node')).toBe('postgres');
+  });
+
+  test("'mysql2' forces mysql2 regardless of engine", () => {
+    expect(resolveDriver('mysql', 'mysql2', 'bun')).toBe('mysql2');
+    expect(resolveDriver('mysql', 'mysql2', 'node')).toBe('mysql2');
+  });
+
+  test("'postgres' forces postgres regardless of engine", () => {
+    expect(resolveDriver('postgres', 'postgres', 'bun')).toBe('postgres');
+    expect(resolveDriver('postgres', 'postgres', 'node')).toBe('postgres');
+  });
+
+  test("'bun-sql' is valid on bun, throws on node", () => {
+    expect(resolveDriver('mysql', 'bun-sql', 'bun')).toBe('bun-sql');
+    expect(() => resolveDriver('mysql', 'bun-sql', 'node')).toThrow();
+  });
+
+  test("'mysql2' on postgres type throws", () => {
+    expect(() => resolveDriver('postgres', 'mysql2', 'bun')).toThrow();
+  });
+
+  test("'postgres' on mysql type throws", () => {
+    expect(() => resolveDriver('mysql', 'postgres', 'bun')).toThrow();
+  });
+});
+
+describe('connection tagging', () => {
+  test('tag and read back driver on object connection', () => {
+    const conn = { query: () => undefined };
+    tagConnection(conn, 'mysql2');
+    expect(getConnectionDriver(conn)).toBe('mysql2');
+  });
+
+  test('tag preserves identity', () => {
+    const conn = {};
+    expect(tagConnection(conn, 'mysql2')).toBe(conn);
+  });
+
+  test('tag is non-enumerable', () => {
+    const conn = { query: () => undefined };
+    tagConnection(conn, 'mysql2');
+    expect(Object.keys(conn)).toEqual(['query']);
+  });
+
+  test('callable connection without tag falls back to bun-sql', () => {
+    const conn = (() => undefined) as unknown;
+    expect(getConnectionDriver(conn)).toBe('bun-sql');
+  });
+
+  test('untagged plain object returns undefined', () => {
+    expect(getConnectionDriver({ query: () => undefined })).toBeUndefined();
+  });
+});
+
+describe('queryViaDriver', () => {
+  test('mysql2 connection uses .query and returns rows (not [rows, fields])', async () => {
+    const calls: Array<{ sql: string; params: unknown[] }> = [];
+    const conn = tagConnection(
+      {
+        query: async (sql: string, params: unknown[]) => {
+          calls.push({ sql, params });
+          return [[{ id: 1 }], [{ name: 'id' }]];
+        },
+      },
+      'mysql2',
+    );
+
+    const rows = await queryViaDriver(conn, 'SELECT * FROM t WHERE id = ?', [1]);
+    expect(rows).toEqual([{ id: 1 }]);
+    expect(calls).toEqual([{ sql: 'SELECT * FROM t WHERE id = ?', params: [1] }]);
+  });
+
+  test('postgres connection uses .unsafe and returns rows', async () => {
+    const calls: Array<{ sql: string; params: unknown[] }> = [];
+    const conn = tagConnection(
+      {
+        unsafe: async (sql: string, params: unknown[]) => {
+          calls.push({ sql, params });
+          return [{ ok: true }];
+        },
+      },
+      'postgres',
+    );
+
+    const rows = await queryViaDriver(conn, 'SELECT 1 WHERE x = ?', ['y']);
+    expect(rows).toEqual([{ ok: true }]);
+    expect(calls).toEqual([{ sql: 'SELECT 1 WHERE x = ?', params: ['y'] }]);
+  });
+
+  test('bun-sql connection uses template string path', async () => {
+    let received: { strings: string[]; values: unknown[] } | null = null;
+    const conn = tagConnection(
+      Object.assign(
+        async (strings: TemplateStringsArray, ...values: unknown[]) => {
+          received = { strings: Array.from(strings), values };
+          return [{ via: 'bun-sql' }];
+        },
+      ),
+      'bun-sql',
+    );
+
+    const rows = await queryViaDriver(conn, 'SELECT * FROM t WHERE id = ?', [42]);
+    expect(rows).toEqual([{ via: 'bun-sql' }]);
+    expect(received!.strings).toEqual(['SELECT * FROM t WHERE id = ', '']);
+    expect(received!.values).toEqual([42]);
+  });
+});
+
+describe('templateQueryViaDriver', () => {
+  test('mysql2 transforms template into ? placeholders', async () => {
+    const calls: Array<{ sql: string; params: unknown[] }> = [];
+    const conn = tagConnection(
+      {
+        query: async (sql: string, params: unknown[]) => {
+          calls.push({ sql, params });
+          return [[{ id: 7 }], []];
+        },
+      },
+      'mysql2',
+    );
+
+    const strings = Object.assign(['SELECT * FROM t WHERE id = ', ''], {
+      raw: ['SELECT * FROM t WHERE id = ', ''],
+    }) as unknown as TemplateStringsArray;
+
+    const rows = await templateQueryViaDriver(conn, strings, [7]);
+    expect(rows).toEqual([{ id: 7 }]);
+    expect(calls).toEqual([
+      { sql: 'SELECT * FROM t WHERE id = ?', params: [7] },
+    ]);
+  });
+
+  test('callable connection invoked directly as tagged template', async () => {
+    let received: unknown[] = [];
+    const conn = tagConnection(
+      Object.assign(
+        async (_strings: TemplateStringsArray, ...values: unknown[]) => {
+          received = values;
+          return [{ ok: 1 }];
+        },
+      ),
+      'bun-sql',
+    );
+
+    const strings = Object.assign(['SELECT ', ''], {
+      raw: ['SELECT ', ''],
+    }) as unknown as TemplateStringsArray;
+
+    const rows = await templateQueryViaDriver(conn, strings, [99]);
+    expect(rows).toEqual([{ ok: 1 }]);
+    expect(received).toEqual([99]);
+  });
+});
+
+describe('healthCheckViaDriver', () => {
+  test('mysql2 health check runs SELECT 1', async () => {
+    const conn = tagConnection(
+      {
+        query: async () => [[{ '1': 1 }], []],
+      },
+      'mysql2',
+    );
+    expect(await healthCheckViaDriver(conn)).toBe(true);
+  });
+
+  test('returns false when query throws', async () => {
+    const conn = tagConnection(
+      {
+        query: async () => {
+          throw new Error('down');
+        },
+      },
+      'mysql2',
+    );
+    expect(await healthCheckViaDriver(conn)).toBe(false);
+  });
+});
+
+describe('closeViaDriver', () => {
+  test('mysql2 connection closed via .end()', async () => {
+    let ended = false;
+    let closed = false;
+    const conn = tagConnection(
+      {
+        end: async () => {
+          ended = true;
+        },
+        close: async () => {
+          closed = true;
+        },
+      },
+      'mysql2',
+    );
+    await closeViaDriver(conn);
+    expect(ended).toBe(true);
+    expect(closed).toBe(false);
+  });
+
+  test('bun-sql connection closed via .close()', async () => {
+    let closed = false;
+    const conn = tagConnection(
+      {
+        close: async () => {
+          closed = true;
+        },
+      },
+      'bun-sql',
+    );
+    await closeViaDriver(conn);
+    expect(closed).toBe(true);
+  });
+});

package/tests/database/orm.test.ts

@@ -11,6 +11,7 @@ import {
 } from '../../src/database/orm';
 import { DatabaseService, DATABASE_SERVICE_TOKEN } from '../../src/database';
 import { Container } from '../../src/di/container';
+import { initRuntime } from '../../src/platform/runtime';
 
 // 测试实体
 @Entity('test_users')
@@ -71,6 +72,9 @@ describe('BaseRepository', () => {
   let databaseService: DatabaseService;
 
   beforeEach(async () => {
+    // DatabaseService.initialize() 会读取 getRuntime()，确保运行时已初始化
+    // （避免依赖其他测试文件的执行顺序）
+    initRuntime('bun');
     container = new Container();
     databaseService = new DatabaseService({
       database: {

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!');
+  });
 });