@navios/core 0.1.0

package/src/services/guard-runner.service.mts

@@ -0,0 +1,93 @@
+import type { CanActivate } from '../interfaces/index.mjs'
+import type { ClassTypeWithInstance } from '../service-locator/index.mjs'
+import type { ExecutionContext } from './execution-context.mjs'
+
+import { HttpException } from '../exceptions/index.mjs'
+import {
+  inject,
+  Injectable,
+  InjectionToken,
+} from '../service-locator/index.mjs'
+
+@Injectable()
+export class GuardRunnerService {
+  async runGuards(
+    allGuards: Set<
+      | ClassTypeWithInstance<CanActivate>
+      | InjectionToken<CanActivate, undefined>
+    >,
+    executionContext: ExecutionContext,
+  ) {
+    let canActivate = true
+    for (const guard of Array.from(allGuards).reverse()) {
+      const guardInstance = await inject(
+        guard as InjectionToken<CanActivate, undefined>,
+      )
+      if (!guardInstance.canActivate) {
+        throw new Error(
+          `[Navios] Guard ${guard.name as string} does not implement canActivate()`,
+        )
+      }
+      try {
+        canActivate = await guardInstance.canActivate(executionContext)
+        if (!canActivate) {
+          break
+        }
+      } catch (error) {
+        if (error instanceof HttpException) {
+          executionContext
+            .getReply()
+            .status(error.statusCode)
+            .send(error.response)
+          return false
+        } else {
+          executionContext
+            .getReply()
+            .status(500)
+            .send({
+              message: 'Internal server error',
+              error: (error as Error).message,
+            })
+          return false
+        }
+      }
+    }
+    if (!canActivate) {
+      executionContext.getReply().status(403).send({
+        message: 'Forbidden',
+      })
+      return false
+    }
+    return canActivate
+  }
+
+  makeContext(
+    executionContext: ExecutionContext,
+  ): Set<
+    ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
+  > {
+    const guards = new Set<
+      | ClassTypeWithInstance<CanActivate>
+      | InjectionToken<CanActivate, undefined>
+    >()
+    const endpointGuards = executionContext.getHandler().guards
+    const controllerGuards = executionContext.getController().guards
+    const moduleGuards = executionContext.getModule().guards
+    if (endpointGuards.size > 0) {
+      for (const guard of endpointGuards) {
+        guards.add(guard)
+      }
+    }
+    if (controllerGuards.size > 0) {
+      for (const guard of controllerGuards) {
+        guards.add(guard)
+      }
+    }
+    if (moduleGuards.size > 0) {
+      for (const guard of moduleGuards) {
+        guards.add(guard)
+      }
+    }
+    return guards
+  }
+}

package/src/services/index.mts

@@ -0,0 +1,4 @@
+export * from './controller-adapter.service.mjs'
+export * from './execution-context.mjs'
+export * from './guard-runner.service.mjs'
+export * from './module-loader.service.mjs'

package/src/services/module-loader.service.mts

@@ -0,0 +1,68 @@
+import type { NaviosModule } from '../interfaces/index.mjs'
+import type { ModuleMetadata } from '../metadata/index.mjs'
+import type { ClassTypeWithInstance } from '../service-locator/index.mjs'
+
+import { extractModuleMetadata } from '../metadata/index.mjs'
+import { inject, Injectable } from '../service-locator/index.mjs'
+
+@Injectable()
+export class ModuleLoaderService {
+  private modulesMetadata: Map<string, ModuleMetadata> = new Map()
+  private loadedModules: Map<string, any> = new Map()
+  private initialized = false
+
+  async loadModules(appModule: ClassTypeWithInstance<NaviosModule>) {
+    if (this.initialized) {
+      return
+    }
+    await this.traverseModules(appModule)
+    this.initialized = true
+  }
+
+  private async traverseModules(
+    module: ClassTypeWithInstance<NaviosModule>,
+    parentMetadata?: ModuleMetadata,
+  ) {
+    const metadata = extractModuleMetadata(module)
+    if (parentMetadata) {
+      this.mergeMetadata(metadata, parentMetadata)
+    }
+    const moduleName = module.name
+    if (this.modulesMetadata.has(moduleName)) {
+      return
+    }
+    this.modulesMetadata.set(moduleName, metadata)
+    const imports = metadata.imports ?? new Set()
+    const loadingPromises = Array.from(imports).map(async (importedModule) =>
+      this.traverseModules(importedModule, metadata),
+    )
+    await Promise.all(loadingPromises)
+    const instance = await inject(module)
+    if (instance.onModuleInit) {
+      await instance.onModuleInit()
+    }
+    this.loadedModules.set(moduleName, instance)
+  }
+
+  private mergeMetadata(
+    metadata: ModuleMetadata,
+    parentMetadata: ModuleMetadata,
+  ): void {
+    if (parentMetadata.guards) {
+      for (const guard of parentMetadata.guards) {
+        metadata.guards.add(guard)
+      }
+    }
+    if (parentMetadata.customAttributes) {
+      for (const [key, value] of parentMetadata.customAttributes) {
+        if (metadata.customAttributes.has(key)) {
+          continue
+        }
+        metadata.customAttributes.set(key, value)
+      }
+    }
+  }
+  getAllModules(): Map<string, ModuleMetadata> {
+    return this.modulesMetadata
+  }
+}

package/src/tokens/application.token.mts

@@ -0,0 +1,9 @@
+import type { FastifyInstance } from 'fastify'
+
+import { InjectionToken } from '../service-locator/index.mjs'
+
+const ApplicationInjectionToken = 'ApplicationInjectionToken'
+
+export const Application = InjectionToken.create<FastifyInstance>(
+  ApplicationInjectionToken,
+)

package/src/tokens/execution-context.token.mts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '../service-locator/index.mjs'
+import { ExecutionContext } from '../services/index.mjs'
+
+export const ExecutionContextInjectionToken = 'ExecutionContextInjectionToken'
+
+export const ExecutionContextToken = InjectionToken.create<ExecutionContext>(
+  ExecutionContextInjectionToken,
+)

package/src/tokens/index.mts

@@ -0,0 +1,4 @@
+export * from './application.token.mjs'
+export * from './execution-context.token.mjs'
+export * from './reply.token.mjs'
+export * from './request.token.mjs'

package/src/tokens/reply.token.mts

@@ -0,0 +1,7 @@
+import type { FastifyReply } from 'fastify'
+
+import { InjectionToken } from '../service-locator/index.mjs'
+
+const ReplyInjectionToken = 'ReplyInjectionToken'
+
+export const Reply = InjectionToken.create<FastifyReply>(ReplyInjectionToken)

package/src/tokens/request.token.mts

@@ -0,0 +1,9 @@
+import type { FastifyRequest } from 'fastify'
+
+import { InjectionToken } from '../service-locator/index.mjs'
+
+const RequestInjectionToken = 'RequestInjectionToken'
+
+export const Request = InjectionToken.create<FastifyRequest>(
+  RequestInjectionToken,
+)