dbdock 1.1.0

package/dist/cli/commands/restore.js

@@ -0,0 +1,637 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreCommand = restoreCommand;
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const config_1 = require("../utils/config");
+const logger_1 = require("../utils/logger");
+const local_adapter_1 = require("../../storage/adapters/local.adapter");
+const s3_adapter_1 = require("../../storage/adapters/s3.adapter");
+const r2_adapter_1 = require("../../storage/adapters/r2.adapter");
+const cloudinary_adapter_1 = require("../../storage/adapters/cloudinary.adapter");
+const child_process_1 = require("child_process");
+const zlib_1 = require("zlib");
+const crypto_1 = require("crypto");
+const os_1 = require("os");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const common_1 = require("@nestjs/common");
+const progress_1 = require("../utils/progress");
+common_1.Logger.overrideLogger(false);
+async function restoreCommand() {
+    const spinner = (0, ora_1.default)('Loading configuration...').start();
+    try {
+        const config = (0, config_1.loadConfig)();
+        spinner.succeed('Configuration loaded');
+        let adapter;
+        switch (config.storage.provider) {
+            case 'local':
+                adapter = new local_adapter_1.LocalStorageAdapter(config.storage.local?.path || './backups');
+                break;
+            case 's3':
+                if (!config.storage.s3?.accessKeyId ||
+                    !config.storage.s3?.secretAccessKey) {
+                    spinner.fail('S3 credentials are required');
+                    process.exit(1);
+                }
+                adapter = new s3_adapter_1.S3StorageAdapter({
+                    endpoint: config.storage.s3.endpoint,
+                    bucket: config.storage.s3.bucket || '',
+                    accessKeyId: config.storage.s3.accessKeyId,
+                    secretAccessKey: config.storage.s3.secretAccessKey,
+                });
+                break;
+            case 'r2': {
+                if (!config.storage.s3?.accessKeyId ||
+                    !config.storage.s3?.secretAccessKey) {
+                    spinner.fail('R2 credentials are required');
+                    process.exit(1);
+                }
+                if (!config.storage.s3?.endpoint) {
+                    spinner.fail('R2 endpoint is required');
+                    process.exit(1);
+                }
+                const accountId = config.storage.s3.endpoint.match(/https:\/\/([^.]+)/)?.[1];
+                if (!accountId) {
+                    spinner.fail('Invalid R2 endpoint format');
+                    process.exit(1);
+                }
+                adapter = new r2_adapter_1.R2StorageAdapter({
+                    accountId,
+                    bucket: config.storage.s3.bucket || '',
+                    accessKeyId: config.storage.s3.accessKeyId,
+                    secretAccessKey: config.storage.s3.secretAccessKey,
+                });
+                break;
+            }
+            case 'cloudinary':
+                if (!config.storage.cloudinary?.cloudName ||
+                    !config.storage.cloudinary?.apiKey ||
+                    !config.storage.cloudinary?.apiSecret) {
+                    spinner.fail('Cloudinary credentials are required');
+                    process.exit(1);
+                }
+                adapter = new cloudinary_adapter_1.CloudinaryStorageAdapter({
+                    cloudName: config.storage.cloudinary.cloudName,
+                    apiKey: config.storage.cloudinary.apiKey,
+                    apiSecret: config.storage.cloudinary.apiSecret,
+                    folder: 'dbdock_backups',
+                });
+                break;
+            default:
+                spinner.fail(`Unknown storage provider: ${config.storage.provider}`);
+                process.exit(1);
+        }
+        spinner.start('Loading backups...');
+        let objects;
+        try {
+            let prefix;
+            if (config.storage.provider === 'local') {
+                prefix = 'backup-';
+            }
+            else if (config.storage.provider === 'cloudinary') {
+                prefix = 'backup-';
+            }
+            else {
+                prefix = 'dbdock_backups/backup-';
+            }
+            objects = await adapter.listObjects({ prefix });
+            objects = objects
+                .filter((obj) => {
+                const key = obj.key.toLowerCase();
+                return (key.includes('backup-') &&
+                    (key.endsWith('.sql') ||
+                        key.endsWith('.dump') ||
+                        key.endsWith('.tar') ||
+                        key.endsWith('.dir') ||
+                        config.storage.provider === 'cloudinary'));
+            })
+                .sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+        }
+        catch (err) {
+            spinner.fail('Failed to list backups');
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            logger_1.logger.error(`\n${errorMessage}\n`);
+            if (config.storage.provider === 's3') {
+                logger_1.logger.info('Common S3 issues:');
+                logger_1.logger.log('  • Verify AWS credentials are correct');
+                logger_1.logger.log('  • Ensure IAM user has s3:ListBucket permission');
+                logger_1.logger.log('  • Check bucket name and region are correct');
+                logger_1.logger.log('  • Verify bucket exists and is accessible');
+            }
+            else if (config.storage.provider === 'r2') {
+                logger_1.logger.info('Common R2 issues:');
+                logger_1.logger.log('  • Verify R2 API token is correct');
+                logger_1.logger.log('  • Ensure endpoint URL is correct');
+                logger_1.logger.log('  • Check bucket name is correct');
+                logger_1.logger.log('  • Verify bucket exists and is accessible');
+            }
+            else if (config.storage.provider === 'cloudinary') {
+                logger_1.logger.info('Common Cloudinary issues:');
+                logger_1.logger.log('  • Verify cloud name, API key, and secret are correct');
+                logger_1.logger.log('  • Check your Cloudinary account is active');
+                logger_1.logger.log('  • Ensure API credentials have media library access');
+            }
+            else if (config.storage.provider === 'local') {
+                const localPath = config.storage.local?.path || './backups';
+                logger_1.logger.info('Common local storage issues:');
+                logger_1.logger.log(`  • Verify directory exists: ${localPath}`);
+                logger_1.logger.log('  • Check you have read permissions');
+                logger_1.logger.log('  • Ensure path is correct in dbdock.config.json');
+            }
+            logger_1.logger.info('\nTo test your configuration, run:');
+            logger_1.logger.log('  npx dbdock test');
+            process.exit(1);
+        }
+        spinner.succeed(`Found ${objects.length} backup(s)`);
+        if (objects.length === 0) {
+            logger_1.logger.error('\nNo backups found');
+            if (config.storage.provider === 'local') {
+                const localPath = config.storage.local?.path || './backups';
+                logger_1.logger.info('\nPlease verify:');
+                logger_1.logger.log(`  • Backup files exist in: ${localPath}`);
+                logger_1.logger.log(`  • Files are named: backup-*.dump or backup-*.sql`);
+                logger_1.logger.log(`  • You have read permissions on the directory`);
+            }
+            else if (config.storage.provider === 's3') {
+                const bucket = config.storage.s3?.bucket || '';
+                logger_1.logger.info('\nPlease verify:');
+                logger_1.logger.log(`  • Backups exist in S3 bucket: ${bucket}`);
+                logger_1.logger.log(`  • Files are in folder: dbdock_backups/`);
+                logger_1.logger.log(`  • Files are named: backup-*.dump or backup-*.sql`);
+                logger_1.logger.log(`  • Your AWS credentials have s3:ListBucket permission`);
+            }
+            else if (config.storage.provider === 'r2') {
+                const bucket = config.storage.s3?.bucket || '';
+                logger_1.logger.info('\nPlease verify:');
+                logger_1.logger.log(`  • Backups exist in R2 bucket: ${bucket}`);
+                logger_1.logger.log(`  • Files are in folder: dbdock_backups/`);
+                logger_1.logger.log(`  • Files are named: backup-*.dump or backup-*.sql`);
+                logger_1.logger.log(`  • Your R2 credentials have read permissions`);
+            }
+            else if (config.storage.provider === 'cloudinary') {
+                const cloudName = config.storage.cloudinary?.cloudName || '';
+                logger_1.logger.info('\nPlease verify:');
+                logger_1.logger.log(`  • Backups exist in Cloudinary cloud: ${cloudName}`);
+                logger_1.logger.log(`  • Files are in folder: dbdock_backups`);
+                logger_1.logger.log(`  • Files are named: backup-*.dump or backup-*.sql`);
+                logger_1.logger.log(`  • Your API credentials are correct`);
+                logger_1.logger.log(`  • Check: https://console.cloudinary.com/console/${cloudName}/media_library/folders/dbdock_backups`);
+            }
+            logger_1.logger.info('\nTo create a backup, run:');
+            logger_1.logger.log('  npx dbdock backup');
+            process.exit(1);
+        }
+        spinner.start('Analyzing current database...');
+        const currentDbStats = await getCurrentDatabaseStats(config);
+        spinner.succeed('Database analysis complete');
+        logger_1.logger.info('\nCurrent Database Statistics:');
+        logger_1.logger.log(`  Database: ${currentDbStats.name}`);
+        logger_1.logger.log(`  Tables: ${currentDbStats.tables}`);
+        logger_1.logger.log(`  Total Size: ${currentDbStats.size}`);
+        logger_1.logger.log(`  Estimated Rows: ${currentDbStats.rows}\n`);
+        let selectedBackup;
+        if (objects.length > 20) {
+            logger_1.logger.info(`Found ${objects.length} backups. Let's filter them to find the right one.\n`);
+            const { filterOption } = (await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'filterOption',
+                    message: 'How would you like to find your backup?',
+                    choices: [
+                        { name: 'Show most recent backups (last 10)', value: 'recent' },
+                        { name: 'Filter by date range', value: 'date' },
+                        { name: 'Search by keyword/ID', value: 'search' },
+                        {
+                            name: 'Show all backups (not recommended for many backups)',
+                            value: 'all',
+                        },
+                    ],
+                },
+            ]));
+            let filteredObjects = objects;
+            if (filterOption === 'recent') {
+                filteredObjects = objects.slice(0, 10);
+                logger_1.logger.info(`\nShowing the 10 most recent backups:\n`);
+            }
+            else if (filterOption === 'date') {
+                const { dateFilter } = (await inquirer_1.default.prompt([
+                    {
+                        type: 'list',
+                        name: 'dateFilter',
+                        message: 'Select time range:',
+                        choices: [
+                            { name: 'Last 24 hours', value: 1 },
+                            { name: 'Last 7 days', value: 7 },
+                            { name: 'Last 30 days', value: 30 },
+                            { name: 'Last 90 days', value: 90 },
+                            { name: 'Custom date range', value: 'custom' },
+                        ],
+                    },
+                ]));
+                if (dateFilter === 'custom') {
+                    const { startDate } = (await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'startDate',
+                            message: 'Enter start date (YYYY-MM-DD):',
+                            validate: (input) => {
+                                const date = new Date(input);
+                                return !isNaN(date.getTime()) || 'Please enter a valid date';
+                            },
+                        },
+                    ]));
+                    const cutoffDate = new Date(startDate);
+                    filteredObjects = objects.filter((obj) => obj.lastModified >= cutoffDate);
+                }
+                else if (typeof dateFilter === 'number') {
+                    const cutoffDate = new Date();
+                    cutoffDate.setDate(cutoffDate.getDate() - dateFilter);
+                    filteredObjects = objects.filter((obj) => obj.lastModified >= cutoffDate);
+                }
+                logger_1.logger.info(`\nFound ${filteredObjects.length} backup(s) in this time range:\n`);
+            }
+            else if (filterOption === 'search') {
+                const { searchTerm } = (await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'searchTerm',
+                        message: 'Enter search term (backup ID, date, etc.):',
+                    },
+                ]));
+                filteredObjects = objects.filter((obj) => obj.key.toLowerCase().includes(searchTerm.toLowerCase()));
+                logger_1.logger.info(`\nFound ${filteredObjects.length} backup(s) matching "${searchTerm}":\n`);
+            }
+            if (filteredObjects.length === 0) {
+                logger_1.logger.error('No backups found matching your criteria');
+                process.exit(1);
+            }
+            const { selected } = (await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'selected',
+                    message: `Select backup to restore (${filteredObjects.length} shown):`,
+                    pageSize: 15,
+                    choices: filteredObjects.map((obj) => ({
+                        name: `${obj.key.replace('dbdock_backups/', '')} (${(obj.size / 1024 / 1024).toFixed(2)} MB) - ${obj.lastModified.toLocaleString()} - ${getTimeAgo(obj.lastModified)}`,
+                        value: obj.key,
+                    })),
+                },
+            ]));
+            selectedBackup = selected;
+        }
+        else {
+            const { selected } = (await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'selected',
+                    message: 'Select backup to restore:',
+                    pageSize: 15,
+                    choices: objects.map((obj) => ({
+                        name: `${obj.key.replace('dbdock_backups/', '')} (${(obj.size / 1024 / 1024).toFixed(2)} MB) - ${obj.lastModified.toLocaleString()} - ${getTimeAgo(obj.lastModified)}`,
+                        value: obj.key,
+                    })),
+                },
+            ]));
+            selectedBackup = selected;
+        }
+        const selectedBackupObj = objects.find((obj) => obj.key === selectedBackup);
+        if (selectedBackupObj) {
+            logger_1.logger.info('\nSelected Backup Details:');
+            logger_1.logger.log(`  Backup: ${selectedBackup}`);
+            logger_1.logger.log(`  Size: ${(selectedBackupObj.size / 1024 / 1024).toFixed(2)} MB`);
+            logger_1.logger.log(`  Created: ${selectedBackupObj.lastModified.toLocaleString()}`);
+            logger_1.logger.log(`  Age: ${getTimeAgo(selectedBackupObj.lastModified)}\n`);
+        }
+        const { confirm } = (await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'This will overwrite the current database. Continue?',
+                default: false,
+            },
+        ]));
+        if (!confirm) {
+            logger_1.logger.warn('Restore cancelled');
+            return;
+        }
+        const restoreSteps = new progress_1.MultiStepProgress([
+            'Downloading backup',
+            'Decrypting data',
+            'Decompressing data',
+            'Restoring to database',
+        ]);
+        restoreSteps.start();
+        const dbConfig = config.database;
+        const pgRestoreArgs = [
+            '-h',
+            dbConfig.host || 'localhost',
+            '-p',
+            String(dbConfig.port || 5432),
+            '-U',
+            dbConfig.username || 'postgres',
+            '-d',
+            dbConfig.database || 'postgres',
+            '-F',
+            'c',
+            '--clean',
+            '--if-exists',
+            '--no-owner',
+            '--no-acl',
+            '--no-password',
+        ];
+        const env = {
+            ...process.env,
+            PGPASSWORD: dbConfig.password,
+        };
+        let stream;
+        let tempFilePath = null;
+        try {
+            if (config.storage.provider === 'local') {
+                const localAdapter = adapter;
+                stream = await localAdapter.downloadStream({ key: selectedBackup });
+            }
+            else {
+                tempFilePath = (0, path_1.join)((0, os_1.tmpdir)(), `dbdock-restore-${Date.now()}.sql`);
+                const downloadStream = await adapter.downloadStream({
+                    key: selectedBackup,
+                });
+                const tempWriteStream = (0, fs_1.createWriteStream)(tempFilePath);
+                let downloadedBytes = 0;
+                downloadStream.on('data', (chunk) => {
+                    downloadedBytes += chunk.length;
+                    const mb = (downloadedBytes / 1024 / 1024).toFixed(2);
+                    restoreSteps.nextStep(`${mb} MB downloaded`);
+                });
+                await new Promise((resolve, reject) => {
+                    downloadStream.pipe(tempWriteStream);
+                    downloadStream.on('error', reject);
+                    tempWriteStream.on('error', reject);
+                    tempWriteStream.on('finish', resolve);
+                });
+                const { createReadStream } = await Promise.resolve().then(() => __importStar(require('fs')));
+                stream = createReadStream(tempFilePath);
+            }
+            restoreSteps.nextStep();
+        }
+        catch (err) {
+            restoreSteps.fail(err instanceof Error ? err.message : String(err));
+            if (tempFilePath && (0, fs_1.existsSync)(tempFilePath)) {
+                (0, fs_1.unlinkSync)(tempFilePath);
+            }
+            process.exit(1);
+        }
+        stream.on('error', (err) => {
+            restoreSteps.fail(`Failed to read backup file: ${err.message}`);
+            if (tempFilePath && (0, fs_1.existsSync)(tempFilePath)) {
+                (0, fs_1.unlinkSync)(tempFilePath);
+            }
+            process.exit(1);
+        });
+        if (config.backup?.encryption?.enabled && config.backup.encryption.key) {
+            const keyBuffer = Buffer.from(config.backup.encryption.key, 'hex');
+            if (keyBuffer.length !== 32) {
+                restoreSteps.fail(`Invalid encryption key length: ${keyBuffer.length} bytes (expected 32 bytes)`);
+                logger_1.logger.error(`\nYour key: "${config.backup.encryption.key}" (${config.backup.encryption.key.length} characters)\n\n` +
+                    `Please fix:\n` +
+                    `  • Encryption key must be exactly 64 hexadecimal characters (32 bytes)\n` +
+                    `  • Generate a valid key: node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"\n` +
+                    `  • Update the "backup.encryption.key" in your dbdock.config.json`);
+                if (tempFilePath && (0, fs_1.existsSync)(tempFilePath)) {
+                    (0, fs_1.unlinkSync)(tempFilePath);
+                }
+                process.exit(1);
+            }
+            const iv = Buffer.alloc(16);
+            const decipher = (0, crypto_1.createDecipheriv)('aes-256-cbc', keyBuffer, iv);
+            stream = stream.pipe(decipher);
+            restoreSteps.nextStep();
+        }
+        else {
+            restoreSteps.nextStep();
+        }
+        if (config.backup?.compression?.enabled) {
+            const decompressStream = (0, zlib_1.createBrotliDecompress)();
+            stream = stream.pipe(decompressStream);
+            restoreSteps.nextStep();
+        }
+        else {
+            restoreSteps.nextStep();
+        }
+        const pgRestoreProcess = (0, child_process_1.spawn)('pg_restore', pgRestoreArgs, { env });
+        stream.pipe(pgRestoreProcess.stdin);
+        const ignoredPatterns = [
+            'NOTICE',
+            'WARNING',
+            'transaction_timeout',
+            'errors ignored on restore',
+            'unrecognized configuration parameter',
+            'already exists',
+            'does not exist',
+            'no privileges could be revoked',
+            'no privileges were granted',
+            'role .* does not exist',
+            'extension .* already exists',
+            'schema .* already exists',
+            'procedural language .* already exists',
+        ];
+        const shouldIgnoreError = (message) => {
+            return ignoredPatterns.some((pattern) => message.toLowerCase().includes(pattern.toLowerCase()));
+        };
+        await new Promise((resolve, reject) => {
+            let errorOutput = '';
+            let hasWarnings = false;
+            pgRestoreProcess.on('close', (code) => {
+                if (tempFilePath && (0, fs_1.existsSync)(tempFilePath)) {
+                    (0, fs_1.unlinkSync)(tempFilePath);
+                }
+                if (code === 0 || (code === 1 && !errorOutput && hasWarnings)) {
+                    resolve();
+                }
+                else if (code === 1 && errorOutput) {
+                    const friendlyError = parsePgRestoreError(errorOutput);
+                    reject(new Error(friendlyError));
+                }
+                else if (code !== 0) {
+                    reject(new Error(`pg_restore exited with code ${code}${errorOutput ? ': ' + errorOutput : ''}`));
+                }
+            });
+            pgRestoreProcess.on('error', (err) => {
+                if (tempFilePath && (0, fs_1.existsSync)(tempFilePath)) {
+                    (0, fs_1.unlinkSync)(tempFilePath);
+                }
+                reject(new Error(`Failed to execute pg_restore: ${err.message}`));
+            });
+            pgRestoreProcess.stderr.on('data', (data) => {
+                const message = data.toString();
+                if (shouldIgnoreError(message)) {
+                    hasWarnings = true;
+                }
+                else if (message.trim()) {
+                    errorOutput += message;
+                }
+            });
+        });
+        restoreSteps.complete();
+        logger_1.logger.success('Restore completed successfully');
+    }
+    catch (error) {
+        logger_1.logger.error('\n✖ Restore failed');
+        logger_1.logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+async function getCurrentDatabaseStats(config) {
+    const dbConfig = config.database;
+    const queries = [
+        `SELECT count(*) as table_count FROM information_schema.tables WHERE table_schema = 'public'`,
+        `SELECT pg_size_pretty(pg_database_size('${dbConfig.database}')) as size`,
+        `SELECT sum(n_live_tup) as total_rows FROM pg_stat_user_tables`,
+    ];
+    const psqlArgs = [
+        '-h',
+        dbConfig.host || 'localhost',
+        '-p',
+        String(dbConfig.port || 5432),
+        '-U',
+        dbConfig.username || 'postgres',
+        '-d',
+        dbConfig.database || 'postgres',
+        '-t',
+        '--no-password',
+    ];
+    const env = {
+        ...process.env,
+        PGPASSWORD: dbConfig.password,
+    };
+    const results = await Promise.all(queries.map((query) => new Promise((resolve, reject) => {
+        const psqlProcess = (0, child_process_1.spawn)('psql', [...psqlArgs, '-c', query], {
+            env,
+        });
+        let output = '';
+        let errorOutput = '';
+        psqlProcess.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        psqlProcess.stderr.on('data', (data) => {
+            errorOutput += data.toString();
+        });
+        psqlProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve(output.trim());
+            }
+            else {
+                reject(new Error(errorOutput || `Query failed with code ${code}`));
+            }
+        });
+        psqlProcess.on('error', reject);
+    })));
+    return {
+        name: dbConfig.database || 'postgres',
+        tables: parseInt(results[0]) || 0,
+        size: results[1] || 'Unknown',
+        rows: results[2] ? parseInt(results[2]).toLocaleString() : '0',
+    };
+}
+function parsePgRestoreError(errorOutput) {
+    const lowerError = errorOutput.toLowerCase();
+    if (lowerError.includes('authentication failed')) {
+        return ('Database authentication failed\n\n' +
+            'Please verify:\n' +
+            '  • Database password is correct in dbdock.config.json\n' +
+            '  • Database user has necessary permissions\n' +
+            '  • Database host and port are accessible');
+    }
+    if (lowerError.includes('connection refused') || lowerError.includes('could not connect')) {
+        return ('Failed to connect to database\n\n' +
+            'Please verify:\n' +
+            '  • Database server is running\n' +
+            '  • Host and port are correct in dbdock.config.json\n' +
+            '  • Firewall allows connection to database port\n' +
+            '  • Database accepts connections from your IP');
+    }
+    if (lowerError.includes('permission denied')) {
+        return ('Database permission denied\n\n' +
+            'Please verify:\n' +
+            '  • Database user has CREATE/DROP privileges\n' +
+            '  • User has permission to restore to this database\n' +
+            '  • Try using a superuser account for restore');
+    }
+    if (lowerError.includes('database') && lowerError.includes('does not exist')) {
+        return ('Target database does not exist\n\n' +
+            'Please:\n' +
+            '  • Create the database first, or\n' +
+            '  • Update database name in dbdock.config.json');
+    }
+    if (lowerError.includes('disk full') || lowerError.includes('no space left')) {
+        return ('Insufficient disk space\n\n' +
+            'Please:\n' +
+            '  • Free up disk space on database server\n' +
+            '  • Check available storage before restoring');
+    }
+    if (lowerError.includes('corrupted') || lowerError.includes('invalid backup')) {
+        return ('Backup file appears to be corrupted\n\n' +
+            'Please:\n' +
+            '  • Try a different backup file\n' +
+            '  • Verify backup was created successfully\n' +
+            '  • Check encryption key matches if encryption is enabled');
+    }
+    return `Database restore error:\n\n${errorOutput.trim()}\n\nIf you need help, please check the documentation or report this issue.`;
+}
+function getTimeAgo(date) {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+        return `${days} day${days > 1 ? 's' : ''} ago`;
+    }
+    else if (hours > 0) {
+        return `${hours} hour${hours > 1 ? 's' : ''} ago`;
+    }
+    else if (minutes > 0) {
+        return `${minutes} minute${minutes > 1 ? 's' : ''} ago`;
+    }
+    else {
+        return 'Just now';
+    }
+}
+//# sourceMappingURL=restore.js.map