Relaciones en NestJS

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

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

  @ApiProperty({ example: 'Booket' }) (3)
  @Column()
  name: string;
}

import { Module } from '@nestjs/common';
import { PublishersService } from './publishers.service';
import { PublishersController } from './publishers.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Publisher } from './entities/publisher.entity';
import { AuthModule } from '../utilities/auth.module';

@Module({
  imports: [TypeOrmModule.forFeature([Publisher]), AuthModule], (1)
  controllers: [PublishersController],
  providers: [PublishersService],
})
export class PublishersModule {}

$ npm run start:dev

import { ApiProperty } from '@nestjs/swagger';
export class CreatePublisherDto {
  @ApiProperty({ example: 'Booket' })
  readonly name: string;
}

import { Injectable } from '@nestjs/common';
import { CreatePublisherDto } from './dto/create-publisher.dto';
import { UpdatePublisherDto } from './dto/update-publisher.dto';
import { InjectRepository } from '@nestjs/typeorm';
import { Publisher } from './entities/publisher.entity';
import { Repository } from 'typeorm';

@Injectable()
export class PublishersService {

  constructor( (1)
    @InjectRepository(Publisher)
    private publishersRepository: Repository<Publisher>,
  ) {}

  create(createPublisherDto: CreatePublisherDto): Promise<Publisher> {
    return this.publishersRepository.save(createPublisherDto);
  }

  async findAll(): Promise<Publisher[]> {
    return this.publishersRepository.find();
  }

  async findOne(id: number): Promise<Publisher> {
    return this.publishersRepository.findOne({
      where: { id },
    });
  }

  async update(id: number, updatePublisherDto: UpdatePublisherDto) {
    return this.publishersRepository.update(id, updatePublisherDto);
  }

  async remove(id: number) {
    return this.publishersRepository.delete({ id });
  }
}

import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  UseGuards,
} from '@nestjs/common';
import { PublishersService } from './publishers.service';
import { CreatePublisherDto } from './dto/create-publisher.dto';
import { UpdatePublisherDto } from './dto/update-publisher.dto';
import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
import { AuthGuard } from '@nestjs/passport';

@Controller('publishers')
@ApiTags('publisher') (1)
@UseGuards(AuthGuard('jwt')) (2)
@ApiBearerAuth('access-token') (3)

export class PublishersController {
  constructor(private readonly publishersService: PublishersService) {}

  @Post()
  create(@Body() createPublisherDto: CreatePublisherDto) {
    return this.publishersService.create(createPublisherDto);
  }

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

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

  @Patch(':id')
  update(
    @Param('id') id: string,
    @Body() updatePublisherDto: UpdatePublisherDto,
  ) {
    return this.publishersService.update(+id, updatePublisherDto);
  }

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

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

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

  @ApiProperty({ example: 'Don Quijote de la Mancha' })
  @Column() (3)
  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: 592 })
  @Column()
  pages: number;

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

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

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

import { ApiProperty } from '@nestjs/swagger';

export class CreateBookDto {
  @ApiProperty({ example: 'Don Quijote de la Mancha' })
  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: 592 })
  readonly pages: number;

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

import { Injectable } from '@nestjs/common';
import { CreateBookDto } from './dto/create-book.dto';
import { UpdateBookDto } from './dto/update-book.dto';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Book } from './entities/book.entity';

@Injectable()
export class BooksService {
  constructor( (1)
    @InjectRepository(Book) private booksRepository: Repository<Book>,
  ) {}

  async create(createBookDto: CreateBookDto): Promise<Book> {
    return this.booksRepository.save(createBookDto);
  }

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

  async findOne(id: number): Promise<Book> {
    return this.booksRepository.findOne({
      where: { id },
    });
  }

  async update(id: number, updateBookDto: UpdateBookDto): Promise<Book> {
    let toUpdate = await this.booksRepository.findOne({
      where: { id },
    });

    let updated = Object.assign(toUpdate, updateBookDto);

    return this.booksRepository.save(updated);
  }

  async remove(id: number): Promise<any> {
    return this.booksRepository.delete({ id });
  }
}

import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  UseGuards,
} from '@nestjs/common';
import { BooksService } from './books.service';
import { CreateBookDto } from './dto/create-book.dto';
import { UpdateBookDto } from './dto/update-book.dto';
import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
import { AuthGuard } from '@nestjs/passport';

@Controller('books')
@ApiTags('book') (1)
@UseGuards(AuthGuard('jwt')) (2)
@ApiBearerAuth('access-token') (3)

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

  @Post()
  create(@Body() createBookDto: CreateBookDto) {
    return this.booksService.create(createBookDto);
  }

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

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

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateBookDto: UpdateBookDto) {
    return this.booksService.update(+id, updateBookDto);
  }

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

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

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

  @ApiProperty({ example: 'Genial!!' })
  @Column()
  title: string; (3)

  @ApiProperty({ example: 5 })
  @Column()
  stars: number;

  @ApiProperty({
    example:
      'Compré el libro por los comentarios tan buenos que tenía. El libro comentá la historia de España de manera muy general y desde un punto de vista súper simplista. Resumiendo temas de compleja explicación en tan solo una frase. ',
  })
  @Column('text')
  comment: string;

  @ApiProperty({ example: 'johndoe' })
  @Column()
  username: string;
}

import { Module } from '@nestjs/common';
import { CommentsService } from './comments.service';
import { CommentsController } from './comments.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from '../utilities/auth.module';
import { Comment } from './entities/comment.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Comment]), AuthModule], (1)
  controllers: [CommentsController],
  providers: [CommentsService],
})
export class CommentsModule {}

import { ApiProperty } from '@nestjs/swagger';
export class CreateCommentDto {
  @ApiProperty({ example: 'Genial!!' })
  readonly title: string;

  @ApiProperty({ example: 5 })
  readonly stars: number;

  @ApiProperty({
    example:
      'Compré el libro por los comentarios tan buenos que tenía. El libro comentá la historia de España de manera muy general y desde un punto de vista súper simplista. Resumiendo temas de compleja explicación en tan solo una frase. ',
  })
  readonly comment: string;

  @ApiProperty({ example: 'johndoe' })
  readonly username: string;
}

import { Injectable } from '@nestjs/common';
import { CreateCommentDto } from './dto/create-comment.dto';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { UpdateCommentDto } from './dto/update-comment.dto';
import { Comment } from './entities/comment.entity';

@Injectable()
export class CommentsService {
  constructor( (1)
    @InjectRepository(Comment)
    private commentsRepository: Repository<Comment>,
  ) {}

  create(createCommentDto: CreateCommentDto): Promise<Comment> {
    return this.commentsRepository.save(createCommentDto);
  }

  async findAll(): Promise<Comment[]> {
    return this.commentsRepository.find();
  }

  async findOne(id: number): Promise<Comment> {
    return this.commentsRepository.findOne({
      where: { id },
    });
  }

  async update(id: number, updateCommentDto: UpdateCommentDto) {
    return this.commentsRepository.update(id, updateCommentDto);
  }

  async remove(id: number) {
    return this.commentsRepository.delete({ id });
  }
}

import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  UseGuards,
} from '@nestjs/common';
import { CommentsService } from './comments.service';
import { CreateCommentDto } from './dto/create-comment.dto';
import { UpdateCommentDto } from './dto/update-comment.dto';
import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
import { AuthGuard } from '@nestjs/passport';

@Controller('comments')
@ApiTags('comment') (1)
@UseGuards(AuthGuard('jwt')) (2)
@ApiBearerAuth('access-token') (3)

export class CommentsController {
  constructor(private readonly commentsService: CommentsService) {}

  @Post()
  create(@Body() createCommentDto: CreateCommentDto) {
    return this.commentsService.create(createCommentDto);
  }

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

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

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateCommentDto: UpdateCommentDto) {
    return this.commentsService.update(+id, updateCommentDto);
  }

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

{
  "title": "Le falló el final",
  "stars": 4,
  "comment": "Una aventura magnífica que se quedó un poco corta en su final",
  "username": "marysmith"
}

import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
import { ApiProperty } from '@nestjs/swagger';
@Entity()
export class Keyword {
  @ApiProperty({ example: 99 })
  @PrimaryGeneratedColumn()
  id: number;

  @ApiProperty({ example: 'NestJS' })
  @Column()
  keyword: string;
}

import { Module } from '@nestjs/common';
import { KeywordsService } from './keywords.service';
import { KeywordsController } from './keywords.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Keyword } from './entities/keyword.entity';
import { AuthModule } from '../utilities/auth.module';

@Module({
  imports: [TypeOrmModule.forFeature([Keyword]), AuthModule], (1)
  controllers: [KeywordsController],
  providers: [KeywordsService],
})
export class KeywordsModule {}

import { ApiProperty } from '@nestjs/swagger';
export class CreateKeywordDto {
  @ApiProperty({ example: 'NestJS' })
  readonly keyword: string;
}

import { Injectable } from '@nestjs/common';
import { CreateKeywordDto } from './dto/create-keyword.dto';
import { UpdateKeywordDto } from './dto/update-keyword.dto';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Keyword } from './entities/keyword.entity';

@Injectable()
export class KeywordsService {
  constructor( (1)
    @InjectRepository(Keyword)
    private keywordsRepository: Repository<Keyword>,
  ) {}

  create(createKeywordDto: CreateKeywordDto): Promise<Keyword> {
    return this.keywordsRepository.save(createKeywordDto);
  }

  async findAll(): Promise<Keyword[]> {
    return this.keywordsRepository.find();
  }

  async findOne(id: number): Promise<Keyword> {
    return this.keywordsRepository.findOne({
      where: { id },
    });
  }

  findBooks(id: number): Promise<Keyword> {
    return this.keywordsRepository.findOne({
      where: { id },
    });
  }

  async update(id: number, updateKeywordDto: UpdateKeywordDto) {
    return this.keywordsRepository.update(id, updateKeywordDto);
  }

  async remove(id: number) {
    return this.keywordsRepository.delete({ id });
  }
}

import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  UseGuards,
} from '@nestjs/common';
import { KeywordsService } from './keywords.service';
import { CreateKeywordDto } from './dto/create-keyword.dto';
import { UpdateKeywordDto } from './dto/update-keyword.dto';
import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
import { AuthGuard } from '@nestjs/passport';

@Controller('keywords')
@ApiTags('keyword') (1)
@UseGuards(AuthGuard('jwt')) (2)
@ApiBearerAuth('access-token') (3)

export class KeywordsController {
  constructor(private readonly keywordsService: KeywordsService) {}

  @Post()
  create(@Body() createKeywordDto: CreateKeywordDto) {
    return this.keywordsService.create(createKeywordDto);
  }

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

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

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateKeywordDto: UpdateKeywordDto) {
    return this.keywordsService.update(+id, updateKeywordDto);
  }

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