@navios/di 0.1.7 → 0.1.9

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,13 +1,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 +26,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 +39,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,
@@ -101,7 +124,7 @@ export function Injectable({
         async (ctx, args: any) => {
           const builder = await resolveService(ctx, target)
           if (typeof builder.create !== 'function') {
-            throw new NaviosException(
+            throw new Error(
               `[ServiceLocator] Factory ${target.name} does not implement the create method.`,
             )
           }

package/src/injection-token.mts

@@ -1,15 +1,19 @@
 import type { AnyZodObject } from 'zod'
 
-import { randomUUID } from 'crypto'
-
 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 const Optional = Symbol('Optional')
+export const Required = Symbol('Required')
 export type BaseInjectionTokenSchemaType = AnyZodObject | ZodRecord
 
 export type OptionalInjectionTokenSchemaType =
@@ -23,8 +27,17 @@ export type InjectionTokenSchemaType =
 export class InjectionToken<
   T,
   S extends InjectionTokenSchemaType | unknown = unknown,
+  Required extends boolean = S extends ZodOptional<AnyZodObject>
+    ? false
+    : S extends ZodOptional<ZodRecord>
+      ? false
+      : S extends AnyZodObject
+        ? true
+        : S extends ZodRecord
+          ? true
+          : false,
 > {
-  public id = randomUUID()
+  public id = globalThis.crypto.randomUUID()
   private formattedName: string | null = null
 
   constructor(
@@ -38,7 +51,9 @@ export class InjectionToken<
   static create<T extends ClassType, Schema extends InjectionTokenSchemaType>(
     name: T,
     schema: Schema,
-  ): InjectionToken<InstanceType<T>, Schema>
+  ): Schema['_def']['typeName'] extends 'ZodOptional'
+    ? InjectionToken<InstanceType<T>, Schema, false>
+    : InjectionToken<InstanceType<T>, Schema, true>
   static create<T>(name: string | symbol): InjectionToken<T, undefined>
   static create<T, Schema extends InjectionTokenSchemaType>(
     name: string | any,

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
 }

package/src/resolve-service.mts

@@ -1,5 +1,3 @@
-import { NaviosException } from '@navios/common'
-
 import type { FactoryContext } from './factory-context.mjs'
 import type { ClassType } from './injection-token.mjs'
 
@@ -30,11 +28,11 @@ export async function resolveService<T extends ClassType>(
   }
   if (promises.length > 0) {
     console.error(`[ServiceLocator] ${target.name} has problem with it's definition.
-     
+
      One or more of the dependencies are registered as a InjectableScope.Instance and are used with syncInject.
-     
+
      Please use inject instead of syncInject to load those dependencies.`)
-    throw new NaviosException(
+    throw new Error(
       `[ServiceLocator] Service ${target.name} cannot be instantiated.`,
     )
   }

package/src/service-locator.mts

@@ -450,7 +450,7 @@ export class ServiceLocator {
             : undefined
           const instanceName = self.makeInstanceName(token, validatedArgs)
           dependencies.add(instanceName)
-          return self.getOrThrowInstance(injectionToken, args)
+          return self.getOrThrowInstance(injectionToken, args as any)
         }
         throw new Error(
           `[ServiceLocator]#inject(): Invalid token type: ${typeof token}. Expected a class or an InjectionToken.`,

package/src/utils/get-injectors.mts

@@ -1,4 +1,4 @@
-import type { AnyZodObject, z } from 'zod'
+import type { AnyZodObject, z, ZodType } from 'zod'
 
 import type {
   BaseInjectionTokenSchemaType,
@@ -6,6 +6,7 @@ import type {
   ClassType,
   FactoryInjectionToken,
   InjectionToken,
+  InjectionTokenSchemaType,
   OptionalInjectionTokenSchemaType,
 } from '../injection-token.mjs'
 import type { ServiceLocator } from '../service-locator.mjs'
@@ -15,30 +16,75 @@ import { InjectableTokenMeta } from '../symbols/index.mjs'
 export interface CreateInjectorsOptions {
   baseLocator: ServiceLocator
 }
+type Join<TElements, TSeparator extends string> =
+  TElements extends Readonly<[infer First, ...infer Rest]>
+    ? Rest extends ReadonlyArray<string>
+      ? First extends string
+        ? `${First}${Rest extends [] ? '' : TSeparator}${Join<Rest, TSeparator>}`
+        : never
+      : never
+    : ''
+// credits goes to https://stackoverflow.com/a/50375286
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never
+
+// Converts union to overloaded function
+type UnionToOvlds<U> = UnionToIntersection<
+  U extends any ? (f: U) => void : never
+>
+
+type PopUnion<U> = UnionToOvlds<U> extends (a: infer A) => void ? A : never
+
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true
+
+type UnionToArray<T, A extends unknown[] = []> =
+  IsUnion<T> extends true
+    ? UnionToArray<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]>
+    : [T, ...A]
 
 export interface Injectors {
+  // #1 Simple class
   inject<T extends ClassType>(token: T): Promise<InstanceType<T>>
-  inject<T, S extends BaseInjectionTokenSchemaType>(
+  // #2 Token with required Schema
+  inject<T, S extends InjectionTokenSchemaType>(
     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>
+  // #3 Token with optional Schema
+  inject<T, S extends InjectionTokenSchemaType, R extends boolean>(
+    token: InjectionToken<T, S, R>,
+  ): R extends false
+    ? Promise<T>
+    : S extends ZodType<infer Type>
+      ? `Error: Your token requires args: ${Join<
+          UnionToArray<keyof Type>,
+          ', '
+        >}`
+      : 'Error: Your token requires args'
+  // #4 Token with no Schema
   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 BaseInjectionTokenSchemaType>(
+  syncInject<T, S extends InjectionTokenSchemaType>(
     token: InjectionToken<T, S>,
     args: z.input<S>,
   ): T
-  syncInject<T, S extends OptionalInjectionTokenSchemaType>(
-    token: InjectionToken<T, S>,
-    args?: z.input<S>,
-  ): T
+  // #3 Token with optional Schema
+  syncInject<T, S extends InjectionTokenSchemaType, R extends boolean>(
+    token: InjectionToken<T, S, R>,
+  ): R extends false
+    ? T
+    : S extends ZodType<infer Type>
+      ? `Error: Your token requires args: ${Join<
+          UnionToArray<keyof Type>,
+          ', '
+        >}`
+      : 'Error: Your token requires args'
   syncInject<T>(token: InjectionToken<T, undefined>): T
   syncInject<T>(token: BoundInjectionToken<T, any>): T
   syncInject<T>(token: FactoryInjectionToken<T, any>): T

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "Node18",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*", "tsdown.config.mts"]
+}

package/tsdown.config.mts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: ['src/index.mts'],
+  outDir: 'lib',
+  format: ['esm', 'cjs'],
+  dts: true,
+  clean: true,
+  platform: 'neutral',
+})

package/vitest.config.mts

@@ -0,0 +1,9 @@
+import { defineProject } from 'vitest/config'
+
+export default defineProject({
+  test: {
+    typecheck: {
+      enabled: true,
+    },
+  },
+})