@dangao/bun-server 1.8.0 → 1.8.1

package/tests/middleware/middleware-decorators.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import {
+  UseMiddleware,
+  RateLimit,
+  getClassMiddlewares,
+  getMethodMiddlewares,
+} from '../../src/middleware/decorators';
+import type { Middleware } from '../../src/middleware';
+import type { Context } from '../../src/core/context';
+
+// 模拟中间件
+const mockMiddleware1: Middleware = async (ctx, next) => {
+  return await next();
+};
+
+const mockMiddleware2: Middleware = async (ctx, next) => {
+  return await next();
+};
+
+const mockMiddleware3: Middleware = async (ctx, next) => {
+  return await next();
+};
+
+describe('UseMiddleware Decorator', () => {
+  describe('Class-level middleware', () => {
+    test('should register single middleware on class', () => {
+      @UseMiddleware(mockMiddleware1)
+      class TestController {}
+
+      const middlewares = getClassMiddlewares(TestController);
+      expect(middlewares.length).toBe(1);
+      expect(middlewares[0]).toBe(mockMiddleware1);
+    });
+
+    test('should register multiple middlewares on class', () => {
+      @UseMiddleware(mockMiddleware1, mockMiddleware2, mockMiddleware3)
+      class TestController {}
+
+      const middlewares = getClassMiddlewares(TestController);
+      expect(middlewares.length).toBe(3);
+      expect(middlewares).toContain(mockMiddleware1);
+      expect(middlewares).toContain(mockMiddleware2);
+      expect(middlewares).toContain(mockMiddleware3);
+    });
+
+    test('should accumulate middlewares from multiple decorators', () => {
+      @UseMiddleware(mockMiddleware1)
+      @UseMiddleware(mockMiddleware2)
+      class TestController {}
+
+      const middlewares = getClassMiddlewares(TestController);
+      expect(middlewares.length).toBe(2);
+    });
+
+    test('should return empty array for class without middleware', () => {
+      class TestController {}
+
+      const middlewares = getClassMiddlewares(TestController);
+      expect(middlewares).toEqual([]);
+    });
+
+    test('should not register when empty array passed', () => {
+      @UseMiddleware()
+      class TestController {}
+
+      const middlewares = getClassMiddlewares(TestController);
+      expect(middlewares.length).toBe(0);
+    });
+  });
+
+  describe('Method-level middleware', () => {
+    test('should register single middleware on method', () => {
+      class TestController {
+        @UseMiddleware(mockMiddleware1)
+        public testMethod(): void {}
+      }
+
+      const middlewares = getMethodMiddlewares(
+        TestController.prototype,
+        'testMethod',
+      );
+      expect(middlewares.length).toBe(1);
+      expect(middlewares[0]).toBe(mockMiddleware1);
+    });
+
+    test('should register multiple middlewares on method', () => {
+      class TestController {
+        @UseMiddleware(mockMiddleware1, mockMiddleware2)
+        public testMethod(): void {}
+      }
+
+      const middlewares = getMethodMiddlewares(
+        TestController.prototype,
+        'testMethod',
+      );
+      expect(middlewares.length).toBe(2);
+    });
+
+    test('should accumulate middlewares from multiple decorators on method', () => {
+      class TestController {
+        @UseMiddleware(mockMiddleware1)
+        @UseMiddleware(mockMiddleware2)
+        public testMethod(): void {}
+      }
+
+      const middlewares = getMethodMiddlewares(
+        TestController.prototype,
+        'testMethod',
+      );
+      expect(middlewares.length).toBe(2);
+    });
+
+    test('should return empty array for method without middleware', () => {
+      class TestController {
+        public testMethod(): void {}
+      }
+
+      const middlewares = getMethodMiddlewares(
+        TestController.prototype,
+        'testMethod',
+      );
+      expect(middlewares).toEqual([]);
+    });
+
+    test('should keep separate middlewares for different methods', () => {
+      class TestController {
+        @UseMiddleware(mockMiddleware1)
+        public method1(): void {}
+
+        @UseMiddleware(mockMiddleware2)
+        public method2(): void {}
+      }
+
+      const middlewares1 = getMethodMiddlewares(
+        TestController.prototype,
+        'method1',
+      );
+      const middlewares2 = getMethodMiddlewares(
+        TestController.prototype,
+        'method2',
+      );
+
+      expect(middlewares1.length).toBe(1);
+      expect(middlewares1[0]).toBe(mockMiddleware1);
+      expect(middlewares2.length).toBe(1);
+      expect(middlewares2[0]).toBe(mockMiddleware2);
+    });
+  });
+
+  describe('Mixed class and method middleware', () => {
+    test('should keep class and method middlewares separate', () => {
+      @UseMiddleware(mockMiddleware1)
+      class TestController {
+        @UseMiddleware(mockMiddleware2)
+        public testMethod(): void {}
+      }
+
+      const classMiddlewares = getClassMiddlewares(TestController);
+      const methodMiddlewares = getMethodMiddlewares(
+        TestController.prototype,
+        'testMethod',
+      );
+
+      expect(classMiddlewares.length).toBe(1);
+      expect(classMiddlewares[0]).toBe(mockMiddleware1);
+      expect(methodMiddlewares.length).toBe(1);
+      expect(methodMiddlewares[0]).toBe(mockMiddleware2);
+    });
+  });
+});
+
+describe('RateLimit Decorator', () => {
+  test('should create rate limit middleware on method', () => {
+    class TestController {
+      @RateLimit({ limit: 100, windowMs: 60000 })
+      public testMethod(): void {}
+    }
+
+    const middlewares = getMethodMiddlewares(
+      TestController.prototype,
+      'testMethod',
+    );
+
+    expect(middlewares.length).toBe(1);
+    expect(typeof middlewares[0]).toBe('function');
+  });
+
+  test('should create rate limit middleware with custom options', () => {
+    class TestController {
+      @RateLimit({
+        limit: 10,
+        windowMs: 1000,
+        keyGenerator: (ctx: Context) => ctx.request.url,
+      })
+      public limitedMethod(): void {}
+    }
+
+    const middlewares = getMethodMiddlewares(
+      TestController.prototype,
+      'limitedMethod',
+    );
+
+    expect(middlewares.length).toBe(1);
+  });
+
+  test('should work alongside UseMiddleware', () => {
+    class TestController {
+      @UseMiddleware(mockMiddleware1)
+      @RateLimit({ limit: 50, windowMs: 30000 })
+      public testMethod(): void {}
+    }
+
+    const middlewares = getMethodMiddlewares(
+      TestController.prototype,
+      'testMethod',
+    );
+
+    expect(middlewares.length).toBe(2);
+  });
+});

package/tests/middleware/middleware-pipeline.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { MiddlewarePipeline, runMiddlewares } from '../../src/middleware/pipeline';
+import { Context } from '../../src/core/context';
+import { Container } from '../../src/di/container';
+import type { Middleware } from '../../src/middleware';
+
+describe('MiddlewarePipeline', () => {
+  let pipeline: MiddlewarePipeline;
+  let context: Context;
+
+  beforeEach(() => {
+    pipeline = new MiddlewarePipeline();
+    const request = new Request('http://localhost/test');
+    context = new Context(request, new Container());
+  });
+
+  describe('constructor', () => {
+    test('should create empty pipeline', () => {
+      const p = new MiddlewarePipeline();
+      expect(p.hasMiddlewares()).toBe(false);
+    });
+
+    test('should create pipeline with initial middlewares', () => {
+      const middleware: Middleware = async (ctx, next) => next();
+      const p = new MiddlewarePipeline([middleware]);
+      expect(p.hasMiddlewares()).toBe(true);
+    });
+  });
+
+  describe('use', () => {
+    test('should add middleware', () => {
+      expect(pipeline.hasMiddlewares()).toBe(false);
+
+      pipeline.use(async (ctx, next) => next());
+
+      expect(pipeline.hasMiddlewares()).toBe(true);
+    });
+  });
+
+  describe('clear', () => {
+    test('should remove all middlewares', () => {
+      pipeline.use(async (ctx, next) => next());
+      pipeline.use(async (ctx, next) => next());
+
+      pipeline.clear();
+
+      expect(pipeline.hasMiddlewares()).toBe(false);
+    });
+  });
+
+  describe('run', () => {
+    test('should run final handler when no middlewares', async () => {
+      let finalCalled = false;
+      const response = await pipeline.run(context, async () => {
+        finalCalled = true;
+        return new Response('final');
+      });
+
+      expect(finalCalled).toBe(true);
+      expect(await response.text()).toBe('final');
+    });
+
+    test('should execute middlewares in order', async () => {
+      const order: number[] = [];
+
+      pipeline.use(async (ctx, next) => {
+        order.push(1);
+        const res = await next();
+        order.push(4);
+        return res;
+      });
+
+      pipeline.use(async (ctx, next) => {
+        order.push(2);
+        const res = await next();
+        order.push(3);
+        return res;
+      });
+
+      await pipeline.run(context, async () => new Response('ok'));
+
+      expect(order).toEqual([1, 2, 3, 4]);
+    });
+
+    test('should allow middleware to modify response', async () => {
+      pipeline.use(async (ctx, next) => {
+        const res = await next();
+        return new Response('modified', { headers: res.headers });
+      });
+
+      const response = await pipeline.run(context, async () => new Response('original'));
+
+      expect(await response.text()).toBe('modified');
+    });
+
+    test('should allow middleware to short-circuit', async () => {
+      let finalCalled = false;
+
+      pipeline.use(async (ctx, next) => {
+        return new Response('short-circuit');
+      });
+
+      const response = await pipeline.run(context, async () => {
+        finalCalled = true;
+        return new Response('final');
+      });
+
+      expect(finalCalled).toBe(false);
+      expect(await response.text()).toBe('short-circuit');
+    });
+
+    test('should track middleware calls', async () => {
+      let nextCallCount = 0;
+
+      pipeline.use(async (ctx, next) => {
+        nextCallCount++;
+        return await next();
+      });
+
+      await pipeline.run(context, async () => new Response('ok'));
+
+      expect(nextCallCount).toBe(1);
+    });
+  });
+});
+
+describe('runMiddlewares', () => {
+  let context: Context;
+
+  beforeEach(() => {
+    const request = new Request('http://localhost/test');
+    context = new Context(request, new Container());
+  });
+
+  test('should run final handler when no middlewares', async () => {
+    const response = await runMiddlewares([], context, async () => new Response('final'));
+    expect(await response.text()).toBe('final');
+  });
+
+  test('should execute middlewares', async () => {
+    const order: number[] = [];
+
+    const middlewares: Middleware[] = [
+      async (ctx, next) => {
+        order.push(1);
+        return await next();
+      },
+      async (ctx, next) => {
+        order.push(2);
+        return await next();
+      },
+    ];
+
+    await runMiddlewares(middlewares, context, async () => new Response('ok'));
+
+    expect(order).toEqual([1, 2]);
+  });
+});

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

@@ -0,0 +1,139 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import {
+  Queue,
+  Cron,
+  getQueueMetadata,
+  getCronMetadata,
+  type QueueOptions,
+  type CronDecoratorOptions,
+} from '../../src/queue/decorators';
+
+describe('Queue Decorator', () => {
+  test('should set queue metadata with default options', () => {
+    class TestService {
+      @Queue()
+      public processTask(): void {}
+    }
+
+    const metadata = getQueueMetadata(TestService.prototype.processTask);
+    expect(metadata).toBeDefined();
+    expect(metadata?.name).toBeUndefined();
+  });
+
+  test('should set queue metadata with custom name', () => {
+    class TestService {
+      @Queue({ name: 'email-queue' })
+      public sendEmail(): void {}
+    }
+
+    const metadata = getQueueMetadata(TestService.prototype.sendEmail);
+    expect(metadata?.name).toBe('email-queue');
+  });
+});
+
+describe('Cron Decorator', () => {
+  test('should set cron metadata with required pattern', () => {
+    class TestService {
+      @Cron({ pattern: '0 * * * *' })
+      public hourlyTask(): void {}
+    }
+
+    const metadata = getCronMetadata(TestService.prototype.hourlyTask);
+    expect(metadata).toBeDefined();
+    expect(metadata?.pattern).toBe('0 * * * *');
+    expect(metadata?.runOnInit).toBe(false);
+  });
+
+  test('should set cron metadata with timezone', () => {
+    class TestService {
+      @Cron({ pattern: '0 9 * * *', timezone: 'Asia/Shanghai' })
+      public dailyTask(): void {}
+    }
+
+    const metadata = getCronMetadata(TestService.prototype.dailyTask);
+    expect(metadata?.timezone).toBe('Asia/Shanghai');
+  });
+
+  test('should set cron metadata with runOnInit', () => {
+    class TestService {
+      @Cron({ pattern: '*/5 * * * *', runOnInit: true })
+      public frequentTask(): void {}
+    }
+
+    const metadata = getCronMetadata(TestService.prototype.frequentTask);
+    expect(metadata?.runOnInit).toBe(true);
+  });
+
+  test('should set cron metadata with queueName', () => {
+    class TestService {
+      @Cron({ pattern: '0 0 * * *', queueName: 'nightly-queue' })
+      public nightlyTask(): void {}
+    }
+
+    const metadata = getCronMetadata(TestService.prototype.nightlyTask);
+    expect(metadata?.queueName).toBe('nightly-queue');
+  });
+
+  test('should set all cron options together', () => {
+    const options: CronDecoratorOptions = {
+      pattern: '0 0 * * 0',
+      timezone: 'UTC',
+      runOnInit: true,
+      queueName: 'weekly-queue',
+    };
+
+    class TestService {
+      @Cron(options)
+      public weeklyTask(): void {}
+    }
+
+    const metadata = getCronMetadata(TestService.prototype.weeklyTask);
+    expect(metadata?.pattern).toBe('0 0 * * 0');
+    expect(metadata?.timezone).toBe('UTC');
+    expect(metadata?.runOnInit).toBe(true);
+    expect(metadata?.queueName).toBe('weekly-queue');
+  });
+});
+
+describe('Metadata getters', () => {
+  test('getQueueMetadata should return undefined for non-decorated method', () => {
+    class TestService {
+      public normalMethod(): void {}
+    }
+
+    const metadata = getQueueMetadata(TestService.prototype.normalMethod);
+    expect(metadata).toBeUndefined();
+  });
+
+  test('getCronMetadata should return undefined for non-decorated method', () => {
+    class TestService {
+      public normalMethod(): void {}
+    }
+
+    const metadata = getCronMetadata(TestService.prototype.normalMethod);
+    expect(metadata).toBeUndefined();
+  });
+
+  test('should handle multiple decorated methods independently', () => {
+    class TestService {
+      @Queue({ name: 'queue1' })
+      public task1(): void {}
+
+      @Queue({ name: 'queue2' })
+      public task2(): void {}
+
+      @Cron({ pattern: '* * * * *' })
+      public cronTask(): void {}
+    }
+
+    const queue1Meta = getQueueMetadata(TestService.prototype.task1);
+    const queue2Meta = getQueueMetadata(TestService.prototype.task2);
+    const cronMeta = getCronMetadata(TestService.prototype.cronTask);
+
+    expect(queue1Meta?.name).toBe('queue1');
+    expect(queue2Meta?.name).toBe('queue2');
+    expect(cronMeta?.pattern).toBe('* * * * *');
+  });
+});

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

@@ -0,0 +1,191 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { QueueService } from '../../src/queue/service';
+import type { QueueStore, Job, JobData, QueueModuleOptions } from '../../src/queue/types';
+import { QUEUE_OPTIONS_TOKEN } from '../../src/queue/types';
+
+// Mock QueueStore
+function createMockStore(): QueueStore {
+  const queues = new Map<string, Map<string, Job<JobData>>>();
+  let idCounter = 0;
+
+  return {
+    async add<T = JobData>(queueName: string, job: { name: string; data: T; options?: any }): Promise<string> {
+      if (!queues.has(queueName)) {
+        queues.set(queueName, new Map());
+      }
+      const jobId = `job-${++idCounter}`;
+      const newJob: Job<T> = {
+        id: jobId,
+        name: job.name,
+        data: job.data,
+        status: 'waiting',
+        createdAt: Date.now(),
+        options: job.options,
+      };
+      queues.get(queueName)!.set(jobId, newJob as Job<JobData>);
+      return jobId;
+    },
+
+    async get<T = JobData>(queueName: string, jobId: string): Promise<Job<T> | undefined> {
+      return queues.get(queueName)?.get(jobId) as Job<T> | undefined;
+    },
+
+    async delete(queueName: string, jobId: string): Promise<boolean> {
+      return queues.get(queueName)?.delete(jobId) ?? false;
+    },
+
+    async clear(queueName: string): Promise<boolean> {
+      queues.get(queueName)?.clear();
+      return true;
+    },
+
+    async getNext<T = JobData>(queueName: string): Promise<Job<T> | undefined> {
+      const queue = queues.get(queueName);
+      if (!queue || queue.size === 0) return undefined;
+      const first = queue.values().next().value;
+      return first as Job<T> | undefined;
+    },
+
+    async complete(queueName: string, jobId: string, result?: any): Promise<boolean> {
+      const job = queues.get(queueName)?.get(jobId);
+      if (job) {
+        job.status = 'completed';
+        job.result = result;
+        job.completedAt = Date.now();
+        return true;
+      }
+      return false;
+    },
+
+    async fail(queueName: string, jobId: string, error: Error): Promise<boolean> {
+      const job = queues.get(queueName)?.get(jobId);
+      if (job) {
+        job.status = 'failed';
+        job.error = error.message;
+        return true;
+      }
+      return false;
+    },
+
+    async getStats(queueName: string) {
+      const queue = queues.get(queueName);
+      if (!queue) {
+        return { waiting: 0, active: 0, completed: 0, failed: 0 };
+      }
+      let waiting = 0, active = 0, completed = 0, failed = 0;
+      for (const job of queue.values()) {
+        switch (job.status) {
+          case 'waiting': waiting++; break;
+          case 'active': active++; break;
+          case 'completed': completed++; break;
+          case 'failed': failed++; break;
+        }
+      }
+      return { waiting, active, completed, failed };
+    },
+  };
+}
+
+// Helper to create QueueService with mock store
+function createQueueService(options?: Partial<QueueModuleOptions>): QueueService {
+  const mockStore = createMockStore();
+  const moduleOptions: QueueModuleOptions = {
+    store: mockStore,
+    enableWorker: false, // Disable worker for unit tests
+    ...options,
+  };
+
+  // Create service by setting metadata on a mock class
+  const service = new (QueueService as any)({
+    ...moduleOptions,
+    store: mockStore,
+  });
+
+  return service;
+}
+
+describe('QueueService', () => {
+  let service: QueueService;
+
+  beforeEach(() => {
+    service = createQueueService();
+  });
+
+  describe('add', () => {
+    test('should add job to queue', async () => {
+      const jobId = await service.add('test-job', { value: 42 });
+      expect(jobId).toBeDefined();
+      expect(typeof jobId).toBe('string');
+    });
+
+    test('should add job with options', async () => {
+      const jobId = await service.add(
+        'test-job',
+        { data: 'test' },
+        { priority: 10, retries: 3 },
+      );
+      expect(jobId).toBeDefined();
+    });
+
+    test('should add job to custom queue', async () => {
+      const jobId = await service.add('test-job', {}, undefined, 'custom-queue');
+      expect(jobId).toBeDefined();
+    });
+  });
+
+  describe('get', () => {
+    test('should get job by id', async () => {
+      const jobId = await service.add('my-job', { key: 'value' });
+      const job = await service.get(jobId);
+
+      expect(job).toBeDefined();
+      expect(job?.name).toBe('my-job');
+      expect(job?.data).toEqual({ key: 'value' });
+    });
+
+    test('should return undefined for non-existent job', async () => {
+      const job = await service.get('non-existent');
+      expect(job).toBeUndefined();
+    });
+
+    test('should get job from custom queue', async () => {
+      const jobId = await service.add('job', {}, undefined, 'other-queue');
+      const job = await service.get(jobId, 'other-queue');
+      expect(job).toBeDefined();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete job', async () => {
+      const jobId = await service.add('deletable', {});
+      const deleted = await service.delete(jobId);
+      expect(deleted).toBe(true);
+
+      const job = await service.get(jobId);
+      expect(job).toBeUndefined();
+    });
+
+    test('should return false for non-existent job', async () => {
+      const deleted = await service.delete('non-existent');
+      expect(deleted).toBe(false);
+    });
+  });
+
+  describe('clear', () => {
+    test('should clear queue', async () => {
+      await service.add('job1', {});
+      await service.add('job2', {});
+
+      const cleared = await service.clear();
+      expect(cleared).toBe(true);
+    });
+
+    test('should clear custom queue', async () => {
+      await service.add('job', {}, undefined, 'test-queue');
+      const cleared = await service.clear('test-queue');
+      expect(cleared).toBe(true);
+    });
+  });
+});