@urbansolv/create-nestjs-app 1.2.4 → 1.2.7

package/templates/nestjs-app/src/app.module.ts

@@ -0,0 +1,68 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { APP_GUARD, APP_FILTER, APP_INTERCEPTOR } from '@nestjs/core';
+import { validationSchema } from './config/env.validation';
+import appConfig from './config/app.config';
+import databaseConfig from './config/database.config';
+import jwtConfig from './config/jwt.config';
+import swaggerConfig from './config/swagger.config';
+
+// Common modules
+import { PrismaModule } from './common/prisma/prisma.module';
+import { JwtAuthGuard } from './common/guards/jwt-auth.guard';
+import { PermissionsGuard } from './common/guards/permissions.guard';
+import { HttpExceptionFilter } from './common/filters/http-exception.filter';
+import { TransformInterceptor } from './common/interceptors/transform.interceptor';
+import { LoggingInterceptor } from './common/interceptors/logging.interceptor';
+
+// Feature modules
+import { AuthModule } from './modules/auth/auth.module';
+import { UsersModule } from './modules/users/users.module';
+import { HealthModule } from './modules/health/health.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/templates/nestjs-app/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/templates/nestjs-app/src/common/decorators/api-response.decorator.ts

@@ -0,0 +1,44 @@
+import { applyDecorators, Type } from '@nestjs/common';
+import { ApiExtraModels, ApiOkResponse, getSchemaPath } from '@nestjs/swagger';
+import { ApiResponseDto } from '@common/dto/api-response.dto';
+
+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/templates/nestjs-app/src/common/decorators/get-user.decorator.ts

@@ -0,0 +1,11 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { JwtPayload } from '@modules/auth/core/interfaces/jwt-payload.interface';
+
+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/templates/nestjs-app/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/templates/nestjs-app/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/templates/nestjs-app/src/common/dto/api-response.dto.ts

@@ -0,0 +1,21 @@
+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;
+
+  @ApiProperty({ example: '2026-01-01T00:00:00.000Z' })
+  timestamp: string;
+
+  @ApiProperty({ example: '/api/v1/users' })
+  path: string;
+}

package/templates/nestjs-app/src/common/dto/pagination.dto.ts

@@ -0,0 +1,33 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsOptional, IsInt, Min, Max } from 'class-validator';
+
+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;
+  };
+}

package/templates/nestjs-app/src/common/filters/http-exception.filter.ts

@@ -0,0 +1,56 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { Response } from 'express';
+import { ApiResponseDto } from '@common/dto/api-response.dto';
+
+@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,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+    };
+
+    response.status(status).json(errorResponse);
+  }
+}

package/templates/nestjs-app/src/common/guards/jwt-auth.guard.ts

@@ -0,0 +1,32 @@
+import { ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { AuthGuard } from '@nestjs/passport';
+import { IS_PUBLIC_KEY } from '@common/decorators/public.decorator';
+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/templates/nestjs-app/src/common/guards/permissions.guard.ts

@@ -0,0 +1,53 @@
+import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { PERMISSIONS_KEY } from '@common/decorators/permissions.decorator';
+import { IS_PUBLIC_KEY } from '@common/decorators/public.decorator';
+import { JwtPayload } from '@modules/auth/core/interfaces/jwt-payload.interface';
+
+@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/templates/nestjs-app/src/common/interceptors/logging.interceptor.ts

@@ -0,0 +1,37 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler, Logger } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
+
+@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/templates/nestjs-app/src/common/interceptors/transform.interceptor.ts

@@ -0,0 +1,55 @@
+import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+  HttpStatus,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ApiResponseDto } from '@common/dto/api-response.dto';
+
+@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,
+          timestamp: new Date().toISOString(),
+          path: request.url,
+        };
+      }),
+    );
+  }
+}

package/templates/nestjs-app/src/common/prisma/prisma.module.ts

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

package/templates/nestjs-app/src/common/prisma/prisma.service.ts

@@ -0,0 +1,45 @@
+import { Injectable, OnModuleInit, OnModuleDestroy, Logger } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(PrismaService.name);
+
+  constructor() {
+    super({
+      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/templates/nestjs-app/src/common/utils/password.util.ts

@@ -0,0 +1,13 @@
+import * as bcrypt from 'bcryptjs';
+
+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/templates/nestjs-app/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',
+  apiVersion: process.env.API_VERSION || 'v1',
+  corsOrigin: process.env.CORS_ORIGIN || '*',
+}));

package/templates/nestjs-app/src/config/database.config.ts

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

package/templates/nestjs-app/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'),
+  API_VERSION: Joi.string().default('v1'),
+
+  // Swagger
+  SWAGGER_ENABLED: Joi.boolean().default(true),
+  SWAGGER_PATH: Joi.string().default('api-docs'),
+});

package/templates/nestjs-app/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/templates/nestjs-app/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',
+}));