@navios/core 0.1.14 → 0.2.0

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

@@ -1,124 +0,0 @@
-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,19 +0,0 @@
-import type { ClassType, InjectionToken } from '../injection-token.mjs'
-
-import { InjectableTokenMeta } from './injectable.decorator.mjs'
-
-export function getInjectableToken<R>(
-  target: ClassType,
-): R extends { create(...args: any[]): infer V }
-  ? InjectionToken<V>
-  : InjectionToken<R> {
-  // @ts-expect-error We inject the token into the class itself
-  const token = target[InjectableTokenMeta] as InjectionToken<any, any>
-  if (!token) {
-    throw new Error(
-      `[ServiceLocator] Class ${target.name} is not decorated with @Injectable.`,
-    )
-  }
-  // @ts-expect-error We detect factory or class
-  return token
-}

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

@@ -1,2 +0,0 @@
-export * from './get-injectable-token.mjs'
-export * from './injectable.decorator.mjs'

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

@@ -1,64 +0,0 @@
-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 } from '../injector.mjs'
-import { resolveService } from '../resolve-service.mjs'
-
-export enum InjectableType {
-  Class = 'Class',
-  Factory = 'Factory',
-}
-
-export interface InjectableOptions {
-  scope?: InjectableScope
-  type?: InjectableType
-  token?: InjectionToken<any, any>
-}
-
-export const InjectableTokenMeta = Symbol('InjectableTokenMeta')
-
-export function Injectable({
-  scope = InjectableScope.Singleton,
-  type = InjectableType.Class,
-  token,
-}: InjectableOptions = {}) {
-  return (target: ClassType, context: ClassDecoratorContext) => {
-    if (context.kind !== 'class') {
-      throw new Error(
-        '[ServiceLocator] @Injectable decorator can only be used on classes.',
-      )
-    }
-    let injectableToken: InjectionToken<any, any> =
-      token ?? InjectionToken.create(target)
-    const locator = getServiceLocator()
-    if (type === InjectableType.Class) {
-      locator.registerAbstractFactory(
-        injectableToken,
-        async (ctx) => resolveService(ctx, target),
-        scope,
-      )
-    } else if (type === InjectableType.Factory) {
-      locator.registerAbstractFactory(
-        injectableToken,
-        async (ctx, args: any) => {
-          const builder = await resolveService(ctx, target)
-          if (typeof builder.create !== 'function') {
-            throw new NaviosException(
-              `[ServiceLocator] Factory ${target.name} does not implement the create method.`,
-            )
-          }
-          return builder.create(ctx, args)
-        },
-        scope,
-      )
-    }
-
-    // @ts-expect-error
-    target[InjectableTokenMeta] = injectableToken
-
-    return target
-  }
-}

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

@@ -1 +0,0 @@
-export * from './injectable-scope.enum.mjs'

package/src/service-locator/enums/injectable-scope.enum.mts

@@ -1,10 +0,0 @@
-export enum InjectableScope {
-  /**
-   * Singleton scope: The instance is created once and shared across the application.
-   */
-  Singleton = 'Singleton',
-  /**
-   * Instance scope: A new instance is created for each injection.
-   */
-  Instance = 'Instance',
-}

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

@@ -1,8 +0,0 @@
-export enum ErrorsEnum {
-  InstanceExpired = 'InstanceExpired',
-  InstanceNotFound = 'InstanceNotFound',
-  InstanceDestroying = 'InstanceDestroying',
-  UnknownError = 'UnknownError',
-  FactoryNotFound = 'FactoryNotFound',
-  FactoryTokenNotResolved = 'FactoryTokenNotResolved',
-}

package/src/service-locator/errors/factory-not-found.mts

@@ -1,8 +0,0 @@
-import { ErrorsEnum } from './errors.enum.mjs'
-
-export class FactoryNotFound extends Error {
-  code = ErrorsEnum.FactoryNotFound
-  constructor(public name: string) {
-    super(`Factory ${name} not found`)
-  }
-}

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

@@ -1,10 +0,0 @@
-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,7 +0,0 @@
-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'
-export * from './unknown-error.mjs'

package/src/service-locator/errors/instance-destroying.mts

@@ -1,8 +0,0 @@
-import { ErrorsEnum } from './errors.enum.mjs'
-
-export class InstanceDestroying extends Error {
-  code = ErrorsEnum.InstanceDestroying
-  constructor(public name: string) {
-    super(`Instance ${name} destroying`)
-  }
-}

package/src/service-locator/errors/instance-expired.mts

@@ -1,8 +0,0 @@
-import { ErrorsEnum } from './errors.enum.mjs'
-
-export class InstanceExpired extends Error {
-  code = ErrorsEnum.InstanceExpired
-  constructor(public name: string) {
-    super(`Instance ${name} expired`)
-  }
-}

package/src/service-locator/errors/instance-not-found.mts

@@ -1,8 +0,0 @@
-import { ErrorsEnum } from './errors.enum.mjs'
-
-export class InstanceNotFound extends Error {
-  code = ErrorsEnum.InstanceNotFound
-  constructor(public name: string) {
-    super(`Instance ${name} not found`)
-  }
-}

package/src/service-locator/errors/unknown-error.mts

@@ -1,15 +0,0 @@
-import { ErrorsEnum } from './errors.enum.mjs'
-
-export class UnknownError extends Error {
-  code = ErrorsEnum.UnknownError
-  parent?: Error
-
-  constructor(message: string | Error) {
-    if (message instanceof Error) {
-      super(message.message)
-      this.parent = message
-      return
-    }
-    super(message)
-  }
-}

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

@@ -1,107 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export type EventsConfig = {
-  [event: string]: any[]
-}
-export type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, symbol | number>
-export type EventsArgs<
-  Events extends EventsConfig,
-  Name extends EventsNames<Events>,
-> = Events[Name] extends any[] ? Events[Name] : []
-
-export type ChannelEmitter<
-  Events extends EventsConfig,
-  Ns extends string,
-  E extends EventsNames<Events>,
-> = {
-  emit<Args extends EventsArgs<Events, E>>(ns: Ns, event: E, ...args: Args): Promise<any>
-}
-
-export interface EventEmitterInterface<Events extends EventsConfig> {
-  on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(
-    event: E,
-    listener: (...args: Args) => void,
-  ): () => void
-  emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(
-    event: E,
-    ...args: Args
-  ): void
-  addChannel<
-    E extends EventsNames<Events>,
-    Ns extends string,
-    Emmiter extends ChannelEmitter<Events, Ns, E>,
-  >(
-    ns: Ns,
-    event: E,
-    target: Emmiter,
-  ): () => void
-}
-
-export class EventEmitter<Events extends EventsConfig = {}>
-  implements EventEmitterInterface<Events>
-{
-  private listeners: Map<EventsNames<Events>, Set<Function>> = new Map()
-
-  on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(
-    event: E,
-    listener: (...args: Args) => void,
-  ) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, new Set())
-    }
-
-    this.listeners.get(event)!.add(listener)
-
-    return () => {
-      this.off(event, listener)
-    }
-  }
-
-  off<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(
-    event: E,
-    listener: (...args: Args) => void,
-  ) {
-    if (!this.listeners.has(event)) {
-      return
-    }
-
-    this.listeners.get(event)!.delete(listener)
-    if (this.listeners.get(event)!.size === 0) {
-      this.listeners.delete(event)
-    }
-  }
-
-  once<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(
-    event: E,
-    listener: (...args: Args) => void,
-  ) {
-    const off = this.on(event, (...args) => {
-      off()
-      // @ts-expect-error - This is a valid call
-      listener(...args)
-    })
-
-    return off
-  }
-
-  async emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(
-    event: E,
-    ...args: Args
-  ): Promise<any> {
-    if (!this.listeners.has(event)) {
-      return
-    }
-
-    return Promise.all(Array.from(this.listeners.get(event)!).map(listener => listener(...args)))
-  }
-
-  addChannel<
-    E extends EventsNames<Events>,
-    Ns extends string,
-    Emitter extends ChannelEmitter<Events, Ns, E>,
-  >(ns: Ns, event: E, target: Emitter) {
-    return this.on(event, (...args) => target.emit(ns, event, ...args))
-  }
-}

package/src/service-locator/index.mts

@@ -1,15 +0,0 @@
-export * from './decorators/index.mjs'
-export * from './enums/index.mjs'
-export * from './errors/index.mjs'
-export * from './event-emitter.mjs'
-export * from './inject.mjs'
-export * from './injection-token.mjs'
-export * from './injector.mjs'
-export * from './override.mjs'
-export * from './service-locator.mjs'
-export * from './service-locator-abstract-factory-context.mjs'
-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

@@ -1,28 +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>>
-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,3 +0,0 @@
-export interface Factory<T> {
-  create(ctx: any): Promise<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)
-    }
-  }
-}