@navios/di 0.1.12 → 0.2.0

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

@@ -1,5 +1,5 @@
 import { expectTypeOf, test } from 'vitest'
-import { z } from 'zod'
+import { z } from 'zod/v4'
 
 import { Injectable } from '../decorators/index.mjs'
 import { InjectableType } from '../enums/index.mjs'
@@ -17,8 +17,8 @@ const simpleOptionalObjectSchema = z
     foo: z.string(),
   })
   .optional()
-const simpleRecordSchema = z.record(z.string())
-const simpleOptionalRecordSchema = z.record(z.string()).optional()
+const simpleRecordSchema = z.record(z.string(), z.string())
+const simpleOptionalRecordSchema = z.record(z.string(), z.string()).optional()
 
 const typelessObjectToken = InjectionToken.create(
   Symbol.for('Typeless object token'),
@@ -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

@@ -1,4 +1,4 @@
-import { z } from 'zod'
+import { z } from 'zod/v4'
 
 import type {
   BaseInjectionTokenSchemaType,
@@ -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/src/injection-token.mts

@@ -1,6 +1,4 @@
-import type { AnyZodObject } from 'zod'
-
-import { z, ZodOptional, ZodRecord } from 'zod'
+import type { z, ZodObject, ZodOptional, ZodRecord } from 'zod/v4'
 
 export type ClassType = new (...args: any[]) => any
 export type ClassTypeWithArgument<Arg> = new (arg: Arg) => any
@@ -12,10 +10,10 @@ export type ClassTypeWithInstanceAndOptionalArgument<T, Arg> = new (
   arg?: Arg,
 ) => T
 
-export type BaseInjectionTokenSchemaType = AnyZodObject | ZodRecord
+export type BaseInjectionTokenSchemaType = ZodObject<any> | ZodRecord
 
 export type OptionalInjectionTokenSchemaType =
-  | ZodOptional<AnyZodObject>
+  | ZodOptional<ZodObject<any>>
   | ZodOptional<ZodRecord>
 
 export type InjectionTokenSchemaType =
@@ -25,11 +23,11 @@ export type InjectionTokenSchemaType =
 export class InjectionToken<
   T,
   S extends InjectionTokenSchemaType | unknown = unknown,
-  Required extends boolean = S extends ZodOptional<AnyZodObject>
+  Required extends boolean = S extends ZodOptional<ZodObject<any>>
     ? false
     : S extends ZodOptional<ZodRecord>
       ? false
-      : S extends AnyZodObject
+      : S extends ZodObject<any>
         ? true
         : S extends ZodRecord
           ? true
@@ -40,7 +38,7 @@ export class InjectionToken<
 
   constructor(
     public readonly name: string | symbol | ClassType,
-    public readonly schema: AnyZodObject | undefined,
+    public readonly schema: ZodObject<any> | undefined,
   ) {}
 
   static create<T extends ClassType>(
@@ -49,7 +47,7 @@ export class InjectionToken<
   static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(
     name: T,
     schema: Schema,
-  ): Schema['_def']['typeName'] extends 'ZodOptional'
+  ): Schema['_def']['type'] extends 'ZodOptional'
     ? InjectionToken<InstanceType<T>, Schema, false>
     : InjectionToken<InstanceType<T>, Schema, true>
   static create<T>(name: string | symbol): InjectionToken<T, undefined>

package/src/interfaces/factory.interface.mts

@@ -1,4 +1,4 @@
-import { z } from 'zod'
+import { z } from 'zod/v4'
 
 import type { FactoryContext } from '../factory-context.mjs'
 import type { InjectionTokenSchemaType } from '../injection-token.mjs'

package/src/proxy-service-locator.mts

@@ -1,4 +1,4 @@
-import type { AnyZodObject, z, ZodOptional } from 'zod'
+import type { z, ZodObject, ZodOptional } from 'zod/v4'
 
 import type { FactoryContext } from './factory-context.mjs'
 import type {
@@ -39,12 +39,12 @@ export class ProxyServiceLocator implements ServiceLocator {
   }
   public getOrThrowInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+    Schema extends ZodObject<any> | ZodOptional<ZodObject<any>> | undefined,
   >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject
+    args: Schema extends ZodObject<any>
       ? z.input<Schema>
-      : Schema extends ZodOptional<AnyZodObject>
+      : Schema extends ZodOptional<ZodObject<any>>
         ? z.input<Schema> | undefined
         : undefined,
   ): Promise<Instance> {
@@ -52,16 +52,16 @@ export class ProxyServiceLocator implements ServiceLocator {
   }
   public getSyncInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+    Schema extends ZodObject<any> | ZodOptional<ZodObject<any>> | undefined,
   >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject
+    args: Schema extends ZodObject<any>
       ? z.input<Schema>
-      : Schema extends ZodOptional<AnyZodObject>
+      : Schema extends ZodOptional<ZodObject<any>>
         ? z.input<Schema> | undefined
         : undefined,
   ): Instance | null {
-    return this.serviceLocator.getSyncInstance(token, args)
+    return this.serviceLocator.getSyncInstance<Instance, Schema>(token, args)
   }
   invalidate(service: string, round?: number): Promise<any> {
     return this.serviceLocator.invalidate(service, round)

package/src/registry.mts

@@ -1,6 +1,4 @@
-import type { AnyZodObject } from 'zod'
-
-import { z } from 'zod'
+import type { z, ZodObject } from 'zod/v4'
 
 import type { FactoryContext } from './factory-context.mjs'
 import type { InjectionToken } from './injection-token.mjs'
@@ -17,7 +15,7 @@ export type FactoryRecord<Instance = any, Schema = any> = {
   originalToken: InjectionToken<Instance, Schema>
   factory: InjectionFactory<
     Instance,
-    Schema extends AnyZodObject ? z.input<Schema> : unknown
+    Schema extends ZodObject<any> ? z.input<Schema> : unknown
   >
 }
 

package/src/service-locator.mts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
-import type { AnyZodObject, z, ZodOptional } from 'zod'
+import type { z, ZodObject, ZodOptional } from 'zod/v4'
 
 import type { FactoryContext } from './factory-context.mjs'
 import type {
@@ -62,7 +62,7 @@ export class ServiceLocator {
   ): void
   public storeInstance<
     Instance,
-    Schema extends AnyZodObject | ZodOptional<AnyZodObject>,
+    Schema extends ZodObject<any> | ZodOptional<ZodObject<any>>,
   >(
     instance: Instance,
     token: InjectionToken<Instance, Schema>,
@@ -292,9 +292,9 @@ export class ServiceLocator {
     Schema extends InjectionTokenSchemaType | undefined,
   >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject
+    args: Schema extends ZodObject<any>
       ? z.input<Schema>
-      : Schema extends ZodOptional<AnyZodObject>
+      : Schema extends ZodOptional<ZodObject<any>>
         ? z.input<Schema> | undefined
         : undefined,
   ): Promise<Instance> {
@@ -321,9 +321,9 @@ export class ServiceLocator {
   >(
     instanceName: string,
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject
+    args: Schema extends ZodObject<any>
       ? z.input<Schema>
-      : Schema extends ZodOptional<AnyZodObject>
+      : Schema extends ZodOptional<ZodObject<any>>
         ? z.input<Schema> | undefined
         : undefined,
   ): Promise<[undefined, Instance] | [FactoryNotFound | UnknownError]> {
@@ -481,9 +481,9 @@ export class ServiceLocator {
     Schema extends InjectionTokenSchemaType | undefined,
   >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject
+    args: Schema extends ZodObject<any>
       ? z.input<Schema>
-      : Schema extends ZodOptional<AnyZodObject>
+      : Schema extends ZodOptional<ZodObject<any>>
         ? z.input<Schema> | undefined
         : undefined,
   ): Instance | null {

package/src/utils/get-injectors.mts

@@ -1,4 +1,4 @@
-import type { AnyZodObject, z, ZodType } from 'zod'
+import type { z, ZodObject, ZodType } from 'zod/v4'
 
 import type {
   BoundInjectionToken,
@@ -150,8 +150,8 @@ export function getInjectors({ baseLocator }: CreateInjectorsOptions) {
       | InjectionToken<T>
       | BoundInjectionToken<T, any>
       | FactoryInjectionToken<T, any>,
-    S extends AnyZodObject | unknown = Token['schema'],
-  >(token: Token, args?: S extends AnyZodObject ? z.input<S> : never): T {
+    S extends ZodObject<any> | unknown = Token['schema'],
+  >(token: Token, args?: S extends ZodObject<any> ? z.input<S> : never): T {
     // @ts-expect-error In case we have a class
     const realToken = token[InjectableTokenMeta] ?? token