@navios/core 0.1.0

package/src/decorators/index.mts

@@ -0,0 +1,4 @@
+export * from './controller.decorator.mjs'
+export * from './endpoint.decorator.mjs'
+export * from './module.decorator.mjs'
+export * from './use-guards.decorator.mjs'

package/src/decorators/module.decorator.mts

@@ -0,0 +1,47 @@
+import type { ClassType } from '../service-locator/index.mjs'
+
+import { getModuleMetadata } from '../metadata/index.mjs'
+import {
+  Injectable,
+  InjectableScope,
+  InjectableType,
+  InjectionToken,
+} from '../service-locator/index.mjs'
+
+export interface ModuleOptions {
+  controllers?: ClassType[] | Set<ClassType>
+  imports?: ClassType[] | Set<ClassType>
+  guards?: ClassType[] | Set<ClassType>
+}
+
+export function Module(metadata: ModuleOptions) {
+  return (target: ClassType, context: ClassDecoratorContext) => {
+    if (context.kind !== 'class') {
+      throw new Error('[Navios] @Module decorator can only be used on classes.')
+    }
+    // Register the module in the service locator
+    const token = InjectionToken.create(target)
+    const moduleMetadata = getModuleMetadata(target, context)
+    if (metadata.controllers) {
+      for (const controller of metadata.controllers) {
+        moduleMetadata.controllers.add(controller)
+      }
+    }
+    if (metadata.imports) {
+      for (const importedModule of metadata.imports) {
+        moduleMetadata.imports.add(importedModule)
+      }
+    }
+    if (metadata.guards) {
+      for (const guard of Array.from(metadata.guards).reverse()) {
+        moduleMetadata.guards.add(guard)
+      }
+    }
+
+    return Injectable({
+      token,
+      type: InjectableType.Class,
+      scope: InjectableScope.Singleton,
+    })(target, context)
+  }
+}

package/src/decorators/use-guards.decorator.mts

@@ -0,0 +1,43 @@
+import type { CanActivate } from '../interfaces/index.mjs'
+import type {
+  ClassType,
+  ClassTypeWithInstance,
+  InjectionToken,
+} from '../service-locator/index.mjs'
+
+import {
+  getControllerMetadata,
+  getEndpointMetadata,
+} from '../metadata/index.mjs'
+
+export function UseGuards(
+  ...guards: (
+    | ClassTypeWithInstance<CanActivate>
+    | InjectionToken<CanActivate, undefined>
+  )[]
+) {
+  return function <T extends Function>(
+    target: T,
+    context: ClassMethodDecoratorContext | ClassDecoratorContext,
+  ): T {
+    if (context.kind === 'class') {
+      const controllerMetadata = getControllerMetadata(
+        target as unknown as ClassType,
+        context,
+      )
+      for (const guard of guards.reverse()) {
+        controllerMetadata.guards.add(guard)
+      }
+    } else if (context.kind === 'method') {
+      const endpointMetadata = getEndpointMetadata(target, context)
+      for (const guard of guards.reverse()) {
+        endpointMetadata.guards.add(guard)
+      }
+    } else {
+      throw new Error(
+        '[Navios] @UseGuards decorator can only be used on classes or methods.',
+      )
+    }
+    return target
+  }
+}

package/src/exceptions/bad-request.exception.mts

@@ -0,0 +1,7 @@
+import { HttpException } from './http.exception.mjs'
+
+export class BadRequestException extends HttpException {
+  constructor(message: string | object) {
+    super(400, message)
+  }
+}

package/src/exceptions/conflict.exception.mts

@@ -0,0 +1,7 @@
+import { HttpException } from './http.exception.mjs'
+
+export class ConflictException extends HttpException {
+  constructor(message: string | object, error?: Error) {
+    super(409, message, error)
+  }
+}

package/src/exceptions/forbidden.exception.mts

@@ -0,0 +1,7 @@
+import { HttpException } from './http.exception.mjs'
+
+export class ForbiddenException extends HttpException {
+  constructor(message: string) {
+    super(403, message)
+  }
+}

package/src/exceptions/http.exception.mts

@@ -0,0 +1,7 @@
+export class HttpException {
+  constructor(
+    public readonly statusCode: number,
+    public readonly response: string | object,
+    public readonly error?: Error,
+  ) {}
+}

package/src/exceptions/index.mts

@@ -0,0 +1,7 @@
+export * from './http.exception.mjs'
+export * from './bad-request.exception.mjs'
+export * from './forbidden.exception.mjs'
+export * from './internal-server-error.exception.mjs'
+export * from './not-found.exception.mjs'
+export * from './unauthorized.exception.mjs'
+export * from './conflict.exception.mjs'

package/src/exceptions/internal-server-error.exception.mts

@@ -0,0 +1,7 @@
+import { HttpException } from './http.exception.mjs'
+
+export class InternalServerErrorException extends HttpException {
+  constructor(message: string | object, error?: Error) {
+    super(500, message, error)
+  }
+}

package/src/exceptions/not-found.exception.mts

@@ -0,0 +1,10 @@
+import { HttpException } from './http.exception.mjs'
+
+export class NotFoundException extends HttpException {
+  constructor(
+    public readonly response: string | object,
+    public readonly error?: Error,
+  ) {
+    super(404, response, error)
+  }
+}

package/src/exceptions/unauthorized.exception.mts

@@ -0,0 +1,7 @@
+import { HttpException } from './http.exception.mjs'
+
+export class UnauthorizedException extends HttpException {
+  constructor(message: string | object, error?: Error) {
+    super(401, message, error)
+  }
+}

package/src/index.mts

@@ -0,0 +1,10 @@
+export * from './decorators/index.mjs'
+export * from './exceptions/index.mjs'
+export * from './interfaces/index.mjs'
+export * from './metadata/index.mjs'
+export * from './service-locator/index.mjs'
+export * from './services/index.mjs'
+export * from './tokens/index.mjs'
+export * from './attribute.factory.mjs'
+export * from './navios.application.mjs'
+export * from './navios.factory.mjs'

package/src/interfaces/can-activate.mts

@@ -0,0 +1,5 @@
+import type { ExecutionContext } from '../services/index.mjs'
+
+export interface CanActivate {
+  canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean
+}

package/src/interfaces/index.mts

@@ -0,0 +1,2 @@
+export * from './can-activate.mjs'
+export * from './navios-module.mjs'

package/src/interfaces/navios-module.mts

@@ -0,0 +1,3 @@
+export interface NaviosModule {
+  onModuleInit?: () => Promise<void> | void
+}

package/src/metadata/controller.metadata.mts

@@ -0,0 +1,71 @@
+import type { CanActivate } from '../interfaces/index.mjs'
+import type {
+  ClassType,
+  ClassTypeWithInstance,
+  InjectionToken,
+} from '../service-locator/index.mjs'
+import type { EndpointMetadata } from './endpoint.metadata.mjs'
+
+import { getAllEndpointMetadata } from './endpoint.metadata.mjs'
+
+export const ControllerMetadataKey = Symbol('ControllerMetadataKey')
+
+export interface ControllerMetadata {
+  endpoints: Set<EndpointMetadata>
+  guards: Set<
+    ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
+  >
+  customAttributes: Map<string | symbol, any>
+}
+
+export function getControllerMetadata(
+  target: ClassType,
+  context: ClassDecoratorContext,
+): ControllerMetadata {
+  if (context.metadata) {
+    const metadata = context.metadata[ControllerMetadataKey] as
+      | ControllerMetadata
+      | undefined
+    if (metadata) {
+      return metadata
+    } else {
+      const endpointsMetadata = getAllEndpointMetadata(context)
+      const newMetadata: ControllerMetadata = {
+        endpoints: endpointsMetadata,
+        guards: new Set<
+          | ClassTypeWithInstance<CanActivate>
+          | InjectionToken<CanActivate, undefined>
+        >(),
+        customAttributes: new Map<string | symbol, any>(),
+      }
+      context.metadata[ControllerMetadataKey] = newMetadata
+      // @ts-expect-error We add a custom metadata key to the target
+      target[ControllerMetadataKey] = newMetadata
+      return newMetadata
+    }
+  }
+  throw new Error('[Navios] Wrong environment.')
+}
+
+export function extractControllerMetadata(
+  target: ClassType,
+): ControllerMetadata {
+  // @ts-expect-error We add a custom metadata key to the target
+  const metadata = target[ControllerMetadataKey] as
+    | ControllerMetadata
+    | undefined
+  if (!metadata) {
+    throw new Error(
+      '[Navios] Controller metadata not found. Make sure to use @Controller decorator.',
+    )
+  }
+  return metadata
+}
+
+export function hasControllerMetadata(target: ClassType): boolean {
+  // @ts-expect-error We add a custom metadata key to the target
+  const metadata = target[ControllerMetadataKey] as
+    | ControllerMetadata
+    | undefined
+  return !!metadata
+}

package/src/metadata/endpoint.metadata.mts

@@ -0,0 +1,69 @@
+import type { BaseEndpointConfig, HttpMethod } from '@navios/common'
+
+import type { CanActivate } from '../interfaces/index.mjs'
+import type {
+  ClassTypeWithInstance,
+  InjectionToken,
+} from '../service-locator/index.mjs'
+
+export const EndpointMetadataKey = Symbol('EndpointMetadataKey')
+
+export interface EndpointMetadata {
+  classMethod: string
+  url: string
+  httpMethod: HttpMethod
+  config: BaseEndpointConfig | null
+  guards: Set<
+    ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
+  >
+  customAttributes: Map<string | symbol, any>
+}
+
+export function getAllEndpointMetadata(
+  context: ClassMethodDecoratorContext | ClassDecoratorContext,
+): Set<EndpointMetadata> {
+  if (context.metadata) {
+    const metadata = context.metadata[EndpointMetadataKey] as
+      | Set<EndpointMetadata>
+      | undefined
+    if (metadata) {
+      return metadata
+    } else {
+      context.metadata[EndpointMetadataKey] = new Set<EndpointMetadata>()
+      return context.metadata[EndpointMetadataKey] as Set<EndpointMetadata>
+    }
+  }
+  throw new Error('[Navios] Wrong environment.')
+}
+
+export function getEndpointMetadata(
+  target: Function,
+  context: ClassMethodDecoratorContext,
+): EndpointMetadata {
+  if (context.metadata) {
+    const metadata = getAllEndpointMetadata(context)
+    if (metadata) {
+      const endpointMetadata = Array.from(metadata).find(
+        (item) => item.classMethod === target.name,
+      )
+      if (endpointMetadata) {
+        return endpointMetadata
+      } else {
+        const newMetadata: EndpointMetadata = {
+          classMethod: target.name,
+          url: '',
+          httpMethod: 'GET',
+          config: null,
+          guards: new Set<
+            | ClassTypeWithInstance<CanActivate>
+            | InjectionToken<CanActivate, undefined>
+          >(),
+          customAttributes: new Map<string | symbol, any>(),
+        }
+        metadata.add(newMetadata)
+        return newMetadata
+      }
+    }
+  }
+  throw new Error('[Navios] Wrong environment.')
+}

package/src/metadata/index.mts

@@ -0,0 +1,4 @@
+export * from './controller.metadata.mjs'
+export * from './endpoint.metadata.mjs'
+export * from './injectable.metadata.mjs'
+export * from './module.metadata.mjs'

package/src/metadata/injectable.metadata.mts

@@ -0,0 +1,11 @@
+import type {
+  InjectableScope,
+  InjectableType,
+  InjectionToken,
+} from '../index.mjs'
+
+export interface InjectableMetadata<Instance = any, Schema = any> {
+  type: InjectableType
+  scope: InjectableScope
+  token: InjectionToken<Instance, Schema>
+}

package/src/metadata/module.metadata.mts

@@ -0,0 +1,62 @@
+import type { CanActivate } from '../index.mjs'
+import type {
+  ClassType,
+  ClassTypeWithInstance,
+  InjectionToken,
+} from '../service-locator/index.mjs'
+
+export const ModuleMetadataKey = Symbol('ControllerMetadataKey')
+
+export interface ModuleMetadata {
+  controllers: Set<ClassType>
+  imports: Set<ClassType>
+  guards: Set<
+    ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>
+  >
+  customAttributes: Map<string | symbol, any>
+}
+
+export function getModuleMetadata(
+  target: ClassType,
+  context: ClassDecoratorContext,
+): ModuleMetadata {
+  if (context.metadata) {
+    const metadata = context.metadata[ModuleMetadataKey] as
+      | ModuleMetadata
+      | undefined
+    if (metadata) {
+      return metadata
+    } else {
+      const newMetadata: ModuleMetadata = {
+        controllers: new Set<ClassType>(),
+        imports: new Set<ClassType>(),
+        guards: new Set<
+          | ClassTypeWithInstance<CanActivate>
+          | InjectionToken<CanActivate, undefined>
+        >(),
+        customAttributes: new Map<string | symbol, any>(),
+      }
+      context.metadata[ModuleMetadataKey] = newMetadata
+      // @ts-expect-error We add a custom metadata key to the target
+      target[ModuleMetadataKey] = newMetadata
+      return newMetadata
+    }
+  }
+  throw new Error('[Navios] Wrong environment.')
+}
+
+export function extractModuleMetadata(target: ClassType): ModuleMetadata {
+  // @ts-expect-error We add a custom metadata key to the target
+  const metadata = target[ModuleMetadataKey] as ModuleMetadata | undefined
+  if (!metadata) {
+    throw new Error(
+      '[Navios] Module metadata not found. Make sure to use @Module decorator.',
+    )
+  }
+  return metadata
+}
+
+export function hasModuleMetadata(target: ClassType): boolean {
+  // @ts-expect-error We add a custom metadata key to the target
+  return !!target[ModuleMetadataKey]
+}

package/src/navios.application.mts

@@ -0,0 +1,113 @@
+import type { FastifyCorsOptions } from '@fastify/cors'
+import type {
+  FastifyInstance,
+  FastifyListenOptions,
+  FastifyServerOptions,
+} from 'fastify'
+
+import cors from '@fastify/cors'
+import { fastify } from 'fastify'
+import {
+  serializerCompiler,
+  validatorCompiler,
+} from 'fastify-type-provider-zod'
+
+import type { NaviosModule } from './interfaces/index.mjs'
+import type { ClassTypeWithInstance } from './service-locator/index.mjs'
+
+import {
+  getServiceLocator,
+  Injectable,
+  syncInject,
+} from './service-locator/index.mjs'
+import {
+  ControllerAdapterService,
+  ModuleLoaderService,
+} from './services/index.mjs'
+import { Application } from './tokens/index.mjs'
+
+export interface NaviosApplicationOptions extends FastifyServerOptions {}
+
+@Injectable()
+export class NaviosApplication {
+  private moduleLoader = syncInject(ModuleLoaderService)
+  private controllerAdapter = syncInject(ControllerAdapterService)
+  private server: FastifyInstance | null = null
+  private corsOptions: FastifyCorsOptions | null = null
+  private globalPrefix: string | null = null
+
+  private appModule: ClassTypeWithInstance<NaviosModule> | null = null
+  private options: NaviosApplicationOptions = {}
+
+  setup(
+    appModule: ClassTypeWithInstance<NaviosModule>,
+    options: NaviosApplicationOptions = {},
+  ) {
+    this.appModule = appModule
+    this.options = options
+  }
+
+  async init() {
+    if (!this.appModule) {
+      throw new Error('App module is not set. Call setAppModule() first.')
+    }
+    await this.moduleLoader.loadModules(this.appModule)
+    this.server = fastify(this.options)
+    getServiceLocator().registerInstance(Application, this.server)
+    // Add schema validator and serializer
+    this.server.setValidatorCompiler(validatorCompiler)
+    this.server.setSerializerCompiler(serializerCompiler)
+
+    if (this.corsOptions) {
+      await this.server.register(cors, this.corsOptions)
+    }
+    const modules = this.moduleLoader.getAllModules()
+    const globalPrefix = this.globalPrefix ?? ''
+    for (const [moduleName, moduleMetadata] of modules) {
+      if (
+        !moduleMetadata.controllers ||
+        moduleMetadata.controllers.size === 0
+      ) {
+        continue
+      }
+      this.server.register(
+        (instance, opts, done) => {
+          for (const controller of moduleMetadata.controllers) {
+            this.controllerAdapter.setupController(
+              controller,
+              instance,
+              moduleMetadata,
+            )
+          }
+          done()
+        },
+        {
+          prefix: globalPrefix,
+        },
+      )
+    }
+  }
+
+  enableCors(options: FastifyCorsOptions) {
+    this.corsOptions = options
+    this.server?.register
+  }
+
+  setGlobalPrefix(prefix: string) {
+    this.globalPrefix = prefix
+  }
+
+  getServer(): FastifyInstance {
+    if (!this.server) {
+      throw new Error('Server is not initialized. Call init() first.')
+    }
+    return this.server
+  }
+
+  async listen(options: FastifyListenOptions) {
+    if (!this.server) {
+      throw new Error('Server is not initialized. Call init() first.')
+    }
+    await this.server.listen(options)
+  }
+}

package/src/navios.factory.mts

@@ -0,0 +1,17 @@
+import type { NaviosModule } from './interfaces/index.mjs'
+import type { NaviosApplicationOptions } from './navios.application.mjs'
+import type { ClassTypeWithInstance } from './service-locator/index.mjs'
+
+import { NaviosApplication } from './navios.application.mjs'
+import { inject } from './service-locator/index.mjs'
+
+export class NaviosFactory {
+  static async create(
+    appModule: ClassTypeWithInstance<NaviosModule>,
+    options: NaviosApplicationOptions = {},
+  ) {
+    const app = await inject(NaviosApplication)
+    app.setup(appModule, options)
+    return app
+  }
+}