# All files / core/helpers context-utils.ts

100% Statements 13/13
100% Branches 2/2
100% Functions 8/8
100% Lines 11/11

    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
    1x

    1x

    14x
    14x

    6x

    7x

    11x

    5x

    7x
    1x

    8x

     import { ParamData } from '@nestjs/common';
    import { PARAMTYPES_METADATA } from '@nestjs/common/constants';
    import { Controller, PipeTransform } from '@nestjs/common/interfaces';

    export interface ParamProperties<T = any, IExtractor extends Function = any> {
      index: number;
      type: T | string;
      data: ParamData;
      pipes: PipeTransform[];
      extractValue: IExtractor;
    }

    export class ContextUtils {
      public mapParamType(key: string): string {
        const keyPair = key.split(':');
        return keyPair[0];
      }

      public reflectCallbackParamtypes(
        instance: Controller,
        methodName: string,
      ): any[] {
        return Reflect.getMetadata(PARAMTYPES_METADATA, instance, methodName);
      }

      public reflectCallbackMetadata<T = any>(
        instance: Controller,
        methodName: string,
        metadataKey: string,
      ): T {
        return Reflect.getMetadata(metadataKey, instance.constructor, methodName);
      }

      public getArgumentsLength<T>(keys: string[], metadata: T): number {
        return Math.max(...keys.map(key => metadata[key].index)) + 1;
      }

      public createNullArray(length: number): any[] {
        return Array.apply(null, { length }).fill(undefined);
      }

      public mergeParamsMetatypes(
        paramsProperties: ParamProperties[],
        paramtypes: any[],
      ): (ParamProperties & { metatype?: any })[] {
        if (!paramtypes) {
          return paramsProperties;
        }
        return paramsProperties.map(param => ({
          ...param,
          metatype: paramtypes[param.index],
        }));
      }
    }