@asad_dev/leo-generator 1.6.0

package/dist/utils/documentationUpdater.js

@@ -0,0 +1,430 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateAllDocumentation = updateAllDocumentation;
+exports.updateExistingModulesDocumentation = updateExistingModulesDocumentation;
+const postmanGenerator_1 = require("./postmanGenerator");
+const postmanApi_1 = require("./postmanApi");
+const swaggerGenerator_1 = require("./swaggerGenerator");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function updateAllDocumentation(moduleName_1, fields_1) {
+    return __awaiter(this, arguments, void 0, function* (moduleName, fields, options = {}) {
+        const { postmanDir = "postman", swaggerFile = "swagger.json", updatePostman = true, updateSwagger = true } = options;
+        console.log(`📚 Updating documentation for ${moduleName}...`);
+        if (updatePostman) {
+            try {
+                const postmanCollection = (0, postmanGenerator_1.generatePostmanCollection)(moduleName, fields);
+                // Save locally (always happens)
+                (0, postmanGenerator_1.savePostmanCollection)(moduleName, postmanCollection, postmanDir);
+                // Save to Postman API if config is provided
+                if (options.postmanApiKey && options.postmanCollectionId) {
+                    console.log(`☁️  Syncing ${moduleName} API to Postman Cloud...`);
+                    // Await the API call to ensure sequential processing
+                    yield (0, postmanApi_1.updatePostmanCollectionViaApi)(moduleName, postmanCollection, {
+                        apiKey: options.postmanApiKey,
+                        collectionId: options.postmanCollectionId
+                    });
+                }
+            }
+            catch (error) {
+                console.error("❌ Error updating Postman collection:", error);
+            }
+        }
+        if (updateSwagger) {
+            try {
+                (0, swaggerGenerator_1.updateSwaggerFile)(moduleName, fields, swaggerFile);
+            }
+            catch (error) {
+                console.error("❌ Error updating Swagger documentation:", error);
+            }
+        }
+        console.log("✅ Documentation update completed!");
+    });
+}
+function updateExistingModulesDocumentation() {
+    return __awaiter(this, arguments, void 0, function* (modulesDir = "src/app/modules", options = {}) {
+        const fullModulesPath = path.join(process.cwd(), modulesDir);
+        if (!fs.existsSync(fullModulesPath)) {
+            console.error(`❌ Modules directory not found: ${fullModulesPath}`);
+            return;
+        }
+        console.log("🔄 Scanning existing modules for documentation updates...");
+        const moduleDirectories = fs.readdirSync(fullModulesPath, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => dirent.name);
+        let updatedCount = 0;
+        // Process modules sequentially to avoid race conditions with Postman API
+        for (const moduleDir of moduleDirectories) {
+            try {
+                const modulePath = path.join(fullModulesPath, moduleDir);
+                const interfaceFile = path.join(modulePath, `${moduleDir}.interface.ts`);
+                const modelFile = path.join(modulePath, `${moduleDir}.model.ts`);
+                if (fs.existsSync(interfaceFile)) {
+                    console.log(`📝 Processing module: ${moduleDir}`);
+                    // Check if model file exists for better parsing
+                    if (fs.existsSync(modelFile)) {
+                        console.log(`   📄 Found interface and model files`);
+                    }
+                    else {
+                        console.log(`   📄 Found interface file (model file missing)`);
+                    }
+                    // Extract fields from interface and model files
+                    const fields = extractFieldsFromInterface(interfaceFile);
+                    if (fields.length > 0) {
+                        console.log(`   🔍 Extracted ${fields.length} fields: ${fields.map(f => f.name).join(', ')}`);
+                        const camelCaseName = toCamelCase(moduleDir);
+                        // Await to ensure sequential processing (prevents Postman API conflicts)
+                        yield updateAllDocumentation(camelCaseName, fields, options);
+                        updatedCount++;
+                    }
+                    else {
+                        console.warn(`   ⚠️  No fields found in ${moduleDir} interface`);
+                    }
+                }
+                else {
+                    console.warn(`⚠️  Interface file not found for module: ${moduleDir}`);
+                }
+            }
+            catch (error) {
+                console.error(`❌ Error processing module ${moduleDir}:`, error);
+                console.error(`   Details: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        console.log(`✅ Updated documentation for ${updatedCount} modules`);
+    });
+}
+// Enhanced field extraction from both interface and model files
+function extractFieldsFromInterface(interfaceFilePath) {
+    try {
+        const moduleDir = path.dirname(interfaceFilePath);
+        const moduleName = path.basename(interfaceFilePath, '.interface.ts');
+        const modelFilePath = path.join(moduleDir, `${moduleName}.model.ts`);
+        // Read both interface and model files
+        const interfaceContent = fs.readFileSync(interfaceFilePath, "utf-8");
+        let modelContent = "";
+        if (fs.existsSync(modelFilePath)) {
+            modelContent = fs.readFileSync(modelFilePath, "utf-8");
+        }
+        const fields = [];
+        // Extract nested interface definitions first
+        const nestedInterfaces = extractNestedInterfaces(interfaceContent);
+        // Extract enum definitions from the interface file
+        const enumDefinitions = extractEnumDefinitions(interfaceContent);
+        // Find the main interface definition (starts with 'I' and is the main entity interface)
+        // Use a more robust approach to find the correct interface
+        let mainInterfaceBody = "";
+        // Split content by interface definitions and find the main one
+        const interfaceRegex = /export interface (I\w+)\s*\{([\s\S]*?)\}/g;
+        let match;
+        while ((match = interfaceRegex.exec(interfaceContent)) !== null) {
+            const [, interfaceName, body] = match;
+            // The main interface usually has _id field and more content
+            if (body.includes('_id') && body.includes('Types.ObjectId')) {
+                mainInterfaceBody = body;
+                break;
+            }
+        }
+        if (!mainInterfaceBody) {
+            // Fallback: find any interface starting with 'I'
+            const fallbackMatch = interfaceContent.match(/export interface I\w+\s*\{([\s\S]*?)\}/);
+            if (fallbackMatch) {
+                mainInterfaceBody = fallbackMatch[1];
+            }
+            else {
+                return fields;
+            }
+        }
+        const lines = mainInterfaceBody.split('\n');
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith('//') || trimmedLine.startsWith('_id') || trimmedLine.includes('createdAt') || trimmedLine.includes('updatedAt')) {
+                continue;
+            }
+            // Enhanced field parsing: fieldName?: Type;
+            const fieldMatch = trimmedLine.match(/(\w+)(\?)?:\s*([^;]+);?/);
+            if (fieldMatch) {
+                const [, name, optional, typeStr] = fieldMatch;
+                const isOptional = !!optional;
+                // Get additional info from model file
+                const modelFieldInfo = extractFieldInfoFromModel(name, modelContent);
+                // Enhanced type mapping with enum support
+                const fieldDef = mapTypeScriptTypeToFieldDefinition(name, typeStr, isOptional, modelFieldInfo, nestedInterfaces, enumDefinitions);
+                if (fieldDef) {
+                    fields.push(fieldDef);
+                }
+            }
+        }
+        return fields;
+    }
+    catch (error) {
+        console.error("Error extracting fields from interface:", error);
+        return [];
+    }
+}
+// Extract enum definitions from interface file
+function extractEnumDefinitions(content) {
+    const enumMap = new Map();
+    // Match TypeScript enum definitions: export enum EnumName { VALUE1 = 'value1', VALUE2 = 'value2' }
+    const enumRegex = /export enum (\w+)\s*\{([\s\S]*?)\}/g;
+    let match;
+    while ((match = enumRegex.exec(content)) !== null) {
+        const [, enumName, enumBody] = match;
+        const values = [];
+        // Extract enum values - handle both 'KEY = "value"' and 'KEY = value' formats
+        const valueRegex = /\w+\s*=\s*['"]([^'"]+)['"]/g;
+        let valueMatch;
+        while ((valueMatch = valueRegex.exec(enumBody)) !== null) {
+            values.push(valueMatch[1]);
+        }
+        if (values.length > 0) {
+            enumMap.set(enumName, values);
+        }
+    }
+    return enumMap;
+}
+// Extract nested interface definitions
+function extractNestedInterfaces(content) {
+    const nestedInterfaces = new Map();
+    // Find all interface definitions using a more robust approach
+    const interfaceRegex = /export interface (\w+)\s*\{([\s\S]*?)\}/g;
+    let match;
+    while ((match = interfaceRegex.exec(content)) !== null) {
+        const [, interfaceName, interfaceBody] = match;
+        // Skip the main interface (starts with 'I' and has more than 1 character after 'I')
+        if (interfaceName.startsWith('I') && interfaceName.length > 1 && interfaceName !== 'ItemsItem') {
+            continue;
+        }
+        // Skip type definitions
+        if (interfaceName.includes('Model') || interfaceName.includes('Type')) {
+            continue;
+        }
+        const fields = [];
+        const lines = interfaceBody.split('\n');
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith('//'))
+                continue;
+            const fieldMatch = trimmedLine.match(/(\w+)(\?)?:\s*([^;]+);?/);
+            if (fieldMatch) {
+                const [, name, optional, typeStr] = fieldMatch;
+                const isOptional = !!optional;
+                fields.push({
+                    name,
+                    type: mapSimpleType(typeStr),
+                    isOptional,
+                    isRequired: !isOptional
+                });
+            }
+        }
+        if (fields.length > 0) {
+            nestedInterfaces.set(interfaceName, fields);
+        }
+    }
+    return nestedInterfaces;
+}
+// Extract field information from model file
+function extractFieldInfoFromModel(fieldName, modelContent) {
+    if (!modelContent)
+        return null;
+    try {
+        // Look for field definition in schema - handle multiline definitions
+        const fieldRegex = new RegExp(`${fieldName}:\\s*\\{([^}]+)\\}`, 'i');
+        const match = modelContent.match(fieldRegex);
+        if (match) {
+            const fieldDef = match[1].trim();
+            // Extract enum values if present
+            const enumMatch = fieldDef.match(/enum:\s*\[([^\]]+)\]/);
+            if (enumMatch) {
+                const enumValues = enumMatch[1].split(',').map(v => v.trim().replace(/['"]/g, ''));
+                return { enumValues, isEnum: true };
+            }
+            // Extract reference information
+            const refMatch = fieldDef.match(/ref:\s*['"]([^'"]+)['"]/);
+            if (refMatch) {
+                return { ref: refMatch[1], isReference: true };
+            }
+            // Check if it's an array
+            if (fieldDef.includes('[') && fieldDef.includes(']')) {
+                return { isArray: true };
+            }
+        }
+        // Fallback: look for simpler field definitions
+        const simpleFieldRegex = new RegExp(`${fieldName}:\\s*([^,}]+)`, 'i');
+        const simpleMatch = modelContent.match(simpleFieldRegex);
+        if (simpleMatch) {
+            const fieldDef = simpleMatch[1].trim();
+            // Extract enum values from simple definitions
+            const enumMatch = fieldDef.match(/enum:\s*\[([^\]]+)\]/);
+            if (enumMatch) {
+                const enumValues = enumMatch[1].split(',').map(v => v.trim().replace(/['"]/g, ''));
+                return { enumValues, isEnum: true };
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+// Enhanced type mapping function
+function mapTypeScriptTypeToFieldDefinition(name, typeStr, isOptional, modelInfo, nestedInterfaces, enumDefinitions) {
+    // Check if typeStr is an enum type reference (e.g., "TypeEnum")
+    if (enumDefinitions && enumDefinitions.has(typeStr.trim())) {
+        const enumValues = enumDefinitions.get(typeStr.trim());
+        return {
+            name,
+            type: "enum",
+            enumValues: enumValues || [],
+            isOptional,
+            isRequired: !isOptional
+        };
+    }
+    // Handle enum types from model or interface
+    if ((modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.isEnum) && modelInfo.enumValues) {
+        return {
+            name,
+            type: "enum",
+            enumValues: modelInfo.enumValues,
+            isOptional,
+            isRequired: !isOptional
+        };
+    }
+    // Check if it's a union type enum in the interface (e.g., 'active' | 'inactive')
+    if (typeStr.includes('|')) {
+        const enumValues = typeStr.split('|').map(v => v.trim().replace(/['"]/g, ''));
+        return {
+            name,
+            type: "enum",
+            enumValues,
+            isOptional,
+            isRequired: !isOptional
+        };
+    }
+    // Handle ObjectId references
+    if (typeStr.includes("Types.ObjectId") || typeStr.includes("ObjectId")) {
+        if (typeStr.includes("[]")) {
+            // Array of ObjectIds
+            return {
+                name,
+                type: "array",
+                arrayItemType: "objectid",
+                ref: (modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.ref) || "Document",
+                isOptional,
+                isRequired: !isOptional
+            };
+        }
+        else {
+            // Single ObjectId
+            return {
+                name,
+                type: "objectid",
+                ref: (modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.ref) || "Document",
+                isOptional,
+                isRequired: !isOptional
+            };
+        }
+    }
+    // Handle arrays
+    if (typeStr.includes("[]")) {
+        const baseType = typeStr.replace("[]", "").trim();
+        // Check if it's an array of nested interface objects
+        if (nestedInterfaces.has(baseType)) {
+            const objectProperties = nestedInterfaces.get(baseType) || [];
+            return {
+                name,
+                type: "array",
+                ref: "object",
+                objectProperties,
+                isOptional,
+                isRequired: !isOptional
+            };
+        }
+        // Handle basic array types with proper arrayItemType
+        const arrayItemType = mapSimpleType(baseType);
+        return {
+            name,
+            type: "array",
+            arrayItemType,
+            isOptional,
+            isRequired: !isOptional
+        };
+    }
+    // Handle nested objects
+    if (nestedInterfaces.has(typeStr)) {
+        const objectProperties = nestedInterfaces.get(typeStr) || [];
+        return {
+            name,
+            type: "object",
+            objectProperties,
+            isOptional,
+            isRequired: !isOptional
+        };
+    }
+    // Handle basic types
+    return {
+        name,
+        type: mapSimpleType(typeStr),
+        isOptional,
+        isRequired: !isOptional
+    };
+}
+// Simple type mapping helper
+function mapSimpleType(typeStr) {
+    const cleanType = typeStr.toLowerCase().trim();
+    if (cleanType.includes("string"))
+        return "string";
+    if (cleanType.includes("number"))
+        return "number";
+    if (cleanType.includes("boolean"))
+        return "boolean";
+    if (cleanType.includes("date"))
+        return "date";
+    if (cleanType.includes("objectid"))
+        return "objectid";
+    return "string"; // Default fallback
+}
+function toCamelCase(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/utils/fieldParser.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFieldDefinitions = parseFieldDefinitions;
+function parseFieldDefinitions(args) {
+    const fields = [];
+    const skipFiles = [];
+    let skipMode = false;
+    let hasFile = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--skip") {
+            skipMode = true;
+            continue;
+        }
+        if (arg === "--file:true" || arg === "file:true") {
+            hasFile = true;
+            continue;
+        }
+        if (skipMode) {
+            skipFiles.push(arg);
+        }
+        else {
+            try {
+                // Check if the argument contains enum values
+                const enumMatch = arg.match(/^([a-zA-Z0-9_]+(?:\?|!)?)\[([^\]]+)\]$/);
+                if (enumMatch) {
+                    // This is an enum field with values in square brackets
+                    let [, name, enumValues] = enumMatch;
+                    const enumOptions = enumValues.split(",").map((v) => v.trim());
+                    // Check for optional marker (?)
+                    const isOptional = name.endsWith("?");
+                    if (isOptional) {
+                        name = name.slice(0, -1);
+                    }
+                    // Check for required marker (!)
+                    const isRequired = name.endsWith("!");
+                    if (isRequired) {
+                        name = name.slice(0, -1);
+                    }
+                    fields.push({
+                        name,
+                        type: "enum",
+                        enumValues: enumOptions,
+                        isRequired,
+                        isOptional,
+                    });
+                    console.log(`Added enum field: ${name} with values [${enumOptions.join(", ")}]`);
+                }
+                else {
+                    // Process as field definition
+                    const parts = arg.split(":");
+                    if (parts.length >= 2) {
+                        let name = parts[0].trim();
+                        const typeRaw = parts[1].trim(); // Don't lowercase yet to preserve enum values if any
+                        let type = typeRaw.toLowerCase();
+                        // Check if type follows enum[a,b] pattern
+                        const typeEnumMatch = typeRaw.match(/^enum\[([^\]]+)\]$/i);
+                        if (typeEnumMatch) {
+                            const enumValues = typeEnumMatch[1].split(",").map((v) => v.trim());
+                            // Check for optional marker (?)
+                            const isOptional = name.endsWith("?");
+                            if (isOptional) {
+                                name = name.slice(0, -1);
+                            }
+                            // Check for required marker (!)
+                            const isRequired = name.endsWith("!");
+                            if (isRequired) {
+                                name = name.slice(0, -1);
+                            }
+                            fields.push({
+                                name,
+                                type: "enum",
+                                enumValues,
+                                isRequired,
+                                isOptional,
+                            });
+                            console.log(`Added enum field: ${name} with values [${enumValues.join(", ")}]`);
+                            continue;
+                        }
+                        // Skip _id field as it's automatically handled by MongoDB
+                        if (name.toLowerCase() === "_id") {
+                            continue;
+                        }
+                        // Check for optional marker (?)
+                        const isOptional = name.endsWith("?");
+                        if (isOptional) {
+                            name = name.slice(0, -1);
+                        }
+                        // Check for required marker (!)
+                        const isRequired = name.endsWith("!");
+                        if (isRequired) {
+                            name = name.slice(0, -1);
+                        }
+                        // Handle array of objects with properties
+                        if (type === "array" &&
+                            parts.length > 2 &&
+                            parts[2].toLowerCase() === "object") {
+                            console.log(`Processing array of objects field: ${name}`);
+                            const objectProperties = [];
+                            for (let j = 3; j < parts.length; j += 2) {
+                                if (j + 1 < parts.length) {
+                                    let propName = parts[j];
+                                    const propType = parts[j + 1];
+                                    console.log(`  Property: ${propName}:${propType}`);
+                                    const propIsOptional = propName.endsWith("?");
+                                    const propIsRequired = propName.endsWith("!");
+                                    if (propIsOptional) {
+                                        propName = propName.slice(0, -1);
+                                    }
+                                    if (propIsRequired) {
+                                        propName = propName.slice(0, -1);
+                                    }
+                                    objectProperties.push({
+                                        name: propName,
+                                        type: propType,
+                                        isOptional: propIsOptional,
+                                        isRequired: propIsRequired,
+                                    });
+                                }
+                            }
+                            fields.push({
+                                name,
+                                type,
+                                ref: "object",
+                                isRequired,
+                                isOptional,
+                                objectProperties,
+                            });
+                            console.log(`Added field with ${objectProperties.length} properties`);
+                        }
+                        else if (type === "array" && parts.length > 2) {
+                            // Handle array of references (e.g., products:array:objectid:Product)
+                            const arrayItemType = parts[2].toLowerCase();
+                            let ref = parts.length > 3 ? parts[3].trim() : undefined;
+                            fields.push({
+                                name,
+                                type,
+                                arrayItemType,
+                                ref,
+                                isRequired,
+                                isOptional,
+                            });
+                            console.log(`Added array field: ${name}:${type}:${arrayItemType}${ref ? `:${ref}` : ""}`);
+                        }
+                        else {
+                            // Regular field
+                            const ref = parts.length > 2 ? parts[2].trim() : undefined;
+                            fields.push({ name, type, ref, isRequired, isOptional });
+                            console.log(`Added regular field: ${name}:${type}${ref ? `:${ref}` : ""}`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error parsing field definition: ${arg}`, error);
+            }
+        }
+    }
+    console.log("Parsed fields:", JSON.stringify(fields, null, 2));
+    if (hasFile)
+        console.log("📂 File upload support enabled");
+    return { fields, skipFiles, hasFile };
+}

package/dist/utils/helperGenerator.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFileHelper = generateFileHelper;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function generateFileHelper(baseDir = 'src') {
+    const helpersDir = path.join(process.cwd(), baseDir, 'helpers');
+    const filePath = path.join(helpersDir, 'fileHelper.ts');
+    // Create helpers directory if it doesn't exist
+    if (!fs.existsSync(helpersDir)) {
+        fs.mkdirSync(helpersDir, { recursive: true });
+        console.log(`✅ Created directory: ${helpersDir}`);
+    }
+    // Define the content for the file helper
+    const content = `import fs from 'fs/promises';
+import path from 'path';
+
+async function removeFile(filenames: string | string[]) {
+    if (!filenames || (Array.isArray(filenames) && filenames.length === 0)) return;
+
+    // Normalize to array for consistent handling
+    const files = Array.isArray(filenames) ? filenames : [filenames];
+
+    for (const filename of files) {
+        if (!filename) continue;
+
+        // Remove leading '/images/' if included
+        const cleanedName = filename.replace(/^\/?images\//, '');
+        const filePath = path.join(process.cwd(), 'uploads', 'images', cleanedName);
+
+        try {
+            await fs.unlink(filePath);
+            console.log(\`Deleted image: \${cleanedName}\`);
+        } catch (err) {
+            if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+                console.warn(\`File not found: \${cleanedName}\`);
+            } else {
+                console.error(\`Error deleting file \${cleanedName}:\`, err);
+            }
+        }
+    }
+}
+
+export default removeFile;
+`;
+    // Write file if it doesn't exist
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, content);
+        console.log(`✅ Created file: ${filePath}`);
+    }
+    else {
+        console.log(`ℹ️  File already exists: ${filePath}`);
+    }
+}