@onurege3467/zerohelper/dist/bin/commands/db-backup.js

ZeroHelper is a versatile high-performance utility library and database framework for Node.js, fully written in TypeScript.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.dbRestoreCommand = exports.dbBackupCommand = void 0;
const commander_1 = require("commander");
const chalk_1 = __importDefault(require("chalk"));
const ora_1 = __importDefault(require("ora"));
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const config_1 = require("../utils/config");
const prompts_1 = require("../utils/prompts");
exports.dbBackupCommand = new commander_1.Command().name('db');
exports.dbBackupCommand
    .command('backup')
    .description('Backup database to timestamped file')
    .option('-c, --config <path>', 'Path to config file', 'zero.config.ts')
    .option('-o, --output <dir>', 'Output directory for backups', './backups')
    .action(async (options) => {
    const spinner = (0, ora_1.default)('Creating backup...').start();
    try {
        const db = await (0, config_1.getDatabase)(options.config);
        const config = (0, config_1.loadConfig)(options.config);
        const backupDir = path_1.default.resolve(process.cwd(), options.output);
        if (!fs_1.default.existsSync(backupDir)) {
            fs_1.default.mkdirSync(backupDir, { recursive: true });
        }
        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
        const backupFile = path_1.default.join(backupDir, `backup_${timestamp}.zerohelper.json`);
        let tables = [];
        if (config.adapter === 'json' && config.config.path) {
            const dbPath = path_1.default.resolve(process.cwd(), config.config.path);
            if (fs_1.default.existsSync(dbPath)) {
                const dbContent = JSON.parse(fs_1.default.readFileSync(dbPath, 'utf-8'));
                tables = Object.keys(dbContent);
            }
        }
        else if (config.adapter === 'sqlite' && config.config.path) {
            tables = await db.tables?.() || [];
        }
        else if (config.adapter === 'zpack' && config.config.path) {
            tables = await db.tables?.() || [];
        }
        else {
            tables = ['users', 'products', 'orders', 'migrations', 'migration_test', 'test_backup'];
        }
        const backupData = {
            version: '10.2.5',
            timestamp: new Date().toISOString(),
            config: config,
            data: {}
        };
        for (const table of tables) {
            try {
                const records = await db.select(table);
                if (records.length > 0) {
                    backupData.data[table] = records;
                }
            }
            catch (err) {
                // Table doesn't exist or can't be accessed
            }
        }
        fs_1.default.writeFileSync(backupFile, JSON.stringify(backupData, null, 2));
        const fileSize = fs_1.default.statSync(backupFile).size;
        spinner.succeed(chalk_1.default.green(`✅ Backup created: ${backupFile}`));
        console.log(chalk_1.default.gray(`  Size: ${(0, config_1.formatBytes)(fileSize)}`));
        console.log(chalk_1.default.gray(`  Tables: ${Object.keys(backupData.data).join(', ') || 'none'}`));
        await db.close();
    }
    catch (error) {
        spinner.fail(chalk_1.default.red('❌ Backup failed'));
        console.error(chalk_1.default.red(error.message));
        process.exit(1);
    }
});
exports.dbRestoreCommand = new commander_1.Command().name('db');
exports.dbRestoreCommand
    .command('restore')
    .description('Restore database from backup file')
    .argument('<backup-file>', 'Path to backup file')
    .option('-c, --config <path>', 'Path to config file', 'zero.config.ts')
    .action(async (backupFile, options) => {
    if (!fs_1.default.existsSync(backupFile)) {
        console.error(chalk_1.default.red(`Error: Backup file not found: ${backupFile}`));
        process.exit(1);
    }
    const backupData = JSON.parse(fs_1.default.readFileSync(backupFile, 'utf-8'));
    const confirmed = await (0, prompts_1.confirmAction)(chalk_1.default.yellow(`⚠️  This will restore data from backup. Are you sure?`));
    if (!confirmed) {
        console.log(chalk_1.default.yellow('Restore cancelled'));
        return;
    }
    const spinner = (0, ora_1.default)('Restoring database...').start();
    try {
        const db = await (0, config_1.getDatabase)(options.config);
        for (const [table, records] of Object.entries(backupData.data)) {
            const rows = records;
            if (Array.isArray(rows) && rows.length > 0) {
                try {
                    await db.bulkInsert(table, rows);
                    spinner.text = `✅ ${table}: ${rows.length} records`;
                }
                catch (err) {
                    spinner.text = `⚠️  ${table}: failed`;
                }
            }
        }
        spinner.succeed(chalk_1.default.green(`✅ Database restored from ${backupFile}`));
        await db.close();
    }
    catch (error) {
        spinner.fail(chalk_1.default.red('❌ Restore failed'));
        console.error(chalk_1.default.red(error.message));
        process.exit(1);
    }
});