add

package.json

@@ -22,9 +22,17 @@
   "dependencies": {
     "@nestjs/common": "^11.0.1",
     "@nestjs/core": "^11.0.1",
+    "@nestjs/mapped-types": "*",
     "@nestjs/platform-express": "^11.0.1",
+    "@nestjs/typeorm": "^11.0.0",
+    "bcrypt": "^5.1.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "mysql2": "^3.14.0",
+    "pg": "^8.14.1",
     "reflect-metadata": "^0.2.2",
-    "rxjs": "^7.8.1"
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.22"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
@@ -34,6 +42,7 @@
     "@nestjs/testing": "^11.0.1",
     "@swc/cli": "^0.6.0",
     "@swc/core": "^1.10.7",
+    "@types/bcrypt": "^5.0.2",
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.7",
@@ -69,5 +78,12 @@
     ],
     "coverageDirectory": "../coverage",
     "testEnvironment": "node"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "@nestjs/core",
+      "@swc/core",
+      "bcrypt"
+    ]
   }
 }

src/app.controller.ts

-import { Controller, Get } from '@nestjs/common';
-import { AppService } from './app.service';
-
-@Controller()
-export class AppController {
-  constructor(private readonly appService: AppService) {}
-
-  @Get()
-  getHello(): string {
-    return this.appService.getHello();
-  }
-}

src/app.module.ts

 import { Module } from '@nestjs/common';
-import { AppController } from './app.controller';
-import { AppService } from './app.service';
+import { ProductModule } from './product/product.module';
+import { CategoryModule } from './category/category.module';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Product } from './product/entities/product.entity';
+import { Category } from './category/entities/category.entity';
+import { UserModule } from './user/user.module';
+import { User } from './user/entities/user.entity';
 
 @Module({
-  imports: [],
-  controllers: [AppController],
-  providers: [AppService],
+  imports: [
+    TypeOrmModule.forRoot({
+      type: 'postgres',
+      host: 'localhost',
+      port: 5432,
+      username: 'postgres',
+      password: 'root',
+      database: 'test_server',
+      schema: 'public',
+      entities: [Product, Category, User],
+      synchronize: true,
+      logging: true,
+      autoLoadEntities: true,
+    }),
+
+    ProductModule,
+    CategoryModule,
+    UserModule,
+  ],
+  controllers: [],
+  providers: [],
 })
 export class AppModule {}

src/app.service.ts

-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class AppService {
-  getHello(): string {
-    return 'Hello World!';
-  }
-}

src/category/category.controller.ts

+import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
+import { CategoryService } from './category.service';
+import { CreateCategoryDto } from './dto/create-category.dto';
+
+@Controller('category')
+export class CategoryController {
+  constructor(private readonly categoryService: CategoryService) {}
+
+  @Post()
+  create(@Body() createCategoryDto: CreateCategoryDto) {
+    return this.categoryService.create(createCategoryDto);
+  }
+
+  @Get()
+  findAll() {
+    return this.categoryService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.categoryService.findOne(+id);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.categoryService.remove(+id);
+  }
+}

src/category/category.module.ts

+import { Module } from '@nestjs/common';
+import { CategoryService } from './category.service';
+import { CategoryController } from './category.controller';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Category } from './entities/category.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Category])],
+  controllers: [CategoryController],
+  providers: [CategoryService],
+})
+export class CategoryModule {}

src/category/category.service.ts

+import { Injectable } from '@nestjs/common';
+import { CreateCategoryDto } from './dto/create-category.dto';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Category } from './entities/category.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class CategoryService {
+  constructor(
+    @InjectRepository(Category) private categoryRepo: Repository<Category>,
+  ) {}
+
+  async create(createCategoryDto: CreateCategoryDto): Promise<Category> {
+    const category = this.categoryRepo.create(createCategoryDto);
+    await this.categoryRepo.save(category);
+    return category;
+  }
+
+  async findAll(): Promise<Category[]> {
+    return await this.categoryRepo.find();
+  }
+
+  async findOne(id: number): Promise<Category | null> {
+    return await this.categoryRepo.findOneBy({ id });
+  }
+
+  async remove(id: number): Promise<number> {
+    await this.categoryRepo.delete({ id });
+    return id;
+  }
+}

src/category/dto/create-category.dto.ts

+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class CreateCategoryDto {
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+}

src/category/dto/update-category.dto.ts

+import { PartialType } from '@nestjs/mapped-types';
+import { CreateCategoryDto } from './create-category.dto';
+
+export class UpdateCategoryDto extends PartialType(CreateCategoryDto) {}

src/category/entities/category.entity.ts

+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity()
+export class Category {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @Column({ nullable: true })
+  description: string;
+}

src/main.ts

 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
+import { ValidationPipe } from '@nestjs/common';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
-  await app.listen(process.env.PORT ?? 3000);
+
+  app.useGlobalPipes(
+    new ValidationPipe({
+      transform: true,
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    }),
+  );
+
+  await app.listen(process.env.PORT ?? 5000);
+  console.log('Nest start to localhost:5000');
 }
 bootstrap();

src/product/dto/create-product.dto.ts

+import { IsString, IsNumber, IsNotEmpty } from 'class-validator';
+
+export class CreateProductDto {
+  @IsString()
+  @IsNotEmpty()
+  title: string;
+
+  @IsString()
+  @IsNotEmpty()
+  description: string;
+
+  @IsNumber()
+  @IsNotEmpty()
+  price: number;
+
+  @IsNumber()
+  @IsNotEmpty()
+  categoryId: number;
+}

src/product/dto/update-product.dto.ts

+import { PartialType } from '@nestjs/mapped-types';
+import { CreateProductDto } from './create-product.dto';
+
+export class UpdateProductDto extends PartialType(CreateProductDto) {}

src/product/entities/product.entity.ts

+import { Category } from 'src/category/entities/category.entity';
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+
+@Entity()
+export class Product {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  title: string;
+
+  @Column()
+  description: string;
+
+  @Column()
+  price: number;
+
+  @Column({ nullable: true })
+  image: string;
+
+  @ManyToOne(() => Category)
+  @JoinColumn({ name: 'categoryId' })
+  category?: Category;
+  @Column({ nullable: true })
+  categoryId?: number;
+}

src/product/product.controller.ts

+import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
+import { ProductService } from './product.service';
+import { CreateProductDto } from './dto/create-product.dto';
+
+@Controller('product')
+export class ProductController {
+  constructor(private readonly productService: ProductService) {}
+
+  @Post()
+  create(@Body() createProductDto: CreateProductDto) {
+    return this.productService.create(createProductDto);
+  }
+
+  @Get()
+  findAll() {
+    return this.productService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.productService.findOne(+id);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.productService.remove(+id);
+  }
+}

src/product/product.module.ts

+import { Module } from '@nestjs/common';
+import { ProductService } from './product.service';
+import { ProductController } from './product.controller';
+import { Product } from './entities/product.entity';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Category } from 'src/category/entities/category.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Product, Category])],
+  controllers: [ProductController],
+  providers: [ProductService],
+  exports: [TypeOrmModule],
+})
+export class ProductModule {}

src/product/product.service.ts

+import { InjectRepository } from '@nestjs/typeorm';
+import { CreateProductDto } from './dto/create-product.dto';
+import { Product } from './entities/product.entity';
+import { Repository } from 'typeorm';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { Category } from 'src/category/entities/category.entity';
+
+@Injectable()
+export class ProductService {
+  constructor(
+    @InjectRepository(Product) private productRepo: Repository<Product>,
+    @InjectRepository(Category) private categoryRepo: Repository<Category>,
+  ) {}
+
+  async create(createProductDto: CreateProductDto): Promise<Product> {
+    const category = await this.categoryRepo.findOneBy({
+      id: createProductDto.categoryId,
+    });
+
+    if (!category) new NotFoundException('Category not found');
+
+    const product = this.productRepo.create({
+      ...createProductDto,
+      categoryId: category?.id,
+    });
+    await this.productRepo.save(product);
+    return product;
+  }
+
+  async findAll(): Promise<Product[]> {
+    return await this.productRepo.find();
+  }
+
+  async findOne(id: number): Promise<Product | null> {
+    return await this.productRepo.findOneBy({ id });
+  }
+
+  async remove(id: number): Promise<number> {
+    await this.productRepo.delete({ id });
+    return id;
+  }
+}

src/user/dto/create-user.dto.ts

+import { IsNotEmpty, IsString, Length } from 'class-validator';
+
+export class CreateUserDto {
+  @IsString()
+  @IsNotEmpty()
+  @Length(4, 50)
+  username: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Length(4, 50)
+  password: string;
+}

src/user/dto/update-user.dto.ts

+import { PartialType } from '@nestjs/mapped-types';
+import { CreateUserDto } from './create-user.dto';
+
+export class UpdateUserDto extends PartialType(CreateUserDto) {}

src/user/entities/user.entity.ts

+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity()
+export class User {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  username: string;
+
+  @Column()
+  password: string;
+}

src/user/user.controller.ts

+import { Controller, Get, Post, Body } from '@nestjs/common';
+import { UserService } from './user.service';
+import { CreateUserDto } from './dto/create-user.dto';
+
+@Controller('user')
+export class UserController {
+  constructor(private readonly userService: UserService) {}
+
+  @Post('register')
+  register(@Body() createUserDto: CreateUserDto) {
+    return this.userService.register(createUserDto);
+  }
+
+  @Post('login')
+  login(@Body() createUserDto: CreateUserDto) {
+    return this.userService.login(createUserDto);
+  }
+
+  @Get()
+  logout() {
+    return this.userService.logout();
+  }
+}

src/user/user.module.ts

+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Module } from '@nestjs/common';
+import { UserService } from './user.service';
+import { UserController } from './user.controller';
+import { User } from './entities/user.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([User])],
+  controllers: [UserController],
+  providers: [UserService],
+})
+export class UserModule {}

src/user/user.service.ts

+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateUserDto } from './dto/create-user.dto';
+import { InjectRepository } from '@nestjs/typeorm';
+import { User } from './entities/user.entity';
+import { Repository } from 'typeorm';
+import * as bcrypt from 'bcrypt';
+
+const SALT_WORK_FACTOR = 10;
+
+@Injectable()
+export class UserService {
+  constructor(@InjectRepository(User) private userRepo: Repository<User>) {}
+
+  async register(createUserDto: CreateUserDto) {
+    const salt = await bcrypt.genSalt(SALT_WORK_FACTOR);
+    createUserDto.password = await bcrypt.hash(createUserDto.password, salt);
+    const user = this.userRepo.create(createUserDto);
+    await this.userRepo.save(user);
+    return user;
+  }
+
+  async login(createUserDto: CreateUserDto) {
+    const user = await this.userRepo.findOneBy({
+      username: createUserDto.username,
+    });
+
+    if (!user) new NotFoundException('User not found');
+
+    // password = 2131
+    const isMatch = await bcrypt.compare(
+      createUserDto.password,
+      user?.password || '',
+    );
+
+    if (isMatch) {
+      return "SUCCESS LOGIN";
+    } else {
+      return null;
+    }
+  }
+
+  logout() {
+    return `This action returns a user`;
+  }
+}