Users module

src/app.module.ts

@@ -5,21 +5,14 @@ import { PostsService } from './modules/posts/posts.service';
 import { PrismaService } from './prisma.service';
 import { PostsModule } from './modules/posts/posts.module';
 import { AuthModule } from './modules/auth/auth.module';
+import { UsersModule } from './modules/users/users.module';
+import { UsersController } from './modules/users/users.controller';
+import { UsersService } from './modules/users/users.service';
 
 @Module({
-  imports: [
-    // GraphQLModule.forRoot<ApolloDriverConfig>({
-    //   driver: ApolloDriver,
-    //   autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
-    //   definitions: {
-    //     path: join(process.cwd(), 'src/graphql.ts'),
-    //   },
-    // }),
-    PostsModule,
-    AuthModule
-  ],
-  controllers: [AppController],
-  providers: [AppService, PrismaService, PostsService],
+  imports: [PostsModule, AuthModule, UsersModule],
+  controllers: [AppController, UsersController],
+  providers: [AppService, PrismaService, PostsService, UsersService],
   exports: [PrismaService],
 })
 export class AppModule {}

src/main.ts

@@ -1,6 +1,7 @@
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import * as dotenv from 'dotenv';
+import { ValidationPipe } from '@nestjs/common';
 dotenv.config();
 
 async function bootstrap() {
@@ -9,6 +10,8 @@ async function bootstrap() {
     origin: '*',
     credentials: true,
   });
+
+  app.useGlobalPipes(new ValidationPipe({ transform: true }));
   await app.listen(3000);
 }
 bootstrap();

src/modules/auth/auth.module.ts

@@ -8,14 +8,14 @@ import { JwtStrategy } from './jwt.strategy';
 
 @Module({
   imports: [
-    PassportModule.register({ defaultStrategy: 'jwt' }),  // ✅ registers 'jwt'
+    PassportModule.register({ defaultStrategy: 'jwt' }),
     JwtModule.register({
-      secret: 'secretKey',  // replace with process.env.JWT_SECRET in production
-      signOptions: { expiresIn: '1h' },  // token expiry time
+      secret: 'secretKey',
+      signOptions: { expiresIn: '1h' },
     }),
   ],
   controllers: [AuthController],
-  providers: [AuthService, PrismaService, JwtStrategy],  // ✅ provide JwtStrategy
+  providers: [AuthService, PrismaService, JwtStrategy],
   exports: [AuthService],
 })
 export class AuthModule {}

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

@@ -0,0 +1,37 @@
+import {
+  IsEmail,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUrl,
+} from 'class-validator';
+
+export class CreateUserDto {
+  @IsEmail()
+  @IsNotEmpty()
+  email: string;
+
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @IsOptional()
+  @IsUrl()
+  avatarLink?: string;
+
+  @IsOptional()
+  @IsString()
+  passwordHash?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  function: string;
+
+  @IsOptional()
+  @IsString()
+  role?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+}

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

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

src/modules/users/pipes/parse-id.pipe.ts

@@ -0,0 +1,13 @@
+import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';
+import { isNumber } from 'class-validator';
+
+@Injectable()
+export class ParseIdPipe implements PipeTransform {
+  transform(value: number) {
+    if (!isNumber(value)) {
+      throw new BadRequestException('ID invalid!');
+    }
+
+    return value;
+  }
+}

src/modules/users/users.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UsersController } from './users.controller';
+
+describe('UsersController', () => {
+  let controller: UsersController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [UsersController],
+    }).compile();
+
+    controller = module.get<UsersController>(UsersController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

src/modules/users/users.controller.ts

@@ -0,0 +1,43 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Post,
+} from '@nestjs/common';
+import { UsersService } from './users.service';
+import { CreateUserDto } from './dto/create-user.dto';
+import { ParseIdPipe } from './pipes/parse-id.pipe';
+import { UpdateUserDto } from './dto/update-user.dto';
+
+@Controller('users')
+export class UsersController {
+  constructor(private userService: UsersService) {}
+
+  @Post()
+  create(@Body() dto: CreateUserDto) {
+    return this.userService.create(dto);
+  }
+
+  @Get()
+  findAll() {
+    return this.userService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id', ParseIdPipe) id: number) {
+    return this.userService.findOne(id);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIdPipe) id: number, @Body() dto: UpdateUserDto) {
+    return this.userService.update(id, dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id', ParseIdPipe) id: number) {
+    return this.userService.remove(id);
+  }
+}

src/modules/users/users.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { UsersController } from './users.controller';
+import { UsersService } from './users.service';
+import { PrismaService } from 'src/prisma.service';
+
+@Module({
+  controllers: [UsersController],
+  providers: [UsersService, PrismaService],
+})
+export class UsersModule {}

src/modules/users/users.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UsersService } from './users.service';
+
+describe('UsersService', () => {
+  let service: UsersService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [UsersService],
+    }).compile();
+
+    service = module.get<UsersService>(UsersService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/modules/users/users.service.ts

@@ -0,0 +1,62 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from 'src/prisma.service';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UpdateUserDto } from './dto/update-user.dto';
+
+@Injectable()
+export class UsersService {
+  constructor(private prisma: PrismaService) {}
+
+  async create(data: CreateUserDto) {
+    return this.prisma.user.create({ data });
+  }
+
+  async findAll() {
+    return this.prisma.user.findMany({
+      where: { deletedAt: null },
+      select: {
+        name: true,
+        function: true,
+      },
+    });
+  }
+
+  async findOne(id: number) {
+    const user = await this.prisma.user.findUnique({
+      where: { id },
+      select: {
+        name: true,
+        function: true,
+        posts: { where: { isPublished: true }, select: { title: true } },
+      },
+    });
+
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    return user;
+  }
+
+  async update(id: number, data: UpdateUserDto) {
+    const findUser = await this.findOne(id);
+
+    if (!findUser) {
+      throw new NotFoundException('User not found');
+    }
+
+    return this.prisma.user.update({ where: { id }, data });
+  }
+
+  async remove(id: number) {
+    const findUser = await this.findOne(id);
+
+    if (!findUser) {
+      throw new NotFoundException('User not found');
+    }
+
+    await this.prisma.user.delete({ where: { id } });
+
+    return { message: 'User successfully removed', id };
+  }
+}