Is there a method to retrieve and organize all routes and corresponding endpoints in a NestJS application?

Question

Is there a method to retrieve and organize all routes and corresponding endpoints in a NestJS application?

When it comes to writing middleware to process requests, I am faced with the issue of excluding certain paths without having to hardcode them manually. To tackle this problem, I came up with an innovative solution:

My plan is to create a special decorator that can be used to tag methods as excluded, like this:

import { ReflectMetadata } from '@nestjs/common';
export const Exclude = () =>
  ReflectMetadata('exclude', 'true');

I am curious if there is a way to dynamically retrieve all methods annotated with this decorator after creating a NestJS application, so that their paths can be automatically added to the exclude list in my middleware. Any ideas on how to achieve this?

typescript nestjs

Answer 1

Answer №1

If you're looking to streamline the process of discovering metadata on your handlers or Injectable classes, I've created a reusable module designed specifically for this purpose. By utilizing @nestjs-plus/common from NPM and leveraging the DiscoveryService, you can automatically retrieve all relevant handlers or classes based on a MetaData token of your choosing. The source code for this module can be found on Github. I will be updating the documentation in the near future, but there are already numerous examples available in the repository.

Underneath it all, the module utilizes the MetaDataScanner but presents a user-friendly API for ease of use. This could potentially reduce a significant amount of boilerplate in your specific use case, as demonstrated in examples within the @nestjs-plus/rabbitmq module (also located in the same repository). These examples showcase how you can effectively utilize this functionality to enhance advanced features.

EDIT: I have recently updated the library to also support scenarios involving the discovery of controllers and controller methods. You can explore a comprehensive test suite that mirrors your setup using the @Roles decorator by following this link. After including the DiscoveryModule in your imports and injecting the DiscoverService, you can easily find all controller methods using the simplified

methodsAndControllerMethodsWithMeta

API.

// Inject the service
constructor(private readonly discover: DiscoveryService) { }

// Discover all controller methods decorated with guest roles or 
// belonging to controllers with guest roles

const allMethods = this.discover.methodsAndControllerMethodsWithMeta<string[]>(
  rolesMetaKey,
  x => x.includes('guest')
);

Once you have retrieved all the desired methods, you have the flexibility to manipulate them as needed—such as creating a collection based on their RequestMethod and path.

const fullPaths = allGuestMethods.map(x => {
  const controllerPath = Reflect.getMetadata(
    PATH_METADATA,
    x.component.metatype
  );

  const methodPath = Reflect.getMetadata(PATH_METADATA, x.handler);
  const methodHttpVerb = Reflect.getMetadata(
    METHOD_METADATA,
    x.handler
  );

  return {
    verb: methodHttpVerb,
    path: `${controllerPath}/${methodPath}`
  }
});

This would output results similar to those shown in the linked test suite:

expect(fullPaths).toContainEqual({verb: RequestMethod.GET, path: 'guest/route-path-one'});
expect(fullPaths).toContainEqual({verb: RequestMethod.GET, path: 'super/route-path-two'});
expect(fullPaths).toContainEqual({verb: RequestMethod.POST, path: 'admin/route-path-three'});

I welcome any feedback or insights regarding this approach/API.

Answer 2

If you're looking to streamline the process of discovering metadata on your handlers or Injectable classes, I've created a reusable module designed specifically for this purpose. By utilizing @nestjs-plus/common from NPM and leveraging the DiscoveryService, you can automatically retrieve all relevant handlers or classes based on a MetaData token of your choosing. The source code for this module can be found on Github. I will be updating the documentation in the near future, but there are already numerous examples available in the repository.

Underneath it all, the module utilizes the MetaDataScanner but presents a user-friendly API for ease of use. This could potentially reduce a significant amount of boilerplate in your specific use case, as demonstrated in examples within the @nestjs-plus/rabbitmq module (also located in the same repository). These examples showcase how you can effectively utilize this functionality to enhance advanced features.

EDIT: I have recently updated the library to also support scenarios involving the discovery of controllers and controller methods. You can explore a comprehensive test suite that mirrors your setup using the @Roles decorator by following this link. After including the DiscoveryModule in your imports and injecting the DiscoverService, you can easily find all controller methods using the simplified

methodsAndControllerMethodsWithMeta

API.

// Inject the service
constructor(private readonly discover: DiscoveryService) { }

// Discover all controller methods decorated with guest roles or 
// belonging to controllers with guest roles

const allMethods = this.discover.methodsAndControllerMethodsWithMeta<string[]>(
  rolesMetaKey,
  x => x.includes('guest')
);

Once you have retrieved all the desired methods, you have the flexibility to manipulate them as needed—such as creating a collection based on their RequestMethod and path.

const fullPaths = allGuestMethods.map(x => {
  const controllerPath = Reflect.getMetadata(
    PATH_METADATA,
    x.component.metatype
  );

  const methodPath = Reflect.getMetadata(PATH_METADATA, x.handler);
  const methodHttpVerb = Reflect.getMetadata(
    METHOD_METADATA,
    x.handler
  );

  return {
    verb: methodHttpVerb,
    path: `${controllerPath}/${methodPath}`
  }
});

This would output results similar to those shown in the linked test suite:

expect(fullPaths).toContainEqual({verb: RequestMethod.GET, path: 'guest/route-path-one'});
expect(fullPaths).toContainEqual({verb: RequestMethod.GET, path: 'super/route-path-two'});
expect(fullPaths).toContainEqual({verb: RequestMethod.POST, path: 'admin/route-path-three'});

I welcome any feedback or insights regarding this approach/API.

Answer 3

Answer №2

Feel free to explore on your own.

Having delved into the depths of NestJS sources, I uncovered a pathway for those keen on learning:

import * as pathToRegexp from 'path-to-regexp';
import { INestApplication, RequestMethod } from '@nestjs/common';
import { NestContainer } from '@nestjs/core/injector/container';
import { MetadataScanner } from '@nestjs/core/metadata-scanner';
import { PATH_METADATA, MODULE_PATH, METHOD_METADATA } from '@nestjs/common/constants';

const trimSlashes = (str: string) => {
  if (str != null && str.length) {
    while (str.length && str[str.length - 1] === '/') {
      str = str.slice(0, str.length - 1);
    }
  }
  return str || '';
};

const joinPath = (...p: string[]) =>
  '/' + trimSlashes(p.map(trimSlashes).filter(x => x).join('/'));

// ---------------8<----------------

const app = await NestFactory.create(AppModule);

// ---------------8<----------------

const excludes = Object.create(null);
const container: NestContainer = (app as any).container; // this is "protected" field, so a bit hacky here
const modules = container.getModules();
const scanner = new MetadataScanner();

modules.forEach(({ routes, metatype }, moduleName) => {
  let modulePath = metatype ? Reflect.getMetadata(MODULE_PATH, metatype) : undefined;
  modulePath = modulePath ? modulePath + globalPrefix : globalPrefix;

  routes.forEach(({ instance, metatype }, controllerName) => {
    const controllerPath = Reflect.getMetadata(PATH_METADATA, metatype);
    const isExcludeController = Reflect.getMetadata('exclude', metatype) === 'true';
    const instancePrototype = Object.getPrototypeOf(instance);

    scanner.scanFromPrototype(instance, instancePrototype, method => {
      const targetCallback = instancePrototype[method];
      const isExcludeMethod = Reflect.getMetadata('exclude', targetCallback) === 'true';

      if (isExcludeController || isExcludeMethod) {
        const requestMethod: RequestMethod = Reflect.getMetadata(METHOD_METADATA, targetCallback);
        const routePath = Reflect.getMetadata(PATH_METADATA, targetCallback);

        // add request method to map, if doesn't exist already
        if (!excludes[RequestMethod[requestMethod]]) {
          excludes[RequestMethod[requestMethod]] = [];
        }

        // add path to excludes
        excludes[RequestMethod[requestMethod]].push(
          // transform path to regexp to match it later in middleware
          pathToRegexp(joinPath(modulePath, controllerPath, routePath)),
        );
      }
    });
  });
});

// you are now equipped to utilize the `excludes` map within middleware

Answer 4

Feel free to explore on your own.

Having delved into the depths of NestJS sources, I uncovered a pathway for those keen on learning:

import * as pathToRegexp from 'path-to-regexp';
import { INestApplication, RequestMethod } from '@nestjs/common';
import { NestContainer } from '@nestjs/core/injector/container';
import { MetadataScanner } from '@nestjs/core/metadata-scanner';
import { PATH_METADATA, MODULE_PATH, METHOD_METADATA } from '@nestjs/common/constants';

const trimSlashes = (str: string) => {
  if (str != null && str.length) {
    while (str.length && str[str.length - 1] === '/') {
      str = str.slice(0, str.length - 1);
    }
  }
  return str || '';
};

const joinPath = (...p: string[]) =>
  '/' + trimSlashes(p.map(trimSlashes).filter(x => x).join('/'));

// ---------------8<----------------

const app = await NestFactory.create(AppModule);

// ---------------8<----------------

const excludes = Object.create(null);
const container: NestContainer = (app as any).container; // this is "protected" field, so a bit hacky here
const modules = container.getModules();
const scanner = new MetadataScanner();

modules.forEach(({ routes, metatype }, moduleName) => {
  let modulePath = metatype ? Reflect.getMetadata(MODULE_PATH, metatype) : undefined;
  modulePath = modulePath ? modulePath + globalPrefix : globalPrefix;

  routes.forEach(({ instance, metatype }, controllerName) => {
    const controllerPath = Reflect.getMetadata(PATH_METADATA, metatype);
    const isExcludeController = Reflect.getMetadata('exclude', metatype) === 'true';
    const instancePrototype = Object.getPrototypeOf(instance);

    scanner.scanFromPrototype(instance, instancePrototype, method => {
      const targetCallback = instancePrototype[method];
      const isExcludeMethod = Reflect.getMetadata('exclude', targetCallback) === 'true';

      if (isExcludeController || isExcludeMethod) {
        const requestMethod: RequestMethod = Reflect.getMetadata(METHOD_METADATA, targetCallback);
        const routePath = Reflect.getMetadata(PATH_METADATA, targetCallback);

        // add request method to map, if doesn't exist already
        if (!excludes[RequestMethod[requestMethod]]) {
          excludes[RequestMethod[requestMethod]] = [];
        }

        // add path to excludes
        excludes[RequestMethod[requestMethod]].push(
          // transform path to regexp to match it later in middleware
          pathToRegexp(joinPath(modulePath, controllerPath, routePath)),
        );
      }
    });
  });
});

// you are now equipped to utilize the `excludes` map within middleware

Is there a method to retrieve and organize all routes and corresponding endpoints in a NestJS application?

Answer №1

Answer №2

Similar questions

Filtering without the includes() Method

Exploring the TypeScript Type System: Challenges with Arrays Generated and Constant Assertions

Issues with running NPM script for compiling TypeScript code

What is the correct way to properly enter a Svelte component instance variable?

Display a targeted highcharts tooltip using React and typescript

Guide to making a ng-bootstrap modal that retains a component's state

What improvements can I implement in this React Component to enhance its efficiency?

When using a Redux action type with an optional payload property, TypeScript may raise complaints within the reducer

Troubleshooting Issue with Angular Library: Live Reload Feature Not Functioning

Receiving intelligent suggestions for TypeScript interfaces declared within function parameters

Encountering a Typescript issue with the updated Apollo server version within a NestJS application

Issue: Unrecognized element type in next.js while starting development server

Tips for resolving the unmounted component issue in React hooks

TypeScript: "Implementing" methods. The organized approach

Converting a promise of type <any> to a promise of type <entity>: A beginner's guide

Discrepancies in ESLint outcomes during React app development

How can I effectively utilize the Metamask SDK with TypeScript?

A TypeScript method for accessing deeply nested properties within an object

ReactJS and Redux: setting input value using properties

Ways to delete a class in typescript