@navios/di 0.1.4 → 0.1.6

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

@@ -24,10 +24,18 @@ declare type ClassType = new (...args: any[]) => any;
 export { ClassType }
 export { ClassType as ClassType_alias_1 }
 
+declare type ClassTypeWithArgument<Arg> = new (arg: Arg) => any;
+export { ClassTypeWithArgument }
+export { ClassTypeWithArgument as ClassTypeWithArgument_alias_1 }
+
 declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
 export { ClassTypeWithInstance }
 export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
 
+declare type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
+export { ClassTypeWithInstanceAndArgument }
+export { ClassTypeWithInstanceAndArgument as ClassTypeWithInstanceAndArgument_alias_1 }
+
 declare interface CreateInjectorsOptions {
     baseLocator: ServiceLocator;
 }
@@ -172,23 +180,29 @@ declare const inject: Injectors['inject'];
 export { inject }
 export { inject as inject_alias_1 }
 
-declare function Injectable(): <T extends ClassType>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
-
-declare function Injectable<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
+declare function Injectable(): <T extends ClassType>(target: T, context: ClassDecoratorContext) => T;
 
 declare function Injectable<R>(options: {
     scope?: InjectableScope;
     type: InjectableType.Factory;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<R, undefined>;
-};
+}): <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: {
+    scope?: InjectableScope;
+    type?: InjectableType.Class;
+    token: InjectionToken<R, S>;
+}): <T extends ClassTypeWithInstanceAndArgument<R, z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
+
+declare function Injectable<T extends ClassType>(options: {
+    scope?: InjectableScope;
+    token: InjectionToken<T, undefined>;
+}): (target: T, context: ClassDecoratorContext) => T;
 
 declare function Injectable<R, S extends AnyZodObject>(options: {
     scope?: InjectableScope;

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

@@ -24,10 +24,18 @@ declare type ClassType = new (...args: any[]) => any;
 export { ClassType }
 export { ClassType as ClassType_alias_1 }
 
+declare type ClassTypeWithArgument<Arg> = new (arg: Arg) => any;
+export { ClassTypeWithArgument }
+export { ClassTypeWithArgument as ClassTypeWithArgument_alias_1 }
+
 declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
 export { ClassTypeWithInstance }
 export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
 
+declare type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T;
+export { ClassTypeWithInstanceAndArgument }
+export { ClassTypeWithInstanceAndArgument as ClassTypeWithInstanceAndArgument_alias_1 }
+
 declare interface CreateInjectorsOptions {
     baseLocator: ServiceLocator;
 }
@@ -172,23 +180,29 @@ declare const inject: Injectors['inject'];
 export { inject }
 export { inject as inject_alias_1 }
 
-declare function Injectable(): <T extends ClassType>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
-
-declare function Injectable<T extends ClassType>(options: {
-    scope?: InjectableScope;
-    token: InjectionToken<T, undefined>;
-}): (target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>;
-};
+declare function Injectable(): <T extends ClassType>(target: T, context: ClassDecoratorContext) => T;
 
 declare function Injectable<R>(options: {
     scope?: InjectableScope;
     type: InjectableType.Factory;
-}): <T extends ClassTypeWithInstance<Factory<R>>>(target: T, context: ClassDecoratorContext) => T & {
-    [InjectableTokenMeta]: InjectionToken<R, undefined>;
-};
+}): <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: {
+    scope?: InjectableScope;
+    type?: InjectableType.Class;
+    token: InjectionToken<R, S>;
+}): <T extends ClassTypeWithInstanceAndArgument<R, z.output<S>>>(target: T, context: ClassDecoratorContext) => T;
+
+declare function Injectable<T extends ClassType>(options: {
+    scope?: InjectableScope;
+    token: InjectionToken<T, undefined>;
+}): (target: T, context: ClassDecoratorContext) => T;
 
 declare function Injectable<R, S extends AnyZodObject>(options: {
     scope?: InjectableScope;

package/dist/index.d.mts

@@ -24,7 +24,9 @@ export { EventEmitterInterface_alias_1 as EventEmitterInterface } from './_tsup-
 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 { ClassTypeWithInstance } from './_tsup-dts-rollup.mjs';
+export { ClassTypeWithInstanceAndArgument } 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

@@ -24,7 +24,9 @@ export { EventEmitterInterface_alias_1 as EventEmitterInterface } from './_tsup-
 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 { ClassTypeWithInstance } from './_tsup-dts-rollup.js';
+export { ClassTypeWithInstanceAndArgument } 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/dist/index.js

@@ -58,6 +58,7 @@ module.exports = __toCommonJS(src_exports);
 
 // packages/di/src/decorators/injectable.decorator.mts
 var import_common2 = require("@navios/common");
+var import_zod3 = require("zod");
 
 // packages/di/src/enums/injectable-scope.enum.mts
 var InjectableScope = /* @__PURE__ */ ((InjectableScope3) => {
@@ -352,7 +353,7 @@ function Injectable({
     if (type === "Class" /* Class */) {
       registry.set(
         injectableToken,
-        async (ctx) => resolveService(ctx, target),
+        async (ctx, args) => resolveService(ctx, target, [args]),
         scope
       );
     } else if (type === "Factory" /* Factory */) {
@@ -445,7 +446,7 @@ var UnknownError = class extends Error {
 };
 
 // packages/di/src/interfaces/factory.interface.mts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // packages/di/src/event-emitter.mts
 var EventEmitter = class {

package/dist/index.mjs

@@ -1,5 +1,6 @@
 // packages/di/src/decorators/injectable.decorator.mts
 import { NaviosException as NaviosException2 } from "@navios/common";
+import "zod";
 
 // packages/di/src/enums/injectable-scope.enum.mts
 var InjectableScope = /* @__PURE__ */ ((InjectableScope3) => {
@@ -294,7 +295,7 @@ function Injectable({
     if (type === "Class" /* Class */) {
       registry.set(
         injectableToken,
-        async (ctx) => resolveService(ctx, target),
+        async (ctx, args) => resolveService(ctx, target, [args]),
         scope
       );
     } else if (type === "Factory" /* Factory */) {

package/package.json

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

package/src/__tests__/injectable.spec.mts

@@ -79,7 +79,7 @@ describe('Injectable decorator', () => {
     expect(value).toBeInstanceOf(Test)
   })
 
-  it('should work with injection token and schema', async () => {
+  it('should work with factory injection token and schema', async () => {
     class TestFoo {
       constructor(public readonly foo: string) {}
     }
@@ -164,4 +164,22 @@ describe('Injectable decorator', () => {
     const result2 = await inst2.makeFoo()
     expect(result1).toBe(result2)
   })
+
+  it('should work with constructor argument', async () => {
+    const schema = z.object({
+      foo: z.string(),
+    })
+
+    const token = InjectionToken.create('Test', schema)
+
+    @Injectable({ token })
+    class Test {
+      constructor(public readonly arg: z.output<typeof schema>) {}
+    }
+
+    const value = await inject(token, { foo: 'bar' })
+    expect(value).toBeInstanceOf(Test)
+    // @ts-expect-error It's a test
+    expect(value.arg).toEqual({ foo: 'bar' })
+  })
 })

package/src/decorators/injectable.decorator.mts

@@ -2,7 +2,14 @@ import type { AnyZodObject } from 'zod'
 
 import { NaviosException } from '@navios/common'
 
-import type { ClassType, ClassTypeWithInstance } from '../injection-token.mjs'
+import { z } from 'zod'
+
+import type {
+  ClassType,
+  ClassTypeWithArgument,
+  ClassTypeWithInstance,
+  ClassTypeWithInstanceAndArgument,
+} from '../injection-token.mjs'
 import type { Factory, FactoryWithArgs } from '../interfaces/index.mjs'
 import type { Registry } from '../registry.mjs'
 
@@ -22,23 +29,35 @@ export interface InjectableOptions {
 export function Injectable(): <T extends ClassType>(
   target: T,
   context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined> }
-export function Injectable<T extends ClassType>(options: {
-  scope?: InjectableScope
-  token: InjectionToken<T, undefined>
-}): (
-  target: T,
-  context: ClassDecoratorContext,
-) => T & {
-  [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>
-}
+) => T
 export function Injectable<R>(options: {
   scope?: InjectableScope
   type: InjectableType.Factory
 }): <T extends ClassTypeWithInstance<Factory<R>>>(
   target: T,
   context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
+) => 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: {
+  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 AnyZodObject>(options: {
   scope?: InjectableScope
   type: InjectableType.Factory
@@ -64,9 +83,7 @@ export function Injectable({
   return <T extends ClassType>(
     target: T,
     context: ClassDecoratorContext,
-  ): T & {
-    [InjectableTokenMeta]: InjectionToken<any, any>
-  } => {
+  ): T => {
     if (context.kind !== 'class') {
       throw new Error(
         '[ServiceLocator] @Injectable decorator can only be used on classes.',
@@ -77,7 +94,7 @@ export function Injectable({
     if (type === InjectableType.Class) {
       registry.set(
         injectableToken,
-        async (ctx) => resolveService(ctx, target),
+        async (ctx, args: any) => resolveService(ctx, target, [args]),
         scope,
       )
     } else if (type === InjectableType.Factory) {
@@ -99,8 +116,6 @@ export function Injectable({
     // @ts-expect-error
     target[InjectableTokenMeta] = injectableToken
 
-    return target as T & {
-      [InjectableTokenMeta]: InjectionToken<any, any>
-    }
+    return target
   }
 }

package/src/injection-token.mts

@@ -5,8 +5,10 @@ import { randomUUID } from 'crypto'
 import { z, ZodOptional } from 'zod'
 
 export type ClassType = new (...args: any[]) => any
+export type ClassTypeWithArgument<Arg> = new (arg: Arg) => any
 
 export type ClassTypeWithInstance<T> = new (...args: any[]) => T
+export type ClassTypeWithInstanceAndArgument<T, Arg> = new (arg: Arg) => T
 
 export class InjectionToken<
   T,

package/src/utils/get-injectable-token.mts

@@ -1,6 +1,6 @@
 import type { ClassType, InjectionToken } from '../injection-token.mjs'
 
-import { InjectableTokenMeta } from '../symbols/injectable-token.mjs'
+import { InjectableTokenMeta } from '../symbols/index.mjs'
 
 export function getInjectableToken<R>(
   target: ClassType,