- autoDeleteFile config field separated to two fields: cleanupAfterSuccessHandle and cleanupAfterFailedHandle

- Extended `HasMimeType` validator, added regex support and asterisk match
- Extended tests for cover a new functionality
- Resolved [Issue 56](#56)
- Resolved [Issue 57](#57)
- Updated README.md - described additional information about the usage of new config fields and validations

Author: dmitriy-nz

CHANGELOG.md

@@ -1,3 +1,11 @@
+### v1.9.7
+- `autoDeleteFile` config field separated to two fields: `cleanupAfterSuccessHandle` and `cleanupAfterFailedHandle`
+- Extended `HasMimeType` validator, added regex support and asterisk match
+- Extended tests for cover a new functionality
+- Resolved [Issue 56](https://github.com/dmitriy-nz/nestjs-form-data/issues/56)
+- Resolved [Issue 57](https://github.com/dmitriy-nz/nestjs-form-data/issues/57)
+- Updated README.md - described additional information about the usage of new config fields and validations
+
 ### v1.9.6
 - Updated peer deps: `reflect-metadata^0.2.0`
 - Resolved [Issue 58](https://github.com/dmitriy-nz/nestjs-form-data/issues/58)

README.md

@@ -167,7 +167,8 @@ export class NestjsFormDataController {
 - `isGlobal` - If you want the module to be available globally. Once you import the module and configure it, it will be available globally
 - `storage` - The type of storage logic for the uploaded file  (Default MemoryStoredFile)
 - `fileSystemStoragePath` - The path to the directory for storing temporary files, used only for `storage: FileSystemStoredFile` (Default: /tmp/nestjs-tmp-storage)  
-- `autoDeleteFile` - Automatically delete files after the request ends (Default true)
+- `cleanupAfterSuccessHandle` - If set to true, all processed and uploaded files will be deleted after successful processing by the final method. This means that the `delete` method will be called on all files (StoredFile)
+- `cleanupAfterFailedHandle` - If set to true, all processed and uploaded files will be deleted after unsuccessful processing by the final method. This means that the `delete` method will be called on all files (StoredFile)
 - `limits` - [busboy](https://www.npmjs.com/package/busboy#busboy-methods) limits configuration. Constraints in this declaration are handled at the serialization stage, so using these parameters is preferable for performance.
 ## File storage types
 ### Memory storage
@@ -216,8 +217,21 @@ The library uses two sources to get the mime type for the file:
 The default is simple mode, which does not check the data source, but you can pass a second argument to strictly check the mime-type and data source.  
 You can also get the mime type and data source via the `get mimeTypeWithSource():MetaFieldSource` getter on the `StoredFile`
 
+
+```ts
+type AllowedMimeTypes = Array<AllowedMimeType>
+type AllowedMimeType = string | RegExp;
+
+@HasMimeType(allowedMimeTypes: AllowedMimeTypes | AllowedMimeType, strictSource?: MetaSource | ValidationOptions, validationOptions?: ValidationOptions)
+```
+
+You can also use partial matching, just pass the unimportant parameter as `*`, for example:
+```ts
+@HasMimeType('image/*')
+```
+also as array:
 ```ts
-@HasMimeType(allowedMimeTypes: string[] | string, strictSource?: MetaSource | ValidationOptions, validationOptions?: ValidationOptions)
+@HasMimeType(['image/*', 'text/*'])
 ```
 
 ### HasExtension

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-form-data",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "NestJS middleware for handling multipart/form-data, which is primarily used for uploading files",
   "main": "dist/index",
   "types": "dist/index",

src/config/default.config.ts

@@ -3,6 +3,7 @@ import { MemoryStoredFile } from '../classes/storage/MemoryStoredFile';
 
 export const DEFAULT_CONFIG: FormDataInterceptorConfig = {
   storage: MemoryStoredFile,
-  autoDeleteFile: true,
+  cleanupAfterSuccessHandle: true,
+  cleanupAfterFailedHandle: true,
   fileSystemStoragePath: '/tmp/nestjs-tmp-storage',
-};
+};

src/decorators/validation/has-mime-type.validator.ts

@@ -4,22 +4,53 @@ import { isFile } from './is-file.validator';
 import { toArray } from '../../helpers/toArray';
 import { MetaFieldSource, MetaSource } from '../../interfaces/MetaFieldSource';
 
-export function HasMimeType(allowedMimeTypes: string[] | string, strictSource?: MetaSource | ValidationOptions, validationOptions?: ValidationOptions): PropertyDecorator {
+
+export type AllowedMimeTypes = Array<AllowedMimeType>
+export type AllowedMimeType = string | RegExp;
+
+export function HasMimeType(allowedMimeTypes: AllowedMimeTypes | AllowedMimeType, strictSource?: MetaSource | ValidationOptions, validationOptions?: ValidationOptions): PropertyDecorator {
 
   return ValidateBy({
     name: 'HasMimeType',
     constraints: [allowedMimeTypes],
     validator: {
 
       validate(value: StoredFile, args: ValidationArguments) {
-        const allowedMimeTypes: string[] = toArray(args.constraints[0]) || [];
+        const allowedMimeTypes: AllowedMimeTypes = toArray(args.constraints[0]) || [];
         const strictSource: MetaSource = (typeof args.constraints[1] === 'string')
           ? args.constraints[1] as MetaSource
           : undefined;
 
         if (isFile(value)) {
           const mimeWithSource: MetaFieldSource = value.mimeTypeWithSource;
-          return allowedMimeTypes.includes(mimeWithSource.value) && (!strictSource || strictSource === mimeWithSource.source);
+          const hasSourceMatch = !strictSource || strictSource === mimeWithSource.source;
+
+          if (!hasSourceMatch) {
+            return false;
+          }
+
+          for (let mimeType of allowedMimeTypes) {
+            switch (true) {
+              case typeof mimeType === 'string' && !mimeType.includes('*'):
+                if (mimeType === mimeWithSource.value) {
+                  return true;
+                }
+                break;
+              case typeof mimeType === 'string' && mimeType.includes('*'):
+                const regex = new RegExp(`^${mimeType as string}$`.replace('*', '.+'));
+                if (regex.test(mimeWithSource.value)) {
+                  return true;
+                }
+                break;
+              case mimeType instanceof RegExp:
+                if ((mimeType as RegExp).test(mimeWithSource.value)) {
+                  return true;
+                }
+                break;
+              default:
+                throw new Error(`Unknown mime type for validate`);
+            }
+          }
         }
 
         return false;

src/helpers/check-config.ts

@@ -2,15 +2,22 @@ import { FormDataInterceptorConfig } from '../interfaces/FormDataInterceptorConf
 import { DEFAULT_CONFIG } from '../config/default.config';
 
 export function checkConfig(config: FormDataInterceptorConfig, defaults: FormDataInterceptorConfig = DEFAULT_CONFIG): FormDataInterceptorConfig {
+  config = Object.assign({}, config)
 
   if (!config.storage)
     config.storage = defaults.storage;
 
-  if (config.autoDeleteFile === undefined)
-    config.autoDeleteFile = defaults.autoDeleteFile;
+
+  if(config.cleanupAfterSuccessHandle === undefined){
+    config.cleanupAfterSuccessHandle = defaults.cleanupAfterSuccessHandle;
+  }
+
+  if(config.cleanupAfterFailedHandle === undefined){
+    config.cleanupAfterFailedHandle = defaults.cleanupAfterFailedHandle;
+  }
 
   if (!config.fileSystemStoragePath)
     config.fileSystemStoragePath = defaults.fileSystemStoragePath;
 
   return Object.assign({}, defaults, config);
-}
+}

src/interceptors/FormData.interceptor.ts

@@ -58,12 +58,12 @@ export class FormDataInterceptor implements NestInterceptor {
       }),
 
       catchError((err) => {
-        if (config.autoDeleteFile) formReader.deleteFiles();
+        if (config.cleanupAfterFailedHandle || config.autoDeleteFile) formReader.deleteFiles();
         return throwError(err);
       }),
 
-      tap((res) => {
-        if (config.autoDeleteFile) formReader.deleteFiles();
+      tap(() => {
+        if (config.cleanupAfterSuccessHandle || config.autoDeleteFile) formReader.deleteFiles();
       }),
     );
   }

src/interfaces/FormDataInterceptorConfig.ts

@@ -4,7 +4,32 @@ import { Type } from '@nestjs/common';
 export interface FormDataInterceptorConfig {
   storage?: Type<StoredFile>,
   fileSystemStoragePath?: string;
+
+  /**
+   * @deprecated
+   * Use `cleanupAfterSuccessHandle` and `cleanupAfterFailedHandle` instead;
+   */
   autoDeleteFile?: boolean;
+
+  /**
+   * Indicates whether cleanup should be performed after successful handling.
+   * If set to true, all processed and uploaded files will be deleted after successful processing by the final method.
+   * This means that the `delete` method will be called on all files (StoredFile)
+   * @type {boolean}
+   * @default true
+   */
+  cleanupAfterSuccessHandle?: boolean;
+
+  /**
+   * Indicates whether cleanup should be performed after error handling.
+   * If set to true, all processed and uploaded files will be deleted after unsuccessful processing by the final method.
+   * This means that the `delete` method will be called on all files (StoredFile)
+   * @type {boolean}
+   * @default true
+   */
+  cleanupAfterFailedHandle?: boolean;
+
+
   limits?: FormDataInterceptorLimitsConfig;
   /**
    * If you want the module to be available globally

test/auto-delete.e2e-spec.ts

@@ -1,20 +1,27 @@
 import { INestApplication } from '@nestjs/common';
 import { NestFastifyApplication } from '@nestjs/platform-fastify';
-import * as request from 'supertest';
+import request from 'supertest';
 import path from 'path';
 import { createTestModule } from './helpers/create-test-module';
 import * as fs from 'fs';
 
 describe('Express - Auto delete', () => {
   let app: INestApplication;
+  let appCleanupAfterSuccessHandleDisabled: INestApplication;
+  let appCleanupAfterFailedHandle: INestApplication;
 
   beforeEach(async () => {
     app = await createTestModule();
+    appCleanupAfterSuccessHandleDisabled = await createTestModule({
+      cleanupAfterSuccessHandle: false
+    });
+    appCleanupAfterFailedHandle = await createTestModule({
+      cleanupAfterFailedHandle: false
+    });
   });
 
-  it('Delete after success upload', () => {
-    return request
-      .default(app.getHttpServer())
+  it('Delete after success upload (cleanupAfterSuccessHandle: true)', () => {
+    return request(app.getHttpServer())
       .post('/auto-delete-single-file')
       .attach('file', path.resolve(__dirname, 'test-files', 'file.txt'))
       .expect(200)
@@ -24,9 +31,19 @@ describe('Express - Auto delete', () => {
       });
   });
 
-  it('Delete after failed upload (class validation)', () => {
-    return request
-      .default(app.getHttpServer())
+  it('Delete after success upload (cleanupAfterSuccessHandle: false)', () => {
+    return request(appCleanupAfterSuccessHandleDisabled.getHttpServer())
+      .post('/auto-delete-single-file')
+      .attach('file', path.resolve(__dirname, 'test-files', 'file.txt'))
+      .expect(200)
+      .expect((res: any) => {
+        expect(typeof res.body.path).toBe('string');
+        expect(fs.existsSync(res.body.path)).toBe(true);
+      });
+  });
+
+  it('Delete after failed upload (cleanupAfterFailedHandle:true, class validation)', () => {
+    return request(app.getHttpServer())
       .post('/auto-delete-single-file')
       .attach('file', path.resolve(__dirname, 'test-files', 'file-large.txt'))
       .expect(400)
@@ -35,20 +52,42 @@ describe('Express - Auto delete', () => {
         expect(fs.existsSync(res.body.message[0])).toBe(false);
       });
   });
+
+  it('Delete after failed upload (cleanupAfterFailedHandle:true, class validation)', () => {
+    return request(appCleanupAfterFailedHandle.getHttpServer())
+      .post('/auto-delete-single-file')
+      .attach('file', path.resolve(__dirname, 'test-files', 'file-large.txt'))
+      .expect(400)
+      .expect((res: any) => {
+        expect(typeof res.body.message[0]).toBe('string');
+        expect(fs.existsSync(res.body.message[0])).toBe(true);
+      });
+  });
 });
 
 describe('Fastify - Auto delete', () => {
   let app: NestFastifyApplication;
+  let appCleanupAfterSuccessHandleDisabled: NestFastifyApplication;
+  let appCleanupAfterFailedHandle: NestFastifyApplication;
 
   beforeEach(async () => {
-    app = (await createTestModule({
+    app = await createTestModule({
+      fastify: true,
+    }) as NestFastifyApplication;
+
+    appCleanupAfterSuccessHandleDisabled = await createTestModule({
       fastify: true,
-    })) as NestFastifyApplication;
+      cleanupAfterSuccessHandle: false
+    }) as NestFastifyApplication;
+
+    appCleanupAfterFailedHandle = await createTestModule({
+      fastify: true,
+      cleanupAfterFailedHandle: false
+    }) as NestFastifyApplication;
   });
 
-  it('Delete after success upload', () => {
-    return request
-      .default(app.getHttpServer())
+  it('Delete after success upload (cleanupAfterSuccessHandle: true)', () => {
+    return request(app.getHttpServer())
       .post('/auto-delete-single-file')
       .attach('file', path.resolve(__dirname, 'test-files', 'file.txt'))
       .expect(200)
@@ -58,9 +97,19 @@ describe('Fastify - Auto delete', () => {
       });
   });
 
-  it('Delete after failed upload (class validation)', () => {
-    return request
-      .default(app.getHttpServer())
+  it('Delete after success upload (cleanupAfterSuccessHandle: false)', () => {
+    return request(appCleanupAfterSuccessHandleDisabled.getHttpServer())
+      .post('/auto-delete-single-file')
+      .attach('file', path.resolve(__dirname, 'test-files', 'file.txt'))
+      .expect(200)
+      .expect((res: any) => {
+        expect(typeof res.body.path).toBe('string');
+        expect(fs.existsSync(res.body.path)).toBe(true);
+      });
+  });
+
+  it('Delete after failed upload (cleanupAfterFailedHandle:true, class validation)', () => {
+    return request(app.getHttpServer())
       .post('/auto-delete-single-file')
       .attach('file', path.resolve(__dirname, 'test-files', 'file-large.txt'))
       .expect(400)
@@ -69,4 +118,15 @@ describe('Fastify - Auto delete', () => {
         expect(fs.existsSync(res.body.message[0])).toBe(false);
       });
   });
+
+  it('Delete after failed upload (cleanupAfterFailedHandle:true, class validation)', () => {
+    return request(appCleanupAfterFailedHandle.getHttpServer())
+      .post('/auto-delete-single-file')
+      .attach('file', path.resolve(__dirname, 'test-files', 'file-large.txt'))
+      .expect(400)
+      .expect((res: any) => {
+        expect(typeof res.body.message[0]).toBe('string');
+        expect(fs.existsSync(res.body.message[0])).toBe(true);
+      });
+  });
 });

test/test-module/controllers/test.controller.ts

@@ -40,7 +40,7 @@ export class TestController {
 
   @Post('auto-delete-single-file')
   @UsePipes(new ValidationPipe({transform: true}))
-  @FormDataRequest({ autoDeleteFile: true, storage: FileSystemStoredFile })
+  @FormDataRequest({ storage: FileSystemStoredFile })
   @HttpCode(HttpStatus.OK)
   uploadSingleWithAutoDeleteFile(@Body() singleFileDto: UploadSingleFileFSStorageDto) {
     return {
@@ -52,7 +52,7 @@ export class TestController {
 
   @Post('auto-delete-single-file-busboy')
   @UsePipes(new ValidationPipe({transform: true}))
-  @FormDataRequest({ autoDeleteFile: true, storage: FileSystemStoredFile, limits: { fileSize: 5 } })
+  @FormDataRequest({ storage: FileSystemStoredFile, limits: { fileSize: 5 } })
   @HttpCode(HttpStatus.OK)
   uploadSingleWithAutoDeleteFileBusboySizeLimit(@Body() singleFileDto: UploadSingleFileFSStorageDto) {
     return {
@@ -82,7 +82,7 @@ export class TestController {
   @FormDataRequest()
   @HttpCode(HttpStatus.OK)
   mimeTypeValidator(@Body() dto: MimeTypeValidatorDto) {
-    const file: MemoryStoredFile = dto.file || dto.strictMagicNumber || dto.strictContentType || dto.any;
+    const file: MemoryStoredFile = dto.file || dto.strictMagicNumber || dto.strictContentType || dto.any || dto.filePartial || dto.filePartialArray?.[0] || dto.fileRegex;
 
     return {
       filename: file.originalName,

test/test-module/dto/MimeTypeValidator.dto.ts

@@ -1,5 +1,5 @@
 import { MemoryStoredFile } from '../../../src/classes/storage';
-import { IsFile, HasMimeType } from '../../../src/decorators';
+import { IsFile, HasMimeType, IsFiles } from '../../../src/decorators';
 import { MetaSource } from '../../../src/interfaces/MetaFieldSource';
 import { IsOptional } from 'class-validator';
 
@@ -24,4 +24,19 @@ export class MimeTypeValidatorDto {
   @IsFile()
   any: MemoryStoredFile;
 
+  @IsOptional()
+  @IsFile()
+  @HasMimeType('image/*')
+  filePartial?: MemoryStoredFile;
+
+  @IsOptional()
+  @IsFiles()
+  @HasMimeType(['image/*'])
+  filePartialArray?: MemoryStoredFile[];
+
+  @IsOptional()
+  @IsFile()
+  @HasMimeType(/^image\/webp$/)
+  fileRegex?: MemoryStoredFile;
+
 }