@navios/di 0.1.7 → 0.1.8

package/README.md

@@ -1,2 +1,80 @@
 # Navios DI
 
+Navios DI is a library that implements the Dependency Injection pattern. It provides you with basic tools to create and manage your services
+
+## Installation
+
+```bash
+npm install @navios/di
+# or
+yarn add @navios/di
+```
+
+## Simple Usage example
+
+```ts
+import { Injectable, inject, syncInject } from '@navios/di';
+
+@Injectable()
+class GreeterService {
+  getFoo(user: string): string {
+    return `Hello ${user}`;
+  }
+}
+
+@Injectable()
+class UserService {
+  private readonly greeterService = syncInject(GreeterService);
+  
+  greet(user: string): string {
+    return this.greeterService.getFoo(user);
+  }
+}
+
+const userService = await inject(UserService);
+
+console.log(userService.greet('World')); // Hello World
+```
+
+## Usage with Injection Token
+
+```ts
+import { Injectable, inject, syncInject, InjectionToken } from '@navios/di';
+import { z } from 'zod';
+
+const schema = z.object({
+  user: z.string(),
+})
+
+interface GreeterInterface {
+  getFoo(): string;
+}
+
+const token = new InjectionToken.create<GreeterInterface, typeof schema>(
+  Symbol.for('user'),
+  schema,
+)
+
+@Injectable({
+  token,
+})
+class GreeterService {
+  constructor(private readonly config: z.infer<typeof schema>) {}
+
+  getFoo(): string {
+    return `Hello ${this.config.user}`;
+  }
+}
+
+const greetWorld = await inject(token, {
+  user: 'World'
+})
+const BoundGreeterService = InjectionToken.bound(token, {
+  user: 'Earth'
+})
+
+const greetEarth = await inject(BoundGreeterService);
+
+console.log(greetWorld.getFoo()); // Hello World
+console.log(greetEarth.getFoo()); // Hello Earth
+```

package/dist/_tsup-dts-rollup.d.mts

@@ -41,6 +41,14 @@ declare type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
 export { ClassTypeWithInstanceAndArgument }
 export { ClassTypeWithInstanceAndArgument as ClassTypeWithInstanceAndArgument_alias_1 }
 
+declare type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (arg?: Arg) => T;
+export { ClassTypeWithInstanceAndOptionalArgument }
+export { ClassTypeWithInstanceAndOptionalArgument as ClassTypeWithInstanceAndOptionalArgument_alias_1 }
+
+declare type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any;
+export { ClassTypeWithOptionalArgument }
+export { ClassTypeWithOptionalArgument as ClassTypeWithOptionalArgument_alias_1 }
+
 declare interface CreateInjectorsOptions {
     baseLocator: ServiceLocator;
 }
@@ -94,7 +102,7 @@ export { EventsNames }
 export { EventsNames as EventsNames_alias_1 }
 
 declare interface Factory<T> {
-    create(ctx?: any): Promise<T> | T;
+    create(ctx?: FactoryContext): Promise<T> | T;
 }
 export { Factory }
 export { Factory as Factory_alias_1 }
@@ -155,7 +163,7 @@ export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
 
 declare interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
-    create(ctx: any, args: z.output<A>): Promise<T> | T;
+    create(...args: [FactoryContext, z.output<A>]): Promise<T> | T;
 }
 export { FactoryWithArgs }
 export { FactoryWithArgs as FactoryWithArgs_alias_1 }
@@ -192,34 +200,17 @@ declare function Injectable<R>(options: {
     type: InjectableType.Factory;
 }): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T;
 
-declare function Injectable<S extends InjectionTokenSchemaType>(options: {
+declare function Injectable<Type, Schema>(options: {
     scope?: InjectableScope;
     type?: InjectableType.Class;
-    token: InjectionToken<undefined, S>;
-}): <T extends ClassTypeWithArgument<z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
+    token: InjectionToken<Type, Schema>;
+}): Schema extends BaseInjectionTokenSchemaType ? Type extends undefined ? <T extends ClassTypeWithArgument<z.output<Schema>>>(target: T, context: ClassDecoratorContext) => T : <T extends ClassTypeWithInstanceAndArgument<Type, z.output<Schema>>>(target: T, context: ClassDecoratorContext) => T : Schema extends OptionalInjectionTokenSchemaType ? Type extends undefined ? <T extends ClassTypeWithOptionalArgument<z.output<Schema>>>(target: T, context: ClassDecoratorContext) => T : <T extends ClassTypeWithInstanceAndOptionalArgument<Type, z.output<Schema>>>(target: T, context: ClassDecoratorContext) => T : Schema extends undefined ? <R extends ClassTypeWithInstance<Type>>(target: R, context: ClassDecoratorContext) => R : never;
 
-declare function Injectable<R, S extends InjectionTokenSchemaType>(options: {
-    scope?: InjectableScope;
-    type?: InjectableType.Class;
-    token: InjectionToken<R, S>;
-}): <T extends ClassTypeWithInstanceAndArgument<R, z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R, S extends InjectionTokenSchemaType>(options: {
+declare function Injectable<R, S>(options: {
     scope?: InjectableScope;
     type: InjectableType.Factory;
     token: InjectionToken<R, S>;
-}): <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    token: InjectionToken<R, undefined>;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T;
+}): R extends undefined ? never : S extends InjectionTokenSchemaType ? <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(target: T, context: ClassDecoratorContext) => T : S extends undefined ? <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T : never;
 export { Injectable }
 export { Injectable as Injectable_alias_1 }
 export { Injectable as Injectable_alias_2 }

package/dist/_tsup-dts-rollup.d.ts

@@ -41,6 +41,14 @@ declare type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
 export { ClassTypeWithInstanceAndArgument }
 export { ClassTypeWithInstanceAndArgument as ClassTypeWithInstanceAndArgument_alias_1 }
 
+declare type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (arg?: Arg) => T;
+export { ClassTypeWithInstanceAndOptionalArgument }
+export { ClassTypeWithInstanceAndOptionalArgument as ClassTypeWithInstanceAndOptionalArgument_alias_1 }
+
+declare type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any;
+export { ClassTypeWithOptionalArgument }
+export { ClassTypeWithOptionalArgument as ClassTypeWithOptionalArgument_alias_1 }
+
 declare interface CreateInjectorsOptions {
     baseLocator: ServiceLocator;
 }
@@ -94,7 +102,7 @@ export { EventsNames }
 export { EventsNames as EventsNames_alias_1 }
 
 declare interface Factory<T> {
-    create(ctx?: any): Promise<T> | T;
+    create(ctx?: FactoryContext): Promise<T> | T;
 }
 export { Factory }
 export { Factory as Factory_alias_1 }
@@ -155,7 +163,7 @@ export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
 
 declare interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
-    create(ctx: any, args: z.output<A>): Promise<T> | T;
+    create(...args: [FactoryContext, z.output<A>]): Promise<T> | T;
 }
 export { FactoryWithArgs }
 export { FactoryWithArgs as FactoryWithArgs_alias_1 }
@@ -192,34 +200,17 @@ declare function Injectable<R>(options: {
     type: InjectableType.Factory;
 }): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T;
 
-declare function Injectable<S extends InjectionTokenSchemaType>(options: {
+declare function Injectable<Type, Schema>(options: {
     scope?: InjectableScope;
     type?: InjectableType.Class;
-    token: InjectionToken<undefined, S>;
-}): <T extends ClassTypeWithArgument<z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
+    token: InjectionToken<Type, Schema>;
+}): Schema extends BaseInjectionTokenSchemaType ? Type extends undefined ? <T extends ClassTypeWithArgument<z.output<Schema>>>(target: T, context: ClassDecoratorContext) => T : <T extends ClassTypeWithInstanceAndArgument<Type, z.output<Schema>>>(target: T, context: ClassDecoratorContext) => T : Schema extends OptionalInjectionTokenSchemaType ? Type extends undefined ? <T extends ClassTypeWithOptionalArgument<z.output<Schema>>>(target: T, context: ClassDecoratorContext) => T : <T extends ClassTypeWithInstanceAndOptionalArgument<Type, z.output<Schema>>>(target: T, context: ClassDecoratorContext) => T : Schema extends undefined ? <R extends ClassTypeWithInstance<Type>>(target: R, context: ClassDecoratorContext) => R : never;
 
-declare function Injectable<R, S extends InjectionTokenSchemaType>(options: {
-    scope?: InjectableScope;
-    type?: InjectableType.Class;
-    token: InjectionToken<R, S>;
-}): <T extends ClassTypeWithInstanceAndArgument<R, z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R, S extends InjectionTokenSchemaType>(options: {
+declare function Injectable<R, S>(options: {
     scope?: InjectableScope;
     type: InjectableType.Factory;
     token: InjectionToken<R, S>;
-}): <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    token: InjectionToken<R, undefined>;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T;
+}): R extends undefined ? never : S extends InjectionTokenSchemaType ? <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(target: T, context: ClassDecoratorContext) => T : S extends undefined ? <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T : never;
 export { Injectable }
 export { Injectable as Injectable_alias_1 }
 export { Injectable as Injectable_alias_2 }

package/dist/index.d.mts

@@ -25,8 +25,10 @@ export { EventEmitter_alias_1 as EventEmitter } from './_tsup-dts-rollup.mjs';
 export { FactoryContext_alias_1 as FactoryContext } from './_tsup-dts-rollup.mjs';
 export { ClassType } from './_tsup-dts-rollup.mjs';
 export { ClassTypeWithArgument } from './_tsup-dts-rollup.mjs';
+export { ClassTypeWithOptionalArgument } from './_tsup-dts-rollup.mjs';
 export { ClassTypeWithInstance } from './_tsup-dts-rollup.mjs';
 export { ClassTypeWithInstanceAndArgument } from './_tsup-dts-rollup.mjs';
+export { ClassTypeWithInstanceAndOptionalArgument } from './_tsup-dts-rollup.mjs';
 export { BaseInjectionTokenSchemaType } from './_tsup-dts-rollup.mjs';
 export { OptionalInjectionTokenSchemaType } from './_tsup-dts-rollup.mjs';
 export { InjectionTokenSchemaType } from './_tsup-dts-rollup.mjs';

package/dist/index.d.ts

@@ -25,8 +25,10 @@ export { EventEmitter_alias_1 as EventEmitter } from './_tsup-dts-rollup.js';
 export { FactoryContext_alias_1 as FactoryContext } from './_tsup-dts-rollup.js';
 export { ClassType } from './_tsup-dts-rollup.js';
 export { ClassTypeWithArgument } from './_tsup-dts-rollup.js';
+export { ClassTypeWithOptionalArgument } from './_tsup-dts-rollup.js';
 export { ClassTypeWithInstance } from './_tsup-dts-rollup.js';
 export { ClassTypeWithInstanceAndArgument } from './_tsup-dts-rollup.js';
+export { ClassTypeWithInstanceAndOptionalArgument } from './_tsup-dts-rollup.js';
 export { BaseInjectionTokenSchemaType } from './_tsup-dts-rollup.js';
 export { OptionalInjectionTokenSchemaType } from './_tsup-dts-rollup.js';
 export { InjectionTokenSchemaType } from './_tsup-dts-rollup.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/di",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"

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

@@ -0,0 +1,289 @@
+import { expectTypeOf, test } from 'vitest'
+import { z } from 'zod'
+
+import { Injectable } from '../decorators/index.mjs'
+import { InjectableType } from '../enums/index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+
+interface FooService {
+  makeFoo(): string
+}
+
+const simpleObjectSchema = z.object({
+  foo: z.string(),
+})
+const simpleOptionalObjectSchema = z
+  .object({
+    foo: z.string(),
+  })
+  .optional()
+const simpleRecordSchema = z.record(z.string())
+const simpleOptionalRecordSchema = z.record(z.string()).optional()
+
+const typelessObjectToken = InjectionToken.create(
+  Symbol.for('Typeless object token'),
+  simpleObjectSchema,
+)
+const typelessOptionalObjectToken = InjectionToken.create(
+  Symbol.for('Typeless optional object token'),
+  simpleOptionalObjectSchema,
+)
+const typelessRecordToken = InjectionToken.create(
+  Symbol.for('Typeless record token'),
+  simpleRecordSchema,
+)
+const typelessOptionalRecordToken = InjectionToken.create(
+  Symbol.for('Typeless optional record token'),
+  simpleOptionalRecordSchema,
+)
+
+const typedObjectToken = InjectionToken.create<
+  FooService,
+  typeof simpleObjectSchema
+>(Symbol.for('Typed object token'), simpleObjectSchema)
+const typedOptionalObjectToken = InjectionToken.create<
+  FooService,
+  typeof simpleOptionalObjectSchema
+>(Symbol.for('Typed optional object token'), simpleOptionalObjectSchema)
+const typedRecordToken = InjectionToken.create<
+  FooService,
+  typeof simpleRecordSchema
+>(Symbol.for('Typed record token'), simpleRecordSchema)
+const typedOptionalRecordToken = InjectionToken.create<
+  FooService,
+  typeof simpleOptionalRecordSchema
+>(Symbol.for('Typed optional record token'), simpleOptionalRecordSchema)
+
+const typedToken = InjectionToken.create<FooService>(Symbol.for('Typed token'))
+
+test('Injectable types', () => {
+  // #1
+  expectTypeOf(
+    @Injectable()
+    class {},
+  ).toBeConstructibleWith()
+  // #2
+  expectTypeOf(
+    @Injectable({
+      type: InjectableType.Factory,
+    })
+    class {
+      create() {}
+    },
+  ).toBeConstructibleWith()
+  expectTypeOf(
+    // @ts-expect-error should check that the class implements the factory
+    @Injectable({
+      type: InjectableType.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(
+    // @ts-expect-error token has optional schema, but Class has required, should fail
+    @Injectable({
+      token: typelessOptionalObjectToken,
+    })
+    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(
+    // @ts-expect-error class doesn't implement the token type
+    @Injectable({
+      token: typedOptionalObjectToken,
+    })
+    class {
+      constructor(public arg?: z.infer<typeof simpleObjectSchema>) {}
+    },
+  ).toBeConstructibleWith({
+    foo: 'something',
+  })
+  // #3 should fail if not compatible
+  expectTypeOf(
+    // @ts-expect-error class doesn't implement the token type
+    @Injectable({
+      token: typedOptionalObjectToken,
+    })
+    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(
+    // @ts-expect-error class doesn't implement the token type
+    @Injectable({
+      token: typedToken,
+    })
+    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(
+    // @ts-expect-error factory doesn't implement the token type
+    @Injectable({
+      type: InjectableType.Factory,
+      token: typedToken,
+    })
+    class {
+      constructor() {}
+      create(ctx: any, arg: z.infer<typeof simpleObjectSchema>) {
+        return {
+          makeFoo: () => 'foo',
+        }
+      }
+    },
+  ).toBeConstructibleWith()
+  // #4 factory with typed token fail if not compatible
+  expectTypeOf(
+    // @ts-expect-error class doesn't implement the token type
+    @Injectable({
+      type: InjectableType.Factory,
+      token: typedToken,
+    })
+    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

@@ -3,11 +3,15 @@ import { NaviosException } from '@navios/common'
 import { z } from 'zod'
 
 import type {
+  BaseInjectionTokenSchemaType,
   ClassType,
   ClassTypeWithArgument,
   ClassTypeWithInstance,
   ClassTypeWithInstanceAndArgument,
+  ClassTypeWithInstanceAndOptionalArgument,
+  ClassTypeWithOptionalArgument,
   InjectionTokenSchemaType,
+  OptionalInjectionTokenSchemaType,
 } from '../injection-token.mjs'
 import type { Factory, FactoryWithArgs } from '../interfaces/index.mjs'
 import type { Registry } from '../registry.mjs'
@@ -24,11 +28,12 @@ export interface InjectableOptions {
   token?: InjectionToken<any, any>
   registry?: Registry
 }
-
+// #1 Simple constructorless class
 export function Injectable(): <T extends ClassType>(
   target: T,
   context: ClassDecoratorContext,
 ) => T
+// #2 Factory class without arguments
 export function Injectable<R>(options: {
   scope?: InjectableScope
   type: InjectableType.Factory
@@ -36,42 +41,62 @@ export function Injectable<R>(options: {
   target: T,
   context: ClassDecoratorContext,
 ) => T
-export function Injectable<S extends InjectionTokenSchemaType>(options: {
-  scope?: InjectableScope
-  type?: InjectableType.Class
-  token: InjectionToken<undefined, S>
-}): <T extends ClassTypeWithArgument<z.output<S>>>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T
-export function Injectable<R, S extends InjectionTokenSchemaType>(options: {
+
+// #3 Class with typeless token and schema
+export function Injectable<Type, Schema>(options: {
   scope?: InjectableScope
   type?: InjectableType.Class
-  token: InjectionToken<R, S>
-}): <T extends ClassTypeWithInstanceAndArgument<R, z.output<S>>>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T
-export function Injectable<T extends ClassType>(options: {
-  scope?: InjectableScope
-  token: InjectionToken<T, undefined>
-}): (target: T, context: ClassDecoratorContext) => T
-export function Injectable<R, S extends InjectionTokenSchemaType>(options: {
+  token: InjectionToken<Type, Schema>
+}): Schema extends BaseInjectionTokenSchemaType
+  ? Type extends undefined
+    ? <T extends ClassTypeWithArgument<z.output<Schema>>>(
+        target: T,
+        context: ClassDecoratorContext,
+      ) => T
+    : <T extends ClassTypeWithInstanceAndArgument<Type, z.output<Schema>>>(
+        target: T,
+        context: ClassDecoratorContext,
+      ) => T
+  : Schema extends OptionalInjectionTokenSchemaType
+    ? Type extends undefined
+      ? <T extends ClassTypeWithOptionalArgument<z.output<Schema>>>(
+          target: T,
+          context: ClassDecoratorContext,
+        ) => T
+      : <
+          T extends ClassTypeWithInstanceAndOptionalArgument<
+            Type,
+            z.output<Schema>
+          >,
+        >(
+          target: T,
+          context: ClassDecoratorContext,
+        ) => T
+    : Schema extends undefined
+      ? <R extends ClassTypeWithInstance<Type>>(
+          target: R,
+          context: ClassDecoratorContext,
+        ) => R
+      : never
+
+// #4 Factory with typed token
+export function Injectable<R, S>(options: {
   scope?: InjectableScope
   type: InjectableType.Factory
   token: InjectionToken<R, S>
-}): <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T
-export function Injectable<R>(options: {
-  scope?: InjectableScope
-  type: InjectableType.Factory
-  token: InjectionToken<R, undefined>
-}): <T extends ClassTypeWithInstance<Factory<R>>>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T
+}): R extends undefined
+  ? never
+  : S extends InjectionTokenSchemaType
+    ? <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(
+        target: T,
+        context: ClassDecoratorContext,
+      ) => T
+    : S extends undefined
+      ? <T extends ClassTypeWithInstance<Factory<R>>>(
+          target: T,
+          context: ClassDecoratorContext,
+        ) => T
+      : never
 export function Injectable({
   scope = InjectableScope.Singleton,
   type = InjectableType.Class,

package/src/injection-token.mts

@@ -6,9 +6,13 @@ import { z, ZodOptional, ZodRecord } from 'zod'
 
 export type ClassType = new (...args: any[]) => any
 export type ClassTypeWithArgument<Arg> = new (arg: Arg) => any
+export type ClassTypeWithOptionalArgument<Arg> = new (arg?: Arg) => any
 
 export type ClassTypeWithInstance<T> = new (...args: any[]) => T
 export type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T
+export type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (
+  arg?: Arg,
+) => T
 
 export type BaseInjectionTokenSchemaType = AnyZodObject | ZodRecord
 

package/src/interfaces/factory.interface.mts

@@ -1,11 +1,12 @@
 import { z } from 'zod'
 
+import type { FactoryContext } from '../factory-context.mjs'
 import type { InjectionTokenSchemaType } from '../injection-token.mjs'
 
 export interface Factory<T> {
-  create(ctx?: any): Promise<T> | T
+  create(ctx?: FactoryContext): Promise<T> | T
 }
 
 export interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
-  create(ctx: any, args: z.output<A>): Promise<T> | T
+  create(...args: [FactoryContext, z.output<A>]): Promise<T> | T
 }