@navios/di 0.9.2 → 1.0.0

package/src/__tests__/gc/scoped-container.spec.mts

@@ -0,0 +1,444 @@
+/**
+ * Garbage Collection Tests: Scoped Container
+ *
+ * Tests that request-scoped services are properly garbage collected
+ * when the scoped container is ended/disposed.
+ *
+ * Run with: NODE_OPTIONS=--expose-gc yarn nx test @navios/di
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import type { ScopedContainer } from '../../container/scoped-container.mjs'
+import type { OnServiceDestroy } from '../../interfaces/on-service-destroy.interface.mjs'
+
+import { Container } from '../../container/container.mjs'
+import { Injectable } from '../../decorators/injectable.decorator.mjs'
+import { InjectableScope } from '../../enums/injectable-scope.enum.mjs'
+import { Registry } from '../../token/registry.mjs'
+import { inject } from '../../utils/index.mjs'
+import {
+  createGCTracker,
+  forceGC,
+  getHeapUsed,
+  isGCAvailable,
+  waitForGC,
+} from './gc-test-utils.mjs'
+
+describe.skipIf(!isGCAvailable)('GC: Scoped Container', () => {
+  let registry: Registry
+  let container: Container
+
+  beforeEach(() => {
+    registry = new Registry()
+    container = new Container(registry)
+  })
+
+  afterEach(async () => {
+    await container.dispose()
+  })
+
+  describe('Request-scoped services released on endRequest', () => {
+    it('should garbage collect request-scoped service after endRequest', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly id = Math.random()
+        public readonly data = Array.from(
+          { length: 1000 },
+          () => 'request-scoped',
+        )
+      }
+
+      const scoped = container.beginRequest('test-request-1')
+      let instance: RequestService | null = await scoped.get(RequestService)
+      const tracker = createGCTracker(instance)
+
+      expect(tracker().collected).toBe(false)
+
+      await scoped.endRequest()
+      instance = null
+
+      const collected = await waitForGC(tracker().ref)
+      expect(collected).toBe(true)
+    })
+
+    it('should collect multiple request-scoped services on endRequest', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class ServiceA {
+        public readonly data = Array.from({ length: 500 }, () => 'a')
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class ServiceB {
+        public readonly data = Array.from({ length: 500 }, () => 'b')
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class ServiceC {
+        public readonly data = Array.from({ length: 500 }, () => 'c')
+      }
+
+      const scoped = container.beginRequest('test-request-2')
+
+      let instanceA: ServiceA | null = await scoped.get(ServiceA)
+      let instanceB: ServiceB | null = await scoped.get(ServiceB)
+      let instanceC: ServiceC | null = await scoped.get(ServiceC)
+
+      const trackerA = createGCTracker(instanceA)
+      const trackerB = createGCTracker(instanceB)
+      const trackerC = createGCTracker(instanceC)
+
+      await scoped.endRequest()
+
+      // Release local references
+      instanceA = null
+      instanceB = null
+      instanceC = null
+
+      expect(await waitForGC(trackerA().ref)).toBe(true)
+      expect(await waitForGC(trackerB().ref)).toBe(true)
+      expect(await waitForGC(trackerC().ref)).toBe(true)
+    })
+
+    it('should call onServiceDestroy and then collect', async () => {
+      const destroyedIds: number[] = []
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestServiceWithDestroy implements OnServiceDestroy {
+        public readonly id = Math.random()
+
+        onServiceDestroy(): void {
+          destroyedIds.push(this.id)
+        }
+      }
+
+      const scoped = container.beginRequest('test-request-3')
+      let instance: RequestServiceWithDestroy | null = await scoped.get(
+        RequestServiceWithDestroy,
+      )
+      const instanceId = instance.id
+      const tracker = createGCTracker(instance)
+
+      expect(destroyedIds).toHaveLength(0)
+
+      await scoped.endRequest()
+      instance = null
+
+      expect(destroyedIds).toContain(instanceId)
+      expect(await waitForGC(tracker().ref)).toBe(true)
+    })
+
+    it('should handle async onServiceDestroy before collection', async () => {
+      let destroyCompleted = false
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class AsyncDestroyService implements OnServiceDestroy {
+        async onServiceDestroy(): Promise<void> {
+          await new Promise((resolve) => setTimeout(resolve, 10))
+          destroyCompleted = true
+        }
+      }
+
+      const scoped = container.beginRequest('test-request-4')
+      let instance: AsyncDestroyService | null =
+        await scoped.get(AsyncDestroyService)
+      const tracker = createGCTracker(instance)
+
+      await scoped.endRequest()
+      instance = null
+
+      expect(destroyCompleted).toBe(true)
+      expect(await waitForGC(tracker().ref)).toBe(true)
+    })
+  })
+
+  describe('Scoped container itself is collected', () => {
+    it('should garbage collect scoped container after endRequest', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {}
+
+      let scoped: ScopedContainer | null =
+        container.beginRequest('test-gc-scoped')
+      await scoped.get(RequestService)
+
+      const scopedTracker = createGCTracker(scoped)
+
+      await scoped.endRequest()
+      scoped = null
+
+      const collected = await waitForGC(scopedTracker().ref)
+      expect(collected).toBe(true)
+    })
+  })
+
+  describe('Mixed scope scenarios with request scope', () => {
+    it('should collect request-scoped but keep singletons', async () => {
+      @Injectable({ registry })
+      class SingletonService {
+        public readonly id = Math.random()
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly singleton = inject(SingletonService)
+        public readonly id = Math.random()
+      }
+
+      // Get singleton first via root container
+      const singleton = await container.get(SingletonService)
+      const singletonTracker = createGCTracker(singleton)
+
+      // Create request scope and get request-scoped service
+      const scoped = container.beginRequest('test-mixed-1')
+      let requestInstance: RequestService | null =
+        await scoped.get(RequestService)
+      const requestTracker = createGCTracker(requestInstance)
+
+      // Request service should reference same singleton
+      expect(requestInstance.singleton).toBe(singleton)
+
+      await scoped.endRequest()
+      requestInstance = null
+
+      // Request-scoped should be collected
+      expect(await waitForGC(requestTracker().ref)).toBe(true)
+
+      // Singleton should remain
+      expect(singletonTracker().collected).toBe(false)
+      expect(await container.get(SingletonService)).toBe(singleton)
+    })
+
+    it('should isolate request-scoped services between requests', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly id = Math.random()
+        public readonly data = Array.from({ length: 500 }, () => 'isolated')
+      }
+
+      const scoped1 = container.beginRequest('request-a')
+      const scoped2 = container.beginRequest('request-b')
+
+      let instance1: RequestService | null = await scoped1.get(RequestService)
+      let instance2: RequestService | null = await scoped2.get(RequestService)
+
+      expect(instance1).not.toBe(instance2)
+
+      const tracker1 = createGCTracker(instance1)
+      const tracker2 = createGCTracker(instance2)
+
+      // End first request
+      await scoped1.endRequest()
+      instance1 = null
+
+      expect(await waitForGC(tracker1().ref)).toBe(true)
+      expect(tracker2().collected).toBe(false)
+
+      // Second request's instance should still work
+      let stillThere: RequestService | null = await scoped2.get(RequestService)
+      expect(stillThere).toBe(instance2)
+
+      // End second request
+      await scoped2.endRequest()
+      instance2 = null
+      stillThere = null
+
+      expect(await waitForGC(tracker2().ref)).toBe(true)
+    })
+  })
+
+  describe('Request-scoped dependency chains', () => {
+    it('should collect entire request-scoped dependency chain', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class Level3 {
+        public readonly data = Array.from({ length: 200 }, () => 'l3')
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class Level2 {
+        public readonly level3 = inject(Level3)
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class Level1 {
+        public readonly level2 = inject(Level2)
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RootService {
+        public readonly level1 = inject(Level1)
+      }
+
+      const scoped = container.beginRequest('chain-request')
+      let root: RootService | null = await scoped.get(RootService)
+
+      let l1: Level1 | null = root.level1
+      let l2: Level2 | null = l1.level2
+      let l3: Level3 | null = l2.level3
+
+      const rootTracker = createGCTracker(root)
+      const l1Tracker = createGCTracker(l1)
+      const l2Tracker = createGCTracker(l2)
+      const l3Tracker = createGCTracker(l3)
+
+      await scoped.endRequest()
+
+      // Release local references
+      root = null
+      l1 = null
+      l2 = null
+      l3 = null
+
+      expect(await waitForGC(rootTracker().ref)).toBe(true)
+      expect(await waitForGC(l1Tracker().ref)).toBe(true)
+      expect(await waitForGC(l2Tracker().ref)).toBe(true)
+      expect(await waitForGC(l3Tracker().ref)).toBe(true)
+    })
+
+    it('should handle mixed singleton/request dependency chain', async () => {
+      @Injectable({ registry })
+      class SingletonBase {
+        public readonly id = 'singleton-base'
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestMiddle {
+        public readonly base = inject(SingletonBase)
+        public readonly id = Math.random()
+      }
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestTop {
+        public readonly middle = inject(RequestMiddle)
+        public readonly id = Math.random()
+      }
+
+      const singletonBase = await container.get(SingletonBase)
+      const baseTracker = createGCTracker(singletonBase)
+
+      const scoped = container.beginRequest('mixed-chain')
+      let top: RequestTop | null = await scoped.get(RequestTop)
+      let middle: RequestMiddle | null = top.middle
+
+      const middleTracker = createGCTracker(middle)
+      const topTracker = createGCTracker(top)
+
+      expect(middle.base).toBe(singletonBase)
+
+      await scoped.endRequest()
+
+      // Release local references
+      top = null
+      middle = null
+
+      // Request-scoped should be collected
+      expect(await waitForGC(topTracker().ref)).toBe(true)
+      expect(await waitForGC(middleTracker().ref)).toBe(true)
+
+      // Singleton should remain
+      expect(baseTracker().collected).toBe(false)
+    })
+  })
+
+  describe('Memory reclamation for request scopes', () => {
+    it.todo('should reclaim memory when request ends', async () => {
+      const ALLOCATION_SIZE = 1024 * 100 // 100KB
+      const SERVICE_COUNT = 10
+
+      // Create multiple request-scoped services
+      const services: Array<{ new (): { data: Uint8Array } }> = []
+      for (let i = 0; i < SERVICE_COUNT; i++) {
+        @Injectable({ registry, scope: InjectableScope.Request })
+        class LargeRequestService {
+          public readonly data = new Uint8Array(ALLOCATION_SIZE)
+        }
+        services.push(LargeRequestService)
+      }
+
+      forceGC()
+      const baselineMemory = getHeapUsed()
+
+      const scoped = container.beginRequest('memory-test')
+
+      // Resolve all services
+      for (const Service of services) {
+        await scoped.get(Service)
+      }
+
+      forceGC()
+      const afterAllocationMemory = getHeapUsed()
+      const allocated = afterAllocationMemory - baselineMemory
+
+      expect(allocated).toBeGreaterThan(ALLOCATION_SIZE * SERVICE_COUNT * 0.8)
+
+      await scoped.endRequest()
+
+      forceGC()
+      const afterReleaseMemory = getHeapUsed()
+      const reclaimed = afterAllocationMemory - afterReleaseMemory
+
+      // Should reclaim most memory (at least 70%)
+      expect(reclaimed).toBeGreaterThan(allocated * 0.7)
+    })
+
+    it.todo('should not leak memory across multiple requests', async () => {
+      const ALLOCATION_SIZE = 1024 * 50 // 50KB
+      const REQUEST_COUNT = 20
+
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly data = new Uint8Array(ALLOCATION_SIZE)
+      }
+
+      forceGC()
+      const baselineMemory = getHeapUsed()
+
+      // Process many requests
+      for (let i = 0; i < REQUEST_COUNT; i++) {
+        const scoped = container.beginRequest(`request-${i}`)
+        await scoped.get(RequestService)
+        await scoped.endRequest()
+      }
+
+      forceGC()
+      const finalMemory = getHeapUsed()
+      const memoryGrowth = finalMemory - baselineMemory
+
+      // Memory growth should be minimal (less than 2 allocations worth)
+      expect(memoryGrowth).toBeLessThan(ALLOCATION_SIZE * 2)
+    })
+  })
+
+  describe('Concurrent request handling', () => {
+    // This test is flaky and no matter how many requests we make, the last instance is never collected.
+    it.skip('should properly collect services from concurrent requests', async () => {
+      @Injectable({ registry, scope: InjectableScope.Request })
+      class RequestService {
+        public readonly id = Math.random()
+        public readonly data = Array.from({ length: 500 }, () => 'concurrent')
+      }
+
+      const requestCount = 10
+      const scopedContainers: ScopedContainer[] = []
+      const trackers: ReturnType<typeof createGCTracker>[] = []
+
+      // Start multiple concurrent requests
+      for (let i = 0; i < requestCount; i++) {
+        const scoped = container.beginRequest(`concurrent-${i}`)
+        scopedContainers.push(scoped)
+        const instance = await scoped.get(RequestService)
+        trackers.push(createGCTracker(instance))
+      }
+
+      // End all requests
+      await Promise.all(scopedContainers.map((s) => s.endRequest()))
+
+      forceGC()
+      // All should be collected
+      let collected = 0
+      for (const tracker of trackers) {
+        console.log('waiting for GC', collected++, tracker().collected)
+        expect(await waitForGC(tracker().ref)).toBe(true)
+      }
+    })
+  })
+})