# All files / core/middleware routes-mapper.ts

100% Statements 19/19
83.33% Branches 5/6
100% Functions 6/6
100% Lines 18/18

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    631x
    1x

    1x

    1x
    1x

    1x

    10x

    10x
    2x

    8x
    8x
    6x

    2x

    3x

    8x

    3x
    3x

    11x

     import { RequestMethod } from '@nestjs/common';
    import { PATH_METADATA } from '@nestjs/common/constants';
    import { RouteInfo, Type } from '@nestjs/common/interfaces';
    import { isString, isUndefined, validatePath } from '@nestjs/common/utils/shared.utils';
    import { NestContainer } from '../injector/container';
    import { MetadataScanner } from '../metadata-scanner';
    import { RouterExplorer } from '../router/router-explorer';

    export class RoutesMapper {
      private readonly routerExplorer: RouterExplorer;

      constructor(container: NestContainer) {
        this.routerExplorer = new RouterExplorer(new MetadataScanner(), container);
      }

      public mapRouteToRouteInfo(
        route: Type<any> | RouteInfo | string,
      ): RouteInfo[] {
        if (isString(route)) {
          return [
            {
              path: this.validateRoutePath(route),
              method: RequestMethod.ALL,
            },
          ];
        }
        const routePath: string = Reflect.getMetadata(PATH_METADATA, route);
        if (this.isRouteInfo(routePath, route)) {
          return [
            {
              path: this.validateRoutePath(route.path),
              method: route.method,
            },
          ];
        }
        const paths = this.routerExplorer.scanForPaths(
          Object.create(route),
          route.prototype,
        );
        return paths.map(item => ({
          path:
            this.validateGlobalPath(routePath) + this.validateRoutePath(item.path),
          method: item.requestMethod,
        }));
      }

      private isRouteInfo(
        path: string | undefined,
        objectOrClass: Function | RouteInfo,
      ): objectOrClass is RouteInfo {
        return isUndefined(path);
      }

      private validateGlobalPath(path: string): string {
        const prefix = validatePath(path);
        return prefix === '/' ? '' : prefix;
      }

      private validateRoutePath(path: string): string {
        return validatePath(path);
      }
    }