Introducción a NestJS

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

@Injectable() (1)
export class AppService {
  getHello(): string { (2)
    return 'Hello World!';
  }
}

import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service'; (1)

@Controller() (2)
export class AppController {
  constructor(private readonly appService: AppService) {} (3)

  @Get() (4)
  getHello(): string { (5)
    return this.appService.getHello(); (6)
  }
}

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.setGlobalPrefix('api/v1'); (1)
  await app.listen(3000);
}
bootstrap();

http://localhost:3000/api/v1

{
  "statusCode": 404,
  "message": "Cannot GET /",
  "error": "Not Found"
}

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

@Injectable()
export class BooksService {
  findAll(): any { (1)
    return 'findAll funcionando';
  }
}

import { Controller, Get } from '@nestjs/common';
import { BooksService } from './books.service'; (1)

@Controller('books')
export class BooksController {
  constructor(private booksService: BooksService) {} (2)

  @Get() (3)
  findAll() { (4)
    return this.booksService.findAll(); (5)
  }
}

{
    "title": "El enigma de la habitación 622",
    "genre": "Ficción contemporánea",
    "description": "Vuelve el «principito de la literatura negra contemporánea, el niño mimado de la industria literaria» (GQ): el nuevo thriller de Joël Dicker es su novela más personal. ",
    "author": "Joël Dicker",
    "publisher": "Alfaguara",
    "pages": 624,
    "image_url": "https://images-na.ssl-images-amazon.com/images/I/41KiZbwOhhL._SX315_BO1,204,203,200_.jpg"
}

export class Book {
  id: number;
  title: string;
  genre: string;
  description: string;
  author: string;
  publisher: string;
  pages: number;
  image_url: string;
}

export class BookDto {
  readonly title: string;
  readonly genre: string;
  readonly description: string;
  readonly author: string;
  readonly publisher: string;
  readonly pages: number;
  readonly image_url: string;
}

...
import { BookDto } from './book.dto'; (1)

@Controller('books')
export class BooksController {
...

  @Post()
  createBook(@Body() newBook: BookDto) { (2)
    return this.booksService.createBook(newBook); (3)
  }

....

  @Put(':bookId')
  updateBook(@Param('bookId') bookId: string, @Body() newBook: BookDto) { (4)
    return this.booksService.updateBook(bookId, newBook); (5)
  }
}

...
import { BookDto } from './book.dto'; (1)

@Injectable()
export class BooksService {
...
  createBook(newBook: BookDto) { (2)
    return newBook;
  }

...

  updateBook(bookId: string, newBook: BookDto) { (3)
    return newBook;
  }
}

import { Injectable, HttpStatus, HttpException } from '@nestjs/common';
import { BookDto } from './book.dto'; (1)
import { Book } from './book.class'; (2)

@Injectable()
export class BooksService {
  books: Book[] = [ (3)
    {
      id: 1,
      title: 'Una historia de España',
      genre: 'Historia',
      description:
        'Un relato ameno, personal, a ratos irónico, pero siempre único, de nuestra accidentada historia a través de los siglos. Una obra concebida por el autor para, en palabras suyas, «divertirme, releer y disfrutar; un pretexto para mirar atrás desde los tiempos remotos hasta el presente, reflexionar un poco sobre ello y contarlo por escrito de una manera poco ortodoxa.',
      author: 'Arturo Pérez-Reverte',
      publisher: 'Alfaguara',
      pages: 256,
      image_url:
        'https://images-na.ssl-images-amazon.com/images/I/41%2B-e981m1L._SX311_BO1,204,203,200_.jpg',
    },
    {
      id: 2,
      title: 'Historia de España contada para escépticos',
      genre: 'Historia',
      description:
        'Como escribe el autor, no pretende ser veraz, justa y desapasionada, porque ninguna historia lo es. No está hecha para halagar a reyes y gobernantes, ni pretende halagar a los banqueros, ni a la Conferencia Episcopal, ni al colectivo gay.',
      author: 'Juan Eslava Galán',
      publisher: 'Booket',
      pages: 592,
      image_url:
        'https://images-na.ssl-images-amazon.com/images/I/51IyZ5Mq8YL._SX326_BO1,204,203,200_.jpg',
    },
  ];
  findAll(params): Book[] { (4)
    return this.books;
  }

  findBook(bookId: string): Book { (5)
    return this.books[parseInt(bookId) - 1];
  }

  createBook(newBook: BookDto): Book { (6)
    let book = new Book();

    book.id = 99;
    book.author = newBook.author;
    book.description = newBook.description;
    book.genre = newBook.genre;
    book.image_url = newBook.image_url;
    book.pages = newBook.pages;
    book.publisher = newBook.publisher;
    book.title = newBook.title;

    return book;
  }

  deleteBook(bookId: string): Book { (7)
    return this.books[parseInt(bookId) - 1];
  }

  updateBook(bookId: string, newBook: BookDto): Book { (8)
    return this.books[parseInt(bookId) - 1];
  }
}

import {
  Controller,
  Get,
  Param,
  Req,
  Post,
  Body,
  Delete,
  Put,
} from '@nestjs/common';
import { BooksService } from './books.service';
import { Request } from 'express';
import { BookDto } from './book.dto';
import { Book } from './book.class';

export class BooksController {
  constructor(private booksService: BooksService) {}

  findAll(@Req() request: Request): Book[] {
    console.log(request.query);
    return this.booksService.findAll(request.query);
  }

  findBook(@Param('bookId') bookId: string): Book {
    return this.booksService.findBook(bookId);
  }

  createBook(@Body() newBook: BookDto): Book {
    return this.booksService.createBook(newBook);
  }

  deleteBook(@Param('bookId') bookId: string): Book {
    return this.booksService.deleteBook(bookId);
  }

  updateBook(@Param('bookId') bookId: string, @Body() newBook: BookDto): Book {
    return this.booksService.updateBook(bookId, newBook);
  }
}

$ docker run --name tutorial_mysql -e MYSQL_ROOT_PASSWORD=secret -p 3306:3306 -d mysql:5.7 (1)

$ docker exec -it tutorial_mysql bash
root@d0512407a21d:/# mysql -u root -p
Enter password: (1)
...
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>
mysql> create database tutorial; (2)
Query OK, 1 row affected (0.00 sec)

$ npm install --save @nestjs/typeorm typeorm mysql

import { TypeOrmModule } from '@nestjs/typeorm';
...
@Module({
  imports: [
    TypeOrmModule.forRoot(), (1)
    ...
  ],
  ....
})
export class AppModule {}

{
  "type": "mysql",
  "host": "localhost",
  "port": 3306,
  "username": "root",
  "password": "secret",
  "database": "tutorial",
  "entities": ["dist/**/*.entity.js"], (1)
  "synchronize": true (2)
}

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Book {
  @PrimaryGeneratedColumn() (1)
  id: number;

  @Column()
  title: string;

  @Column()
  genre: string;

  @Column('text') (2)
  description: string;

  @Column()
  author: string;

  @Column()
  publisher: string;

  @Column()
  pages: number;

  @Column()
  image_url: string;
}

import { Injectable, HttpStatus, HttpException } from '@nestjs/common';
import { BookDto } from './book.dto'; (1)
import { Book } from './book.entity'; (2)
import { InjectRepository } from '@nestjs/typeorm'; (3)
import { Repository } from 'typeorm'; (4)

@Injectable()
export class BooksService {

  constructor(
    @InjectRepository(Book) private booksRepository: Repository<Book>, (5)
  ) {}

  async findAll(params): Promise<Book[]> { (6)
    return await this.booksRepository.find(); (7)
  }

  async findBook(bookId: string): Promise<Book> {
    return await this.booksRepository.findOne({ where: { id: bookId } }); (8)
  }

  createBook(newBook: BookDto): Promise<Book> {
    return this.booksRepository.save(newBook);
  }

  async deleteBook(bookId: string): Promise<any> {
    return await this.booksRepository.delete({ id: parseInt(bookId) });
  }

  async updateBook(bookId: string, newBook: BookDto): Promise<Book> { (9)
    let toUpdate = await this.booksRepository.findOne(bookId); (10)

    let updated = Object.assign(toUpdate, newBook); (11)

    return this.booksRepository.save(updated); (12)
  }
}

import {
  Controller,
  Get,
  Param,
  Req,
  Post,
  Body,
  Delete,
  Put,
} from '@nestjs/common';
import { BooksService } from './books.service';
import { Request } from 'express';
import { BookDto } from './book.dto';
import { Book } from './book.entity'; (1)

@Controller('books')
export class BooksController {

  constructor(private booksService: BooksService) {}

  @Get()
  findAll(@Req() request: Request): Promise<Book[]> { (2)
    console.log(request.query);
    return this.booksService.findAll(request.query);
  }

  @Get(':bookId')
  findBook(@Param('bookId') bookId: string): Promise<Book> {
    return this.booksService.findBook(bookId);
  }

  @Post()
  createBook(@Body() newBook: BookDto): Promise<Book> { (3)
    return this.booksService.createBook(newBook);
  }

  @Delete(':bookId')
  deleteBook(@Param('bookId') bookId: string): Promise<Book> {
    return this.booksService.deleteBook(bookId);
  }


  @Put(':bookId')
  updateBook(
    @Param('bookId') bookId: string,
    @Body() newBook: BookDto, (4)
  ): Promise<Book> {
    return this.booksService.updateBook(bookId, newBook);
  }
}

import { Module } from '@nestjs/common';
import { Book } from './book.entity';
import { BooksService } from './books.service';
import { BooksController } from './books.controller';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [TypeOrmModule.forFeature([Book])], (1)
  providers: [BooksService], (2)
  controllers: [BooksController], (3)
})
export class BooksModule {}

import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { HttpException, HttpStatus, Injectable } from '@nestjs/common';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) { (1)
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(), (2)
      secretOrKey: 'secret', (3)
    });
  }

  async validate(payload: any): Promise<any> { (4)
    if (!payload) {
      throw new HttpException('Invalid token', HttpStatus.UNAUTHORIZED);
    }
    return payload;
  }
}

import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { JwtStrategy } from './jwt.strategy';
@Module({
  imports: [
    PassportModule.register({ (1)
      defaultStrategy: 'jwt', (2)
      property: 'user', (3)
      session: false,
    }),
  ],
  controllers: [],
  providers: [JwtStrategy], (4)
  exports: [PassportModule], (5)
})
export class AuthModule {}

...
import { AuthModule } from '../utilities/auth.module';

@Module({
  imports: [
    ...
    , AuthModule], (1)
  providers: [...],
  controllers: [...],
})

export class BooksModule {}

import {
  ...
  UseGuards, (1)
} from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport'; (2)
...
@Controller('books')
@UseGuards(AuthGuard('jwt')) (3)
...
export class BooksController {
...
}

import { ApiProperty } from '@nestjs/swagger'; (1)

export class BookDto {
  @ApiProperty({ example: 'Don Quijote de la Mancha' }) (2)
  readonly title: string;

  @ApiProperty({ example: 'Novela' })
  readonly genre: string;

  @ApiProperty({
    example: 'Esta edición del Ingenioso hidalgo don Quijote de la Mancha ...',
  })
  readonly description: string;

  @ApiProperty({ example: 'Miguel de Cervantes' })
  readonly author: string;

  @ApiProperty({ example: 'Santillana' })
  readonly publisher: string;

  @ApiProperty({ example: 592 })
  readonly pages: number;

  @ApiProperty({ example: 'www.imagen.com/quijote.png' })
  readonly image_url: string;
}

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
import { ApiProperty } from '@nestjs/swagger';

@Entity()
export class Book {
  @ApiProperty({ example: 99 })
  @PrimaryGeneratedColumn()
  id: number;

  @ApiProperty({ example: 'Don Quijote de la Mancha' })
  @Column()
  title: string;

  @ApiProperty({ example: 'Novela' })
  @Column()
  genre: string;

  @ApiProperty({
    example: 'Esta edición del Ingenioso hidalgo don Quijote de la Mancha ...',
  })
  @Column('text')
  description: string;

  @ApiProperty({ example: 'Miguel de Cervantes' })
  @Column()
  author: string;

  @ApiProperty({ example: 'Santillana' })
  @Column()
  publisher: string;

  @ApiProperty({ example: 592 })
  @Column()
  pages: number;

  @ApiProperty({ example: 'www.imagen.com/quijote.png' })
  @Column()
  image_url: string;
}

...
import { BookDto } from './book.dto'; (1)
import { Book } from './book.entity'; (2)
import { (3)
  ApiOperation,
  ApiResponse,
  ApiTags,
  ApiBearerAuth,
} from '@nestjs/swagger';
...
@ApiTags('book') (4)
@Controller('books')
@UseGuards(AuthGuard('jwt')) (5)
@ApiBearerAuth('access-token') (6)
export class BooksController {
...
  /** (7)
   *
   * @returns {Book[]} Devuelve una lista de libros
   * @param {Request} request Lista de parámetros para filtrar
   */
  @Get()
  @ApiOperation({ summary: 'Obtener lista de libros' }) (8)
  @ApiResponse({ (9)
    status: 201,
    description: 'Lista de libros',
    type: Book, (10)
  })
  findAll(@Req() request: Request): Promise<Book[]> {
  ...
  }
...
}

$ npm install --save nestjs-redoc@1.3.1

...
import { RedocModule, RedocOptions } from 'nestjs-redoc'; (1)

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

  // Configurar títulos de documnentación
  const options = new DocumentBuilder() (2)
    .setTitle('Sample REST API')
    .setDescription('Sample API REST Description')
    .setVersion('1.0')
    .addBearerAuth(
      { type: 'http', scheme: 'bearer', bearerFormat: 'JWT', in: 'header' },
      'access-token',
    )
    .build();
  const document = SwaggerModule.createDocument(app, options);

  const redocOptions: RedocOptions = { (3)
    favicon: 'https://www.ual.es/favicon.ico',
    title: 'API Reservas',
    logo: {
      url:
        'https://www.ual.es/application/themes/ual/images/logoual25-300px.png',
      backgroundColor: '#0082B7',
    },
    sortPropsAlphabetically: true,
    hideDownloadButton: false,
    hideHostname: false,
    noAutoAuth: false,
  };

  // La ruta en que se sirve la documentación
  //SwaggerModule.setup('docs', app, document); (4)
  await RedocModule.setup('/docs', app, document, redocOptions); (5)

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

npm install --save nest-winston winston

...
import { WinstonModule } from 'nest-winston'; (1)
import * as winston from 'winston';
import * as path from 'path';

@Module({
  imports: [
    ...
    WinstonModule.forRoot({
      level: 'info', (2)
      format: winston.format.combine( (3)
        winston.format.timestamp({
          format: 'YYYY-MM-DD HH:mm:ss',
        }),
        winston.format.errors({ stack: true }),
        winston.format.splat(),
        winston.format.json(),
      ),
      transports: [ (4)
        new winston.transports.File({
          dirname: path.join(__dirname, './../log/debug/'),
          filename: 'debug.log',
          level: 'debug',
        }),
        new winston.transports.File({
          dirname: path.join(__dirname, './../log/error/'),
          filename: 'error.log',
          level: 'error',
        }),
        new winston.transports.File({
          dirname: path.join(__dirname, './../log/info/'),
          filename: 'info.log',
          level: 'info',
        }),
        new winston.transports.Console({ level: 'debug' }),
      ],
    }),
  ],
  controllers: [...],
  providers: [...],
})
export class AppModule {}

import { (1)
    ...
    Inject } from '@nestjs/common';
import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
import { Logger } from 'winston';

@Controller()
export class SomeController {
  constructor(
    ...
    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger, (2)
  ) {
  ...
  }
  ...
}

    this.logger.log({
      level: 'info',
      message: 'Hola',
      service: 'Books',
    });

{"level":"info","message":"Hola","service":"Books","timestamp":"2020-08-05 19:14:08"} (1)

  ...
  @Get()
  ...
  findAll(@Req() request: Request): Promise<Book[]> { (1)
    let startTime = Date.now(); (2)
    let data = this.booksService.findAll(request.query); (3)

    this.writeLog(startTime, request, 200); (4)

    return data; (5)
  }
  ...

...
  writeLog(startTime: any, request: any, statusCode: number) {
    let finishTime = Date.now();
    let elapsedTime = finishTime - startTime;

    this.logger.log({
      level: 'info',
      message: '',
      statusCode: statusCode,
      method: request['method'],
      url: request['url'],
      user: request['user'].username,
      duration: elapsedTime,
    });
  }
  ...

{"level":"info","message":"","statusCode":200,"method":"GET","url":"/api/v1/books/1","user":"mtorres","duration":8,"timestamp":"2020-08-06 13:01:49"}

$ npm install --save @nestjs/terminus

$ nest generate module health
$ nest generate controller health

...
import { HealthModule } from './health/health.module';

@Module({
  imports: [
    ...
    HealthModule, (1)
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

import { Module } from '@nestjs/common';
import { HealthController } from './health.controller';
import { TerminusModule } from '@nestjs/terminus';

@Module({
  imports: [TerminusModule], (1)
  controllers: [HealthController],
})
export class HealthModule {}

import { Controller, Get } from '@nestjs/common';
import {
  HealthCheckService,
  HealthCheck,
} from '@nestjs/terminus';

@Controller('health') (1)
export class HealthController {
  constructor(
    private health: HealthCheckService, (2)
  ) {}

  @Get()
  @HealthCheck() (3)
  check() { (4)
    return this.health.check([]); (5)
  }
}

{
    "status": "ok",
    "info": {},
    "error": {},
    "details": {}
}

import { Controller, Get } from '@nestjs/common';
import { DiskHealthIndicator } from '@nestjs/terminus';
import {
  HealthCheckService,
  HealthCheck,
  TypeOrmHealthIndicator,
  MemoryHealthIndicator,
} from '@nestjs/terminus';

@Controller('health')
export class HealthController {
  constructor( (1)
    private health: HealthCheckService,
    private dbIndicator: TypeOrmHealthIndicator,
    private memoryIndicator: MemoryHealthIndicator,
    private diskHealthIndicator: DiskHealthIndicator,
  ) {}

  @Get()
  @HealthCheck()
  check() {
    return this.health.check([
      () => this.dbIndicator.pingCheck('database'), (2)
      () => this.memoryIndicator.checkHeap('heap', 50 * 1024 * 1024), // process < 50MB (3)
      () => this.memoryIndicator.checkRSS('memory', 150 * 1024 * 1024), // process < 150MB (4)
      () =>
        this.diskHealthIndicator.checkStorage('disk <5> health', {
          thresholdPercent: 0.75,
          path: '/',
        }),
    ]);
  }
}

$ npm install @willsoto/nestjs-prometheus prom-client --save

...
import {
  makeCounterProvider,
  PrometheusModule,
} from '@willsoto/nestjs-prometheus'; (1)

@Module({
  imports: [
    ...
    PrometheusModule.register(), (2)
  ],
  ...
  providers: [
    ...
    makeCounterProvider({(3)
      name: 'books_served',
      help: 'books_help',
    }),
  ],
})
export class BooksModule {}

import { HttpStatus, Injectable } from '@nestjs/common';
import { InjectMetric } from '@willsoto/nestjs-prometheus'; (1)
import { Counter } from 'prom-client'; (2)

@Injectable()
export class BooksService {
  constructor(@InjectMetric('books_served') public counter:  Counter<string>) {} (3)
  findAll(): any {
    this.counter.inc(); (4)
    return {
      status: HttpStatus.OK,
      message: 'findAll funcionando',
    };
  }

  findOne(bookId: string): any {
    return {
      status: HttpStatus.OK,
      message: `findOne funcionando con ${bookId}`,
    };
  }
}

# HELP books_served books_help
# TYPE books_served counter
books_served 1 (1)

# HELP books_served books_help
# TYPE books_served counter
books_served 2 (1)

$ npm install prom-client swagger-stats --save

...
import * as swStats from 'swagger-stats'; (1)
...

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  ...
  app.use(swStats.getMiddleware({})); (2)
  ...
}
bootstrap();
...

$ nest generate resource <nombre-recurso>

? What transport layer do you use? (Use arrow keys)
❯ REST API
  GraphQL (code first)
  GraphQL (schema first)
  Microservice (non-HTTP)
  WebSockets

? Would you like to generate CRUD entry points? (Y/n)

CREATE src/users/users.controller.spec.ts (566 bytes)
CREATE src/users/users.controller.ts (890 bytes)
CREATE src/users/users.module.ts (247 bytes)
CREATE src/users/users.service.spec.ts (453 bytes)
CREATE src/users/users.service.ts (609 bytes)
CREATE src/users/dto/create-user.dto.ts (30 bytes)
CREATE src/users/dto/update-user.dto.ts (169 bytes)
CREATE src/users/entities/user.entity.ts (21 bytes)
UPDATE src/app.module.ts (312 bytes)

import { Controller, Get, Post, Body, Put, Param, Delete } from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }

  @Get()
  findAll() {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(+id);
  }

  @Put(':id')
  update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
    return this.usersService.update(+id, updateUserDto);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.usersService.remove(+id);
  }
}

import { Injectable } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';

@Injectable()
export class UsersService {
  create(createUserDto: CreateUserDto) {
    return 'This action adds a new user';
  }

  findAll() {
    return `This action returns all users`;
  }

  findOne(id: number) {
    return `This action returns a #${id} user`;
  }

  update(id: number, updateUserDto: UpdateUserDto) {
    return `This action updates a #${id} user`;
  }

  remove(id: number) {
    return `This action removes a #${id} user`;
  }
}

$ npx typeorm-model-generator -h localhost -d myDatabase -u myUser -x myPassword -e oracle -o ./reservations -p 1527

import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
import { RstCalendarios } from "./RstCalendarios";

@Index("RST_DIAS_PK", ["yDia"], { unique: true })
@Entity("RST_DIAS") (1)
export class RstDias {
  @Column("varchar2", { name: "T_OBSERVACIONES", nullable: true, length: 100 }) (2)
  tObservaciones: string | null;

  @Column("varchar2", { name: "L_RESERVABLE", nullable: true, length: 1 })
  lReservable: string | null;

  @Column("date", { name: "F_CALENDARIO", nullable: true })
  fCalendario: Date | null;

  @Column("number", { primary: true, name: "Y_DIA" })
  yDia: number;

  @ManyToOne(() => RstCalendarios, (rstCalendarios) => rstCalendarios.rstDias) (3)
  @JoinColumn([{ name: "Y_CALENDARIO", referencedColumnName: "yCalendario" }])
  yCalendario: RstCalendarios;
}