@koalarx/nest 1.8.5 → 1.9.1

package/README.md

@@ -5,3 +5,332 @@
 <h1 align="center">@koalarx/nest</h1>
 
 <p align="center">Uma abstração <a href="https://nestjs.com" target="_blank">Nest.js</a> para APIs escaláveis.</p>
+
+# Índice
+1. [Introdução](#introdução)  
+2. [Estrutura do Projeto](#estrutura-do-projeto)  
+3. [Uso da CLI @koalarx/nest-cli](#uso-da-cli-koalarxnest-cli)  
+4. [Recursos Optionais](#recursos-opcionais)
+
+    4.1. [API Key Strategy](#api-key-strategy)
+
+    4.2. [Ngrok](#ngrok)
+
+    4.3. [ApiPropertyEnum](#apipropertyenum)
+
+    4.4. [Upload](#upload)
+
+---
+
+## Introdução
+
+Este projeto utiliza a CLI `@koalarx/nest-cli` para facilitar a criação de aplicações seguindo os princípios do Domain-Driven Design (DDD). A CLI automatiza a configuração inicial e a estruturação do projeto, permitindo que você comece rapidamente a desenvolver sua aplicação.  
+
+---
+
+## Estrutura do Projeto
+
+A estrutura do projeto gerada pela CLI segue os princípios do DDD, separando as responsabilidades em camadas:  
+
+- **application**: Contém a lógica de mapeamento e casos de uso.  
+- **core**: Configurações e variáveis de ambiente.  
+- **domain**: Entidades, DTOs, repositórios e serviços do domínio.  
+- **host**: Controladores e ponto de entrada da aplicação.  
+- **infra**: Implementações de infraestrutura, como banco de dados e serviços externos.
+
+---
+
+## Uso da CLI @koalarx/nest-cli
+
+### Instalação da CLI
+
+Certifique-se de instalar a CLI globalmente no seu ambiente:  
+
+```bash
+npm install -g @koalarx/nest-cli
+```
+
+### Criação de um Novo Projeto
+
+Para criar um novo projeto, execute o seguinte comando:  
+
+```bash
+koala-nest new my-project
+```
+
+Este comando irá gerar um projeto com a estrutura recomendada e todas as dependências configuradas.
+
+### Recursos Opcionais
+
+#### API Key Strategy
+
+Tendo em vista a falta de uma opção para o Nest 11 de estratégias de autenticação para APIKey, foi disponibilizada uma abstração para o mesmo no Koala Nest.
+
+Abaixo está a estrutura de pastas recomendada para a implementação de segurança no diretório `host/security`:
+
+```
+host
+└── security
+  ├── strategies
+  │   └── api-key.strategy.ts
+  ├── guards
+  │   └── auth.guard.ts
+  └── security.module.ts
+```
+
+##### Exemplo de implementação
+
+###### api-key.strategy.ts
+```ts
+import {
+  DoneFn,
+  ApiKeyStrategy as KoalaApiKeyStrategy,
+} from '@koalarx/nest/core/security/strategies/api-key.strategy'
+import { Injectable } from '@nestjs/common'
+import { PassportStrategy } from '@nestjs/passport'
+import { Request } from 'express'
+
+@Injectable()
+export class ApiKeyStrategy extends PassportStrategy(
+  KoalaApiKeyStrategy,
+  'apikey',
+) {
+  constructor() {
+    super({ header: 'ApiKey' })
+  }
+
+  validate(apikey: string, done: DoneFn, request: Request) {
+    // Valide a chave de API aqui
+    // Por exemplo, verifique se ela corresponde a um valor específico
+    if (apikey === 'valid-api-key') {
+      // Se for válida, chame done com o objeto do usuário
+      return done(null, { userId: 1, username: 'testuser' })
+    } else {
+      // Se for inválida, chame done com false
+      return done(null, false)
+    }
+  }
+}
+```
+
+###### auth.guard.ts
+```ts
+import { IS_PUBLIC_KEY } from '@koalarx/nest/decorators/is-public.decorator'
+import { ExecutionContext, Injectable } from '@nestjs/common'
+import { Reflector } from '@nestjs/core'
+import { AuthGuard as NestAuthGuard } from '@nestjs/passport'
+
+@Injectable()
+export class AuthGuard extends NestAuthGuard(['apikey']) {
+  constructor(private readonly reflector: Reflector) {
+    super()
+  }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ])
+
+    const request = context.switchToHttp().getRequest()
+
+    if (isPublic) {
+      return true
+    }
+
+    const canActivate = super.canActivate(context)
+
+    if (typeof canActivate === 'boolean') {
+      return canActivate
+    }
+
+    return (canActivate as Promise<boolean>).then(async (activated) => {
+      if (!request.user) {
+        const user = {} // busque o usuário aqui
+
+        if (user) {
+          request.user = user
+        }
+      }
+
+      return activated
+    })
+  }
+}
+```
+
+###### security.module.ts
+```ts
+import { EnvService } from '@koalarx/nest/env/env.service'
+import { Module } from '@nestjs/common'
+import { PassportModule } from '@nestjs/passport'
+import { ApiKeyStrategy } from './strategies/api-key.strategy'
+
+@Module({
+  imports: [PassportModule],
+  providers: [EnvService, ApiKeyStrategy],
+})
+export class SecurityModule {}
+```
+
+Agora basta importar o módulo de segurança em seu `app.module.ts` e utilizar globalmente ou em um endpoint específico
+
+###### app.module.ts
+```ts
+import { CreatePersonJob } from '@/application/person/create-person-job/create-person-job'
+import { DeleteInactiveJob } from '@/application/person/delete-inative-job/delete-inactive-job'
+import { InactivePersonHandler } from '@/application/person/events/inactive-person/inactive-person-handler'
+import { env } from '@/core/env'
+import { KoalaNestModule } from '@koalarx/nest/core/koala-nest.module'
+import { Module } from '@nestjs/common'
+import { PersonModule } from './controllers/person/person.module'
+import { SecurityModule } from './security/security.module'
+
+@Module({
+  imports: [
+    SecurityModule,
+    KoalaNestModule.register({
+      env,
+      controllers: [PersonModule],
+      cronJobs: [DeleteInactiveJob, CreatePersonJob],
+      eventJobs: [InactivePersonHandler],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Para configurar globalmente inclua o guard em seu arquivo `main.ts`
+
+###### main.ts
+```ts
+import { CreatePersonJob } from '@/application/person/create-person-job/create-person-job'
+import { DeleteInactiveJob } from '@/application/person/delete-inative-job/delete-inactive-job'
+import { InactivePersonHandler } from '@/application/person/events/inactive-person/inactive-person-handler'
+import { DbTransactionContext } from '@/infra/database/db-transaction-context'
+import { KoalaApp } from '@koalarx/nest/core/koala-app'
+import { NestFactory } from '@nestjs/core'
+import { AppModule } from './app.module'
+import { AuthGuard } from './security/guards/auth.guard'
+
+async function bootstrap() {
+  return NestFactory.create(AppModule).then((app) =>
+    new KoalaApp(app)
+      .useDoc({
+        ui: 'scalar',
+        endpoint: '/doc',
+        title: 'API de Demonstração',
+        version: '1.0',
+        authorizations: [
+          { name: 'ApiKey', config: { type: 'apiKey', name: 'ApiKey' } },
+        ],
+      })
+      .addGlobalGuard(AuthGuard)
+      .addCronJob(CreatePersonJob)
+      .addCronJob(DeleteInactiveJob)
+      .addEventJob(InactivePersonHandler)
+      .setAppName('example')
+      .setInternalUserName('integration.bot')
+      .setDbTransactionContext(DbTransactionContext)
+      .enableCors()
+      .buildAndServe(),
+  )
+}
+bootstrap()
+```
+
+#### Ngrok
+
+[Ngrok](https://ngrok.com) é uma ferramenta que cria túneis seguros para expor servidores locais à internet. Ele é útil para testar webhooks, compartilhar aplicações em desenvolvimento ou acessar serviços locais remotamente.
+
+##### Exemplo de implementação
+
+Inclua seu token no arquivo `main.ts` no método `.useNgrok()` e inicie a aplicação. O servidor Ngrok será configurado automaticamente para expor sua aplicação local à internet.  
+
+Certifique-se de substituir `'erarwrqwrqwr...'` pelo seu token de autenticação do Ngrok. Após iniciar a aplicação, você poderá acessar o endereço gerado pelo Ngrok para testar webhooks ou compartilhar sua aplicação em desenvolvimento.
+
+###### main.ts
+```ts
+...
+import { KoalaApp } from '@koalarx/nest/core/koala-app'
+import { NestFactory } from '@nestjs/core'
+import { AppModule } from './app.module'
+
+async function bootstrap() {
+  return NestFactory.create(AppModule).then((app) =>
+    new KoalaApp(app)
+      ...
+      .useNgrok('erarwrqwrqwr...') // Inclua sua Chave do Ngrok aqui
+      ...
+      .buildAndServe(),
+  )
+}
+bootstrap()
+```
+
+### ApiPropertyEnum
+
+Um decorador para aprimorar o `@ApiProperty` do `@nestjs/swagger`, fornecendo suporte adicional para enumerações. Ele gera uma descrição para os valores do enum, incluindo suas representações numéricas e descrições, e aplica isso à propriedade na documentação.
+
+#### Parâmetros
+
+- **options** - Opções de configuração para o decorador.
+  - **options.enum** - A enumeração a ser documentada. Deve ser um objeto onde as chaves são os nomes dos enums e os valores são suas representações numéricas.
+  - **options.required** - (Opcional) Indica se a propriedade é obrigatória.
+
+#### Exemplo de Uso
+
+```ts
+import { ApiPropertyEnum } from './decorators/api-property-enum.decorator';
+
+enum Status {
+  Ativo = 1,
+  Inativo = 2,
+}
+
+class ExemploDto {
+  @ApiPropertyEnum({ enum: Status, required: true })
+  status: Status;
+}
+```
+
+Na documentação, a propriedade `status` exibirá uma descrição com os valores do enum e suas representações numéricas correspondentes, por exemplo:
+
+```
+Ativo: 1
+Inativo: 2
+```
+
+### ApiExcludeEndpointDiffDevelop
+
+O decorator `ApiExcludeEndpointDiffDevelop` é utilizado para condicionar a exclusão de endpoints na documentação com base no ambiente de execução da aplicação. Ele utiliza a configuração de ambiente definida na classe `EnvConfig` para determinar se o endpoint será ou não excluído.
+
+#### Como funciona
+
+- Se o ambiente atual for de desenvolvimento (`isEnvDevelop` for `true`), o endpoint será incluído na documentação.
+- Caso contrário, o endpoint será excluído da documentação.
+
+### Upload
+
+Um decorator personalizado para lidar com o upload de arquivos em um controlador NestJS.
+
+@param {number} maxSizeInKb - O tamanho máximo permitido para os arquivos em kilobytes.
+
+@param {RegExp} filetype - Um padrão de expressão regular para validar os tipos de arquivo permitidos.
+
+@returns {MethodDecorator} - Um decorator que pode ser aplicado a métodos de controladores para processar uploads de arquivos.
+
+Este decorator utiliza o `UploadedFiles` do NestJS para processar múltiplos arquivos enviados em uma requisição.
+Ele valida os arquivos com base no tamanho máximo permitido e no tipo de arquivo especificado.
+
+Exemplos de uso:
+
+```ts
+@Post('upload')
+@UploadDecorator(1024, /\.(jpg|jpeg|png)$/)
+uploadFiles(@UploadedFiles() files: Express.Multer.File[]) {
+  console.log(files);
+}
+```
+
+No exemplo acima, o método `uploadFiles` aceita múltiplos arquivos com tamanho máximo de 1MB (1024 KB) e tipos de arquivo `.jpg`, `.jpeg` ou `.png`.

package/core/database/repository.base.d.ts

@@ -24,7 +24,7 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     protected findUnique<T>(where: T): Promise<any>;
     protected findMany<T>(where: T, pagination?: PaginationDto): Promise<any>;
     protected findManyAndCount<T>(where: T, pagination?: PaginationDto): Promise<ListResponse<TEntity>>;
-    protected saveChanges<TWhere = any>(entity: TEntity, updateWhere?: TWhere): Promise<TEntity | null>;
+    protected saveChanges<TWhere = any>(entity: TEntity, updateWhere?: TWhere): Promise<TEntity>;
     protected remove<TWhere = any>(where: TWhere, externalServices?: Promise<any>): Promise<any>;
     private listToRelationActionList;
     private entityToPrisma;

package/core/database/repository.base.js

@@ -83,9 +83,10 @@ class RepositoryBase {
                 .then((response) => this.createEntity(response));
         }
         else {
+            const where = updateWhere ?? { id: entity._id };
             return this.withTransaction((client) => this.context(client)
                 .update({
-                where: updateWhere ?? { id: entity._id },
+                where,
                 data: prismaEntity,
             })
                 .then(() => {
@@ -94,7 +95,7 @@ class RepositoryBase {
                     ...relationUpdates.map((relation) => client[relation.modelName].updateMany(relation.schema)),
                     ...relationDeletes.map((relation) => client[relation.modelName].deleteMany(relation.schema)),
                 ]);
-            })).then(() => null);
+            })).then(() => this.findFirst(where));
         }
     }
     async remove(where, externalServices) {

package/core/index.d.ts

@@ -1,3 +1,4 @@
+export type FileType = Express.Multer.File;
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
 export type CreatedRegister<TypeId = string> = {

package/core/koala-app.d.ts

@@ -1,4 +1,4 @@
-import { INestApplication, Type } from '@nestjs/common';
+import { CanActivate, INestApplication, Type } from '@nestjs/common';
 import { BaseExceptionFilter } from '@nestjs/core';
 import { SecuritySchemeObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
 import { CronJobHandlerBase } from './backgroud-services/cron-service/cron-job.handler.base';
@@ -35,9 +35,14 @@ export declare class KoalaApp {
     private _prismaValidationExceptionFilter;
     private _domainExceptionFilter;
     private _zodExceptionFilter;
+    private _guards;
     private _cronJobs;
     private _eventJobs;
+    private _apiReferenceEndpoint;
+    private _ngrokKey;
+    private _ngrokUrl;
     constructor(app: INestApplication<any>);
+    addGlobalGuard(Guard: Type<CanActivate>): this;
     addCronJob(job: CronJobClass): this;
     addEventJob(eventJob: EventJobClass): this;
     addCustomGlobalExceptionFilter(filter: BaseExceptionFilter): this;
@@ -45,10 +50,14 @@ export declare class KoalaApp {
     addCustomDomainExceptionFilter(filter: BaseExceptionFilter): this;
     addCustomZodExceptionFilter(filter: BaseExceptionFilter): this;
     useDoc(config: ApiDocConfig): this;
+    useNgrok(key: string): this;
     enableCors(): this;
     setAppName(name: string): this;
     setInternalUserName(name: string): this;
     setDbTransactionContext(transactionContext: Type<PrismaTransactionalClient>): this;
     build(): Promise<INestApplication<any>>;
+    serve(): Promise<void>;
+    buildAndServe(): Promise<void>;
+    private showListeningMessage;
 }
 export {};

package/core/koala-app.js

@@ -5,23 +5,30 @@ const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const swagger_1 = require("@nestjs/swagger");
 const nestjs_api_reference_1 = require("@scalar/nestjs-api-reference");
+const consola = require("consola");
 const expressBasicAuth = require("express-basic-auth");
+const ngrok = require("ngrok");
+const env_service_1 = require("../env/env.service");
 const domain_errors_filter_1 = require("../filters/domain-errors.filter");
 const global_exception_filter_1 = require("../filters/global-exception.filter");
 const prisma_validation_exception_filter_1 = require("../filters/prisma-validation-exception.filter");
 const zod_errors_filter_1 = require("../filters/zod-errors.filter");
 const ilogging_service_1 = require("../services/logging/ilogging.service");
 const koala_global_vars_1 = require("./koala-global-vars");
-const instanciate_class_with_dependencies_injection_1 = require("./utils/instanciate-class-with-dependencies-injection");
 const env_config_1 = require("./utils/env.config");
+const instanciate_class_with_dependencies_injection_1 = require("./utils/instanciate-class-with-dependencies-injection");
 class KoalaApp {
     app;
     _globalExceptionFilter;
     _prismaValidationExceptionFilter;
     _domainExceptionFilter;
     _zodExceptionFilter;
+    _guards = [];
     _cronJobs = [];
     _eventJobs = [];
+    _apiReferenceEndpoint;
+    _ngrokKey;
+    _ngrokUrl;
     constructor(app) {
         this.app = app;
         const { httpAdapter } = this.app.get(core_1.HttpAdapterHost);
@@ -34,6 +41,11 @@ class KoalaApp {
         this._domainExceptionFilter = new domain_errors_filter_1.DomainErrorsFilter(loggingService);
         this._zodExceptionFilter = new zod_errors_filter_1.ZodErrorsFilter(loggingService);
     }
+    addGlobalGuard(Guard) {
+        const reflector = this.app.get(core_1.Reflector);
+        this._guards.push(new Guard(reflector));
+        return this;
+    }
     addCronJob(job) {
         this._cronJobs.push(job);
         return this;
@@ -102,6 +114,7 @@ class KoalaApp {
         }
         const document = swagger_1.SwaggerModule.createDocument(this.app, documentBuilder.build());
         const swaggerEndpoint = config.endpoint;
+        this._apiReferenceEndpoint = swaggerEndpoint;
         if (config.ui === 'scalar' && swaggerEndpoint === '/') {
             throw new common_1.InternalServerErrorException("O endpoint de documentação não pode ser '/' para UI Scalar.");
         }
@@ -155,6 +168,10 @@ class KoalaApp {
         }
         return this;
     }
+    useNgrok(key) {
+        this._ngrokKey = key;
+        return this;
+    }
     enableCors() {
         this.app.enableCors({
             credentials: true,
@@ -185,7 +202,45 @@ class KoalaApp {
         for (const eventJob of eventJobs) {
             eventJob.setupSubscriptions();
         }
+        for (const guard of this._guards) {
+            this.app.useGlobalGuards(guard);
+        }
+        if (this._ngrokKey) {
+            const envService = this.app.get(env_service_1.EnvService);
+            const port = envService.get('PORT') ?? 3000;
+            await ngrok
+                .connect({
+                authtoken: this._ngrokKey,
+                addr: port,
+            })
+                .then((url) => {
+                this._ngrokUrl = url;
+            });
+        }
         return this.app;
     }
+    async serve() {
+        const envService = this.app.get(env_service_1.EnvService);
+        const port = envService.get('PORT') ?? 3000;
+        this.app.listen(port).then(() => this.showListeningMessage(port));
+    }
+    async buildAndServe() {
+        await this.build();
+        await this.serve();
+    }
+    showListeningMessage(port) {
+        const envService = this.app.get(env_service_1.EnvService);
+        console.log('------------------------------');
+        if (this._apiReferenceEndpoint) {
+            consola.info('API Reference:', `http://localhost:${port}${this._apiReferenceEndpoint}`);
+        }
+        consola.info('Internal Host:', `http://localhost:${port}`);
+        if (this._ngrokUrl) {
+            consola.info('External Host:', this._ngrokUrl);
+            consola.info('External Inspect:', 'http://localhost:4040/inspect/http');
+        }
+        consola.box('Environment:', envService.get('NODE_ENV'));
+        console.log('------------------------------');
+    }
 }
 exports.KoalaApp = KoalaApp;

package/core/security/strategies/api-key.strategy.d.ts

@@ -0,0 +1,16 @@
+import { Request } from 'express';
+import { Strategy } from 'passport-custom';
+export type DoneFn = (err: Error | null, user?: any) => void;
+interface ApiKeyStrategyOptions {
+    header: string;
+    prefix?: string;
+}
+declare abstract class ApiKeyStrategyBase extends Strategy {
+    constructor({ header, prefix }: ApiKeyStrategyOptions);
+    abstract validate(apikey: string, done: DoneFn, request: Request): Promise<void> | void;
+}
+export declare class ApiKeyStrategy extends ApiKeyStrategyBase {
+    constructor(options: ApiKeyStrategyOptions);
+    validate(apikey: string, done: DoneFn, request: Request): void;
+}
+export {};

package/core/security/strategies/api-key.strategy.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyStrategy = void 0;
+const common_1 = require("@nestjs/common");
+const passport_custom_1 = require("passport-custom");
+class ApiKeyStrategyBase extends passport_custom_1.Strategy {
+    constructor({ header, prefix }) {
+        super(async (request, done) => {
+            try {
+                const apikey = request.headers[header.toLowerCase()];
+                const apiKeyEncoded = apikey?.replace(`${prefix || ''} `, '');
+                if (apiKeyEncoded) {
+                    return await this.validate(apiKeyEncoded, done, request);
+                }
+                return done(new common_1.UnauthorizedException());
+            }
+            catch (err) {
+                return done(err, null);
+            }
+        });
+    }
+}
+class ApiKeyStrategy extends ApiKeyStrategyBase {
+    constructor(options) {
+        super(options);
+    }
+    validate(apikey, done, request) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.ApiKeyStrategy = ApiKeyStrategy;

package/core/validators/file-validator.d.ts

@@ -0,0 +1,27 @@
+import { FileValidator } from '@nestjs/common';
+import { FileType } from '..';
+type FileTypeInternal = FileType | FileType[] | Record<string, FileType[]>;
+export declare class FileSizeValidator extends FileValidator {
+    private maxSizeBytes;
+    private multiple;
+    private errorFileName;
+    constructor(args: {
+        maxSizeBytes: number;
+        multiple: boolean;
+    });
+    isValid(file?: FileTypeInternal): Promise<boolean>;
+    buildErrorMessage(file: any): string;
+}
+export declare class FileTypeValidator extends FileValidator {
+    private multiple;
+    private errorFileName;
+    private filetype;
+    constructor(args: {
+        multiple: boolean;
+        filetype: RegExp | string;
+    });
+    isMimeTypeValid(file: FileType): boolean;
+    isValid(file?: FileTypeInternal): Promise<boolean>;
+    buildErrorMessage(file: any): string;
+}
+export {};

package/core/validators/file-validator.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTypeValidator = exports.FileSizeValidator = void 0;
+const common_1 = require("@nestjs/common");
+const runFileValidation = async (args) => {
+    if (args.multiple) {
+        const fileFields = Object.keys(args.file);
+        for (const field of fileFields) {
+            const fieldFile = args.file[field];
+            if (Array.isArray(fieldFile)) {
+                for (const f of fieldFile) {
+                    if (!args.validator(f)) {
+                        return { errorFileName: f.originalname, isValid: false };
+                    }
+                }
+            }
+            else {
+                if (!args.validator(fieldFile)) {
+                    return { errorFileName: fieldFile.originalname, isValid: false };
+                }
+            }
+        }
+        return { isValid: true };
+    }
+    if (Array.isArray(args.file)) {
+        for (const f of args.file) {
+            if (!args.validator(f)) {
+                return { errorFileName: f.originalname, isValid: false };
+            }
+        }
+        return { isValid: true };
+    }
+    if (args.validator(args.file)) {
+        return { errorFileName: args.file.originalname, isValid: false };
+    }
+    return { isValid: true };
+};
+class FileSizeValidator extends common_1.FileValidator {
+    maxSizeBytes;
+    multiple;
+    errorFileName;
+    constructor(args) {
+        super({});
+        this.maxSizeBytes = args.maxSizeBytes;
+        this.multiple = args.multiple;
+    }
+    async isValid(file) {
+        if (!file) {
+            return true;
+        }
+        const result = await runFileValidation({
+            file,
+            multiple: this.multiple,
+            validator: (f) => f.size < this.maxSizeBytes,
+        });
+        this.errorFileName = result.errorFileName ?? '';
+        return result.isValid;
+    }
+    buildErrorMessage(file) {
+        return (`file ${this.errorFileName || ''} exceeded the size limit ` +
+            parseFloat((this.maxSizeBytes / 1024 / 1024).toFixed(2)) +
+            'MB');
+    }
+}
+exports.FileSizeValidator = FileSizeValidator;
+class FileTypeValidator extends common_1.FileValidator {
+    multiple;
+    errorFileName;
+    filetype;
+    constructor(args) {
+        super({});
+        this.multiple = args.multiple;
+        this.filetype = args.filetype;
+    }
+    isMimeTypeValid(file) {
+        return file.mimetype.search(this.filetype) === 0;
+    }
+    async isValid(file) {
+        if (!file) {
+            return true;
+        }
+        const result = await runFileValidation({
+            multiple: this.multiple,
+            file,
+            validator: (f) => this.isMimeTypeValid(f),
+        });
+        this.errorFileName = result.errorFileName ?? '';
+        return result.isValid;
+    }
+    buildErrorMessage(file) {
+        return `file ${this.errorFileName || ''} must be of type ${this.filetype}`;
+    }
+}
+exports.FileTypeValidator = FileTypeValidator;

package/decorators/upload.decorator.d.ts

@@ -0,0 +1 @@
+export declare function UploadDecorator(maxSizeInKb: number, filetype: RegExp): ParameterDecorator;