create-nestjs-middleware-module
    TypeScript icon, indicating that this package has built-in type declarations

    0.2.2 • Public • Published

    create-nestjs-middleware-module

    npm GitHub branch checks state Supported platforms: Express & Fastify

    Snyk Vulnerabilities for npm package Dependencies status Dependabot

    NestJS configured middleware module made simple

    What is it?

    It is a tiny helper library that helps you create simple idiomatic NestJS module based on Express/Fastify middleware in just a few lines of code with routing out of the box.

    Install

    npm i create-nestjs-middleware-module

    or

    yarn add create-nestjs-middleware-module

    Usage

    Let's imaging you have some middleware factory, for example, simple logger:

    export interface Options {
      maxDuration: number
    }
    
    export function createResponseDurationLoggerMiddleware(opts: Options) {
      return (request, response, next) => {
        const start = Date.now();
    
        response.on('finish', () => {
          const message = `${request.method} ${request.path} - ${duration}ms`;
    
          const duration = Date.now() - start;
    
          if (duration > maxDuration) {
            console.warn(message);
          } else {
            console.log(message);
          }
        });
    
        next();
      };
    }

    And you want to create an idiomatic NestJS module based on that middleware. Just pass this middleware factory to createModule function:

    import { createModule } from 'create-nestjs-middleware-module';
    import { Options, createResponseDurationLoggerMiddleware } from './middleware';
    
    export const TimingModule = createModule<Options>(createResponseDurationLoggerMiddleware);

    That's it, your module is ready. Let's see what API it has:

    import { TimingModule } from './timing-module';
    import { MyController } from './my.controller';
    
    @Module({
      imports: [
    
        // 1. `.forRoot()` method accept params satisfying `Options` interface
        TimingModule.forRoot({ maxDuration: 1000 }),
    
        // 2. `.forRoot()` method accept additional optional routing params
        TimingModule.forRoot({
          maxDuration: 1000,
    
          // both `forRoutes` and `exclude` properties are optional
          // and has the same API as NestJS buil-in `MiddlewareConfigProxy`
          // @see https://docs.nestjs.com/middleware#applying-middleware
          forRoutes: [MyController],
          exclude: [{ method: RequestMethod.ALL, path: 'always-fast' }],
        }),
    
        // 3. `.forRootAsync()` method with only factory
        TimingModule.forRootAsync({
          useFactory: async () => {
            return { maxDuration: 1000 }
          }
        }),
    
        // 4. `.forRootAsync()` method with dependencies
        TimingModule.forRootAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: async (config: ConfigService) => {
            return { maxDuration: config.maxDurationForAPIHandler }
          }
        }),
    
        // 5. `.forRootAsync()` method with routing
        TimingModule.forRootAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: async (config: ConfigService) => {
            return {
              maxDuration: config.maxDurationForAPIHandler
    
              // both `forRoutes` and `exclude` properties are optional
              // and has the same API as NestJS buil-in `MiddlewareConfigProxy`
              // @see https://docs.nestjs.com/middleware#applying-middleware
              forRoutes: [MyController],
              exclude: [{ method: RequestMethod.ALL, path: 'always-fast' }],
            };
          }
        }),
      ]
      controllers: [MyController /*, ... */]
    })
    class App {}

    More examples

    See examples of usage in __tests__ folder or nestjs-session and nestjs-cookie-session packages

    Notes

    1. createModule callback function can return not only one middleware, but array of it.
    import { createModule } from 'create-nestjs-middleware-module';
    
    
    interface Options {
      // ...
    }
    
    createModule<Options>((options) => {
      function firstMidlleware() { /* ... */ }
      function secondMidlleware() { /* ... */ }
      return [firstMidlleware, secondMidlleware]
    });
    1. If your Options interface has not required properties it can be frustrating to force end-users of your module to call forRoot({}), and for better developer expirience you can cast createModule(...) result to FacadeModuleStaticOptional<Options>, then forRoot() could be called without arguments and without TS error. In such case createModule callback function will be called with empty object {}.
    import { createModule, FacadeModuleStaticOptional } from 'create-nestjs-middleware-module';
    
    interface Options {
      maxDuration?: number;
    }
    
    createModule<Options>((options) => {
      typeof options // always "object" even if not passed to `forRoot()`
    
      return (request, response, next) => {
        // ...
        next();
      };
    }) as FacadeModuleStaticOptional<Options>;
    1. For better developer experience of end-users of your module you can also export interfaces of forRoot and forRootAsync argument:
    import {
      AsyncOptions,
      SyncOptions,
    } from 'create-nestjs-middleware-module';
    
    interface Options {
      // ...
    }
    
    export type MyModuleOptions = SyncOptions<Options>;
    
    export type MyModuleAsyncOptions = AsyncOptions<Options>;
    1. This library is tested against express and fastify. But you should be aware that middlewares of express are not always work with fastify and vise versa. Sometimes you can check platforms internally. Sometimes maybe it's better to create 2 separate modules for each platform. It's up to you.

    Do you use this library?
    Don't be shy to give it a star! ★

    Also if you are into NestJS ecosystem you may be interested in one of my other libs:

    nestjs-pino

    GitHub stars npm

    Platform agnostic logger for NestJS based on pino with request context in every log


    nestjs-session

    GitHub stars npm

    Idiomatic session module for NestJS. Built on top of express-session


    nestjs-cookie-session

    GitHub stars npm

    Idiomatic cookie session module for NestJS. Built on top of cookie-session


    nestjs-roles

    GitHub stars npm

    Type safe roles guard and decorator made easy


    nestjs-injectable

    GitHub stars npm

    @Injectable() on steroids that simplifies work with inversion of control in your hexagonal architecture


    nest-ratelimiter

    GitHub stars npm

    Distributed consistent flexible NestJS rate limiter based on Redis


    create-nestjs-middleware-module

    GitHub stars npm

    Create simple idiomatic NestJS module based on Express/Fastify middleware in just a few lines of code with routing out of the box


    nestjs-configure-after

    GitHub stars npm

    Declarative configuration of NestJS middleware order

    Install

    npm i create-nestjs-middleware-module

    DownloadsWeekly Downloads

    4,656

    Version

    0.2.2

    License

    MIT

    Unpacked Size

    19 kB

    Total Files

    5

    Last publish

    Collaborators

    • iamolegga