@navios/core 0.1.0

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

@@ -0,0 +1,445 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import type { AnyZodObject, z } from 'zod'
+
+import type { ServiceLocatorAbstractFactoryContext } from './service-locator-abstract-factory-context.mjs'
+import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
+
+import { InjectableScope } from './enums/index.mjs'
+import { ErrorsEnum, FactoryNotFound, UnknownError } from './errors/index.mjs'
+import { getInjectableToken } from './index.mjs'
+import { InjectionToken } from './injection-token.mjs'
+import { ServiceLocatorEventBus } from './service-locator-event-bus.mjs'
+import {
+  ServiceLocatorInstanceHolderKind,
+  ServiceLocatorInstanceHolderStatus,
+} from './service-locator-instance-holder.mjs'
+import { ServiceLocatorManager } from './service-locator-manager.mjs'
+
+export class ServiceLocator {
+  private abstractFactories: Map<
+    InjectionToken<any, any>,
+    (ctx: ServiceLocatorAbstractFactoryContext, ...args: any) => Promise<any>
+  > = new Map()
+  private instanceFactories: Map<
+    InjectionToken<any, any>,
+    (ctx: ServiceLocatorAbstractFactoryContext, ...args: any) => Promise<any>
+  > = new Map()
+
+  private readonly eventBus: ServiceLocatorEventBus
+  private readonly manager: ServiceLocatorManager
+
+  constructor(private readonly logger: Console | null = null) {
+    this.eventBus = new ServiceLocatorEventBus(logger)
+    this.manager = new ServiceLocatorManager(logger)
+  }
+
+  getEventBus() {
+    return this.eventBus
+  }
+
+  public registerInstance<Instance>(
+    token: InjectionToken<Instance, undefined>,
+    instance: Instance,
+  ): void {
+    const instanceName = this.getInstanceIdentifier(token, undefined)
+    this.manager.set(instanceName, {
+      name: instanceName,
+      instance,
+      status: ServiceLocatorInstanceHolderStatus.Created,
+      kind: ServiceLocatorInstanceHolderKind.Instance,
+      createdAt: Date.now(),
+      ttl: Infinity,
+      deps: [],
+      destroyListeners: [],
+      effects: [],
+      destroyPromise: null,
+      creationPromise: null,
+    })
+  }
+
+  public removeInstance<Instance>(token: InjectionToken<Instance, undefined>) {
+    const instanceName = this.getInstanceIdentifier(token, undefined)
+    return this.invalidate(instanceName)
+  }
+
+  public registerAbstractFactory<
+    Instance,
+    Schema extends AnyZodObject | undefined,
+  >(
+    token: InjectionToken<Instance, Schema>,
+    factory: (
+      ctx: ServiceLocatorAbstractFactoryContext,
+      values: Schema extends AnyZodObject ? z.output<Schema> : undefined,
+    ) => Promise<Instance>,
+    type: InjectableScope = InjectableScope.Singleton,
+  ) {
+    this.logger?.log(
+      `[ServiceLocator]#registerAbstractFactory(): Registering abstract factory for ${name}`,
+    )
+    if (type === InjectableScope.Instance) {
+      this.instanceFactories.set(token, factory)
+      this.abstractFactories.delete(token)
+    } else {
+      this.abstractFactories.set(token, factory)
+      this.instanceFactories.delete(token)
+    }
+  }
+
+  public getInstanceIdentifier<
+    Instance,
+    Schema extends AnyZodObject | undefined,
+  >(
+    token: InjectionToken<Instance, Schema>,
+    args: Schema extends AnyZodObject ? z.input<Schema> : undefined,
+  ): string {
+    const validatedArgs = token.schema
+      ? token.schema.safeParse(args)
+      : undefined
+    if (validatedArgs && !validatedArgs.success) {
+      this.logger?.error(
+        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
+        validatedArgs.error,
+      )
+      throw new UnknownError(validatedArgs.error)
+    }
+    return this.makeInstanceName(token, validatedArgs)
+  }
+
+  public async getInstance<Instance, Schema extends AnyZodObject | undefined>(
+    token: InjectionToken<Instance, Schema>,
+    args: Schema extends AnyZodObject ? z.input<Schema> : undefined,
+  ): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]> {
+    const validatedArgs = token.schema
+      ? token.schema.safeParse(args)
+      : undefined
+    if (validatedArgs && !validatedArgs.success) {
+      this.logger?.error(
+        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
+        validatedArgs.error,
+      )
+      return [new UnknownError(validatedArgs.error)]
+    }
+    const instanceName = this.makeInstanceName(token, validatedArgs)
+    const [error, holder] = this.manager.get(instanceName)
+    if (!error) {
+      if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) {
+        // @ts-expect-error TS2322 We should redefine the instance name type
+        return holder.creationPromise
+      } else if (
+        holder.status === ServiceLocatorInstanceHolderStatus.Destroying
+      ) {
+        // Should never happen
+        return [new UnknownError(ErrorsEnum.InstanceDestroying)]
+      }
+      // @ts-expect-error We should redefine the instance name type
+      return [undefined, holder.instance]
+    }
+    switch (error.code) {
+      case ErrorsEnum.InstanceDestroying:
+        this.logger?.log(
+          `[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`,
+        )
+        await holder?.destroyPromise
+        //Maybe we already have a new instance
+        return this.getInstance<Instance, Schema>(token, args)
+
+      case ErrorsEnum.InstanceExpired:
+        this.logger?.log(
+          `[ServiceLocator]#getInstance() TTL expired for ${holder?.name}`,
+        )
+        await this.invalidate(instanceName)
+        //Maybe we already have a new instance
+        return this.getInstance<Instance, Schema>(token, args)
+      case ErrorsEnum.InstanceNotFound:
+        break
+      default:
+        return [error]
+    }
+    return this.createInstance(instanceName, token, args)
+  }
+
+  public async getOrThrowInstance<
+    Instance,
+    Schema extends AnyZodObject | undefined,
+  >(
+    token: InjectionToken<Instance, Schema>,
+    args: Schema extends AnyZodObject ? z.input<Schema> : undefined,
+  ): Promise<Instance> {
+    const [error, instance] = await this.getInstance(token, args)
+    if (error) {
+      throw error
+    }
+    return instance
+  }
+
+  private notifyListeners(
+    name: string,
+    event: 'create' | 'destroy' = 'create',
+  ) {
+    this.logger?.log(
+      `[ServiceLocator]#notifyListeners() Notifying listeners for ${name} with event ${event}`,
+    )
+    return this.eventBus.emit(name, event)
+  }
+
+  private async createInstance<
+    Instance,
+    Schema extends AnyZodObject | undefined,
+  >(
+    instanceName: string,
+    token: InjectionToken<Instance, Schema>,
+    args: Schema extends AnyZodObject ? z.input<Schema> : undefined,
+  ): Promise<[undefined, Instance] | [FactoryNotFound | UnknownError]> {
+    this.logger?.log(
+      `[ServiceLocator]#createInstance() Creating instance for ${instanceName}`,
+    )
+    if (
+      this.abstractFactories.has(token) ||
+      this.instanceFactories.has(token)
+    ) {
+      return this.createInstanceFromAbstractFactory(instanceName, token, args)
+    } else {
+      return [new FactoryNotFound(token.name.toString())]
+    }
+  }
+
+  private async createInstanceFromAbstractFactory<
+    Instance,
+    Schema extends AnyZodObject | undefined,
+    Args extends Schema extends AnyZodObject ? z.input<Schema> : undefined,
+  >(
+    instanceName: string,
+    token: InjectionToken<Instance, Schema>,
+    args: Args,
+  ): Promise<[undefined, Instance] | [FactoryNotFound]> {
+    this.logger?.log(
+      `[ServiceLocator]#createInstanceFromAbstractFactory(): Creating instance for ${instanceName} from abstract factory`,
+    )
+    const ctx = this.createContextForAbstractFactory(instanceName)
+    let shouldStore = true
+    let abstractFactory = this.abstractFactories.get(token)
+    if (!abstractFactory) {
+      abstractFactory = this.instanceFactories.get(token)
+      shouldStore = false
+      if (!abstractFactory) {
+        return [new FactoryNotFound(token.name.toString())]
+      }
+    }
+    const holder: ServiceLocatorInstanceHolder<Instance> = {
+      name: instanceName,
+      instance: null,
+      status: ServiceLocatorInstanceHolderStatus.Creating,
+      kind: ServiceLocatorInstanceHolderKind.AbstractFactory,
+      // @ts-expect-error TS2322 This is correct type
+      creationPromise: abstractFactory(ctx, args)
+        .then(async (instance: Instance) => {
+          holder.instance = instance
+          holder.status = ServiceLocatorInstanceHolderStatus.Created
+          holder.deps = ctx.getDependencies()
+          holder.destroyListeners = ctx.getDestroyListeners()
+          holder.ttl = ctx.getTtl()
+          if (holder.deps.length > 0) {
+            this.logger?.log(
+              `[ServiceLocator]#createInstanceFromAbstractFactory(): Adding subscriptions for ${instanceName} dependencies for their invalidations: ${holder.deps.join(
+                ', ',
+              )}`,
+            )
+            holder.deps.forEach((dependency) => {
+              holder.destroyListeners.push(
+                this.eventBus.on(dependency, 'destroy', () =>
+                  this.invalidate(instanceName),
+                ),
+              )
+            })
+          }
+          if (holder.ttl === 0) {
+            // One time instance
+            await this.invalidate(instanceName)
+          }
+          await this.notifyListeners(instanceName)
+          return [undefined, instance as Instance]
+        })
+        .catch((error) => {
+          this.logger?.error(
+            `[ServiceLocator]#createInstanceFromAbstractFactory(): Error creating instance for ${instanceName}`,
+            error,
+          )
+          return [new UnknownError(error)]
+        }),
+      effects: [],
+      deps: [],
+      destroyListeners: [],
+      createdAt: Date.now(),
+      ttl: Infinity,
+    }
+
+    if (shouldStore) {
+      this.manager.set(instanceName, holder)
+    }
+    // @ts-expect-error TS2322 This is correct type
+    return holder.creationPromise
+  }
+
+  private createContextForAbstractFactory(
+    instanceName: string,
+  ): ServiceLocatorAbstractFactoryContext {
+    const dependencies = new Set<string>()
+    const destroyListeners = new Set<() => void>()
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this
+
+    function invalidate(name = instanceName) {
+      return self.invalidate(name)
+    }
+    function addEffect(listener: () => void) {
+      destroyListeners.add(listener)
+    }
+    let ttl = Infinity
+    function setTtl(value: number) {
+      ttl = value
+    }
+    function getTtl() {
+      return ttl
+    }
+
+    function on(key: string, event: string, listener: (event: string) => void) {
+      destroyListeners.add(self.eventBus.on(key, event, listener))
+    }
+
+    return {
+      // @ts-expect-error This is correct type
+      async inject(token, args) {
+        let injectionToken = token
+        if (typeof token === 'function') {
+          injectionToken = getInjectableToken(token)
+        }
+        if (injectionToken instanceof InjectionToken) {
+          const validatedArgs = token.schema
+            ? token.schema.safeParse(args)
+            : undefined
+          const instanceName = self.makeInstanceName(token, validatedArgs)
+          dependencies.add(instanceName)
+          // @ts-expect-error TS2322 This is correct type
+          return self.getOrThrowInstance(injectionToken, args)
+        }
+        throw new Error(
+          `[ServiceLocator]#inject(): Invalid token type: ${typeof token}. Expected a class or an InjectionToken.`,
+        )
+      },
+      invalidate,
+      eventBus: self.eventBus,
+      on: on as ServiceLocatorEventBus['on'],
+      getDependencies: () => Array.from(dependencies),
+      addEffect,
+      getDestroyListeners: () => Array.from(destroyListeners),
+      setTtl,
+      getTtl,
+    }
+  }
+
+  public getSyncInstance<Instance, Schema extends AnyZodObject | undefined>(
+    token: InjectionToken<Instance, Schema>,
+    args: Schema extends AnyZodObject ? z.input<Schema> : undefined,
+  ): Instance | null {
+    const validatedArgs = token.schema
+      ? token.schema.safeParse(args)
+      : undefined
+    if (validatedArgs && !validatedArgs.success) {
+      this.logger?.error(
+        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
+        validatedArgs.error,
+      )
+      throw new UnknownError(validatedArgs.error)
+    }
+    const instanceName = this.makeInstanceName(token, validatedArgs)
+    const [error, holder] = this.manager.get(instanceName)
+    if (error) {
+      return null
+    }
+    return holder.instance as Instance
+  }
+
+  invalidate(service: string, round = 1): Promise<any> {
+    this.logger?.log(
+      `[ServiceLocator]#invalidate(): Starting Invalidating process of ${service}`,
+    )
+    const toInvalidate = this.manager.filter(
+      (holder) => holder.name === service || holder.deps.includes(service),
+    )
+    const promises = []
+    for (const [key, holder] of toInvalidate.entries()) {
+      if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) {
+        this.logger?.trace(
+          `[ServiceLocator]#invalidate(): ${key} is already being destroyed`,
+        )
+        promises.push(holder.destroyPromise)
+        continue
+      }
+      if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) {
+        this.logger?.trace(
+          `[ServiceLocator]#invalidate(): ${key} is being created, waiting for creation to finish`,
+        )
+        promises.push(
+          holder.creationPromise?.then(() => {
+            if (round > 3) {
+              this.logger?.error(
+                `[ServiceLocator]#invalidate(): ${key} creation is triggering a new invalidation round, but it is still not created`,
+              )
+              return
+            }
+            return this.invalidate(key, round + 1)
+          }),
+        )
+        continue
+      }
+      // @ts-expect-error TS2322 we are changing the status
+      holder.status = ServiceLocatorInstanceHolderStatus.Destroying
+      this.logger?.log(
+        `[ServiceLocator]#invalidate(): Invalidating ${key} and notifying listeners`,
+      )
+      // @ts-expect-error TS2322 we are changing the status
+      holder.destroyPromise = Promise.all(
+        holder.destroyListeners.map((listener) => listener()),
+      ).then(async () => {
+        this.manager.delete(key)
+        await this.notifyListeners(key, 'destroy')
+      })
+      promises.push(holder.destroyPromise)
+    }
+    return Promise.all(promises)
+  }
+
+  async ready() {
+    return Promise.all(
+      Array.from(this.manager.filter(() => true)).map(([, holder]) => {
+        if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) {
+          return holder.creationPromise?.then(() => null)
+        }
+        if (holder.status === ServiceLocatorInstanceHolderStatus.Destroying) {
+          return holder.destroyPromise.then(() => null)
+        }
+        return Promise.resolve(null)
+      }),
+    ).then(() => null)
+  }
+
+  makeInstanceName(token: InjectionToken<any, any>, args: any) {
+    let stringifiedArgs = args
+      ? ':' +
+        JSON.stringify(args)
+          .replaceAll(/"/g, '')
+          .replaceAll(/:/g, '=')
+          .replaceAll(/,/g, '|')
+      : ''
+    const { name } = token
+    if (typeof name === 'function') {
+      const className = name.name
+      return `${className}(${token.id})${stringifiedArgs}`
+    } else if (typeof name === 'symbol') {
+      return `${name.toString()}(${token.id})${stringifiedArgs}`
+    } else {
+      return `${name}(${token.id})${stringifiedArgs}`
+    }
+  }
+}

package/src/service-locator/sync-injector.mts

@@ -0,0 +1,55 @@
+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'
+
+let promiseCollector: null | ((promise: Promise<any>) => void) = null
+
+export function syncInject<T extends ClassType>(token: T): InstanceType<T>
+export function syncInject<T, S extends AnyZodObject>(
+  token: InjectionToken<T, S>,
+  args: z.input<S>,
+): T
+export function syncInject<T>(token: InjectionToken<T, undefined>): T
+export function syncInject<
+  T,
+  Token extends InjectionToken<T>,
+  S extends AnyZodObject | unknown = Token['schema'],
+>(token: Token, args?: S extends AnyZodObject ? z.input<S> : never): 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>
+  }
+
+  const instance = getServiceLocator().getSyncInstance(realToken, args)
+  if (!instance) {
+    if (promiseCollector) {
+      const promise = getServiceLocator().getInstance(realToken, args)
+      promiseCollector(promise)
+    } else {
+      throw new Error(
+        `[ServiceLocator] No instance found for ${realToken.name.toString()}`,
+      )
+    }
+  }
+  return instance as unknown as T
+}
+
+export function setPromiseCollector(
+  collector: null | ((promise: Promise<any>) => void),
+): typeof promiseCollector {
+  const original = promiseCollector
+  promiseCollector = collector
+  return original
+}

package/src/services/controller-adapter.service.mts

@@ -0,0 +1,124 @@
+import type { FastifyInstance } from 'fastify'
+import type { ZodTypeProvider } from 'fastify-type-provider-zod'
+
+import type { ModuleMetadata } from '../metadata/index.mjs'
+import type { ClassType } from '../service-locator/index.mjs'
+
+import { HttpException } from '../exceptions/index.mjs'
+import { extractControllerMetadata } from '../metadata/index.mjs'
+import {
+  getServiceLocator,
+  inject,
+  Injectable,
+  syncInject,
+} from '../service-locator/index.mjs'
+import { ExecutionContextToken, Reply, Request } from '../tokens/index.mjs'
+import { ExecutionContext } from './execution-context.mjs'
+import { GuardRunnerService } from './guard-runner.service.mjs'
+
+@Injectable()
+export class ControllerAdapterService {
+  guardRunner = syncInject(GuardRunnerService)
+
+  setupController(
+    controller: ClassType,
+    instance: FastifyInstance,
+    moduleMetadata: ModuleMetadata,
+  ): void {
+    const controllerMetadata = extractControllerMetadata(controller)
+    for (const endpoint of controllerMetadata.endpoints) {
+      const { classMethod, url, httpMethod, config } = endpoint
+
+      if (!url || !config) {
+        throw new Error(
+          `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`,
+        )
+      }
+      const executionContext = new ExecutionContext(
+        moduleMetadata,
+        controllerMetadata,
+        endpoint,
+      )
+      const guards = this.guardRunner.makeContext(executionContext)
+      const { querySchema, requestSchema, responseSchema } = config
+      const schema: Record<string, any> = {}
+      if (querySchema) {
+        schema.querystring = querySchema
+      }
+      if (requestSchema) {
+        schema.body = requestSchema
+      }
+      if (responseSchema) {
+        schema.response = {
+          200: responseSchema,
+        }
+      }
+      instance.withTypeProvider<ZodTypeProvider>().route({
+        method: httpMethod,
+        url: url.replaceAll('$', ':'),
+        schema,
+        preHandler: async (request, reply) => {
+          if (guards.size > 0) {
+            getServiceLocator().registerInstance(Request, request)
+            getServiceLocator().registerInstance(Reply, reply)
+            getServiceLocator().registerInstance(
+              ExecutionContextToken,
+              executionContext,
+            )
+            executionContext.provideRequest(request)
+            executionContext.provideReply(reply)
+            const canActivate = await this.guardRunner.runGuards(
+              guards,
+              executionContext,
+            )
+            getServiceLocator().removeInstance(Request)
+            getServiceLocator().removeInstance(Reply)
+            getServiceLocator().removeInstance(ExecutionContextToken)
+            if (!canActivate) {
+              return reply
+            }
+          }
+        },
+        handler: async (request, reply) => {
+          getServiceLocator().registerInstance(Request, request)
+          getServiceLocator().registerInstance(Reply, reply)
+          getServiceLocator().registerInstance(
+            ExecutionContextToken,
+            executionContext,
+          )
+          executionContext.provideRequest(request)
+          executionContext.provideReply(reply)
+          const controllerInstance = await inject(controller)
+          try {
+            const { query, params, body } = request
+            const argument: Record<string, any> = {}
+            if (query && Object.keys(query).length > 0) {
+              argument.params = query
+            }
+            if (params && Object.keys(params).length > 0) {
+              argument.urlParams = params
+            }
+            if (body) {
+              argument.data = body
+            }
+            const result = await controllerInstance[classMethod](argument)
+            reply.status(200).send(result)
+          } catch (error) {
+            if (error instanceof HttpException) {
+              reply.status(error.statusCode).send(error.response)
+            } else {
+              reply.status(500).send({
+                message: 'Internal server error',
+                error: (error as Error).message,
+              })
+            }
+          } finally {
+            getServiceLocator().removeInstance(Request)
+            getServiceLocator().removeInstance(Reply)
+            getServiceLocator().removeInstance(ExecutionContextToken)
+          }
+        },
+      })
+    }
+  }
+}

package/src/services/execution-context.mts

@@ -0,0 +1,53 @@
+import type { FastifyReply, FastifyRequest } from 'fastify'
+
+import type {
+  ControllerMetadata,
+  EndpointMetadata,
+  ModuleMetadata,
+} from '../metadata/index.mjs'
+
+export class ExecutionContext {
+  private request: FastifyRequest | undefined
+  private reply: FastifyReply | undefined
+  constructor(
+    private readonly module: ModuleMetadata,
+    private readonly controller: ControllerMetadata,
+    private readonly handler: EndpointMetadata,
+  ) {}
+  getModule(): ModuleMetadata {
+    return this.module
+  }
+
+  getController(): ControllerMetadata {
+    return this.controller
+  }
+
+  getHandler(): EndpointMetadata {
+    return this.handler
+  }
+
+  getRequest(): FastifyRequest {
+    if (!this.request) {
+      throw new Error(
+        '[Navios] Request is not set. Make sure to set it before using it.',
+      )
+    }
+    return this.request
+  }
+
+  getReply(): FastifyReply {
+    if (!this.reply) {
+      throw new Error(
+        '[Navios] Reply is not set. Make sure to set it before using it.',
+      )
+    }
+    return this.reply
+  }
+
+  provideRequest(request: FastifyRequest): void {
+    this.request = request
+  }
+  provideReply(reply: FastifyReply): void {
+    this.reply = reply
+  }
+}