@kuldi/create-nestjs 1.0.1 → 1.1.0

package/template/src/common/filters/http-exception.filter.ts

@@ -0,0 +1,54 @@
+import { ApiResponseDto } from '@common/dto/api-response.dto';
+import { Response } from 'express';
+import {
+  Catch,
+  Logger,
+  HttpStatus,
+  ArgumentsHost,
+  HttpException,
+  ExceptionFilter,
+} from '@nestjs/common';
+
+@Catch()
+export class HttpExceptionFilter implements ExceptionFilter {
+  private readonly logger = new Logger(HttpExceptionFilter.name);
+
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    let status = HttpStatus.INTERNAL_SERVER_ERROR;
+    let message = 'Internal server error';
+    let errors: any = null;
+
+    if (exception instanceof HttpException) {
+      status = exception.getStatus();
+      const exceptionResponse = exception.getResponse();
+
+      if (typeof exceptionResponse === 'object' && exceptionResponse !== null) {
+        message = (exceptionResponse as any).message || exception.message;
+        errors = (exceptionResponse as any).errors || null;
+      } else {
+        message = exceptionResponse as string;
+      }
+    } else if (exception instanceof Error) {
+      message = exception.message;
+    }
+
+    // Log error for monitoring
+    this.logger.error(
+      `${request.method} ${request.url} - Status: ${status} - Message: ${message}`,
+      exception instanceof Error ? exception.stack : undefined,
+    );
+
+    const errorResponse: ApiResponseDto<null> = {
+      statusCode: status,
+      message,
+      data: null,
+      errors,
+    };
+
+    response.status(status).json(errorResponse);
+  }
+}

package/template/src/common/guards/jwt-auth.guard.ts

@@ -0,0 +1,32 @@
+import { ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
+import { IS_PUBLIC_KEY } from '@common/decorators/public.decorator';
+import { AuthGuard } from '@nestjs/passport';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {
+  constructor(private reflector: Reflector) {
+    super();
+  }
+
+  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    if (isPublic) {
+      return true;
+    }
+
+    return super.canActivate(context);
+  }
+
+  handleRequest(err: any, user: any, info: any) {
+    if (err || !user) {
+      throw err || new UnauthorizedException('Invalid or expired token');
+    }
+    return user;
+  }
+}

package/template/src/common/guards/permissions.guard.ts

@@ -0,0 +1,53 @@
+import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from '@nestjs/common';
+import { JwtPayload } from '@modules/auth/core/interfaces/jwt-payload.interface';
+import { PERMISSIONS_KEY } from '@common/decorators/permissions.decorator';
+import { IS_PUBLIC_KEY } from '@common/decorators/public.decorator';
+import { Reflector } from '@nestjs/core';
+
+@Injectable()
+export class PermissionsGuard implements CanActivate {
+  constructor(private reflector: Reflector) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    // Check if route is public
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    if (isPublic) {
+      return true;
+    }
+
+    // Get required permissions from decorator
+    const requiredPermissions = this.reflector.getAllAndOverride<string[]>(PERMISSIONS_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    if (!requiredPermissions || requiredPermissions.length === 0) {
+      return true;
+    }
+
+    // Get user from request
+    const request = context.switchToHttp().getRequest();
+    const user: JwtPayload = request.user;
+
+    if (!user) {
+      throw new ForbiddenException('User not authenticated');
+    }
+
+    // Check if user has required permissions
+    const hasPermission = requiredPermissions.every((permission) =>
+      user.permissions.includes(permission),
+    );
+
+    if (!hasPermission) {
+      throw new ForbiddenException(
+        `You do not have the required permissions: ${requiredPermissions.join(', ')}`,
+      );
+    }
+
+    return true;
+  }
+}

package/template/src/common/helpers/function/error-helper.ts

@@ -0,0 +1,35 @@
+import { Prisma } from '@prisma/client';
+
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  // Prisma known error
+  if (error instanceof Prisma.PrismaClientKnownRequestError) {
+    return (error as any).message;
+  }
+
+  // Prisma validation error
+  if (error instanceof Prisma.PrismaClientValidationError) {
+    return (error as any).message;
+  }
+
+  // String thrown
+  if (typeof error === 'string') {
+    return error;
+  }
+
+  // Object with message
+  if (
+    typeof error === 'object' &&
+    error !== null &&
+    'message' in error &&
+    typeof (error as any).message === 'string'
+  ) {
+    return (error as any).message;
+  }
+
+  // Fallback
+  return 'Unexpected error occurred';
+}

package/template/src/common/interceptors/logging.interceptor.ts

@@ -0,0 +1,37 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler, Logger } from '@nestjs/common';
+import { tap } from 'rxjs/operators';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class LoggingInterceptor implements NestInterceptor {
+  private readonly logger = new Logger('HTTP');
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const request = context.switchToHttp().getRequest();
+    const { method, url, body, user } = request;
+    const now = Date.now();
+
+    const userId = user?.userId || 'anonymous';
+
+    this.logger.log(
+      `→ [${method}] ${url} - User: ${userId} ${
+        Object.keys(body || {}).length > 0 ? `- Body: ${JSON.stringify(body)}` : ''
+      }`,
+    );
+
+    return next.handle().pipe(
+      tap({
+        next: () => {
+          const responseTime = Date.now() - now;
+          this.logger.log(`← [${method}] ${url} - ${responseTime}ms - User: ${userId}`);
+        },
+        error: (error) => {
+          const responseTime = Date.now() - now;
+          this.logger.error(
+            `← [${method}] ${url} - ${responseTime}ms - User: ${userId} - Error: ${error.message}`,
+          );
+        },
+      }),
+    );
+  }
+}

package/template/src/common/interceptors/transform.interceptor.ts

@@ -0,0 +1,53 @@
+import { ApiResponseDto } from '@common/dto/api-response.dto';
+import { map } from 'rxjs/operators';
+import { Observable } from 'rxjs';
+import {
+  Injectable,
+  HttpStatus,
+  CallHandler,
+  NestInterceptor,
+  ExecutionContext,
+} from '@nestjs/common';
+
+@Injectable()
+export class TransformInterceptor<T> implements NestInterceptor<T, ApiResponseDto<T>> {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<ApiResponseDto<T>> {
+    const request = context.switchToHttp().getRequest();
+    const response = context.switchToHttp().getResponse();
+
+    return next.handle().pipe(
+      map((data) => {
+        // If data is already in ApiResponseDto format, return as is
+        if (data && typeof data === 'object' && 'statusCode' in data && 'message' in data) {
+          return data;
+        }
+
+        // Default success message based on HTTP method
+        let message = 'Operation successful';
+
+        switch (request.method) {
+          case 'POST':
+            message = 'Resource created successfully';
+            response.status(HttpStatus.CREATED);
+            break;
+          case 'PUT':
+          case 'PATCH':
+            message = 'Resource updated successfully';
+            break;
+          case 'DELETE':
+            message = 'Resource deleted successfully';
+            break;
+          case 'GET':
+            message = 'Data retrieved successfully';
+            break;
+        }
+
+        return {
+          statusCode: response.statusCode || HttpStatus.OK,
+          message,
+          data,
+        };
+      }),
+    );
+  }
+}

package/template/src/common/prisma/prisma.module.ts

@@ -0,0 +1,9 @@
+import { PrismaService } from './prisma.service';
+import { Global, Module } from '@nestjs/common';
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}

package/template/src/common/prisma/prisma.service.ts

@@ -0,0 +1,52 @@
+import { Injectable, OnModuleInit, OnModuleDestroy, Logger } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+import { PrismaPg } from '@prisma/adapter-pg';
+import { Pool } from 'pg';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(PrismaService.name);
+
+  constructor() {
+    const connectionString = process.env.DATABASE_URL;
+    const pool = new Pool({ connectionString });
+    const adapter = new PrismaPg(pool as any);
+
+    super({
+      adapter,
+      log: [
+        { level: 'error', emit: 'stdout' },
+        { level: 'warn', emit: 'stdout' },
+      ],
+    });
+  }
+
+  async onModuleInit() {
+    await this.$connect();
+    this.logger.log('✅ Database connected successfully');
+
+    // Log queries in development
+    if (process.env.NODE_ENV === 'development') {
+      // @ts-ignore
+      this.$on('query', (e) => {
+        this.logger.debug(`Query: ${e.query}`);
+        this.logger.debug(`Duration: ${e.duration}ms`);
+      });
+    }
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+    this.logger.log('Database disconnected');
+  }
+
+  async cleanDatabase() {
+    if (process.env.NODE_ENV === 'production') {
+      throw new Error('Cannot clean database in production');
+    }
+
+    const models = Reflect.ownKeys(this).filter((key) => key[0] !== '_');
+
+    return Promise.all(models.map((modelKey) => (this as any)[modelKey].deleteMany()));
+  }
+}

package/template/src/common/utils/password.util.ts

@@ -0,0 +1,13 @@
+import * as bcrypt from 'bcrypt';
+
+export class PasswordUtil {
+  private static readonly SALT_ROUNDS = 10;
+
+  static async hash(password: string): Promise<string> {
+    return bcrypt.hash(password, this.SALT_ROUNDS);
+  }
+
+  static async compare(password: string, hashedPassword: string): Promise<boolean> {
+    return bcrypt.compare(password, hashedPassword);
+  }
+}

package/template/src/config/app.config.ts

@@ -0,0 +1,10 @@
+import { registerAs } from '@nestjs/config';
+
+export default registerAs('app', () => ({
+  env: process.env.NODE_ENV || 'development',
+  port: parseInt(process.env.PORT, 10) || 3000,
+  name: process.env.APP_NAME,
+  apiPrefix: process.env.API_PREFIX || 'api',
+
+  corsOrigin: process.env.CORS_ORIGIN || '*',
+}));

package/template/src/config/database.config.ts

@@ -0,0 +1,5 @@
+import { registerAs } from '@nestjs/config';
+
+export default registerAs('database', () => ({
+  url: process.env.DATABASE_URL,
+}));

package/template/src/config/env.validation.ts

@@ -0,0 +1,30 @@
+import * as Joi from 'joi';
+
+export const validationSchema = Joi.object({
+  // Application
+  NODE_ENV: Joi.string()
+    .valid('development', 'production', 'test', 'staging')
+    .default('development'),
+  PORT: Joi.number().default(3000),
+  APP_NAME: Joi.string().required(),
+
+  // Database
+  DATABASE_URL: Joi.string().required(),
+
+  // JWT
+  JWT_SECRET: Joi.string().required(),
+  JWT_EXPIRATION: Joi.string().default('7d'),
+  JWT_REFRESH_SECRET: Joi.string().required(),
+  JWT_REFRESH_EXPIRATION: Joi.string().default('30d'),
+
+  // CORS
+  CORS_ORIGIN: Joi.string().default('*'),
+
+  // API
+  API_PREFIX: Joi.string().default('api'),
+
+
+  // Swagger
+  SWAGGER_ENABLED: Joi.boolean().default(true),
+  SWAGGER_PATH: Joi.string().default('api-docs'),
+});

package/template/src/config/jwt.config.ts

@@ -0,0 +1,8 @@
+import { registerAs } from '@nestjs/config';
+
+export default registerAs('jwt', () => ({
+  secret: process.env.JWT_SECRET,
+  expiresIn: process.env.JWT_EXPIRATION || '7d',
+  refreshSecret: process.env.JWT_REFRESH_SECRET,
+  refreshExpiresIn: process.env.JWT_REFRESH_EXPIRATION || '30d',
+}));

package/template/src/config/swagger.config.ts

@@ -0,0 +1,6 @@
+import { registerAs } from '@nestjs/config';
+
+export default registerAs('swagger', () => ({
+  enabled: process.env.SWAGGER_ENABLED === 'true',
+  path: process.env.SWAGGER_PATH || 'docs',
+}));

package/template/src/main.ts

@@ -0,0 +1,84 @@
+import { ValidationPipe, VersioningType, ClassSerializerInterceptor } from '@nestjs/common';
+import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
+import { NestFactory, Reflector } from '@nestjs/core';
+import { ConfigService } from '@nestjs/config';
+import cookieParser = require('cookie-parser');
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  const configService = app.get(ConfigService);
+
+  // Get configurations
+  const swaggerEnabled = configService.get<boolean>('swagger.enabled');
+  const corsOrigin = configService.get<string>('app.corsOrigin');
+  const swaggerPath = configService.get<string>('swagger.path');
+  const apiPrefix = configService.get<string>('app.apiPrefix');
+  const port = configService.get<number>('app.port');
+
+  // Enable CORS
+  app.enableCors({
+    origin: corsOrigin,
+    credentials: true,
+  });
+
+  app.use(cookieParser());
+
+  // Global prefix
+  app.setGlobalPrefix(apiPrefix);
+
+  // API Versioning
+  app.enableVersioning({
+    type: VersioningType.URI,
+    defaultVersion: '1',
+  });
+
+  // Global validation pipe
+  app.useGlobalPipes(
+    new ValidationPipe({
+      whitelist: true,
+      forbidNonWhitelisted: true,
+      transform: true,
+      transformOptions: {
+        enableImplicitConversion: true,
+      },
+    }),
+  );
+
+  // Class serializer for excluding fields (like password)
+  app.useGlobalInterceptors(new ClassSerializerInterceptor(app.get(Reflector)));
+
+  // Swagger Documentation
+  if (swaggerEnabled) {
+    const config = new DocumentBuilder()
+      .setTitle('Kuli Digital Standard API')
+      .setDescription('Kuli Digital NestJS Backend API Documentation')
+      .setVersion('1.0')
+      .addTag('Authentication', 'Authentication endpoints')
+      .addTag('Users', 'User management endpoints')
+      .addTag('Health', 'Health check endpoints')
+      .build();
+
+    const document = SwaggerModule.createDocument(app, config);
+    SwaggerModule.setup(swaggerPath, app, document, {
+      useGlobalPrefix: true,
+      swaggerOptions: {
+        persistAuthorization: true,
+        defaultModelsExpandDepth: -1,
+      },
+    });
+  }
+
+  await app.listen(port);
+
+  console.log(`\n🚀 Application is running on: http://localhost:${port}/`);
+  console.log(`🌍 Environment: ${configService.get<string>('app.env')}\n`);
+  if (swaggerEnabled) {
+    console.log(`📚 Swagger Documentaion on : http://localhost:${port}/api/${swaggerPath}`);
+  }
+  console.log(`📊 Health check: http://localhost:${port}/health`);
+  console.log(`🏓 Ping endpoint: http://localhost:${port}/ping\n`);
+}
+
+bootstrap();

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

@@ -0,0 +1,28 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { AuthService } from './auth.service';
+import { AuthController } from './controllers/v1/auth.controller';
+import { JwtStrategy } from './core/strategies/jwt.strategy';
+import type { StringValue } from 'ms';
+
+@Module({
+  imports: [
+    PassportModule.register({ defaultStrategy: 'jwt' }),
+    JwtModule.registerAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (configService: ConfigService) => ({
+        secret: configService.get<string>('jwt.secret'),
+        signOptions: {
+          expiresIn: configService.get('jwt.expiresIn', '7d') as StringValue,
+        },
+      }),
+    }),
+  ],
+  controllers: [AuthController],
+  providers: [AuthService, JwtStrategy],
+  exports: [JwtStrategy, PassportModule, JwtModule],
+})
+export class AuthModule {}