example-interceptor.ts

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class ExampleUploadInterceptor extends MulterInterceptor implements NestInterceptor {
    private MAX_FILE_SIZE = 50 * 1024 * 1024;

    constructor(
        private fs: FsService,
    ) {
        super();
    }

    public async intercept(
        context: ExecutionContext,
        next: CallHandler,
    ): Promise<Observable<any>> {
        return await super.intercept(context, next, {
            fieldName: 'uploadField',
            uploadConfig: this.fs.multerConfig({
                dest: 'example-folder',
                filenameGenerator: getFileName,
                limits: {
                    fileSize: this.MAX_FILE_SIZE,
                },
                fileFilter: (req, file: MulterLocalFile, cb) => {
                    const mimes = extensions.map(ext => ext.mime);
                    if (mimes.includes(file.mimetype) === false) {
                        cb(new MimetypeNotSupportedException());
                    }
                    cb(null, true);
                },
            }),
        });
    }
}

multer-interceptor.ts

import { CallHandler, ExecutionContext } from '@nestjs/common';
import { Dictionary } from '../../../common/interfaces/dictionary';
import { Observable } from 'rxjs';
import * as multer from 'multer';
import { transformException } from '@nestjs/platform-express/multer/multer/multer.utils';

export class MulterInterceptor {
    public async intercept(
        context: ExecutionContext,
        next: CallHandler,
        options: { fieldName: string, uploadConfig: Dictionary },
    ): Promise<Observable<any>> {
        const { fieldName, uploadConfig } = options;
        const ctx = context.switchToHttp();
        const multerInstance = (multer as any)(uploadConfig);

        await new Promise((resolve, reject) =>
            multerInstance.single(fieldName)(
                ctx.getRequest(),
                ctx.getResponse(),
                (err: any) => {
                    if (err) {
                        const error = transformException(err);
                        return reject(error);
                    }
                    resolve();
                },
            ),
        );
        return next.handle();
    }
}