nexpgen 1.0.0

package/src/utils/fileGenerator.js

@@ -0,0 +1,617 @@
+const fs = require('fs');
+const path = require('path');
+
+
+class TemplateError extends Error {
+  constructor(message, templateName) {
+    super(message);
+    this.name = 'TemplateError';
+    this.templateName = templateName;
+  }
+}
+
+class ConfigError extends Error {
+  constructor(message, configPath) {
+    super(message);
+    this.name = 'ConfigError';
+    this.configPath = configPath;
+  }
+}
+
+class ValidationError extends Error {
+  constructor(message, field) {
+    super(message);
+    this.name = 'ValidationError';
+    this.field = field;
+  }
+}
+
+
+const utils = {
+  /**
+   * Safely read file with error handling
+   */
+  readFileSafe(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+      }
+      return fs.readFileSync(filePath, 'utf-8');
+    } catch (error) {
+      if (error.code === 'EACCES') {
+        throw new Error(`Permission denied reading: ${filePath}`);
+      }
+      throw error;
+    }
+  },
+
+  /**
+   * Safely write file with directory creation
+   */
+  writeFileSafe(filePath, content) {
+    try {
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(filePath, content, 'utf-8');
+      return true;
+    } catch (error) {
+      if (error.code === 'EACCES') {
+        throw new Error(`Permission denied writing: ${filePath}`);
+      }
+      throw error;
+    }
+  },
+
+  /**
+   * Check if path is safe (within cwd)
+   */
+  isPathSafe(targetPath, basePath = process.cwd()) {
+    const resolvedTarget = path.resolve(targetPath);
+    const resolvedBase = path.resolve(basePath);
+    const normalizedTarget = path.normalize(resolvedTarget);
+    const normalizedBase = path.normalize(resolvedBase);
+    return normalizedTarget.startsWith(normalizedBase);
+  },
+
+  /**
+   * Deep clone object
+   */
+  deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+  }
+};
+
+class FileGenerator {
+  constructor() {
+    this.templateDir = path.join(__dirname, '../templates');
+    this.validateTemplateDir();
+    
+    this._configCache = null;
+    this._templateCache = new Map();
+    this._configPath = null;
+    this._configMtime = null;
+    
+    this._ifRegex = /\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{else\}\}([\s\S]*?)\{\{\/if\}\}/g;
+    
+    this._fileExistsCache = new Map();
+    this._fileExistsCacheTime = 0;
+    this._CACHE_TTL = 5000; 
+  }
+
+  validateTemplateDir() {
+    try {
+      if (!fs.existsSync(this.templateDir)) {
+        throw new TemplateError(`Template directory not found: ${this.templateDir}`, 'templateDir');
+      }
+      const stats = fs.statSync(this.templateDir);
+      if (!stats.isDirectory()) {
+        throw new TemplateError(`Template path is not a directory: ${this.templateDir}`, 'templateDir');
+      }
+    } catch (error) {
+      if (error instanceof TemplateError) {
+        throw error;
+      }
+      throw new TemplateError(`Template directory validation failed: ${error.message}`, 'templateDir');
+    }
+  }
+
+  _clearFileExistsCache() {
+    const now = Date.now();
+    if (now - this._fileExistsCacheTime > this._CACHE_TTL) {
+      this._fileExistsCache.clear();
+      this._fileExistsCacheTime = now;
+    }
+  }
+
+  _cacheFileExists(filePath) {
+    this._clearFileExistsCache();
+    if (!this._fileExistsCache.has(filePath)) {
+      this._fileExistsCache.set(filePath, fs.existsSync(filePath));
+    }
+    return this._fileExistsCache.get(filePath);
+  }
+
+  readConfig() {
+    try {
+      const configPath = path.resolve(process.cwd(), '.nexpgenrc');
+      
+      
+      if (this._configCache && this._configPath === configPath) {
+        try {
+          const stats = fs.statSync(configPath);
+          if (stats.mtimeMs === this._configMtime) {
+            return utils.deepClone(this._configCache); 
+          }
+        } catch {
+          
+        }
+      }
+
+      this._configPath = configPath;
+      
+      if (!this._cacheFileExists(configPath)) {
+        this._configCache = { functionStyle: 'class' };
+        return utils.deepClone(this._configCache);
+      }
+
+      const stats = fs.statSync(configPath);
+      this._configMtime = stats.mtimeMs;
+      
+      if (!stats.isFile()) {
+        throw new ConfigError('.nexpgenrc exists but is not a file', configPath);
+      }
+
+      const content = utils.readFileSafe(configPath);
+      
+      if (!content || content.trim().length === 0) {
+        this._configCache = { functionStyle: 'class' };
+        return utils.deepClone(this._configCache);
+      }
+
+      try {
+        const config = JSON.parse(content);
+        
+        
+        if (config.functionStyle && !['class', 'arrow'].includes(config.functionStyle)) {
+          console.warn(`⚠️  Invalid functionStyle in config, using default: class`);
+          config.functionStyle = 'class';
+        }
+
+        
+        if (config.packages && !Array.isArray(config.packages)) {
+          config.packages = [];
+        }
+
+        this._configCache = config;
+        return utils.deepClone(this._configCache);
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          throw new ConfigError(`Invalid JSON in .nexpgenrc: ${error.message}`, configPath);
+        }
+        throw error;
+      }
+    } catch (error) {
+      if (error.code === 'EACCES') {
+        throw new ConfigError(`Permission denied reading .nexpgenrc`, this._configPath);
+      }
+      if (error instanceof ConfigError) {
+        throw error;
+      }
+      console.warn(`⚠️  Failed to read config, using defaults: ${error.message}`);
+      this._configCache = { functionStyle: 'class' };
+      return utils.deepClone(this._configCache);
+    }
+  }
+
+  readTemplate(templateName) {
+    try {
+      if (!templateName || typeof templateName !== 'string' || templateName.trim().length === 0) {
+        throw new ValidationError('Template name must be a non-empty string', 'templateName');
+      }
+
+      
+      if (this._templateCache.has(templateName)) {
+        return this._templateCache.get(templateName);
+      }
+
+      
+      const sanitizedName = path.basename(templateName);
+      if (sanitizedName !== templateName) {
+        throw new ValidationError(`Invalid template name: ${templateName}`, 'templateName');
+      }
+
+      const templatePath = path.join(this.templateDir, `${sanitizedName}.template`);
+      const normalizedPath = path.normalize(templatePath);
+      
+      
+      if (!normalizedPath.startsWith(path.normalize(this.templateDir))) {
+        throw new TemplateError(`Template path outside template directory: ${templateName}`, templateName);
+      }
+      
+      if (!this._cacheFileExists(normalizedPath)) {
+        throw new TemplateError(`Template not found: ${templateName}`, templateName);
+      }
+
+      const stats = fs.statSync(normalizedPath);
+      if (!stats.isFile()) {
+        throw new TemplateError(`Template path is not a file: ${templateName}`, templateName);
+      }
+
+      const content = utils.readFileSafe(normalizedPath);
+      
+      if (!content || content.trim().length === 0) {
+        throw new TemplateError(`Template file is empty: ${templateName}`, templateName);
+      }
+
+      
+      this._templateCache.set(templateName, content);
+      return content;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new TemplateError(`Template file not found: ${templateName}`, templateName);
+      } else if (error.code === 'EACCES') {
+        throw new TemplateError(`Permission denied reading template: ${templateName}`, templateName);
+      }
+      if (error instanceof TemplateError || error instanceof ValidationError) {
+        throw error;
+      }
+      throw new TemplateError(`Failed to read template: ${error.message}`, templateName);
+    }
+  }
+
+  processTemplate(template, data) {
+    try {
+      if (!template || typeof template !== 'string') {
+        throw new ValidationError('Template must be a non-empty string', 'template');
+      }
+
+      if (!data || typeof data !== 'object') {
+        throw new ValidationError('Template data must be an object', 'data');
+      }
+
+      let content = template;
+      
+      
+      
+      this._ifRegex.lastIndex = 0;
+      content = content.replace(this._ifRegex, (match, condition, ifBlock, elseBlock) => {
+        if (!condition || typeof condition !== 'string') {
+          return match; 
+        }
+        return data[condition] ? ifBlock : elseBlock;
+      });
+
+      
+      
+      const sortedKeys = Object.keys(data).sort((a, b) => b.length - a.length);
+      sortedKeys.forEach(key => {
+        if (key && typeof key === 'string') {
+          const value = data[key];
+          const safeValue = value !== null && value !== undefined ? String(value) : '';
+          
+          const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+          const regex = new RegExp(`\\{\\{${escapedKey}\\}\\}`, 'g');
+          content = content.replace(regex, safeValue);
+        }
+      });
+
+      return content;
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        throw error;
+      }
+      throw new Error(`Template processing failed: ${error.message}`);
+    }
+  }
+
+  toCamelCase(str) {
+    if (!str || typeof str !== 'string') {
+      return '';
+    }
+    
+    return str
+      .split(/[-_/]/)
+      .filter(word => word.length > 0)
+      .map((word, index) => {
+        const cleaned = word.trim();
+        if (cleaned.length === 0) return '';
+        if (index === 0) {
+          return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
+        }
+        return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+      })
+      .filter(word => word.length > 0)
+      .join('');
+  }
+
+  toPascalCase(str) {
+    if (!str || typeof str !== 'string') {
+      return '';
+    }
+    
+    return str
+      .split(/[-_/]/)
+      .filter(word => word.length > 0)
+      .map(word => {
+        const cleaned = word.trim();
+        return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+      })
+      .filter(word => word.length > 0)
+      .join('');
+  }
+
+  sanitizeFileName(fileName) {
+    if (!fileName || typeof fileName !== 'string') {
+      return 'file';
+    }
+    
+    
+    let sanitized = fileName
+      .replace(/[<>:"|?*\x00-\x1f]/g, '')
+      .replace(/^\.+/, '') 
+      .replace(/\.+$/, '') 
+      .trim();
+    
+    
+    if (!sanitized || sanitized.length === 0) {
+      return 'file';
+    }
+    
+    return sanitized;
+  }
+
+  generateFromTemplate(templateType, name, outputDir) {
+    try {
+      
+      if (!templateType || typeof templateType !== 'string') {
+        throw new ValidationError('Template type must be a non-empty string', 'templateType');
+      }
+
+      if (!name || typeof name !== 'string' || name.trim().length === 0) {
+        throw new ValidationError('Name must be a non-empty string', 'name');
+      }
+
+      if (!outputDir || typeof outputDir !== 'string') {
+        throw new ValidationError('Output directory must be a non-empty string', 'outputDir');
+      }
+
+      const template = this.readTemplate(templateType);
+      const config = this.readConfig();
+      
+      
+      const nameParts = name.split('/').filter(part => part.trim().length > 0);
+      
+      if (nameParts.length === 0) {
+        throw new ValidationError('Invalid name: empty after splitting', 'name');
+      }
+
+      const finalName = nameParts[nameParts.length - 1];
+      const sanitizedName = this.sanitizeFileName(finalName);
+      
+      if (sanitizedName !== finalName) {
+        console.warn(`⚠️  Name sanitized: ${finalName} -> ${sanitizedName}`);
+      }
+
+      const className = this.toPascalCase(sanitizedName);
+      const camelCaseName = this.toCamelCase(sanitizedName);
+      
+      if (!className || className.length === 0) {
+        throw new ValidationError('Failed to generate valid class name', 'className');
+      }
+
+      
+      let relativePath = '';
+      if (nameParts.length > 1) {
+        
+        const dirParts = nameParts.slice(0, -1).map(part => this.sanitizeFileName(part));
+        relativePath = dirParts.join('/');
+      }
+      
+      const fileName = this.getFileName(templateType, sanitizedName);
+      const resolvedOutputDir = path.resolve(outputDir);
+      const fullOutputDir = relativePath 
+        ? path.join(resolvedOutputDir, relativePath)
+        : resolvedOutputDir;
+      
+      
+      if (!utils.isPathSafe(fullOutputDir)) {
+        throw new ValidationError(`Output directory outside current working directory: ${fullOutputDir}`, 'outputDir');
+      }
+
+      const templateData = {
+        name: sanitizedName,
+        className: className,
+        camelCaseName: camelCaseName,
+        isClass: config.functionStyle === 'class'
+      };
+
+      const content = this.processTemplate(template, templateData);
+
+      const filePath = path.join(fullOutputDir, fileName);
+      
+      
+      if (!this._cacheFileExists(fullOutputDir)) {
+        try {
+          fs.mkdirSync(fullOutputDir, { recursive: true });
+          
+          this._fileExistsCache.delete(fullOutputDir);
+        } catch (error) {
+          if (error.code === 'EACCES') {
+            throw new Error(`Permission denied creating directory: ${fullOutputDir}`);
+          }
+          throw new Error(`Failed to create directory ${fullOutputDir}: ${error.message}`);
+        }
+      }
+
+      
+      if (this._cacheFileExists(filePath)) {
+        const errorMsg = `File already exists: ${filePath}`;
+        console.error(`❌ ${errorMsg}`);
+        throw new Error(errorMsg);
+      }
+
+      utils.writeFileSafe(filePath, content);
+      console.log(`✅ Generated: ${filePath}`);
+    } catch (error) {
+      const errorMsg = error instanceof ValidationError || error instanceof TemplateError
+        ? error.message
+        : `Error generating file: ${error.message}`;
+      console.error(`❌ ${errorMsg}`);
+      throw error;
+    }
+  }
+
+  getFileName(templateType, name) {
+    const extensions = {
+      controller: '.controller.js',
+      service: '.service.js',
+      util: '.util.js',
+      error: '.error.js',
+      route: '.routes.js',
+      middleware: '.middleware.js'
+    };
+
+    const extension = extensions[templateType] || '.js';
+    const sanitizedName = this.sanitizeFileName(name);
+    
+    return `${sanitizedName}${extension}`;
+  }
+
+  generateMiddleware(name, outputDir) {
+    try {
+      const nameParts = name.split('/').filter(part => part.trim().length > 0);
+      if (nameParts.length === 0) {
+        throw new ValidationError('Invalid middleware name: empty after splitting', 'name');
+      }
+
+      const finalName = nameParts[nameParts.length - 1];
+      const sanitizedName = this.sanitizeFileName(finalName);
+      const className = this.toPascalCase(sanitizedName);
+      const camelCaseName = this.toCamelCase(sanitizedName);
+      const config = this.readConfig();
+
+      
+      const middlewareTypes = {
+        auth: { isAuth: true },
+        authentication: { isAuth: true },
+        validate: { isValidation: true },
+        validation: { isValidation: true },
+        error: { isErrorHandler: true },
+        errorhandler: { isErrorHandler: true },
+        ratelimit: { isRateLimit: true },
+        'rate-limit': { isRateLimit: true }
+      };
+
+      const typeKey = sanitizedName.toLowerCase().replace(/[-_]/g, '');
+      const middlewareType = middlewareTypes[typeKey] || { isAuth: true }; 
+
+      const template = this.readTemplate('middleware');
+      const templateData = {
+        name: sanitizedName,
+        className: className,
+        camelCaseName: camelCaseName,
+        isClass: config.functionStyle === 'class',
+        ...middlewareType
+      };
+
+      const content = this.processTemplate(template, templateData);
+      
+      let relativePath = '';
+      if (nameParts.length > 1) {
+        const dirParts = nameParts.slice(0, -1).map(part => this.sanitizeFileName(part));
+        relativePath = dirParts.join('/');
+      }
+
+      const fileName = this.getFileName('middleware', sanitizedName);
+      const resolvedOutputDir = path.resolve(outputDir);
+      const fullOutputDir = relativePath 
+        ? path.join(resolvedOutputDir, relativePath)
+        : resolvedOutputDir;
+
+      
+      if (!utils.isPathSafe(fullOutputDir)) {
+        throw new ValidationError(`Output directory outside current working directory: ${fullOutputDir}`, 'outputDir');
+      }
+
+      
+      if (!this._cacheFileExists(fullOutputDir)) {
+        try {
+          fs.mkdirSync(fullOutputDir, { recursive: true });
+          this._fileExistsCache.delete(fullOutputDir);
+        } catch (error) {
+          if (error.code === 'EACCES') {
+            throw new Error(`Permission denied creating directory: ${fullOutputDir}`);
+          }
+          throw new Error(`Failed to create directory ${fullOutputDir}: ${error.message}`);
+        }
+      }
+
+      const filePath = path.join(fullOutputDir, fileName);
+      
+      if (this._cacheFileExists(filePath)) {
+        throw new Error(`File already exists: ${filePath}`);
+      }
+
+      utils.writeFileSafe(filePath, content);
+      console.log(`✅ Generated: ${filePath}`);
+    } catch (error) {
+      const errorMsg = error instanceof ValidationError || error instanceof TemplateError
+        ? error.message
+        : `Failed to generate middleware: ${error.message}`;
+      throw new Error(errorMsg);
+    }
+  }
+
+  generateCRUD(name, outputDir) {
+    try {
+      console.log(`\n🚀 Generating CRUD for: ${name}\n`);
+      
+      
+      const nameParts = name.split('/').filter(part => part.trim().length > 0);
+      if (nameParts.length === 0) {
+        throw new ValidationError('Invalid CRUD name: empty after splitting', 'name');
+      }
+      
+      const finalName = nameParts[nameParts.length - 1];
+      const camelCaseName = this.toCamelCase(finalName);
+      const pluralName = `${finalName}s`; 
+      
+      
+      this.generateFromTemplate('controller', name, outputDir);
+      
+      
+      this.generateFromTemplate('service', name, outputDir);
+      
+      
+      this.generateFromTemplate('route', name, outputDir);
+      
+      console.log(`\n✨ CRUD generation complete for: ${name}`);
+      console.log(`📝 Don't forget to register routes in your server.js:\n`);
+      console.log(`   const ${camelCaseName}Routes = require('./src/routes/${finalName}.routes');`);
+      console.log(`   app.use('/api/${pluralName}', ${camelCaseName}Routes);\n`);
+    } catch (error) {
+      const errorMsg = error instanceof ValidationError || error instanceof TemplateError
+        ? error.message
+        : `Failed to generate CRUD: ${error.message}`;
+      throw new Error(errorMsg);
+    }
+  }
+
+  
+  clearCache() {
+    this._configCache = null;
+    this._configMtime = null;
+    this._templateCache.clear();
+    this._fileExistsCache.clear();
+    this._fileExistsCacheTime = 0;
+  }
+}
+
+
+module.exports = new FileGenerator();
+module.exports.utils = utils;
+module.exports.TemplateError = TemplateError;
+module.exports.ConfigError = ConfigError;
+module.exports.ValidationError = ValidationError;