@navios/di 0.1.6 → 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

@@ -1,13 +1,18 @@
 import type { AnyZodObject } from 'zod';
 import { z } from 'zod';
 import { ZodOptional } from 'zod';
+import { ZodRecord } from 'zod';
 
-declare class BoundInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+declare type BaseInjectionTokenSchemaType = AnyZodObject | ZodRecord;
+export { BaseInjectionTokenSchemaType }
+export { BaseInjectionTokenSchemaType as BaseInjectionTokenSchemaType_alias_1 }
+
+declare class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {
     readonly token: InjectionToken<T, S>;
     readonly value: z.input<S>;
     id: string;
     name: string | symbol | ClassType;
-    schema: AnyZodObject | ZodOptional<AnyZodObject>;
+    schema: InjectionTokenSchemaType;
     constructor(token: InjectionToken<T, S>, value: z.input<S>);
     toString(): string;
 }
@@ -36,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;
 }
@@ -89,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 }
@@ -109,14 +122,14 @@ declare interface FactoryContext {
 export { FactoryContext }
 export { FactoryContext as FactoryContext_alias_1 }
 
-declare class FactoryInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+declare class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {
     readonly token: InjectionToken<T, S>;
     readonly factory: () => Promise<z.input<S>>;
     value?: z.input<S>;
     resolved: boolean;
     id: string;
     name: string | symbol | ClassType;
-    schema: AnyZodObject | ZodOptional<AnyZodObject>;
+    schema: InjectionTokenSchemaType;
     constructor(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>);
     resolve(): Promise<z.input<S>>;
     toString(): string;
@@ -149,8 +162,8 @@ export { FactoryTokenNotResolved }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
 
-declare interface FactoryWithArgs<T, A extends AnyZodObject> {
-    create(ctx: any, args: z.output<A>): Promise<T> | T;
+declare interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
+    create(...args: [FactoryContext, z.output<A>]): Promise<T> | T;
 }
 export { FactoryWithArgs }
 export { FactoryWithArgs as FactoryWithArgs_alias_1 }
@@ -187,38 +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 AnyZodObject>(options: {
-    scope?: InjectableScope;
-    type?: InjectableType.Class;
-    token: InjectionToken<undefined, S>;
-}): <T extends ClassTypeWithArgument<z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R, S extends AnyZodObject>(options: {
+declare 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;
+    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<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R, S extends AnyZodObject>(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 & {
-    [InjectableTokenMeta]: InjectionToken<R, S>;
-};
-
-declare function Injectable<R>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    token: InjectionToken<R, undefined>;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<R, undefined>;
-};
+}): 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 }
@@ -264,34 +256,38 @@ declare type InjectionFactory<T = unknown, Args = unknown> = (ctx: FactoryContex
 export { InjectionFactory }
 export { InjectionFactory as InjectionFactory_alias_1 }
 
-declare class InjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown> {
+declare class InjectionToken<T, S extends InjectionTokenSchemaType | unknown = unknown> {
     readonly name: string | symbol | ClassType;
     readonly schema: AnyZodObject | undefined;
     id: `${string}-${string}-${string}-${string}-${string}`;
     private formattedName;
     constructor(name: string | symbol | ClassType, schema: AnyZodObject | undefined);
     static create<T extends ClassType>(name: T): InjectionToken<InstanceType<T>, undefined>;
-    static create<T extends ClassType, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
+    static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
     static create<T>(name: string | symbol): InjectionToken<T, undefined>;
-    static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
-    static bound<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
-    static factory<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
+    static create<T, Schema extends InjectionTokenSchemaType>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
+    static bound<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
+    static factory<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
     static refineType<T>(token: BoundInjectionToken<any, any>): BoundInjectionToken<T, any>;
     toString(): string;
 }
 export { InjectionToken }
 export { InjectionToken as InjectionToken_alias_1 }
 
+declare type InjectionTokenSchemaType = BaseInjectionTokenSchemaType | OptionalInjectionTokenSchemaType;
+export { InjectionTokenSchemaType }
+export { InjectionTokenSchemaType as InjectionTokenSchemaType_alias_1 }
+
 declare interface Injectors {
     inject<T extends ClassType>(token: T): Promise<InstanceType<T>>;
-    inject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
-    inject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): Promise<T>;
+    inject<T, S extends BaseInjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+    inject<T, S extends OptionalInjectionTokenSchemaType>(token: InjectionToken<T, S>, args?: z.input<S>): Promise<T>;
     inject<T>(token: InjectionToken<T, undefined>): Promise<T>;
     inject<T>(token: BoundInjectionToken<T, any>): Promise<T>;
     inject<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
     syncInject<T extends ClassType>(token: T): InstanceType<T>;
-    syncInject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): T;
-    syncInject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): T;
+    syncInject<T, S extends BaseInjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T;
+    syncInject<T, S extends OptionalInjectionTokenSchemaType>(token: InjectionToken<T, S>, args?: z.input<S>): T;
     syncInject<T>(token: InjectionToken<T, undefined>): T;
     syncInject<T>(token: BoundInjectionToken<T, any>): T;
     syncInject<T>(token: FactoryInjectionToken<T, any>): T;
@@ -338,6 +334,10 @@ declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: Fa
 export { makeProxyServiceLocator }
 export { makeProxyServiceLocator as makeProxyServiceLocator_alias_1 }
 
+declare type OptionalInjectionTokenSchemaType = ZodOptional<AnyZodObject> | ZodOptional<ZodRecord>;
+export { OptionalInjectionTokenSchemaType }
+export { OptionalInjectionTokenSchemaType as OptionalInjectionTokenSchemaType_alias_1 }
+
 declare const provideServiceLocator: Injectors['provideServiceLocator'];
 export { provideServiceLocator }
 export { provideServiceLocator as provideServiceLocator_alias_1 }
@@ -387,24 +387,25 @@ declare class ServiceLocator {
     removeInstance<Instance>(token: BoundInjectionToken<Instance, any>): void;
     removeInstance<Instance>(token: FactoryInjectionToken<Instance, any>): void;
     removeInstance<Instance>(token: InjectionToken<Instance, undefined>): void;
-    removeInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): void;
+    removeInstance<Instance, Schema extends BaseInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): void;
+    removeInstance<Instance, Schema extends OptionalInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): void;
     private resolveTokenArgs;
-    getInstanceIdentifier<Instance, Schema extends AnyZodObject>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): string;
-    getInstanceIdentifier<Instance, Schema extends ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): string;
+    getInstanceIdentifier<Instance, Schema extends BaseInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): string;
+    getInstanceIdentifier<Instance, Schema extends OptionalInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): string;
     getInstanceIdentifier<Instance>(token: InjectionToken<Instance, undefined>): string;
     getInstanceIdentifier<Instance>(token: BoundInjectionToken<Instance, any>): string;
     getInstanceIdentifier<Instance>(token: FactoryInjectionToken<Instance, any>): string;
-    getInstance<Instance, Schema extends AnyZodObject>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
-    getInstance<Instance, Schema extends ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance, Schema extends BaseInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance, Schema extends OptionalInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
     getInstance<Instance>(token: InjectionToken<Instance, undefined>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
     getInstance<Instance>(token: BoundInjectionToken<Instance, any>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
     getInstance<Instance>(token: FactoryInjectionToken<Instance, any>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
-    getOrThrowInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<Instance>;
+    getOrThrowInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<Instance>;
     private notifyListeners;
     private createInstance;
     private resolveInstance;
     private createFactoryContext;
-    getSyncInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Instance | null;
+    getSyncInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Instance | null;
     invalidate(service: string, round?: number): Promise<any>;
     ready(): Promise<null>;
     makeInstanceName(token: InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args: any): string;

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

@@ -1,13 +1,18 @@
 import type { AnyZodObject } from 'zod';
 import { z } from 'zod';
 import { ZodOptional } from 'zod';
+import { ZodRecord } from 'zod';
 
-declare class BoundInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+declare type BaseInjectionTokenSchemaType = AnyZodObject | ZodRecord;
+export { BaseInjectionTokenSchemaType }
+export { BaseInjectionTokenSchemaType as BaseInjectionTokenSchemaType_alias_1 }
+
+declare class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {
     readonly token: InjectionToken<T, S>;
     readonly value: z.input<S>;
     id: string;
     name: string | symbol | ClassType;
-    schema: AnyZodObject | ZodOptional<AnyZodObject>;
+    schema: InjectionTokenSchemaType;
     constructor(token: InjectionToken<T, S>, value: z.input<S>);
     toString(): string;
 }
@@ -36,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;
 }
@@ -89,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 }
@@ -109,14 +122,14 @@ declare interface FactoryContext {
 export { FactoryContext }
 export { FactoryContext as FactoryContext_alias_1 }
 
-declare class FactoryInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> {
+declare class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {
     readonly token: InjectionToken<T, S>;
     readonly factory: () => Promise<z.input<S>>;
     value?: z.input<S>;
     resolved: boolean;
     id: string;
     name: string | symbol | ClassType;
-    schema: AnyZodObject | ZodOptional<AnyZodObject>;
+    schema: InjectionTokenSchemaType;
     constructor(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>);
     resolve(): Promise<z.input<S>>;
     toString(): string;
@@ -149,8 +162,8 @@ export { FactoryTokenNotResolved }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
 export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
 
-declare interface FactoryWithArgs<T, A extends AnyZodObject> {
-    create(ctx: any, args: z.output<A>): Promise<T> | T;
+declare interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
+    create(...args: [FactoryContext, z.output<A>]): Promise<T> | T;
 }
 export { FactoryWithArgs }
 export { FactoryWithArgs as FactoryWithArgs_alias_1 }
@@ -187,38 +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 AnyZodObject>(options: {
-    scope?: InjectableScope;
-    type?: InjectableType.Class;
-    token: InjectionToken<undefined, S>;
-}): <T extends ClassTypeWithArgument<z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R, S extends AnyZodObject>(options: {
+declare 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;
+    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<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T;
-
-declare function Injectable<R, S extends AnyZodObject>(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 & {
-    [InjectableTokenMeta]: InjectionToken<R, S>;
-};
-
-declare function Injectable<R>(options: {
-    scope?: InjectableScope;
-    type: InjectableType.Factory;
-    token: InjectionToken<R, undefined>;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<R, undefined>;
-};
+}): 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 }
@@ -264,34 +256,38 @@ declare type InjectionFactory<T = unknown, Args = unknown> = (ctx: FactoryContex
 export { InjectionFactory }
 export { InjectionFactory as InjectionFactory_alias_1 }
 
-declare class InjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown> {
+declare class InjectionToken<T, S extends InjectionTokenSchemaType | unknown = unknown> {
     readonly name: string | symbol | ClassType;
     readonly schema: AnyZodObject | undefined;
     id: `${string}-${string}-${string}-${string}-${string}`;
     private formattedName;
     constructor(name: string | symbol | ClassType, schema: AnyZodObject | undefined);
     static create<T extends ClassType>(name: T): InjectionToken<InstanceType<T>, undefined>;
-    static create<T extends ClassType, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
+    static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
     static create<T>(name: string | symbol): InjectionToken<T, undefined>;
-    static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
-    static bound<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
-    static factory<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
+    static create<T, Schema extends InjectionTokenSchemaType>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
+    static bound<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
+    static factory<T, S extends InjectionTokenSchemaType>(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
     static refineType<T>(token: BoundInjectionToken<any, any>): BoundInjectionToken<T, any>;
     toString(): string;
 }
 export { InjectionToken }
 export { InjectionToken as InjectionToken_alias_1 }
 
+declare type InjectionTokenSchemaType = BaseInjectionTokenSchemaType | OptionalInjectionTokenSchemaType;
+export { InjectionTokenSchemaType }
+export { InjectionTokenSchemaType as InjectionTokenSchemaType_alias_1 }
+
 declare interface Injectors {
     inject<T extends ClassType>(token: T): Promise<InstanceType<T>>;
-    inject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
-    inject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): Promise<T>;
+    inject<T, S extends BaseInjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+    inject<T, S extends OptionalInjectionTokenSchemaType>(token: InjectionToken<T, S>, args?: z.input<S>): Promise<T>;
     inject<T>(token: InjectionToken<T, undefined>): Promise<T>;
     inject<T>(token: BoundInjectionToken<T, any>): Promise<T>;
     inject<T>(token: FactoryInjectionToken<T, any>): Promise<T>;
     syncInject<T extends ClassType>(token: T): InstanceType<T>;
-    syncInject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): T;
-    syncInject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): T;
+    syncInject<T, S extends BaseInjectionTokenSchemaType>(token: InjectionToken<T, S>, args: z.input<S>): T;
+    syncInject<T, S extends OptionalInjectionTokenSchemaType>(token: InjectionToken<T, S>, args?: z.input<S>): T;
     syncInject<T>(token: InjectionToken<T, undefined>): T;
     syncInject<T>(token: BoundInjectionToken<T, any>): T;
     syncInject<T>(token: FactoryInjectionToken<T, any>): T;
@@ -338,6 +334,10 @@ declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: Fa
 export { makeProxyServiceLocator }
 export { makeProxyServiceLocator as makeProxyServiceLocator_alias_1 }
 
+declare type OptionalInjectionTokenSchemaType = ZodOptional<AnyZodObject> | ZodOptional<ZodRecord>;
+export { OptionalInjectionTokenSchemaType }
+export { OptionalInjectionTokenSchemaType as OptionalInjectionTokenSchemaType_alias_1 }
+
 declare const provideServiceLocator: Injectors['provideServiceLocator'];
 export { provideServiceLocator }
 export { provideServiceLocator as provideServiceLocator_alias_1 }
@@ -387,24 +387,25 @@ declare class ServiceLocator {
     removeInstance<Instance>(token: BoundInjectionToken<Instance, any>): void;
     removeInstance<Instance>(token: FactoryInjectionToken<Instance, any>): void;
     removeInstance<Instance>(token: InjectionToken<Instance, undefined>): void;
-    removeInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): void;
+    removeInstance<Instance, Schema extends BaseInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): void;
+    removeInstance<Instance, Schema extends OptionalInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): void;
     private resolveTokenArgs;
-    getInstanceIdentifier<Instance, Schema extends AnyZodObject>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): string;
-    getInstanceIdentifier<Instance, Schema extends ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): string;
+    getInstanceIdentifier<Instance, Schema extends BaseInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): string;
+    getInstanceIdentifier<Instance, Schema extends OptionalInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): string;
     getInstanceIdentifier<Instance>(token: InjectionToken<Instance, undefined>): string;
     getInstanceIdentifier<Instance>(token: BoundInjectionToken<Instance, any>): string;
     getInstanceIdentifier<Instance>(token: FactoryInjectionToken<Instance, any>): string;
-    getInstance<Instance, Schema extends AnyZodObject>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
-    getInstance<Instance, Schema extends ZodOptional<AnyZodObject>>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance, Schema extends BaseInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getInstance<Instance, Schema extends OptionalInjectionTokenSchemaType>(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
     getInstance<Instance>(token: InjectionToken<Instance, undefined>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
     getInstance<Instance>(token: BoundInjectionToken<Instance, any>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
     getInstance<Instance>(token: FactoryInjectionToken<Instance, any>): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
-    getOrThrowInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<Instance>;
+    getOrThrowInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<Instance>;
     private notifyListeners;
     private createInstance;
     private resolveInstance;
     private createFactoryContext;
-    getSyncInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Instance | null;
+    getSyncInstance<Instance, Schema extends InjectionTokenSchemaType | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Instance | null;
     invalidate(service: string, round?: number): Promise<any>;
     ready(): Promise<null>;
     makeInstanceName(token: InjectionToken<any, any> | BoundInjectionToken<any, any> | FactoryInjectionToken<any, any>, args: any): string;

package/dist/index.d.mts

@@ -25,8 +25,13 @@ 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';
 export { InjectionToken } from './_tsup-dts-rollup.mjs';
 export { BoundInjectionToken } from './_tsup-dts-rollup.mjs';
 export { FactoryInjectionToken } from './_tsup-dts-rollup.mjs';

package/dist/index.d.ts

@@ -25,8 +25,13 @@ 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';
 export { InjectionToken } from './_tsup-dts-rollup.js';
 export { BoundInjectionToken } from './_tsup-dts-rollup.js';
 export { FactoryInjectionToken } from './_tsup-dts-rollup.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/di",
-  "version": "0.1.6",
+  "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

@@ -1,14 +1,17 @@
-import type { AnyZodObject } from 'zod'
-
 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'
@@ -25,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
@@ -37,43 +41,62 @@ export function Injectable<R>(options: {
   target: T,
   context: ClassDecoratorContext,
 ) => T
-export function Injectable<S extends AnyZodObject>(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 AnyZodObject>(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
+  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
 
-export function Injectable<R, S extends AnyZodObject>(options: {
+// #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 & { [InjectableTokenMeta]: InjectionToken<R, S> }
-export function Injectable<R>(options: {
-  scope?: InjectableScope
-  type: InjectableType.Factory
-  token: InjectionToken<R, undefined>
-}): <T extends ClassTypeWithInstance<Factory<R>>>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
+}): 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

@@ -2,17 +2,31 @@ import type { AnyZodObject } from 'zod'
 
 import { randomUUID } from 'crypto'
 
-import { z, ZodOptional } from 'zod'
+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
+
+export type OptionalInjectionTokenSchemaType =
+  | ZodOptional<AnyZodObject>
+  | ZodOptional<ZodRecord>
+
+export type InjectionTokenSchemaType =
+  | BaseInjectionTokenSchemaType
+  | OptionalInjectionTokenSchemaType
 
 export class InjectionToken<
   T,
-  S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown,
+  S extends InjectionTokenSchemaType | unknown = unknown,
 > {
   public id = randomUUID()
   private formattedName: string | null = null
@@ -25,12 +39,12 @@ export class InjectionToken<
   static create<T extends ClassType>(
     name: T,
   ): InjectionToken<InstanceType<T>, undefined>
-  static create<
-    T extends ClassType,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject>,
-  >(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>
+  static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(
+    name: T,
+    schema: Schema,
+  ): InjectionToken<InstanceType<T>, Schema>
   static create<T>(name: string | symbol): InjectionToken<T, undefined>
-  static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(
+  static create<T, Schema extends InjectionTokenSchemaType>(
     name: string | any,
     schema: Schema,
   ): InjectionToken<T, Schema>
@@ -39,14 +53,14 @@ export class InjectionToken<
     return new InjectionToken(name, schema)
   }
 
-  static bound<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(
+  static bound<T, S extends InjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     value: z.input<S>,
   ): BoundInjectionToken<T, S> {
     return new BoundInjectionToken(token, value)
   }
 
-  static factory<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(
+  static factory<T, S extends InjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     factory: () => Promise<z.input<S>>,
   ): FactoryInjectionToken<T, S> {
@@ -77,13 +91,10 @@ export class InjectionToken<
   }
 }
 
-export class BoundInjectionToken<
-  T,
-  S extends AnyZodObject | ZodOptional<AnyZodObject>,
-> {
+export class BoundInjectionToken<T, S extends InjectionTokenSchemaType> {
   public id: string
   public name: string | symbol | ClassType
-  public schema: AnyZodObject | ZodOptional<AnyZodObject>
+  public schema: InjectionTokenSchemaType
 
   constructor(
     public readonly token: InjectionToken<T, S>,
@@ -91,7 +102,7 @@ export class BoundInjectionToken<
   ) {
     this.name = token.name
     this.id = token.id
-    this.schema = token.schema as AnyZodObject | ZodOptional<AnyZodObject>
+    this.schema = token.schema as InjectionTokenSchemaType
   }
 
   toString() {
@@ -99,15 +110,12 @@ export class BoundInjectionToken<
   }
 }
 
-export class FactoryInjectionToken<
-  T,
-  S extends AnyZodObject | ZodOptional<AnyZodObject>,
-> {
+export class FactoryInjectionToken<T, S extends InjectionTokenSchemaType> {
   public value?: z.input<S>
   public resolved = false
   public id: string
   public name: string | symbol | ClassType
-  public schema: AnyZodObject | ZodOptional<AnyZodObject>
+  public schema: InjectionTokenSchemaType
 
   constructor(
     public readonly token: InjectionToken<T, S>,
@@ -115,7 +123,7 @@ export class FactoryInjectionToken<
   ) {
     this.name = token.name
     this.id = token.id
-    this.schema = token.schema as AnyZodObject | ZodOptional<AnyZodObject>
+    this.schema = token.schema as InjectionTokenSchemaType
   }
 
   async resolve(): Promise<z.input<S>> {

package/src/interfaces/factory.interface.mts

@@ -1,11 +1,12 @@
-import type { AnyZodObject } from 'zod'
-
 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 AnyZodObject> {
-  create(ctx: any, args: z.output<A>): Promise<T> | T
+export interface FactoryWithArgs<T, A extends InjectionTokenSchemaType> {
+  create(...args: [FactoryContext, z.output<A>]): Promise<T> | T
 }

package/src/service-locator.mts

@@ -3,6 +3,11 @@
 import type { AnyZodObject, z, ZodOptional } from 'zod'
 
 import type { FactoryContext } from './factory-context.mjs'
+import type {
+  BaseInjectionTokenSchemaType,
+  InjectionTokenSchemaType,
+  OptionalInjectionTokenSchemaType,
+} from './injection-token.mjs'
 import type { Registry } from './registry.mjs'
 import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
 
@@ -98,13 +103,15 @@ export class ServiceLocator {
   public removeInstance<Instance>(
     token: InjectionToken<Instance, undefined>,
   ): void
-  public removeInstance<
-    Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject>,
-  >(
+  public removeInstance<Instance, Schema extends BaseInjectionTokenSchemaType>(
     token: InjectionToken<Instance, Schema>,
     args: z.input<Schema>,
   ): void
+  public removeInstance<
+    Instance,
+    Schema extends OptionalInjectionTokenSchemaType,
+  >(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): void
+
   public removeInstance(
     token:
       | InjectionToken<any, any>
@@ -116,18 +123,25 @@ export class ServiceLocator {
     const instanceName = this.getInstanceIdentifier(token, args)
     return this.invalidate(instanceName)
   }
-  private resolveTokenArgs<Instance, Schema extends AnyZodObject>(
+
+  private resolveTokenArgs<
+    Instance,
+    Schema extends BaseInjectionTokenSchemaType,
+  >(
     token: InjectionToken<Instance, Schema>,
     args: z.input<Schema>,
   ): [undefined, z.output<Schema>] | [UnknownError]
-  private resolveTokenArgs<Instance, Schema extends ZodOptional<AnyZodObject>>(
+  private resolveTokenArgs<
+    Instance,
+    Schema extends OptionalInjectionTokenSchemaType,
+  >(
     token: InjectionToken<Instance, Schema>,
     args?: z.input<Schema>,
   ): [undefined, z.output<Schema>] | [UnknownError]
-  private resolveTokenArgs<Instance, Schema extends AnyZodObject>(
+  private resolveTokenArgs<Instance, Schema extends InjectionTokenSchemaType>(
     token: BoundInjectionToken<Instance, Schema>,
   ): [undefined, z.output<Schema>] | [UnknownError]
-  private resolveTokenArgs<Instance, Schema extends AnyZodObject>(
+  private resolveTokenArgs<Instance, Schema extends InjectionTokenSchemaType>(
     token: FactoryInjectionToken<Instance, Schema>,
   ): [undefined, z.output<Schema>] | [FactoryTokenNotResolved | UnknownError]
   private resolveTokenArgs(
@@ -161,13 +175,13 @@ export class ServiceLocator {
     return [undefined, validatedArgs?.data]
   }
 
-  public getInstanceIdentifier<Instance, Schema extends AnyZodObject>(
-    token: InjectionToken<Instance, Schema>,
-    args: z.input<Schema>,
-  ): string
   public getInstanceIdentifier<
     Instance,
-    Schema extends ZodOptional<AnyZodObject>,
+    Schema extends BaseInjectionTokenSchemaType,
+  >(token: InjectionToken<Instance, Schema>, args: z.input<Schema>): string
+  public getInstanceIdentifier<
+    Instance,
+    Schema extends OptionalInjectionTokenSchemaType,
   >(token: InjectionToken<Instance, Schema>, args?: z.input<Schema>): string
   public getInstanceIdentifier<Instance>(
     token: InjectionToken<Instance, undefined>,
@@ -195,11 +209,11 @@ export class ServiceLocator {
     return this.makeInstanceName(token as InjectionToken<any>, realArgs)
   }
 
-  public getInstance<Instance, Schema extends AnyZodObject>(
+  public getInstance<Instance, Schema extends BaseInjectionTokenSchemaType>(
     token: InjectionToken<Instance, Schema>,
     args: z.input<Schema>,
   ): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>
-  public getInstance<Instance, Schema extends ZodOptional<AnyZodObject>>(
+  public getInstance<Instance, Schema extends OptionalInjectionTokenSchemaType>(
     token: InjectionToken<Instance, Schema>,
     args?: z.input<Schema>,
   ): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>
@@ -273,7 +287,7 @@ export class ServiceLocator {
 
   public async getOrThrowInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+    Schema extends InjectionTokenSchemaType | undefined,
   >(
     token: InjectionToken<Instance, Schema>,
     args: Schema extends AnyZodObject
@@ -301,7 +315,7 @@ export class ServiceLocator {
 
   private async createInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+    Schema extends InjectionTokenSchemaType | undefined,
   >(
     instanceName: string,
     token: InjectionToken<Instance, Schema>,
@@ -328,10 +342,10 @@ export class ServiceLocator {
 
   private async resolveInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
-    Args extends Schema extends AnyZodObject
+    Schema extends InjectionTokenSchemaType | undefined,
+    Args extends Schema extends BaseInjectionTokenSchemaType
       ? z.input<Schema>
-      : Schema extends ZodOptional<AnyZodObject>
+      : Schema extends OptionalInjectionTokenSchemaType
         ? z.input<Schema> | undefined
         : undefined,
   >(
@@ -455,7 +469,7 @@ export class ServiceLocator {
 
   public getSyncInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+    Schema extends InjectionTokenSchemaType | undefined,
   >(
     token: InjectionToken<Instance, Schema>,
     args: Schema extends AnyZodObject

package/src/utils/get-injectors.mts

@@ -1,10 +1,12 @@
-import type { AnyZodObject, z, ZodOptional } from 'zod'
+import type { AnyZodObject, z } from 'zod'
 
 import type {
+  BaseInjectionTokenSchemaType,
   BoundInjectionToken,
   ClassType,
   FactoryInjectionToken,
   InjectionToken,
+  OptionalInjectionTokenSchemaType,
 } from '../injection-token.mjs'
 import type { ServiceLocator } from '../service-locator.mjs'
 
@@ -16,11 +18,11 @@ export interface CreateInjectorsOptions {
 
 export interface Injectors {
   inject<T extends ClassType>(token: T): Promise<InstanceType<T>>
-  inject<T, S extends AnyZodObject>(
+  inject<T, S extends BaseInjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     args: z.input<S>,
   ): Promise<T>
-  inject<T, S extends ZodOptional<AnyZodObject>>(
+  inject<T, S extends OptionalInjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     args?: z.input<S>,
   ): Promise<T>
@@ -29,11 +31,11 @@ export interface Injectors {
   inject<T>(token: FactoryInjectionToken<T, any>): Promise<T>
 
   syncInject<T extends ClassType>(token: T): InstanceType<T>
-  syncInject<T, S extends AnyZodObject>(
+  syncInject<T, S extends BaseInjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     args: z.input<S>,
   ): T
-  syncInject<T, S extends ZodOptional<AnyZodObject>>(
+  syncInject<T, S extends OptionalInjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     args?: z.input<S>,
   ): T