@martel/calyx 0.1.0 → 1.0.0

package/tests/phase3.test.ts

@@ -0,0 +1,203 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  Module,
+  Injectable,
+  Inject,
+  Controller,
+  Get,
+  CalyxContainer,
+  CalyxFactory,
+  Scope,
+  REQUEST,
+  ModuleRef,
+} from '../src/index.ts';
+
+describe('Phase 3: Dependency Injection Scopes (Request & Transient)', () => {
+
+  // 1. Transient Scope Test
+  test('should resolve transient provider as new instances every time', () => {
+    let transientInstantiations = 0;
+
+    @Injectable({ scope: Scope.TRANSIENT })
+    class TransientService {
+      id = ++transientInstantiations;
+    }
+
+    @Injectable()
+    class ConsumerService {
+      constructor(public t1: TransientService, public t2: TransientService) {}
+    }
+
+    @Module({
+      providers: [TransientService, ConsumerService],
+    })
+    class RootModule {}
+
+    const container = new CalyxContainer();
+    container.bootstrap(RootModule);
+
+    const consumer = container.getGlobalOrAnyInstance(ConsumerService);
+    expect(consumer.t1.id).toBe(1);
+    expect(consumer.t2.id).toBe(2);
+    expect(consumer.t1).not.toBe(consumer.t2);
+
+    const t3 = container.resolveTokenGlobally(TransientService);
+    expect(t3.id).toBe(3);
+  });
+
+  // 2. Request Scope and Bubble Up Test
+  test('should bubble up Request scope and instantiate once per request', async () => {
+    let requestScopedInstantiations = 0;
+    let controllerInstantiations = 0;
+
+    @Injectable({ scope: Scope.REQUEST })
+    class ScopedService {
+      id = ++requestScopedInstantiations;
+    }
+
+    @Injectable() // implicitly request-scoped because of dependency ScopedService
+    class DependentService {
+      constructor(public scoped: ScopedService) {}
+    }
+
+    @Controller('scoped')
+    class ScopedController {
+      id = ++controllerInstantiations;
+      constructor(public dep: DependentService, public scoped: ScopedService) {}
+
+      @Get()
+      getIds() {
+        return {
+          controllerId: this.id,
+          depScopedId: this.dep.scoped.id,
+          scopedId: this.scoped.id,
+        };
+      }
+    }
+
+    @Module({
+      controllers: [ScopedController],
+      providers: [ScopedService, DependentService],
+    })
+    class RootModule {}
+
+    const app = await CalyxFactory.create(RootModule);
+    await app.listen(3994);
+
+    try {
+      // First request
+      const res1 = await fetch('http://localhost:3994/scoped');
+      expect(res1.status).toBe(200);
+      const data1 = await res1.json();
+      expect(data1).toEqual({
+        controllerId: 1,
+        depScopedId: 1,
+        scopedId: 1,
+      });
+
+      // Second request
+      const res2 = await fetch('http://localhost:3994/scoped');
+      expect(res2.status).toBe(200);
+      const data2 = await res2.json();
+      expect(data2).toEqual({
+        controllerId: 2,
+        depScopedId: 2,
+        scopedId: 2,
+      });
+    } finally {
+      await app.close();
+    }
+  });
+
+  // 3. REQUEST Object Injection Test
+  test('should inject the current Request object into request-scoped providers', async () => {
+    @Injectable({ scope: Scope.REQUEST })
+    class ReqService {
+      constructor(@Inject(REQUEST) public request: Request) {}
+
+      getUrl() {
+        return this.request.url;
+      }
+    }
+
+    @Controller('request-inject')
+    class ReqController {
+      constructor(public reqService: ReqService) {}
+
+      @Get()
+      testInject() {
+        return { url: this.reqService.getUrl() };
+      }
+    }
+
+    @Module({
+      controllers: [ReqController],
+      providers: [ReqService],
+    })
+    class RootModule {}
+
+    const app = await CalyxFactory.create(RootModule);
+    await app.listen(3995);
+
+    try {
+      const res = await fetch('http://localhost:3995/request-inject?query=123');
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.url).toContain('/request-inject?query=123');
+    } finally {
+      await app.close();
+    }
+  });
+
+  // 4. ModuleRef resolve() and create() Test
+  test('should support ModuleRef.resolve() and ModuleRef.create()', async () => {
+    let transientCount = 0;
+
+    @Injectable({ scope: Scope.TRANSIENT })
+    class TransService {
+      id = ++transientCount;
+    }
+
+    @Injectable()
+    class ConsumerService {
+      constructor(public moduleRef: ModuleRef) {}
+
+      async resolveTransient() {
+        return this.moduleRef.resolve(TransService);
+      }
+
+      async createDynamicClass() {
+        class DynamicClass {
+          constructor(public t: TransService) {}
+        }
+        Reflect.defineMetadata('design:paramtypes', [TransService], DynamicClass);
+        Reflect.defineMetadata('calyx:injectable', true, DynamicClass);
+        return this.moduleRef.create(DynamicClass);
+      }
+    }
+
+    @Module({
+      providers: [TransService, ConsumerService],
+    })
+    class RootModule {}
+
+    const container = new CalyxContainer();
+    container.bootstrap(RootModule);
+
+    const consumer = container.getGlobalOrAnyInstance(ConsumerService);
+    
+    // Test resolve
+    const t1 = await consumer.resolveTransient();
+    const t2 = await consumer.resolveTransient();
+    expect(t1).toBeInstanceOf(TransService);
+    expect(t2).toBeInstanceOf(TransService);
+    expect(t1.id).toBe(1);
+    expect(t2.id).toBe(2);
+    expect(t1).not.toBe(t2);
+
+    // Test create
+    const dynamic = await consumer.createDynamicClass();
+    expect(dynamic.t).toBeInstanceOf(TransService);
+    expect(dynamic.t.id).toBe(3);
+  });
+});

package/tests/routing.test.ts

@@ -14,8 +14,8 @@ import {
   Header,
   Res,
   Redirect,
-  calyxFactory,
-  calyxResponse,
+  CalyxFactory,
+  CalyxResponse,
   NotFoundException,
   BadRequestException,
 } from '../src/index.ts';
@@ -59,7 +59,7 @@ class UsersController {
   }
 
   @Get('manual')
-  manual(@Res() res: calyxResponse) {
+  manual(@Res() res: CalyxResponse) {
     res.status(202).json({ manual: true });
   }
 
@@ -80,7 +80,7 @@ describe('HTTP Routing and Controller System', () => {
   const PORT = 3847;
 
   beforeAll(async () => {
-    app = await calyxFactory.create(AppModule);
+    app = await CalyxFactory.create(AppModule);
     await app.listen(PORT);
     baseUrl = `http://localhost:${PORT}`;
   });