@navios/di 0.2.0 → 0.3.0

package/src/__tests__/factory.spec.mts

@@ -0,0 +1,137 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+import { z } from 'zod/v4'
+
+import { Factory } from '../decorators/index.mjs'
+import { InjectableScope } from '../enums/index.mjs'
+import { Container, Registry } from '../index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+
+describe('Factory decorator', () => {
+  let container: Container
+  beforeEach(() => {
+    container = new Container()
+  })
+  it('should work with factory', async () => {
+    @Factory()
+    class Test {
+      create() {
+        return 'foo'
+      }
+    }
+
+    const value = await container.get(Test)
+    expect(value).toBe('foo')
+  })
+
+  it('should work with request scope', async () => {
+    @Factory({
+      scope: InjectableScope.Transient,
+    })
+    class Test {
+      create() {
+        return Date.now()
+      }
+    }
+
+    const value = await container.get(Test)
+    await new Promise((resolve) => setTimeout(resolve, 10))
+    const value2 = await container.get(Test)
+    expect(value).not.toBe(value2)
+  })
+
+  it('should work with factory injection token and schema', async () => {
+    class TestFoo {
+      constructor(public readonly foo: string) {}
+    }
+    const token = InjectionToken.create(
+      TestFoo,
+      z.object({
+        foo: z.string(),
+      }),
+    )
+
+    @Factory({ token })
+    // oxlint-disable-next-line no-unused-vars
+    class Test {
+      create(ctx: any, args: { foo: string }) {
+        return new TestFoo(args.foo)
+      }
+    }
+
+    const value = await container.get(token, { foo: 'bar' })
+    const sameValue = await container.get(token, { foo: 'bar' })
+    const differentValue = await container.get(token, { foo: 'baz' })
+    // await new Promise((resolve) => setTimeout(resolve, 10))
+    expect(value).toBeInstanceOf(TestFoo)
+    expect(value.foo).toBe('bar')
+    expect(differentValue).toBeInstanceOf(TestFoo)
+    expect(differentValue.foo).toBe('baz')
+    expect(value).not.toBe(differentValue)
+    expect(value).toBe(sameValue)
+  })
+
+  it('should work with factory and inner inject', async () => {
+    @Factory()
+    class TestFactory {
+      create() {
+        return {
+          makeFoo: () => 'foo',
+        }
+      }
+    }
+
+    @Factory()
+    class Test2Factory {
+      create() {
+        return {
+          async makeFoo() {
+            const instance = await container.get(TestFactory)
+            return instance.makeFoo()
+          },
+        }
+      }
+    }
+
+    const instance = await container.get(Test2Factory)
+    const result = await instance.makeFoo()
+    expect(result).toBe('foo')
+  })
+
+  it('should work with factory and custom registry', async () => {
+    const registry = new Registry()
+    const newContainer = new Container(registry)
+
+    @Factory({ registry })
+    class TestFactory {
+      create() {
+        return 'custom-registry-foo'
+      }
+    }
+
+    const value = await newContainer.get(TestFactory)
+    expect(value).toBe('custom-registry-foo')
+  })
+
+  it('should work with factory and invalidation', async () => {
+    @Factory()
+    class TestFactory {
+      create() {
+        return Date.now()
+      }
+    }
+
+    const factory = await container.get(TestFactory)
+    const result1 = factory
+    const inst2 = await container.get(TestFactory)
+    expect(factory).toBe(inst2)
+    const result2 = inst2
+    await container.invalidate(factory)
+    await new Promise((resolve) => setTimeout(resolve, 10))
+    const inst3 = await container.get(TestFactory)
+    expect(factory).not.toBe(inst3)
+    const result3 = inst3
+    expect(result1).not.toBe(result3)
+    expect(result2).not.toBe(result3)
+    expect(result1).toBe(result2)
+  })
+})

package/src/__tests__/injectable.spec.mts

@@ -1,19 +1,26 @@
-import { describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it } from 'vitest'
 import { z } from 'zod/v4'
 
 import { Injectable } from '../decorators/index.mjs'
-import { InjectableScope, InjectableType } from '../enums/index.mjs'
-import { Registry, ServiceLocator, syncInject } from '../index.mjs'
+import {
+  asyncInject,
+  Container,
+  inject,
+  InjectableScope,
+  Registry,
+} from '../index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
-import { getGlobalServiceLocator, inject } from '../injector.mjs'
-import { getInjectableToken, getInjectors } from '../utils/index.mjs'
 
 describe('Injectable decorator', () => {
+  let container: Container
+  beforeEach(() => {
+    container = new Container()
+  })
   it('should work with class', async () => {
     @Injectable()
     class Test {}
 
-    const value = await inject(Test)
+    const value = await container.get(Test)
     expect(value).toBeInstanceOf(Test)
   })
 
@@ -27,7 +34,7 @@ describe('Injectable decorator', () => {
 
     @Injectable()
     class Test2 {
-      fooMaker = inject(Test)
+      fooMaker = asyncInject(Test)
 
       async makeFoo() {
         const fooMaker = await this.fooMaker
@@ -35,106 +42,46 @@ describe('Injectable decorator', () => {
       }
     }
 
-    const value = await inject(Test2)
+    const value = await container.get(Test2)
     expect(value).toBeInstanceOf(Test2)
     const result = await value.makeFoo()
     expect(result).toBe('foo')
   })
 
-  it('should work with factory', async () => {
-    @Injectable({ type: InjectableType.Factory })
-    class Test {
-      create() {
-        return 'foo'
-      }
-    }
-
-    const value = await inject(Test)
-    expect(value).toBe('foo')
-  })
-  it('should work with request scope', async () => {
-    @Injectable({
-      scope: InjectableScope.Instance,
-      type: InjectableType.Factory,
-    })
-    class Test {
-      create() {
-        return Date.now()
-      }
-    }
-
-    const value = await inject(Test)
-    await new Promise((resolve) => setTimeout(resolve, 10))
-    const value2 = await inject(Test)
-    expect(value).not.toBe(value2)
-  })
-
   it('should work with injection token', async () => {
     const token = InjectionToken.create('Test')
 
     @Injectable({ token })
     class Test {}
 
-    const value = await inject(token)
+    const value = await container.get(token)
     expect(value).toBeInstanceOf(Test)
   })
 
-  it('should work with factory injection token and schema', async () => {
-    class TestFoo {
-      constructor(public readonly foo: string) {}
-    }
-    const token = InjectionToken.create(
-      TestFoo,
-      z.object({
-        foo: z.string(),
-      }),
-    )
-
-    @Injectable({ token, type: InjectableType.Factory })
-    class Test {
-      create(ctx: any, args: { foo: string }) {
-        return new TestFoo(args.foo)
-      }
-    }
-
-    const value = await inject(token, { foo: 'bar' })
-    const differentValue = await inject(token, { foo: 'baz' })
-    const sameValue = await inject(token, { foo: 'bar' })
-    expect(value).toBeInstanceOf(TestFoo)
-    expect(value.foo).toBe('bar')
-    expect(differentValue).toBeInstanceOf(TestFoo)
-    expect(differentValue.foo).toBe('baz')
-    expect(value).not.toBe(differentValue)
-    expect(value).toBe(sameValue)
-  })
   it('should work with invalidation', async () => {
-    @Injectable()
+    @Injectable({ scope: InjectableScope.Transient })
     class Test {
       value = Date.now()
     }
 
     @Injectable()
     class Test2 {
-      test = inject(Test)
+      test = asyncInject(Test)
 
       async makeFoo() {
         const test = await this.test
         return test.value
       }
     }
-    const identifier = getGlobalServiceLocator().getInstanceIdentifier(
-      getInjectableToken(Test),
-      undefined,
-    )
-    const inst1 = await inject(Test2)
+    const inst1 = await container.get(Test2)
     expect(inst1).toBeInstanceOf(Test2)
     const result1 = await inst1.makeFoo()
-    const inst2 = await inject(Test2)
+    const inst2 = await container.get(Test2)
     expect(inst1).toBe(inst2)
     const result2 = await inst2.makeFoo()
-    await getGlobalServiceLocator().invalidate(identifier)
+    await container.invalidate(inst1)
     await new Promise((resolve) => setTimeout(resolve, 10))
-    const inst3 = await inject(Test2)
+    const inst3 = await container.get(Test2)
     expect(inst1).not.toBe(inst3)
     const result3 = await inst3.makeFoo()
     expect(result1).not.toBe(result3)
@@ -142,7 +89,7 @@ describe('Injectable decorator', () => {
     expect(result1).toBe(result2)
   })
 
-  it('should work with syncInject', async () => {
+  it('should work with inject', async () => {
     @Injectable()
     class Test {
       value = Date.now()
@@ -150,16 +97,16 @@ describe('Injectable decorator', () => {
 
     @Injectable()
     class Test2 {
-      test = syncInject(Test)
+      test = inject(Test)
 
       makeFoo() {
         return this.test.value
       }
     }
-    const inst1 = await inject(Test2)
+    const inst1 = await container.get(Test2)
     expect(inst1).toBeInstanceOf(Test2)
     const result1 = inst1.makeFoo()
-    const inst2 = await inject(Test2)
+    const inst2 = await container.get(Test2)
     expect(inst1).toBe(inst2)
     const result2 = await inst2.makeFoo()
     expect(result1).toBe(result2)
@@ -177,7 +124,7 @@ describe('Injectable decorator', () => {
       constructor(public readonly arg: z.output<typeof schema>) {}
     }
 
-    const value = await inject(token, { foo: 'bar' })
+    const value = await container.get(token, { foo: 'bar' })
     expect(value).toBeInstanceOf(Test)
     // @ts-expect-error It's a test
     expect(value.arg).toEqual({ foo: 'bar' })
@@ -196,16 +143,13 @@ describe('Injectable decorator', () => {
       foo: 'bar',
     })
 
-    const value = await inject(boundToken)
+    const value = await container.get(boundToken)
     expect(value).toBeInstanceOf(Test)
   })
 
-  it('should work with bound injection token', async () => {
+  it('should work with bound injection token and custom registry', async () => {
     const registry = new Registry()
-    const newServiceLocator = new ServiceLocator(registry)
-    const { inject, syncInject } = getInjectors({
-      baseLocator: newServiceLocator,
-    })
+    const newContainer = new Container(registry, console)
     const schema = z.object({
       foo: z.string(),
     })
@@ -219,10 +163,10 @@ describe('Injectable decorator', () => {
 
     @Injectable({ registry })
     class TestOuter {
-      foo = syncInject(boundToken)
+      foo = inject(boundToken)
     }
 
-    const value = await inject(TestOuter)
+    const value = await newContainer.get(TestOuter)
     expect(value).toBeInstanceOf(TestOuter)
     expect(value.foo).toBeInstanceOf(TestInner)
   })