DEV Community: Leonardo Minora

js / ts - expressão regular

Leonardo Minora — Fri, 20 Sep 2024 23:56:08 +0000

Claro! Aqui está um exemplo de como usar expressões regulares (regex) em TypeScript:

Exemplo: Validar um endereço de email

// Função para validar e-mail usando regex
function validarEmail(email: string): boolean {
    const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
    return regex.test(email);
}

// Testando a função
const email1 = "teste@example.com";
const email2 = "invalid-email@.com";

console.log(`${email1} é válido? ${validarEmail(email1)}`);
// Saída: teste@example.com é válido? true
console.log(`${email2} é válido? ${validarEmail(email2)}`);
// Saída: invalid-email@.com é válido? false

Descrição do Regex:

^: Início da string.
[a-zA-Z0-9._%+-]+: Um ou mais caracteres alfanuméricos, incluindo pontos, sublinhados, porcentagens, sinais de mais e menos.
@: Um caractere "@".
[a-zA-Z0-9.-]+: Um ou mais caracteres alfanuméricos ou pontos e hífens.
\.: Um caractere de ponto literal.
[a-zA-Z]{2,}: Duas ou mais letras (para o domínio de nível superior, como .com, .org, etc.).
$: Fim da string.

Esse exemplo mostra como você pode usar regex para validar um formato de email em TypeScript. Se precisar de mais exemplos ou explicações, fique à vontade para perguntar!

by ChatGPT

js / ts - comando !!

Leonardo Minora — Fri, 20 Sep 2024 22:39:06 +0000

Em TypeScript (e JavaScript), o operador !! é uma maneira comum de converter um valor em um booleano. Essencialmente, o !! transforma qualquer valor em um valor booleano verdadeiro (true) ou falso (false).

Como Funciona:

O primeiro ! nega o valor: se o valor for "truthy" (verdadeiro), ele se tornará false. Se o valor for "falsy" (falso), ele se tornará true.
O segundo ! nega novamente o resultado da primeira negação. Assim, se o valor original era "truthy", o resultado final será true, e se era "falsy", o resultado final será false.

Valores Truthy e Falsy

Em JavaScript, alguns exemplos de valores "falsy" incluem:

false
0
-0
"" (string vazia)
null
undefined
NaN

Qualquer outro valor é considerado "truthy", como:

Objetos (inclusive arrays)
Strings não vazias
Números diferentes de zero

Exemplos:

Aqui estão alguns exemplos que mostram como o !! funciona:

const a = 5;
const b = 0;
const c = null;
const d = "Hello";

// Usando !! para converter em booleano
console.log(!!a); // true (5 é truthy)
console.log(!!b); // false (0 é falsy)
console.log(!!c); // false (null é falsy)
console.log(!!d); // true (string não vazia é truthy)

// Exemplo mais complexo
const myArray = [];
console.log(!!myArray); // true (array vazio é truthy)

Uso Típico

O !! é frequentemente usado em códigos onde você deseja garantir que um valor seja tratado como um booleano, especialmente em condições. Por exemplo:

if (!!user) {
    console.log("User exists");
} else {
    console.log("User does not exist");
}

Neste caso, o uso de !! assegura que user é tratado como um booleano ao avaliar a condição do if.

Conclusão

Portanto, o !! é uma forma conveniente e concisa de forçar um valor a ser interpretado como um booleano em TypeScript e JavaScript. É uma prática comum para garantir que uma condição seja avaliada corretamente.

by ChatGPT

NestJS - Validando o envio de arquivos

Leonardo Minora — Thu, 19 Sep 2024 21:10:31 +0000

Informações gerais

aula com FIXME para os alunos de programação orientada a serviços, do 4o ano de infoweb, do CNAT-IFRN
repositório de código
código final branch zip

objetivo

validar os arquivos enviados com validadores do nestjs
validar os arquivos enviados com validador personalizado

notas de aula

sumário

pegar o código base
acessar pasta do projeto e instalar bibliotecas do projeto
executar a api
incluir módulo nestjs para os novos endpoints
codar 1 endpoint com validação nestjs para envio de imagem png
codar 1 endpoint com validação nestjs para envio de imagem jpeg
codar 1 endpoint com validação personalizada para envio de imagens

1. pegar o código base

pode utilizar o seu próprio código, ou baixar o zip ou fazer o clone do repositório github com o código-fonte do projeto da nota de aula anterior.

lembrando que fazendo o clone do repositório github, precisará executar na pasta do projeto o comando git checkout -b 05-upload-validacao origin/05-upload-validacao.

2. acessar pasta do projeto e instalar bibliotecas do projeto

[upload-api] $ npm install

3. executar a api

[upload-api] $ npm run start:dev

após lançar a api, o terminal deverá parecer como o console abaixo.

[14:44:53] Starting compilation in watch mode...

[14:44:56] Found 0 errors. Watching for file changes.

[Nest] 359207  - 20/09/2024, 14:44:57     LOG [NestFactory] Starting Nest application...
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [InstanceLoader] ConfigHostModule dependencies initialized +22ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [InstanceLoader] AppModule dependencies initialized +1ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [InstanceLoader] ConfigModule dependencies initialized +1ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [InstanceLoader] ImageKitModule dependencies initialized +1ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [InstanceLoader] NuvemModule dependencies initialized +1ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RoutesResolver] AppController {/}: +32ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +1ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RoutesResolver] NuvemController {/nuvem}: +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RouterExplorer] Mapped {/nuvem/upload, POST} route +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RouterExplorer] Mapped {/nuvem/nome/:arquivo_nome, GET} route +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [RouterExplorer] Mapped {/nuvem/id/:arquivo_id, GET} route +0ms
[Nest] 359207  - 20/09/2024, 14:44:57     LOG [NestApplication] Nest application successfully started +3ms

4. incluir módulo nestjs para os novos endpoints

[upload-api] $ npx @nestjs/cli generate resource validacao --no-spec

[upload-api]$ npx @nestjs/cli generate resource validacao --no-spec
? What transport layer do you use? REST API
? Would you like to generate CRUD entry points? No
CREATE src/validacao/validacao.controller.ts (234 bytes)
CREATE src/validacao/validacao.module.ts (276 bytes)
CREATE src/validacao/validacao.service.ts (93 bytes)
UPDATE src/app.module.ts (940 bytes)

após adicionar o recurso/módulo, o terminal deverá parecer como o console abaixo.

[14:46:17] File change detected. Starting incremental compilation...

[14:46:17] Found 0 errors. Watching for file changes.

[Nest] 359539  - 20/09/2024, 14:46:18     LOG [NestFactory] Starting Nest application...
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [InstanceLoader] ConfigHostModule dependencies initialized +16ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [InstanceLoader] AppModule dependencies initialized +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [InstanceLoader] ValidacaoModule dependencies initialized +1ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [InstanceLoader] ImageKitModule dependencies initialized +1ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [InstanceLoader] NuvemModule dependencies initialized +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RoutesResolver] AppController {/}: +17ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +1ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RoutesResolver] NuvemController {/nuvem}: +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RouterExplorer] Mapped {/nuvem/upload, POST} route +1ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RouterExplorer] Mapped {/nuvem/nome/:arquivo_nome, GET} route +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RouterExplorer] Mapped {/nuvem/id/:arquivo_id, GET} route +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [RoutesResolver] ValidacaoController {/validacao}: +0ms
[Nest] 359539  - 20/09/2024, 14:46:18     LOG [NestApplication] Nest application successfully started +2ms

5. codar 1 endpoint com validação nestjs para envio de imagem png

objetivo: criar o endpoint para upload de 1 arquivo imagem png com documentação swagger.

modificar o arquivo ./src/validacao/validacao.controller.ts.

--import { Controller } from '@nestjs/common';
++import {
++  Controller,
++  HttpStatus,
++  Post,
++  UploadedFile,
++  UseInterceptors,
++} from '@nestjs/common';
++import {
++  ApiBadRequestResponse,
++  ApiBody,
++  ApiConsumes,
++  ApiOperation,
++  ApiResponse,
++  ApiTags,
++} from '@nestjs/swagger';
++import { FileInterceptor } from '@nestjs/platform-express';
import { ValidacaoService } from './validacao.service';

@Controller('validacao')
++@ApiTags('validação')
export class ValidacaoController {
  constructor(private readonly validacaoService: ValidacaoService) {}
++
++  @Post('upload/png')
++  @UseInterceptors(FileInterceptor('arquivo_png'))
++  @ApiConsumes('multipart/form-data')
++  @ApiBody({
++    schema: {
++      type: 'object',
++      properties: {
++        arquivo_png: {
++          type: 'string',
++          format: 'binary',
++        },
++      },
++    },
++  })
++  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
++  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
++  @ApiBadRequestResponse({
++    status: HttpStatus.BAD_REQUEST,
++    description: 'PROBLEMA com a imagem png enviada.',
++  })
++  upload_png(@UploadedFile() arquivo: Express.Multer.File) {
++    return { estado: 'ok' };
++  }
}

após salvar o arquivo ./src/validacao/validacao.controller.ts, o terminal onde esta executando a API deve parecer com o console abaixo.
Note que foi adicionado mais um endpoint Mapped {/validacao/upload/png, POST} route

[20:19:27] File change detected. Starting incremental compilation...

[20:19:27] Found 0 errors. Watching for file changes.

[Nest] 415309  - 20/09/2024, 20:19:28     LOG [NestFactory] Starting Nest application...
[Nest] 415309  - 20/09/2024, 20:19:28     LOG [InstanceLoader] ConfigHostModule dependencies initialized +16ms
[Nest] 415309  - 20/09/2024, 20:19:28     LOG [InstanceLoader] AppModule dependencies initialized +0ms
[Nest] 415309  - 20/09/2024, 20:19:28     LOG [InstanceLoader] ConfigModule dependencies initialized +1ms
[Nest] 415309  - 20/09/2024, 20:19:28     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 415309  - 20/09/2024, 20:19:28     LOG [InstanceLoader] UploadModule dependencies initialized +0ms
[Nest] 415309  - 20/09/2024, 20:19:28     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 415309  - 20/09/2024, 20:19:28     LOG [InstanceLoader] ValidacaoModule dependencies initialized +0ms
[Nest] 415309  - 20/09/2024, 20:19:28     LOG [InstanceLoader] ImageKitModule dependencies initialized +1ms
[Nest] 415309  - 20/09/2024, 20:19:28     LOG [InstanceLoader] NuvemModule dependencies initialized +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RoutesResolver] AppController {/}: +18ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +1ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RoutesResolver] NuvemController {/nuvem}: +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RouterExplorer] Mapped {/nuvem/upload, POST} route +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RouterExplorer] Mapped {/nuvem/nome/:arquivo_nome, GET} route +1ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RouterExplorer] Mapped {/nuvem/id/:arquivo_id, GET} route +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RoutesResolver] ValidacaoController {/validacao}: +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [RouterExplorer] Mapped {/validacao/upload/png, POST} route +0ms
[Nest] 415309  - 20/09/2024, 20:19:29     LOG [NestApplication] Nest application successfully started +3ms

para essa versão do endpoint e qualquer arquivo enviado o resultado será como no console abaixo.

{
  "estato": "ok"
}

objetivo: modificar o endpoint para validar o arquivo enviado, aceitando apenas o png.

modificar o arquivo ./src/validacao/validacao.controller.ts

import {
  Controller,
++  FileTypeValidator,
  HttpStatus,
++  ParseFilePipe,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { ValidacaoService } from './validacao.service';
import {
  ApiBadRequestResponse,
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('validacao')
@ApiTags('validação')
export class ValidacaoController {
  constructor(private readonly validacaoService: ValidacaoService) {}

  @Post('upload/png')
  @UseInterceptors(FileInterceptor('arquivo_png'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo_png: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
  @ApiBadRequestResponse({
    status: HttpStatus.BAD_REQUEST,
    description: 'PROBLEMA com a imagem png enviada.',
  })
--  upload_png(@UploadedFile() arquivo: Express.Multer.File) {
++  upload_png(
++    @UploadedFile(
++      new ParseFilePipe({
++        validators: [new FileTypeValidator({ fileType: 'image/png' })],
++      }),
++    )
++    arquivo: Express.Multer.File,
++  ) {
    return { estado: 'ok' };
  }
}

foi adicionado no decorador (decorator) @UploadedFile, no parâmetro da assinatura do método upload_png, um novo objeto new ParseFilePipe que será responsável por executar as validações de arquivos enviados.
As validações são inseridas no atributo validators em seguida, e neste caso foi usado apenas o FileTypeValidator para verificar o tipo de arquivo (ver aviso abaixo).

Aviso by nestjs no tutorial sobre File upload com tradução pelo ChatGPT e links by me.

Para verificar o tipo de arquivo, a classe FileTypeValidator usa o tipo detectado pelo multer. Por padrão, o multer extrai o tipo do arquivo a partir da extensão do arquivo no dispositivo do usuário. No entanto, ele não verifica o conteúdo real do arquivo. Como os arquivos podem ser renomeados para extensões arbitrárias, considere usar uma implementação personalizada (como verificar o número mágico do arquivo) se seu aplicativo requer uma solução mais segura.

para esta versão com validação do endpoint, quando enviamos um arquivo imagem png, a resposta continuará a mesma acima.
caso envie qualquer outro tipo de arquivo, a resposta será como o json abaixo.

{
  "message": "Validation failed (expected type is image/png)",
  "error": "Bad Request",
  "statusCode": 400
}

6. codar 1 endpoint com validação nestjs para envio de imagem jpeg

objetivo: criar o endpoint para upload de 1 arquivo imagem jpeg com documentação swagger.

modificar o arquivo ./src/validacao/validacao.controller.ts.

import {
  Controller,
  FileTypeValidator,
  HttpStatus,
  ParseFilePipe,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { ValidacaoService } from './validacao.service';
import {
  ApiBadRequestResponse,
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('validacao')
@ApiTags('validação')
export class ValidacaoController {
  constructor(private readonly validacaoService: ValidacaoService) {}

  @Post('upload/png')
  @UseInterceptors(FileInterceptor('arquivo_png'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo_png: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
  @ApiBadRequestResponse({
    status: HttpStatus.BAD_REQUEST,
    description: 'PROBLEMA com a imagem png enviada.',
  })
  upload_png(
    @UploadedFile(
      new ParseFilePipe({
        validators: [new FileTypeValidator({ fileType: 'image/png' })],
      }),
    )
    arquivo: Express.Multer.File,
  ) {
    return { estado: 'ok' };
  }
++
++  @Post('upload/jpeg')
++  @UseInterceptors(FileInterceptor('arquivo_jpeg'))
++  @ApiConsumes('multipart/form-data')
++  @ApiBody({
++    schema: {
++      type: 'object',
++      properties: {
++        arquivo_jpeg: {
++          type: 'string',
++          format: 'binary',
++        },
++      },
++    },
++  })
++  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
++  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
++  @ApiBadRequestResponse({
++    status: HttpStatus.BAD_REQUEST,
++    description: 'PROBLEMA com a imagem jpeg enviada.',
++  })
++  upload_jpeg(
++    @UploadedFile()
++    arquivo: Express.Multer.File,
++  ) {
++    return { estado: 'ok' };
++  }
}

[20:59:39] File change detected. Starting incremental compilation...

[20:59:39] Found 0 errors. Watching for file changes.

[Nest] 418615  - 20/09/2024, 20:59:41     LOG [NestFactory] Starting Nest application...
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [InstanceLoader] ConfigHostModule dependencies initialized +34ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [InstanceLoader] AppModule dependencies initialized +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [InstanceLoader] ConfigModule dependencies initialized +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [InstanceLoader] ConfigModule dependencies initialized +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [InstanceLoader] ValidacaoModule dependencies initialized +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [InstanceLoader] ImageKitModule dependencies initialized +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [InstanceLoader] NuvemModule dependencies initialized +2ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RoutesResolver] AppController {/}: +42ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/, GET} route +5ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RoutesResolver] UploadController {/upload}: +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +0ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +0ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RoutesResolver] NuvemController {/nuvem}: +0ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/nuvem/upload, POST} route +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/nuvem/nome/:arquivo_nome, GET} route +0ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/nuvem/id/:arquivo_id, GET} route +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RoutesResolver] ValidacaoController {/validacao}: +0ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/validacao/upload/png, POST} route +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [RouterExplorer] Mapped {/validacao/upload/jpeg, POST} route +1ms
[Nest] 418615  - 20/09/2024, 20:59:41     LOG [NestApplication] Nest application successfully started +4ms

para essa versão do endpoint e qualquer arquivo enviado o resultado será como no console abaixo.

{
  "estato": "ok"
}

objetivo: modificar o endpoint para validar o arquivo enviado, aceitando apenas o jpeg e jpg.

modificar o arquivo ./src/validacao/validacao.controller.ts

import {
  Controller,
  FileTypeValidator,
  HttpStatus,
  ParseFilePipe,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { ValidacaoService } from './validacao.service';
import {
  ApiBadRequestResponse,
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('validacao')
@ApiTags('validação')
export class ValidacaoController {
  constructor(private readonly validacaoService: ValidacaoService) {}

  @Post('upload/png')
  @UseInterceptors(FileInterceptor('arquivo_png'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo_png: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
  @ApiBadRequestResponse({
    status: HttpStatus.BAD_REQUEST,
    description: 'PROBLEMA com a imagem png enviada.',
  })
  upload_png(
    @UploadedFile(
      new ParseFilePipe({
        validators: [new FileTypeValidator({ fileType: 'image/png' })],
      }),
    )
    arquivo: Express.Multer.File,
  ) {
    return { estado: 'ok' };
  }

  @Post('upload/jpeg')
  @UseInterceptors(FileInterceptor('arquivo_jpeg'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo_jpeg: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
  @ApiBadRequestResponse({
    status: HttpStatus.BAD_REQUEST,
    description: 'PROBLEMA com a imagem jpeg enviada.',
  })
  upload_jpeg(
--    @UploadedFile()
++    @UploadedFile(
++      new ParseFilePipe({
++        validators: [new FileTypeValidator({ fileType: /jpeg|jpg/ })],
++      }),
++    )
    arquivo: Express.Multer.File,
  ) {
    return { estado: 'ok' };
  }
}

assim como no endpoint anterior /upload/png, aqui também foi adicionado no decorador (decorator) @UploadedFile, no parâmetro da assinatura do método upload_jpeg, um novo objeto new ParseFilePipe que será responsável por executar as validações de arquivos enviados.
As validações são inseridas no atributo validators em seguida, e neste caso foi usado apenas o FileTypeValidator para verificar o tipo de arquivo.
contudo neste caso, o valor de fileType em FileTypeValidator teve uma expressão regular /jpeg|jpg/ que será processada no interpretada e validada em FileTypeValidator verifique a extensão do arquivo se é igual a jpeg ou jpg por causa do pipe adicionado.

{
  "message": "Validation failed (expected type is /jpeg|jpg/)",
  "error": "Bad Request",
  "statusCode": 400
}

7. codar 1 endpoint com validação personalizada para envio de imagens

FIXME

NestJS - Armazenamento nas nuvens

Leonardo Minora — Thu, 19 Sep 2024 18:16:56 +0000

Informações gerais

aula com endpoint para upload de arquivos com armazenamento em nuvem (cloud) para os alunos de programação orientada a serviços, do 4o ano de infoweb, do CNAT-IFRN
repositório de código
código final branch zip

objetivo

criar 1 endpoint de upload de 1 arquivo com armazenamento em nuvem (cloud)
criar 1 endpoint de download de 1 arquivo que foi armazenado em nuvem (cloud)

notas de aula

sumário

pegar o código base
acessar pasta do projeto e instalar bibliotecas do projeto
executar a api
criar conta no imagekit.io e configurar acesso ao serviço
incluir módulo nestjs para os novos endpoints
codar o upload de arquivo para armazenamento na nuvem
codar o "download" de arquivo armazenado na nuvem

1. pegar o código base

pode utilizar o seu próprio código, ou baixar o zip ou fazer o clone do repositório github com o código-fonte do projeto da nota de aula anterior.

lembrando que fazendo o clone do repositório github, precisará executar na pasta do projeto o comando git checkout -b 04-upload-cloud origin/04-upload-cloud.

2. acessar pasta do projeto e instalar bibliotecas do projeto

[upload-api] $ npm install imagekit-nestjs @nestjs/config

3. executar a api

[upload-api] $ npm run start:dev

[21:37:06] Starting compilation in watch mode...

[21:37:08] Found 0 errors. Watching for file changes.

[Nest] 237322  - 18/09/2024, 21:37:09     LOG [NestFactory] Starting Nest application...
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [InstanceLoader] AppModule dependencies initialized +17ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [InstanceLoader] NuvemModule dependencies initialized +0ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [InstanceLoader] UploadModule dependencies initialized +0ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [RoutesResolver] AppController {/}: +19ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [RoutesResolver] UploadController {/upload}: +1ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +7ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +1ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +0ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +1ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +0ms
[Nest] 237322  - 18/09/2024, 21:37:09     LOG [NestApplication] Nest application successfully started +2ms

4. criar conta no imagekit.io e configurar acesso ao serviço

acessar imagekit.io e criar um conta gratuita;
acessar imagekit.io conectado e criar uma chave privada;
1. conectado e já com uma conta funcionando, acessar o dashboard
2. no menu lateral, no meu caso direito, rolar e acessar Developer options
3. na página que abre, tem já pronto a Public key habilitada para copiar
4. nesta mesma página e logo ao lado de Public key, tem Private key (keep confidential) que vem desabilitada, caso sua conta seja criada com login de terceiros
5. habilite Private key (keep confidential)
codar no projeto o acesso a imagekit.io.
1. criar e editar o arquivo .env na pasta raiz do projeto, como exemplo abaixo
2. criar e editar o arquivo ./src/configs/imagekit.config.ts conforme arquivo abaixo
3. editar o arquivo ./src/app.module.ts para configurar o acesso ao serviço do imagekit.io com as libs imagekit-nestjs e @nestjs/config, como arquivo abaixo

arquivo ./src/.env

  CLOUD_PUBLIC_KEY='COPIAR AQUI A SUA CHAVE PUBLICA'
  CLOUD_PRIVATE_KEY='COPIAR AQUI A SUA CHAVE PRIVADA'
  CLOUD_URL_ENDPOINT='https://ik.imagekit.io/SEU ImagekitID/'

arquivo ./src/configs/imagekit.config.ts

import { ConfigService } from '@nestjs/config';
import { ImageKitModuleOptions } from 'imagekit-nestjs';

export const ImageKitConfig = (
  configService: ConfigService,
): ImageKitModuleOptions => ({
  privateKey: configService.get('CLOUD_PRIVATE_KEY'),
  publicKey: configService.get('CLOUD_PUBLIC_KEY'),
  urlEndpoint: configService.get('CLOUD_URL_ENDPOINT'),
});

arquivo ./src/app.module.ts

import { Module } from '@nestjs/common';
++import { ConfigModule, ConfigService } from '@nestjs/config';
++import { ImageKitModule } from 'imagekit-nestjs';
++import { ImageKitConfig } from './configs/imagekit.config';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { UploadModule } from './upload/upload.module';
import { ArmazenamentoModule } from './armazenamento/armazenamento.module';

@Module({
--  imports: [UploadModule, ArmazenamentoModule],
++  imports: [
++    ConfigModule.forRoot(),
++    ImageKitModule.forRootAsync({
++      useFactory: ImageKitConfig,
++      inject: [ConfigService],
++      imports: [ConfigModule],
++      isGlobal: true,
++    }),
++    UploadModule,
++    ArmazenamentoModule,
++  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

após salvar os arquivos, o terminal de execução da API deve parecer com o console abaixo.

[13:56:12] File change detected. Starting incremental compilation...

[13:56:12] Found 0 errors. Watching for file changes.

[Nest] 273809  - 19/09/2024, 13:56:13     LOG [NestFactory] Starting Nest application...
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ConfigHostModule dependencies initialized +25ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] AppModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ConfigModule dependencies initialized +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] NuvemModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ImageKitModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RoutesResolver] AppController {/}: +18ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RoutesResolver] UploadController {/upload}: +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [NestApplication] Nest application successfully started +3ms

5. incluir módulo nestjs para os novos endpoints

[upload-api] $ npx @nestjs/cli generate resource nuvem --no-spec

resultado da execução do comando de gerar recurso (module) nuvem.

[upload-api] $ npx @nestjs/cli g res nuvem --no-spec
? What transport layer do you use? REST API
? Would you like to generate CRUD entry points? No
CREATE src/nuvem/nuvem.controller.ts (210 bytes)
CREATE src/nuvem/nuvem.module.ts (248 bytes)
CREATE src/nuvem/nuvem.service.ts (89 bytes)
UPDATE src/app.module.ts (478 bytes)

resultado do terminal que esta com a API em execução.

[13:56:12] File change detected. Starting incremental compilation...

[13:56:12] Found 0 errors. Watching for file changes.

[Nest] 273809  - 19/09/2024, 13:56:13     LOG [NestFactory] Starting Nest application...
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ConfigHostModule dependencies initialized +25ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] AppModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ConfigModule dependencies initialized +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] NuvemModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [InstanceLoader] ImageKitModule dependencies initialized +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RoutesResolver] AppController {/}: +18ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RoutesResolver] UploadController {/upload}: +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +1ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [RoutesResolver] NuvemController {/nuvem}: +0ms
[Nest] 273809  - 19/09/2024, 13:56:13     LOG [NestApplication] Nest application successfully started +3ms

6. codar o upload de arquivo para armazenamento na nuvem

objetivo: criar o endpoint para upload de 1 arquivo com documentação swagger.

modificar o arquivo src/nuvem/nuvem.controller.ts

--import { Controller } from '@nestjs/common';
--import { NuvemService } from './nuvem.service';
++import {
++  Controller,
++  Post,
++  UploadedFile,
++  UseInterceptors,
++} from '@nestjs/common';
++import { NuvemService } from './nuvem.service';
++import {
++  ApiBody,
++  ApiConsumes,
++  ApiOperation,
++  ApiResponse,
++  ApiTags,
++} from '@nestjs/swagger';
++import { FileInterceptor } from '@nestjs/platform-express';

@Controller('nuvem')
++@ApiTags('nuvem')
export class NuvemController {
  constructor(private readonly nuvemService: NuvemService) {}
++
++  @Post('upload')
++  @UseInterceptors(FileInterceptor('arquivo'))
++  @ApiConsumes('multipart/form-data')
++  @ApiBody({
++    schema: {
++      type: 'object',
++      properties: {
++        arquivo: {
++          type: 'string',
++          format: 'binary',
++        },
++      },
++    },
++  })
++  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
++  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
++  @ApiResponse({ status: 400, description: 'ERRO no upload do arquivo.' })
++  upload(@UploadedFile() arquivo: Express.Multer.File) {
++    return { estado: 'ok' };
++  }
++
}

após salvar o arquivo ./src/nuvem/nuvem.controller.ts, o terminal onde esta executando a API deve parecer com o console abaixo.
Note que foi adicionado mais um endpoint Mapped {/nuvem/upload, POST} route

[13:59:42] File change detected. Starting incremental compilation...

[13:59:42] Found 0 errors. Watching for file changes.

[Nest] 273999  - 19/09/2024, 13:59:42     LOG [NestFactory] Starting Nest application...
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [InstanceLoader] ConfigHostModule dependencies initialized +16ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [InstanceLoader] AppModule dependencies initialized +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [InstanceLoader] ConfigModule dependencies initialized +1ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [InstanceLoader] NuvemModule dependencies initialized +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [InstanceLoader] ImageKitModule dependencies initialized +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RoutesResolver] AppController {/}: +20ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RouterExplorer] Mapped {/, GET} route +3ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +1ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +1ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RoutesResolver] NuvemController {/nuvem}: +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [RouterExplorer] Mapped {/nuvem/upload, POST} route +0ms
[Nest] 273999  - 19/09/2024, 13:59:42     LOG [NestApplication] Nest application successfully started +2ms

para essa versão do endpoint, o exemplo de teste com a documentação swagger na figura abaixo e o resultado no console, também, abaixo.

{
  "estato": "ok"
}

objetivo: armazenar o arquivo recebido na nuvem imagekit.io.

modificar o arquivo ./src/nuvem/nuvem.service.ts

import { Injectable } from '@nestjs/common';
++import { ImageKitService } from 'imagekit-nestjs';
++
++class ArquivoDto {
++  id: string;
++  nome: string;
++  tamanho: number;
++  mimetype: string;
++  encoding: string;
++  armazenamento: string;
++}

@Injectable()
--export class NuvemService {}
++export class NuvemService {
++  arquivos: ArquivoDto[] = [];
++
++  constructor(private readonly cloud: ImageKitService) {}
++
++  async upload(arquivo: Express.Multer.File) {
++    const resultado = await this.cloud.upload({
++      file: arquivo.buffer,
++      fileName: arquivo.originalname,
++    });
++
++    if (!resultado) {
++      throw new HttpException(
++        'Erro ao tentar armazenar arquivo na nuvem',
++        HttpStatus.NOT_ACCEPTABLE,
++      );
++    }
++
++    const informacao: ArquivoDto = {
++      id: resultado.fileId,
++      nome: arquivo.originalname,
++      encoding: arquivo.encoding,
++      mimetype: arquivo.mimetype,
++      tamanho: arquivo.size,
++      armazenamento: resultado.url,
++    };
++    this.arquivos.push(informacao);
++    return {
++      estado: 'ok',
++      data: informacao,
++    };
++  }
++}

objetivo: ligar o endpoint (controller) ao processamento de armazenamento (service).

modificar o arquivo ./src/nuvem/nuvem.controller.ts

import {
  Controller,
  HttpStatus,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { NuvemService } from './nuvem.service';
import {
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('nuvem')
@ApiTags('nuvem')
export class NuvemController {
  constructor(private readonly nuvemService: NuvemService) {}

  @Post('upload')
  @UseInterceptors(FileInterceptor('arquivo'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
--  @ApiResponse({ status: 400, description: 'ERRO no upload do arquivo.' })
++  @ApiResponse({
++    status: HttpStatus.NOT_ACCEPTABLE,
++    description: 'ERRO no upload do arquivo.',
++  })
  upload(@UploadedFile() arquivo: Express.Multer.File) {
--    return { estado: 'ok' };
++    return this.nuvemService.upload(arquivo);
  }
}

para a versão final do endpoint, o exemplo de teste com a documentação swagger na figura abaixo e o resultado no console, também, abaixo.

{
  "estado": "ok",
  "data": {
    "id": "66ec6724e375273f6095fca5",
    "nome": "diatinf.png",
    "encoding": "7bit",
    "mimetype": "image/png",
    "tamanho": 132200,
    "armazenamento": "https://ik.imagekit.io/minora/diatinf_nLtEXmRGb.png"
  }
}

7. codar o "download" de arquivo armazenado na nuvem

objetivo: criar o endpoint para download de 1 arquivo com documentação swagger.

modificar o arquivo src/nuvem/nuvem.controller.ts

import {
  Controller,
++  Get,
++  Param,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { NuvemService } from './nuvem.service';
import {
++  ApiBadRequestResponse,
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('nuvem')
@ApiTags('nuvem')
export class NuvemController {
  constructor(private readonly nuvemService: NuvemService) {}

  @Post('upload')
  @UseInterceptors(FileInterceptor('arquivo'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
  @ApiResponse({ status: 400, description: 'ERRO no upload do arquivo.' })
  upload(@UploadedFile() arquivo: Express.Multer.File) {
    return this.nuvemService.upload(arquivo);
  }

++  @Get('nome/:arquivo_nome')
++  @ApiOperation({
++    summary: 'pegar um arquivo pelo seu nome que esta armazenado na nuvem',
++  })
++  @ApiResponse({ status: 201, description: 'Download de arquivo concluído.' })
++  @ApiBadRequestResponse({
++    status: 404,
++    description: 'ERRO arquivo não encontrado.',
++  })
++  downloadByNome(@Param('arquivo_nome') arquivo_nome: string) {
++    return { estado: 'ok' };
++  }
++
++  @Get('id/:arquivo_id')
++  @ApiOperation({
++    summary: 'pegar um arquivo pelo seu id que esta armazenado na nuvem',
++  })
++  @ApiResponse({ status: 201, description: 'Download de arquivo concluído.' })
++  @ApiBadRequestResponse({
++    status: 404,
++    description: 'ERRO arquivo não encontrado.',
++  })
++  downloadById(@Param('arquivo_id') arquivo_id: string) {
++    return { estado: 'ok' };
++  }
}

após salvar o arquivo src/nuvem/nuvem.controller.ts, o terminal onde esta executando a API deve parecer com o console abaixo.
Note que foi adicionado mais 2 endpoints Mapped {/armazenamento/:nome, GET} e Mapped {/nuvem/id/:arquivo_id, GET.

[16:42:11] File change detected. Starting incremental compilation...

[16:42:11] Found 0 errors. Watching for file changes.

[Nest] 285402  - 19/09/2024, 16:42:12     LOG [NestFactory] Starting Nest application...
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [InstanceLoader] ConfigHostModule dependencies initialized +15ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [InstanceLoader] AppModule dependencies initialized +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [InstanceLoader] ConfigModule dependencies initialized +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [InstanceLoader] ImageKitModule dependencies initialized +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [InstanceLoader] NuvemModule dependencies initialized +1ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RoutesResolver] AppController {/}: +17ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +1ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RoutesResolver] NuvemController {/nuvem}: +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RouterExplorer] Mapped {/nuvem/upload, POST} route +1ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RouterExplorer] Mapped {/nuvem/nome/:arquivo_nome, GET} route +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [RouterExplorer] Mapped {/nuvem/id/:arquivo_id, GET} route +0ms
[Nest] 285402  - 19/09/2024, 16:42:12     LOG [NestApplication] Nest application successfully started +2ms

para ambas os endpoints, segue o exemplo de teste com a documentação swagger na figura abaixo e o resultado no console, também, abaixo.

{
  "estato": "ok"
}

objetivo: recuperar informações do arquivo armazenado na nuvem imagekit.io.

modificar o arquivo ./src/nuvem/nuvem.service.ts

--import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
++import {
++  HttpException,
++  HttpStatus,
++  Injectable,
++  NotFoundException,
++} from '@nestjs/common';import { ImageKitService } from 'imagekit-nestjs';

class ArquivoDto {
  id: string;
  nome: string;
  tamanho: number;
  mimetype: string;
  encoding: string;
  armazenamento: string;
}

@Injectable()
export class NuvemService {
  arquivos: ArquivoDto[] = [];

  constructor(private readonly cloud: ImageKitService) {}

  async upload(arquivo: Express.Multer.File) {
    const resultado = await this.cloud.upload({
      file: arquivo.buffer,
      fileName: arquivo.originalname,
    });

    if (!resultado) {
      throw new HttpException(
        'Erro ao tentar armazenar arquivo na nuvem',
        HttpStatus.NOT_ACCEPTABLE,
      );
    }

    const informacao: ArquivoDto = {
      id: resultado.fileId,
      nome: arquivo.originalname,
      encoding: arquivo.encoding,
      mimetype: arquivo.mimetype,
      tamanho: arquivo.size,
      armazenamento: resultado.url,
    };
    this.arquivos.push(informacao);
    return {
      estado: 'ok',
      data: informacao,
    };
  }
++
++  pegarPorNome(nome: string) {
++    const informacao = this.arquivos.filter((item) => item.nome === nome);
++    if (informacao.length === 0) {
++      throw new NotFoundException(`Arquivo (${nome}) não encontrado.`);
++    }
++    return informacao[0];
++  }
++
++  pegarPorID(id: string) {
++    const informacao = this.arquivos.filter((item) => item.id === id);
++    if (informacao.length === 0) {
++      throw new NotFoundException(`Arquivo (${id}) não encontrado.`);
++    }
++    return informacao[0];
++  }
}

objetivo: ligar o endpoint (controller) ao processamento de armazenamento (service).

modificar o arquivo ./src/nuvem/nuvem.controller.ts

import {
  Controller,
  Get,
  Param,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { NuvemService } from './nuvem.service';
import {
  ApiBadRequestResponse,
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('nuvem')
@ApiTags('nuvem')
export class NuvemController {
  constructor(private readonly nuvemService: NuvemService) {}

  @Post('upload')
  @UseInterceptors(FileInterceptor('arquivo'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento na nuvem' })
  @ApiResponse({ status: 201, description: 'Upload de arquivo concluído.' })
  @ApiResponse({ status: 400, description: 'ERRO no upload do arquivo.' })
  upload(@UploadedFile() arquivo: Express.Multer.File) {
    return this.nuvemService.upload(arquivo);
  }

  @Get('nome/:arquivo_nome')
  @ApiOperation({
    summary: 'pegar um arquivo pelo seu nome que esta armazenado na nuvem',
  })
  @ApiResponse({ status: 201, description: 'Download de arquivo concluído.' })
  @ApiBadRequestResponse({
    status: 404,
    description: 'ERRO arquivo não encontrado.',
  })
  downloadByNome(@Param('arquivo_nome') arquivo_nome: string) {
--    return { estado: 'ok' };
++    return this.nuvemService.pegarPorNome(arquivo_nome);
  }

  @Get('id/:arquivo_id')
  @ApiOperation({
    summary: 'pegar um arquivo pelo seu id que esta armazenado na nuvem',
  })
  @ApiResponse({ status: 201, description: 'Download de arquivo concluído.' })
  @ApiBadRequestResponse({
    status: 404,
    description: 'ERRO arquivo não encontrado.',
  })
  downloadById(@Param('arquivo_id') arquivo_id: string) {
--    return { estado: 'ok' };
++    return this.nuvemService.pegarPorID(arquivo_id);
  }
}

para a versão final dos endpoints, o exemplo de teste com a documentação swagger na figura abaixo e o resultado no console, também, abaixo.

{
  "estado": "ok",
  "data": {
    "id": "66ec6724e375273f6095fca5",
    "nome": "diatinf.png",
    "encoding": "7bit",
    "mimetype": "image/png",
    "tamanho": 132200,
    "armazenamento": "https://ik.imagekit.io/minora/diatinf_nLtEXmRGb.png"
  }
}

NestJS - Armazenamento local de upload

Leonardo Minora — Mon, 16 Sep 2024 17:59:19 +0000

Informações gerais

aula com endpoint para upload de arquivos com armazenamento em disco local para os alunos de programação orientada a serviços, do 4o ano de infoweb, do CNAT-IFRN
repositório de código
código final branch 03-upload-store ou zip

objetivo

criar 1 endpoint de upload de 1 arquivo com armazenamento em disco local
criar 1 endpoint de download de 1 arquivo que foi armazenado em disco local

notas de aula

sumário

pegar o código base
acessar pasta do projeto e instalar bibliotecas do projeto
executar a api
incluir módulo nestjs para os novos endpoints
codar o upload de arquivo com armazenamento local
codar o download de arquivo com armazenamento local
codar para adicionar exceção para arquivo não encontrado

1. pegar o código base

pode utilizar o seu próprio código, ou baixar o zip ou fazer o clone do repositório github com o código-fonte do projeto da nota de aula anterior.

lembrando que fazendo o clone do repositório github, precisará executar na pasta do projeto o comando git checkout -b 02-upload-arquivos-multiplos origin/02-upload-arquivos-multiplos.

2. acessar pasta do projeto e instalar bibliotecas do projeto

[upload-api] $ npm install

3. executar a api

[upload-api] $ npm run start:dev

4. incluir módulo nestjs para os novos endpoints

[upload-api] $ npx @nestjs/cli generate resource armazenamento --no-spec

[15:08:33] Starting compilation in watch mode...

[15:08:35] Found 0 errors. Watching for file changes.

[Nest] 134297  - 17/09/2024, 15:08:35     LOG [NestFactory] Starting Nest application...
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [InstanceLoader] AppModule dependencies initialized +21ms
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [InstanceLoader] UploadModule dependencies initialized +0ms
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [RoutesResolver] AppController {/}: +18ms
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +0ms
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +1ms
[Nest] 134297  - 17/09/2024, 15:08:35     LOG [NestApplication] Nest application successfully started +2ms

5. codar o upload de arquivo com armazenamento local

objetivo: criar o endpoint para upload de 1 arquivo com documentação swagger.

modificar o arquivo src/armazenamento/armazenamento.controller.ts

--import { Controller } from '@nestjs/common';
++import {
++  Controller,
++  Post,
++  UploadedFile,
++  UseInterceptors,
++} from '@nestjs/common';
++import { ArmazenamentoService } from './armazenamento.service';
++import {
++  ApiBody,
++  ApiConsumes,
++  ApiOperation,
++  ApiResponse,
++  ApiTags,
++} from '@nestjs/swagger';
++import { FileInterceptor } from '@nestjs/platform-express';
++
++@Controller('armazenamento')
++@ApiTags('armazenamento')
export class ArmazenamentoController {
  constructor(private readonly armazenamentoService: ArmazenamentoService) {}
++
++  @Post()
++  @UseInterceptors(FileInterceptor('imagem'))
++  @ApiConsumes('multipart/form-data')
++  @ApiBody({
++    schema: {
++      type: 'object',
++      properties: {
++        imagem: {
++          type: 'string',
++          format: 'binary',
++        },
++      },
++    },
++  })
++  @ApiOperation({ summary: 'Upload de arquivo com armazenamento' })
++  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
++  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
++  salvar(@UploadedFile() arq: Express.Multer.File) {
++    return {estato: 'ok'};
++  }
}

após salvar o arquivo src/armazenamento/armazenamento.controller.ts, o terminal onde esta executando a API deve parecer com o console abaixo.
Note que foi adicionado mais um endpoint Mapped {/armazenamento, POST}

[19:37:49] File change detected. Starting incremental compilation...

[19:37:49] Found 0 errors. Watching for file changes.

[Nest] 155823  - 17/09/2024, 19:37:50     LOG [NestFactory] Starting Nest application...
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [InstanceLoader] AppModule dependencies initialized +23ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [InstanceLoader] UploadModule dependencies initialized +0ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [RoutesResolver] AppController {/}: +16ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +1ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +0ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +0ms
[Nest] 155823  - 17/09/2024, 19:37:50     LOG [NestApplication] Nest application successfully started +2ms

para essa versão do endpoint, o exemplo de teste com a documentação swagger na figura abaixo e o resultado no console, também, abaixo.

{
  "estato": "ok"
}

objetivo: armazenar o arquivo recebido em disco local.

modificar o arquivo src/armazenamento/armazenamento.service.ts

import { Injectable } from '@nestjs/common';
++import { promises as fs } from 'fs';
++import * as path from 'path';
++
++class ImagemDto {
++  id: string;
++  nome: string;
++  tamanho: number;
++  mimetype: string;
++  encoding: string;
++  armazenamento: string;
++}

@Injectable()
export class ArmazenamentoService {
++  dir = path.join(__dirname, '..', '..', 'uploads');
++  imagens = new Array<ImagemDto>();

++  async salvarEmDisco(arquivo: Express.Multer.File) {
++    const nomeCompleto = path.join(this.dir, arquivo.originalname);
++
++    await fs.writeFile(nomeCompleto, arquivo.buffer);
++    this.imagens.push({
++      id: arquivo.originalname,
++      nome: arquivo.originalname,
++      tamanho: arquivo.size,
++      mimetype: arquivo.mimetype,
++      encoding: arquivo.encoding,
++      armazenamento: nomeCompleto,
++    });
++    return {
++      estado: 'ok',
++      dados: {
++        id: arquivo.originalname,
++        nome: arquivo.originalname,
++      },
++    };
++  }
}

objetivo: ligar o endpoint (controller) ao processamento de armazenamento (service).

modificar o arquivo src/armazenamento/armazenamento.controller.ts

import {
  Controller,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { ArmazenamentoService } from './armazenamento.service';
import {
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('armazenamento')
@ApiTags('armazenamento')
export class ArmazenamentoController {
  constructor(private readonly armazenamentoService: ArmazenamentoService) {}

  @Post()
  @UseInterceptors(FileInterceptor('imagem'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        imagem: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento' })
  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
  salvar(@UploadedFile() arq: Express.Multer.File) {
--    return {estato: 'ok'};
++    return this.armazenamentoService.salvarEmDisco(arq);
  }
}

para a versão final do endpoint, o exemplo de teste com a documentação swagger na figura abaixo e o resultado no console, também, abaixo.

{
  "estado": "ok",
  "dados": {
    "id": "Captura de tela de 2024-09-17 15-12-17.png",
    "nome": "Captura de tela de 2024-09-17 15-12-17.png"
  }
}

6. codar o download de arquivo com armazenamento local

objetivo: criar o endpoint para upload de 1 arquivo com documentação swagger.

modificar o arquivo src/armazenamento/armazenamento.controller.ts

import {
  Controller,
++  Get,
++  Param,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { ArmazenamentoService } from './armazenamento.service';
import {
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('armazenamento')
@ApiTags('armazenamento')
export class ArmazenamentoController {
  constructor(private readonly armazenamentoService: ArmazenamentoService) {}

  @Post()
  @UseInterceptors(FileInterceptor('imagem'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        imagem: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento' })
  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
  salvar(@UploadedFile() arq: Express.Multer.File) {
    return this.armazenamentoService.salvarEmDisco(arq);
  }
++
++  @Get(':nome')
++  @ApiOperation({ summary: 'Endpoint para receber arquivo' })
++  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
++  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
++  ler(@Param('nome') nome: string) {
++    return { estado: 'ok' };
++  }
}

[19:51:57] File change detected. Starting incremental compilation...

[19:51:57] Found 0 errors. Watching for file changes.

[Nest] 156968  - 17/09/2024, 19:51:58     LOG [NestFactory] Starting Nest application...
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [InstanceLoader] AppModule dependencies initialized +12ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [InstanceLoader] ArmazenamentoModule dependencies initialized +0ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [RoutesResolver] AppController {/}: +15ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [RouterExplorer] Mapped {/upload/arquivos, POST} route +0ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [RoutesResolver] ArmazenamentoController {/armazenamento}: +1ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [RouterExplorer] Mapped {/armazenamento, POST} route +0ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [RouterExplorer] Mapped {/armazenamento/:nome, GET} route +0ms
[Nest] 156968  - 17/09/2024, 19:51:58     LOG [NestApplication] Nest application successfully started +5ms

para essa versão do endpoint, o exemplo de teste com a documentação swagger na figura abaixo e o resultado no console, também, abaixo.

{
  "estato": "ok"
}

objetivo: ler o arquivo do disco local.

modificar o arquivo src/armazenamento/armazenamento.service.ts

import { Injectable } from '@nestjs/common';
import { promises as fs } from 'fs';
import * as path from 'path';

class ImagemDto {
  id: string;
  nome: string;
  tamanho: number;
  mimetype: string;
  encoding: string;
  armazenamento: string;
}

@Injectable()
export class ArmazenamentoService {
  dir = path.join(__dirname, '..', '..', 'uploads');
  imagens = new Array<ImagemDto>();

  async salvarEmDisco(arquivo: Express.Multer.File) {
    const nomeCompleto = path.join(this.dir, arquivo.originalname);

    await fs.writeFile(nomeCompleto, arquivo.buffer);
    this.imagens.push({
      id: arquivo.originalname,
      nome: arquivo.originalname,
      tamanho: arquivo.size,
      mimetype: arquivo.mimetype,
      encoding: arquivo.encoding,
      armazenamento: nomeCompleto,
    });
    return {
      estado: 'ok',
      dados: {
        id: arquivo.originalname,
        nome: arquivo.originalname,
      },
    };
  }
++
++  async pegar(nome: string) {
++    const imagem = this.imagens.filter((item) => item.id === nome)[0];
++    try {
++      const arquivo = await fs.readFile(imagem.armazenamento);
++      return {
++        estado: 'ok',
++        dados: {
++          informacao: imagem,
++          buffer: arquivo,
++        },
++      };
++    } catch (erro) {
++      return null;
++    }
++  }
}

objetivo: ligar o endpoint (controller) ao processamento de armazenamento (service).

modificar o arquivo src/armazenamento/armazenamento.controller.ts

import {
  Controller,
  Get,
  Param,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { ArmazenamentoService } from './armazenamento.service';
import {
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('armazenamento')
@ApiTags('armazenamento')
export class ArmazenamentoController {
  constructor(private readonly armazenamentoService: ArmazenamentoService) {}

  @Post()
  @UseInterceptors(FileInterceptor('imagem'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        imagem: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento' })
  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
  salvar(@UploadedFile() arq: Express.Multer.File) {
    return this.armazenamentoService.salvarEmDisco(arq);
  }

  @Get(':nome')
  @ApiOperation({ summary: 'Endpoint para receber arquivo' })
  @ApiResponse({ status: 200, description: 'Arquivo enviado com sucesso.' })
  @ApiResponse({ status: 404, description: 'Erro no envio do arquivo.' })
  ler(@Param('nome') nome: string) {
--    return { estado: 'ok' };
++    return this.armazenamentoService.pegar(nome);
  }
}

para a versão final do endpoint, o exemplo de teste com a documentação swagger na figura abaixo e o resultado no console, também, abaixo.

{
  "estado":"ok",
  "dados": {
      "informacao": {
        "id":"diatinf.png",
        "nome":"diatinf.png",
        "tamanho":132200,
        "mimetype":"image/png",
        "encoding":"7bit",
        "armazenamento":"/home/minora/minora/2024/upload-api/uploads/diatinf.png"},
        "buffer":{
          "type":"Buffer",
          "data": [137,80,78,71,13...]
        }
      }
    }
  }
}

7. codar para adicionar exceção para arquivo não encontrado

a imagem abaixo mostra como é respondido pela API quando um arquivo não foi encontrado.
isso ocorre porque em service retorna null mas não é tratado devidamende em controller.

objetivo: lançar exceção quando o arquivo requisitado não for encontrado.

modificar o arquivo src/armazenamento/armazenamento.controller.ts

import {
  Controller,
  Get,
++  NotFoundException,
  Param,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import {
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { FileInterceptor } from '@nestjs/platform-express';
import { ArmazenamentoService } from './armazenamento.service';

@Controller('armazenamento')
@ApiTags('armazenamento')
export class ArmazenamentoController {
  constructor(private readonly armazenamentoService: ArmazenamentoService) {}

  @Post()
  @UseInterceptors(FileInterceptor('imagem'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        imagem: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Upload de arquivo com armazenamento' })
  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
  salvar(@UploadedFile() arq: Express.Multer.File) {
    return this.armazenamentoService.salvarEmDisco(arq);
  }

  @Get(':nome')
  @ApiOperation({ summary: 'Endpoint para receber arquivo' })
  @ApiResponse({ status: 200, description: 'Arquivo enviado com sucesso.' })
  @ApiResponse({ status: 404, description: 'Arquivo não encontrado.' })
--  ler(@Param('nome') nome: string) {
++  async ler(@Param('nome') nome: string) {
--    return this.armazenamentoService.pegar(nome);
++    const resposta = await this.armazenamentoService.pegar(nome);
++    if (resposta) return resposta;
++    throw new NotFoundException('Arquivo não encontrado.');
  }
}

NestJS - criar um endpoint para upload de diversos arquivos

Leonardo Minora — Sun, 15 Sep 2024 19:38:56 +0000

Informações gerais

aula com endpoint para upload de arquivos para os alunos de programação orientada a serviços, do 4o ano de infoweb, do CNAT-IFRN
repositório de código
código final branch 03-upload-arquivos-multiplos zip

objetivo

criar 1 endpoint para API de upload de múltiplos arquivos

notas de aula

sumário

pegar o código do projeto anterior
executar a API
criar e configurar 1 endpoint para receber vários arquivos
criar método no serviço para retornar as informações dos arquivos

para receber vários arquivos, o nestjs disponibiliza os seguintes interceptors:

FilesInterceptor - identifica um array de arquivos com o mesmo nome de campo do formulário;
FileFieldsInterceptor -
AnyFilesInterceptor -

1. pegar o código do projeto anterior

a nota de aula anterior é NestJS - Upload de 1 arquivo que criou um projeto javascript para uma API Rest usando nestjs e typescript.

pode utilizar o seu próprio código, ou baixar o zip ou fazer o clone do repositório github.

2. Executar a API

lembre de acessar a pasta do projeto!!!

antes de executar a api, lembrar de instalar as bibliotecas do projeto com o comando npm i.

lançar a api em modo desenvolvimento executando o comando npm com a opção run para executar o script start:dev.

[upload-api] $ npm run start:dev

a execução deverá produzir um resultado parecido com o console abaixo.

[11:58:35] Starting compilation in watch mode...

[11:58:37] Found 0 errors. Watching for file changes.

[Nest] 12346  - 15/09/2024, 11:58:38     LOG [NestFactory] Starting Nest application...
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [InstanceLoader] AppModule dependencies initialized +14ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [RoutesResolver] AppController {/}: +15ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [RouterExplorer] Mapped {/, GET} route +3ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +2ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [NestApplication] Nest application successfully started +4ms

3. criar e configurar 1 endpoint para receber vários arquivos

adicionar um endpoint no controller src/upload/upload.controller.ts, atualizando as importações, conforme código (diff) abaixo.

import {
  Controller,
  Post,
  UploadedFile,
++  UploadedFiles,
  UseInterceptors,
} from '@nestjs/common';
--import { FileInterceptor } from '@nestjs/platform-express';
++import { FileInterceptor, FilesInterceptor } from '@nestjs/platform-express';
import {
++  ApiBadRequestResponse,
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { UploadService } from './upload.service';

@Controller('upload')
@ApiTags('upload')
export class UploadController {
  constructor(private readonly uploadService: UploadService) {}

  @Post('exemplo-simples')
  @UseInterceptors(FileInterceptor('arquivo'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Exemplo de upload de 1 arquivo qualquer' })
  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
  uploadArquivoSimples(@UploadedFile() arq: Express.Multer.File) {
    console.log(arq);

    return this.uploadService.responderInformacaoArquivo(arq);
  }

++  @Post('arquivos')
++  @UseInterceptors(FilesInterceptor('arquivos'))
++  @ApiConsumes('multipart/form-data')
++  @ApiBody({
++    schema: {
++      type: 'object',
++      properties: {
++        arquivos: {
++          type: 'array',
++          items: {
++            type: 'string',
++            format: 'binary',
++          },
++        },
++      },
++    },
++  })
++  @ApiResponse({
++    status: 201,
++    description: 'Arquivo(s) enviado(s) com sucesso.',
++  })
++  @ApiBadRequestResponse({
++    status: 400,
++    description: 'Erro no envio de arquivos.',
++  })
++  uploadArquivos(@UploadedFiles() arquivos: Array<Express.Multer.File>) {
++    return {
++      estado: 'ok',
++      data: {
++        quantidade: arquivos?.length,
++      },
++    };
++  }
}

foi adicionado nas importações o interceptor FilesInterceptor e o decorator UploadedFiles responsáveis por interceptar e extrair vários arquivos em uma array nomeada como arquivos no formulário.

o decorator @Post configura o verdo POST e o path arquivos do endpoint.
enquanto o decorator @UseInterceptors configura o uso do FilesInterceptor para interceptar a requisitação HTTTP(S) a procura da variável arquivos dentro do formulário no corpo da mensagem.

as próximas linhas contém os decorators @Api (ApiConsumes, ApiBody, ApiResponse, e ApiBadRequestResponse) para configurar a documentação do swagger.

a próxima linha, uploadArquivos(@UploadedFiles() arquivos: Array<Express.Multer.File>) especifica o método uploadArquivos.
este método tem como parâmetro a variável arquivos que irá receber um array contendo itens cada tipados com Express.Multer.File.
o parâmetro arquivos também esta decorado com UploadedFiles que é responsável por extrair o array de arquivos da mensagem HTTP.

ao salvar, a api será relançada e o terminal onde ela esta sendo executada deverá ficar como o console abaixo.

[11:58:35] Starting compilation in watch mode...

[11:58:37] Found 0 errors. Watching for file changes.

[Nest] 12346  - 15/09/2024, 11:58:38     LOG [NestFactory] Starting Nest application...
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [InstanceLoader] AppModule dependencies initialized +14ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [RoutesResolver] AppController {/}: +15ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [RouterExplorer] Mapped {/, GET} route +3ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +2ms
[Nest] 12346  - 15/09/2024, 11:58:38     LOG [NestApplication] Nest application successfully started +4ms

para testar, use a documentação da api acessando o endereço http://localhost:3000/docs/
clique no botão Try it out, escolher alguns arquivos, e clicar em Execute.
a operação deve estar semelhante com a figura abaixo e o resultado após a execução com o json abaixo da figura.

{
  "estado": "ok",
  "data": {
    "quantidade": 3
  }
}

4. criar método no serviço para retornar as informações dos arquivos

no arquivo src/upload/upload.service.ts crie o método responderInformacoesArquivos(arquivos: Array<Express.Multer.File>) e coloque a implementação conforme arquivo (diff) abaixo.

import { Injectable } from '@nestjs/common';

@Injectable()
export class UploadService {
  responderInformacaoArquivo(arquivo: Express.Multer.File) {
    return {
      estado: 'ok',
      dados: {
        nome: arquivo.originalname,
        tamanho: arquivo.size,
        mimetype: arquivo.mimetype,
        encode: arquivo.encoding,
      },
    };
  }
++
++  responderInformacoesArquivos(arquivos: Array<Express.Multer.File>) {
++    const informacoes = arquivos.map((arquivo) => {
++      return {
++        nome: arquivo.originalname,
++        tamanho: arquivo.size,
++        mimetype: arquivo.mimetype,
++        encode: arquivo.encoding,
++      };
++    });
++    return {
++      estado: 'ok',
++      dados: {
++        quantidade: arquivos?.length,
++        arquivos: informacoes,
++      },
++    };
++  }
}

após a modificação do service terá de modificar o controller no arquivo src/upload/upload.controller.ts conforme arquivo abaixo para chamar o método responderInformacoesArquivos.

import {
  Controller,
  Post,
  UploadedFile,
  UploadedFiles,
  UseInterceptors,
} from '@nestjs/common';
import { FileInterceptor, FilesInterceptor } from '@nestjs/platform-express';
import {
  ApiBadRequestResponse,
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';
import { UploadService } from './upload.service';

@Controller('upload')
@ApiTags('upload')
export class UploadController {
  constructor(private readonly uploadService: UploadService) {}

  @Post('exemplo-simples')
  @UseInterceptors(FileInterceptor('arquivo'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Exemplo de upload de 1 arquivo qualquer' })
  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
  uploadArquivoSimples(@UploadedFile() arq: Express.Multer.File) {
    console.log(arq);

    return this.uploadService.responderInformacaoArquivo(arq);
  }

  @Post('arquivos')
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivos: {
          type: 'array',
          items: {
            type: 'string',
            format: 'binary',
          },
        },
      },
    },
  })
  @ApiResponse({
    status: 201,
    description: 'Arquivo(s) enviado(s) com sucesso.',
  })
  @ApiBadRequestResponse({
    status: 400,
    description: 'Erro no envio de arquivos.',
  })
  @UseInterceptors(FilesInterceptor('arquivos'))
  uploadArquivos(@UploadedFiles() arquivos: Array<Express.Multer.File>) {
--    return {
--      estado: 'ok',
--      dados: {
--        quantidade: arquivos?.length,
--        arquivos: informacoes,
--      },
--    };
++    return this.uploadService.responderInformacoesArquivos(arquivos);
  }
}

para testar, pode usar novamente a documentação da API conforme a figura anterior.
o resultado agora será parecido conforme o json abaixo.

{
  "estado": "ok",
  "dados": {
    "quantidade": 3,
    "arquivos": [
      {
        "nome": "README.md",
        "tamanho": 1373,
        "mimetype": "text/markdown",
        "encode": "7bit"
      },
      {
        "nome": "package.json",
        "tamanho": 2020,
        "mimetype": "application/json",
        "encode": "7bit"
      },
      {
        "nome": "Captura de tela de 2024-09-15 15-35-33.png",
        "tamanho": 44726,
        "mimetype": "image/png",
        "encode": "7bit"
      }
    ]
  }
}

Referência e link

notas de aula baseado nos tutoriais/documentações nestjs
- File upload
- OpenAPI - Introduction

NestJS - criar endpoint para upload de 1 arquivo

Leonardo Minora — Mon, 09 Sep 2024 20:57:32 +0000

Informações gerais

aula introdutória de endpoint para upload de arquivo para os alunos de programação orientada a serviços, do 4o ano de infoweb, do CNAT-IFRN
repositório de código
código final zip

objetivo

criar 1 endpoint para API de upload de arquivo

notas de aula

criar um projeto nestjs e instalar a lib necessária
executar (levantar) a api
configurar a API para documentar com swagger
criar módulo nestjs para upload
programar endpoint para upload de 1 arquivo
Programar o serviço para processar e responder ao endpoint de upload

1. criar um projeto nestjs e instalar a lib necessária

## cria novo projeto nestjs
npx @nestjs/cli --package-manager npm new upload-api

## após criado o projeto, e em tudo terminando ok
## acessa a pasta do projeto nestjs
cd upload-api

## instala a lib em modo desenvolvimento
npm install -D @types/multer

npm install @nestjs/swagger

o resultado deve parecer com o terminal abaixo.

$ npx @nestjs/cli --package-manager npm new upload-api
⚡  We will scaffold your app in a few seconds..

CREATE upload-api/.eslintrc.js (663 bytes)
CREATE upload-api/.prettierrc (51 bytes)
CREATE upload-api/README.md (3340 bytes)
CREATE upload-api/nest-cli.json (171 bytes)
CREATE upload-api/package.json (1955 bytes)
CREATE upload-api/tsconfig.build.json (97 bytes)
CREATE upload-api/tsconfig.json (546 bytes)
CREATE upload-api/src/app.controller.spec.ts (617 bytes)
CREATE upload-api/src/app.controller.ts (274 bytes)
CREATE upload-api/src/app.module.ts (249 bytes)
CREATE upload-api/src/app.service.ts (142 bytes)
CREATE upload-api/src/main.ts (208 bytes)
CREATE upload-api/test/app.e2e-spec.ts (630 bytes)
CREATE upload-api/test/jest-e2e.json (183 bytes)

✔ Installation in progress... ☕

🚀  Successfully created project upload-api
👉  Get started with the following commands:

$ cd upload-api
$ npm run start:dev


                          Thanks for installing Nest 🙏
                 Please consider donating to our open collective
                        to help us maintain this package.


               🍷  Donate: https://opencollective.com/nest

$ cd upload-api

[upload-api]$ npm i -D @types/multer

added 1 package, and audited 687 packages in 2s

106 packages are looking for funding
  run `npm fund` for details

found 0 vulnerabilities

[upload-api]$

2. executar (levantar) a api

levantar a api em modo de desenvolvimento para que no momento que houver mudança nos códigos-fonte, a API ser re-lançada.

executar a ferramenta npm com o comando run para executar o script start:dev.

[upload-api]$ npm run start:dev

resultado do comando acima deve ser algo parecido com o terminal abaixo.

[15:31:39] Starting compilation in watch mode...

[15:31:41] Found 0 errors. Watching for file changes.

[Nest] 620648  - 07/09/2024, 15:31:41     LOG [NestFactory] Starting Nest application...
[Nest] 620648  - 07/09/2024, 15:31:41     LOG [InstanceLoader] AppModule dependencies initialized +13ms
[Nest] 620648  - 07/09/2024, 15:31:41     LOG [RoutesResolver] AppController {/}: +5ms
[Nest] 620648  - 07/09/2024, 15:31:41     LOG [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 620648  - 07/09/2024, 15:31:41     LOG [NestApplication] Nest application successfully started +2ms

3. configurar a API para documentar com swagger

editar o arquivo /src/main.ts para colocar a configuração do swagger.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
++import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

++  const config = new DocumentBuilder()
++    .setTitle('Infoweb - Upload API')
++    .setDescription('API exemplo de upload de arquivos')
++    .setVersion('1.0')
++    .build();
++  const document = SwaggerModule.createDocument(app, config);
++  SwaggerModule.setup('docs', app, document);

  await app.listen(3000);
}
bootstrap();

DocumentBuilder é responsável por configurar a documentação da API.
SwaggerModule.createDocument é responsável por construir a documentação.
SwaggerModule.setup cria um endpoint no app e vincula a documentação da API.

4. criar módulo nestjs para upload

abrir um 2o terminal, e executar o @nestjs/cli com o comando generate resource, podendo abreviar g res.

[upload-api]$ npx @nestjs/cli generate resource upload --no-spec

o resultado do comando deverá parecer com o terminal abaixo.

[upload-api]$ npx @nestjs/cli generate resource upload --no-spec
? What transport layer do you use? REST API
? Would you like to generate CRUD entry points? No
CREATE src/upload.controller.ts (216 bytes)
CREATE src/upload.module.ts (255 bytes)
CREATE src/upload.service.ts (90 bytes)
UPDATE package.json (2020 bytes)
UPDATE src/app.module.ts (309 bytes)
✔ Packages installed successfully.

ao final, o terminal que esta executando a API deve adicionar a rota /upload como [RoutesResolver], ver terminal abaixo como exemplo.

[09:45:33] File change detected. Starting incremental compilation...

[09:45:33] Found 0 errors. Watching for file changes.

[Nest] 14414  - 13/09/2024, 09:45:35     LOG [NestFactory] Starting Nest application...
[Nest] 14414  - 13/09/2024, 09:45:35     LOG [InstanceLoader] AppModule dependencies initialized +12ms
[Nest] 14414  - 13/09/2024, 09:45:35     LOG [InstanceLoader] UploadModule dependencies initialized +1ms
[Nest] 14414  - 13/09/2024, 09:45:35     LOG [RoutesResolver] AppController {/}: +170ms
[Nest] 14414  - 13/09/2024, 09:45:36     LOG [RouterExplorer] Mapped {/, GET} route +20ms
[Nest] 14414  - 13/09/2024, 09:45:36     LOG [RoutesResolver] UploadController {/upload}: +9ms
[Nest] 14414  - 13/09/2024, 09:45:36     LOG [NestApplication] Nest application successfully started +32ms

5. programar endpoint para upload de 1 arquivo

para fazer o upload de um único arquivo no endpoint de uma API usando nestjs, preciso vincular o interceptor FileInterceptor() ao endpoint e extrair esse arquivo da requisição usando o decorador @UploadedFile().

editar o arquivo src/uplaod/upload.controller.ts para inserir os códigos abaixo.

++import {
++  Controller,
++  Post,
++  UploadedFile,
++  UseInterceptors,
++} from '@nestjs/common';
import { UploadService } from './upload.service';
++import { FileInterceptor } from '@nestjs/platform-express';
++import {
++  ApiBody,
++  ApiConsumes,
++  ApiOperation,
++  ApiResponse,
++  ApiTags,
++} from '@nestjs/swagger';

@Controller('upload')
++@ApiTags('upload')
export class UploadController {
  constructor(private readonly uploadService: UploadService) {}

++  @Post('exemplo-simples')
++  @UseInterceptors(FileInterceptor('arquivo'))
++  @ApiConsumes('multipart/form-data')
++  @ApiBody({
++    schema: {
++      type: 'object',
++      properties: {
++        arquivo: {
++          type: 'string',
++          format: 'binary',
++        },
++      },
++    },
++  })
++  @ApiOperation({ summary: 'Exemplo de upload de 1 arquivo qualquer' })
++  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
++  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
++  uploadArquivoSimples(@UploadedFile() arq: Express.Multer.File) {
++    console.log(arq);
++
++    return {
++      estado: 'ok',
++    };
++  }
}

os decorators novos são:

swagger
- @ApiTags cria uma divisão na documentação da API organizada pela string passada como parâmetro.
- @ApiConsumes
- @ApiBody configura o que capturar do corpo da mensagem de requisição
- @ApiOperation configura como será descrito o endpoint na documentação
- @ApiResponse configura as respostas na documentação
nestjs
- @UseInterceptors usa um interceptors que tem a função de interceptar as requisições antes que ela chegue na função que trata o endpoint.
- @UploadedFile trabalha em conjunto com interceptor para extração do arquivo da mensagem de requisição.

FileInterceptor é um interceptor padrão do nestjs para extrair um arquivo da mensagem de requisição. Este interceptor trabalha junto do decorator @UploadedFile. É definido aqui o nome do campo do formulário que referencia o arquivo.

o console onde executa a API deve parecer como o terminal abaixo.

[10:14:23] File change detected. Starting incremental compilation...

[10:14:23] Found 0 errors. Watching for file changes.

[Nest] 23723  - 13/09/2024, 10:14:23     LOG [NestFactory] Starting Nest application...
[Nest] 23723  - 13/09/2024, 10:14:23     LOG [InstanceLoader] AppModule dependencies initialized +11ms
[Nest] 23723  - 13/09/2024, 10:14:23     LOG [InstanceLoader] UploadModule dependencies initialized +0ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [RoutesResolver] AppController {/}: +13ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [RouterExplorer] Mapped {/, GET} route +3ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [NestApplication] Nest application successfully started +1ms

para testar o endpoint, acessar o link http://localhost:3000/docs, ir em /upload/exemplo-simples, clicar no botão try it out, escolher um arquivo e executar a requisição.

após a execução do teste, o terminal ...

[10:14:23] File change detected. Starting incremental compilation...

[10:14:23] Found 0 errors. Watching for file changes.

[Nest] 23723  - 13/09/2024, 10:14:23     LOG [NestFactory] Starting Nest application...
[Nest] 23723  - 13/09/2024, 10:14:23     LOG [InstanceLoader] AppModule dependencies initialized +11ms
[Nest] 23723  - 13/09/2024, 10:14:23     LOG [InstanceLoader] UploadModule dependencies initialized +0ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [RoutesResolver] AppController {/}: +13ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [RouterExplorer] Mapped {/, GET} route +3ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [RoutesResolver] UploadController {/upload}: +0ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [RouterExplorer] Mapped {/upload/exemplo-simples, POST} route +1ms
[Nest] 23723  - 13/09/2024, 10:14:24     LOG [NestApplication] Nest application successfully started +1ms
{
  fieldname: 'arquivo',
  originalname: 'README.md',
  encoding: '7bit',
  mimetype: 'text/markdown',
  buffer: <Buffer 23 20 4e 65 73 74 4a 53 20 2d 20 55 70 6c 6f 61 64 20 64 65 20 61 72 71 75 69 76 6f 73 0a 0a 0a 23 23 20 49 6e 66 6f 72 6d 61 c3 a7 c3 b5 65 73 20 67 ... 958 more bytes>,
  size: 1008
}

6. Programar o serviço para processar e responder ao endpoint de upload

editar o arquivo src/uplaod/upload.service.ts para inserir os códigos abaixo.

import { Injectable } from '@nestjs/common';

@Injectable()
export class UploadService {
  responderInformacaoArquivo(arquivo: Express.Multer.File) {
    return {
      estado: 'ok',
      dados: {
        nome: arquivo.originalname,
        tamanho: arquivo.size,
        mimetype: arquivo.mimetype,
        encode: arquivo.encoding,
      },
    };
  }
}

também deve modificar o arquivo src/uplaod/upload.controller.ts para inserir os códigos abaixo.

import {
  Controller,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { UploadService } from './upload.service';
import { FileInterceptor } from '@nestjs/platform-express';
import {
  ApiBody,
  ApiConsumes,
  ApiOperation,
  ApiResponse,
  ApiTags,
} from '@nestjs/swagger';

@Controller('upload')
@ApiTags('upload')
export class UploadController {
  constructor(private readonly uploadService: UploadService) {}

  @Post('exemplo-simples')
  @UseInterceptors(FileInterceptor('arquivo'))
  @ApiConsumes('multipart/form-data')
  @ApiBody({
    schema: {
      type: 'object',
      properties: {
        arquivo: {
          type: 'string',
          format: 'binary',
        },
      },
    },
  })
  @ApiOperation({ summary: 'Exemplo de upload de 1 arquivo qualquer' })
  @ApiResponse({ status: 201, description: 'Arquivo enviado com sucesso.' })
  @ApiResponse({ status: 400, description: 'Erro no envio do arquivo.' })
  uploadArquivoSimples(@UploadedFile() arq: Express.Multer.File) {
    console.log(arq);

--    return {
--      estado: 'ok',
--    };
++    return this.uploadService.responderInformacaoArquivo(arq);
  }
}

novamente para testar o endpoint, acessar o link http://localhost:3000/docs, ir em /upload/exemplo-simples, clicar no botão try it out, escolher um arquivo e executar a requisição.
perceba a mudança com a resposta da requisição que deverá parecer com algo como o json abaixo.

{
  "estado": "ok",
  "dados": {
    "nome": "README.md",
    "tamanho": 1008,
    "mimetype": "text/markdown",
    "encode": "7bit"
  }
}

Referência e link

notas de aula baseado nos tutoriais/documentações nestjs
- File upload
- OpenAPI - Introduction