@urbansolv/create-nestjs-app 1.0.2 → 1.2.0

package/dist/templates/nestjs-app/src/modules/auth/auth.service.ts

@@ -1,54 +1,180 @@
-import { Injectable, UnauthorizedException } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { PassportStrategy } from '@nestjs/passport';
-import { ExtractJwt, Strategy } from 'passport-jwt';
-import { PrismaService } from '@common/prisma/prisma.service';
-import { JwtPayload } from '../interfaces/jwt-payload.interface';
-
-@Injectable()
-export class JwtStrategy extends PassportStrategy(Strategy) {
-  constructor(
-    private configService: ConfigService,
-    private prisma: PrismaService,
-  ) {
-    super({
-      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-      ignoreExpiration: false,
-      secretOrKey: configService.get<string>('jwt.secret'),
-    });
-  }
-
-  async validate(payload: JwtPayload): Promise<JwtPayload> {
-    const user = await this.prisma.user.findUnique({
-      where: { id: payload.userId },
-      include: {
-        position: {
-          include: {
-            position_permissions: {
-              include: {
-                permission: true,
-              },
-            },
-          },
-        },
-      },
-    });
-
-    if (!user || !user.is_active) {
-      throw new UnauthorizedException('User not found or inactive');
-    }
-
-    // Build permissions array from position
-    const permissions = user.position.position_permissions.map(
-      (pp) => pp.permission.name,
-    );
-
-    return {
-      userId: user.id,
-      email: user.email,
-      positionId: user.position.id,
-      positionName: user.position.name,
-      permissions,
-    };
-  }
-}
+import {
+  Injectable,
+  UnauthorizedException,
+  ConflictException,
+  BadRequestException,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from '@common/prisma/prisma.service';
+import { PasswordUtil } from '@common/utils/password.util';
+import { LoginDto } from './core/dto/login.dto';
+import { RegisterDto } from './core/dto/register.dto';
+import { AuthResponseDto } from './core/dto/auth-response.dto';
+import { JwtPayload } from './core/interfaces/jwt-payload.interface';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private prisma: PrismaService,
+    private jwtService: JwtService,
+    private configService: ConfigService,
+  ) {}
+
+  async login(loginDto: LoginDto): Promise<AuthResponseDto> {
+    const { email, password } = loginDto;
+
+    // Find user with position and permissions
+    const user = await this.prisma.user.findUnique({
+      where: { email },
+      include: {
+        position: {
+          include: {
+            position_permissions: {
+              include: {
+                permission: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!user) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    if (!user.is_active) {
+      throw new UnauthorizedException('Account is inactive');
+    }
+
+      console.log({
+        passwordInput: loginDto.password,
+        passwordHash: user.password,
+        isActive: user.is_active,
+        deletedAt: user.deleted_at,
+      });
+
+    // Verify password
+    const isPasswordValid = await PasswordUtil.compare(password, user.password);
+    if (!isPasswordValid) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    // Build permissions array
+    const permissions = user.position.position_permissions.map(
+      (pp) => pp.permission.name,
+    );
+
+    // Generate JWT token
+    const payload: JwtPayload = {
+      userId: user.id,
+      email: user.email,
+      positionId: user.position.id,
+      positionName: user.position.name,
+      permissions,
+    };
+
+    const access_token = this.jwtService.sign(payload);
+
+    return {
+      access_token,
+      user: {
+        id: user.id,
+        email: user.email,
+        first_name: user.first_name,
+        last_name: user.last_name,
+        position: {
+          id: user.position.id,
+          name: user.position.name,
+        },
+        permissions,
+      },
+    };
+  }
+
+  async register(registerDto: RegisterDto): Promise<AuthResponseDto> {
+    const { email, password, first_name, last_name, position_id } = registerDto;
+
+    // Check if user already exists
+    const existingUser = await this.prisma.user.findUnique({
+      where: { email },
+    });
+
+    if (existingUser) {
+      throw new ConflictException('Email already exists');
+    }
+
+    // Validate position exists
+    const position = await this.prisma.position.findUnique({
+      where: { id: position_id },
+      include: {
+        position_permissions: {
+          include: {
+            permission: true,
+          },
+        },
+      },
+    });
+
+    if (!position) {
+      throw new BadRequestException('Invalid position ID');
+    }
+
+    // Hash password
+    const hashedPassword = await PasswordUtil.hash(password);
+
+    // Create user
+    const user = await this.prisma.user.create({
+      data: {
+        email,
+        password: hashedPassword,
+        first_name,
+        last_name,
+        position_id,
+      },
+      include: {
+        position: {
+          include: {
+            position_permissions: {
+              include: {
+                permission: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    // Build permissions array
+    const permissions = user.position.position_permissions.map(
+      (pp) => pp.permission.name,
+    );
+
+    // Generate JWT token
+    const payload: JwtPayload = {
+      userId: user.id,
+      email: user.email,
+      positionId: user.position.id,
+      positionName: user.position.name,
+      permissions,
+    };
+
+    const access_token = this.jwtService.sign(payload);
+
+    return {
+      access_token,
+      user: {
+        id: user.id,
+        email: user.email,
+        first_name: user.first_name,
+        last_name: user.last_name,
+        position: {
+          id: user.position.id,
+          name: user.position.name,
+        },
+        permissions,
+      },
+    };
+  }
+}

package/dist/templates/nestjs-app/src/modules/auth/controllers/v1/auth.controller.ts

@@ -1,33 +1,33 @@
-import { Controller, Post, Body, HttpCode, HttpStatus } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
-import { AuthService } from '../../auth.service';
-import { LoginDto } from '../../dto/login.dto';
-import { RegisterDto } from '../../dto/register.dto';
-import { AuthResponseDto } from '../../dto/auth-response.dto';
-import { Public } from '@common/decorators/public.decorator';
-import { ApiSuccessResponse } from '@common/decorators/api-response.decorator';
-
-@ApiTags('Authentication')
-@Controller({ path: 'auth', version: '1' })
-export class AuthController {
-  constructor(private readonly authService: AuthService) {}
-
-  @Public()
-  @Post('login')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({ summary: 'User login' })
-  @ApiSuccessResponse(AuthResponseDto)
-  @ApiResponse({ status: 401, description: 'Invalid credentials' })
-  async login(@Body() loginDto: LoginDto): Promise<AuthResponseDto> {
-    return this.authService.login(loginDto);
-  }
-
-  @Public()
-  @Post('register')
-  @ApiOperation({ summary: 'User registration' })
-  @ApiSuccessResponse(AuthResponseDto)
-  @ApiResponse({ status: 409, description: 'Email already exists' })
-  async register(@Body() registerDto: RegisterDto): Promise<AuthResponseDto> {
-    return this.authService.register(registerDto);
-  }
-}
+import { Controller, Post, Body, HttpCode, HttpStatus } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
+import { AuthService } from '../../auth.service';
+import { LoginDto } from '../../core/dto/login.dto';
+import { RegisterDto } from '../../core/dto/register.dto';
+import { AuthResponseDto } from '../../core/dto/auth-response.dto';
+import { Public } from '@common/decorators/public.decorator';
+import { ApiSuccessResponse } from '@common/decorators/api-response.decorator';
+
+@ApiTags('Authentication')
+@Controller({ path: 'auth', version: '1' })
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Public()
+  @Post('login')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'User login' })
+  @ApiSuccessResponse(AuthResponseDto)
+  @ApiResponse({ status: 401, description: 'Invalid credentials' })
+  async login(@Body() loginDto: LoginDto): Promise<AuthResponseDto> {
+    return this.authService.login(loginDto);
+  }
+
+  @Public()
+  @Post('register')
+  @ApiOperation({ summary: 'User registration' })
+  @ApiSuccessResponse(AuthResponseDto)
+  @ApiResponse({ status: 409, description: 'Email already exists' })
+  async register(@Body() registerDto: RegisterDto): Promise<AuthResponseDto> {
+    return this.authService.register(registerDto);
+  }
+}

package/dist/templates/nestjs-app/src/modules/auth/{dto → core/dto}/auth-response.dto.ts

@@ -1,19 +1,19 @@
-import { ApiProperty } from '@nestjs/swagger';
-
-export class AuthResponseDto {
-  @ApiProperty()
-  access_token: string;
-
-  @ApiProperty()
-  user: {
-    id: number;
-    email: string;
-    first_name: string;
-    last_name: string;
-    position: {
-      id: number;
-      name: string;
-    };
-    permissions: string[];
-  };
-}
+import { ApiProperty } from '@nestjs/swagger';
+
+export class AuthResponseDto {
+  @ApiProperty()
+  access_token: string;
+
+  @ApiProperty()
+  user: {
+    id: number;
+    email: string;
+    first_name: string;
+    last_name: string;
+    position: {
+      id: number;
+      name: string;
+    };
+    permissions: string[];
+  };
+}

package/dist/templates/nestjs-app/src/modules/auth/core/dto/login-response.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { UserResponseDto } from '@modules/users/core/dto/user-response.dto';
+
+export class LoginResponseDto {
+  @ApiProperty()
+  access_token: string;
+
+  @ApiProperty()
+  user: UserResponseDto;
+}

package/dist/templates/nestjs-app/src/modules/auth/{dto → core/dto}/login.dto.ts

@@ -1,15 +1,15 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { IsEmail, IsNotEmpty, IsString, MinLength } from 'class-validator';
-
-export class LoginDto {
-  @ApiProperty({ example: 'admin@urbansolv.co.id' })
-  @IsEmail({}, { message: 'Please provide a valid email address' })
-  @IsNotEmpty({ message: 'Email is required' })
-  email: string;
-
-  @ApiProperty({ example: 'password123' })
-  @IsString()
-  @IsNotEmpty({ message: 'Password is required' })
-  @MinLength(6, { message: 'Password must be at least 6 characters long' })
-  password: string;
-}
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEmail, IsNotEmpty, IsString, MinLength } from 'class-validator';
+
+export class LoginDto {
+  @ApiProperty({ example: 'admin@urbansolv.co.id' })
+  @IsEmail({}, { message: 'Please provide a valid email address' })
+  @IsNotEmpty({ message: 'Email is required' })
+  email: string;
+
+  @ApiProperty({ example: 'password123' })
+  @IsString()
+  @IsNotEmpty({ message: 'Password is required' })
+  @MinLength(6, { message: 'Password must be at least 6 characters long' })
+  password: string;
+}

package/dist/templates/nestjs-app/src/modules/auth/{dto → core/dto}/register.dto.ts

@@ -1,30 +1,30 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { IsEmail, IsNotEmpty, IsString, MinLength, IsInt } from 'class-validator';
-
-export class RegisterDto {
-  @ApiProperty({ example: 'bhagaskoro@urbansolv.co.id' })
-  @IsEmail({}, { message: 'Please provide a valid email address' })
-  @IsNotEmpty({ message: 'Email is required' })
-  email: string;
-
-  @ApiProperty({ example: 'password123' })
-  @IsString()
-  @IsNotEmpty({ message: 'Password is required' })
-  @MinLength(6, { message: 'Password must be at least 6 characters long' })
-  password: string;
-
-  @ApiProperty({ example: 'Bhagas' })
-  @IsString()
-  @IsNotEmpty({ message: 'First name is required' })
-  first_name: string;
-
-  @ApiProperty({ example: 'Koro' })
-  @IsString()
-  @IsNotEmpty({ message: 'Last name is required' })
-  last_name: string;
-
-  @ApiProperty({ example: 2, description: 'Position ID' })
-  @IsInt({ message: 'Position ID must be an integer' })
-  @IsNotEmpty({ message: 'Position ID is required' })
-  position_id: number;
-}
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEmail, IsNotEmpty, IsString, MinLength, IsInt } from 'class-validator';
+
+export class RegisterDto {
+  @ApiProperty({ example: 'bhagaskoro@urbansolv.co.id' })
+  @IsEmail({}, { message: 'Please provide a valid email address' })
+  @IsNotEmpty({ message: 'Email is required' })
+  email: string;
+
+  @ApiProperty({ example: 'password123' })
+  @IsString()
+  @IsNotEmpty({ message: 'Password is required' })
+  @MinLength(6, { message: 'Password must be at least 6 characters long' })
+  password: string;
+
+  @ApiProperty({ example: 'Bhagas' })
+  @IsString()
+  @IsNotEmpty({ message: 'First name is required' })
+  first_name: string;
+
+  @ApiProperty({ example: 'Koro' })
+  @IsString()
+  @IsNotEmpty({ message: 'Last name is required' })
+  last_name: string;
+
+  @ApiProperty({ example: 2, description: 'Position ID' })
+  @IsInt({ message: 'Position ID must be an integer' })
+  @IsNotEmpty({ message: 'Position ID is required' })
+  position_id: number;
+}

package/dist/templates/nestjs-app/src/modules/auth/{interfaces → core/interfaces}/jwt-payload.interface.ts

@@ -1,7 +1,7 @@
-export interface JwtPayload {
-  userId: number;
-  email: string;
-  positionId: number;
-  positionName: string;
-  permissions: string[];
-}
+export interface JwtPayload {
+  userId: number;
+  email: string;
+  positionId: number;
+  positionName: string;
+  permissions: string[];
+}

package/dist/templates/nestjs-app/src/modules/auth/{strategies → core/strategies}/jwt.strategy.ts

@@ -1,54 +1,54 @@
-import { Injectable, UnauthorizedException } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { PassportStrategy } from '@nestjs/passport';
-import { ExtractJwt, Strategy } from 'passport-jwt';
-import { PrismaService } from '@common/prisma/prisma.service';
-import { JwtPayload } from '../interfaces/jwt-payload.interface';
-
-@Injectable()
-export class JwtStrategy extends PassportStrategy(Strategy) {
-  constructor(
-    private configService: ConfigService,
-    private prisma: PrismaService,
-  ) {
-    super({
-      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-      ignoreExpiration: false,
-      secretOrKey: configService.get<string>('jwt.secret'),
-    });
-  }
-
-  async validate(payload: JwtPayload): Promise<JwtPayload> {
-    const user = await this.prisma.user.findUnique({
-      where: { id: payload.userId },
-      include: {
-        position: {
-          include: {
-            position_permissions: {
-              include: {
-                permission: true,
-              },
-            },
-          },
-        },
-      },
-    });
-
-    if (!user || !user.is_active) {
-      throw new UnauthorizedException('User not found or inactive');
-    }
-
-    // Build permissions array from position
-    const permissions = user.position.position_permissions.map(
-      (pp) => pp.permission.name,
-    );
-
-    return {
-      userId: user.id,
-      email: user.email,
-      positionId: user.position.id,
-      positionName: user.position.name,
-      permissions,
-    };
-  }
-}
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { PrismaService } from '@common/prisma/prisma.service';
+import { JwtPayload } from '../interfaces/jwt-payload.interface';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(
+    private configService: ConfigService,
+    private prisma: PrismaService,
+  ) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get<string>('jwt.secret'),
+    });
+  }
+
+  async validate(payload: JwtPayload): Promise<JwtPayload> {
+    const user = await this.prisma.user.findUnique({
+      where: { id: payload.userId },
+      include: {
+        position: {
+          include: {
+            position_permissions: {
+              include: {
+                permission: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!user || !user.is_active) {
+      throw new UnauthorizedException('User not found or inactive');
+    }
+
+    // Build permissions array from position
+    const permissions = user.position.position_permissions.map(
+      (pp) => pp.permission.name,
+    );
+
+    return {
+      userId: user.id,
+      email: user.email,
+      positionId: user.position.id,
+      positionName: user.position.name,
+      permissions,
+    };
+  }
+}

package/dist/templates/nestjs-app/src/modules/health/health.controller.ts

@@ -1,29 +1,29 @@
-import { Controller, Get } from '@nestjs/common';
-import { ApiTags, ApiOperation } from '@nestjs/swagger';
-import { Public } from '@common/decorators/public.decorator';
-
-@ApiTags('Health')
-@Controller()
-export class HealthController {
-  @Public()
-  @Get('health')
-  @ApiOperation({ summary: 'Health check endpoint' })
-  health() {
-    return {
-      status: 'ok',
-      timestamp: new Date().toISOString(),
-      uptime: process.uptime(),
-      environment: process.env.NODE_ENV,
-    };
-  }
-
-  @Public()
-  @Get('ping')
-  @ApiOperation({ summary: 'Ping endpoint' })
-  ping() {
-    return {
-      message: 'pong',
-      timestamp: new Date().toISOString(),
-    };
-  }
-}
+import { Controller, Get } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { Public } from '@common/decorators/public.decorator';
+
+@ApiTags('Health')
+@Controller()
+export class HealthController {
+  @Public()
+  @Get('health')
+  @ApiOperation({ summary: 'Health check endpoint' })
+  health() {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+      environment: process.env.NODE_ENV,
+    };
+  }
+
+  @Public()
+  @Get('ping')
+  @ApiOperation({ summary: 'Ping endpoint' })
+  ping() {
+    return {
+      message: 'pong',
+      timestamp: new Date().toISOString(),
+    };
+  }
+}

package/dist/templates/nestjs-app/src/modules/health/health.module.ts

@@ -1,7 +1,7 @@
-import { Module } from '@nestjs/common';
-import { HealthController } from './health.controller';
-
-@Module({
-  controllers: [HealthController],
-})
-export class HealthModule {}
+import { Module } from '@nestjs/common';
+import { HealthController } from './health.controller';
+
+@Module({
+  controllers: [HealthController],
+})
+export class HealthModule {}