@navios/core 0.1.15 → 0.2.1

package/src/service-locator/__tests__/injectable.spec.mts

@@ -1,171 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { z } from 'zod'
-
-import {
-  getInjectableToken,
-  Injectable,
-  InjectableType,
-} from '../decorators/index.mjs'
-import { InjectableScope } from '../enums/index.mjs'
-import { syncInject } from '../index.mjs'
-import { inject } from '../inject.mjs'
-import { InjectionToken } from '../injection-token.mjs'
-import { getServiceLocator } from '../injector.mjs'
-
-describe('Injectable decorator', () => {
-  it('should work with class', async () => {
-    @Injectable()
-    class Test {}
-
-    const value = await inject(Test)
-    expect(value).toBeInstanceOf(Test)
-  })
-
-  it('should work with inner inject', async () => {
-    @Injectable()
-    class Test {
-      makeFoo() {
-        return 'foo'
-      }
-    }
-
-    @Injectable()
-    class Test2 {
-      fooMaker = inject(Test)
-
-      async makeFoo() {
-        const fooMaker = await this.fooMaker
-        return fooMaker.makeFoo()
-      }
-    }
-
-    const value = await inject(Test2)
-    expect(value).toBeInstanceOf(Test2)
-    const result = await value.makeFoo()
-    expect(result).toBe('foo')
-  })
-
-  it('should work with factory', async () => {
-    @Injectable({ type: InjectableType.Factory })
-    class Test {
-      create() {
-        return 'foo'
-      }
-    }
-
-    const value = await inject(Test)
-    expect(value).toBe('foo')
-  })
-  it('should work with request scope', async () => {
-    @Injectable({
-      scope: InjectableScope.Instance,
-      type: InjectableType.Factory,
-    })
-    class Test {
-      create() {
-        return Date.now()
-      }
-    }
-
-    const value = await inject(Test)
-    await new Promise((resolve) => setTimeout(resolve, 10))
-    const value2 = await inject(Test)
-    expect(value).not.toBe(value2)
-  })
-
-  it('should work with injection token', async () => {
-    const token = InjectionToken.create('Test')
-
-    @Injectable({ token })
-    class Test {}
-
-    const value = await inject(token)
-    expect(value).toBeInstanceOf(Test)
-  })
-
-  it('should work with injection token and schema', async () => {
-    class TestFoo {
-      constructor(public readonly foo: string) {}
-    }
-    const token = InjectionToken.create(
-      TestFoo,
-      z.object({
-        foo: z.string(),
-      }),
-    )
-
-    @Injectable({ token, type: InjectableType.Factory })
-    class Test {
-      create(ctx: any, args: { foo: string }) {
-        return new TestFoo(args.foo)
-      }
-    }
-
-    const value = await inject(token, { foo: 'bar' })
-    const differentValue = await inject(token, { foo: 'baz' })
-    const sameValue = await inject(token, { foo: 'bar' })
-    expect(value).toBeInstanceOf(TestFoo)
-    expect(value.foo).toBe('bar')
-    expect(differentValue).toBeInstanceOf(TestFoo)
-    expect(differentValue.foo).toBe('baz')
-    expect(value).not.toBe(differentValue)
-    expect(value).toBe(sameValue)
-  })
-  it('should work with invalidation', async () => {
-    @Injectable()
-    class Test {
-      value = Date.now()
-    }
-
-    @Injectable()
-    class Test2 {
-      test = inject(Test)
-
-      async makeFoo() {
-        const test = await this.test
-        return test.value
-      }
-    }
-    const identifier = getServiceLocator().getInstanceIdentifier(
-      getInjectableToken(Test),
-      undefined,
-    )
-    const inst1 = await inject(Test2)
-    expect(inst1).toBeInstanceOf(Test2)
-    const result1 = await inst1.makeFoo()
-    const inst2 = await inject(Test2)
-    expect(inst1).toBe(inst2)
-    const result2 = await inst2.makeFoo()
-    await getServiceLocator().invalidate(identifier)
-    await new Promise((resolve) => setTimeout(resolve, 10))
-    const inst3 = await inject(Test2)
-    expect(inst1).not.toBe(inst3)
-    const result3 = await inst3.makeFoo()
-    expect(result1).not.toBe(result3)
-    expect(result2).not.toBe(result3)
-    expect(result1).toBe(result2)
-  })
-
-  it('should work with syncInject', async () => {
-    @Injectable()
-    class Test {
-      value = Date.now()
-    }
-
-    @Injectable()
-    class Test2 {
-      test = syncInject(Test)
-
-      makeFoo() {
-        return this.test.value
-      }
-    }
-    const inst1 = await inject(Test2)
-    expect(inst1).toBeInstanceOf(Test2)
-    const result1 = inst1.makeFoo()
-    const inst2 = await inject(Test2)
-    expect(inst1).toBe(inst2)
-    const result2 = await inst2.makeFoo()
-    expect(result1).toBe(result2)
-  })
-})

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

@@ -1,129 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { z } from 'zod'
-
-import type {
-  Factory,
-  FactoryWithArgs,
-} from '../interfaces/factory.interface.mjs'
-
-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<string>('Test')
-    @Injectable({
-      token,
-      type: InjectableType.Factory,
-    })
-    class Test implements Factory<string> {
-      async 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 implements FactoryWithArgs<string, typeof schema> {
-      async 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,113 +0,0 @@
-import type { AnyZodObject } from 'zod'
-
-import { NaviosException } from '@navios/common'
-
-import type { ClassType, ClassTypeWithInstance } from '../injection-token.mjs'
-import type {
-  Factory,
-  FactoryWithArgs,
-} from '../interfaces/factory.interface.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.for('InjectableTokenMeta')
-
-export function Injectable(): <T extends ClassType>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined> }
-export function Injectable<T extends ClassType>(options: {
-  scope?: InjectableScope
-  token: InjectionToken<T, undefined>
-}): (
-  target: T,
-  context: ClassDecoratorContext,
-) => T & {
-  [InjectableTokenMeta]: InjectionToken<InstanceType<T>, undefined>
-}
-export function Injectable<R>(options: {
-  scope?: InjectableScope
-  type: InjectableType.Factory
-}): <T extends ClassTypeWithInstance<Factory<R>>>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
-export function Injectable<R, S extends AnyZodObject>(options: {
-  scope?: InjectableScope
-  type: InjectableType.Factory
-  token: InjectionToken<R, S>
-}): <T extends ClassTypeWithInstance<FactoryWithArgs<R, S>>>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<R, S> }
-export function Injectable<R>(options: {
-  scope?: InjectableScope
-  type: InjectableType.Factory
-  token: InjectionToken<R, undefined>
-}): <T extends ClassTypeWithInstance<Factory<R>>>(
-  target: T,
-  context: ClassDecoratorContext,
-) => T & { [InjectableTokenMeta]: InjectionToken<R, undefined> }
-export function Injectable({
-  scope = InjectableScope.Singleton,
-  type = InjectableType.Class,
-  token,
-}: InjectableOptions = {}) {
-  return <T extends ClassType>(
-    target: T,
-    context: ClassDecoratorContext,
-  ): T & {
-    [InjectableTokenMeta]: InjectionToken<any, any>
-  } => {
-    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 as T & {
-      [InjectableTokenMeta]: InjectionToken<any, any>
-    }
-  }
-}

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'