nexpgen 1.0.0

package/src/utils/architectureGenerator.js

@@ -0,0 +1,925 @@
+const fs = require('fs');
+const path = require('path');
+
+
+class TemplateError extends Error {
+  constructor(message, templateName) {
+    super(message);
+    this.name = 'TemplateError';
+    this.templateName = templateName;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+class ConfigError extends Error {
+  constructor(message, configPath) {
+    super(message);
+    this.name = 'ConfigError';
+    this.configPath = configPath;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+class ValidationError extends Error {
+  constructor(message, field) {
+    super(message);
+    this.name = 'ValidationError';
+    this.field = field;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+class FileSystemError extends Error {
+  constructor(message, filePath, code) {
+    super(message);
+    this.name = 'FileSystemError';
+    this.filePath = filePath;
+    this.code = code;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+
+const logger = {
+  _isVerbose: process.env.nexpgen_VERBOSE === 'true' || process.env.NODE_ENV === 'development',
+  
+  info(message) {
+    console.log(`ℹ️  ${message}`);
+  },
+  
+  success(message) {
+    console.log(`✅ ${message}`);
+  },
+  
+  warn(message) {
+    console.warn(`⚠️  ${message}`);
+  },
+  
+  error(message, error = null) {
+    console.error(`❌ ${message}`);
+    if (error && this._isVerbose && error.stack) {
+      console.error('Stack trace:', error.stack);
+    }
+  },
+  
+  debug(message) {
+    if (this._isVerbose) {
+      console.log(`🔍 DEBUG: ${message}`);
+    }
+  },
+  
+  verbose(message) {
+    if (this._isVerbose) {
+      console.log(`📝 ${message}`);
+    }
+  }
+};
+
+
+const utils = {
+  /**
+   * Safely read file with error handling
+   */
+  readFileSafe(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) {
+        throw new FileSystemError(`File not found: ${filePath}`, filePath, 'ENOENT');
+      }
+      const content = fs.readFileSync(filePath, 'utf-8');
+      logger.debug(`Read file: ${filePath}`);
+      return content;
+    } catch (error) {
+      if (error instanceof FileSystemError) {
+        throw error;
+      }
+      if (error.code === 'EACCES') {
+        throw new FileSystemError(`Permission denied reading: ${filePath}`, filePath, 'EACCES');
+      }
+      throw new FileSystemError(`Failed to read file: ${error.message}`, filePath, error.code);
+    }
+  },
+
+  /**
+   * Safely write file with directory creation
+   */
+  writeFileSafe(filePath, content) {
+    try {
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+        logger.debug(`Created directory: ${dir}`);
+      }
+      fs.writeFileSync(filePath, content, 'utf-8');
+      logger.debug(`Wrote file: ${filePath}`);
+      return true;
+    } catch (error) {
+      if (error.code === 'EACCES') {
+        throw new FileSystemError(`Permission denied writing: ${filePath}`, filePath, 'EACCES');
+      }
+      throw new FileSystemError(`Failed to write file: ${error.message}`, filePath, error.code);
+    }
+  },
+
+  /**
+   * Check if path is safe (within cwd) - prevents directory traversal
+   */
+  isPathSafe(targetPath, basePath = process.cwd()) {
+    try {
+      const resolvedTarget = path.resolve(targetPath);
+      const resolvedBase = path.resolve(basePath);
+      const normalizedTarget = path.normalize(resolvedTarget);
+      const normalizedBase = path.normalize(resolvedBase);
+      
+      
+      const isWithin = normalizedTarget.startsWith(normalizedBase);
+      const hasDangerousPatterns = normalizedTarget.includes('..') || 
+                                     normalizedTarget.includes('\0') ||
+                                     normalizedTarget.includes('\x00');
+      
+      return isWithin && !hasDangerousPatterns;
+    } catch (error) {
+      logger.debug(`Path safety check failed: ${error.message}`);
+      return false;
+    }
+  },
+
+  /**
+   * Deep clone object (prevents accidental mutations)
+   */
+  deepClone(obj) {
+    try {
+      return JSON.parse(JSON.stringify(obj));
+    } catch (error) {
+      logger.warn(`Deep clone failed, returning original: ${error.message}`);
+      return obj;
+    }
+  },
+
+  /**
+   * Validate file path
+   */
+  validateFilePath(filePath) {
+    if (!filePath || typeof filePath !== 'string') {
+      throw new ValidationError('File path must be a non-empty string', 'filePath');
+    }
+    
+    
+    if (filePath.includes('..') || filePath.includes('\0') || filePath.includes('\x00')) {
+      throw new ValidationError('File path contains dangerous patterns', 'filePath');
+    }
+    
+    return true;
+  },
+
+  /**
+   * Escape regex special characters
+   */
+  escapeRegex(str) {
+    if (!str || typeof str !== 'string') return '';
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+};
+
+class ArchitectureGenerator {
+  constructor() {
+    this.templateDir = path.join(__dirname, '../templates');
+    this.serverTemplateDir = path.join(this.templateDir, 'servers');
+    this.helperTemplateDir = path.join(this.templateDir, 'helpers');
+    this.validatePaths();
+    
+    this._templateCache = new Map();
+    
+    this._ifRegex = /\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{else\}\}([\s\S]*?)\{\{\/if\}\}/g;
+    
+    this._fileExistsCache = new Map();
+    this._fileExistsCacheTime = 0;
+    this._CACHE_TTL = 5000; 
+  }
+
+  validatePaths() {
+    try {
+      
+      const pathsToCheck = [
+        { path: this.templateDir, name: 'Template directory' },
+        { path: this.serverTemplateDir, name: 'Server template directory' },
+        { path: this.helperTemplateDir, name: 'Helper template directory' }
+      ];
+
+      for (const { path: checkPath, name } of pathsToCheck) {
+        if (!fs.existsSync(checkPath)) {
+          throw new FileSystemError(`${name} not found: ${checkPath}`, checkPath, 'ENOENT');
+        }
+        const stats = fs.statSync(checkPath);
+        if (!stats.isDirectory()) {
+          throw new FileSystemError(`${name} is not a directory: ${checkPath}`, checkPath, 'ENOTDIR');
+        }
+      }
+      logger.debug('All template paths validated successfully');
+    } catch (error) {
+      if (error instanceof FileSystemError) {
+        logger.error(`Path validation failed: ${error.message}`);
+        throw error;
+      }
+      throw new FileSystemError(`Path validation failed: ${error.message}`, '', error.code);
+    }
+  }
+
+  _clearFileExistsCache() {
+    const now = Date.now();
+    if (now - this._fileExistsCacheTime > this._CACHE_TTL) {
+      this._fileExistsCache.clear();
+      this._fileExistsCacheTime = now;
+      logger.debug('File existence cache cleared');
+    }
+  }
+
+  _cacheFileExists(filePath) {
+    this._clearFileExistsCache();
+    if (!this._fileExistsCache.has(filePath)) {
+      this._fileExistsCache.set(filePath, fs.existsSync(filePath));
+    }
+    return this._fileExistsCache.get(filePath);
+  }
+
+  readTemplate(templatePath) {
+    try {
+      if (!templatePath || typeof templatePath !== 'string') {
+        throw new ValidationError('Template path must be a non-empty string', 'templatePath');
+      }
+
+      
+      utils.validateFilePath(templatePath);
+
+      
+      if (this._templateCache.has(templatePath)) {
+        logger.debug(`Template cache hit: ${templatePath}`);
+        return this._templateCache.get(templatePath);
+      }
+
+      const normalizedPath = path.normalize(templatePath);
+      
+      
+      if (!utils.isPathSafe(normalizedPath, this.templateDir)) {
+        throw new TemplateError(`Template path outside template directory: ${templatePath}`, templatePath);
+      }
+      
+      if (!this._cacheFileExists(normalizedPath)) {
+        throw new TemplateError(`Template not found: ${templatePath}`, templatePath);
+      }
+
+      const stats = fs.statSync(normalizedPath);
+      if (!stats.isFile()) {
+        throw new TemplateError(`Path is not a file: ${templatePath}`, templatePath);
+      }
+
+      const content = utils.readFileSafe(normalizedPath);
+      
+      if (!content || content.trim().length === 0) {
+        throw new TemplateError(`Template file is empty: ${templatePath}`, templatePath);
+      }
+
+      
+      this._templateCache.set(templatePath, content);
+      logger.debug(`Template cached: ${templatePath}`);
+      return content;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new TemplateError(`Template file not found: ${templatePath}`, templatePath);
+      } else if (error.code === 'EACCES') {
+        throw new TemplateError(`Permission denied reading template: ${templatePath}`, templatePath);
+      }
+      if (error instanceof TemplateError || error instanceof ValidationError || error instanceof FileSystemError) {
+        throw error;
+      }
+      throw new TemplateError(`Failed to read template: ${error.message}`, templatePath);
+    }
+  }
+
+  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 = utils.escapeRegex(key);
+          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}`);
+    }
+  }
+
+  validateInputs(architecture, functionStyle, packageName, packages) {
+    const errors = [];
+
+    
+    const validArchitectures = ['mvc', 'microservices', 'layered', 'clean', 'simple'];
+    if (!architecture || typeof architecture !== 'string') {
+      errors.push('Architecture must be a non-empty string');
+    } else if (!validArchitectures.includes(architecture)) {
+      errors.push(`Invalid architecture. Must be one of: ${validArchitectures.join(', ')}`);
+    }
+
+    
+    const validStyles = ['class', 'arrow'];
+    if (!functionStyle || typeof functionStyle !== 'string') {
+      errors.push('Function style must be a non-empty string');
+    } else if (!validStyles.includes(functionStyle)) {
+      errors.push(`Invalid function style. Must be one of: ${validStyles.join(', ')}`);
+    }
+
+    
+    if (!packageName || typeof packageName !== 'string' || packageName.trim().length === 0) {
+      errors.push('Package name must be a non-empty string');
+    } else {
+      
+      const npmNameRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+      if (!npmNameRegex.test(packageName)) {
+        errors.push('Invalid package name format. Must be a valid npm package name');
+      }
+    }
+
+    
+    if (!Array.isArray(packages)) {
+      errors.push('Packages must be an array');
+    } else {
+      const validPackages = ['dotenv', 'helmet', 'imageUpload', 'timeConverter'];
+      packages.forEach(pkg => {
+        if (typeof pkg !== 'string') {
+          errors.push('All package names must be strings');
+        } else if (!validPackages.includes(pkg)) {
+          errors.push(`Invalid package: ${pkg}. Valid packages: ${validPackages.join(', ')}`);
+        }
+      });
+    }
+
+    if (errors.length > 0) {
+      throw new ValidationError(`Validation errors:\n${errors.map(e => `  - ${e}`).join('\n')}`, 'inputs');
+    }
+  }
+
+  generate(architecture, functionStyle, packageName, packages = []) {
+    try {
+      
+      this.validateInputs(architecture, functionStyle, packageName, packages);
+
+      const structures = {
+        mvc: this.getMVCStructure,
+        microservices: this.getMicroservicesStructure,
+        layered: this.getLayeredStructure,
+        clean: this.getCleanArchitectureStructure,
+        simple: this.getSimpleStructure
+      };
+
+      const structureGenerator = structures[architecture];
+      if (!structureGenerator) {
+        throw new ValidationError(`Unknown architecture: ${architecture}`, 'architecture');
+      }
+
+      const structure = structureGenerator.call(this);
+      this.createStructure(process.cwd(), structure);
+      this.createServerJs(architecture, functionStyle, packages);
+      this.createHelperFiles(packages, functionStyle);
+      this.createPackageJson(packageName, packages);
+      
+      logger.success('Architecture generation completed successfully');
+    } catch (error) {
+      if (error instanceof ValidationError || error instanceof FileSystemError || error instanceof TemplateError) {
+        logger.error(`Error generating architecture: ${error.message}`, error);
+        throw error;
+      }
+      logger.error(`Error generating architecture: ${error.message}`, error);
+      throw error;
+    }
+  }
+
+  getMVCStructure() {
+    return {
+      'src': {
+        'controllers': {},
+        'models': {},
+        'views': {},
+        'routes': {},
+        'middleware': {},
+        'config': {},
+        'utils': {}
+      },
+      'public': {
+        'css': {},
+        'js': {},
+        'images': {}
+      },
+      'config': {
+        'uploads': {
+          'images': {}
+        }
+      },
+      'tests': {}
+    };
+  }
+
+  getMicroservicesStructure() {
+    return {
+      'services': {
+        'api-gateway': {
+          'src': {
+            'controllers': {},
+            'routes': {},
+            'middleware': {}
+          },
+          'public': {
+            'css': {},
+            'js': {},
+            'images': {}
+          },
+          'config': {
+            'uploads': {
+              'images': {}
+            }
+          }
+        },
+        'user-service': {
+          'src': {
+            'controllers': {},
+            'services': {},
+            'models': {},
+            'routes': {}
+          },
+          'config': {
+            'uploads': {
+              'images': {}
+            }
+          }
+        },
+        'shared': {
+          'utils': {},
+          'errors': {}
+        }
+      },
+      'public': {
+        'css': {},
+        'js': {},
+        'images': {}
+      },
+      'config': {
+        'uploads': {
+          'images': {}
+        }
+      },
+      'tests': {}
+    };
+  }
+
+  getLayeredStructure() {
+    return {
+      'src': {
+        'presentation': {
+          'controllers': {},
+          'routes': {},
+          'middleware': {}
+        },
+        'business': {
+          'services': {},
+          'interfaces': {}
+        },
+        'data': {
+          'repositories': {},
+          'models': {}
+        },
+        'infrastructure': {
+          'config': {},
+          'database': {}
+        },
+        'utils': {}
+      },
+      'public': {
+        'css': {},
+        'js': {},
+        'images': {}
+      },
+      'config': {
+        'uploads': {
+          'images': {}
+        }
+      },
+      'tests': {}
+    };
+  }
+
+  getCleanArchitectureStructure() {
+    return {
+      'src': {
+        'domain': {
+          'entities': {},
+          'interfaces': {},
+          'errors': {}
+        },
+        'application': {
+          'use-cases': {},
+          'dto': {}
+        },
+        'infrastructure': {
+          'controllers': {},
+          'repositories': {},
+          'database': {},
+          'config': {}
+        },
+        'presentation': {
+          'routes': {},
+          'middleware': {}
+        },
+        'utils': {}
+      },
+      'public': {
+        'css': {},
+        'js': {},
+        'images': {}
+      },
+      'config': {
+        'uploads': {
+          'images': {}
+        }
+      },
+      'tests': {}
+    };
+  }
+
+  getSimpleStructure() {
+    return {
+      'src': {
+        'controllers': {},
+        'services': {},
+        'routes': {},
+        'utils': {},
+        'config': {}
+      },
+      'public': {
+        'css': {},
+        'js': {},
+        'images': {}
+      },
+      'config': {
+        'uploads': {
+          'images': {}
+        }
+      },
+      'tests': {}
+    };
+  }
+
+  createStructure(basePath, structure) {
+    try {
+      if (!basePath || typeof basePath !== 'string') {
+        throw new ValidationError('Base path must be a non-empty string', 'basePath');
+      }
+
+      const normalizedBasePath = path.resolve(basePath);
+      
+      
+      if (!utils.isPathSafe(normalizedBasePath)) {
+        throw new ValidationError(`Base path is not safe: ${normalizedBasePath}`, 'basePath');
+      }
+      
+      
+      if (!this._cacheFileExists(normalizedBasePath)) {
+        throw new FileSystemError(`Base path does not exist: ${normalizedBasePath}`, normalizedBasePath, 'ENOENT');
+      }
+
+      const stats = fs.statSync(normalizedBasePath);
+      if (!stats.isDirectory()) {
+        throw new FileSystemError(`Base path is not a directory: ${normalizedBasePath}`, normalizedBasePath, 'ENOTDIR');
+      }
+
+      const createDir = (currentPath, structureObj) => {
+        if (!structureObj || typeof structureObj !== 'object') {
+          return;
+        }
+
+        Object.keys(structureObj).forEach(dir => {
+          if (!dir || typeof dir !== 'string') {
+            return; 
+          }
+
+          
+          const sanitizedDir = dir.replace(/[<>:"|?*\x00-\x1f]/g, '');
+          if (sanitizedDir !== dir) {
+            logger.warn(`Directory name sanitized: ${dir} -> ${sanitizedDir}`);
+          }
+
+          const dirPath = path.join(currentPath, sanitizedDir);
+          
+          
+          if (!utils.isPathSafe(dirPath, normalizedBasePath)) {
+            logger.warn(`Skipping unsafe path: ${dirPath}`);
+            return;
+          }
+          
+          try {
+            
+            if (!this._cacheFileExists(dirPath)) {
+              fs.mkdirSync(dirPath, { recursive: true });
+              logger.info(`Created directory: ${dirPath}`);
+            }
+            
+            if (typeof structureObj[dir] === 'object' && structureObj[dir] !== null && Object.keys(structureObj[dir]).length > 0) {
+              createDir(dirPath, structureObj[dir]);
+            }
+          } catch (error) {
+            if (error.code === 'EACCES') {
+              throw new FileSystemError(`Permission denied creating directory: ${dirPath}`, dirPath, 'EACCES');
+            }
+            throw new FileSystemError(`Failed to create directory ${dirPath}: ${error.message}`, dirPath, error.code);
+          }
+        });
+      };
+
+      createDir(normalizedBasePath, structure);
+      logger.debug('Directory structure created successfully');
+    } catch (error) {
+      if (error instanceof ValidationError || error instanceof FileSystemError) {
+        throw error;
+      }
+      throw new FileSystemError(`Failed to create structure: ${error.message}`, '', error.code);
+    }
+  }
+
+  createServerJs(architecture, functionStyle, packages) {
+    try {
+      const templateFileName = `${architecture}-${functionStyle}.template`;
+      const templatePath = path.join(this.serverTemplateDir, templateFileName);
+      
+      const template = this.readTemplate(templatePath);
+      const templateData = {
+        useDotenv: Array.isArray(packages) && packages.includes('dotenv'),
+        useHelmet: Array.isArray(packages) && packages.includes('helmet')
+      };
+      
+      const content = this.processTemplate(template, templateData);
+      const serverPath = path.resolve(process.cwd(), 'server.js');
+      
+      
+      if (!utils.isPathSafe(serverPath)) {
+        throw new ValidationError(`Server path is not safe: ${serverPath}`, 'serverPath');
+      }
+      
+      
+      if (this._cacheFileExists(serverPath)) {
+        logger.warn('server.js already exists, skipping...');
+        return;
+      }
+
+      utils.writeFileSafe(serverPath, content);
+      logger.success('Created: server.js');
+    } catch (error) {
+      if (error instanceof TemplateError || error instanceof ValidationError || error instanceof FileSystemError) {
+        logger.error(`Error creating server.js: ${error.message}`, error);
+        throw error;
+      }
+      logger.error(`Error creating server.js: ${error.message}`, error);
+      throw error;
+    }
+  }
+
+  createHelperFiles(packages, functionStyle) {
+    if (!Array.isArray(packages) || packages.length === 0) {
+      return;
+    }
+
+    const helpers = {
+      imageUpload: {
+        template: 'imageUpload.template',
+        fileName: 'imageUploadHelper.js',
+        directory: 'src/utils'
+      },
+      timeConverter: {
+        template: 'timeConverter.template',
+        fileName: 'customHelp.js',
+        directory: 'src/utils'
+      }
+    };
+
+    packages.forEach(pkg => {
+      if (!pkg || typeof pkg !== 'string') {
+        return;
+      }
+
+      if (helpers[pkg]) {
+        const helper = helpers[pkg];
+        const templatePath = path.join(this.helperTemplateDir, helper.template);
+        
+        try {
+          const template = this.readTemplate(templatePath);
+          const templateData = {
+            isClass: functionStyle === 'class'
+          };
+          
+          const content = this.processTemplate(template, templateData);
+          const helperDir = path.resolve(process.cwd(), helper.directory);
+          const helperPath = path.join(helperDir, helper.fileName);
+          
+          
+          if (!utils.isPathSafe(helperPath)) {
+            logger.warn(`Helper path is not safe, skipping: ${helperPath}`);
+            return;
+          }
+          
+          
+          if (!this._cacheFileExists(helperDir)) {
+            try {
+              fs.mkdirSync(helperDir, { recursive: true });
+              this._fileExistsCache.delete(helperDir);
+            } catch (error) {
+              if (error.code === 'EACCES') {
+                throw new FileSystemError(`Permission denied creating directory: ${helperDir}`, helperDir, 'EACCES');
+              }
+              throw new FileSystemError(`Failed to create directory ${helperDir}: ${error.message}`, helperDir, error.code);
+            }
+          }
+
+          
+          if (this._cacheFileExists(helperPath)) {
+            logger.warn(`${helper.fileName} already exists, skipping...`);
+            return;
+          }
+
+          utils.writeFileSafe(helperPath, content);
+          logger.success(`Created: ${helper.directory}/${helper.fileName}`);
+        } catch (error) {
+          logger.error(`Error creating ${helper.fileName}: ${error.message}`, error);
+          
+        }
+      }
+    });
+
+    
+    if (packages.includes('dotenv')) {
+      try {
+        const envExamplePath = path.resolve(process.cwd(), '.env.example');
+        
+        
+        if (!utils.isPathSafe(envExamplePath)) {
+          logger.warn(`.env.example path is not safe, skipping`);
+          return;
+        }
+        
+        if (!this._cacheFileExists(envExamplePath)) {
+          const envExample = `PORT=3000
+NODE_ENV=development
+# Add your environment variables here
+`;
+          utils.writeFileSafe(envExamplePath, envExample);
+          logger.success('Created: .env.example');
+        }
+      } catch (error) {
+        logger.error(`Error creating .env.example: ${error.message}`, error);
+        
+      }
+    }
+  }
+
+  createPackageJson(packageName, packages = []) {
+    try {
+      const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+      
+      
+      if (!utils.isPathSafe(packageJsonPath)) {
+        throw new ValidationError(`Package.json path is not safe: ${packageJsonPath}`, 'packageJsonPath');
+      }
+      
+      
+      const packageDependencies = {
+        dotenv: '^16.3.1',
+        helmet: '^7.1.0',
+        imageUpload: { multer: '^1.4.5-lts.1' },
+        timeConverter: {}
+      };
+
+      const dependencies = {
+        express: '^4.18.2'
+      };
+
+      
+      if (Array.isArray(packages)) {
+        packages.forEach(pkg => {
+          if (pkg && typeof pkg === 'string' && packageDependencies[pkg]) {
+            if (typeof packageDependencies[pkg] === 'object') {
+              Object.assign(dependencies, packageDependencies[pkg]);
+            } else {
+              dependencies[pkg] = packageDependencies[pkg];
+            }
+          }
+        });
+      }
+      
+      let packageJson;
+      const fileExists = this._cacheFileExists(packageJsonPath);
+      
+      if (fileExists) {
+        try {
+          const existingContent = utils.readFileSafe(packageJsonPath);
+          packageJson = JSON.parse(existingContent);
+        } catch (error) {
+          if (error instanceof SyntaxError) {
+            throw new ConfigError(`Invalid JSON in existing package.json: ${error.message}`, packageJsonPath);
+          }
+          throw new FileSystemError(`Failed to read package.json: ${error.message}`, packageJsonPath, error.code);
+        }
+
+        packageJson.name = packageName;
+        packageJson.main = 'server.js';
+        packageJson.scripts = {
+          ...(packageJson.scripts || {}),
+          start: 'node server.js',
+          dev: 'node server.js'
+        };
+        
+        if (!packageJson.dependencies) {
+          packageJson.dependencies = {};
+        }
+        
+        
+        Object.assign(packageJson.dependencies, dependencies);
+      } else {
+        packageJson = {
+          name: packageName,
+          version: '1.0.0',
+          description: '',
+          main: 'server.js',
+          scripts: {
+            start: 'node server.js',
+            dev: 'node server.js'
+          },
+          dependencies: dependencies,
+          author: '',
+          license: 'ISC'
+        };
+      }
+
+      try {
+        const jsonContent = JSON.stringify(packageJson, null, 2);
+        utils.writeFileSafe(packageJsonPath, jsonContent);
+        logger.success(`${fileExists ? 'Updated' : 'Created'}: package.json`);
+      } catch (error) {
+        if (error.code === 'EACCES') {
+          throw new FileSystemError(`Permission denied writing package.json`, packageJsonPath, 'EACCES');
+        }
+        throw new FileSystemError(`Failed to write package.json: ${error.message}`, packageJsonPath, error.code);
+      }
+    } catch (error) {
+      if (error instanceof ValidationError || error instanceof ConfigError || error instanceof FileSystemError) {
+        logger.error(`Error creating/updating package.json: ${error.message}`, error);
+        throw error;
+      }
+      logger.error(`Error creating/updating package.json: ${error.message}`, error);
+      throw error;
+    }
+  }
+
+  
+  clearCache() {
+    this._templateCache.clear();
+    this._fileExistsCache.clear();
+    this._fileExistsCacheTime = 0;
+    logger.debug('Architecture generator cache cleared');
+  }
+}
+
+
+module.exports = new ArchitectureGenerator();
+module.exports.utils = utils;
+module.exports.logger = logger;
+module.exports.TemplateError = TemplateError;
+module.exports.ConfigError = ConfigError;
+module.exports.ValidationError = ValidationError;
+module.exports.FileSystemError = FileSystemError;