kira-crud/utils/settings-manager.js

Intelligent CRUD Generator for Laravel and Angular

/**
 * Settings Manager
 * Manages Kira application settings
 */

const fs = require('fs').promises;
const path = require('path');
const os = require('os');
const chalk = require('chalk');
const inquirer = require('inquirer');
const yaml = require('js-yaml');

// Settings file path
const settingsDir = path.join(os.homedir(), '.kira');
const settingsFile = path.join(settingsDir, 'settings.json');

/**
 * Display a styled section header
 * @param {string} title - The section title
 */
function displaySectionHeader(title) {
  console.log(
    "\n" +
      chalk.bold.blue(
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
      )
  );
  console.log(chalk.bold.blue("✨ ") + chalk.bold.white(title));
  console.log(
    chalk.bold.blue(
      "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    ) + "\n"
  );
}

/**
 * Load application settings
 * @returns {Promise<Object>} Settings object
 */
async function loadSettings() {
  try {
    // Create settings directory if it doesn't exist
    try {
      await fs.mkdir(settingsDir, { recursive: true });
    } catch (error) {
      // Directory already exists, that's fine
    }
    
    // Try to read settings file
    try {
      const data = await fs.readFile(settingsFile, 'utf8');
      return JSON.parse(data);
    } catch (error) {
      // File doesn't exist or is invalid, create default settings
      const defaultSettings = {
        defaults: {
          backendArchitecture: 'advanced'
        },
        paths: {
          backend: './back',
          frontend: './front'
        },
        templates: {},
        theme: 'default'
      };
      
      // Save default settings
      await saveSettings(defaultSettings);
      return defaultSettings;
    }
  } catch (error) {
    console.error(chalk.red(`Error loading settings: ${error.message}`));
    return {
      defaults: {
        backendArchitecture: 'advanced'
      },
      paths: {
        backend: './back',
        frontend: './front'
      },
      templates: {},
      theme: 'default'
    };
  }
}

/**
 * Save application settings
 * @param {Object} settings - Settings object to save
 * @returns {Promise<void>}
 */
async function saveSettings(settings) {
  try {
    await fs.writeFile(settingsFile, JSON.stringify(settings, null, 2), 'utf8');
  } catch (error) {
    console.error(chalk.red(`Error saving settings: ${error.message}`));
  }
}

/**
 * Settings menu
 * @returns {Promise<void>}
 */
async function settingsMenu() {
  displaySectionHeader("Application Settings");
  
  // Load current settings
  const settings = await loadSettings();
  
  const { settingOption } = await inquirer.prompt([
    {
      type: 'list',
      name: 'settingOption',
      message: 'Select a setting to configure:',
      choices: [
        { name: 'Backend Path Configuration', value: 'backendPath' },
        { name: 'Frontend Path Configuration', value: 'frontendPath' },
        { name: 'Default Templates', value: 'templates' },
        { name: 'Generation Options', value: 'options' },
        { name: 'Back to Main Menu', value: 'back' }
      ]
    }
  ]);
  
  if (settingOption === 'back') {
    return;
  }
  
  switch (settingOption) {
    case 'options':
      await configureGenerationOptions(settings);
      break;
    case 'backendPath':
      const { backendPath } = await inquirer.prompt([
        {
          type: 'input',
          name: 'backendPath',
          message: 'Enter default backend path:',
          default: settings.paths?.backend || './back',
          validate: (input) => input ? true : 'Path cannot be empty'
        }
      ]);
      
      // Update settings
      settings.paths = settings.paths || {};
      settings.paths.backend = backendPath;
      await saveSettings(settings);
      console.log(chalk.green(`\nDefault backend path set to: ${backendPath}\n`));
      break;
    case 'frontendPath':
      const { frontendPath } = await inquirer.prompt([
        {
          type: 'input',
          name: 'frontendPath',
          message: 'Enter default frontend path:',
          default: settings.paths?.frontend || './front',
          validate: (input) => input ? true : 'Path cannot be empty'
        }
      ]);
      
      // Update settings
      settings.paths = settings.paths || {};
      settings.paths.frontend = frontendPath;
      await saveSettings(settings);
      console.log(chalk.green(`\nDefault frontend path set to: ${frontendPath}\n`));
      break;
    case 'templates':
      console.log(chalk.yellow(`\nConfiguration for templates is under development.\n`));
      break;
  }
  
  // Press any key to continue
  await inquirer.prompt([
    {
      type: 'input',
      name: 'continue',
      message: 'Press Enter to continue...'
    }
  ]);
}

/**
 * Configure generation options
 * @param {Object} settings - Current settings
 * @returns {Promise<void>}
 */
async function configureGenerationOptions(settings) {
  displaySectionHeader("Generation Options");
  
  const { option } = await inquirer.prompt([
    {
      type: 'list',
      name: 'option',
      message: 'Select an option to configure:',
      choices: [
        { name: 'Default Backend Architecture', value: 'backendArchitecture' },
        { name: 'Default Backend Path', value: 'backendPath' },
        { name: 'Default Frontend Path', value: 'frontendPath' },
        { name: 'Back', value: 'back' }
      ]
    }
  ]);
  
  if (option === 'back') {
    return;
  }
  
  switch (option) {
    case 'backendArchitecture':
      const { architecture } = await inquirer.prompt([
        {
          type: 'list',
          name: 'architecture',
          message: 'Select default backend architecture:',
          choices: [
            { name: 'Advanced (Repository, Service, etc.)', value: 'advanced' },
            { name: 'Classic (Controller, Model only)', value: 'classic' }
          ],
          default: settings.defaults?.backendArchitecture || 'advanced'
        }
      ]);
      
      // Update settings
      settings.defaults = settings.defaults || {};
      settings.defaults.backendArchitecture = architecture;
      await saveSettings(settings);
      console.log(chalk.green(`\nDefault backend architecture set to: ${architecture}\n`));
      break;
      
    case 'backendPath':
      const { backendPath } = await inquirer.prompt([
        {
          type: 'input',
          name: 'backendPath',
          message: 'Enter default backend path:',
          default: settings.paths?.backend || './back',
          validate: (input) => input ? true : 'Path cannot be empty'
        }
      ]);
      
      // Update settings
      settings.paths = settings.paths || {};
      settings.paths.backend = backendPath;
      await saveSettings(settings);
      console.log(chalk.green(`\nDefault backend path set to: ${backendPath}\n`));
      break;
      
    case 'frontendPath':
      const { frontendPath } = await inquirer.prompt([
        {
          type: 'input',
          name: 'frontendPath',
          message: 'Enter default frontend path:',
          default: settings.paths?.frontend || './front',
          validate: (input) => input ? true : 'Path cannot be empty'
        }
      ]);
      
      // Update settings
      settings.paths = settings.paths || {};
      settings.paths.frontend = frontendPath;
      await saveSettings(settings);
      console.log(chalk.green(`\nDefault frontend path set to: ${frontendPath}\n`));
      break;
  }
}

/**
 * Direct testing functionality
 */
if (require.main === module) {
  settingsMenu().catch(error => {
    console.error(chalk.red(`Error: ${error.message}`));
  });
}

/**
 * Affiche les chemins actuellement configurés
 */
async function displayPaths() {
  try {
    const settings = await loadSettings();
    
    console.log(chalk.blue('\n✨ Chemins configurés\n'));
    
    // Chemins par défaut
    console.log(chalk.cyan('Chemins par défaut:'));
    console.log(chalk.green(`  Backend: ${settings.paths?.backend || './back'}`));
    console.log(chalk.green(`  Frontend: ${settings.paths?.frontend || './front'}`));
    
    // Architecture par défaut
    console.log(chalk.cyan('\nArchitecture par défaut:'));
    console.log(chalk.green(`  ${settings.defaults?.backendArchitecture || 'advanced'}`));
    
    // Exemples d'utilisation
    console.log(chalk.cyan('\nCommandes d\'utilisation:'));
    console.log(chalk.yellow(`  - Génération CRUD: kira-generate <fichier-config>`));
    console.log(chalk.yellow(`  - Configuration des chemins: kira -> Application Settings`));
    
    return settings.paths;
  } catch (error) {
    console.error(chalk.red(`Erreur lors de l'affichage des chemins: ${error.message}`));
    return null;
  }
}

module.exports = {
  loadSettings,
  saveSettings,
  settingsMenu,
  displayPaths
};