nexpgen 1.0.0

package/src/commands/generate.js

@@ -0,0 +1,205 @@
+const path = require('path');
+const fs = require('fs');
+const fileGenerator = require('../utils/fileGenerator');
+
+
+async function promptInquirer(questions) {
+  try {
+    const inquirer = require('inquirer');
+    if (typeof inquirer.createPromptModule === 'function') {
+      const prompt = inquirer.createPromptModule();
+      return await prompt(questions);
+    }
+
+
+    if (typeof inquirer.prompt === 'function') {
+      return await inquirer.prompt(questions);
+    }
+
+    throw new Error('Inquirer prompt method not available');
+  } catch (error) {
+
+    if (error.code === 'MODULE_NOT_FOUND') {
+      throw new Error('Inquirer package not found. Please install it: npm install inquirer');
+    }
+    throw error;
+  }
+}
+
+async function generate(type, name, options) {
+  try {
+    if (!type || typeof type !== 'string') {
+      console.error('❌ Error: Type must be a non-empty string');
+      process.exit(1);
+    }
+
+    if (!name || typeof name !== 'string' || name.trim().length === 0) {
+      console.error('❌ Error: Name must be a non-empty string');
+      process.exit(1);
+    }
+
+    if (!options || typeof options !== 'object') {
+      console.error('❌ Error: Options must be an object');
+      process.exit(1);
+    }
+
+    const { directory = 'src' } = options;
+
+    if (typeof directory !== 'string' || directory.trim().length === 0) {
+      console.error('❌ Error: Directory must be a non-empty string');
+      process.exit(1);
+    }
+
+    const typeMap = {
+      controller: 'controller',
+      service: 'service',
+      util: 'util',
+      error: 'error',
+      route: 'route',
+      middleware: 'middleware',
+      crud: 'crud'
+    };
+
+    const templateType = typeMap[type.toLowerCase()];
+
+    if (!templateType) {
+      const availableTypes = Object.keys(typeMap).join(', ');
+      console.error(`❌ Error: Unknown type "${type}". Available types: ${availableTypes}`);
+      process.exit(1);
+    }
+
+    const outputDir = path.resolve(process.cwd(), directory);
+
+
+    try {
+      if (fs.existsSync(outputDir)) {
+        const stats = fs.statSync(outputDir);
+        if (!stats.isDirectory()) {
+          console.error(`❌ Error: Output path exists but is not a directory: ${outputDir}`);
+          process.exit(1);
+        }
+      } else {
+
+        const parentDir = path.dirname(outputDir);
+        if (!fs.existsSync(parentDir)) {
+          console.error(`❌ Error: Parent directory does not exist: ${parentDir}`);
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      if (error.code === 'EACCES') {
+        console.error(`❌ Error: Permission denied accessing directory: ${outputDir}`);
+      } else {
+        console.error(`❌ Error: Failed to validate output directory: ${error.message}`);
+      }
+      process.exit(1);
+    }
+
+
+    const names = name.split(',')
+      .map(n => n.trim())
+      .filter(n => n.length > 0);
+
+    if (names.length === 0) {
+      console.error('❌ Error: No valid names provided after parsing');
+      process.exit(1);
+    }
+
+
+    const invalidCharRegex = /[<>:"|?*\x00-\x1f]/;
+    const invalidNames = names.filter(n => {
+      return invalidCharRegex.test(n) || n.includes('..');
+    });
+
+    if (invalidNames.length > 0) {
+      console.error(`❌ Error: Invalid characters in names: ${invalidNames.join(', ')}`);
+      process.exit(1);
+    }
+
+
+    if (templateType === 'crud') {
+      const crudQuestions = [
+        {
+          type: 'confirm',
+          name: 'generateCRUD',
+          message: `Do you want to generate complete CRUD (controller + service + routes) for: ${names.join(', ')}?`,
+          default: true
+        }
+      ];
+
+      try {
+        const crudAnswers = await promptInquirer(crudQuestions);
+
+        if (!crudAnswers.generateCRUD) {
+          console.log('\n❌ CRUD generation cancelled.');
+          console.log('💡 Tip: You can generate individual files using:');
+          console.log('   nexpgen generate controller <name>');
+          console.log('   nexpgen generate service <name>');
+          console.log('   nexpgen generate route <name>\n');
+          process.exit(0);
+        }
+      } catch (error) {
+        if (error.isTtyError) {
+          console.error('❌ Prompt couldn\'t be rendered in the current environment');
+          console.log('💡 Proceeding with CRUD generation...\n');
+        } else if (error.message && error.message.includes('Inquirer')) {
+          console.error(`❌ ${error.message}`);
+          console.log('💡 Proceeding with CRUD generation...\n');
+        } else {
+          console.error(`❌ Error: ${error.message}`);
+          process.exit(1);
+        }
+      }
+    }
+
+    let successCount = 0;
+    let failureCount = 0;
+
+
+    if (templateType === 'crud') {
+      for (const nameItem of names) {
+        try {
+          fileGenerator.generateCRUD(nameItem, outputDir);
+          successCount++;
+        } catch (error) {
+          failureCount++;
+          console.error(`❌ Failed to generate CRUD for ${nameItem}: ${error.message}`);
+        }
+      }
+    } else {
+
+      for (const nameItem of names) {
+        try {
+
+          if (templateType === 'middleware') {
+            fileGenerator.generateMiddleware(nameItem, outputDir);
+          } else {
+            fileGenerator.generateFromTemplate(templateType, nameItem, outputDir);
+          }
+          successCount++;
+        } catch (error) {
+          failureCount++;
+          console.error(`❌ Failed to generate ${nameItem}: ${error.message}`);
+
+        }
+      }
+    }
+
+    if (failureCount > 0) {
+      console.error(`\n⚠️  Generated ${successCount} file(s), failed ${failureCount} file(s)`);
+      if (failureCount === names.length) {
+        process.exit(1);
+      }
+    } else {
+      console.log(`\n✅ Successfully generated ${successCount} file(s)`);
+    }
+  } catch (error) {
+    console.error(`❌ Unexpected error: ${error.message}`);
+    if (error.stack && process.env.NODE_ENV === 'development') {
+      console.error('Stack trace:', error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = generate;

package/src/commands/init.js

@@ -0,0 +1,191 @@
+const fs = require('fs');
+const path = require('path');
+const architectureGenerator = require('../utils/architectureGenerator');
+
+async function promptInquirer(questions) {
+  try {
+    
+    const inquirer = require('inquirer');
+    if (typeof inquirer.createPromptModule === 'function') {
+      const prompt = inquirer.createPromptModule();
+      return await prompt(questions);
+    }
+    
+    if (typeof inquirer.prompt === 'function') {
+      return await inquirer.prompt(questions);
+    }
+    
+    throw new Error('Inquirer prompt method not available');
+  } catch (error) {
+    
+    if (error.code === 'MODULE_NOT_FOUND') {
+      throw new Error('Inquirer package not found. Please install it: npm install inquirer');
+    }
+    throw error;
+  }
+}
+
+async function init() {
+  console.log('🚀 Initializing project...\n');
+
+  try {
+    const configPath = path.resolve(process.cwd(), '.nexpgenrc');
+    if (fs.existsSync(configPath)) {
+      const readline = require('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      return new Promise((resolve, reject) => {
+        rl.question('⚠️  .nexpgenrc already exists. Do you want to overwrite it? (y/N): ', async (answer) => {
+          rl.close();
+          if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+            console.log('Initialization cancelled.');
+            process.exit(0);
+          }
+          try {
+            await proceedWithInit();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+    } else {
+      await proceedWithInit();
+    }
+  } catch (error) {
+    console.error(`❌ Error during initialization: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+async function proceedWithInit() {
+  const questions = [
+    {
+      type: 'input',
+      name: 'packageName',
+      message: 'What is your package name?',
+      default: 'my-app',
+      validate: (input) => {
+        if (!input || typeof input !== 'string' || !input.trim()) {
+          return 'Package name cannot be empty';
+        }
+        
+        const npmNameRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+        if (!npmNameRegex.test(input.trim())) {
+          return 'Invalid package name format. Must be a valid npm package name';
+        }
+        
+        return true;
+      }
+    },
+    {
+      type: 'list',
+      name: 'architecture',
+      message: 'Which architecture do you want to use?',
+      choices: [
+        { name: 'MVC (Model-View-Controller)', value: 'mvc' },
+        { name: 'Microservices', value: 'microservices' },
+        { name: 'Layered Architecture', value: 'layered' },
+        { name: 'Clean Architecture', value: 'clean' },
+        { name: 'Simple Structure', value: 'simple' }
+      ],
+      default: 'mvc'
+    },
+    {
+      type: 'list',
+      name: 'functionStyle',
+      message: 'What function style do you prefer?',
+      choices: [
+        { name: 'Class-based', value: 'class' },
+        { name: 'Arrow functions with module.exports', value: 'arrow' }
+      ],
+      default: 'class'
+    },
+    {
+      type: 'checkbox',
+      name: 'packages',
+      message: 'Select additional packages you want to include:',
+      choices: [
+        { name: 'dotenv (Environment variables)', value: 'dotenv', checked: true },
+        { name: 'helmet (Security headers)', value: 'helmet' },
+        { name: 'Image Upload Helper (multer)', value: 'imageUpload' },
+        { name: 'Time Converter Helper', value: 'timeConverter' }
+      ],
+      validate: (input) => {
+        if (!Array.isArray(input)) {
+          return 'Packages must be an array';
+        }
+        return true;
+      }
+    }
+  ];
+
+  try {
+    const answers = await promptInquirer(questions);
+    
+    
+    if (!answers.packageName || !answers.architecture || !answers.functionStyle) {
+      throw new Error('Missing required answers');
+    }
+
+    
+    if (!Array.isArray(answers.packages)) {
+      answers.packages = [];
+    }
+    
+    
+    const configPath = path.resolve(process.cwd(), '.nexpgenrc');
+    
+    try {
+      const configContent = JSON.stringify(answers, null, 2);
+      fs.writeFileSync(configPath, configContent, 'utf-8');
+      console.log('\n✅ Configuration saved to .nexpgenrc\n');
+    } catch (error) {
+      if (error.code === 'EACCES') {
+        throw new Error(`Permission denied writing .nexpgenrc`);
+      }
+      throw new Error(`Failed to save configuration: ${error.message}`);
+    }
+
+    
+    try {
+      architectureGenerator.generate(
+        answers.architecture, 
+        answers.functionStyle, 
+        answers.packageName,
+        answers.packages
+      );
+      
+      console.log('\n✨ Project initialized successfully!');
+    } catch (error) {
+      console.error(`\n❌ Failed to generate project structure: ${error.message}`);
+      
+      try {
+        if (fs.existsSync(configPath)) {
+          fs.unlinkSync(configPath);
+        }
+      } catch (cleanupError) {
+        
+      }
+      throw error;
+    }
+  } catch (error) {
+    if (error.isTtyError) {
+      console.error('❌ Prompt couldn\'t be rendered in the current environment');
+      console.error('💡 This might be because:');
+      console.error('   1. The terminal doesn\'t support interactive prompts');
+      console.error('   2. Inquirer version compatibility issue');
+      console.error('   3. Try running: npm install inquirer@latest');
+    } else if (error.message && error.message.includes('Inquirer')) {
+      console.error(`❌ ${error.message}`);
+    } else {
+      console.error(`❌ Error initializing project: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = init;

package/src/templates/controller.template

@@ -0,0 +1,127 @@
+{{#if isClass}}
+class {{className}}Controller {
+  constructor() {
+    this.name = '{{name}}';
+  }
+
+  async getAll(req, res, next) {
+    try {
+      // TODO: Implement get all logic
+      res.json({ message: 'Get all {{camelCaseName}}s', data: [] });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async getById(req, res, next) {
+    try {
+      const { id } = req.params;
+      // TODO: Implement get by id logic
+      res.json({ message: \`Get {{camelCaseName}} by id: \${id}\` });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async create(req, res, next) {
+    try {
+      const {{camelCaseName}}Data = req.body;
+      // TODO: Implement create logic
+      res.json({ message: 'Create {{camelCaseName}}', data: {{camelCaseName}}Data });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async update(req, res, next) {
+    try {
+      const { id } = req.params;
+      const {{camelCaseName}}Data = req.body;
+      // TODO: Implement update logic
+      res.json({ message: \`Update {{camelCaseName}} \${id}\`, data: {{camelCaseName}}Data });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  async remove(req, res, next) {
+    try {
+      const { id } = req.params;
+      // TODO: Implement delete logic
+      res.json({ message: \`Delete {{camelCaseName}} \${id}\` });
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+module.exports = {{className}}Controller;
+{{else}}
+const handle = async (req, res, next) => {
+  try {
+    // TODO: Implement controller logic
+    res.json({ message: '{{className}}Controller - handle method' });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const getAll = async (req, res, next) => {
+  try {
+    // TODO: Implement get all logic
+    res.json({ message: 'Get all {{camelCaseName}}s', data: [] });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const getById = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    // TODO: Implement get by id logic
+    res.json({ message: \`Get {{camelCaseName}} by id: \${id}\` });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const create = async (req, res, next) => {
+  try {
+    const {{camelCaseName}}Data = req.body;
+    // TODO: Implement create logic
+    res.json({ message: 'Create {{camelCaseName}}', data: {{camelCaseName}}Data });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const update = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const {{camelCaseName}}Data = req.body;
+    // TODO: Implement update logic
+    res.json({ message: \`Update {{camelCaseName}} \${id}\`, data: {{camelCaseName}}Data });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const remove = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    // TODO: Implement delete logic
+    res.json({ message: \`Delete {{camelCaseName}} \${id}\` });
+  } catch (error) {
+    next(error);
+  }
+};
+
+module.exports = {
+  handle,
+  getAll,
+  getById,
+  create,
+  update,
+  remove
+};
+{{/if}}

package/src/templates/error.template

@@ -0,0 +1,24 @@
+{{#if isClass}}
+class {{className}}Error extends Error {
+  constructor(message, statusCode = 500) {
+    super(message);
+    this.name = '{{className}}Error';
+    this.statusCode = statusCode;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+module.exports = {{className}}Error;
+{{else}}
+const create{{className}}Error = (message, statusCode = 500) => {
+  const error = new Error(message);
+  error.name = '{{className}}Error';
+  error.statusCode = statusCode;
+  Error.captureStackTrace(error, create{{className}}Error);
+  return error;
+};
+
+module.exports = {
+  create{{className}}Error
+};
+{{/if}}