Dev

api/package.json

@@ -20,19 +20,22 @@
     "test:e2e": "jest --config ./test/jest-e2e.json"
   },
   "dependencies": {
-    "@nestjs/common": "^10.0.0",
-    "@nestjs/core": "^10.0.0",
+    "@nestjs/common": "^10.4.19",
+    "@nestjs/config": "^4.0.2",
+    "@nestjs/core": "^10.4.19",
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/typeorm": "^10.0.2",
-    "pg": "^8.12.0",
+    "bcrypt": "^6.0.0",
+    "pg": "^8.16.0",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1",
-    "typeorm": "^0.3.20"
+    "typeorm": "^0.3.24"
   },
   "devDependencies": {
     "@nestjs/cli": "^10.0.0",
     "@nestjs/schematics": "^10.0.0",
     "@nestjs/testing": "^10.0.0",
+    "@types/bcrypt": "^5.0.2",
     "@types/express": "^4.17.17",
     "@types/jest": "^29.5.2",
     "@types/node": "^20.3.1",

api/src/app.module.ts

@@ -1,10 +1,35 @@
 import { Module } from '@nestjs/common';
-import { AppController } from './app.controller';
-import { AppService } from './app.service';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ConfigModule } from '@nestjs/config';
+import { UsersModule } from './users/users.module';
+import { AuthModule } from './auth/auth.module';
+import { LikesModule } from './likes/likes.module';
+
+// type: 'postgres',
+//       host: 'cat-pinterest-api-pg',
+//       port: 5432,
+//       username: 'postgres',
+//       password: '1',
+//       database: 'support_lk_db',
+//       synchronize: true,
+//       autoLoadEntities: true,
 
 @Module({
-  imports: [],
-  controllers: [AppController],
-  providers: [AppService],
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    TypeOrmModule.forRoot({
+      type: 'postgres',
+      host: 'localhost',
+      port: 5432,
+      username: 'postgres',
+      password: '2004',
+      database: 'cat_service',
+      synchronize: true,
+      autoLoadEntities: true,
+    }),
+    UsersModule,
+    AuthModule,
+    LikesModule,
+  ],
 })
 export class AppModule {}

api/src/auth/auth.guard.ts

@@ -0,0 +1,30 @@
+import {
+  Injectable,
+  CanActivate,
+  ExecutionContext,
+  UnauthorizedException,
+} from '@nestjs/common';
+
+import { Request } from 'express';
+import { UsersService } from '../users/users.service';
+import { generateToken } from '../common/utils/token.util';
+
+const SECRET_SALT = 'supersecretsalt';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  constructor(private readonly usersService: UsersService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const req = context.switchToHttp().getRequest<Request>();
+    const token = req.headers.authorization?.replace('Bearer ', '');
+    if (!token) throw new UnauthorizedException();
+
+    const users = await this.usersService.findAll();
+    const user = users.find((u) => generateToken(u.id, SECRET_SALT) === token);
+    if (!user) throw new UnauthorizedException();
+
+    (req as any).user = user;
+    return true;
+  }
+}

api/src/auth/auth.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AuthGuard } from './auth.guard';
+import { UsersModule } from '../users/users.module';
+
+@Module({
+  imports: [UsersModule],
+  providers: [AuthGuard],
+  exports: [AuthGuard],
+})
+export class AuthModule {}

api/src/common/utils/token.util.ts

@@ -0,0 +1,8 @@
+import * as crypto from 'crypto';
+
+export function generateToken(userId: string, salt: string): string {
+  return crypto
+    .createHash('sha256')
+    .update(userId + salt)
+    .digest('hex');
+}

api/src/likes/likes.controller.ts

@@ -0,0 +1,37 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Delete,
+  Param,
+  Body,
+  Req,
+  UseGuards,
+  NotFoundException,
+} from '@nestjs/common';
+
+import { LikesService } from './likes.service';
+import { AuthGuard } from '../auth/auth.guard';
+
+@Controller('likes')
+@UseGuards(AuthGuard)
+export class LikesController {
+  constructor(private readonly likesService: LikesService) {}
+
+  @Get()
+  async list(@Req() req) {
+    return { data: await this.likesService.findByUser(req.user) };
+  }
+
+  @Post()
+  async create(@Body() body: { cat_id: string; url: string }, @Req() req) {
+    return await this.likesService.createLike(body.cat_id, body.url, req.user);
+  }
+
+  @Delete(':cat_id')
+  async remove(@Param('cat_id') cat_id: string, @Req() req) {
+    const like = await this.likesService.findByCatId(req.user, cat_id);
+    if (!like) throw new NotFoundException();
+    return await this.likesService.deleteLike(like);
+  }
+}

api/src/likes/likes.entity.ts

@@ -0,0 +1,26 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  CreateDateColumn,
+} from 'typeorm';
+import { User } from '../users/users.entity';
+
+@Entity()
+export class Like {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  cat_id: string;
+
+  @Column()
+  url: string;
+
+  @CreateDateColumn()
+  created_at: Date;
+
+  @ManyToOne(() => User, (user) => user.likes, { onDelete: 'CASCADE' })
+  user: User;
+}

api/src/likes/likes.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Like } from './likes.entity';
+import { LikesService } from './likes.service';
+import { LikesController } from './likes.controller';
+import { UsersModule } from '../users/users.module';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Like]), UsersModule],
+  providers: [LikesService],
+  controllers: [LikesController],
+})
+export class LikesModule {}

api/src/likes/likes.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Like } from './likes.entity';
+import { Repository } from 'typeorm';
+import { User } from '../users/users.entity';
+
+@Injectable()
+export class LikesService {
+  constructor(@InjectRepository(Like) private repo: Repository<Like>) {}
+
+  findByUser(user: User) {
+    return this.repo.find({ where: { user } });
+  }
+
+  async createLike(cat_id: string, url: string, user: User) {
+    const existing = await this.repo.findOne({ where: { cat_id, user } });
+    if (existing) throw new Error('Already liked');
+
+    const like = this.repo.create({ cat_id, url, user });
+    return this.repo.save(like);
+  }
+
+  findByCatId(user: User, cat_id: string) {
+    return this.repo.findOne({ where: { cat_id, user } });
+  }
+
+  deleteLike(like: Like) {
+    return this.repo.remove(like);
+  }
+}

api/src/main.ts

@@ -3,6 +3,10 @@ import { AppModule } from './app.module';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
+  app.enableCors({
+    origin: '*',
+    exposedHeaders: ['X-Auth-Token'],
+  });
   await app.listen(3000);
 }
 bootstrap();

api/src/users/users.controller.ts

@@ -0,0 +1,30 @@
+import { Controller, Post, Body, Res } from '@nestjs/common';
+import { UsersService } from './users.service';
+import { Response } from 'express';
+import * as bcrypt from 'bcrypt';
+import { generateToken } from '../common/utils/token.util';
+
+const SECRET_SALT = 'supersecretsalt';
+
+@Controller('user')
+export class UsersController {
+  constructor(private readonly usersService: UsersService) {}
+
+  @Post()
+  async register(
+    @Body() body: { login: string; password: string },
+    @Res() res: Response,
+  ) {
+    const { login, password } = body;
+    if (!login || !password) return res.status(405).send('Invalid input');
+
+    const existing = await this.usersService.findByLogin(login);
+    if (existing) return res.status(405).send('User already exists');
+
+    const hash = await bcrypt.hash(password, 10);
+    const user = await this.usersService.createUser(login, hash);
+    const token = generateToken(user.id, SECRET_SALT!);
+
+    return res.status(201).set('X-Auth-Token', token).json(user);
+  }
+}

api/src/users/users.entity.ts

@@ -0,0 +1,18 @@
+import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';
+
+import { Like } from '../likes/likes.entity';
+
+@Entity()
+export class User {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ unique: true })
+  login: string;
+
+  @Column()
+  password: string;
+
+  @OneToMany(() => Like, (like) => like.user)
+  likes: Like[];
+}

api/src/users/users.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { User } from './users.entity';
+import { UsersService } from './users.service';
+import { UsersController } from './users.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([User])],
+  providers: [UsersService],
+  controllers: [UsersController],
+  exports: [UsersService],
+})
+export class UsersModule {}

api/src/users/users.service.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { User } from './users.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class UsersService {
+  constructor(@InjectRepository(User) private repo: Repository<User>) {}
+
+  findAll() {
+    return this.repo.find();
+  }
+
+  findByLogin(login: string) {
+    return this.repo.findOne({ where: { login } });
+  }
+
+  createUser(login: string, password: string) {
+    const user = this.repo.create({ login, password });
+    return this.repo.save(user);
+  }
+}