@navios/di 0.1.0

package/src/index.mts

@@ -0,0 +1,16 @@
+export * from './decorators/index.mjs'
+export * from './enums/index.mjs'
+export * from './errors/index.mjs'
+export * from './interfaces/index.mjs'
+export * from './utils/index.mjs'
+export * from './event-emitter.mjs'
+export * from './factory-context.mjs'
+export * from './injection-token.mjs'
+export * from './injector.mjs'
+export * from './proxy-service-locator.mjs'
+export * from './registry.mjs'
+export * from './resolve-service.mjs'
+export * from './service-locator.mjs'
+export * from './service-locator-event-bus.mjs'
+export * from './service-locator-instance-holder.mjs'
+export * from './service-locator-manager.mjs'

package/src/injection-token.mts

@@ -0,0 +1,130 @@
+import type { AnyZodObject } from 'zod'
+
+import { randomUUID } from 'crypto'
+
+import { z, ZodOptional } from 'zod'
+
+export type ClassType = new (...args: any[]) => any
+
+export type ClassTypeWithInstance<T> = new (...args: any[]) => T
+
+export class InjectionToken<
+  T,
+  S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown,
+> {
+  public id = randomUUID()
+  private formattedName: string | null = null
+
+  constructor(
+    public readonly name: string | symbol | ClassType,
+    public readonly schema: AnyZodObject | undefined,
+  ) {}
+
+  static create<T extends ClassType>(
+    name: T,
+  ): InjectionToken<InstanceType<T>, undefined>
+  static create<
+    T extends ClassType,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject>,
+  >(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>
+  static create<T>(name: string | symbol): InjectionToken<T, undefined>
+  static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(
+    name: string | any,
+    schema: Schema,
+  ): InjectionToken<T, Schema>
+  static create(name: string | symbol, schema?: unknown) {
+    // @ts-expect-error
+    return new InjectionToken(name, schema)
+  }
+
+  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>
+  }
+
+  toString() {
+    if (this.formattedName) {
+      return this.formattedName
+    }
+    const { name } = this
+    if (typeof name === 'function') {
+      const className = name.name
+      this.formattedName = `${className}(${this.id})`
+    } else if (typeof name === 'symbol') {
+      this.formattedName = `${name.toString()}(${this.id})`
+    } else {
+      this.formattedName = `${name}(${this.id})`
+    }
+
+    return this.formattedName
+  }
+}
+
+export class BoundInjectionToken<
+  T,
+  S extends AnyZodObject | ZodOptional<AnyZodObject>,
+> {
+  public id: string
+  public name: string | symbol | ClassType
+  public schema: AnyZodObject | ZodOptional<AnyZodObject>
+
+  constructor(
+    public readonly token: InjectionToken<T, S>,
+    public readonly value: z.input<S>,
+  ) {
+    this.name = token.name
+    this.id = token.id
+    this.schema = token.schema as AnyZodObject | ZodOptional<AnyZodObject>
+  }
+
+  toString() {
+    return this.token.toString()
+  }
+}
+
+export class FactoryInjectionToken<
+  T,
+  S extends AnyZodObject | ZodOptional<AnyZodObject>,
+> {
+  public value?: z.input<S>
+  public resolved = false
+  public id: string
+  public name: string | symbol | ClassType
+  public schema: AnyZodObject | ZodOptional<AnyZodObject>
+
+  constructor(
+    public readonly token: InjectionToken<T, S>,
+    public readonly factory: () => Promise<z.input<S>>,
+  ) {
+    this.name = token.name
+    this.id = token.id
+    this.schema = token.schema as AnyZodObject | ZodOptional<AnyZodObject>
+  }
+
+  async resolve(): Promise<z.input<S>> {
+    if (!this.value) {
+      this.value = await this.factory()
+      this.resolved = true
+    }
+    return this.value
+  }
+
+  toString() {
+    return this.token.toString()
+  }
+}

package/src/injector.mts

@@ -0,0 +1,19 @@
+import { ServiceLocator } from './service-locator.mjs'
+import { getInjectors } from './utils/index.mjs'
+
+const globalServiceLocator: ServiceLocator = new ServiceLocator()
+
+export function getGlobalServiceLocator(): ServiceLocator {
+  if (!globalServiceLocator) {
+    throw new Error(
+      '[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.',
+    )
+  }
+  return globalServiceLocator
+}
+const { inject, syncInject, wrapSyncInit, provideServiceLocator } =
+  getInjectors({
+    baseLocator: globalServiceLocator,
+  })
+
+export { inject, syncInject, wrapSyncInit, provideServiceLocator }

package/src/interfaces/factory.interface.mts

@@ -0,0 +1,11 @@
+import type { AnyZodObject } from 'zod'
+
+import { z } from 'zod'
+
+export interface Factory<T> {
+  create(ctx?: any): Promise<T> | T
+}
+
+export interface FactoryWithArgs<T, A extends AnyZodObject> {
+  create(ctx: any, args: z.output<A>): Promise<T> | T
+}

package/src/interfaces/index.mts

@@ -0,0 +1 @@
+export * from './factory.interface.mjs'

package/src/proxy-service-locator.mts

@@ -0,0 +1,83 @@
+import type { AnyZodObject, z, ZodOptional } from 'zod'
+
+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 AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+  >(
+    token: InjectionToken<Instance, Schema>,
+    args: Schema extends AnyZodObject
+      ? z.input<Schema>
+      : Schema extends ZodOptional<AnyZodObject>
+        ? z.input<Schema> | undefined
+        : undefined,
+  ): Promise<Instance> {
+    return this.ctx.inject(token, args)
+  }
+  public getSyncInstance<
+    Instance,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+  >(
+    token: InjectionToken<Instance, Schema>,
+    args: Schema extends AnyZodObject
+      ? z.input<Schema>
+      : Schema extends ZodOptional<AnyZodObject>
+        ? z.input<Schema> | undefined
+        : undefined,
+  ): Instance | null {
+    return this.serviceLocator.getSyncInstance(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/registry.mts

@@ -0,0 +1,65 @@
+import type { AnyZodObject } from 'zod'
+
+import { z } from 'zod'
+
+import type { FactoryContext } from './factory-context.mjs'
+import type { InjectionToken } from './injection-token.mjs'
+
+import { InjectableScope } from './enums/index.mjs'
+
+export type InjectionFactory<T = unknown, Args = unknown> = (
+  ctx: FactoryContext,
+  args: Args,
+) => Promise<T>
+
+export type FactoryRecord<Instance = any, Schema = any> = {
+  scope: InjectableScope
+  originalToken: InjectionToken<Instance, Schema>
+  factory: InjectionFactory<
+    Instance,
+    Schema extends AnyZodObject ? z.input<Schema> : unknown
+  >
+}
+
+export class Registry {
+  private readonly factories = new Map<string, FactoryRecord>()
+
+  constructor(private readonly parent?: Registry) {}
+
+  has(token: InjectionToken<any, any>): boolean {
+    if (this.factories.has(token.id)) {
+      return true
+    }
+    if (this.parent) {
+      return this.parent.has(token)
+    }
+    return false
+  }
+
+  get<Instance, Schema>(
+    token: InjectionToken<Instance, Schema>,
+  ): FactoryRecord<Instance, Schema> {
+    const factory = this.factories.get(token.id)
+    if (!factory) {
+      if (this.parent) {
+        return this.parent.get(token)
+      }
+      throw new Error(`[Registry] No factory found for ${token.toString()}`)
+    }
+    return factory
+  }
+
+  set<Instance, Schema>(
+    token: InjectionToken<Instance, Schema>,
+    factory: InjectionFactory,
+    scope: InjectableScope,
+  ) {
+    this.factories.set(token.id, { factory, scope, originalToken: token })
+  }
+
+  delete(token: InjectionToken<any, any>) {
+    this.factories.delete(token.id)
+  }
+}
+
+export const globalRegistry = new Registry()

package/src/resolve-service.mts

@@ -0,0 +1,43 @@
+import { NaviosException } from '@navios/common'
+
+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 proxyServiceLocator = makeProxyServiceLocator(ctx.locator, ctx)
+  const { wrapSyncInit, provideServiceLocator } = getInjectors({
+    baseLocator: ctx.locator,
+  })
+  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.all(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 NaviosException(
+      `[ServiceLocator] Service ${target.name} cannot be instantiated.`,
+    )
+  }
+
+  return instance
+}

package/src/service-locator-event-bus.mts

@@ -0,0 +1,96 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+
+type ListenersMap = Map<string, Map<string, Set<Function>>>
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+export class ServiceLocatorEventBus {
+  private listeners: ListenersMap = new Map()
+  constructor(private readonly logger: Console | null = null) {}
+
+  on<Event extends string | `pre:${string}` | `post:${string}`>(
+    ns: string,
+    event: Event,
+    listener: (event: Event) => void,
+  ) {
+    this.logger?.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`)
+    if (!this.listeners.has(ns)) {
+      this.listeners.set(ns, new Map())
+    }
+
+    const nsEvents = this.listeners.get(ns)!
+    if (!nsEvents.has(event)) {
+      nsEvents.set(event, new Set())
+    }
+
+    nsEvents.get(event)!.add(listener)
+
+    return () => {
+      nsEvents.get(event)!.delete(listener)
+      if (nsEvents.get(event)?.size === 0) {
+        nsEvents.delete(event)
+      }
+      if (nsEvents.size === 0) {
+        this.listeners.delete(ns)
+      }
+    }
+  }
+
+  async emit(key: string, event: string) {
+    if (!this.listeners.has(key)) {
+      return
+    }
+
+    const events = this.listeners.get(key)!
+
+    const preEvent = `pre:${event}`
+    const postEvent = `post:${event}`
+    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`)
+    await Promise.allSettled(
+      [...(events.get(preEvent) ?? [])].map((listener) => listener(preEvent)),
+    ).then((results) => {
+      results
+        .filter((result) => result.status === 'rejected')
+        .forEach((result: PromiseRejectedResult) => {
+          this.logger?.warn(
+            `[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`,
+            result.reason,
+          )
+        })
+    })
+    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`)
+
+    const res = await Promise.allSettled(
+      [...(events.get(event) ?? [])!].map((listener) => listener(event)),
+    ).then((results) => {
+      const res = results
+        .filter((result) => result.status === 'rejected')
+        .map((result: PromiseRejectedResult) => {
+          this.logger?.warn(
+            `[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`,
+            result.reason,
+          )
+          return result
+        })
+
+      if (res.length > 0) {
+        return Promise.reject(res)
+      }
+      return results
+    })
+    this.logger?.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent}`)
+    await Promise.allSettled(
+      [...(events.get(postEvent) ?? [])].map((listener) => listener(postEvent)),
+    ).then((results) => {
+      results
+        .filter((result) => result.status === 'rejected')
+        .forEach((result: PromiseRejectedResult) => {
+          this.logger?.warn(
+            `[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`,
+            result.reason,
+          )
+        })
+    })
+    return res
+  }
+}

package/src/service-locator-instance-holder.mts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+
+export enum ServiceLocatorInstanceHolderKind {
+  Instance = 'instance',
+  Factory = 'factory',
+  AbstractFactory = 'abstractFactory',
+}
+
+export enum ServiceLocatorInstanceHolderStatus {
+  Created = 'created',
+  Creating = 'creating',
+  Destroying = 'destroying',
+}
+
+export type ServiceLocatorInstanceEffect = () => void
+export type ServiceLocatorInstanceDestroyListener = () => void | Promise<void>
+
+export interface ServiceLocatorInstanceHolderCreating<Instance> {
+  status: ServiceLocatorInstanceHolderStatus.Creating
+  name: string
+  instance: null
+  creationPromise: Promise<[undefined, Instance]> | null
+  destroyPromise: null
+  kind: ServiceLocatorInstanceHolderKind
+  effects: ServiceLocatorInstanceEffect[]
+  deps: string[]
+  destroyListeners: ServiceLocatorInstanceDestroyListener[]
+  createdAt: number
+  ttl: number
+}
+
+export interface ServiceLocatorInstanceHolderCreated<Instance> {
+  status: ServiceLocatorInstanceHolderStatus.Created
+  name: string
+  instance: Instance
+  creationPromise: null
+  destroyPromise: null
+  kind: ServiceLocatorInstanceHolderKind
+  effects: ServiceLocatorInstanceEffect[]
+  deps: string[]
+  destroyListeners: ServiceLocatorInstanceDestroyListener[]
+  createdAt: number
+  ttl: number
+}
+
+export interface ServiceLocatorInstanceHolderDestroying<Instance> {
+  status: ServiceLocatorInstanceHolderStatus.Destroying
+  name: string
+  instance: Instance | null
+  creationPromise: null
+  destroyPromise: Promise<void>
+  kind: ServiceLocatorInstanceHolderKind
+  effects: ServiceLocatorInstanceEffect[]
+  deps: string[]
+  destroyListeners: ServiceLocatorInstanceDestroyListener[]
+  createdAt: number
+  ttl: number
+}
+
+export type ServiceLocatorInstanceHolder<Instance = unknown> =
+  | ServiceLocatorInstanceHolderCreating<Instance>
+  | ServiceLocatorInstanceHolderCreated<Instance>
+  | ServiceLocatorInstanceHolderDestroying<Instance>

package/src/service-locator-manager.mts

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
+
+import {
+  ErrorsEnum,
+  InstanceDestroying,
+  InstanceExpired,
+  InstanceNotFound,
+} from './errors/index.mjs'
+import { ServiceLocatorInstanceHolderStatus } from './service-locator-instance-holder.mjs'
+
+export class ServiceLocatorManager {
+  private readonly instancesHolders: Map<string, ServiceLocatorInstanceHolder> =
+    new Map()
+
+  constructor(private readonly logger: Console | null = null) {}
+
+  get(
+    name: string,
+  ):
+    | [InstanceExpired | InstanceDestroying, ServiceLocatorInstanceHolder]
+    | [InstanceNotFound]
+    | [undefined, ServiceLocatorInstanceHolder] {
+    const holder = this.instancesHolders.get(name)
+    if (holder) {
+      if (holder.ttl !== Infinity) {
+        const now = Date.now()
+        if (now - holder.createdAt > holder.ttl) {
+          this.logger?.log(
+            `[ServiceLocatorManager]#getInstanceHolder() TTL expired for ${holder.name}`,
+          )
+          return [new InstanceExpired(holder.name), holder]
+        }
+      } else if (
+        holder.status === ServiceLocatorInstanceHolderStatus.Destroying
+      ) {
+        this.logger?.log(
+          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`,
+        )
+        return [new InstanceDestroying(holder.name), holder]
+      }
+
+      return [undefined, holder]
+    } else {
+      this.logger?.log(
+        `[ServiceLocatorManager]#getInstanceHolder() Instance ${name} not found`,
+      )
+      return [new InstanceNotFound(name)]
+    }
+  }
+
+  set(name: string, holder: ServiceLocatorInstanceHolder): void {
+    this.instancesHolders.set(name, holder)
+  }
+
+  has(
+    name: string,
+  ): [InstanceExpired | InstanceDestroying] | [undefined, boolean] {
+    const [error, holder] = this.get(name)
+    if (!error) {
+      return [undefined, true]
+    }
+    if (
+      [ErrorsEnum.InstanceExpired, ErrorsEnum.InstanceDestroying].includes(
+        error.code,
+      )
+    ) {
+      return [error]
+    }
+    return [undefined, !!holder]
+  }
+
+  delete(name: string): boolean {
+    return this.instancesHolders.delete(name)
+  }
+
+  filter(
+    predicate: (
+      value: ServiceLocatorInstanceHolder<any>,
+      key: string,
+    ) => boolean,
+  ): Map<string, ServiceLocatorInstanceHolder> {
+    return new Map(
+      [...this.instancesHolders].filter(([key, value]) =>
+        predicate(value, key),
+      ),
+    )
+  }
+}