@kuldi/create-nestjs 1.0.1 → 1.1.1

package/template/src/modules/users/core/dto/user-response.dto.ts

@@ -0,0 +1,32 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Exclude } from 'class-transformer';
+
+export class UserResponseDto {
+  @ApiProperty()
+  id: number;
+
+  @ApiProperty()
+  email: string;
+
+  @ApiProperty({ required: false })
+  first_name?: string;
+
+  @ApiProperty({ required: false })
+  last_name?: string;
+
+  @ApiProperty()
+  is_active: boolean;
+
+  @ApiProperty()
+  created_at: Date;
+
+  @ApiProperty()
+  updated_at: Date;
+
+  @Exclude()
+  password: string;
+
+  constructor(partial: Partial<UserResponseDto>) {
+    Object.assign(this, partial);
+  }
+}

package/template/src/modules/users/core/entities/user.entity.ts

@@ -0,0 +1,45 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { User as PrismaUser, Position } from '@prisma/client';
+import { Exclude } from 'class-transformer';
+
+export class UserEntity implements Partial<PrismaUser> {
+  @ApiProperty()
+  id: number;
+
+  @ApiProperty()
+  email: string;
+
+  @Exclude()
+  password: string;
+
+  @ApiProperty()
+  first_name: string;
+
+  @ApiProperty()
+  last_name: string;
+
+  @ApiProperty()
+  is_active: boolean;
+
+  @ApiProperty()
+  position_id: number;
+
+  @ApiPropertyOptional()
+  position?: Partial<Position>;
+
+  @ApiPropertyOptional()
+  permissions?: string[];
+
+  @ApiProperty()
+  created_at: Date;
+
+  @ApiProperty()
+  updated_at: Date;
+
+  @ApiPropertyOptional()
+  deleted_at: Date | null;
+
+  constructor(partial: Partial<UserEntity>) {
+    Object.assign(this, partial);
+  }
+}

package/template/src/modules/users/core/helpers/user-transform.helper.ts

@@ -0,0 +1,31 @@
+import { User, Position, PositionPermission, Permission } from '@prisma/client';
+import { UserEntity } from '../entities/user.entity';
+type UserWithRelations = User & {
+  position?: Position & {
+    position_permissions?: (PositionPermission & {
+      permission: Permission;
+    })[];
+  };
+};
+
+export class UserTransformHelper {
+  static toEntity(user: UserWithRelations): UserEntity {
+    const permissions = user.position?.position_permissions?.map(
+      (pp) => pp.permission.name,
+    ) || [];
+
+    return new UserEntity({
+      ...user,
+      permissions,
+      position: user.position ? {
+        id: user.position.id,
+        name: user.position.name,
+        description: user.position.description,
+      } : undefined,
+    });
+  }
+
+  static toEntities(users: UserWithRelations[]): UserEntity[] {
+    return users.map((user) => this.toEntity(user));
+  }
+}

package/template/src/modules/users/users.module.ts

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

package/template/src/modules/users/users.service.ts

@@ -0,0 +1,344 @@
+import {
+  Injectable,
+  NotFoundException,
+  ConflictException,
+  BadRequestException,
+} from '@nestjs/common';
+import { PrismaService } from '@common/prisma/prisma.service';
+import { PasswordUtil } from '@common/utils/password.util';
+import { CreateUserDto } from './core/dto/create-user.dto';
+import { UpdateUserDto } from './core/dto/update-user.dto';
+import { ChangePositionDto } from './core/dto/change-position.dto';
+import { ManagePermissionsDto } from './core/dto/manage-permissions.dto';
+import { UserQueryDto } from './core/dto/user-query.dto';
+import { UserEntity } from './core/entities/user.entity';
+import { UserTransformHelper } from './core/helpers/user-transform.helper';
+import { PaginatedResponseDto } from '@common/dto/pagination.dto';
+
+@Injectable()
+export class UsersService {
+  constructor(private prisma: PrismaService) {}
+
+  async create(createUserDto: CreateUserDto): Promise<UserEntity> {
+    const { email, password, position_id, ...userData } = createUserDto;
+
+    // Check if email 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 },
+    });
+
+    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,
+        position_id,
+        ...userData,
+      },
+      include: {
+        position: {
+          include: {
+            position_permissions: {
+              include: {
+                permission: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return UserTransformHelper.toEntity(user);
+  }
+
+  async findAll(query: UserQueryDto): Promise<PaginatedResponseDto<UserEntity>> {
+    const { page = 1, limit = 10, search, is_active, position_id } = query;
+    const skip = (page - 1) * limit;
+
+    const where: any = {
+      deleted_at: null,
+    };
+
+    if (search) {
+      where.OR = [
+        { first_name: { contains: search, mode: 'insensitive' } },
+        { last_name: { contains: search, mode: 'insensitive' } },
+        { email: { contains: search, mode: 'insensitive' } },
+      ];
+    }
+
+    if (is_active !== undefined) {
+      where.is_active = is_active;
+    }
+
+    if (position_id) {
+      where.position_id = position_id;
+    }
+
+    const [users, total] = await Promise.all([
+      this.prisma.user.findMany({
+        where,
+        skip,
+        take: limit,
+        include: {
+          position: {
+            include: {
+              position_permissions: {
+                include: {
+                  permission: true,
+                },
+              },
+            },
+          },
+        },
+        orderBy: {
+          created_at: 'desc',
+        },
+      }),
+      this.prisma.user.count({ where }),
+    ]);
+
+    if (total === 0) {
+      throw new NotFoundException('No users found');
+    }
+
+    return {
+      data: UserTransformHelper.toEntities(users),
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  async findOne(id: number): Promise<UserEntity> {
+    const user = await this.prisma.user.findFirst({
+      where: { id, deleted_at: null },
+      include: {
+        position: {
+          include: {
+            position_permissions: {
+              include: {
+                permission: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!user) {
+      throw new NotFoundException(`User with ID ${id} not found`);
+    }
+
+    return UserTransformHelper.toEntity(user);
+  }
+
+  async update(id: number, updateUserDto: UpdateUserDto): Promise<UserEntity> {
+    const user = await this.prisma.user.findFirst({
+      where: { id, deleted_at: null },
+    });
+
+    if (!user) {
+      throw new NotFoundException(`User with ID ${id} not found`);
+    }
+
+    const { email, password, ...updateData } = updateUserDto;
+
+    // Check email uniqueness if changing email
+    if (email && email !== user.email) {
+      const existingUser = await this.prisma.user.findUnique({
+        where: { email },
+      });
+
+      if (existingUser) {
+        throw new ConflictException('Email already exists');
+      }
+    }
+
+    // Hash password if provided
+    let hashedPassword: string | undefined;
+    if (password) {
+      hashedPassword = await PasswordUtil.hash(password);
+    }
+
+    const updatedUser = await this.prisma.user.update({
+      where: { id },
+      data: {
+        ...updateData,
+        ...(email && { email }),
+        ...(hashedPassword && { password: hashedPassword }),
+      },
+      include: {
+        position: {
+          include: {
+            position_permissions: {
+              include: {
+                permission: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return UserTransformHelper.toEntity(updatedUser);
+  }
+
+  async remove(id: number): Promise<void> {
+    const user = await this.prisma.user.findFirst({
+      where: { id, deleted_at: null },
+    });
+
+    if (!user) {
+      throw new NotFoundException(`User with ID ${id} not found`);
+    }
+
+    // Soft delete
+    await this.prisma.user.update({
+      where: { id },
+      data: { deleted_at: new Date() },
+    });
+  }
+
+  async changePosition(id: number, changePositionDto: ChangePositionDto): Promise<UserEntity> {
+    const user = await this.prisma.user.findFirst({
+      where: { id, deleted_at: null },
+    });
+
+    if (!user) {
+      throw new NotFoundException(`User with ID ${id} not found`);
+    }
+
+    // Validate position exists
+    const position = await this.prisma.position.findUnique({
+      where: { id: changePositionDto.position_id },
+    });
+
+    if (!position) {
+      throw new BadRequestException('Invalid position ID');
+    }
+
+    const updatedUser = await this.prisma.user.update({
+      where: { id },
+      data: { position_id: changePositionDto.position_id },
+      include: {
+        position: {
+          include: {
+            position_permissions: {
+              include: {
+                permission: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return UserTransformHelper.toEntity(updatedUser);
+  }
+
+  async assignPermissions(
+    userId: number,
+    managePermissionsDto: ManagePermissionsDto,
+  ): Promise<UserEntity> {
+    const user = await this.prisma.user.findFirst({
+      where: { id: userId, deleted_at: null },
+      include: { position: true },
+    });
+
+    if (!user) {
+      throw new NotFoundException(`User with ID ${userId} not found`);
+    }
+
+    // Validate all permissions exist
+    const permissions = await this.prisma.permission.findMany({
+      where: { name: { in: managePermissionsDto.permissions } },
+    });
+
+    if (permissions.length !== managePermissionsDto.permissions.length) {
+      throw new BadRequestException('One or more permissions are invalid');
+    }
+
+    // Get current permissions for the position
+    const currentPermissions = await this.prisma.positionPermission.findMany({
+      where: { position_id: user.position_id },
+    });
+
+    const currentPermissionIds = currentPermissions.map((pp) => pp.permission_id);
+    const newPermissionIds = permissions.map((p) => p.id);
+
+    // Find permissions to add
+    const permissionsToAdd = newPermissionIds.filter(
+      (id) => !currentPermissionIds.includes(id),
+    );
+
+    // Add new permissions
+    if (permissionsToAdd.length > 0) {
+      await this.prisma.positionPermission.createMany({
+        data: permissionsToAdd.map((permission_id) => ({
+          position_id: user.position_id,
+          permission_id,
+        })),
+        skipDuplicates: true,
+      });
+    }
+
+    // Return updated user
+    return this.findOne(userId);
+  }
+
+  async revokePermissions(
+    userId: number,
+    managePermissionsDto: ManagePermissionsDto,
+  ): Promise<UserEntity> {
+    const user = await this.prisma.user.findFirst({
+      where: { id: userId, deleted_at: null },
+      include: { position: true },
+    });
+
+    if (!user) {
+      throw new NotFoundException(`User with ID ${userId} not found`);
+    }
+
+    // Validate all permissions exist
+    const permissions = await this.prisma.permission.findMany({
+      where: { name: { in: managePermissionsDto.permissions } },
+    });
+
+    if (permissions.length !== managePermissionsDto.permissions.length) {
+      throw new BadRequestException('One or more permissions are invalid');
+    }
+
+    const permissionIds = permissions.map((p) => p.id);
+
+    // Remove permissions
+    await this.prisma.positionPermission.deleteMany({
+      where: {
+        position_id: user.position_id,
+        permission_id: { in: permissionIds },
+      },
+    });
+
+    // Return updated user
+    return this.findOne(userId);
+  }
+}

package/template/test/app.e2e-spec.ts

@@ -0,0 +1,40 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import * as request from 'supertest';
+import { AppModule } from './../src/app.module';
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('/health (GET)', () => {
+    return request(app.getHttpServer())
+      .get('/health')
+      .expect(200)
+      .expect((res) => {
+        expect(res.body).toHaveProperty('status', 'ok');
+        expect(res.body).toHaveProperty('timestamp');
+      });
+  });
+
+  it('/ping (GET)', () => {
+    return request(app.getHttpServer())
+      .get('/ping')
+      .expect(200)
+      .expect((res) => {
+        expect(res.body).toHaveProperty('message', 'pong');
+      });
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+});

package/template/test/jest-e2e.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-node/register"
+  }
+}

package/template/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "src",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "paths": {
+      "@common/*": ["src/common/*"],
+      "@config/*": ["src/config/*"],
+      "@modules/*": ["src/modules/*"]
+    },
+    "ignoreDeprecations": "6.0"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/bin/cli.js

@@ -1,71 +0,0 @@
-#!/usr/bin/env node
-
-const { execSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-const projectName = process.argv[2];
-
-if (!projectName) {
-  console.error('\n❌ Tolong masukkan nama project!');
-  console.error('Contoh: npm create @kuldi/nestjs my-app');
-  console.error('Atau gunakan "." untuk install di folder saat ini: npm create @kuldi/nestjs .\n');
-  process.exit(1);
-}
-
-// Menangani jika user menggunakan titik (.) untuk current directory
-const currentPath = process.cwd();
-const projectPath = projectName === '.' ? currentPath : path.join(currentPath, projectName);
-const gitRepo = 'https://github.com/bhagaskuro/boilerplate-nestJs.git';
-
-try {
-  // Mengecek apakah target directory kosong (jika menggunakan .)
-  if (projectName === '.') {
-    const files = fs.readdirSync(currentPath);
-    if (files.length > 0) {
-      console.error('\n❌ Folder saat ini tidak kosong! Harap jalankan di folder kosong agar tidak menimpa file yang ada.\n');
-      process.exit(1);
-    }
-  }
-
-  console.log(`\n🚀 Mengunduh Kuli Digital NestJS Boilerplate ke ${projectPath}...`);
-  
-  // 1. Clone repository
-  // Gunakan git clone ke folder sementara jika current dir agar tidak tabrakan, 
-  // tapi berhubung git clone butuh folder kosong, aman.
-  execSync(`git clone --depth 1 ${gitRepo} "${projectPath}"`, { stdio: 'inherit' });
-
-  // 2. Masuk ke folder project
-  process.chdir(projectPath);
-
-  // 3. Hapus folder .git bawaan boilerplate
-  fs.rmSync(path.join(projectPath, '.git'), { recursive: true, force: true });
-  
-  // Hapus juga folder create-nestjs agar tidak mengotori project user akhir
-  const cliFolder = path.join(projectPath, 'create-nestjs');
-  if (fs.existsSync(cliFolder)) {
-    fs.rmSync(cliFolder, { recursive: true, force: true });
-  }
-  
-  // Inisialisasi ulang git baru
-  execSync('git init', { stdio: 'ignore' });
-
-  // 4. Install dependencies
-  console.log('\n📦 Meng-install dependencies (ini butuh waktu beberapa menit)...');
-  execSync('npm install', { stdio: 'inherit' });
-
-  console.log('\n✅ Project berhasil dibuat!');
-  
-  if (projectName !== '.') {
-    console.log(`\nLangkah selanjutnya:`);
-    console.log(`  cd ${projectName}`);
-    console.log(`  npm run start:dev\n`);
-  } else {
-    console.log(`\nLangkah selanjutnya:`);
-    console.log(`  npm run start:dev\n`);
-  }
-  
-} catch (error) {
-  console.error('\n❌ Gagal membuat project:', error.message);
-  process.exit(1);
-}