express-project-builder 1.0.0

package/dist/lib/src/utils/createCatchAsync_Utils.js

@@ -0,0 +1,59 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Creates a catch async utilities file for handling asynchronous errors in Express route handlers
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the catch async utils file is created
+ */
+export const createCatchAsync_Utils = async (projectPath) => {
+    try {
+        const catchAsyncTemplate = `import { NextFunction, Request, RequestHandler, Response } from 'express';
+
+/**
+ * Higher-order function to catch asynchronous errors in Express route handlers.
+ * This eliminates the need for try-catch blocks in async route handlers.
+ * 
+ * @param fn - The async route handler function to wrap
+ * @returns A wrapped function that passes errors to Express error middleware
+ * 
+ * @example
+ * // Without catchAsync
+ * app.get('/users', async (req, res, next) => {
+ *   try {
+ *     const users = await User.find();
+ *     res.json(users);
+ *   } catch (error) {
+ *     next(error);
+ *   }
+ * });
+ * 
+ * // With catchAsync
+ * app.get('/users', catchAsync(async (req, res) => {
+ *   const users = await User.find();
+ *   res.json(users);
+ * }));
+ */
+const catchAsync = (fn: RequestHandler): RequestHandler => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    Promise.resolve(fn(req, res, next)).catch((error: unknown) => {
+      // Log the error for debugging (optional)
+      console.error('Async error caught by catchAsync:', error);
+      next(error);
+    });
+  };
+};
+
+export default catchAsync;
+`;
+        await createFile(path.join(projectPath, "src/app/utils", "catchAsync.ts"), catchAsyncTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ CatchAsync Utils file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating CatchAsync Utils file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=createCatchAsync_Utils.js.map

package/dist/lib/src/utils/createCatchAsync_Utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCatchAsync_Utils.js","sourceRoot":"","sources":["../../../../src/lib/src/utils/createCatchAsync_Utils.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,sBAAsB,GAAG,KAAK,EACzC,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC9B,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,EAAE,eAAe,CAAC,EACxD,kBAAkB,CACnB,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,8CAA8C,CAAC,CAAC,CAAC;IAC3E,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,yCAAyC,CAAC,EAAE,GAAG,CAAC,CAAC;QACzE,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/utils/createLoggerFile.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a logger utilities file for application logging
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the logger file is created
+ */
+export declare const createLoggerFile: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=createLoggerFile.d.ts.map

package/dist/lib/src/utils/createLoggerFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLoggerFile.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/utils/createLoggerFile.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,IAAI,CA6BxE,CAAC"}

package/dist/lib/src/utils/createLoggerFile.js

@@ -0,0 +1,35 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Creates a logger utilities file for application logging
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the logger file is created
+ */
+export const createLoggerFile = async (projectPath) => {
+    try {
+        const loggerTemplate = `
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const logger = {
+  info: (message: string, meta?: any) => {
+    console.log(\`[INFO] \${message}\`, meta || '');
+  },
+  error: (message: string, error?: any) => {
+    console.error(\`[ERROR] \${message}\`, error || '');
+  },
+  warn: (message: string, meta?: any) => {
+    console.warn(\`[WARN] \${message}\`, meta || '');
+  },
+};
+`;
+        await createFile(path.join(projectPath, "src/app/", "utils", "logger.ts"), loggerTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Logger file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Logger file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=createLoggerFile.js.map

package/dist/lib/src/utils/createLoggerFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLoggerFile.js","sourceRoot":"","sources":["../../../../src/lib/src/utils/createLoggerFile.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,gBAAgB,GAAG,KAAK,EAAE,WAAmB,EAAiB,EAAE;IAC3E,IAAI,CAAC;QACH,MAAM,cAAc,GAAG;;;;;;;;;;;;;CAa1B,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,CAAC,EACxD,cAAc,CACf,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,oCAAoC,CAAC,CAAC,CAAC;IACjE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,+BAA+B,CAAC,EAAE,GAAG,CAAC,CAAC;QAC/D,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/utils/create_Common_Utils.d.ts

@@ -0,0 +1,9 @@
+import { TAnswers } from "../../utils/types.js";
+/**
+ * Creates a common utilities file with optional JWT utilities
+ * @param projectPath - Absolute path to the project root
+ * @param answers - User answers from CLI prompts
+ * @returns Promise that resolves when the common utils file is created
+ */
+export declare const create_Common_Utils: (projectPath: string, answers: TAnswers) => Promise<void>;
+//# sourceMappingURL=create_Common_Utils.d.ts.map

package/dist/lib/src/utils/create_Common_Utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Common_Utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/utils/create_Common_Utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAC9B,aAAa,MAAM,EACnB,SAAS,QAAQ,KAChB,OAAO,CAAC,IAAI,CAgQd,CAAC"}

package/dist/lib/src/utils/create_Common_Utils.js

@@ -0,0 +1,262 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Creates a common utilities file with optional JWT utilities
+ * @param projectPath - Absolute path to the project root
+ * @param answers - User answers from CLI prompts
+ * @returns Promise that resolves when the common utils file is created
+ */
+export const create_Common_Utils = async (projectPath, answers) => {
+    try {
+        // Create the file path
+        const filePath = path.join(projectPath, "src/app/utils", "commonUtils.ts");
+        // Base imports that are always included
+        const baseImports = `/* eslint-disable @typescript-eslint/no-explicit-any */
+import AppError from '../errors/AppError';
+`;
+        // JWT utilities - only included if auth is enabled
+        const jwtUtils = answers.includeAuth
+            ? `import jwt, { JwtPayload, SignOptions } from 'jsonwebtoken'
+import { TJwtPayload } from '../interfaces/jwtToken_interface'
+
+/**
+ * Create a JWT token
+ * @param jwtPayload - Payload to include in the token
+ * @param jwtSecret - Secret key for signing the token
+ * @param expiresIn - Token expiration time (e.g., '1d', '2h', '60m')
+ * @returns JWT token string
+ */
+export const createToken = (
+  jwtPayload: TJwtPayload,
+  jwtSecret: string,
+  expiresIn: string
+): string => {
+  const options: SignOptions = { expiresIn: expiresIn as any }
+  return jwt.sign(jwtPayload, jwtSecret, options)
+}
+
+/**
+ * Verify a JWT token
+ * @param token - JWT token to verify
+ * @param secret - Secret key for verification
+ * @returns Decoded JWT payload
+ * @throws AppError if token is invalid or expired
+ */
+export const verifyToken = (token: string, secret: string): JwtPayload => {
+  try {
+    const decoded = jwt.verify(token, secret) as JwtPayload
+    return decoded
+  } catch (err: any) {
+    throw new AppError(401, '', err.message || 'Invalid or expired token!')
+  }
+}
+`
+            : "";
+        // Common utilities that are always included
+        const commonUtils = `
+/**
+ * Generate a random OTP (One-Time Password)
+ * @param length - Length of the OTP (default: 6)
+ * @returns Random OTP as a string
+ */
+export const generateOTP = (length: number = 6): string => {
+  if (length < 1) {
+    throw new AppError(400, 'otp_length', 'OTP length must be at least 1')
+  }
+  if (length > 24) {
+    throw new AppError(400, 'otp_length', 'OTP length cannot exceed 24')
+  }
+  const min = Math.pow(10, length - 1)
+  const max = Math.pow(10, length) - 1
+  return Math.floor(min + Math.random() * (max - min + 1)).toString()
+}
+
+/**
+ * Check if input is a valid phone number or email
+ * @param input - String to validate
+ * @returns Object containing type ('phone' or 'email') and formatted value
+ * @throws AppError if input is neither a valid phone nor email
+ */
+export const check_Input_isPhone_Or_isEmail = (
+  input: string
+): { type: 'phone' | 'email'; value: string } => {
+  if (!input || typeof input !== 'string') {
+    throw new AppError(400, 'input', 'Input must be a non-empty string')
+  }
+  // Trim to remove accidental spaces
+  const trimmed = input.trim()
+  // Check if it's all digits (potential phone number)
+  const isAllDigits = /^[0-9]+$/.test(trimmed)
+  if (isAllDigits) {
+    // Validate phone number format
+    if (trimmed.length === 11 && trimmed.startsWith('01')) {
+      return { type: 'phone', value: trimmed }
+    } else {
+      throw new AppError(
+        400,
+        'phone_format',
+        'Invalid phone number format (must be 11 digits and start with "01")'
+      )
+    }
+  } else {
+    // Validate email format
+    const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    if (emailPattern.test(trimmed)) {
+      return { type: 'email', value: trimmed }
+    } else {
+      throw new AppError(400, 'email_format', 'Invalid email format')
+    }
+  }
+}
+
+/**
+ * Format a phone number to a specific format
+ * @param phone - Phone number string
+ * @param format - Desired format ('standard', 'international', 'national')
+ * @returns Formatted phone number
+ */
+export const formatPhoneNumber = (
+  phone: string,
+  format: 'standard' | 'international' | 'national' = 'standard'
+): string => {
+  // Remove all non-digit characters
+  const digitsOnly = phone.replace(/\D/g, '')
+  if (digitsOnly.length !== 11 || !digitsOnly.startsWith('01')) {
+    throw new AppError(
+      400,
+      'phone_format',
+      'Invalid phone number for formatting'
+    )
+  }
+  switch (format) {
+    case 'international':
+      return \`+880\${digitsOnly.substring(1)}\`
+    case 'national':
+      return \`0\${digitsOnly.substring(1)}\`
+    case 'standard':
+    default:
+      return digitsOnly
+  }
+}
+
+/**
+ * Generate a random string of specified length
+ * @param length - Length of the string to generate
+ * @param options - Options for character set
+ * @returns Random string
+ */
+export const generateRandomString = (
+  length: number,
+  options: {
+    includeUppercase?: boolean
+    includeLowercase?: boolean
+    includeNumbers?: boolean
+    includeSymbols?: boolean
+  } = {}
+): string => {
+  const {
+    includeUppercase = true,
+    includeLowercase = true,
+    includeNumbers = true,
+    includeSymbols = false
+  } = options
+  if (length < 1) {
+    throw new AppError(400, 'string_length', 'Length must be at least 1')
+  }
+  let charset = ''
+  if (includeUppercase) charset += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+  if (includeLowercase) charset += 'abcdefghijklmnopqrstuvwxyz'
+  if (includeNumbers) charset += '0123456789'
+  if (includeSymbols) charset += '!@#$%^&*()_+-=[]{}|;:,.<>?'
+  if (charset === '') {
+    throw new AppError(
+      400,
+      'charset',
+      'At least one character type must be selected'
+    )
+  }
+  let result = ''
+  for (let i = 0; i < length; i++) {
+    result += charset.charAt(Math.floor(Math.random() * charset.length))
+  }
+  return result
+}
+
+/**
+ * Check if a string is a valid email address
+ * @param email - Email string to validate
+ * @returns True if valid, false otherwise
+ */
+export const isValidEmail = (email: string): boolean => {
+  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+  return emailPattern.test(email.trim())
+}
+
+/**
+ * Check if a string is a valid phone number
+ * @param phone - Phone number string to validate
+ * @returns True if valid, false otherwise
+ */
+export const isValidPhone = (phone: string): boolean => {
+  const digitsOnly = phone.replace(/\D/g, '')
+  return digitsOnly.length === 11 && digitsOnly.startsWith('01')
+}
+
+/**
+ * Mask sensitive information (like email or phone)
+ * @param value - Value to mask
+ * @param type - Type of value ('email' or 'phone')
+ * @returns Masked string
+ */
+export const maskSensitiveInfo = (
+  value: string,
+  type: 'email' | 'phone'
+): string => {
+  if (!value || typeof value !== 'string') {
+    return value
+  }
+  let maskedValue: string
+  switch (type) {
+    case 'email': {
+      const [username, domain] = value.split('@')
+      if (username && domain) {
+        const visibleChars = Math.max(1, Math.floor(username.length / 2))
+        const maskedUsername =
+          username.substring(0, visibleChars) +
+          '*'.repeat(username.length - visibleChars)
+        maskedValue = \`\${maskedUsername}@\${domain}\`
+        break
+      }
+      maskedValue = value
+      break
+    }
+    case 'phone': {
+      const digitsOnly = value.replace(/\D/g, '')
+      if (digitsOnly.length === 11) {
+        maskedValue = \`\${digitsOnly.substring(0, 3)}****\${digitsOnly.substring(7)}\`
+        break
+      }
+      maskedValue = value
+      break
+    }
+    default:
+      maskedValue = value
+  }
+  return maskedValue
+}
+`;
+        // Combine all parts
+        const templateContent = baseImports + jwtUtils + commonUtils;
+        // Create the file
+        await createFile(filePath, templateContent);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Common Utils file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Common Utils file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Common_Utils.js.map

package/dist/lib/src/utils/create_Common_Utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Common_Utils.js","sourceRoot":"","sources":["../../../../src/lib/src/utils/create_Common_Utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,EACtC,WAAmB,EACnB,OAAiB,EACF,EAAE;IACjB,IAAI,CAAC;QACH,uBAAuB;QACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,EAAE,gBAAgB,CAAC,CAAC;QAE3E,wCAAwC;QACxC,MAAM,WAAW,GAAG;;CAEvB,CAAC;QAEE,mDAAmD;QACnD,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW;YAClC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCP;YACK,CAAC,CAAC,EAAE,CAAC;QAEP,4CAA4C;QAC5C,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+LvB,CAAC;QAEE,oBAAoB;QACpB,MAAM,eAAe,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;QAE7D,kBAAkB;QAClB,MAAM,UAAU,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QAE5C,gDAAgD;QAChD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,0CAA0C,CAAC,CAAC,CAAC;IACvE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,qCAAqC,CAAC,EAAE,GAAG,CAAC,CAAC;QACrE,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/utils/create_Date_Time_Validation_Utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a date and time validation utilities file
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the date time validation utils file is created
+ */
+export declare const create_Date_Time_Validation_Utils: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_Date_Time_Validation_Utils.d.ts.map

package/dist/lib/src/utils/create_Date_Time_Validation_Utils.d.ts.map

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

package/dist/lib/src/utils/create_Date_Time_Validation_Utils.js

@@ -0,0 +1,181 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Creates a date and time validation utilities file
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the date time validation utils file is created
+ */
+export const create_Date_Time_Validation_Utils = async (projectPath) => {
+    try {
+        const dateTimeValidationTemplate = `import AppError from '../errors/AppError';
+
+/**
+ * Check if a date string or Date object is valid
+ * @param dateString - Date string or Date object to validate
+ * @returns True if the date is valid, false otherwise
+ */
+export function isValidDate(dateString: string | Date): boolean {
+  // Handle Date objects
+  if (dateString instanceof Date) {
+    return !isNaN(dateString.getTime());
+  }
+  
+  // Handle string inputs
+  const date = new Date(dateString);
+  
+  // Check if the date is invalid
+  if (isNaN(date.getTime())) {
+    return false;
+  }
+  
+  // Additional validation: Check if the parsed date matches the input
+  // This catches cases like "2023-02-30" which becomes March 2nd
+  const dateStringNormalized = dateString.toString().trim();
+  const parsedString = date.toISOString();
+  
+  // For ISO format strings, we can do a more direct comparison
+  if (dateStringNormalized.includes('T') || dateStringNormalized.includes('Z')) {
+    return !isNaN(date.getTime());
+  }
+  
+  // For other formats, check if the date components match
+  const inputParts = dateStringNormalized.split(/[-/:T\s]/).map(part => parseInt(part, 10));
+  const parsedParts = [
+    date.getFullYear(),
+    date.getMonth() + 1, // getMonth() is 0-indexed
+    date.getDate(),
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds()
+  ];
+  
+  // Compare the significant parts (year, month, day)
+  for (let i = 0; i < Math.min(inputParts.length, 3); i++) {
+    if (inputParts[i] !== parsedParts[i]) {
+      return false;
+    }
+  }
+  
+  return true;
+}
+
+/**
+ * Validate and normalize start and end dates
+ * @param start_date - Optional start date string or Date object
+ * @param end_date - Optional end date string or Date object
+ * @returns Object containing validated start and end Date objects
+ * @throws AppError if dates are invalid
+ */
+export const Start_End_DateTime_Validation = (
+  start_date?: string | Date,
+  end_date?: string | Date
+): { start: Date; end: Date } => {
+  const now = new Date();
+  
+  // Validate start date
+  if (start_date && !isValidDate(start_date)) {
+    throw new AppError(400, 'start_date', 'Start date is not a valid date');
+  }
+  
+  // Validate end date
+  if (end_date && !isValidDate(end_date)) {
+    throw new AppError(400, 'end_date', 'End date is not a valid date');
+  }
+  
+  // Parse dates or use defaults
+  let start = start_date ? new Date(start_date) : new Date(now.setHours(0, 0, 0, 0));
+  let end = end_date ? new Date(end_date) : new Date(now.setHours(23, 59, 59, 999));
+  
+   if (start > end) [start, end] = [end, start]
+  
+  // Validate that dates are not too far in the past or future (optional)
+  const maxPastDate = new Date();
+  maxPastDate.setFullYear(maxPastDate.getFullYear() - 100); // 100 years ago
+  
+  const maxFutureDate = new Date();
+  maxFutureDate.setFullYear(maxFutureDate.getFullYear() + 100); // 100 years in future
+  
+  if (start < maxPastDate || end < maxPastDate) {
+    throw new AppError(400, 'date_range', 'Date cannot be more than 100 years in the past');
+  }
+  
+  if (start > maxFutureDate || end > maxFutureDate) {
+    throw new AppError(400, 'date_range', 'Date cannot be more than 100 years in the future');
+  }
+  
+  return { start, end };
+};
+
+/**
+ * Check if a date is within a given range
+ * @param date - Date to check
+ * @param startDate - Start of the range
+ * @param endDate - End of the range
+ * @returns True if the date is within the range, false otherwise
+ */
+export const isDateInRange = (
+  date: string | Date,
+  startDate: string | Date,
+  endDate: string | Date
+): boolean => {
+  const checkDate = date instanceof Date ? date : new Date(date);
+  const start = startDate instanceof Date ? startDate : new Date(startDate);
+  const end = endDate instanceof Date ? endDate : new Date(endDate);
+  
+  return checkDate >= start && checkDate <= end;
+};
+
+/**
+ * Format a date to ISO string without timezone
+ * @param date - Date to format
+ * @returns Formatted date string (YYYY-MM-DDTHH:mm:ss)
+ */
+export const formatDateToISOString = (date: string | Date): string => {
+  const d = date instanceof Date ? date : new Date(date);
+  return d.toISOString().replace('.000Z', '');
+};
+
+/**
+ * Get the difference between two dates in various units
+ * @param startDate - Start date
+ * @param endDate - End date
+ * @param unit - Unit of difference ('days', 'hours', 'minutes', 'seconds', 'milliseconds')
+ * @returns Difference in the specified unit
+ */
+export const getDateDifference = (
+  startDate: string | Date,
+  endDate: string | Date,
+  unit: 'days' | 'hours' | 'minutes' | 'seconds' | 'milliseconds' = 'milliseconds'
+): number => {
+  const start = startDate instanceof Date ? startDate : new Date(startDate);
+  const end = endDate instanceof Date ? endDate : new Date(endDate);
+  
+  const diffInMs = end.getTime() - start.getTime();
+  
+  switch (unit) {
+    case 'days':
+      return Math.floor(diffInMs / (1000 * 60 * 60 * 24));
+    case 'hours':
+      return Math.floor(diffInMs / (1000 * 60 * 60));
+    case 'minutes':
+      return Math.floor(diffInMs / (1000 * 60));
+    case 'seconds':
+      return Math.floor(diffInMs / 1000);
+    case 'milliseconds':
+    default:
+      return diffInMs;
+  }
+};
+`;
+        await createFile(path.join(projectPath, "src/app/utils", "date_Time_Validation.ts"), dateTimeValidationTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Date Time Validation Utils file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Date Time Validation Utils file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Date_Time_Validation_Utils.js.map

package/dist/lib/src/utils/create_Date_Time_Validation_Utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Date_Time_Validation_Utils.js","sourceRoot":"","sources":["../../../../src/lib/src/utils/create_Date_Time_Validation_Utils.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,iCAAiC,GAAG,KAAK,EACpD,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+JtC,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,EAAE,yBAAyB,CAAC,EAClE,0BAA0B,CAC3B,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CAAC,wDAAwD,CAAC,CACtE,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/utils/create_Node_Cache_Utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a Node Cache utilities file for in-memory caching
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the Node Cache utils file is created
+ */
+export declare const create_Node_Cache_Utils: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_Node_Cache_Utils.d.ts.map

package/dist/lib/src/utils/create_Node_Cache_Utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Node_Cache_Utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/utils/create_Node_Cache_Utils.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAClC,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CA+Id,CAAC"}