nestjs/backend/src/.env

@@ -1,7 +1,7 @@
-DB_HOST=localhost
+DB_HOST=109.107.166.17
 DB_PORT=5432
-DB_USER=postgres
+DB_USER=nichtar
-DB_PASSWORD=postgres
+DB_PASSWORD=6t30a72
 DB_NAME=todo
 
 JWT_SECRET=your_secret_key

nestjs/backend/src/app.module.ts

@@ -1,32 +1,40 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { ConfigModule } from '@nestjs/config';
-import { AuthModule } from './auth/auth.module';
 import { UsersModule } from './users/users.module';
 import { ProjectsModule } from './projects/projects.module';
 import { TasksModule } from './tasks/tasks.module';
+import { AuthModule } from './auth/auth.module';
 import { User } from './users/user.entity';
 import { Project } from './projects/project.entity';
 import { Task } from './tasks/task.entity';
 import { ProjectMember } from './projects/project-member.entity';
 
+console.log('Database Config:', {
+  host: process.env.DB_HOST,
+  port: process.env.DB_PORT,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD ? '***HIDDEN***' : 'UNDEFINED',
+  database: process.env.DB_NAME,
+});
+
 @Module({
   imports: [
-    ConfigModule.forRoot(),
+    ConfigModule.forRoot(), // Читает .env
     TypeOrmModule.forRoot({
       type: 'postgres',
-      host: process.env.DB_HOST || 'localhost',
+      host: process.env.DB_HOST || '109.107.166.17',
       port: Number(process.env.DB_PORT) || 5432,
-      username: process.env.DB_USER || 'postgres',
+      username: process.env.DB_USER || 'nichtar',
-      password: process.env.DB_PASSWORD || 'postgres',
+      password: process.env.DB_PASSWORD || '6t30a72', // Убрал `String()`, оно тут не нужно
       database: process.env.DB_NAME || 'todo',
       entities: [User, Project, Task, ProjectMember],
       synchronize: true,
     }),
-    AuthModule,
     UsersModule,
     ProjectsModule,
     TasksModule,
+    AuthModule,
   ],
 })
 export class AppModule {}

nestjs/backend/src/auth/auth.controller.ts

@@ -1,88 +1,24 @@
 import { Controller, Post, Body, UnauthorizedException } from '@nestjs/common';
 import { AuthService } from './auth.service';
 import { UsersService } from '../users/users.service';
-import { ApiTags, ApiOperation, ApiBody, ApiResponse, ApiBearerAuth } from '@nestjs/swagger';
 
-class LoginDto {
-  username: string;
-  password: string;
-}
-
-class LoginResponse {
-  access_token: string;
-}
-
-class RegisterDto {
-  username: string;
-  email: string;
-  password: string;
-}
-
-@ApiTags('Auth')
 @Controller('auth')
 export class AuthController {
   constructor(
     private authService: AuthService,
-    private usersService: UsersService,
+    private usersService: UsersService
   ) {}
 
-  @ApiOperation({ summary: 'Register new user' })
-  @ApiBody({
-    description: 'User registration data',
-    type: RegisterDto,
-    examples: {
-      example1: {
-        summary: 'Typical registration',
-        value: {
-          username: 'john_doe',
-          email: 'john@example.com',
-          password: '123456',
-        },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 201,
-    description: 'User created successfully',
-  })
-  @ApiResponse({
-    status: 409,
-    description: 'Username already exists',
-  })
   @Post('register')
-  async register(@Body() body: RegisterDto) {
+  async register(@Body() body) {
-    const existing = await this.usersService.findOneByUsername(body.username);
+    const existingUser = await this.usersService.findOneByUsername(body.username);
-    if (existing) {
+    if (existingUser) throw new UnauthorizedException('Username already exists');
-      throw new UnauthorizedException('Username already exists');
+
-    }
     return this.usersService.create(body);
   }
 
-  @ApiOperation({ summary: 'Login user' })
-  @ApiBody({
-    description: 'User login data',
-    type: LoginDto,
-    examples: {
-      example1: {
-        summary: 'Typical login',
-        value: {
-          username: 'john_doe',
-          password: '123456',
-        },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'User logged in successfully',
-    type: LoginResponse,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Invalid username or password',
-  })
   @Post('login')
-  async login(@Body() body: LoginDto) {
+  async login(@Body() body) {
     const user = await this.authService.validateUser(body.username, body.password);
     return this.authService.login(user);
   }

nestjs/backend/src/auth/auth.module.ts

@@ -1,10 +1,10 @@
 import { Module } from '@nestjs/common';
-import { PassportModule } from '@nestjs/passport';
 import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
 import { AuthService } from './auth.service';
-import { AuthController } from './auth.controller';
-import { UsersModule } from '../users/users.module';
 import { JwtStrategy } from './jwt.strategy';
+import { UsersModule } from '../users/users.module';
+import { AuthController } from './auth.controller';
 
 @Module({
   imports: [
@@ -12,11 +12,11 @@ import { JwtStrategy } from './jwt.strategy';
     PassportModule,
     JwtModule.register({
       secret: process.env.JWT_SECRET || 'super_secret_key',
-      signOptions: { expiresIn: process.env.JWT_EXPIRES_IN || '3600s' },
+      signOptions: { expiresIn: '1h' },
     }),
   ],
-  controllers: [AuthController],
   providers: [AuthService, JwtStrategy],
+  controllers: [AuthController],
   exports: [AuthService],
 })
 export class AuthModule {}

nestjs/backend/src/auth/auth.service.ts

@@ -7,20 +7,16 @@ import * as bcrypt from 'bcrypt';
 export class AuthService {
   constructor(
     private usersService: UsersService,
-    private jwtService: JwtService,
+    private jwtService: JwtService
   ) {}
 
-  async validateUser(username: string, password: string) {
+  async validateUser(username: string, password: string): Promise<any> {
     const user = await this.usersService.findOneByUsername(username);
-    if (!user) {
+    if (user && (await bcrypt.compare(password, user.password))) {
-      throw new UnauthorizedException('User not found');
+      const { password, ...result } = user;
+      return result;
     }
-    const isMatch = await bcrypt.compare(password, user.password);
+    throw new UnauthorizedException('Invalid username or password');
-    if (!isMatch) {
-      throw new UnauthorizedException('Invalid password');
-    }
-    const { password: _, ...rest } = user;
-    return rest;
   }
 
   async login(user: any) {

nestjs/backend/src/main.ts

@@ -10,10 +10,10 @@ async function bootstrap() {
 
   // Настройка Swagger
   const config = new DocumentBuilder()
-  .setTitle('Cool TODO Manager API')
+  .setTitle('Project Management API')
-  .setDescription('NestJS + PostgreSQL + JWT + Docker')
+  .setDescription('API documentation for NestJS + Docker project')
-  .setVersion('2.0')
+  .setVersion('1.0')
-  .addBearerAuth()
+  .addBearerAuth() // Добавляем поддержку JWT (Bearer)
   .build();
 
   const document = SwaggerModule.createDocument(app, config);

nestjs/backend/src/projects/project-member.entity.ts

@@ -7,12 +7,12 @@ export class ProjectMember {
   @PrimaryGeneratedColumn()
   id: number;
 
-  @ManyToOne(() => Project, (project) => project.id, { eager: true })
+  @ManyToOne(() => Project, (project) => project.id)
   project: Project;
 
-  @ManyToOne(() => User, (user) => user.id, { eager: true })
+  @ManyToOne(() => User, (user) => user.id)
   user: User;
 
   @Column()
-  role: string; // 'owner' or 'member'
+  role: string; // owner, member
 }

nestjs/backend/src/projects/project.entity.ts

@@ -1,30 +1,23 @@
 import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, CreateDateColumn, UpdateDateColumn } from 'typeorm';
 import { User } from '../users/user.entity';
-import { ApiProperty } from '@nestjs/swagger';
 
 @Entity()
 export class Project {
-  @ApiProperty({ example: 1, description: 'Project ID' })
   @PrimaryGeneratedColumn()
   id: number;
 
-  @ApiProperty({ example: 'My Project', description: 'Title of the project' })
   @Column()
   title: string;
 
-  @ApiProperty({ example: 'Optional description', description: 'Project description', required: false })
   @Column({ nullable: true })
   description: string;
 
-  @ApiProperty({ description: 'Owner user object' })
+  @ManyToOne(() => User, (user) => user.id, { eager: true }) // `eager: true` загружает владельца проекта
-  @ManyToOne(() => User, (user) => user.id, { eager: true })
   owner: User;
 
-  @ApiProperty({ description: 'Date of creation' })
   @CreateDateColumn()
   created_at: Date;
 
-  @ApiProperty({ description: 'Date of last update' })
   @UpdateDateColumn()
   updated_at: Date;
 }

nestjs/backend/src/projects/projects.controller.ts

@@ -1,116 +1,28 @@
-import { Controller, Post, Get, Patch, Delete, Body, Param, UseGuards, Request } from '@nestjs/common';
+import { Controller, Post, Get, Delete, Body, Param, UseGuards, Request } from '@nestjs/common';
 import { ProjectsService } from './projects.service';
 import { Project } from './project.entity';
 import { AuthGuard } from '@nestjs/passport';
-import { ApiTags, ApiBearerAuth, ApiOperation, ApiParam, ApiBody, ApiResponse } from '@nestjs/swagger';
 
-class CreateProjectDto {
-  title: string;
-  description?: string;
-}
-
-@ApiTags('Projects')
-@ApiBearerAuth() // Все маршруты под Bearer Token (Try it out -> authorize)
 @Controller('projects')
 export class ProjectsController {
   constructor(private readonly projectsService: ProjectsService) {}
 
-  @ApiOperation({ summary: 'Create new project' })
-  @ApiBody({
-    description: 'Project data',
-    type: CreateProjectDto,
-    examples: {
-      example1: {
-        summary: 'Simple project',
-        value: {
-          title: 'My project',
-          description: 'Test desc',
-        },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 201,
-    description: 'Project created',
-    type: Project,
-  })
   @UseGuards(AuthGuard('jwt'))
   @Post('create')
-  async create(@Request() req, @Body() body: CreateProjectDto): Promise<Project> {
+  async create(@Request() req, @Body() body): Promise<Project> {
-    return this.projectsService.create({
+    return this.projectsService.create({ ...body, ownerId: req.user.userId });
-      title: body.title,
-      description: body.description,
-      ownerId: req.user.userId,
-    });
   }
 
-  @ApiOperation({ summary: 'Get all projects' })
-  @ApiResponse({
-    status: 200,
-    description: 'List of projects',
-    type: Project,
-    isArray: true,
-  })
   @Get()
   async findAll(): Promise<Project[]> {
     return this.projectsService.findAll();
   }
 
-  @ApiOperation({ summary: 'Get single project by ID' })
-  @ApiParam({ name: 'id', type: 'number' })
-  @ApiResponse({
-    status: 200,
-    description: 'Found project',
-    type: Project,
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Project not found',
-  })
   @Get(':id')
   async findOne(@Param('id') id: number): Promise<Project | null> {
     return this.projectsService.findOneById(id);
   }
 
-  @ApiOperation({ summary: 'Update project' })
-  @ApiParam({ name: 'id', type: 'number' })
-  @ApiBody({
-    description: 'Fields to update',
-    schema: {
-      properties: {
-        title: { type: 'string', example: 'Updated Title' },
-        description: { type: 'string', example: 'Updated desc' },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Project updated',
-    type: Project,
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Project not found',
-  })
-  @UseGuards(AuthGuard('jwt'))
-  @Patch(':id')
-  async update(
-    @Param('id') id: number,
-    @Body() data: { title?: string; description?: string },
-  ): Promise<Project> {
-    return this.projectsService.update(id, data);
-  }
-
-  @ApiOperation({ summary: 'Delete project' })
-  @ApiParam({ name: 'id', type: 'number' })
-  @ApiResponse({
-    status: 200,
-    description: 'Project deleted',
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Project not found',
-  })
   @UseGuards(AuthGuard('jwt'))
   @Delete(':id')
   async delete(@Param('id') id: number): Promise<void> {

nestjs/backend/src/projects/projects.module.ts

@@ -3,14 +3,10 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { ProjectsService } from './projects.service';
 import { ProjectsController } from './projects.controller';
 import { Project } from './project.entity';
-import { ProjectMember } from './project-member.entity';
 import { UsersModule } from '../users/users.module';
 
 @Module({
-  imports: [
+  imports: [TypeOrmModule.forFeature([Project]), UsersModule],
-    TypeOrmModule.forFeature([Project, ProjectMember]),
-    UsersModule,
-  ],
   controllers: [ProjectsController],
   providers: [ProjectsService],
   exports: [ProjectsService],

nestjs/backend/src/projects/projects.service.ts

@@ -9,37 +9,29 @@ export class ProjectsService {
   constructor(
     @InjectRepository(Project)
     private projectsRepository: Repository<Project>,
-    private usersService: UsersService,
+    private usersService: UsersService
   ) {}
 
-  async create(data: { title: string; description?: string; ownerId: number }): Promise<Project> {
+  async create(projectData: { title: string; description?: string; ownerId: number }): Promise<Project> {
-    const owner = await this.usersService.findOneById(data.ownerId);
+    const owner = await this.usersService.findOneById(projectData.ownerId); // Ищем по ID, а не username
     if (!owner) throw new NotFoundException('Owner not found');
   
     const project = this.projectsRepository.create({
-      title: data.title,
+      title: projectData.title,
-      description: data.description,
+      description: projectData.description,
-      owner,
+      owner: owner,
     });
-    return this.projectsRepository.save(project);
+  
+    return await this.projectsRepository.save(project);
   }
   
+
   async findAll(): Promise<Project[]> {
-    return this.projectsRepository.find();
+    return await this.projectsRepository.find();
   }
 
   async findOneById(id: number): Promise<Project | null> {
-    return this.projectsRepository.findOne({ where: { id } });
+    return await this.projectsRepository.findOne({ where: { id } });
-  }
-
-  async update(id: number, data: { title?: string; description?: string }): Promise<Project> {
-    const project = await this.findOneById(id);
-    if (!project) throw new NotFoundException('Project not found');
-
-    if (data.title !== undefined) project.title = data.title;
-    if (data.description !== undefined) project.description = data.description;
-
-    return this.projectsRepository.save(project);
   }
 
   async delete(id: number): Promise<void> {

nestjs/backend/src/tasks/task.entity.ts

@@ -1,35 +1,27 @@
 import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, CreateDateColumn } from 'typeorm';
 import { Project } from '../projects/project.entity';
 import { User } from '../users/user.entity';
-import { ApiProperty } from '@nestjs/swagger';
 
 @Entity()
 export class Task {
-  @ApiProperty({ example: 1, description: 'Task ID' })
   @PrimaryGeneratedColumn()
   id: number;
 
-  @ApiProperty({ description: 'Project object' })
   @ManyToOne(() => Project, (project) => project.id, { eager: true })
   project: Project;
 
-  @ApiProperty({ example: 'My Task', description: 'Task title' })
   @Column()
   title: string;
 
-  @ApiProperty({ example: 'todo', description: 'Task status' })
+  @Column({ default: 'todo' }) // Возможные значения: 'todo', 'in_progress', 'done'
-  @Column({ default: 'todo' })
+  status: string;
-  status: string; // 'todo', 'in_progress', 'done'
 
-  @ApiProperty({ description: 'Assigned user object', required: false })
   @ManyToOne(() => User, (user) => user.id, { nullable: true, eager: true })
   assigned_user?: User;
 
-  @ApiProperty({ example: '2025-03-01T12:00:00Z', required: false })
+  @Column({ type: 'timestamp', nullable: true }) // Исправлено
-  @Column({ type: 'timestamp', nullable: true })
   deadline?: Date;
 
-  @ApiProperty({ description: 'Date of creation' })
   @CreateDateColumn()
   created_at: Date;
 }

nestjs/backend/src/tasks/tasks.controller.ts

@@ -1,137 +1,33 @@
-import { Controller, Post, Get, Patch, Delete, Body, Param, UseGuards } from '@nestjs/common';
+import { Controller, Post, Get, Patch, Delete, Body, Param } from '@nestjs/common';
 import { TasksService } from './tasks.service';
 import { Task } from './task.entity';
-import { AuthGuard } from '@nestjs/passport';
-import { ApiTags, ApiBearerAuth, ApiOperation, ApiParam, ApiBody, ApiResponse } from '@nestjs/swagger';
 
-class CreateTaskDto {
-  title: string;
-  projectId: number;
-  assignedUserId?: number;
-  deadline?: string;
-}
-
-class UpdateTaskDto {
-  title?: string;
-  status?: string; // 'todo', 'in_progress', 'done'
-  deadline?: string;
-  assignedUserId?: number;
-}
-
-@ApiTags('Tasks')
-@ApiBearerAuth()
 @Controller('tasks')
 export class TasksController {
   constructor(private readonly tasksService: TasksService) {}
 
-  @ApiOperation({ summary: 'Create new task' })
-  @ApiBody({
-    description: 'Task creation data',
-    type: CreateTaskDto,
-    examples: {
-      example1: {
-        summary: 'Simple task',
-        value: {
-          title: 'My Task',
-          projectId: 1,
-          assignedUserId: 2,
-          deadline: '2025-03-01T12:00:00Z',
-        },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 201,
-    description: 'Task created',
-    type: Task,
-  })
-  @UseGuards(AuthGuard('jwt'))
   @Post('create')
-  async create(@Body() body: CreateTaskDto): Promise<Task> {
+  async create(@Body() body): Promise<Task> {
-    return this.tasksService.create({
+    return this.tasksService.create(body);
-      title: body.title,
-      projectId: body.projectId,
-      assignedUserId: body.assignedUserId,
-      deadline: body.deadline ? new Date(body.deadline) : undefined,
-    });
   }
 
-  @ApiOperation({ summary: 'Get all tasks' })
-  @ApiResponse({
-    status: 200,
-    description: 'List of tasks',
-    type: Task,
-    isArray: true,
-  })
   @Get()
   async findAll(): Promise<Task[]> {
     return this.tasksService.findAll();
   }
 
-  @ApiOperation({ summary: 'Get task by ID' })
-  @ApiParam({ name: 'id', type: 'number' })
-  @ApiResponse({
-    status: 200,
-    description: 'Found task',
-    type: Task,
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Task not found',
-  })
   @Get(':id')
   async findOne(@Param('id') id: number): Promise<Task | null> {
     return this.tasksService.findOneById(id);
   }
 
-  @ApiOperation({ summary: 'Update task' })
+  @Patch(':id/status')
-  @ApiParam({ name: 'id', type: 'number' })
+  async updateStatus(@Param('id') id: number, @Body('status') status: string): Promise<Task> {
-  @ApiBody({
+    return this.tasksService.updateStatus(id, status);
-    description: 'Fields to update in the task',
-    type: UpdateTaskDto,
-    examples: {
-      example1: {
-        summary: 'Update partial fields',
-        value: {
-          title: 'Updated Task Title',
-          status: 'in_progress',
-        },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Task updated',
-    type: Task,
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Task not found',
-  })
-  @UseGuards(AuthGuard('jwt'))
-  @Patch(':id')
-  async update(@Param('id') id: number, @Body() body: UpdateTaskDto): Promise<Task> {
-    return this.tasksService.update(id, {
-      title: body.title,
-      status: body.status,
-      deadline: body.deadline ? new Date(body.deadline) : undefined,
-      assignedUserId: body.assignedUserId,
-    });
   }
 
-  @ApiOperation({ summary: 'Delete task' })
-  @ApiParam({ name: 'id', type: 'number' })
-  @ApiResponse({
-    status: 200,
-    description: 'Task deleted',
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Task not found',
-  })
-  @UseGuards(AuthGuard('jwt'))
   @Delete(':id')
-  async delete(@Param('id') id: number) {
+  async delete(@Param('id') id: number): Promise<void> {
     return this.tasksService.delete(id);
   }
 }

nestjs/backend/src/tasks/tasks.module.ts

@@ -7,11 +7,7 @@ import { ProjectsModule } from '../projects/projects.module';
 import { UsersModule } from '../users/users.module';
 
 @Module({
-  imports: [
+  imports: [TypeOrmModule.forFeature([Task]), ProjectsModule, UsersModule],
-    TypeOrmModule.forFeature([Task]),
-    ProjectsModule,
-    UsersModule,
-  ],
   controllers: [TasksController],
   providers: [TasksService],
   exports: [TasksService],

nestjs/backend/src/tasks/tasks.service.ts

@@ -4,6 +4,7 @@ import { Repository } from 'typeorm';
 import { Task } from './task.entity';
 import { ProjectsService } from '../projects/projects.service';
 import { UsersService } from '../users/users.service';
+import { User } from '../users/user.entity';
 
 @Injectable()
 export class TasksService {
@@ -11,55 +12,47 @@ export class TasksService {
     @InjectRepository(Task)
     private tasksRepository: Repository<Task>,
     private projectsService: ProjectsService,
-    private usersService: UsersService,
+    private usersService: UsersService
   ) {}
 
-  async create(data: { title: string; projectId: number; assignedUserId?: number; deadline?: Date }) {
+  async create(taskData: { title: string; projectId: number; assignedUserId?: number; deadline?: Date }): Promise<Task> {
-    const project = await this.projectsService.findOneById(data.projectId);
+    const project = await this.projectsService.findOneById(taskData.projectId);
     if (!project) throw new NotFoundException('Project not found');
 
-    let user;
+    let assignedUser: User | undefined = undefined;
-    if (data.assignedUserId) {
+    if (taskData.assignedUserId) {
-      user = await this.usersService.findOneById(data.assignedUserId);
+      const user = await this.usersService.findOneById(taskData.assignedUserId);
       if (!user) throw new NotFoundException('Assigned user not found');
+      assignedUser = user; // Теперь `assignedUser` всегда `User | undefined`
     }
 
     const task = this.tasksRepository.create({
-      title: data.title,
+      title: taskData.title,
-      project,
+      project: project,
-      assigned_user: user,
+      assigned_user: assignedUser,
-      deadline: data.deadline,
+      deadline: taskData.deadline ?? undefined, // `undefined`, если нет значения
     });
 
-    return this.tasksRepository.save(task);
+    return await this.tasksRepository.save(task);
   }
 
   async findAll(): Promise<Task[]> {
-    return this.tasksRepository.find();
+    return await this.tasksRepository.find();
   }
 
   async findOneById(id: number): Promise<Task | null> {
-    return this.tasksRepository.findOne({ where: { id } });
+    return await this.tasksRepository.findOne({ where: { id } });
   }
 
-  async update(id: number, data: { title?: string; status?: string; deadline?: Date; assignedUserId?: number }) {
+  async updateStatus(id: number, status: string): Promise<Task> {
     const task = await this.findOneById(id);
     if (!task) throw new NotFoundException('Task not found');
 
-    if (data.title !== undefined) task.title = data.title;
+    task.status = status;
-    if (data.status !== undefined) task.status = data.status;
+    return await this.tasksRepository.save(task);
-    if (data.deadline !== undefined) task.deadline = data.deadline;
-
-    if (data.assignedUserId !== undefined) {
-      const user = await this.usersService.findOneById(data.assignedUserId);
-      if (!user) throw new NotFoundException('Assigned user not found');
-      task.assigned_user = user;
   }
 
-    return this.tasksRepository.save(task);
+  async delete(id: number): Promise<void> {
-  }
-
-  async delete(id: number) {
     const result = await this.tasksRepository.delete(id);
     if (result.affected === 0) {
       throw new NotFoundException('Task not found');

nestjs/backend/src/users/user.entity.ts

@@ -1,25 +1,19 @@
 import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn } from 'typeorm';
-import { ApiProperty } from '@nestjs/swagger';
 
 @Entity()
 export class User {
-  @ApiProperty({ example: 1, description: 'User ID' })
   @PrimaryGeneratedColumn()
   id: number;
 
-  @ApiProperty({ example: 'john_doe', description: 'Unique username' })
   @Column({ unique: true })
   username: string;
 
-  @ApiProperty({ example: 'john@example.com', description: 'Unique email' })
   @Column({ unique: true })
   email: string;
 
-  @ApiProperty({ example: '$2b$10$...', description: 'Hashed password' })
   @Column()
   password: string;
 
-  @ApiProperty({ example: '2025-03-01T10:00:00.000Z', description: 'Creation date' })
   @CreateDateColumn()
   created_at: Date;
 }

nestjs/backend/src/users/users.controller.ts

@@ -1,26 +1,18 @@
-import { Controller, Get, Param } from '@nestjs/common';
+import { Controller, Post, Body, Get, Param } from '@nestjs/common';
 import { UsersService } from './users.service';
 import { User } from './user.entity';
-import { ApiTags, ApiOperation, ApiParam, ApiResponse } from '@nestjs/swagger';
 
-@ApiTags('Users')
 @Controller('users')
 export class UsersController {
   constructor(private readonly usersService: UsersService) {}
 
-  @ApiOperation({ summary: 'Get user by username' })
+  @Post('register')
-  @ApiParam({ name: 'username', type: 'string', description: 'The username to look up' })
+  async register(@Body() body): Promise<User> {
-  @ApiResponse({
+    return this.usersService.create(body);
-    status: 200,
+  }
-    description: 'User found',
+
-    type: User,
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'User not found',
-  })
   @Get(':username')
-  async getUser(@Param('username') username: string): Promise<User | null> {
+  async getUserByUsername(@Param('username') username: string): Promise<User | null> {
     return this.usersService.findOneByUsername(username);
   }
 }

nestjs/backend/src/users/users.module.ts

@@ -6,8 +6,8 @@ import { User } from './user.entity';
 
 @Module({
   imports: [TypeOrmModule.forFeature([User])],
-  providers: [UsersService],
   controllers: [UsersController],
+  providers: [UsersService],
   exports: [UsersService],
 })
 export class UsersModule {}

nestjs/backend/src/users/users.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, ConflictException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { User } from './user.entity';
@@ -8,28 +8,31 @@ import * as bcrypt from 'bcrypt';
 export class UsersService {
   constructor(
     @InjectRepository(User)
-    private usersRepository: Repository<User>,
+    private usersRepository: Repository<User>
   ) {}
 
   async create(userData: Partial<User>): Promise<User> {
     if (!userData.password) {
-      throw new Error('Password is required');
+      throw new ConflictException('Password is required');
     }
+
     const hashedPassword = await bcrypt.hash(userData.password, 10);
 
     const user = this.usersRepository.create({
-      username: userData.username,
+      username: userData.username as string,
-      email: userData.email,
+      email: userData.email as string,
       password: hashedPassword,
     });
-    return this.usersRepository.save(user);
+
+    return await this.usersRepository.save(user);
   }
 
   async findOneByUsername(username: string): Promise<User | null> {
-    return this.usersRepository.findOne({ where: { username } });
+    return await this.usersRepository.findOne({ where: { username } });
   }
 
   async findOneById(id: number): Promise<User | null> {
-    return this.usersRepository.findOne({ where: { id } });
+    return await this.usersRepository.findOne({ where: { id } });
   }
+  
 }