@navios/core 0.1.15 → 0.2.1

package/src/service-locator/inject.mts

@@ -1,42 +0,0 @@
-import type { AnyZodObject, z, ZodOptional } from 'zod'
-
-import type { ClassType } from './injection-token.mjs'
-
-import { getInjectableToken } from './decorators/index.mjs'
-import { InjectionToken } from './injection-token.mjs'
-import { getServiceLocator } from './injector.mjs'
-
-export function inject<T extends ClassType>(token: T): Promise<InstanceType<T>>
-// Not supported by TypeScript yet
-// export function inject<
-//   R,
-//   T extends ClassType & {
-//     [InjectableTokenMeta]: InjectionToken<R, undefined>
-//   },
-// >(token: T): Promise<R>
-// export function inject<
-//   R,
-//   S extends AnyZodObject,
-//   T extends ClassType & {
-//     [InjectableTokenMeta]: InjectionToken<R, S>
-//   },
-// >(token: T, args: z.input<S>): Promise<R>
-export function inject<T, S extends AnyZodObject>(
-  token: InjectionToken<T, S>,
-  args: z.input<S>,
-): Promise<T>
-export function inject<T, S extends ZodOptional<AnyZodObject>>(
-  token: InjectionToken<T, S>,
-  args?: z.input<S>,
-): Promise<T>
-
-export function inject<T>(token: InjectionToken<T, undefined>): Promise<T>
-export function inject(token: InjectionToken<any>, args?: unknown) {
-  let realToken = token
-  if (!(token instanceof InjectionToken)) {
-    realToken = getInjectableToken(token)
-  }
-
-  // @ts-expect-error We chek the type in overload
-  return getServiceLocator().getOrThrowInstance(realToken, args)
-}

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

@@ -1,92 +0,0 @@
-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()
-  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>
-  }
-}
-
-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/injector.mts

@@ -1,18 +0,0 @@
-import { ServiceLocator } from './service-locator.mjs'
-
-let serviceLocator: ServiceLocator = new ServiceLocator()
-
-export function provideServiceLocator(locator: ServiceLocator): ServiceLocator {
-  const original = serviceLocator
-  serviceLocator = locator
-  return original
-}
-
-export function getServiceLocator(): ServiceLocator {
-  if (!serviceLocator) {
-    throw new Error(
-      '[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.',
-    )
-  }
-  return serviceLocator
-}

package/src/service-locator/interfaces/factory.interface.mts

@@ -1,11 +0,0 @@
-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/service-locator/override.mts

@@ -1,22 +0,0 @@
-import type { ClassType, InjectionToken } from './injection-token.mjs'
-
-import { getServiceLocator } from './injector.mjs'
-
-/**
- * Useful for tests or when you want to override a service
- * with a different implementation.
- */
-export function override<T>(token: InjectionToken<T>, target: ClassType) {
-  const serviceLocator = getServiceLocator()
-  const originalDefinition = serviceLocator['abstractFactories'].get(token)
-  serviceLocator.registerAbstractFactory(token, async (ctx, args: any) => {
-    const builder = new target()
-    return builder.create(ctx, args)
-  })
-
-  return () => {
-    if (originalDefinition) {
-      serviceLocator.registerAbstractFactory(token, originalDefinition)
-    }
-  }
-}

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),
-      ),
-    )
-  }
-}