@anmol0493/fullstack-app 1.0.0

package/backend-nestjs/src/app.controller.ts

@@ -0,0 +1,12 @@
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}

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

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+import { ConfigModule } from '@nestjs/config';
+import { CoreModule } from './core/core.module';
+import { IndexModule } from './module/index.module';
+
+@Module({
+  imports: [ConfigModule.forRoot({ isGlobal: true }), CoreModule, IndexModule],
+  controllers: [AppController],
+  providers: [AppService]
+})
+export class AppModule {}

package/backend-nestjs/src/app.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}

package/backend-nestjs/src/common/decorators/user.decorator.ts

@@ -0,0 +1,8 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+export const CurrentUser = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext) => {
+    const { user } = ctx.switchToHttp().getRequest();
+    return user;
+  }
+);

package/backend-nestjs/src/common/dtos/common.dto.ts

@@ -0,0 +1,87 @@
+import { Transform, Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsInt,
+  IsOptional,
+  IsString,
+  ValidateNested
+} from 'class-validator';
+
+export class ResponseDto {
+  @IsInt()
+  status_code: number;
+
+  @IsBoolean()
+  error: boolean;
+
+  @IsString()
+  message: string;
+
+  constructor(response: {
+    status_code: number;
+    error: boolean;
+    message: string;
+  }) {
+    this.status_code = response.status_code;
+    this.error = response.error;
+    this.message = response.message;
+  }
+}
+
+export class ResponseBaseDto<T> extends ResponseDto {
+  @Type(() => Object)
+  result: T;
+
+  constructor(response: {
+    status_code: number;
+    error: boolean;
+    message: string;
+    result: T;
+  }) {
+    super({
+      status_code: response.status_code,
+      error: response.error,
+      message: response.message
+    });
+    this.result = response.result;
+  }
+}
+
+export class ResponseBaseWithCountDto<T> extends ResponseDto {
+  @ValidateNested({ each: true })
+  @Type(() => Object)
+  result: {
+    data: T[];
+    count: number;
+  };
+
+  constructor(response: {
+    status_code: number;
+    error: boolean;
+    message: string;
+    result: {
+      data: T[];
+      count: number;
+    };
+  }) {
+    super({
+      status_code: response.status_code,
+      error: response.error,
+      message: response.message
+    });
+    this.result = response.result;
+  }
+}
+
+export class RequestQueryDto {
+  @IsOptional()
+  @Transform(({ value }) => (value ? Number(value) : undefined))
+  page?: number;
+
+  @IsOptional()
+  @Transform(({ value }) => (value ? Number(value) : undefined))
+  limit?: number;
+
+  @IsOptional()
+  search?: string;
+}

package/backend-nestjs/src/common/exceptions/custom.exception.ts

@@ -0,0 +1,28 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+import { ERROR_MSG } from 'src/common/utils/constants';
+
+export class ResourceNotFound extends HttpException {
+  constructor(resourceName: string, resourceId?: string) {
+    super(
+      resourceId
+        ? `${resourceName} with ${resourceId} not found`
+        : `${resourceName} not found`,
+      HttpStatus.NOT_FOUND
+    );
+  }
+}
+
+export class Unauthorized extends HttpException {
+  constructor() {
+    super(ERROR_MSG.UNAUTHORIZED, HttpStatus.UNAUTHORIZED);
+  }
+}
+
+export class CustomException extends HttpException {
+  constructor(
+    message: string = ERROR_MSG.INTERNAL_SERVER_ERROR,
+    status_code: HttpStatus = HttpStatus.BAD_REQUEST
+  ) {
+    super(message, status_code);
+  }
+}

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

@@ -0,0 +1,46 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus
+} from '@nestjs/common';
+import { Response } from 'express';
+import { ERROR_MSG } from 'src/common/utils/constants';
+
+@Catch()
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : HttpStatus.INTERNAL_SERVER_ERROR;
+    const message =
+      exception instanceof HttpException
+        ? exception.getResponse()
+        : ERROR_MSG.INTERNAL_SERVER_ERROR;
+
+    const errorResponse: any = {
+      status_code: status,
+      error: true,
+      message,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      method: request.method
+    };
+
+    if (process.env.NODE_ENV !== 'prod') {
+      console.error('🚨 Error Details:', exception);
+    }
+
+    return response.status(status).json({
+      status_code: status,
+      error: true,
+      message
+    });
+  }
+}

package/backend-nestjs/src/common/guard/permission.guard.ts

@@ -0,0 +1,18 @@
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { CustomException } from '../exceptions/custom.exception';
+import { ERROR_MSG } from '../utils/constants';
+
+@Injectable()
+export class CheckPermissionGuard implements CanActivate {
+  constructor(private readonly screen: string) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+
+    if (!user.permissions.some((p) => p.screen === this.screen && p.value))
+      throw new CustomException(ERROR_MSG.UNAUTHORIZED);
+
+    return true;
+  }
+}

package/backend-nestjs/src/common/middleware/auth.middleware.ts

@@ -0,0 +1,20 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { NextFunction } from 'express';
+import { Unauthorized } from '../exceptions/custom.exception';
+import { AuthService } from 'src/module/auth/auth.service';
+
+@Injectable()
+export class AuthMiddleware implements NestMiddleware {
+  constructor(private readonly authService: AuthService) {}
+  async use(req: Request, res: Response, next: NextFunction) {
+    const authHeader = req.headers['authorization'];
+    if (!authHeader) throw new Unauthorized();
+
+    const token = authHeader.split(' ')[1];
+    const user = await this.authService.verifyToken(token);
+    if (!user) throw new Unauthorized();
+
+    req['user'] = user;
+    next();
+  }
+}

package/backend-nestjs/src/common/pipes/validation.pipe.ts

@@ -0,0 +1,61 @@
+import { PipeTransform, Injectable, ArgumentMetadata } from '@nestjs/common';
+import { validate, ValidationError } from 'class-validator';
+import { plainToInstance } from 'class-transformer';
+import { CustomException } from '../exceptions/custom.exception';
+
+@Injectable()
+export class ValidationPipe implements PipeTransform<any> {
+  async transform(value: any, { metatype }: ArgumentMetadata) {
+    const trimmedValue = this.trimStrings(value);
+    if (!metatype || !this.toValidate(metatype)) return trimmedValue;
+
+    const object = plainToInstance(metatype, trimmedValue);
+    const errors = await validate(object, {
+      whitelist: true,
+      forbidNonWhitelisted: true
+    });
+
+    if (errors.length > 0) {
+      const errorMessage = this.formatErrors(errors);
+      throw new CustomException(errorMessage);
+    }
+
+    return object;
+  }
+
+  private trimStrings(value: any): any {
+    if (typeof value === 'string') {
+      return value.replace(/\s+/g, ' ').trim();
+    } else if (Array.isArray(value)) {
+      return value.map((item) => this.trimStrings(item));
+    } else if (value && typeof value === 'object' && value !== null) {
+      const trimmedObject: Record<string, any> = {};
+      for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          if (key === 'email')
+            trimmedObject[key] = this.trimStrings(value[key]).toLowerCase();
+          else trimmedObject[key] = this.trimStrings(value[key]);
+        }
+      }
+      return trimmedObject;
+    }
+    return value;
+  }
+
+  private toValidate(metatype: Function): boolean {
+    const types: Function[] = [String, Boolean, Number, Array, Object];
+    return !types.includes(metatype);
+  }
+
+  private formatErrors(errors: ValidationError[]): string {
+    return errors
+      .map((error) => {
+        if (error.constraints) {
+          return Object.values(error.constraints).join(', ');
+        } else if (error.children) {
+          return this.formatErrors(error.children);
+        }
+      })
+      .join(', ');
+  }
+}

package/backend-nestjs/src/common/utils/constants.ts

@@ -0,0 +1,36 @@
+export const REQ_ENV = ['JWT_SECRET', 'DATABASE_URL'];
+
+const MESSAGES = {
+  SUCCESS_MSG: {
+    REGISTERED: 'Registered successfully',
+    LOG_IN: 'Log in successfully',
+    LOGGED_OUT: 'Logged out successfully',
+
+    CREATED: 'Created successfully',
+    UPDATED: 'Updated successfully',
+    DELETED: 'Deleted successfully',
+    FETCHED: 'Fetched successfully'
+  },
+  ERROR_MSG: {
+    JSON_WEB_TOKEN_ERROR: 'JsonWebTokenError',
+    TOKEN_EXPIRED_ERROR: 'TokenExpiredError',
+    TOKEN_EXPIRED: 'Token has expired!',
+
+    EMAIL_EXISTS: 'Email already exists with another user',
+    INVALID_PASSWORD: 'Invalid password',
+    UNAUTHORIZED: 'Unauthorized',
+    FORBIDDEN: 'Forbidden',
+    INTERNAL_SERVER_ERROR: 'Internal server error',
+    INVALID_TOKEN: 'Token Expired'
+  }
+} as const;
+
+export const { SUCCESS_MSG, ERROR_MSG } = MESSAGES;
+
+export const RESOURCE_NAME = {
+  USER: 'User',
+};
+
+export const DEFAULT_LIMIT = {
+  
+}

package/backend-nestjs/src/common/utils/helper.ts

@@ -0,0 +1,43 @@
+import { HttpStatus } from '@nestjs/common';
+import bcrypt from 'bcrypt';
+
+export const encryptPassword = async (password: string): Promise<string> =>
+  await bcrypt.hash(password, 10);
+
+export const comparePassword = async (
+  password: string,
+  hash: string
+): Promise<boolean> => await bcrypt.compare(password, hash);
+
+export function checkEnvVariables(requiredEnvVars: string[]) {
+  requiredEnvVars.forEach((envVar) => {
+    if (!process.env[envVar]) {
+      console.error(
+        `\x1b[31mMissing required environment variable: ${envVar}\x1b[0m`
+      );
+      process.exit(1);
+    }
+  });
+}
+
+export const successResponse = <T>(message: string) =>
+  ({
+    status_code: HttpStatus.OK,
+    error: false,
+    message
+  }) as const;
+
+export const successResponseWithResult = <T>(message: string, result: T) =>
+  ({
+    status_code: HttpStatus.OK,
+    error: false,
+    message,
+    result
+  }) as const;
+
+export function formatResponse<T>(data: T[], count: number) {
+  return {
+    data,
+    count
+  } as const;
+}

package/backend-nestjs/src/core/core.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from './jwt/jwt.module';
+import { PrismaModule } from './prisma/prisma.module';
+
+@Module({
+  imports: [JwtModule, PrismaModule]
+})
+export class CoreModule {}

package/backend-nestjs/src/core/jwt/jwt.module.ts

@@ -0,0 +1,10 @@
+import { Global, Module } from '@nestjs/common';
+import { JwtService as JWTService } from '@nestjs/jwt';
+import { JwtService } from './jwt.service';
+
+@Global()
+@Module({
+  providers: [JWTService, JwtService],
+  exports: [JwtService]
+})
+export class JwtModule {}

package/backend-nestjs/src/core/jwt/jwt.service.ts

@@ -0,0 +1,45 @@
+import { HttpStatus, Injectable } from '@nestjs/common';
+import { JwtService as JWTService } from '@nestjs/jwt';
+import { CustomException } from 'src/common/exceptions/custom.exception';
+import { ERROR_MSG } from 'src/common/utils/constants';
+
+@Injectable()
+export class JwtService {
+  private readonly secret: string;
+  private readonly expiresIn: string;
+
+  constructor(private readonly jwtService: JWTService) {
+    const { JWT_SECRET, JWT_EXP_IN } = process.env;
+    this.secret = JWT_SECRET as string;
+    this.expiresIn = JWT_EXP_IN as string;
+  }
+
+  async signAsync(payload: any, expiresIn?: string): Promise<string> {
+    return this.jwtService.signAsync(payload, {
+      secret: this.secret,
+      expiresIn: expiresIn || this.expiresIn
+    });
+  }
+
+  async verifyAsync(token: string): Promise<any> {
+    try {
+      const decoded = await this.jwtService.verifyAsync(token, {
+        secret: this.secret
+      });
+
+      return decoded;
+    } catch (error) {
+      if (error.name === ERROR_MSG.TOKEN_EXPIRED_ERROR) {
+        throw new CustomException(
+          ERROR_MSG.TOKEN_EXPIRED,
+          HttpStatus.UNAUTHORIZED
+        );
+      } else {
+        throw new CustomException(
+          ERROR_MSG.UNAUTHORIZED,
+          HttpStatus.UNAUTHORIZED
+        );
+      }
+    }
+  }
+}

package/backend-nestjs/src/core/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/backend-nestjs/src/core/prisma/prisma.service.ts

@@ -0,0 +1,17 @@
+import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService
+  extends PrismaClient
+  implements OnModuleInit, OnModuleDestroy
+{
+  async onModuleInit() {
+    await this.$connect();
+    console.log('Connected to Prisma Client');
+  }
+
+  async onModuleDestroy() {
+    await this.$disconnect();
+  }
+}

package/backend-nestjs/src/core/prisma/schema.prisma

@@ -0,0 +1,27 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "mysql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id              Int             @id @default(autoincrement())
+  name            String
+  email           String          @unique
+  password        String
+  isDeleted       Boolean         @default(false)
+  createdAt       DateTime        @default(now())
+  updatedAt       DateTime        @updatedAt
+
+  @@index([email, createdAt])
+  @@map("users")
+}

package/backend-nestjs/src/main.ts

@@ -0,0 +1,26 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+import { ValidationPipe } from './common/pipes/validation.pipe';
+import { HttpExceptionFilter } from './common/filters/http-exception.filter';
+import { checkEnvVariables } from './common/utils/helper';
+import { REQ_ENV } from './common/utils/constants';
+
+async function bootstrap() {
+  checkEnvVariables(REQ_ENV);
+  const app = await NestFactory.create(AppModule);
+  app.enableCors({
+    origin: '*',
+    methods: 'GET,PUT,POST,PATCH,DELETE',
+    credentials: true
+  });
+
+  app.useGlobalPipes(new ValidationPipe());
+
+  app.useGlobalFilters(new HttpExceptionFilter());
+
+  const port = process.env.PORT ?? 5000;
+  await app.listen(port, () => {
+    console.log(`🚀 Server is listening on port ${port}`);
+  });
+}
+bootstrap();

package/backend-nestjs/src/module/auth/auth.controller.ts

@@ -0,0 +1,30 @@
+import { Body, Controller, Get, Post, Put } from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { LoginDto, RegisterDto, UpdateUserDto } from './dto';
+import { CurrentUser } from 'src/common/decorators/user.decorator';
+import { User } from '@prisma/client';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('register')
+  register(@Body() body: RegisterDto) {
+    return this.authService.register(body);
+  }
+
+  @Post('login')
+  login(@Body() body: LoginDto) {
+    return this.authService.login(body);
+  }
+
+  @Get('profile')
+  profile(@CurrentUser() user: Partial<User>) {
+    return this.authService.profile(user);
+  }
+
+  @Put('update')
+  update(@Body() body: UpdateUserDto, @CurrentUser() user: Partial<User>) {
+    return this.authService.update(body, user.id as number);
+  }
+}

package/backend-nestjs/src/module/auth/auth.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AuthController } from './auth.controller';
+import { AuthService } from './auth.service';
+
+@Module({
+  controllers: [AuthController],
+  providers: [AuthService],
+  exports: [AuthService]
+})
+export class AuthModule {}

package/backend-nestjs/src/module/auth/auth.service.ts

@@ -0,0 +1,83 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from 'src/core/prisma/prisma.service';
+import { LoginDto, LoginResDto, RegisterDto, UpdateUserDto } from './dto';
+import {
+  comparePassword,
+  encryptPassword,
+  successResponse,
+  successResponseWithResult
+} from 'src/common/utils/helper';
+import {
+  ERROR_MSG,
+  RESOURCE_NAME,
+  SUCCESS_MSG
+} from 'src/common/utils/constants';
+import {
+  CustomException,
+  ResourceNotFound
+} from 'src/common/exceptions/custom.exception';
+import { ResponseDto } from 'src/common/dtos/common.dto';
+import { JwtService } from 'src/core/jwt/jwt.service';
+import { User } from '@prisma/client';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly jwtService: JwtService
+  ) {}
+
+  async register(body: RegisterDto): Promise<ResponseDto> {
+    const existingUser = await this.findByEmail(body.email);
+    if (existingUser) throw new CustomException(ERROR_MSG.EMAIL_EXISTS);
+
+    body.password = await encryptPassword(body.password);
+    await this.prisma.user.create({ data: body });
+
+    return successResponse(SUCCESS_MSG.REGISTERED);
+  }
+
+  async login(body: LoginDto): Promise<LoginResDto> {
+    const user = await this.findByEmail(body.email);
+    if (!user) throw new ResourceNotFound(RESOURCE_NAME.USER);
+
+    if (!(await comparePassword(body.password, user.password)))
+      throw new CustomException(ERROR_MSG.INVALID_PASSWORD);
+
+    const token = await this.jwtService.signAsync({ id: user.id });
+    return successResponseWithResult(SUCCESS_MSG.LOG_IN, { token });
+  }
+
+  profile(user: Partial<User>) {
+    return successResponseWithResult(SUCCESS_MSG.FETCHED, user);
+  }
+
+  async verifyToken(token: string): Promise<Partial<User>> {
+    const { id } = await this.jwtService.verifyAsync(token);
+    return this.findById(id);
+  }
+
+  async update(data: UpdateUserDto, id: number): Promise<ResponseDto> {
+    await this.findById(id);
+
+    const existingUser = await this.findByEmail(data.email);
+    if (existingUser && existingUser.id !== id)
+      throw new CustomException(ERROR_MSG.EMAIL_EXISTS);
+
+    await this.prisma.user.update({ where: { id }, data });
+    return successResponse(SUCCESS_MSG.UPDATED);
+  }
+
+  private async findById(id: number): Promise<Partial<User>> {
+    const user = await this.prisma.user.findUnique({
+      where: { id, isDeleted: false },
+      select: { id: true, name: true, email: true }
+    });
+    if (!user) throw new ResourceNotFound(RESOURCE_NAME.USER);
+    return user;
+  }
+
+  private async findByEmail(email: string): Promise<User | null> {
+    return this.prisma.user.findUnique({ where: { email } });
+  }
+}