@navios/core 0.1.0

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

@@ -0,0 +1,170 @@
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod'
+
+import {
+  Injectable,
+  InjectableType,
+} from '../decorators/index.mjs'
+import { InjectableScope } from '../enums/index.mjs'
+import { getInjectableToken, 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/decorators/get-injectable-token.mts

@@ -0,0 +1,23 @@
+import type {
+  ClassType,
+  ClassTypeWithInstance,
+  InjectionToken,
+} from '../injection-token.mjs'
+
+import { InjectableTokenMeta } from './injectable.decorator.mjs'
+
+export function getInjectableToken<R, T extends ClassTypeWithInstance<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

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

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

@@ -0,0 +1,103 @@
+import type { ClassType } from '../injection-token.mjs'
+
+import { InjectableScope } from '../enums/index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+import { getServiceLocator, provideServiceLocator } from '../injector.mjs'
+import { makeProxyServiceLocator } from '../proxy-service-locator.mjs'
+import { setPromiseCollector } from '../sync-injector.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 (!locator) {
+      throw new Error(
+        '[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator.',
+      )
+    }
+    if (type === InjectableType.Class) {
+      locator.registerAbstractFactory(
+        injectableToken,
+        async (ctx) => {
+          if (scope === InjectableScope.Instance) {
+            ctx.setTtl(0)
+          }
+          const proxyServiceLocator = makeProxyServiceLocator(
+            getServiceLocator(),
+            ctx,
+          )
+          const promises: Promise<any>[] = []
+          const promiseCollector = (promise: Promise<any>) => {
+            promises.push(promise)
+          }
+          const originalPromiseCollector = setPromiseCollector(promiseCollector)
+          const tryInit = () => {
+            const original = provideServiceLocator(proxyServiceLocator)
+            let result = new target()
+            provideServiceLocator(original)
+            return result
+          }
+          const result = tryInit()
+          setPromiseCollector(originalPromiseCollector)
+          if (promises.length > 0) {
+            await Promise.all(promises)
+            return tryInit()
+          }
+          return result
+        },
+        scope,
+      )
+    } else if (type === InjectableType.Factory) {
+      locator.registerAbstractFactory(
+        injectableToken,
+        async (ctx, args: any) => {
+          if (scope === InjectableScope.Instance) {
+            ctx.setTtl(0)
+          }
+          const proxyServiceLocator = makeProxyServiceLocator(
+            getServiceLocator(),
+            ctx,
+          )
+          const original = provideServiceLocator(proxyServiceLocator)
+          const builder = new target()
+          if (typeof builder.create !== 'function') {
+            throw new Error(
+              `[ServiceLocator] Factory ${target.name} does not implement the create method.`,
+            )
+          }
+          provideServiceLocator(original)
+          return builder.create(ctx, args)
+        },
+        scope,
+      )
+    }
+
+    // @ts-expect-error
+    target[InjectableTokenMeta] = injectableToken
+
+    return target
+  }
+}

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+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/index.mts

@@ -0,0 +1,6 @@
+export * from './errors.enum.mjs'
+export * from './factory-not-found.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

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

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

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

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

@@ -0,0 +1,107 @@
+/* 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

@@ -0,0 +1,14 @@
+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'

package/src/service-locator/inject.mts

@@ -0,0 +1,37 @@
+import type { AnyZodObject, z } 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>(token: InjectionToken<T, undefined>): Promise<T>
+export function inject<
+  T,
+  Token extends InjectionToken<T>,
+  S extends AnyZodObject | unknown = Token['schema'],
+>(
+  token: Token,
+  args?: S extends AnyZodObject ? z.input<S> : never,
+): Promise<T> {
+  if (token.schema) {
+    const parsed = token.schema.safeParse(args)
+    if (!parsed.success) {
+      throw new Error(
+        `[ServiceLocator] Invalid arguments for ${token.name.toString()}: ${parsed.error}`,
+      )
+    }
+  }
+  let realToken: InjectionToken<T, S> = token
+  if (!(token instanceof InjectionToken)) {
+    realToken = getInjectableToken(token) as InjectionToken<T, S>
+  }
+
+  return getServiceLocator().getOrThrowInstance(realToken, args)
+}

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

@@ -0,0 +1,36 @@
+import type { AnyZodObject } from 'zod'
+
+import { randomUUID } from 'crypto'
+
+export type ClassType = new (...args: any[]) => any
+
+export type ClassTypeWithInstance<T> = new (...args: any[]) => T
+
+export class InjectionToken<T, S extends 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>(
+    name: T,
+    schema: Schema,
+  ): InjectionToken<InstanceType<T>, Schema>
+  static create<T>(name: string): InjectionToken<T, undefined>
+  static create<T, Schema extends AnyZodObject>(
+    name: string,
+    schema: Schema,
+  ): InjectionToken<T, Schema>
+  static create(name: string, schema?: unknown) {
+    // @ts-expect-error
+    return new InjectionToken(name, schema)
+  }
+
+  toString() {
+    return this.name
+  }
+}

package/src/service-locator/injector.mts

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

@@ -0,0 +1,3 @@
+export interface Factory<T> {
+  create(ctx: any): Promise<T>
+}

package/src/service-locator/override.mts

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