@navios/di 0.1.0

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@navios/di",
+  "version": "0.1.0",
+  "author": {
+    "name": "Oleksandr Hanzha",
+    "email": "alex@granted.name"
+  },
+  "repository": {
+    "directory": "packages/di",
+    "type": "git",
+    "url": "https://github.com/Arilas/navios.git"
+  },
+  "license": "MIT",
+  "typings": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "peerDependencies": {
+    "@navios/common": "^0.1.5",
+    "zod": "^3.23.8"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@navios/common": "^0.1.5",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "zod": "^3.24.4"
+  },
+  "dependencies": {
+    "@fastify/cors": "^11.0.1",
+    "@fastify/multipart": "^9.0.3",
+    "fastify": "^5.3.2",
+    "fastify-type-provider-zod": "^4.0.2"
+  }
+}

package/src/__tests__/injectable.spec.mts

@@ -0,0 +1,167 @@
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod'
+
+import { Injectable } from '../decorators/index.mjs'
+import { InjectableScope, InjectableType } from '../enums/index.mjs'
+import { syncInject } from '../index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+import { getGlobalServiceLocator, inject } from '../injector.mjs'
+import { getInjectableToken } from '../utils/index.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 = getGlobalServiceLocator().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 getGlobalServiceLocator().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/__tests__/injection-token.spec.mts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod'
+
+import type { Factory, FactoryWithArgs } from '../interfaces/index.mjs'
+
+import { Injectable } from '../decorators/index.mjs'
+import { InjectableType } from '../enums/index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+import { inject } from '../injector.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/decorators/index.mts

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

package/src/decorators/injectable.decorator.mts

@@ -0,0 +1,107 @@
+import type { AnyZodObject } from 'zod'
+
+import { NaviosException } from '@navios/common'
+
+import type { ClassType, ClassTypeWithInstance } from '../injection-token.mjs'
+import type { Factory, FactoryWithArgs } from '../interfaces/index.mjs'
+import type { Registry } from '../registry.mjs'
+
+import { InjectableScope, InjectableType } from '../enums/index.mjs'
+import { InjectionToken } from '../injection-token.mjs'
+import { globalRegistry } from '../registry.mjs'
+import { resolveService } from '../resolve-service.mjs'
+
+export interface InjectableOptions {
+  scope?: InjectableScope
+  type?: InjectableType
+  token?: InjectionToken<any, any>
+  registry?: Registry
+}
+
+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,
+  registry = globalRegistry,
+}: 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)
+    if (type === InjectableType.Class) {
+      registry.set(
+        injectableToken,
+        async (ctx) => resolveService(ctx, target),
+        scope,
+      )
+    } else if (type === InjectableType.Factory) {
+      registry.set(
+        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/enums/index.mts

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

package/src/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/enums/injectable-type.enum.mts

@@ -0,0 +1,4 @@
+export enum InjectableType {
+  Class = 'Class',
+  Factory = 'Factory',
+}

package/src/errors/errors.enum.mts

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

package/src/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/errors/factory-token-not-resolved.mts

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

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

@@ -0,0 +1,16 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import type { ServiceLocatorEventBus } from './service-locator-event-bus.mjs'
+import type { ServiceLocator } from './service-locator.mjs'
+import type { Injectors } from './utils/index.mjs'
+
+export interface FactoryContext {
+  inject: Injectors['inject']
+  on: ServiceLocatorEventBus['on']
+  getDependencies: () => string[]
+  invalidate: () => void
+  addEffect: (listener: () => void) => void
+  getDestroyListeners: () => (() => void)[]
+  setTtl: (ttl: number) => void
+  getTtl: () => number
+  locator: ServiceLocator
+}