@navios/di 0.1.11 → 0.1.13

package/src/__type-tests__/injectable.spec-d.mts

@@ -286,4 +286,259 @@ test('Injectable types', () => {
       }
     },
   )
+
+  // #1 Injectable w/o decorators enabled in project
+  expectTypeOf(
+    Injectable({
+      token: typedObjectToken,
+    })(
+      class {
+        constructor() {}
+        makeFoo() {
+          return 'foo'
+        }
+      },
+    ),
+  ).toBeConstructibleWith()
+  expectTypeOf(
+    Injectable({
+      type: InjectableType.Factory,
+    })(
+      class {
+        create() {}
+      },
+    ),
+  ).toBeConstructibleWith()
+  expectTypeOf(
+    Injectable({
+      type: InjectableType.Factory,
+    })(
+      // @ts-expect-error should check that the class implements the factory
+      class {},
+    ),
+  ).toBeConstructibleWith()
+
+  // #3 required argument
+  expectTypeOf(
+    Injectable({
+      token: typelessObjectToken,
+    })(
+      class {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      },
+    ),
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #3 it's required in token but optional in class allowed
+  expectTypeOf(
+    Injectable({
+      token: typelessObjectToken,
+    })(
+      class {
+        constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
+      },
+    ),
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #3 optional value but class accepts it
+  expectTypeOf(
+    Injectable({
+      token: typelessOptionalObjectToken,
+    })(
+      class {
+        constructor(public arg: z.infer<typeof simpleOptionalObjectSchema>) {}
+      },
+    ),
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #3 optional value and class accepts it
+  expectTypeOf(
+    Injectable({
+      token: typelessOptionalObjectToken,
+    })(
+      class {
+        constructor(public arg: z.infer<typeof simpleOptionalObjectSchema>) {}
+      },
+    ),
+  ).toBeConstructibleWith(undefined)
+  // #3 compatible schemas
+  expectTypeOf(
+    Injectable({
+      token: typelessOptionalObjectToken,
+    })(
+      class {
+        constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
+      },
+    ),
+  ).toBeConstructibleWith(undefined)
+  // #3 compatible schemas
+  expectTypeOf(
+    Injectable({
+      token: typelessOptionalObjectToken,
+    })(
+      // @ts-expect-error token has optional schema, but Class has required, should fail
+      class {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+      },
+    ),
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+
+  // #3 typed token and required argument
+  expectTypeOf(
+    Injectable({
+      token: typedObjectToken,
+    })(
+      class {
+        constructor(public arg: z.infer<typeof simpleObjectSchema>) {}
+
+        makeFoo() {
+          return this.arg.foo
+        }
+      },
+    ),
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #3 typed token and required argument
+  expectTypeOf(
+    Injectable({
+      token: typedOptionalObjectToken,
+    })(
+      class {
+        constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
+
+        makeFoo() {
+          return this.arg?.foo ?? 'default'
+        }
+      },
+    ),
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #3 should fail if not compatible
+  expectTypeOf(
+    Injectable({
+      token: typedOptionalObjectToken,
+    })(
+      // @ts-expect-error class doesn't implement the token type
+      class {
+        constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
+      },
+    ),
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #3 should fail if not compatible
+  expectTypeOf(
+    Injectable({
+      token: typedOptionalObjectToken,
+    })(
+      // @ts-expect-error class doesn't implement the token type
+      class {
+        constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
+
+        makeFoo() {
+          return this.arg?.foo
+        }
+      },
+    ),
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #3 typed token without schema
+  expectTypeOf(
+    Injectable({
+      token: typedToken,
+    })(
+      class {
+        constructor() {}
+        makeFoo() {
+          return 'foo'
+        }
+      },
+    ),
+  ).toBeConstructibleWith()
+  // #3 typed token without schema fail if not compatible
+  expectTypeOf(
+    Injectable({
+      token: typedToken,
+    })(
+      // @ts-expect-error class doesn't implement the token type
+      class {
+        constructor() {}
+      },
+    ),
+  ).toBeConstructibleWith()
+
+  // #4 factory with typed token
+  expectTypeOf(
+    Injectable({
+      type: InjectableType.Factory,
+      token: typedToken,
+    })(
+      class {
+        constructor() {}
+        create() {
+          return {
+            makeFoo: () => 'foo',
+          }
+        }
+      },
+    ),
+  ).toBeConstructibleWith()
+  // #4 factory with typed token without schema should fail if not compatible
+  expectTypeOf(
+    Injectable({
+      type: InjectableType.Factory,
+      token: typedToken,
+    })(
+      // @ts-expect-error factory doesn't implement the token type
+      class {
+        constructor() {}
+        create(ctx: any, arg: z.infer<typeof simpleObjectSchema>) {
+          return {
+            makeFoo: () => 'foo',
+          }
+        }
+      },
+    ),
+  ).toBeConstructibleWith()
+  // #4 factory with typed token fail if not compatible
+  expectTypeOf(
+    Injectable({
+      type: InjectableType.Factory,
+      token: typedToken,
+    })(
+      // @ts-expect-error class doesn't implement the token type
+      class {
+        constructor() {}
+        create() {
+          return {
+            // makeFoo: () => 'foo',
+          }
+        }
+      },
+    ),
+  ).toBeConstructibleWith()
+  // #4 factory with typed token and schema
+  expectTypeOf(
+    Injectable({
+      type: InjectableType.Factory,
+      token: typedObjectToken,
+    })(
+      class {
+        constructor() {}
+        create(ctx: any, arg: z.infer<typeof simpleObjectSchema>) {
+          return {
+            makeFoo: () => 'foo',
+          }
+        }
+      },
+    ),
+  )
 })

package/src/decorators/injectable.decorator.mts

@@ -29,11 +29,11 @@ export interface InjectableOptions {
 // #1 Simple constructorless class
 export function Injectable(): <T extends ClassType>(
   target: T,
-  context: ClassDecoratorContext,
+  context?: ClassDecoratorContext,
 ) => T
 export function Injectable(options: {
   registry: Registry
-}): <T extends ClassType>(target: T, context: ClassDecoratorContext) => T
+}): <T extends ClassType>(target: T, context?: ClassDecoratorContext) => T
 
 // #2 Factory without arguments
 export function Injectable<R>(options: {
@@ -42,7 +42,7 @@ export function Injectable<R>(options: {
   registry?: Registry
 }): <T extends ClassTypeWithInstance<Factory<R>>>(
   target: T,
-  context: ClassDecoratorContext,
+  context?: ClassDecoratorContext,
 ) => T
 
 // #3 Class with typeless token and schema
@@ -55,17 +55,17 @@ export function Injectable<Type, Schema>(options: {
   ? Type extends undefined
     ? <T extends ClassTypeWithArgument<z.output<Schema>>>( // #3.1.1 Typeless token
         target: T,
-        context: ClassDecoratorContext,
+        context?: ClassDecoratorContext,
       ) => T
     : <T extends ClassTypeWithInstanceAndArgument<Type, z.output<Schema>>>( // #3.1.2 Typed token
         target: T,
-        context: ClassDecoratorContext,
+        context?: ClassDecoratorContext,
       ) => T
   : Schema extends OptionalInjectionTokenSchemaType // #3.2 Check that schema is an optional object or a record
     ? Type extends undefined
       ? <T extends ClassTypeWithOptionalArgument<z.output<Schema>>>( // #3.2.1 Typeless token
           target: T,
-          context: ClassDecoratorContext,
+          context?: ClassDecoratorContext,
         ) => T
       : <
           // #3.2.2 Typed token
@@ -75,12 +75,12 @@ export function Injectable<Type, Schema>(options: {
           >,
         >(
           target: T,
-          context: ClassDecoratorContext,
+          context?: ClassDecoratorContext,
         ) => T
     : Schema extends undefined // #3.3 Check that schema is undefined
       ? <R extends ClassTypeWithInstance<Type>>( // #3.3.1 Token must have a type
           target: R,
-          context: ClassDecoratorContext,
+          context?: ClassDecoratorContext,
         ) => R
       : never // #3.4 Cannot use a token without a type and schema
 
@@ -95,12 +95,12 @@ export function Injectable<R, S>(options: {
   : S extends InjectionTokenSchemaType // #4.2 Check that schema is an object or a record
     ? <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>( // #4.2.1 Token have a schema
         target: T,
-        context: ClassDecoratorContext,
+        context?: ClassDecoratorContext,
       ) => T
     : S extends undefined // #4.3 For a factory without schema
       ? <T extends ClassTypeWithInstance<Factory<R>>>( // #4.3.1 Token without a schema
           target: T,
-          context: ClassDecoratorContext,
+          context?: ClassDecoratorContext,
         ) => T
       : never // #4.4 Cannot use a token without a type and schema
 export function Injectable({
@@ -111,9 +111,12 @@ export function Injectable({
 }: InjectableOptions = {}) {
   return <T extends ClassType>(
     target: T,
-    context: ClassDecoratorContext,
+    context?: ClassDecoratorContext,
   ): T => {
-    if (context.kind !== 'class') {
+    if (
+      (context && context.kind !== 'class') ||
+      (target instanceof Function && !context)
+    ) {
       throw new Error(
         '[ServiceLocator] @Injectable decorator can only be used on classes.',
       )

package/tsup.config.mts

@@ -5,6 +5,7 @@ export default defineConfig({
   outDir: 'lib',
   format: ['esm', 'cjs'],
   clean: true,
+  treeshake: 'smallest',
   sourcemap: true,
   platform: 'node',
   experimentalDts: true,