@navios/core 0.1.15 → 0.2.0

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

@@ -1,99 +0,0 @@
-import type { AnyZodObject, output, z, ZodOptional } from 'zod'
-
-import type { FactoryNotFound, UnknownError } from './index.mjs'
-import type { InjectionToken } from './injection-token.mjs'
-import type { ServiceLocatorAbstractFactoryContext } from './service-locator-abstract-factory-context.mjs'
-import type { ServiceLocatorEventBus } from './service-locator-event-bus.mjs'
-import type { ServiceLocator } from './service-locator.mjs'
-
-// @ts-expect-error We don't need all the properties of the class
-export class ProxyServiceLocator implements ServiceLocator {
-  constructor(
-    private readonly serviceLocator: ServiceLocator,
-    private readonly ctx: ServiceLocatorAbstractFactoryContext,
-  ) {}
-  get abstractFactories(): Map<
-    InjectionToken<any, any>,
-    (ctx: ServiceLocatorAbstractFactoryContext, args: any) => Promise<any>
-  > {
-    return this.serviceLocator['abstractFactories']
-  }
-  getEventBus(): ServiceLocatorEventBus {
-    return this.serviceLocator.getEventBus()
-  }
-  public registerAbstractFactory<
-    Instance,
-    Schema extends AnyZodObject | undefined,
-  >(
-    token: InjectionToken<Instance, Schema>,
-    factory: (
-      ctx: ServiceLocatorAbstractFactoryContext,
-      values: Schema extends AnyZodObject ? output<Schema> : undefined,
-    ) => Promise<Instance>,
-  ): void {
-    return this.serviceLocator.registerAbstractFactory(token, factory)
-  }
-  public getInstance<
-    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<[undefined, Instance] | [UnknownError | FactoryNotFound]> {
-    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: ServiceLocatorAbstractFactoryContext,
-): ServiceLocator {
-  // @ts-expect-error We don't need all the properties of the class
-  return new ProxyServiceLocator(serviceLocator, ctx)
-}

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

@@ -1,46 +0,0 @@
-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
-}

package/src/service-locator/service-locator-abstract-factory-context.mts

@@ -1,23 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import type { AnyZodObject, z } from 'zod'
-
-import type { inject } from './inject.mjs'
-import type { InjectionToken } from './injection-token.mjs'
-import type { ServiceLocatorEventBus } from './service-locator-event-bus.mjs'
-
-export interface ServiceLocatorAbstractFactoryContext {
-  inject: typeof inject
-  addDependency:
-    | ((token: InjectionToken<any, undefined>) => void)
-    | (<S extends AnyZodObject>(
-        token: InjectionToken<any, S>,
-        args: z.input<S>,
-      ) => void)
-  on: ServiceLocatorEventBus['on']
-  getDependencies: () => string[]
-  invalidate: () => void
-  addEffect: (listener: () => void) => void
-  getDestroyListeners: () => (() => void)[]
-  setTtl: (ttl: number) => void
-  getTtl: () => number
-}

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

@@ -1,96 +0,0 @@
-/* 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/service-locator-instance-holder.mts

@@ -1,63 +0,0 @@
-/* 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/service-locator-manager.mts

@@ -1,89 +0,0 @@
-/* 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),
-      ),
-    )
-  }
-}