NESTJS 7による単純な例カスタムリポジトリ.X/8 .xとtypem😻

この記事では、NestJSにカスタムリポジトリの簡単な例を示します😻 となっている.
TypeORMと不慣れな、または知らない人のために、それはノードです.JS TypeScriptフレームワークは、効率的でスケーラブルなエンタープライズグレードのノードを構築するのに役立ちます.JSアプリケーション.
では、nestjsアプリを作成することから始めましょう
NESTJS用のオープンターミナルとCLIをインストールします.既にインストールされている場合は、この手順をスキップします.

$ npm i -g @nestjs/cli

NestJS
次に、NeSTJSプロジェクトを作成します

$ nest new app
$ cd app
// start the application
$ npm run start: dev

Hello Worldが表示されることを確認するためにlocalhost:3000にブラウザを開きます.
それから、我々はDocker構成をつくります.サービスを作成するファイル
MySQL

version: "3"

services:
   mysql:
     image: mysql:5
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: root
       MYSQL_DATABASE: nest
     ports:
       - "3306:3306"

Dockerが何であるかわからない人のために、私はより詳細に のためにここで関連を残します.
前の記事で述べたように、巣をデータベースに統合する方法はいろいろありますが、それらはすべて個人的な好みやプロジェクトの必要性に依存します.
Docker
MySQLの依存関係をインストールする

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

モジュールでモジュールを設定する

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module ({
   imports: [
     TypeOrmModule.forRoot(),
   ],
})
export class AppModule {}

ormconfigを作成します.プロジェクトのルートディレクトリにあるJSONファイル.

{
  "type": "mysql",
  "host": "localhost",
  "port": 3306,
  "username": "root",
  "password": "root",
  "database": "nest",
  "entities": ["dist/**/*.entity{.ts,.js}"],
  "synchronize": true,
  "autoLoadEntities": true
}

ここでtypeRemmoduleを設定するのが面倒であるなら、Dockerがdocker compose upで動いていることを確認してください.
また、TypeOrmModule.forRootの中のデータベース名があなたのDocker構成ファイルにあるものと一致することを確認してください.
さて、私たちがproducts.entity.tsと呼ぶ実体を作りましょう.

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

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

     @Column()
     name: string;

     @Column()
     description: string;

     @Column()
     price: string;
}

データ転送オブジェクト( DTO )クラスを作成して、製品を作成します.

import { MaxLength, IsNotEmpty, IsString } from 'class-validator';

export class CreateProductDto {
    @IsString()
    @IsNotEmpty()
    @MaxLength(20)
    name: string;

    @IsString()
    @IsNotEmpty()
    @MaxLength(100)
    description: string;

    @IsString()
    @IsNotEmpty()
    price: string;
}

アップグレードのためにDTOクラスを作成する前にこのパッケージをインストールしてください.

$ npm i @nestjs/mapped-types

さて、顧客データを更新するにはcreateProductdtoクラスを拡張します.

import { PartialType } from '@nestjs/mapped-types';
import { CreateProductDto } from './create-product.dto';

export class UpdateProductDto extends PartialType(CreateProductDto) {}

検証パイプをメインと呼びます.TSファイルは次のようになります.

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      transform: true,
      forbidNonWhitelisted: true,
      transformOptions: {
        enableImplicitConversion: true,
      },
    }),
  );
  await app.listen(3000);
}
bootstrap();

さて、今私たちはシンプルなサービス、コントローラ、および製品モジュールを作成するつもりです

$ nest g module products
$ nest g service products
$ nest g controller products

これで、productmodule、productsservice、およびproductsControlを使用したカスタマーフォルダーがあります.
今すぐ製品を作成しましょう.リポジトリ.TSファイルは、このようにtypeRMベースリポジトリを拡張するカスタムリポジトリを作成します.

import { Repository, EntityRepository } from 'typeorm';
import { Products } from './products.entity';

@EntityRepository(Products)
export class ProductsRepository extends Repository<Products> {}

私たちのproductsmoduleファイルは次のようになります.

import { Module } from '@nestjs/common';
import { ProductsController } from './products.controller';
import { ProductsService } from './products.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ProductsRepository } from './products.repository';

@Module({
  imports: [TypeOrmModule.forFeature([ProductsRepository])],
  controllers: [ProductsController],
  providers: [ProductsService],
})

export class ProductsModule {}

プロダクションサービス:

import { HttpException, HttpStatus, Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Products } from './entities/products.entity';
import { CreateProductDto } from './dto/create-product.dto';
import { UpdateProductDto } from './dto/update-product.dto';
import { ProductsRepository } from './repositories/products.repository';

@Injectable()
export class ProductsService {
    constructor(
        @InjectRepository(ProductsRepository)
        private productsRepository: ProductsRepository,
    ) {}

    public async findAll(): Promise<Products[]> {
        return await this.productsRepository.findAll();
    }

    public async findOne(productId: number): Promise<Products> {
        const product = await this.productsRepository.findById(productId);
        if (!product) {
            throw new NotFoundException(`Product #${productId} not found`);
        }
        return product;
    }

    public async create(
        createProductDto: CreateProductDto,
    ): Promise<Products> {
        try {
          return await this.productsRepository.createProduct(createProductDto);
        } catch (err) {
          throw new HttpException(err, HttpStatus.BAD_REQUEST);
        }
    }

    public async update(
        productId: number,
        updateProductDto: UpdateProductDto,
    ): Promise<Products> {
        const product = await this.productsRepository.findOne(productId);
        if (!product) {
            throw new NotFoundException(`Product #${productId} not found`);
        }
        return this.productsRepository.editProduct(productId, updateProductDto);
    }

    public async remove(productId: number): Promise<void> {
        await this.productsRepository.delete(productId);
    }
}

次のようにカスタムリポジトリを編集しましょう.

import { Repository, EntityRepository } from 'typeorm';
import { Products } from '../entities/products.entity';
import { CreateProductDto } from '../dto/create-product.dto';
import { UpdateProductDto } from '../dto/update-product.dto';
import { Injectable } from '@nestjs/common';

@EntityRepository(Products)
export class ProductsRepository extends Repository<Products> {

    public async findAll(): Promise<Products[]> {
        return await this.find({});
    } 

    public async findById(productId: number): Promise<Products> {
        return await this.findOne(productId);
    }

    public async createProduct(
        createProductDto: CreateProductDto,
    ): Promise<Products> {
        const { name, description, price } = createProductDto;
        const product = new Products();
        product.name = name;
        product.description = description;
        product.price = price;

        await this.save(product);
        return product;
    }

    public async editProduct(
        productId: number,
        updateProductDto: UpdateProductDto,
    ): Promise<Products> {
        const { name, description, price } = updateProductDto;
        const product = await this.findOne(productId);
        product.name = name;
        product.description = description;
        product.price = price;
        await this.save(product);

        return product;
    }

    public async destroy(productId: number): Promise<void> {
        const product = await this.findOne(productId);
        await this.remove(product);
    } 
}

ProductsController:

import {
    Controller,
    Post,
    Body,
    Get,
    Patch,
    Param,
    Delete,
} from '@nestjs/common';
import { ProductsService } from './products.service';
import { CreateProductDto } from './dto/create-product.dto';
import { UpdateProductDto } from './dto/update-product.dto';
import { Products } from './entities/products.entity';

@Controller('/api/products')
export class ProductsController {
    constructor(private productsService: ProductsService) { }

    @Get()
    public async findAll(): Promise<Products[]> {
        return await this.productsService.findAll();
    }

    @Get('/:productId')
    public async findOne(@Param('productId') productId: number): Promise<Products> {
        return await this.productsService.findOne(productId);
    }

    @Post()
    public async create(
        @Body() createProductsDto: CreateProductDto,
    ): Promise<Products> {
        return await this.productsService.create(createProductsDto);
    }

    @Patch('/:productId')
    public async update(
        @Body() updateProductDto: UpdateProductDto,
        @Param('productId') productId: number,
    ): Promise<Products> {
        const product = await this.productsService.update(
            productId,
            updateProductDto,
        );
        return product;
    }

    @Delete('/:productId')
    public async delete(@Param('productId') productId: number): Promise<void> {
        const product = await this.findOne(productId);
        if (!product) {
            throw new NotFoundException(`Product #${product} not found`);
        }

        return await this.productsService.remove(productId);
    }
}

カール製品との出会い

    $ curl -H 'content-type: application/json' -v -X GET http://127.0.0.1:3000/api/products  
    $ curl -H 'content-type: application/json' -v -X GET http://127.0.0.1:3000/api/products/:id 
    $ curl -H 'content-type: application/json' -v -X POST -d '{"name": "Product #1","description": "Lorem ipsum", "price": "19.99"}' http://127.0.0.1:3000/api/products 
    $ curl -H 'content-type: application/json' -v -X PUT -d '{"name": "Product #1","description": "Lorem ipsum", "price": "19.99"}' http://127.0.0.1:3000/api/products/:id 
    $ curl -H 'content-type: application/json' -v -X DELETE http://127.0.0.1:3000/api/products/:id 

私は、それがNESTJSであなたのアプリケーションを構築する際に役に立つことを望みます😻
それで😀
何かのためにコメントで私を書く😉