@kuldi/create-nestjs 1.0.1 → 1.1.1

package/template/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "nest-prisma-boilerplate",
+  "version": "1.0.0",
+  "description": "Kuli Digital NestJS Application",
+  "author": "Kuli Digital",
+  "private": true,
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf dist",
+    "copy-templates": "cp -r templates dist/",
+    "dev": "ts-node src/cli.ts",
+    "prepublishOnly": "npm run build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "echo \"No tests yet\" && exit 0",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "prisma:generate": "prisma generate",
+    "prisma:migrate": "prisma migrate dev",
+    "prisma:studio": "prisma studio",
+    "prisma:seed": "ts-node prisma/seeder/index.ts"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.1.27",
+    "@nestjs/config": "^4.0.4",
+    "@nestjs/core": "^11.1.27",
+    "@nestjs/jwt": "^11.0.2",
+    "@nestjs/passport": "^11.0.5",
+    "@nestjs/platform-express": "^11.1.27",
+    "@nestjs/swagger": "^11.4.4",
+    "@prisma/adapter-pg": "^7.8.0",
+    "@prisma/client": "^7.8.0",
+    "bcrypt": "^6.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.15.1",
+    "cookie-parser": "^1.4.7",
+    "joi": "^18.2.3",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1",
+    "pg": "^8.22.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^11.0.23",
+    "@nestjs/schematics": "^11.1.0",
+    "@nestjs/testing": "^11.1.27",
+    "@types/bcrypt": "^6.0.0",
+    "@types/cookie-parser": "^1.4.10",
+    "@types/express": "^5.0.6",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.0.1",
+    "@types/passport-jwt": "^4.0.1",
+    "@types/pg": "^8.20.0",
+    "@types/supertest": "^7.2.0",
+    "@typescript-eslint/eslint-plugin": "^8.62.0",
+    "@typescript-eslint/parser": "^8.62.0",
+    "eslint": "^10.5.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.6",
+    "jest": "^30.4.2",
+    "prettier": "^3.8.4",
+    "prisma": "^7.8.0",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.2.2",
+    "ts-jest": "^29.4.11",
+    "ts-loader": "^9.6.2",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^6.0.3"
+  },
+  "prisma": {
+    "seed": "ts-node prisma/seeder/index.ts"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/template/prisma/migrations/20260625045841_init/migration.sql

@@ -0,0 +1,73 @@
+-- CreateTable
+CREATE TABLE "users" (
+    "id" SERIAL NOT NULL,
+    "email" TEXT NOT NULL,
+    "password" TEXT NOT NULL,
+    "first_name" TEXT NOT NULL,
+    "last_name" TEXT NOT NULL,
+    "is_active" BOOLEAN NOT NULL DEFAULT true,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMP(3) NOT NULL,
+    "deleted_at" TIMESTAMP(3),
+    "position_id" INTEGER NOT NULL,
+
+    CONSTRAINT "users_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "positions" (
+    "id" SERIAL NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT,
+    "is_active" BOOLEAN NOT NULL DEFAULT true,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMP(3) NOT NULL,
+    "deleted_at" TIMESTAMP(3),
+
+    CONSTRAINT "positions_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "permissions" (
+    "id" SERIAL NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT,
+    "resource" TEXT NOT NULL,
+    "action" TEXT NOT NULL,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMP(3) NOT NULL,
+    "deleted_at" TIMESTAMP(3),
+
+    CONSTRAINT "permissions_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "position_permissions" (
+    "id" SERIAL NOT NULL,
+    "position_id" INTEGER NOT NULL,
+    "permission_id" INTEGER NOT NULL,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "position_permissions_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "users_email_key" ON "users"("email");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "positions_name_key" ON "positions"("name");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "permissions_name_key" ON "permissions"("name");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "position_permissions_position_id_permission_id_key" ON "position_permissions"("position_id", "permission_id");
+
+-- AddForeignKey
+ALTER TABLE "users" ADD CONSTRAINT "users_position_id_fkey" FOREIGN KEY ("position_id") REFERENCES "positions"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "position_permissions" ADD CONSTRAINT "position_permissions_position_id_fkey" FOREIGN KEY ("position_id") REFERENCES "positions"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "position_permissions" ADD CONSTRAINT "position_permissions_permission_id_fkey" FOREIGN KEY ("permission_id") REFERENCES "permissions"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/template/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "postgresql"

package/template/prisma/schema.prisma

@@ -0,0 +1,75 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+// ============================================
+// RBAC Schema
+// ============================================
+
+model User {
+  id         Int       @id @default(autoincrement())
+  email      String    @unique
+  password   String
+  first_name String
+  last_name  String
+  is_active  Boolean   @default(true)
+  created_at DateTime  @default(now())
+  updated_at DateTime  @updatedAt
+  deleted_at DateTime?
+
+  // Relations
+  position_id Int
+  position    Position @relation(fields: [position_id], references: [id])
+
+  @@map("users")
+}
+
+model Position {
+  id          Int       @id @default(autoincrement())
+  name        String    @unique
+  description String?
+  is_active   Boolean   @default(true)
+  created_at  DateTime  @default(now())
+  updated_at  DateTime  @updatedAt
+  deleted_at  DateTime?
+
+  // Relations
+  users                User[]
+  position_permissions PositionPermission[]
+
+  @@map("positions")
+}
+
+model Permission {
+  id          Int       @id @default(autoincrement())
+  name        String    @unique
+  description String?
+  resource    String // e.g., 'USER', 'TRANSACTION', 'REPORT'
+  action      String // e.g., 'VIEW', 'ADD', 'UPDATE', 'DELETE'
+  created_at  DateTime  @default(now())
+  updated_at  DateTime  @updatedAt
+  deleted_at  DateTime?
+
+  // Relations
+  position_permissions PositionPermission[]
+
+  @@map("permissions")
+}
+
+model PositionPermission {
+  id            Int      @id @default(autoincrement())
+  position_id   Int
+  permission_id Int
+  created_at    DateTime @default(now())
+
+  // Relations
+  position   Position   @relation(fields: [position_id], references: [id], onDelete: Cascade)
+  permission Permission @relation(fields: [permission_id], references: [id], onDelete: Cascade)
+
+  @@unique([position_id, permission_id])
+  @@map("position_permissions")
+}

package/template/prisma/seeder/data/permission.seed.ts

@@ -0,0 +1,67 @@
+import { PrismaClient } from '@prisma/client';
+
+export const seedPermissions = async (
+  prisma: PrismaClient,
+  adminPositionId: number,
+  memberPositionId: number,
+) => {
+  console.log('🔐 Seeding permissions...');
+
+  const permissionsData = [
+    // User Management
+    { name: 'VIEW_USER', resource: 'USER', action: 'VIEW', description: 'View user information' },
+    { name: 'ADD_USER', resource: 'USER', action: 'ADD', description: 'Create new user' },
+    { name: 'UPDATE_USER', resource: 'USER', action: 'UPDATE', description: 'Update user information' },
+    { name: 'DELETE_USER', resource: 'USER', action: 'DELETE', description: 'Delete user' },
+    { name: 'MANAGE_USER_PERMISSION', resource: 'USER', action: 'MANAGE_PERMISSION', description: 'Assign or revoke user permissions' },
+    { name: 'CHANGE_USER_POSITION', resource: 'USER', action: 'CHANGE_POSITION', description: 'Change user position/role' },
+
+    // Position Management
+    { name: 'VIEW_POSITION', resource: 'POSITION', action: 'VIEW', description: 'View position information' },
+    { name: 'ADD_POSITION', resource: 'POSITION', action: 'ADD', description: 'Create new position' },
+    { name: 'UPDATE_POSITION', resource: 'POSITION', action: 'UPDATE', description: 'Update position information' },
+    { name: 'DELETE_POSITION', resource: 'POSITION', action: 'DELETE', description: 'Delete position' },
+
+    // Permission Management
+    { name: 'VIEW_PERMISSION', resource: 'PERMISSION', action: 'VIEW', description: 'View permission information' },
+    { name: 'ADD_PERMISSION', resource: 'PERMISSION', action: 'ADD', description: 'Create new permission' },
+    { name: 'UPDATE_PERMISSION', resource: 'PERMISSION', action: 'UPDATE', description: 'Update permission information' },
+    { name: 'DELETE_PERMISSION', resource: 'PERMISSION', action: 'DELETE', description: 'Delete permission' },
+  ];
+
+  const permissions = await Promise.all(
+    permissionsData.map((permission) =>
+      prisma.permission.create({ data: permission }),
+    ),
+  );
+
+  console.log(`✅ ${permissions.length} permissions seeded`);
+
+  // ============================================
+  // Assign Permissions to Positions
+  // ============================================
+  console.log('🔗 Assigning permissions to positions...');
+
+  // Admin gets all permissions
+  const adminPermissions = permissions.map((permission) => ({
+    position_id: adminPositionId,
+    permission_id: permission.id,
+  }));
+
+  await prisma.positionPermission.createMany({
+    data: adminPermissions,
+  });
+
+  // Member gets only VIEW_USER permission
+  const viewUserPermission = permissions.find((p) => p.name === 'VIEW_USER');
+  if (viewUserPermission) {
+    await prisma.positionPermission.create({
+      data: {
+        position_id: memberPositionId,
+        permission_id: viewUserPermission.id,
+      },
+    });
+  }
+
+  console.log('✅ Permissions assigned to positions');
+};

package/template/prisma/seeder/data/position.seed.ts

@@ -0,0 +1,21 @@
+import { PrismaClient } from '@prisma/client';
+
+export const seedPositions = async (prisma: PrismaClient) => {
+  console.log('📋 Seeding positions...');
+  const adminPosition = await prisma.position.create({
+    data: {
+      name: 'Administrator',
+      description: 'Full system access with all permissions',
+    },
+  });
+
+  const memberPosition = await prisma.position.create({
+    data: {
+      name: 'Member',
+      description: 'Standard user with limited permissions',
+    },
+  });
+
+  console.log('✅ Positions seeded');
+  return { adminPosition, memberPosition };
+};

package/template/prisma/seeder/data/user.seed.ts

@@ -0,0 +1,39 @@
+import { PrismaClient } from '@prisma/client';
+import * as bcrypt from 'bcrypt';
+
+export const seedUsers = async (
+  prisma: PrismaClient,
+  adminPositionId: number,
+  memberPositionId: number,
+) => {
+  console.log('👥 Seeding users...');
+
+  const defaultPassword = 'password123';
+  const hashedPassword = await bcrypt.hash(defaultPassword, 10);
+
+  const adminUser = await prisma.user.create({
+    data: {
+      email: 'admin@kulidigital.com',
+      password: hashedPassword,
+      first_name: 'Admin',
+      last_name: 'Kuli Digital',
+      position_id: adminPositionId,
+      is_active: true,
+    },
+  });
+
+  const memberUser = await prisma.user.create({
+    data: {
+      email: 'member@kulidigital.com',
+      password: hashedPassword,
+      first_name: 'Member',
+      last_name: 'User',
+      position_id: memberPositionId,
+      is_active: true,
+    },
+  });
+
+  console.log('✅ Users seeded');
+
+  return { adminUser, memberUser, defaultPassword };
+};

package/template/prisma/seeder/index.ts

@@ -0,0 +1,56 @@
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+import { PrismaClient } from '@prisma/client';
+import { PrismaPg } from '@prisma/adapter-pg';
+import { Pool } from 'pg';
+import { seedPositions } from './data/position.seed';
+import { seedPermissions } from './data/permission.seed';
+import { seedUsers } from './data/user.seed';
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const adapter = new PrismaPg(pool as any);
+const prisma = new PrismaClient({ adapter });
+
+async function main() {
+  console.log('🌱 Starting database seeding...\n');
+
+  // Clear existing data
+  console.log('🗑️  Clearing existing data...');
+  await prisma.positionPermission.deleteMany();
+  await prisma.user.deleteMany();
+  await prisma.permission.deleteMany();
+  await prisma.position.deleteMany();
+
+  // Run seeders
+  const { adminPosition, memberPosition } = await seedPositions(prisma);
+  await seedPermissions(prisma, adminPosition.id, memberPosition.id);
+  const { adminUser, memberUser, defaultPassword } = await seedUsers(
+    prisma,
+    adminPosition.id,
+    memberPosition.id,
+  );
+
+  // Summary
+  console.log('\n✨ Database seeding completed!\n');
+  console.log('📊 Summary:');
+  console.log(`   - Positions: ${await prisma.position.count()}`);
+  console.log(`   - Permissions: ${await prisma.permission.count()}`);
+  console.log(`   - Users: ${await prisma.user.count()}`);
+  console.log(
+    `   - Position-Permission Links: ${await prisma.positionPermission.count()}\n`,
+  );
+
+  console.log('🔑 Default Users:');
+  console.log(`   Admin: ${adminUser.email} / ${defaultPassword}`);
+  console.log(`   Member: ${memberUser.email} / ${defaultPassword}\n`);
+}
+
+main()
+  .catch((e) => {
+    console.error('❌ Error seeding database:', e);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });

package/template/prisma.config.ts

@@ -0,0 +1,8 @@
+import 'dotenv/config';
+import { defineConfig, env } from '@prisma/config';
+
+export default defineConfig({
+  datasource: {
+    url: env('DATABASE_URL'),
+  },
+});

package/template/src/app.module.ts

@@ -0,0 +1,68 @@
+import { APP_GUARD, APP_FILTER, APP_INTERCEPTOR } from '@nestjs/core';
+import { validationSchema } from './config/env.validation';
+import databaseConfig from './config/database.config';
+import swaggerConfig from './config/swagger.config';
+import { ConfigModule } from '@nestjs/config';
+import appConfig from './config/app.config';
+import jwtConfig from './config/jwt.config';
+import { Module } from '@nestjs/common';
+
+// Common modules
+import { TransformInterceptor } from './common/interceptors/transform.interceptor';
+import { LoggingInterceptor } from './common/interceptors/logging.interceptor';
+import { HttpExceptionFilter } from './common/filters/http-exception.filter';
+import { PermissionsGuard } from './common/guards/permissions.guard';
+import { JwtAuthGuard } from './common/guards/jwt-auth.guard';
+import { PrismaModule } from './common/prisma/prisma.module';
+
+// Feature modules
+import { HealthModule } from './modules/health/health.module';
+import { UsersModule } from './modules/users/users.module';
+import { AuthModule } from './modules/auth/auth.module';
+
+@Module({
+  imports: [
+    // Configuration
+    ConfigModule.forRoot({
+      isGlobal: true,
+      validationSchema,
+      load: [appConfig, databaseConfig, jwtConfig, swaggerConfig],
+    }),
+
+    // Common modules
+    PrismaModule,
+
+    // Feature modules
+    AuthModule,
+    UsersModule,
+    HealthModule,
+  ],
+  providers: [
+    // Global guards
+    {
+      provide: APP_GUARD,
+      useClass: JwtAuthGuard,
+    },
+    {
+      provide: APP_GUARD,
+      useClass: PermissionsGuard,
+    },
+
+    // Global filters
+    {
+      provide: APP_FILTER,
+      useClass: HttpExceptionFilter,
+    },
+
+    // Global interceptors
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: LoggingInterceptor,
+    },
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: TransformInterceptor,
+    },
+  ],
+})
+export class AppModule {}

package/template/src/common/constants/permissions.constant.ts

@@ -0,0 +1,27 @@
+export const PERMISSIONS = {
+  // User Management
+  USER: {
+    VIEW: 'VIEW_USER',
+    ADD: 'ADD_USER',
+    UPDATE: 'UPDATE_USER',
+    DELETE: 'DELETE_USER',
+    MANAGE_PERMISSION: 'MANAGE_USER_PERMISSION',
+    CHANGE_POSITION: 'CHANGE_USER_POSITION',
+  },
+
+  // Position Management
+  POSITION: {
+    VIEW: 'VIEW_POSITION',
+    ADD: 'ADD_POSITION',
+    UPDATE: 'UPDATE_POSITION',
+    DELETE: 'DELETE_POSITION',
+  },
+
+  // Permission Management
+  PERMISSION: {
+    VIEW: 'VIEW_PERMISSION',
+    ADD: 'ADD_PERMISSION',
+    UPDATE: 'UPDATE_PERMISSION',
+    DELETE: 'DELETE_PERMISSION',
+  },
+} as const;

package/template/src/common/decorators/api-response.decorator.ts

@@ -0,0 +1,44 @@
+import { ApiExtraModels, ApiOkResponse, getSchemaPath } from '@nestjs/swagger';
+import { ApiResponseDto } from '@common/dto/api-response.dto';
+import { applyDecorators, Type } from '@nestjs/common';
+
+export const ApiSuccessResponse = <TModel extends Type<any>>(model: TModel) => {
+  return applyDecorators(
+    ApiExtraModels(ApiResponseDto, model),
+    ApiOkResponse({
+      schema: {
+        allOf: [
+          { $ref: getSchemaPath(ApiResponseDto) },
+          {
+            properties: {
+              data: {
+                $ref: getSchemaPath(model),
+              },
+            },
+          },
+        ],
+      },
+    }),
+  );
+};
+
+export const ApiSuccessArrayResponse = <TModel extends Type<any>>(model: TModel) => {
+  return applyDecorators(
+    ApiExtraModels(ApiResponseDto, model),
+    ApiOkResponse({
+      schema: {
+        allOf: [
+          { $ref: getSchemaPath(ApiResponseDto) },
+          {
+            properties: {
+              data: {
+                type: 'array',
+                items: { $ref: getSchemaPath(model) },
+              },
+            },
+          },
+        ],
+      },
+    }),
+  );
+};

package/template/src/common/decorators/get-user.decorator.ts

@@ -0,0 +1,11 @@
+import { JwtPayload } from '@modules/auth/core/interfaces/jwt-payload.interface';
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+export const GetUser = createParamDecorator(
+  (data: keyof JwtPayload | undefined, ctx: ExecutionContext): JwtPayload | any => {
+    const request = ctx.switchToHttp().getRequest();
+    const user = request.user;
+
+    return data ? user?.[data] : user;
+  },
+);

package/template/src/common/decorators/permissions.decorator.ts

@@ -0,0 +1,5 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const PERMISSIONS_KEY = 'permissions';
+export const Permissions = (...permissions: string[]) =>
+  SetMetadata(PERMISSIONS_KEY, permissions);

package/template/src/common/decorators/public.decorator.ts

@@ -0,0 +1,4 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const IS_PUBLIC_KEY = 'isPublic';
+export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);

package/template/src/common/dto/api-response.dto.ts

@@ -0,0 +1,15 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class ApiResponseDto<T = any> {
+  @ApiProperty({ example: 200 })
+  statusCode: number;
+
+  @ApiProperty({ example: 'Operation successful' })
+  message: string;
+
+  @ApiPropertyOptional()
+  data?: T;
+
+  @ApiPropertyOptional()
+  errors?: any;
+}

package/template/src/common/dto/pagination.dto.ts

@@ -0,0 +1,33 @@
+import { IsOptional, IsInt, Min, Max } from 'class-validator';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+
+export class PaginationDto {
+  @ApiPropertyOptional({ minimum: 1, default: 1 })
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @IsOptional()
+  page?: number = 1;
+
+  @ApiPropertyOptional({ minimum: 1, maximum: 100, default: 10 })
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  @IsOptional()
+  limit?: number = 10;
+}
+
+export class PaginatedResponseDto<T> {
+  @ApiPropertyOptional()
+  data: T[];
+
+  @ApiPropertyOptional()
+  meta: {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+  };
+}