express-project-builder 1.0.0

package/dist/lib/src/middlewares/create_Auth_Gurad.js

@@ -0,0 +1,99 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates an authentication middleware file when authentication is enabled
+ * @param projectPath - Absolute path to the project root
+ * @param answers - User answers from CLI prompts
+ * @returns Promise that resolves when the auth guard file is created (if auth is enabled)
+ */
+export const create_Auth_Guard = async (projectPath, answers) => {
+    try {
+        if (answers.includeAuth) {
+            const authMiddlewareTemplate = `import { JwtPayload } from 'jsonwebtoken'
+import config from '../config'
+import AppError from '../errors/AppError'
+import { TUserRole } from '../interfaces/userRole_type'
+import catchAsync from '../utils/catchAsync'
+import { verifyToken } from '../utils/commonUtils'
+
+// initiate authentication route auth function
+const auth = (...rolesAndFlags: Array<TUserRole | boolean>) => {
+   // Check if the last argument is a boolean flag
+  let isIgnoreAuthentication = false;
+  if (typeof rolesAndFlags[rolesAndFlags.length - 1] === 'boolean') {
+    isIgnoreAuthentication = rolesAndFlags.pop() as boolean;
+  }
+  
+  // The remaining arguments are the required roles
+  const requiredRoles = rolesAndFlags as TUserRole[];
+  return catchAsync(async (req, res, next) => {
+    // Skip authentication if flag is set
+      if (isIgnoreAuthentication) {
+        return next();
+      }
+     // Extract token from Authorization header
+      const authHeader = req.headers.authorization;
+      if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        throw new AppError(401, 'UNAUTHORIZED', 'You are not authorized. No token provided.');
+      }
+      const token = authHeader.split(' ')[1];
+      
+    // Verify token
+      const decoded = verifyToken(token, config.jwt_access_token_secret as string);
+      const { user_id, role, iat } = decoded;
+
+     // Check if user exists (implementation depends on your user model)
+      // const user = await User.isUserStatusCheckFindBy_id(user_id);
+      // if (!user) {
+      //   throw new AppError(404, 'NOT_FOUND', 'User not found!');
+      // }
+      // Check if user is deleted
+      // if (user.isDeleted) {
+      //   throw new AppError(401, 'UNAUTHORIZED', 'This user has been deleted!');
+      // }
+      // Check if user is blocked
+      // if (user.status === 'blocked') {
+      //   throw new AppError(403, 'FORBIDDEN', 'This user is blocked!');
+      // }
+      // Check if user role matches
+      // if (user.role !== role) {
+      //   throw new AppError(403, 'FORBIDDEN', 'Invalid user role!');
+      // }
+      // Check if password was changed after token was issued
+      // if (user.passwordChangedAt) {
+      //   const isPasswordChanged = User.isJWTIssuedAtBeforePasswordChanged(
+      //     user.passwordChangedAt,
+      //     iat as number
+      //   );
+      //   if (isPasswordChanged) {
+      //     // Clear cache if needed
+      //     // delete_cache_from_RAM(user._id?.toString() as string);
+      //     throw new AppError(401, 'UNAUTHORIZED', 'Password has been changed. Please login again.');
+      //   }
+      // }
+
+     // Check if user has required role
+      if (requiredRoles.length > 0 && !requiredRoles.includes(role)) {
+        throw new AppError(403, 'FORBIDDEN', 'You do not have permission to perform this action.');
+      }
+    // Attach user to request object
+      req.user = decoded as JwtPayload;
+      next();
+      
+  })
+}
+export default auth
+`;
+            await createFile(path.join(projectPath, "src/app/middlewares", "auth.ts"), authMiddlewareTemplate);
+            // Success message with green checkmark and text
+            console.log(chalk.green("✅ Successfully created Auth_Guard file"));
+        }
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Auth_Guard file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Auth_Gurad.js.map

package/dist/lib/src/middlewares/create_Auth_Gurad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Auth_Gurad.js","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_Auth_Gurad.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,EACpC,WAAmB,EACnB,OAAiB,EACF,EAAE;IACjB,IAAI,CAAC;QACH,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YACxB,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EpC,CAAC;YAEI,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,EAAE,SAAS,CAAC,EACxD,sBAAsB,CACvB,CAAC;YAEF,gDAAgD;YAChD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,mCAAmC,CAAC,EAAE,GAAG,CAAC,CAAC;QACnE,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/middlewares/create_BigIntSerializer_Guard.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a BigInt serializer middleware file for handling BigInt values in JSON responses
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the BigInt serializer guard file is created
+ */
+export declare const create_BigIntSerializer_Guard: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_BigIntSerializer_Guard.d.ts.map

package/dist/lib/src/middlewares/create_BigIntSerializer_Guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_BigIntSerializer_Guard.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_BigIntSerializer_Guard.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GACxC,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CA+Dd,CAAC"}

package/dist/lib/src/middlewares/create_BigIntSerializer_Guard.js

@@ -0,0 +1,64 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates a BigInt serializer middleware file for handling BigInt values in JSON responses
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the BigInt serializer guard file is created
+ */
+export const create_BigIntSerializer_Guard = async (projectPath) => {
+    try {
+        const bigIntSerializerMiddlewareTemplate = `/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Request, Response, NextFunction } from 'express';
+
+/**
+ * BigInt serializer middleware for JSON responses
+ * Handles BigInt values by converting them to strings during JSON serialization
+ * This prevents errors when BigInt values are included in response bodies
+ * 
+ * @param req - Express Request object
+ * @param res - Express Response object
+ * @param next - Express NextFunction
+ */
+export function bigIntSerializer(
+  req: Request,
+  res: Response,
+  next: NextFunction
+): void {
+  // Store the original json method
+  const originalJson = res.json;
+  
+  // Override the json method
+  res.json = function (body: any): Response {
+    // Define a replacer function to handle BigInt values
+    const replacer = (key: string, value: any): any => {
+      // Convert BigInt to string
+      if (typeof value === 'bigint') {
+        return value.toString();
+      }
+      // Return other values unchanged
+      return value;
+    };
+    
+    // Serialize the body with the replacer
+    const serializedBody = JSON.stringify(body, replacer);
+    
+    // Parse it back to an object and send it using the original method
+    return originalJson.call(this, JSON.parse(serializedBody));
+  };
+  
+  // Continue to the next middleware
+  next();
+}
+`;
+        await createFile(path.join(projectPath, "src/app/middlewares", "bigIntSerializer.ts"), bigIntSerializerMiddlewareTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ BigIntSerializer Guard file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating BigIntSerializer Guard file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_BigIntSerializer_Guard.js.map

package/dist/lib/src/middlewares/create_BigIntSerializer_Guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_BigIntSerializer_Guard.js","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_BigIntSerializer_Guard.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;GAIG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,KAAK,EAChD,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,kCAAkC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0C9C,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,EAAE,qBAAqB,CAAC,EACpE,kCAAkC,CACnC,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CAAC,oDAAoD,CAAC,CAClE,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CACX,KAAK,CAAC,GAAG,CAAC,+CAA+C,CAAC,EAC1D,GAAG,CACJ,CAAC;QACF,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/middlewares/create_FormDataToSetJSONformatData_Guard.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a middleware to parse JSON data from form data
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the form data to JSON format guard file is created
+ */
+export declare const create_formDataToSetJSONformatData_Guard: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_FormDataToSetJSONformatData_Guard.d.ts.map

package/dist/lib/src/middlewares/create_FormDataToSetJSONformatData_Guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_FormDataToSetJSONformatData_Guard.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_FormDataToSetJSONformatData_Guard.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,wCAAwC,GACnD,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CAoEd,CAAC"}

package/dist/lib/src/middlewares/create_FormDataToSetJSONformatData_Guard.js

@@ -0,0 +1,63 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates a middleware to parse JSON data from form data
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the form data to JSON format guard file is created
+ */
+export const create_formDataToSetJSONformatData_Guard = async (projectPath) => {
+    try {
+        const formDataToSetJSONformatDataMiddlewareTemplate = `import { NextFunction, Request, Response } from 'express';
+
+/**
+ * Middleware to parse JSON data from form data
+ * This middleware expects the request body to contain a 'data' field with a JSON string.
+ * It parses the JSON string and replaces req.body with the parsed object.
+ * 
+ * @param req - Express Request object
+ * @param res - Express Response object
+ * @param next - Express NextFunction
+ */
+const formData_ToSet_JSONformat_Data = (
+  req: Request,
+  res: Response,
+  next: NextFunction
+): void => {
+  try {
+    // Check if the data field exists in the request body
+    if (!req.body || !req.body.data) {
+      throw new Error('Missing required field: data');
+    }
+    
+    // Parse the JSON string from the data field
+    const parsedData = JSON.parse(req.body.data);
+    
+    // Replace the entire request body with the parsed data
+    req.body = parsedData;
+    
+    // Continue to the next middleware
+    next();
+  } catch (error) {
+    // Handle JSON parsing errors or missing data field
+    res.status(400).json({
+      success: false,
+      message: 'Invalid JSON data provided',
+      error: error instanceof Error ? error.message : 'Unknown error'
+    });
+  }
+};
+
+export default formData_ToSet_JSONformat_Data;
+`;
+        await createFile(path.join(projectPath, "src/app/middlewares", "formDataToSetJSONformatData.ts"), formDataToSetJSONformatDataMiddlewareTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Successfully created formDataToSetJSONformatData_Guard file"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating formDataToSetJSONformatData_Guard file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_FormDataToSetJSONformatData_Guard.js.map

package/dist/lib/src/middlewares/create_FormDataToSetJSONformatData_Guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_FormDataToSetJSONformatData_Guard.js","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_FormDataToSetJSONformatData_Guard.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;GAIG;AACH,MAAM,CAAC,MAAM,wCAAwC,GAAG,KAAK,EAC3D,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,6CAA6C,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCzD,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CACP,WAAW,EACX,qBAAqB,EACrB,gCAAgC,CACjC,EACD,6CAA6C,CAC9C,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CACT,+DAA+D,CAChE,CACF,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CACX,KAAK,CAAC,GAAG,CAAC,0DAA0D,CAAC,EACrE,GAAG,CACJ,CAAC;QACF,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/middlewares/create_Global_ErrorHandler_Guard.d.ts

@@ -0,0 +1,12 @@
+interface Answers {
+    database: "MongoDB with Mongoose" | "PostgreSQL with Prisma" | "None" | string;
+}
+/**
+ * Creates a global error handler middleware file based on the selected database
+ * @param projectPath - Absolute path to the project root
+ * @param answers - User answers from CLI prompts
+ * @returns Promise that resolves when the global error handler file is created
+ */
+export declare const create_Global_Error_Handler_Guard: (projectPath: string, answers: Answers) => Promise<void>;
+export {};
+//# sourceMappingURL=create_Global_ErrorHandler_Guard.d.ts.map

package/dist/lib/src/middlewares/create_Global_ErrorHandler_Guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Global_ErrorHandler_Guard.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_Global_ErrorHandler_Guard.ts"],"names":[],"mappings":"AAKA,UAAU,OAAO;IACf,QAAQ,EACJ,uBAAuB,GACvB,wBAAwB,GACxB,MAAM,GACN,MAAM,CAAC;CAEZ;AAED;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,GAC5C,aAAa,MAAM,EACnB,SAAS,OAAO,KACf,OAAO,CAAC,IAAI,CAiYd,CAAC"}

package/dist/lib/src/middlewares/create_Global_ErrorHandler_Guard.js

@@ -0,0 +1,375 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates a global error handler middleware file based on the selected database
+ * @param projectPath - Absolute path to the project root
+ * @param answers - User answers from CLI prompts
+ * @returns Promise that resolves when the global error handler file is created
+ */
+export const create_Global_Error_Handler_Guard = async (projectPath, answers) => {
+    try {
+        if (answers.database === "MongoDB with Mongoose") {
+            const globalErrorHandlerMiddlewareTemplate = `/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { NextFunction, Request, Response } from 'express'
+import { TErrorSource, TGenericErrorResponse } from '../interfaces/errors'
+import { ZodError } from 'zod'
+import handleZodValidationError from '../errors/handleZodValidationError'
+import handleMongooseValidationError from '../errors/handleMongooseValidationError'
+import handleMongooseCastError from '../errors/handleMongooseCastError'
+import handleMongooseDuplicateError from '../errors/handleMongooseDuplicateError'
+import AppError from '../errors/AppError'
+import {
+  removeSingleUploadedFile,
+  removeUploadedFiles
+} from '../utils/removeUploadedFiles'
+import config from '../config'
+
+/**
+ * Global error handler middleware for MongoDB with Mongoose
+ * Handles all types of errors and returns consistent error responses
+ */
+const globalErrorHandler = async (
+  err: any,
+  req: Request,
+  res: Response,
+  next: NextFunction
+): Promise<void> => {
+  // Initialize default error details
+  let statusCode: number = 500;
+  let message: string = 'Something went wrong';
+  let errorSources: TErrorSource[] = [
+    {
+      path: '',
+      message: 'Something went wrong'
+    }
+  ];
+
+  // Zod validation error handling
+  if (err instanceof ZodError) {
+    const simplifiedError: TGenericErrorResponse = handleZodValidationError(err);
+    statusCode = simplifiedError.statusCode;
+    message = simplifiedError.message;
+    errorSources = simplifiedError.errorSources;
+  }
+  // Mongoose validation error handling
+  else if (err.name === 'ValidationError') {
+    const simplifiedError: TGenericErrorResponse = handleMongooseValidationError(err);
+    statusCode = simplifiedError.statusCode;
+    message = simplifiedError.message;
+    errorSources = simplifiedError.errorSources;
+  }
+  // Mongoose cast error handling
+  else if (err.name === 'CastError') {
+    const simplifiedError: TGenericErrorResponse = handleMongooseCastError(err);
+    statusCode = simplifiedError.statusCode;
+    message = simplifiedError.message;
+    errorSources = simplifiedError.errorSources;
+  }
+  // Mongoose Duplicate error handling
+  else if (err.code === 11000) {
+    const simplifiedError: TGenericErrorResponse = handleMongooseDuplicateError(err);
+    statusCode = simplifiedError.statusCode;
+    message = simplifiedError.message;
+    errorSources = simplifiedError.errorSources;
+  }
+  // Custom AppError handling
+  else if (err instanceof AppError) {
+    statusCode = err.statusCode;
+    message = err.message;
+    errorSources = [
+      {
+        path: err.path || '',
+        message: err.message
+      }
+    ];
+  }
+  // Built-in error handling
+  else if (err instanceof Error) {
+    message = err.message;
+    errorSources = [
+      {
+        path: '',
+        message: err.message
+      }
+    ];
+  }
+
+  // Clean up uploaded files if they exist
+  try {
+    // Handle multiple files (req.files)
+    if (req.files) {
+      // Type assertion for files object with field names as keys
+      const files = req.files as { [fieldname: string]: Express.Multer.File[] };
+      await removeUploadedFiles(files);
+    }
+    
+    // Handle single file (req.file)
+    if (req.file) {
+      await removeSingleUploadedFile(req.file.path);
+    }
+  } catch (cleanupError) {
+    console.error('Error during file cleanup:', cleanupError);
+    // Don't throw the cleanup error, just log it
+  }
+
+  // Send error response
+  res.status(statusCode).json({
+    status: statusCode,
+    success: false,
+    message,
+    error: errorSources,
+    stack: config.NODE_ENV === 'development' ? err.stack : null
+  });
+};
+
+export default globalErrorHandler;
+`;
+            await createFile(path.join(projectPath, "src/app/middlewares", "globalErrorHandler.ts"), globalErrorHandlerMiddlewareTemplate);
+        }
+        if (answers.database === "PostgreSQL with Prisma") {
+            const globalErrorHandlerMiddlewareTemplate = `/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { NextFunction, Request, Response } from 'express'
+import {
+  PrismaClientKnownRequestError,
+  PrismaClientValidationError
+} from '@prisma/client/runtime/library'
+import { TErrorSource, TGenericErrorResponse } from '../interfaces/errors'
+import { ZodError } from 'zod'
+import handleZodValidationError from '../errors/handleZodValidationError'
+import handlePrismaValidationError from '../errors/handlePrismaValidationError'
+import handlePrismaCastError from '../errors/handlePrismaCastError'
+import handlePrismaDuplicateError from '../errors/handlePrismaDuplicateError'
+import AppError from '../errors/AppError'
+import {
+  removeSingleUploadedFile,
+  removeUploadedFiles
+} from '../utils/removeUploadedFiles'
+import config from '../config'
+
+/**
+ * Global error handler middleware for PostgreSQL with Prisma
+ * Handles all types of errors and returns consistent error responses
+ */
+const globalErrorHandler = async (
+  err: any,
+  req: Request,
+  res: Response,
+  next: NextFunction
+): Promise<void> => {
+  // Initialize default error details
+  let statusCode: number = 500
+  let message: string = 'Something went wrong'
+  let errorSources: TErrorSource[] = [
+    {
+      path: '',
+      message: 'Something went wrong'
+    }
+  ]
+
+  // Zod validation error handling
+  if (err instanceof ZodError) {
+    const simplifiedError: TGenericErrorResponse = handleZodValidationError(err)
+    statusCode = simplifiedError.statusCode
+    message = simplifiedError.message
+    errorSources = simplifiedError.errorSources
+  }
+  // Prisma validation error handling
+  else if (
+    err instanceof PrismaClientValidationError ||
+    (err instanceof PrismaClientKnownRequestError && err.code === 'P2018')
+  ) {
+    const simplifiedError: TGenericErrorResponse | null =
+      handlePrismaValidationError(err)
+    if (simplifiedError) {
+      statusCode = simplifiedError.statusCode
+      message = simplifiedError.message
+      errorSources = simplifiedError.errorSources
+    }
+  }
+  // Prisma cast error handling
+  else if (
+    err instanceof PrismaClientKnownRequestError &&
+    (err.code === 'P2023' || err.code === 'P2025')
+  ) {
+    const simplifiedError: TGenericErrorResponse | null =
+      handlePrismaCastError(err)
+    if (simplifiedError) {
+      statusCode = simplifiedError.statusCode
+      message = simplifiedError.message
+      errorSources = simplifiedError.errorSources
+    }
+  }
+  // Prisma Duplicate error handling
+  else if (
+    err instanceof PrismaClientKnownRequestError &&
+    err.code === 'P2002'
+  ) {
+    const simplifiedError: TGenericErrorResponse | null =
+      handlePrismaDuplicateError(err)
+    if (simplifiedError) {
+      statusCode = simplifiedError.statusCode
+      message = simplifiedError.message
+      errorSources = simplifiedError.errorSources
+    }
+  }
+  // Custom AppError handling
+  else if (err instanceof AppError) {
+    statusCode = err.statusCode
+    message = err.message
+    errorSources = [
+      {
+        path: err.path || '',
+        message: err.message
+      }
+    ]
+  }
+  // Built-in error handling
+  else if (err instanceof Error) {
+    message = err.message
+    errorSources = [
+      {
+        path: '',
+        message: err.message
+      }
+    ]
+  }
+
+  // Clean up uploaded files if they exist
+  try {
+    // Handle multiple files (req.files)
+    if (req.files) {
+      // Type assertion for files object with field names as keys
+      const files = req.files as { [fieldname: string]: Express.Multer.File[] }
+      await removeUploadedFiles(files)
+    }
+    // Handle single file (req.file)
+    if (req.file) {
+      await removeSingleUploadedFile(req.file.path)
+    }
+  } catch (cleanupError) {
+    console.error('Error during file cleanup:', cleanupError)
+    // Don't throw the cleanup error, just log it
+  }
+
+  // Send error response
+  res.status(statusCode).json({
+    status: statusCode,
+    success: false,
+    message,
+    error: errorSources,
+    stack: config.NODE_ENV === 'development' ? err.stack : null
+  })
+}
+
+export default globalErrorHandler
+`;
+            await createFile(path.join(projectPath, "src/app/middlewares", "globalErrorHandler.ts"), globalErrorHandlerMiddlewareTemplate);
+        }
+        if (answers.database === "None") {
+            const globalErrorHandlerMiddlewareTemplate = `/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { NextFunction, Request, Response } from 'express'
+import { TErrorSource, TGenericErrorResponse } from '../interfaces/errors'
+import { ZodError } from 'zod'
+import handleZodValidationError from '../errors/handleZodValidationError'
+import AppError from '../errors/AppError'
+import {
+  removeSingleUploadedFile,
+  removeUploadedFiles
+} from '../utils/removeUploadedFiles'
+import config from '../config'
+
+/**
+ * Global error handler middleware for applications without a database
+ * Handles all types of errors and returns consistent error responses
+ */
+const globalErrorHandler = async (
+  err: any,
+  req: Request,
+  res: Response,
+  next: NextFunction
+): Promise<void> => {
+  // Initialize default error details
+  let statusCode: number = 500;
+  let message: string = 'Something went wrong';
+  let errorSources: TErrorSource[] = [
+    {
+      path: '',
+      message: 'Something went wrong'
+    }
+  ];
+
+  // Zod validation error handling
+  if (err instanceof ZodError) {
+    const simplifiedError: TGenericErrorResponse = handleZodValidationError(err);
+    statusCode = simplifiedError.statusCode;
+    message = simplifiedError.message;
+    errorSources = simplifiedError.errorSources;
+  }
+  // Custom AppError handling
+  else if (err instanceof AppError) {
+    statusCode = err.statusCode;
+    message = err.message;
+    errorSources = [
+      {
+        path: err.path || '',
+        message: err.message
+      }
+    ];
+  }
+  // Built-in error handling
+  else if (err instanceof Error) {
+    message = err.message;
+    errorSources = [
+      {
+        path: '',
+        message: err.message
+      }
+    ];
+  }
+
+  // Clean up uploaded files if they exist
+  try {
+    // Handle multiple files (req.files)
+    if (req.files) {
+      // Type assertion for files object with field names as keys
+      const files = req.files as { [fieldname: string]: Express.Multer.File[] };
+      await removeUploadedFiles(files);
+    }
+    
+    // Handle single file (req.file)
+    if (req.file) {
+      await removeSingleUploadedFile(req.file.path);
+    }
+  } catch (cleanupError) {
+    console.error('Error during file cleanup:', cleanupError);
+    // Don't throw the cleanup error, just log it
+  }
+
+  // Send error response
+  res.status(statusCode).json({
+    status: statusCode,
+    success: false,
+    message,
+    error: errorSources,
+    stack: config.NODE_ENV === 'development' ? err.stack : null
+  });
+};
+
+export default globalErrorHandler;
+`;
+            await createFile(path.join(projectPath, "src/app/middlewares", "globalErrorHandler.ts"), globalErrorHandlerMiddlewareTemplate);
+        }
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Successfully created Global Error Handler Middleware file"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Global Error Handler Guard file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Global_ErrorHandler_Guard.js.map

package/dist/lib/src/middlewares/create_Global_ErrorHandler_Guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Global_ErrorHandler_Guard.js","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_Global_ErrorHandler_Guard.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAY1B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,KAAK,EACpD,WAAmB,EACnB,OAAgB,EACD,EAAE;IACjB,IAAI,CAAC;QACH,IAAI,OAAO,CAAC,QAAQ,KAAK,uBAAuB,EAAE,CAAC;YACjD,MAAM,oCAAoC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmHlD,CAAC;YAEI,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,EAAE,uBAAuB,CAAC,EACtE,oCAAoC,CACrC,CAAC;QACJ,CAAC;QAED,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAwB,EAAE,CAAC;YAClD,MAAM,oCAAoC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwIlD,CAAC;YAEI,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,EAAE,uBAAuB,CAAC,EACtE,oCAAoC,CACrC,CAAC;QACJ,CAAC;QAED,IAAI,OAAO,CAAC,QAAQ,KAAK,MAAM,EAAE,CAAC;YAChC,MAAM,oCAAoC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2FlD,CAAC;YAEI,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,EAAE,uBAAuB,CAAC,EACtE,oCAAoC,CACrC,CAAC;QACJ,CAAC;QAED,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CACT,6DAA6D,CAC9D,CACF,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CACX,KAAK,CAAC,GAAG,CAAC,mDAAmD,CAAC,EAC9D,GAAG,CACJ,CAAC;QACF,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/middlewares/create_Handle_File_Upload_Middleware.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a file upload middleware with dynamic field configuration
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the file upload middleware file is created
+ */
+export declare const create_Handle_File_Upload_Middleware: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_Handle_File_Upload_Middleware.d.ts.map

package/dist/lib/src/middlewares/create_Handle_File_Upload_Middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Handle_File_Upload_Middleware.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_Handle_File_Upload_Middleware.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,oCAAoC,GAC/C,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CAmQd,CAAC"}