@navios/di 0.2.1 → 0.3.0

package/docs/concepts/injection-token.md

@@ -1,145 +0,0 @@
-# Injection Token
-
-Injection tokens are used to identify and retrieve services from the dependency injection container. They are typically defined as constants and used to inject services into classes.
-
-## Creating an Injection Token
-
-To create an injection token, you can use the `InjectionToken` class from the `@navios/di` or `@navios/core` package. Here's an example:
-
-```ts
-import { InjectionToken } from '@navios/di'
-
-export const GREETER_SERVICE =
-  InjectionToken.create<GreeterService>('GreeterService')
-
-@Injectable({ token: GREETER_SERVICE })
-class GreeterService {}
-```
-
-## Using an Injection Token
-
-To use an injection token, you can inject it into a class or a function.
-
-```ts
-import { inject } from '@navios/di'
-
-const greeterService = await inject(GREETER_SERVICE)
-```
-
-or
-
-```ts
-@Injectable()
-class UserService {
-  private readonly greeterService = inject(GREETER_SERVICE) // This will be a Promise<GreeterService>
-  private readonly greeterServiceSync = syncInject(GREETER_SERVICE) // This will be a GreeterService
-}
-```
-
-## Adding a parameter to the injection token
-
-You can add a parameter to the injection token to make it more specific.
-
-```ts
-import { z } from 'zod/v4'
-
-const GreeterServiceParams = z.object({
-  context: z.string(),
-})
-
-export const GREETER_SERVICE = InjectionToken.create<
-  GreeterService,
-  typeof GreeterServiceParams
->('GreeterService', GreeterServiceParams)
-
-@Injectable({ token: GREETER_SERVICE })
-class GreeterService {}
-
-const greeterService = await inject(GREETER_SERVICE, { context: 'Hello' })
-```
-
-## Providing a value to an injection token
-
-You can provide a value to an injection token by using the `bound` function.
-
-```ts
-import { inject, InjectionToken } from '@navios/di'
-
-const helloGreeterService = InjectionToken.bound(GREETER_SERVICE, {
-  context: 'Hello',
-})
-
-const greeterService = await inject(helloGreeterService)
-```
-
-## Providing a factory to an injection token
-
-You can provide a factory to an injection token by using the `factory` function.
-
-It is useful, when you need to bind a value to a result of another service (e.g. a configuration).
-
-```ts
-import { inject, InjectionToken } from '@navios/di'
-
-@Injectable()
-class GreeterConfigService {
-  getContext() {
-    return 'Hello'
-  }
-}
-const helloGreeterService = InjectionToken.factory(
-  GREETER_SERVICE,
-  async () => {
-    const config = await inject(GreeterConfigService)
-    return { context: config.getContext() }
-  },
-)
-
-const greeterService = await inject(helloGreeterService)
-```
-
-## API
-
-### `InjectionToken.create`
-
-Creates a new injection token.
-
-Generic arguments:
-
-- `T`: The type of the value to bind to the injection token.
-- `P`: Zod schema type of the parameters of the injection token.
-
-Arguments:
-
-- `name: string | Class | symbol`: The name of the injection token.
-- `params: ZodSchema | undefined`: The parameters of the injection token.
-
-Returns:
-
-- `InjectionToken`: The new injection token.
-
-### `InjectionToken.bound`
-
-Creates a new injection token that is bound to a value.
-
-Arguments:
-
-- `token: InjectionToken`: The injection token to bind.
-- `value: any`: The value to bind to the injection token.
-
-Returns:
-
-- `BoundInjectionToken`: The new injection token.
-
-### `InjectionToken.factory`
-
-Creates a new injection token that is a factory.
-
-Arguments:
-
-- `token: InjectionToken`: The injection token to bind.
-- `factory: () => Promise<any>`: The factory to bind to the injection token.
-
-Returns:
-
-- `FactoryInjectionToken`: The new injection token.

package/src/proxy-service-locator.mts

@@ -1,83 +0,0 @@
-import type { z, ZodObject, ZodOptional } from 'zod/v4'
-
-import type { FactoryContext } from './factory-context.mjs'
-import type {
-  BoundInjectionToken,
-  FactoryInjectionToken,
-  InjectionToken,
-} from './injection-token.mjs'
-import type { ServiceLocatorEventBus } from './service-locator-event-bus.mjs'
-import type { ServiceLocator } from './service-locator.mjs'
-
-export class ProxyServiceLocator implements ServiceLocator {
-  constructor(
-    private readonly serviceLocator: ServiceLocator,
-    private readonly ctx: FactoryContext,
-  ) {}
-
-  getEventBus(): ServiceLocatorEventBus {
-    return this.serviceLocator.getEventBus()
-  }
-
-  // @ts-expect-error We don't need all the properties of the class
-  public getInstance(
-    token:
-      | InjectionToken<any, any>
-      | BoundInjectionToken<any, any>
-      | FactoryInjectionToken<any, any>,
-    args?: any,
-  ) {
-    // @ts-expect-error We don't need all the properties of the class
-    return this.ctx.inject(token, args).then(
-      (instance) => {
-        return [undefined, instance]
-      },
-      (error) => {
-        return [error]
-      },
-    )
-  }
-  public getOrThrowInstance<
-    Instance,
-    Schema extends ZodObject | ZodOptional<ZodObject> | undefined,
-  >(
-    token: InjectionToken<Instance, Schema>,
-    args: Schema extends ZodObject
-      ? z.input<Schema>
-      : Schema extends ZodOptional<ZodObject>
-        ? z.input<Schema> | undefined
-        : undefined,
-  ): Promise<Instance> {
-    return this.ctx.inject(token, args)
-  }
-  public getSyncInstance<
-    Instance,
-    Schema extends ZodObject | ZodOptional<ZodObject> | undefined,
-  >(
-    token: InjectionToken<Instance, Schema>,
-    args: Schema extends ZodObject
-      ? z.input<Schema>
-      : Schema extends ZodOptional<ZodObject>
-        ? z.input<Schema> | undefined
-        : undefined,
-  ): Instance | null {
-    return this.serviceLocator.getSyncInstance<Instance, Schema>(token, args)
-  }
-  invalidate(service: string, round?: number): Promise<any> {
-    return this.serviceLocator.invalidate(service, round)
-  }
-  ready(): Promise<null> {
-    return this.serviceLocator.ready()
-  }
-  makeInstanceName(token: InjectionToken<any, any>, args: any): string {
-    return this.serviceLocator.makeInstanceName(token, args)
-  }
-}
-
-export function makeProxyServiceLocator(
-  serviceLocator: ServiceLocator,
-  ctx: FactoryContext,
-): ServiceLocator {
-  // @ts-expect-error We don't need all the properties of the class
-  return new ProxyServiceLocator(serviceLocator, ctx)
-}

package/src/resolve-service.mts

@@ -1,41 +0,0 @@
-import type { FactoryContext } from './factory-context.mjs'
-import type { ClassType } from './injection-token.mjs'
-
-import { makeProxyServiceLocator } from './proxy-service-locator.mjs'
-import { getInjectors } from './utils/index.mjs'
-
-export async function resolveService<T extends ClassType>(
-  ctx: FactoryContext,
-  target: T,
-  args: any[] = [],
-): Promise<InstanceType<T>> {
-  const { wrapSyncInit, provideServiceLocator } = getInjectors({
-    baseLocator: ctx.locator,
-  })
-  const proxyServiceLocator = makeProxyServiceLocator(ctx.locator, ctx)
-  const tryLoad = wrapSyncInit(() => {
-    const original = provideServiceLocator(proxyServiceLocator)
-    let result = new target(...args)
-    provideServiceLocator(original)
-    return result
-  })
-  let [instance, promises] = tryLoad()
-  if (promises.length > 0) {
-    await Promise.allSettled(promises)
-    const newRes = tryLoad()
-    instance = newRes[0]
-    promises = newRes[1]
-  }
-  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 Error(
-      `[ServiceLocator] Service ${target.name} cannot be instantiated.`,
-    )
-  }
-
-  return instance
-}