Migration guide

This article provides a set of guidelines for migrating from 5 to the latest 6 version. Even though we tried to reduce a number of breaking changes, the API had to be modified in a few places in order to simplify its usage.

Middleware

Based on this topic, the middleware API has been changed in order to make it more straightforward for people who come from different Node libraries and also to reduce the number of confusions that arose from the previous API.

  1. @@filename()
  2. // Before
  3. @Injectable()
  4. export class LoggerMiddleware implements NestMiddleware {
  5.  resolve(...args: any[]): MiddlewareFunction {
  6.    return (req: Request, res: Response, next: Function) => {
  7.      console.log('Request...');
  8.      next();
  9.    };
  10.  }
  11. }
  13. // After
  14. @Injectable()
  15. export class LoggerMiddleware implements NestMiddleware {
  16.   use(req: Request, res: Response, next: Function) {
  17.     console.log('Request...');
  18.     next();
  19.   }
  20. }
  21. @@switch
  22. @Injectable()
  23. export class LoggerMiddleware {
  24.  resolve(...args) {
  25.    return (req, res, next) => {
  26.      console.log('Request...');
  27.      next();
  28.    };
  29.  }
  30. }
  32. // After
  33. @Injectable()
  34. export class LoggerMiddleware {
  35.   use(req, res, next) {
  36.     console.log('Request...');
  37.     next();
  38.   }
  39. }

Consequently, the with() method of the MiddlewareConsumer won’t work anymore (is fully useless). If you want to pass options to the middleware class, use a custom provider or check more examples here.

Interceptors

The interceptors API has also been simplified. In addition, the change was required due to this issue which was reported by the community.

  1. @@filename()
  2. // Before
  3. @Injectable()
  4. export class TransformInterceptor implements NestInterceptor {
  5.   intercept(
  6.     context: ExecutionContext,
  7.     call$: Observable<T>,
  8.   ): Observable<Response<T>> {
  9.     return call$.pipe(map(data => ({ data })));
  10.   }
  11. }
  13. // After
  14. @Injectable()
  15. export class TransformInterceptor implements NestInterceptor {
  16.   intercept(
  17.     context: ExecutionContext,
  18.     next: CallHandler,
  19.   ): Observable<Response<T>> {
  20.     return next
  21.       .handle()
  22.       .pipe(map(data => ({ data })));
  23.   }
  24. }
  25. @@switch
  26. // Before
  27. @Injectable()
  28. export class TransformInterceptor {
  29.   intercept(context, next) {
  30.     return call$.pipe(map(data => ({ data })));
  31.   }
  32. }
  34. // After
  35. @Injectable()
  36. export class TransformInterceptor {
  37.   intercept(context, next) {
  38.     return next
  39.       .handle()
  40.       .pipe(map(data => ({ data })));
  41.   }
  42. }

info Hint The CallHandler interface is exported from the @nestjs/common package.

Please note that your interceptors will now run in the correct order - they will follow a simple request processing pipeline, being executed from global to concrete once the request wants to hit an end-handler, and then (in response pipeline), they will be executed from specific to global ones (if you attach some asynchronous/mapping logic inside them).

Platforms

So far, even if you were not using an HTTP server, you had to install the express library internally (as a dependency of the @nestjs/core package). Since a new major release, Nest will no longer ship these packages upfront. Each platform has been extracted into an individual package, respectively @nestjs/platform-express, @nestjs/platform-fastify, @nestjs/platform-ws, and @nestjs/platform-socket.io. Assuming that your application was using both express and socket.io, you only have to install the corresponding platforms:

  1. $ npm i @nestjs/platform-express @nestjs/platform-socket.io

Every existing adapter (for example, FastifyAdapter) is now being served from the dedicated platform package.

  • FastifyAdapter - @nestjs/platform-fastify
  • ExpressAdapter - @nestjs/platform-express
  • WsAdapter - @nestjs/platform-ws
  • IoAdapter - @nestjs/platform-socket.io

Also, FileInterceptor (and other multer related interceptors) are now exported from @nestjs/platform-express (because multer library is not compatible with fastify).

Metadata reflection

The @ReflectMetadata() decorator has been deprecated and will be removed in the next major release (for now it will only display a warning). Use the @SetMetadata() decorator instead.

GraphQL

The subscriptions mechanism has been changed. Check this chapter for more details. Additionally, @nestjs/graphql package was heavily relying on @ReflectMetadata() (which has been deprecated) so it’s required to update the package itself as well.

Express instance

We no longer support passing express instance as a second argument of the NestFactory.create() method. In order to pluck underlying HTTP adapter, use techniques described here. Also, you can pass ExpressAdapter instead (simply pass your express instance as a constructor parameter new ExpressAdapter(express)).

  1. // Before (no longer supported)
  2. const server = express();
  3. const app = await NestFactory.create(ApplicationModule, server);
  5. // After (potential solution)
  6. const server = express();
  7. const app = await NestFactory.create(
  8.   ApplicationModule,
  9.   new ExpressAdapter(server),
  10. );

Deprecations

All deprecations (from 4 to 5 version) have been finally removed.

TypeScript

Nest 6 supports the latest major release of TypeScript (3.0.0).