@navios/core 0.1.3 → 0.1.4

package/package.json

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

package/src/config/config.provider.mts

@@ -4,36 +4,34 @@ import type { ConfigService } from './config-service.interface.mjs'
 
 import { Logger } from '../logger/index.mjs'
 import {
-  getInjectableToken,
-  inject,
   Injectable,
   InjectableType,
   InjectionToken,
+  syncInject,
 } from '../service-locator/index.mjs'
 import { ConfigServiceInstance } from './config.service.mjs'
 
-export const ConfigProviderInjectionToken = 'ConfigProvider'
-
 export const ConfigProviderOptions = z.object({
   load: z.function(),
 })
+
 export const ConfigProvider = InjectionToken.create<
   ConfigService,
   typeof ConfigProviderOptions
->(ConfigProviderInjectionToken, ConfigProviderOptions)
+>(ConfigServiceInstance, ConfigProviderOptions)
 
 @Injectable({
   token: ConfigProvider,
   type: InjectableType.Factory,
 })
 export class ConfigProviderFactory {
-  logger = inject(Logger, {
+  logger = syncInject(Logger, {
     context: 'ConfigService',
   })
 
   async create(ctx: any, args: z.infer<typeof ConfigProviderOptions>) {
     const { load } = args
-    const logger = await this.logger
+    const logger = this.logger
     try {
       const config = await load()
 
@@ -45,18 +43,11 @@ export class ConfigProviderFactory {
   }
 }
 
-export function makeConfigToken<Config extends Record<string, unknown>>(
+export function provideConfig<ConfigMap extends Record<string, unknown>>(
   options: z.input<typeof ConfigProviderOptions>,
-): InjectionToken<ConfigService<Config>> {
-  @Injectable({
-    type: InjectableType.Factory,
-  })
-  class ConfigServiceImpl {
-    configService = inject(ConfigProvider, options)
-
-    create() {
-      return this.configService
-    }
-  }
-  return getInjectableToken(ConfigServiceImpl)
+) {
+  return InjectionToken.bound(ConfigProvider, options) as InjectionToken<
+    ConfigServiceInstance<ConfigMap>,
+    undefined
+  >
 }

package/src/service-locator/__tests__/injectable.spec.mts

@@ -2,11 +2,12 @@ import { describe, expect, it } from 'vitest'
 import { z } from 'zod'
 
 import {
+  getInjectableToken,
   Injectable,
   InjectableType,
 } from '../decorators/index.mjs'
 import { InjectableScope } from '../enums/index.mjs'
-import { getInjectableToken, syncInject } from '../index.mjs'
+import { syncInject } from '../index.mjs'
 import { inject } from '../inject.mjs'
 import { InjectionToken } from '../injection-token.mjs'
 import { getServiceLocator } from '../injector.mjs'

package/src/service-locator/__tests__/injection-token.spec.mts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod'
+
+import { Injectable, InjectableType } from '../decorators/index.mjs'
+import { inject } from '../inject.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+
+describe('InjectToken', () => {
+  it('should work with class', async () => {
+    const token = InjectionToken.create('Test')
+    @Injectable({
+      token,
+    })
+    class Test {}
+
+    const value = await inject(Test)
+    expect(value).toBeInstanceOf(Test)
+  })
+
+  it('should work with class and schema', async () => {
+    const schema = z.object({
+      test: z.string(),
+    })
+    const token = InjectionToken.create('Test', schema)
+
+    @Injectable({
+      token,
+    })
+    class Test {
+      makeFoo() {
+        return 'foo'
+      }
+    }
+    const value = await inject(token, {
+      test: 'test',
+    })
+
+    expect(value).toBeInstanceOf(Test)
+  })
+
+  it('should work with factory', async () => {
+    const token = InjectionToken.create('Test')
+    @Injectable({
+      token,
+      type: InjectableType.Factory,
+    })
+    class Test {
+      create() {
+        return 'foo'
+      }
+    }
+
+    const value = await inject(Test)
+    expect(value).toBe('foo')
+  })
+
+  it('should work with factory and schema', async () => {
+    const schema = z.object({
+      test: z.string(),
+    })
+    const token = InjectionToken.create<string, typeof schema>('Test', schema)
+
+    @Injectable({
+      token,
+      type: InjectableType.Factory,
+    })
+    class Test {
+      create(ctx: any, args: { test: string }) {
+        return args.test
+      }
+    }
+    const value = await inject(token, {
+      test: 'test',
+    })
+
+    expect(value).toBe('test')
+  })
+
+  it('should work with bound token', async () => {
+    const schema = z.object({
+      test: z.string(),
+    })
+    const token = InjectionToken.create('Test', schema)
+    const boundToken = InjectionToken.bound(token, {
+      test: 'test',
+    })
+
+    @Injectable({
+      token,
+    })
+    class Test {
+      makeFoo() {
+        return 'foo'
+      }
+    }
+    const value = await inject(boundToken)
+
+    expect(value).toBeInstanceOf(Test)
+  })
+
+  it('should work with factory token', async () => {
+    const schema = z.object({
+      test: z.string(),
+    })
+    const token = InjectionToken.create('Test', schema)
+    const factoryInjectionToken = InjectionToken.factory(token, () =>
+      Promise.resolve({
+        test: 'test',
+      }),
+    )
+
+    @Injectable({
+      token,
+    })
+    class Test {
+      makeFoo() {
+        return 'foo'
+      }
+    }
+    const value = await inject(factoryInjectionToken)
+
+    expect(value).toBeInstanceOf(Test)
+  })
+})

package/src/service-locator/decorators/get-injectable-token.mts

@@ -1,12 +1,8 @@
-import type {
-  ClassType,
-  ClassTypeWithInstance,
-  InjectionToken,
-} from '../injection-token.mjs'
+import type { ClassType, InjectionToken } from '../injection-token.mjs'
 
 import { InjectableTokenMeta } from './injectable.decorator.mjs'
 
-export function getInjectableToken<R, T extends ClassTypeWithInstance<R>>(
+export function getInjectableToken<R>(
   target: ClassType,
 ): R extends { create(...args: any[]): infer V }
   ? InjectionToken<V>

package/src/service-locator/decorators/injectable.decorator.mts

@@ -1,10 +1,11 @@
+import { NaviosException } from '@navios/common'
+
 import type { ClassType } from '../injection-token.mjs'
 
 import { InjectableScope } from '../enums/index.mjs'
 import { InjectionToken } from '../injection-token.mjs'
-import { getServiceLocator, provideServiceLocator } from '../injector.mjs'
-import { makeProxyServiceLocator } from '../proxy-service-locator.mjs'
-import { setPromiseCollector } from '../sync-injector.mjs'
+import { getServiceLocator } from '../injector.mjs'
+import { resolveService } from '../resolve-service.mjs'
 
 export enum InjectableType {
   Class = 'Class',
@@ -33,62 +34,22 @@ export function Injectable({
     let injectableToken: InjectionToken<any, any> =
       token ?? InjectionToken.create(target)
     const locator = getServiceLocator()
-    if (!locator) {
-      throw new Error(
-        '[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.',
-      )
-    }
     if (type === InjectableType.Class) {
       locator.registerAbstractFactory(
         injectableToken,
-        async (ctx) => {
-          if (scope === InjectableScope.Instance) {
-            ctx.setTtl(0)
-          }
-          const proxyServiceLocator = makeProxyServiceLocator(
-            getServiceLocator(),
-            ctx,
-          )
-          const promises: Promise<any>[] = []
-          const promiseCollector = (promise: Promise<any>) => {
-            promises.push(promise)
-          }
-          const originalPromiseCollector = setPromiseCollector(promiseCollector)
-          const tryInit = () => {
-            const original = provideServiceLocator(proxyServiceLocator)
-            let result = new target()
-            provideServiceLocator(original)
-            return result
-          }
-          const result = tryInit()
-          setPromiseCollector(originalPromiseCollector)
-          if (promises.length > 0) {
-            await Promise.all(promises)
-            return tryInit()
-          }
-          return result
-        },
+        async (ctx) => resolveService(ctx, target),
         scope,
       )
     } else if (type === InjectableType.Factory) {
       locator.registerAbstractFactory(
         injectableToken,
         async (ctx, args: any) => {
-          if (scope === InjectableScope.Instance) {
-            ctx.setTtl(0)
-          }
-          const proxyServiceLocator = makeProxyServiceLocator(
-            getServiceLocator(),
-            ctx,
-          )
-          const original = provideServiceLocator(proxyServiceLocator)
-          const builder = new target()
+          const builder = await resolveService(ctx, target)
           if (typeof builder.create !== 'function') {
-            throw new Error(
+            throw new NaviosException(
               `[ServiceLocator] Factory ${target.name} does not implement the create method.`,
             )
           }
-          provideServiceLocator(original)
           return builder.create(ctx, args)
         },
         scope,

package/src/service-locator/errors/errors.enum.mts

@@ -4,4 +4,5 @@ export enum ErrorsEnum {
   InstanceDestroying = 'InstanceDestroying',
   UnknownError = 'UnknownError',
   FactoryNotFound = 'FactoryNotFound',
+  FactoryTokenNotResolved = 'FactoryTokenNotResolved',
 }

package/src/service-locator/errors/factory-token-not-resolved.mts

@@ -0,0 +1,10 @@
+import type { ClassType } from '../injection-token.mjs'
+
+import { ErrorsEnum } from './errors.enum.mjs'
+
+export class FactoryTokenNotResolved extends Error {
+  code = ErrorsEnum.FactoryTokenNotResolved
+  constructor(name: string | symbol | ClassType) {
+    super(`Factory token not resolved: ${name.toString()}`)
+  }
+}

package/src/service-locator/errors/index.mts

@@ -1,5 +1,6 @@
 export * from './errors.enum.mjs'
 export * from './factory-not-found.mjs'
+export * from './factory-token-not-resolved.mjs'
 export * from './instance-destroying.mjs'
 export * from './instance-expired.mjs'
 export * from './instance-not-found.mjs'

package/src/service-locator/index.mts

@@ -12,3 +12,4 @@ export * from './service-locator-event-bus.mjs'
 export * from './service-locator-instance-holder.mjs'
 export * from './service-locator-manager.mjs'
 export * from './sync-injector.mjs'
+export * from './resolve-service.mjs'

package/src/service-locator/inject.mts

@@ -17,26 +17,12 @@ export function inject<T, S extends ZodOptional<AnyZodObject>>(
 ): Promise<T>
 
 export function inject<T>(token: InjectionToken<T, undefined>): Promise<T>
-export function inject<
-  T,
-  Token extends InjectionToken<T>,
-  S extends AnyZodObject | unknown = Token['schema'],
->(
-  token: Token,
-  args?: S extends AnyZodObject ? z.input<S> : never,
-): Promise<T> {
-  if (token.schema) {
-    const parsed = token.schema.safeParse(args)
-    if (!parsed.success) {
-      throw new Error(
-        `[ServiceLocator] Invalid arguments for ${token.name.toString()}: ${parsed.error}`,
-      )
-    }
-  }
-  let realToken: InjectionToken<T, S> = token
+export function inject(token: InjectionToken<any>, args?: unknown) {
+  let realToken = token
   if (!(token instanceof InjectionToken)) {
-    realToken = getInjectableToken(token) as InjectionToken<T, S>
+    realToken = getInjectableToken(token)
   }
 
+  // @ts-expect-error We chek the type in overload
   return getServiceLocator().getOrThrowInstance(realToken, args)
 }

package/src/service-locator/injection-token.mts

@@ -2,7 +2,7 @@ import type { AnyZodObject } from 'zod'
 
 import { randomUUID } from 'crypto'
 
-import { ZodOptional } from 'zod'
+import { z, ZodOptional } from 'zod'
 
 export type ClassType = new (...args: any[]) => any
 
@@ -25,17 +25,68 @@ export class InjectionToken<
     T extends ClassType,
     Schema extends AnyZodObject | ZodOptional<AnyZodObject>,
   >(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>
-  static create<T>(name: string): InjectionToken<T, undefined>
+  static create<T>(name: string | symbol): InjectionToken<T, undefined>
   static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(
-    name: string,
+    name: string | any,
     schema: Schema,
   ): InjectionToken<T, Schema>
-  static create(name: string, schema?: unknown) {
+  static create(name: string | symbol, schema?: unknown) {
     // @ts-expect-error
     return new InjectionToken(name, schema)
   }
 
-  toString() {
-    return this.name
+  static bound<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(
+    token: InjectionToken<T, S>,
+    value: z.input<S>,
+  ): BoundInjectionToken<T, S> {
+    return new BoundInjectionToken(token, value)
+  }
+
+  static factory<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(
+    token: InjectionToken<T, S>,
+    factory: () => Promise<z.input<S>>,
+  ): FactoryInjectionToken<T, S> {
+    return new FactoryInjectionToken(token, factory)
+  }
+
+  static refineType<T>(
+    token: BoundInjectionToken<any, any>,
+  ): BoundInjectionToken<T, any> {
+    return token as BoundInjectionToken<T, any>
+  }
+}
+
+export class BoundInjectionToken<
+  T,
+  S extends AnyZodObject | ZodOptional<AnyZodObject>,
+> extends InjectionToken<T, undefined> {
+  constructor(
+    public readonly token: InjectionToken<T, S>,
+    public readonly value: z.input<S>,
+  ) {
+    super(token.name, token.schema)
+    this.id = token.id
+  }
+}
+
+export class FactoryInjectionToken<
+  T,
+  S extends AnyZodObject | ZodOptional<AnyZodObject>,
+> extends InjectionToken<T, S> {
+  public value?: z.input<S>
+  public resolved = false
+  constructor(
+    public readonly token: InjectionToken<T, S>,
+    public readonly factory: () => Promise<z.input<S>>,
+  ) {
+    super(token.name, token.schema)
+  }
+
+  async resolve(): Promise<z.input<S>> {
+    if (!this.value) {
+      this.value = await this.factory()
+      this.resolved = true
+    }
+    return this.value
   }
 }

package/src/service-locator/resolve-service.mts

@@ -0,0 +1,46 @@
+import { NaviosException } from '@navios/common'
+
+import type { ClassType } from './injection-token.mjs'
+import type { ServiceLocatorAbstractFactoryContext } from './service-locator-abstract-factory-context.mjs'
+
+import { getServiceLocator, provideServiceLocator } from './injector.mjs'
+import { makeProxyServiceLocator } from './proxy-service-locator.mjs'
+import { setPromiseCollector } from './sync-injector.mjs'
+
+export async function resolveService<T extends ClassType>(
+  ctx: ServiceLocatorAbstractFactoryContext,
+  target: T,
+  args: any[] = [],
+): Promise<InstanceType<T>> {
+  const proxyServiceLocator = makeProxyServiceLocator(getServiceLocator(), ctx)
+  let promises: Promise<any>[] = []
+  const promiseCollector = (promise: Promise<any>) => {
+    promises.push(promise)
+  }
+  const originalPromiseCollector = setPromiseCollector(promiseCollector)
+  const tryLoad = () => {
+    const original = provideServiceLocator(proxyServiceLocator)
+    let result = new target(...args)
+    provideServiceLocator(original)
+    return result
+  }
+  let instance = tryLoad()
+  setPromiseCollector(originalPromiseCollector)
+  if (promises.length > 0) {
+    await Promise.all(promises)
+    promises = []
+    instance = tryLoad()
+  }
+  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(
+      `[ServiceLocator] Service ${target.name} cannot be instantiated.`,
+    )
+  }
+
+  return instance
+}