express-project-builder 1.0.0

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

@@ -0,0 +1,260 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * 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 const create_Handle_File_Upload_Middleware = async (projectPath) => {
+    try {
+        const handleFileUploadTemplate = `/* eslint-disable @typescript-eslint/no-explicit-any */
+import multer from 'multer';
+import path from 'path';
+import fs from 'fs/promises';
+import { Request, Response, NextFunction } from 'express';
+import AppError from '../errors/AppError';
+import { removeUploadedFiles } from '../utils/removeUploadedFiles';
+
+// Default constants
+const DEFAULT_MAX_IMAGE_SIZE = 5 * 1024 * 1024; // 5MB
+const DEFAULT_MAX_VIDEO_SIZE = 50 * 1024 * 1024; // 50MB
+
+// Default allowed file types
+const DEFAULT_ALLOWED_IMAGE_TYPES = [
+  'image/jpeg',
+  'image/png',
+  'image/gif',
+  'image/webp',
+  'image/bmp',
+  'image/svg+xml'
+];
+
+const DEFAULT_ALLOWED_VIDEO_TYPES = [
+  'video/mp4',
+  'video/webm',
+  'video/mov',
+  'video/avi',
+  'video/mkv'
+];
+
+// Helper function to ensure directory exists
+async function ensureDirectoryExists(dirPath: string): Promise<void> {
+  try {
+    await fs.access(dirPath);
+  } catch {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+}
+
+// Dynamic storage configuration
+const storage = multer.diskStorage({
+  destination: async (req: Request, file, cb) => {
+    let uploadPath: string;
+    
+    // Determine upload path based on file type
+    if (file.mimetype.startsWith('image/')) {
+      uploadPath = path.join(process.cwd(), 'uploads/images');
+    } else if (file.mimetype.startsWith('video/')) {
+      uploadPath = path.join(process.cwd(), 'uploads/videos');
+    } else {
+      return cb(new AppError(400, '', 'Invalid file type'), '');
+    }
+    
+    try {
+      await ensureDirectoryExists(uploadPath);
+      cb(null, uploadPath);
+    } catch (error: any) {
+      cb(error, '');
+    }
+  },
+  filename: (req: Request, file, cb) => {
+    const ext = path.extname(file.originalname);
+    const originalName = path.basename(file.originalname, ext);
+    // Use a more unique filename to avoid collisions
+    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
+    cb(null, \`\${originalName}-\${uniqueSuffix}\${ext}\`);
+  }
+});
+
+// Multer instance with global file size limit
+const upload = multer({
+  storage,
+  limits: { fileSize: DEFAULT_MAX_VIDEO_SIZE },
+  fileFilter: (req: Request, file, cb) => {
+    // Basic file type validation at the multer level
+    if (file.mimetype.startsWith('image/') || file.mimetype.startsWith('video/')) {
+      cb(null, true);
+    } else {
+      cb(new AppError(400, '', 'Invalid file type. Only images and videos are allowed.'));
+    }
+  }
+});
+
+// Field configuration interface
+interface FieldConfig {
+  fieldName: string;
+  fileType: 'image' | 'video';
+  maxCount?: number;
+  optional?: boolean;
+  maxImageSize?: number;
+  maxVideoSize?: number;
+  allowedImageTypes?: string[];
+  allowedVideoTypes?: string[];
+}
+
+// Main dynamic upload handler for multiple fields
+export const handle_file_upload_middleware = (
+  fieldConfigs: FieldConfig[],
+  globalOptions?: {
+    maxImageSize?: number;
+    maxVideoSize?: number;
+    allowedImageTypes?: string[];
+    allowedVideoTypes?: string[];
+  }
+) => {
+  // Set global defaults with options
+  const globalMaxImageSize = globalOptions?.maxImageSize || DEFAULT_MAX_IMAGE_SIZE;
+  const globalMaxVideoSize = globalOptions?.maxVideoSize || DEFAULT_MAX_VIDEO_SIZE;
+  const globalAllowedImageTypes = globalOptions?.allowedImageTypes || DEFAULT_ALLOWED_IMAGE_TYPES;
+  const globalAllowedVideoTypes = globalOptions?.allowedVideoTypes || DEFAULT_ALLOWED_VIDEO_TYPES;
+  
+  return (req: Request, res: Response, next: NextFunction) => {
+    // Prepare multer fields configuration
+    const multerFields = fieldConfigs.map(config => ({
+      name: config.fieldName,
+      maxCount: config.maxCount || 1
+    }));
+    
+    // Use multer's fields method to handle all dynamic fields
+    upload.fields(multerFields)(req, res, async (err: any) => {
+      if (err) {
+        // Handle multer errors
+        let errorMessage = '';
+        let fieldConfig: FieldConfig | undefined;
+        
+        if (err instanceof multer.MulterError) {
+          switch (err.code) {
+            case 'LIMIT_FILE_SIZE':
+              fieldConfig = fieldConfigs.find(f => f.fieldName === err.field);
+              errorMessage = \`File size exceeds maximum limit for \${err.field}\`;
+              break;
+            case 'LIMIT_FILE_COUNT':
+              fieldConfig = fieldConfigs.find(f => f.fieldName === err.field);
+              errorMessage = \`Too many files uploaded for \${err.field} (max \${fieldConfig?.maxCount || 1})\`;
+              break;
+            case 'LIMIT_UNEXPECTED_FILE':
+              fieldConfig = fieldConfigs.find(f => f.fieldName === err.field);
+              if (fieldConfig) {
+                errorMessage = \`Too many files uploaded for \${err.field} (max \${fieldConfig.maxCount || 1})\`;
+              } else {
+                errorMessage = \`Unexpected field name: \${err.field}\`;
+              }
+              break;
+            case 'LIMIT_FIELD_KEY':
+              errorMessage = 'Too many fields specified';
+              break;
+            case 'LIMIT_FIELD_VALUE':
+              errorMessage = 'Field value too long';
+              break;
+            case 'LIMIT_FIELD_COUNT':
+              errorMessage = 'Too many fields';
+              break;
+            case 'LIMIT_PART_COUNT':
+              errorMessage = 'Too many parts in form';
+              break;
+            default:
+              errorMessage = \`Upload error: \${err.message}\`;
+          }
+        } else {
+          errorMessage = err.message;
+        }
+        
+        return next(new AppError(400, fieldConfig?.fieldName || '', errorMessage));
+      }
+      
+      // Get uploaded files with proper typing
+      const files = req.files as { [fieldname: string]: Express.Multer.File[] } | undefined;
+      
+      try {
+        // Check for required fields
+        for (const config of fieldConfigs) {
+          if (
+            !config.optional &&
+            (!files ||
+              !files[config.fieldName] ||
+              files[config.fieldName].length === 0)
+          ) {
+            throw new AppError(
+              400,
+              config.fieldName,
+              \`\${config.fieldName} file field is required\`
+            );
+          }
+        }
+        
+        // Validate each file in each field
+        for (const config of fieldConfigs) {
+          const fieldFiles = files?.[config.fieldName] || [];
+          
+          // Determine the max size for this field
+          const maxSize = config.fileType === 'image' 
+            ? (config.maxImageSize || globalMaxImageSize)
+            : (config.maxVideoSize || globalMaxVideoSize);
+          
+          // Determine allowed types for this field
+          const allowedTypes = config.fileType === 'image'
+            ? (config.allowedImageTypes || globalAllowedImageTypes)
+            : (config.allowedVideoTypes || globalAllowedVideoTypes);
+          
+          for (const file of fieldFiles) {
+            // Validate file type
+            if (!allowedTypes.includes(file.mimetype)) {
+              // Create a user-friendly list of allowed extensions
+              const allowedExtensions = allowedTypes.map(type => {
+                const parts = type.split('/');
+                return parts[1] || type;
+              }).join(', ');
+              
+              throw new AppError(
+                400,
+                config.fieldName,
+                \`Invalid file type for \${config.fieldName}. Only \${allowedExtensions} files are allowed\`
+              );
+            }
+            
+            // Validate file size
+            if (file.size > maxSize) {
+              throw new AppError(
+                400,
+                config.fieldName,
+                \`File size exceeds maximum limit for \${config.fieldName} (\${maxSize / (1024 * 1024)}MB)\`
+              );
+            }
+          }
+        }
+        
+        // If validation passes, proceed to next middleware
+        next();
+      } catch (validationError) {
+        // Clean up all uploaded files on validation error
+        if (files) {
+          await removeUploadedFiles(files);
+        }
+        next(validationError);
+      }
+    });
+  };
+};
+`;
+        await createFile(path.join(projectPath, "src/app/middlewares", "handleFileUpload.ts"), handleFileUploadTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Handle File Upload Middleware file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Handle File Upload Middleware file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Handle_File_Upload_Middleware.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_Handle_File_Upload_Middleware.js","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_Handle_File_Upload_Middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;GAIG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,KAAK,EACvD,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8OpC,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,EAAE,qBAAqB,CAAC,EACpE,wBAAwB,CACzB,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CAAC,2DAA2D,CAAC,CACzE,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CACX,KAAK,CAAC,GAAG,CAAC,sDAAsD,CAAC,EACjE,GAAG,CACJ,CAAC;QACF,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

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

@@ -0,0 +1,7 @@
+/**
+ * Creates a not found middleware file for handling 404 errors
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the not found middleware file is created
+ */
+export declare const create_NotFound_Guard: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_NotFound_Guard.d.ts.map

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

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

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

@@ -0,0 +1,47 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates a not found middleware file for handling 404 errors
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the not found middleware file is created
+ */
+export const create_NotFound_Guard = async (projectPath) => {
+    try {
+        const notFoundMiddlewareTemplate = `/* eslint-disable @typescript-eslint/no-unused-vars */
+import { NextFunction, Request, Response } from 'express';
+
+/**
+ * Not Found middleware
+ * Handles requests to non-existent routes and returns a consistent 404 response
+ * 
+ * @param req - Express Request object
+ * @param res - Express Response object
+ * @param next - Express NextFunction
+ */
+const notFound = (req: Request, res: Response, next: NextFunction) => {
+  res.status(404).json({
+    status: 404,
+    success: false,
+    message: 'API Not Found!',
+    error: {
+      path: req.originalUrl,
+      message: 'Your requested API not found',
+      method: req.method
+    }
+  });
+};
+
+export default notFound;
+`;
+        await createFile(path.join(projectPath, "src/app/middlewares", "notFound.ts"), notFoundMiddlewareTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Not Found Middleware file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Not Found Middleware file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_NotFound_Guard.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_NotFound_Guard.js","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_NotFound_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,qBAAqB,GAAG,KAAK,EACxC,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBtC,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,EAAE,aAAa,CAAC,EAC5D,0BAA0B,CAC3B,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAChE,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CACX,KAAK,CAAC,GAAG,CAAC,6CAA6C,CAAC,EACxD,GAAG,CACJ,CAAC;QACF,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

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

@@ -0,0 +1,7 @@
+/**
+ * Creates a progressive rate limiter middleware file
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the rate limiting handler file is created
+ */
+export declare const create_RateLimiting_Handler_Guard: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_RateLimiting_Handler_Guard.d.ts.map

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

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

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

@@ -0,0 +1,270 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates a progressive rate limiter middleware file
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the rate limiting handler file is created
+ */
+export const create_RateLimiting_Handler_Guard = async (projectPath) => {
+    try {
+        const rateLimitingHandlerTemplate = `import { NextFunction, Request, Response } from 'express';
+
+/**
+ * Creates a progressive rate limiter with increasing block durations
+ * @param options Configuration options
+ * @returns Express middleware function
+ */
+export const createProgressiveRateLimiter = (
+  options: {
+    initialWindowMs?: number; // Time window for counting requests
+    initialMax?: number; // Max requests per window
+    initialBlockMs?: number; // Initial block duration
+    message?: string | object; // Custom message when blocked
+    skipSuccessfulRequests?: boolean;
+    skipFailedRequests?: boolean;
+    keyGenerator?: (req: Request) => string;
+  } = {}
+) => {
+  // Set default values
+  const {
+    initialWindowMs = 60 * 1000, // 1 minute by default
+    initialMax = 15, // 15 requests by default
+    initialBlockMs = 20 * 60 * 1000, // 20 minutes initial block
+    message = {
+      success: false,
+      message: 'Too many requests. You are temporarily blocked.'
+    },
+    skipSuccessfulRequests = false,
+    skipFailedRequests = false,
+    keyGenerator = (req: Request) =>
+      req.ip || req.connection.remoteAddress || 'unknown'
+  } = options;
+
+  // Store for tracking request counts and blocked IPs
+  const requestCounts = new Map<string, { count: number; resetTime: number }>();
+  const blockedIPs = new Map<
+    string,
+    {
+      unblockTime: number;
+      blockHistory: { duration: number; timestamp: number }[];
+    }
+  >();
+
+  // Cleanup function to remove old entries
+  const cleanup = () => {
+    const now = Date.now();
+    
+    // Clean up request counts
+    for (const [key, value] of requestCounts.entries()) {
+      if (value.resetTime < now) {
+        requestCounts.delete(key);
+      }
+    }
+    
+    // Clean up blocked IPs
+    for (const [key, value] of blockedIPs.entries()) {
+      if (value.unblockTime < now) {
+        // Keep block history but remove the block
+        blockedIPs.delete(key);
+      }
+    }
+  };
+
+  // Run cleanup every minute
+  setInterval(cleanup, 60 * 1000);
+
+  // Function to determine next block duration based on history
+  const calculateNextBlockDuration = (
+    blockHistory: { duration: number; timestamp: number }[]
+  ): number => {
+    const now = Date.now();
+    
+    // Filter out old blocks (older than 30 days)
+    const recentBlocks = blockHistory.filter(
+      block => now - block.timestamp < 30 * 24 * 60 * 60 * 1000
+    );
+    
+    // Count blocks by duration type
+    const twentyMinBlocks = recentBlocks.filter(
+      b => b.duration === initialBlockMs
+    ).length;
+    const oneDayBlocks = recentBlocks.filter(
+      b => b.duration === 24 * 60 * 60 * 1000
+    ).length;
+    const sevenDayBlocks = recentBlocks.filter(
+      b => b.duration === 7 * 24 * 60 * 60 * 1000
+    ).length;
+    const oneMonthBlocks = recentBlocks.filter(
+      b => b.duration === 30 * 24 * 60 * 60 * 1000
+    ).length;
+    
+    // Progressive blocking logic
+    if (oneMonthBlocks >= 3) {
+      // 1 year block
+      return 365 * 24 * 60 * 60 * 1000;
+    } else if (sevenDayBlocks >= 3) {
+      // 1 month block
+      return 30 * 24 * 60 * 60 * 1000;
+    } else if (oneDayBlocks >= 3) {
+      // 7 days block
+      return 7 * 24 * 60 * 60 * 1000;
+    } else if (twentyMinBlocks >= 5) {
+      // 1 day block
+      return 24 * 60 * 60 * 1000;
+    } else {
+      // Default 20 minutes block
+      return initialBlockMs;
+    }
+  };
+
+  // Function to get block message based on duration
+  const getBlockMessage = (duration: number): string | object => {
+    if (typeof message === 'string') {
+      return message;
+    }
+    
+    let blockDurationText = '';
+    if (duration >= 365 * 24 * 60 * 60 * 1000) {
+      blockDurationText = '1 year';
+    } else if (duration >= 30 * 24 * 60 * 60 * 1000) {
+      blockDurationText = '1 month';
+    } else if (duration >= 7 * 24 * 60 * 60 * 1000) {
+      blockDurationText = '7 days';
+    } else if (duration >= 24 * 60 * 60 * 1000) {
+      blockDurationText = '1 day';
+    } else {
+      blockDurationText = \`\${initialBlockMs ? initialBlockMs / 60000 : 20} minutes\`;
+    }
+    
+    return {
+      ...message,
+      message: \`Too many requests. You are blocked for \${blockDurationText}.\`
+    };
+  };
+
+  // Helper function to set rate limit headers
+  const setRateLimitHeaders = (
+    res: Response,
+    limit: number,
+    remaining: number,
+    resetTime: number,
+    retryAfter?: number
+  ) => {
+    res.setHeader('X-RateLimit-Limit', limit.toString());
+    res.setHeader('X-RateLimit-Remaining', remaining.toString());
+    res.setHeader('X-RateLimit-Reset', Math.ceil(resetTime / 1000).toString());
+    if (retryAfter) {
+      res.setHeader('Retry-After', retryAfter.toString());
+    }
+  };
+
+  return (req: Request, res: Response, next: NextFunction) => {
+    const key = keyGenerator(req);
+    const now = Date.now();
+    
+    // Check if IP is blocked
+    if (blockedIPs.has(key)) {
+      const blockInfo = blockedIPs.get(key)!;
+      if (blockInfo.unblockTime > now) {
+        const retryAfter = Math.ceil((blockInfo.unblockTime - now) / 1000);
+        setRateLimitHeaders(
+          res,
+          initialMax,
+          0,
+          blockInfo.unblockTime,
+          retryAfter
+        );
+        res.status(429).json(getBlockMessage(blockInfo.unblockTime - now));
+        return;
+      } else {
+        // Unblock if time has passed
+        blockedIPs.delete(key);
+      }
+    }
+    
+    // Get or create request count info
+    let countInfo = requestCounts.get(key);
+    if (!countInfo || countInfo.resetTime < now) {
+      // New window
+      countInfo = {
+        count: 1,
+        resetTime: now + initialWindowMs
+      };
+      requestCounts.set(key, countInfo);
+      // Set headers for new window
+      setRateLimitHeaders(res, initialMax, initialMax - 1, countInfo.resetTime);
+      next();
+      return;
+    }
+    
+    // Increment count
+    countInfo.count++;
+    
+    // Set headers for existing window
+    setRateLimitHeaders(
+      res,
+      initialMax,
+      Math.max(0, initialMax - countInfo.count),
+      countInfo.resetTime
+    );
+    
+    // Check if we should skip counting this request
+    const isSuccess = res.statusCode < 400;
+    if (
+      (skipSuccessfulRequests && isSuccess) ||
+      (skipFailedRequests && !isSuccess)
+    ) {
+      next();
+      return;
+    }
+    
+    // Check if limit exceeded
+    if (countInfo.count > initialMax) {
+      // Get existing block history or create new one
+      let blockHistory: { duration: number; timestamp: number }[] = [];
+      if (blockedIPs.has(key)) {
+        blockHistory = blockedIPs.get(key)!.blockHistory;
+      }
+      
+      // Calculate next block duration based on history
+      const blockDuration = calculateNextBlockDuration(blockHistory);
+      
+      // Add this block to history
+      blockHistory.push({
+        duration: blockDuration,
+        timestamp: now
+      });
+      
+      // Block the IP
+      const unblockTime = now + blockDuration;
+      blockedIPs.set(key, {
+        unblockTime,
+        blockHistory
+      });
+      
+      // Remove from request counts to save memory
+      requestCounts.delete(key);
+      
+      // Set headers for blocked IP
+      const retryAfter = Math.ceil(blockDuration / 1000);
+      setRateLimitHeaders(res, initialMax, 0, unblockTime, retryAfter);
+      res.status(429).json(getBlockMessage(blockDuration));
+      return;
+    }
+    
+    next();
+  };
+};
+`;
+        await createFile(path.join(projectPath, "src/app/middlewares", "rateLimitingHandler.ts"), rateLimitingHandlerTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Rate Limiting Handler file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Rate Limiting Handler file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_RateLimiting_Handler_Guard.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_RateLimiting_Handler_Guard.js","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_RateLimiting_Handler_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,iCAAiC,GAAG,KAAK,EACpD,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwPvC,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,EAAE,wBAAwB,CAAC,EACvE,2BAA2B,CAC5B,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CAAC,mDAAmD,CAAC,CACjE,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CACX,KAAK,CAAC,GAAG,CAAC,8CAA8C,CAAC,EACzD,GAAG,CACJ,CAAC;QACF,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

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

@@ -0,0 +1,7 @@
+/**
+ * Creates a request validation middleware file using Zod schemas
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the validate request middleware file is created
+ */
+export declare const create_ValidateRequest_Guard: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_ValidateRequest_Guard.d.ts.map

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

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