express-project-builder 1.0.0

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

@@ -0,0 +1,149 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * 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 const create_Node_Cache_Utils = async (projectPath) => {
+    try {
+        const node_cache_template = `/* eslint-disable @typescript-eslint/no-explicit-any */
+import NodeCache from 'node-cache';
+
+// Initialize cache with default options (stdTTL: 0 = never expire, checkperiod: 600 = 10 minutes)
+export const myCache = new NodeCache({
+  stdTTL: 0, // Default time to live in seconds (0 = never expire)
+  checkperiod: 600, // Period in seconds to check for expired items
+  useClones: false // For better performance with large objects
+});
+
+/**
+ * Create or update cache entry in RAM
+ * @param key - Cache key (string)
+ * @param value - Value to cache (any type)
+ * @param ttl - Time to live in seconds (optional)
+ * @returns boolean indicating success
+ */
+export const create_cache_into_RAM = (
+  key: string,
+  value: any,
+  ttl?: number
+): boolean => {
+  try {
+    if (ttl && ttl > 0) {
+      return myCache.set(key, value, ttl);
+    }
+    return myCache.set(key, value);
+  } catch (error) {
+    console.error('Cache creation error:', error);
+    return false;
+  }
+};
+
+/**
+ * Retrieve cached value from RAM
+ * @param key - Cache key (string)
+ * @returns Cached value or undefined if not found
+ */
+export const get_cache_from_RAM = (key: string): any | undefined => {
+  try {
+    return myCache.get(key);
+  } catch (error) {
+    console.error('Cache retrieval error:', error);
+    return undefined;
+  }
+};
+
+/**
+ * Delete specific cache entry from RAM
+ * @param key - Cache key to delete
+ * @returns number of deleted entries (0 or 1)
+ */
+export const delete_cache_from_RAM = (key: string): number => {
+  try {
+    return myCache.del(key);
+  } catch (error) {
+    console.error('Cache deletion error:', error);
+    return 0;
+  }
+};
+
+/**
+ * Clear all cache entries
+ * @returns void
+ */
+export const clear_all_cache = (): void => {
+  try {
+    myCache.flushAll();
+    console.log('All cache entries cleared');
+  } catch (error) {
+    console.error('Cache clearing error:', error);
+  }
+};
+
+/**
+ * Get cache statistics
+ * @returns Object with cache statistics
+ */
+export const get_cache_stats = () => {
+  try {
+    return myCache.getStats();
+  } catch (error) {
+    console.error('Cache stats error:', error);
+    return null;
+  }
+};
+
+/**
+ * Check if key exists in cache
+ * @param key - Cache key to check
+ * @returns boolean indicating if key exists
+ */
+export const has_cache_key = (key: string): boolean => {
+  try {
+    return myCache.has(key);
+  } catch (error) {
+    console.error('Cache key check error:', error);
+    return false;
+  }
+};
+
+/**
+ * Get all cache keys
+ * @returns Array of all cache keys
+ */
+export const get_all_cache_keys = (): string[] => {
+  try {
+    return myCache.keys();
+  } catch (error) {
+    console.error('Cache keys retrieval error:', error);
+    return [];
+  }
+};
+
+/**
+ * Get TTL for a specific key
+ * @param key - Cache key
+ * @returns TTL in seconds or 0 if no TTL set
+ */
+export const get_cache_ttl = (key: string): number => {
+  try {
+    return myCache.getTtl(key) || 0;
+  } catch (error) {
+    console.error('Cache TTL retrieval error:', error);
+    return 0;
+  }
+};
+`;
+        await createFile(path.join(projectPath, "src/app/utils", "node_cache.ts"), node_cache_template);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Node Cache Utils file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Node Cache Utils file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Node_Cache_Utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_Node_Cache_Utils.js","sourceRoot":"","sources":["../../../../src/lib/src/utils/create_Node_Cache_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,uBAAuB,GAAG,KAAK,EAC1C,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+H/B,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,EAAE,eAAe,CAAC,EACxD,mBAAmB,CACpB,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/create_Remove_Uploaded_Files_Utils.d.ts

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

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

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

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

@@ -0,0 +1,162 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Creates a remove uploaded files utilities file for cleaning up uploaded files
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the remove uploaded files utils file is created
+ */
+export const create_Remove_Uploaded_Files_Utils = async (projectPath) => {
+    try {
+        const removeUploadedFilesTemplate = `/* eslint-disable @typescript-eslint/no-explicit-any */
+import fs from 'fs/promises';
+import { promisify } from 'util';
+import path from 'path';
+
+// Promisify the unlink function for callback-based operations
+const unlinkAsync = promisify(fs.unlink);
+
+/**
+ * Remove a single uploaded file
+ * @param filePath - Path to the file to remove
+ * @returns Promise that resolves when file is removed or rejects on error
+ */
+export const removeSingleUploadedFile = async (filePath: string): Promise<void> => {
+  try {
+    // Check if file exists before attempting to remove
+    await fs.access(filePath, fs.constants.F_OK);
+    await unlinkAsync(filePath);
+  } catch (error: any) {
+    // If file doesn't exist (ENOENT), that's okay - it might have been removed already
+    if (error.code !== 'ENOENT') {
+      console.error(\`Failed to remove file: \${filePath}\`, error);
+      throw new Error(\`Failed to remove file: \${filePath}\`);
+    }
+  }
+};
+
+/**
+ * Type definition for uploaded files structure from multer
+ */
+type UploadedFiles = {
+  [fieldname: string]: Express.Multer.File[];
+};
+
+/**
+ * Remove multiple uploaded files from all fields
+ * @param files - Object containing uploaded files grouped by field name
+ * @returns Promise that resolves when all files are removed or rejects on error
+ */
+export const removeUploadedFiles = async (files: UploadedFiles): Promise<void> => {
+  if (!files || Object.keys(files).length === 0) {
+    return;
+  }
+  
+  try {
+    // Create an array of removal promises for all files
+    const removalPromises: Promise<void>[] = [];
+    
+    // Iterate through each field in the files object
+    for (const fieldName in files) {
+      if (Object.prototype.hasOwnProperty.call(files, fieldName)) {
+        const fieldFiles = files[fieldName] || [];
+        
+        // Add removal promise for each file in the field
+        for (const file of fieldFiles) {
+          removalPromises.push(
+            removeSingleUploadedFile(file.path).catch(error => {
+              console.error(\`Failed to remove file: \${file.path}\`, error);
+              // Don't throw - continue removing other files
+            })
+          );
+        }
+      }
+    }
+    
+    // Execute all removal promises concurrently
+    await Promise.all(removalPromises);
+  } catch (error: any) {
+    console.error('Error during batch file removal:', error);
+    throw new Error('Failed to remove uploaded files');
+  }
+};
+
+/**
+ * Remove files from specific fields only
+ * @param files - Object containing uploaded files grouped by field name
+ * @param fieldNames - Array of field names to remove files from
+ * @returns Promise that resolves when specified files are removed or rejects on error
+ */
+export const removeFilesFromFields = async (
+  files: UploadedFiles,
+  fieldNames: string[]
+): Promise<void> => {
+  if (!files || fieldNames.length === 0) {
+    return;
+  }
+  
+  try {
+    const removalPromises: Promise<void>[] = [];
+    
+    // Only process files from specified fields
+    for (const fieldName of fieldNames) {
+      const fieldFiles = files[fieldName] || [];
+      
+      for (const file of fieldFiles) {
+        removalPromises.push(
+          removeSingleUploadedFile(file.path).catch(error => {
+            console.error(\`Failed to remove file: \${file.path}\`, error);
+          })
+        );
+      }
+    }
+    
+    await Promise.all(removalPromises);
+  } catch (error: any) {
+    console.error('Error during field-specific file removal:', error);
+    throw new Error('Failed to remove files from specified fields');
+  }
+};
+
+/**
+ * Clean up uploaded files directory (removes all files in a directory)
+ * @param directoryPath - Path to the directory to clean
+ * @returns Promise that resolves when directory is cleaned or rejects on error
+ */
+export const cleanUploadDirectory = async (directoryPath: string): Promise<void> => {
+  try {
+    // Check if directory exists
+    await fs.access(directoryPath, fs.constants.F_OK);
+    
+    // Read all files in the directory
+    const files = await fs.readdir(directoryPath);
+    
+    // Remove each file
+    const removalPromises = files.map(file => {
+      const filePath = path.join(directoryPath, file);
+      return removeSingleUploadedFile(filePath).catch(error => {
+        console.error(\`Failed to remove file: \${filePath}\`, error);
+      });
+    });
+    
+    await Promise.all(removalPromises);
+  } catch (error: any) {
+    // If directory doesn't exist, that's okay
+    if (error.code !== 'ENOENT') {
+      console.error('Error cleaning upload directory:', error);
+      throw new Error(\`Failed to clean directory: \${directoryPath}\`);
+    }
+  }
+};
+`;
+        await createFile(path.join(projectPath, "src/app/utils", "removeUploadedFiles.ts"), removeUploadedFilesTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Remove Uploaded Files Utils file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Remove Uploaded Files Utils file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Remove_Uploaded_Files_Utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_Remove_Uploaded_Files_Utils.js","sourceRoot":"","sources":["../../../../src/lib/src/utils/create_Remove_Uploaded_Files_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,kCAAkC,GAAG,KAAK,EACrD,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4IvC,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,EAAE,wBAAwB,CAAC,EACjE,2BAA2B,CAC5B,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CAAC,yDAAyD,CAAC,CACvE,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CACX,KAAK,CAAC,GAAG,CAAC,oDAAoD,CAAC,EAC/D,GAAG,CACJ,CAAC;QACF,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

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

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

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

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

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

@@ -0,0 +1,140 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Creates a send email utilities file for handling email operations
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the send email utils file is created
+ */
+export const create_SendEmail_Utils = async (projectPath) => {
+    try {
+        const sendEmailTemplate = `/* eslint-disable @typescript-eslint/no-explicit-any */
+import nodemailer from 'nodemailer'
+import config from '../config'
+import { TEmailFormat } from '../interfaces/emailFormat'
+import AppError from '../errors/AppError'
+
+/**
+ * Email transporter configuration
+ */
+const createTransporter = () => {
+  return nodemailer.createTransport({
+    host: config.email_host_provider_name as string,
+    port: Number(config.email_host_provider_port),
+    secure: config.NODE_ENV === 'production', // Use TLS in production
+    auth: {
+      user: config.email_sender_email,
+      pass: config.email_sender_email_app_pass
+    },
+    // Additional security options for production
+    ...(config.NODE_ENV === 'production' && {
+      tls: {
+        rejectUnauthorized: true // Enforce certificate validation in production
+      }
+    })
+  });
+};
+
+/**
+ * Send email using configured transporter
+ * @param to - Recipient email address
+ * @param emailTemplate - Email template containing subject and body
+ * @returns Promise that resolves when email is sent
+ * @throws AppError if email sending fails
+ */
+const sendEmail = async (to: string, emailTemplate: TEmailFormat): Promise<void> => {
+  try {
+    // Validate required parameters
+    if (!to || !emailTemplate?.subject || !emailTemplate?.emailBody) {
+      throw new AppError(400, 'INVALID_INPUT', 'Missing required email parameters');
+    }
+    
+    // Create transporter
+    const transporter = createTransporter();
+    
+    // Prepare email options
+    const mailOptions = {
+      from: \`"\${config.email_sender_name || 'Your App'}" <\${config.email_sender_email}>\`,
+      to,
+      subject: emailTemplate.subject,
+      text: emailTemplate.text || '', // Fallback to empty string if text not provided
+      html: emailTemplate.emailBody,
+      // Optional: Add reply-to address
+      ...(config.email_reply_to && {
+        replyTo: config.email_reply_to
+      })
+    };
+    
+    // Send email
+    const info = await transporter.sendMail(mailOptions);
+    
+    // Log successful email sending (optional)
+    console.log('Email sent successfully:', {
+      messageId: info.messageId,
+      to,
+      subject: emailTemplate.subject
+    });
+  } catch (error: any) {
+    console.error('Email sending failed:', {
+      to,
+      subject: emailTemplate?.subject,
+      error: error.message,
+      stack: error.stack
+    });
+    
+    // Throw a more specific error based on the error type
+    if (error.code === 'EAUTH') {
+      throw new AppError(500, 'EMAIL_AUTH_ERROR', 'Email authentication failed. Check email credentials.');
+    } else if (error.code === 'ECONNECTION') {
+      throw new AppError(500, 'EMAIL_CONNECTION_ERROR', 'Failed to connect to email server.');
+    } else if (error.code === 'EMESSAGE') {
+      throw new AppError(400, 'EMAIL_MESSAGE_ERROR', 'Invalid email message format.');
+    } else {
+      throw new AppError(500, 'EMAIL_SEND_ERROR', \`Failed to send email: \${error.message}\`);
+    }
+  }
+};
+
+/**
+ * Test email configuration
+ * @returns Promise that resolves when test email is sent
+ */
+export const testEmailConfig = async (): Promise<void> => {
+  try {
+    const testEmail = config.email_test_recipient || config.email_sender_email;
+    
+    if (!testEmail) {
+      throw new AppError(400, 'INVALID_CONFIG', 'No test email recipient configured');
+    }
+    
+    const testTemplate: TEmailFormat = {
+      subject: 'Test Email from Your App',
+      text: 'This is a test email to verify your email configuration.',
+      emailBody: \`
+        <h1>Email Configuration Test</h1>
+        <p>If you receive this email, your email configuration is working correctly.</p>
+        <p>Time sent: \${new Date().toISOString()}</p>
+      \`
+    };
+    
+    await sendEmail(testEmail, testTemplate);
+    console.log('Email configuration test successful');
+  } catch (error) {
+    console.error('Email configuration test failed:', error);
+    throw error;
+  }
+};
+
+export default sendEmail;
+`;
+        await createFile(path.join(projectPath, "src/app/utils", "sendEmail.ts"), sendEmailTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ SendEmail utility file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating SendEmail utility file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_SendEmail_Utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_SendEmail_Utils.js","sourceRoot":"","sources":["../../../../src/lib/src/utils/create_SendEmail_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,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsH7B,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,EAAE,cAAc,CAAC,EACvD,iBAAiB,CAClB,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,+CAA+C,CAAC,CAAC,CAAC;IAC5E,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,0CAA0C,CAAC,EAAE,GAAG,CAAC,CAAC;QAC1E,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

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

@@ -0,0 +1,7 @@
+/**
+ * Creates a send response utilities file for standardized API responses
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the send response utils file is created
+ */
+export declare const create_SendResponse_Utils: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_sendResponse_Utils.d.ts.map

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

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

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

@@ -0,0 +1,95 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Creates a send response utilities file for standardized API responses
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the send response utils file is created
+ */
+export const create_SendResponse_Utils = async (projectPath) => {
+    try {
+        const responseTemplate = `import { Response } from 'express';
+
+/**
+ * Metadata type for paginated responses
+ */
+type TMeta = {
+  page: number;
+  limit: number;
+  totalData: number;
+  totalPage: number;
+};
+
+/**
+ * Standardized response structure
+ */
+type TSendResponse<T> = {
+  status: number;
+  success: boolean;
+  message?: string;
+  meta?: TMeta;
+  data: T;
+};
+
+/**
+ * Sends a standardized JSON response
+ * @param res - Express Response object
+ * @param data - Response data containing status, success, message, meta, and actual data
+ * @returns Express Response with JSON payload
+ * 
+ * @example
+ * // Basic success response
+ * sendResponse(res, {
+ *   status: 200,
+ *   success: true,
+ *   message: 'User created successfully',
+ *   data: newUser
+ * });
+ * 
+ * @example
+ * // Paginated response
+ * sendResponse(res, {
+ *   status: 200,
+ *   success: true,
+ *   message: 'Users retrieved',
+ *   meta: {
+ *     page: 1,
+ *     limit: 10,
+ *     totalData: 100,
+ *     totalPage: 10
+ *   },
+ *   data: users
+ * });
+ * 
+ * @example
+ * // Error response
+ * sendResponse(res, {
+ *   status: 404,
+ *   success: false,
+ *   message: 'User not found',
+ *   data: null
+ * });
+ */
+const sendResponse = <T>(res: Response, data: TSendResponse<T>) => {
+  return res.status(data.status).json({
+    status: data.status,
+    success: data.success,
+    message: data.message,
+    meta: data.meta,
+    data: data.data
+  });
+};
+
+export default sendResponse;
+`;
+        await createFile(path.join(projectPath, "src/app/utils", "sendResponse.ts"), responseTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ SendResponse utility file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating SendResponse utility file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_sendResponse_Utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_sendResponse_Utils.js","sourceRoot":"","sources":["../../../../src/lib/src/utils/create_sendResponse_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,yBAAyB,GAAG,KAAK,EAC5C,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyE5B,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,EAAE,iBAAiB,CAAC,EAC1D,gBAAgB,CACjB,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/utils/helpers.d.ts

@@ -0,0 +1,5 @@
+export declare const createProjectDirectory: (projectName: string) => Promise<void>;
+export declare const createDirectory: (dirPath: string) => Promise<void>;
+export declare const createFile: (filePath: string, content: string) => Promise<void>;
+export declare const createJsonFile: <T = unknown>(filePath: string, data: T) => Promise<void>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/lib/utils/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/helpers.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,sBAAsB,GACjC,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CAEd,CAAC;AAKF,eAAO,MAAM,eAAe,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAEnE,CAAC;AAOF,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,EAChB,SAAS,MAAM,KACd,OAAO,CAAC,IAAI,CAEd,CAAC;AAQF,eAAO,MAAM,cAAc,GAAU,CAAC,GAAG,OAAO,EAC9C,UAAU,MAAM,EAChB,MAAM,CAAC,KACN,OAAO,CAAC,IAAI,CAEd,CAAC"}

package/dist/lib/utils/helpers.js

@@ -0,0 +1,31 @@
+import fs from "fs-extra";
+// Creates a project directory with the given name
+// Parameter: projectName (string) - Name of the directory to create
+// Returns: Promise<void> - Resolves when directory is created
+export const createProjectDirectory = async (projectName) => {
+    await fs.mkdir(projectName);
+};
+// Creates a directory and any necessary parent directories
+// Parameter: dirPath (string) - Path of the directory to create
+// Returns: Promise<void> - Resolves when directory is created
+export const createDirectory = async (dirPath) => {
+    await fs.ensureDir(dirPath);
+};
+// Creates a file with specified content
+// Parameters:
+//   filePath (string) - Path where the file should be created
+//   content (string) - Content to write to the file
+// Returns: Promise<void> - Resolves when file is created
+export const createFile = async (filePath, content) => {
+    await fs.writeFile(filePath, content);
+};
+// Creates a JSON file with formatted data
+// Generic Type: T - Type of data to be serialized (defaults to unknown)
+// Parameters:
+//   filePath (string) - Path where the JSON file should be created
+//   data (T) - Data object to serialize to JSON
+// Returns: Promise<void> - Resolves when JSON file is created
+export const createJsonFile = async (filePath, data) => {
+    await fs.writeJSON(filePath, data, { spaces: 2 });
+};
+//# sourceMappingURL=helpers.js.map

package/dist/lib/utils/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/lib/utils/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,UAAU,CAAC;AAE1B,kDAAkD;AAClD,oEAAoE;AACpE,8DAA8D;AAC9D,MAAM,CAAC,MAAM,sBAAsB,GAAG,KAAK,EACzC,WAAmB,EACJ,EAAE;IACjB,MAAM,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AAC9B,CAAC,CAAC;AAEF,2DAA2D;AAC3D,gEAAgE;AAChE,8DAA8D;AAC9D,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,EAAE,OAAe,EAAiB,EAAE;IACtE,MAAM,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAC9B,CAAC,CAAC;AAEF,wCAAwC;AACxC,cAAc;AACd,8DAA8D;AAC9D,oDAAoD;AACpD,yDAAyD;AACzD,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,EAC7B,QAAgB,EAChB,OAAe,EACA,EAAE;IACjB,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF,0CAA0C;AAC1C,wEAAwE;AACxE,cAAc;AACd,mEAAmE;AACnE,gDAAgD;AAChD,8DAA8D;AAC9D,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,EACjC,QAAgB,EAChB,IAAO,EACQ,EAAE;IACjB,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;AACpD,CAAC,CAAC"}

package/dist/lib/utils/types.d.ts

@@ -0,0 +1,5 @@
+export type TAnswers = {
+    database: "MongoDB with Mongoose" | "PostgreSQL with Prisma" | string;
+    includeAuth: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/types.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,uBAAuB,GAAG,wBAAwB,GAAG,MAAM,CAAC;IACtE,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC"}

package/dist/lib/utils/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lib/utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/utils/types.ts"],"names":[],"mappings":""}