adastra_api/scripts/create-user.js

#!/usr/bin/env node

/**
 * Script pour créer un utilisateur Admin interactivement
 * Usage: npm run create:user
 */

const readline = require('readline');
const crypto = require('crypto');
const { v4: uuidv4 } = require('uuid');

// Load environment
const appEnv = process.env.APP_ENV || 'development';
require('dotenv').config({ path: `config/env/.env.${appEnv}` });

const sequelize = require('../src/database/config/sequelize');

// Create readline interface
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// Helper function for prompts
const question = (prompt) => {
    return new Promise((resolve) => {
        rl.question(prompt, (answer) => {
            resolve(answer);
        });
    });
};

// Helper function for hidden password input
const questionHidden = (prompt) => {
    return new Promise((resolve) => {
        process.stdout.write(prompt);
        process.stdin.setRawMode(true);
        process.stdin.resume();
        
        let password = '';
        
        const dataListener = (char) => {
            char = char.toString();
            
            switch (char) {
                case '\n':
                case '\r':
                case '\u0004':
                    process.stdin.setRawMode(false);
                    process.stdin.pause();
                    process.stdout.write('\n');
                    process.stdin.removeListener('data', dataListener);
                    resolve(password);
                    break;
                case '\u0003':
                    process.exit();
                    break;
                case '\u007F':
                case '\b':
                    password = password.slice(0, -1);
                    process.stdout.write('\b \b');
                    break;
                default:
                    password += char;
                    process.stdout.write('*');
            }
        };
        
        process.stdin.on('data', dataListener);
    });
};

// Hash password
const hashPassword = (password) => {
    const salt = crypto.randomBytes(16).toString('hex');
    const hash = crypto.pbkdf2Sync(password, salt, 10000, 512, 'sha512').toString('hex');
    return { salt, hash };
};

// Main function
const createUser = async () => {
    try {
        console.log('\n🔐 Création d\'un utilisateur Admin\n');
        console.log('Veuillez fournir les informations suivantes:\n');

        // Get user input
        const email = await question('Email: ');
        const username = await question('Nom d\'utilisateur: ');
        const firstname = await question('Prénom (optionnel): ');
        const lastname = await question('Nom (optionnel): ');
        const phone = await question('Téléphone (optionnel): ');
        const password = await questionHidden('Mot de passe: ');
        const passwordConfirm = await questionHidden('Confirmer le mot de passe: ');

        // Validation
        if (!email || !username || !password) {
            console.error('\n❌ Email, nom d\'utilisateur et mot de passe sont obligatoires\n');
            rl.close();
            process.exit(1);
        }

        if (password !== passwordConfirm) {
            console.error('\n❌ Les mots de passe ne correspondent pas\n');
            rl.close();
            process.exit(1);
        }

        if (password.length < 6) {
            console.error('\n❌ Le mot de passe doit contenir au moins 6 caractères\n');
            rl.close();
            process.exit(1);
        }

        // Connect to database and load models
        console.log('\n📡 Connexion à la base de données...');
        await sequelize.authenticate();
        console.log('✅ Connexion établie\n');

        // Initialize all models by calling their functions
        const rawDB = require('../src/database/models/mysql');
        
        // Call each model function to initialize it
        rawDB.User();
        rawDB.Role();
        rawDB.Article();
        rawDB.Tag();
        rawDB.TagList();
        rawDB.UserRoleXref();
        rawDB.Follower();
        rawDB.Favorite();
        rawDB.Comment();
        rawDB.Brand();
        rawDB.Category();
        rawDB.Packaging();
        rawDB.Product();
        rawDB.ProductCategoryXref();
        rawDB.ProductTagXref();
        
        // Also initialize relationships
        require('../src/database/relationships')();
        
        // Get the initialized models from sequelize
        const DB = sequelize.models;

        // Hash password with same algorithm as UserService
        const { salt, hash } = hashPassword(password);

        // Create user
        console.log('👤 Création de l\'utilisateur...');
        const user = await DB.User.create({
            id: uuidv4(),
            email: email.toLowerCase(),
            username,
            firstname: firstname || null,
            lastname: lastname || null,
            phone: phone || null,
            image: null,
            role: 'Admin',
            salt,
            hash
        });

        // Find and assign Admin role
        const adminRole = await DB.Role.findOne({ where: { name: 'Admin' } });
        if (adminRole) {
            await user.addRoleIdRole(adminRole);
            console.log('✅ Rôle Admin assigné\n');
        } else {
            console.log('⚠️  Rôle Admin non trouvé, création en tant qu\'utilisateur uniquement\n');
        }

        // Success message
        console.log('✅ Utilisateur créé avec succès!\n');
        console.log('Détails:');
        console.log(`  📧 Email: ${user.email}`);
        console.log(`  👤 Nom d'utilisateur: ${user.username}`);
        console.log(`  🔐 Rôle: ${user.role}`);
        console.log('');

        rl.close();
        await sequelize.close();
        process.exit(0);
    } catch (error) {
        console.error('\n❌ Erreur lors de la création de l\'utilisateur:\n');
        console.error(error.message);
        console.error(error.stack);
        console.log('');
        rl.close();
        process.exit(1);
    }
};

// Run script
createUser();