myex-cli/lib/commands/generate-middleware.js

Opinionated Express.js framework with CLI tools

import path from 'path';
import fs from 'fs-extra';
import chalk from 'chalk';
import ora from 'ora';
import { fileURLToPath } from 'url';
import ejs from 'ejs';
import { camelCase } from '../utils/string-utils.js';

// Convert ES Module path
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const templatesDir = path.resolve(__dirname, '../templates/middleware');

/**
 * Generate a new middleware file
 * @param {string} name - Middleware name
 */
export async function generateMiddleware(name) {
  const spinner = ora(`Generating middleware: ${chalk.blue(name)}`).start();
  
  try {
    // Ensure proper casing
    const middlewareName = camelCase(name) + 'Middleware';
    const middlewareFileName = `${camelCase(name)}.middleware.js`;
    const destPath = path.join(process.cwd(), 'src', 'middlewares', middlewareFileName);
    
    // Check if middleware already exists
    if (fs.existsSync(destPath)) {
      spinner.warn(chalk.yellow(`Middleware ${middlewareFileName} already exists. Skipping.`));
      return;
    }
    
    // Load template
    const templateFile = path.join(templatesDir, 'middleware.template.ejs');
    const template = await fs.readFile(templateFile, 'utf8');
    
    // Render template
    const content = ejs.render(template, {
      middlewareName,
      middlewareNameCamel: camelCase(name) + 'Middleware',
      name: camelCase(name)
    });
    
    // Create middleware file
    await fs.ensureDir(path.dirname(destPath));
    await fs.writeFile(destPath, content, 'utf8');
    
    // Update middlewares index.js to export the new middleware
    await updateMiddlewaresIndex(name);
    
    spinner.succeed(chalk.green(`Middleware generated: ${destPath}`));
    
  } catch (error) {
    spinner.fail(chalk.red(`Failed to generate middleware: ${error.message}`));
  }
}

/**
 * Update the middlewares index.js file to export the new middleware
 * @param {string} name - Middleware name
 */
async function updateMiddlewaresIndex(name) {
  const indexPath = path.join(process.cwd(), 'src', 'middlewares', 'index.js');
  
  // Create the index file if it doesn't exist
  if (!fs.existsSync(indexPath)) {
    await fs.ensureDir(path.dirname(indexPath));
    await fs.writeFile(indexPath, '', 'utf8');
  }
  
  // Read existing file
  let content = await fs.readFile(indexPath, 'utf8');
  
  // Import and export statements to add
  const middlewareName = camelCase(name) + 'Middleware';
  const importStatement = `import { ${middlewareName} } from './${camelCase(name)}.middleware.js';`;
  
  // Check if import already exists
  if (content.includes(importStatement)) {
    return; // Already imported
  }
  
  // Add import statement
  content += `\\n${importStatement}\\n`;
  
  // Add export statement
  if (content.includes('export {')) {
    // Update existing export statement
    content = content.replace(
      /export\s*{([^}]*)}/,
      (match, exports) => `export {${exports}, ${middlewareName}}`
    );
  } else {
    // Add new export statement
    content += `\\nexport { ${middlewareName} };\\n`;
  }
  
  // Write updated content back to file
  await fs.writeFile(indexPath, content, 'utf8');
}