ante-erp-cli 1.9.12 → 1.9.14

package/bin/ante-cli.js

@@ -81,10 +81,9 @@ program
 const backupCmd = program
   .command('backup')
   .alias('dump')
-  .description('Create backup of ANTE ERP')
+  .description('Create backup of ANTE ERP databases (PostgreSQL and MongoDB)')
   .option('-o, --output <path>', 'Output file path')
-  .option('--compress', 'Compress backup', true)
-  .option('--databases-only', 'Only backup databases')
+  .option('-k, --keyword <text>', 'Add keyword to backup filename for easier identification')
   .action(backup);
 
 backupCmd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ante-erp-cli",
-  "version": "1.9.12",
+  "version": "1.9.14",
   "description": "Comprehensive CLI tool for managing ANTE ERP self-hosted installations",
   "type": "module",
   "bin": {

package/src/commands/backup.js

@@ -1,32 +1,37 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { join } from 'path';
-import { readdirSync } from 'fs';
+import { readdirSync, readFileSync } from 'fs';
 import { execa } from 'execa';
 import Table from 'cli-table3';
 import { getInstallDir } from '../utils/config.js';
+import { dumpDatabase, parseMongoUrl } from '../utils/mongodb.js';
 
 /**
- * Create backup of ANTE ERP
+ * Create backup of ANTE ERP databases (PostgreSQL and MongoDB)
  */
 export async function backup(options) {
   try {
     const installDir = getInstallDir();
     const composeFile = join(installDir, 'docker-compose.yml');
     const backupDir = join(installDir, 'backups');
-    
+
+    // Generate backup filename with optional keyword
     const timestamp = new Date().toISOString().split('.')[0].replace(/:/g, '-').replace('T', '_');
-    const backupFile = options.output || join(backupDir, `ante-backup-${timestamp}.tar.gz`);
-    
-    const spinner = ora('Creating backup...').start();
-    
+    const keywordPart = options.keyword
+      ? `-${options.keyword.replace(/[^a-zA-Z0-9-_]/g, '-')}`
+      : '';
+    const backupFile = options.output || join(backupDir, `ante-backup-${timestamp}${keywordPart}.tar.gz`);
+
+    const spinner = ora('Creating database backup...').start();
+
     try {
       // Create temporary backup directory
       const tempDir = join(installDir, '.backup-temp');
       await execa('mkdir', ['-p', tempDir]);
 
       // Backup PostgreSQL - dump directly to file inside container
-      spinner.text = 'Backing up PostgreSQL...';
+      spinner.text = 'Backing up PostgreSQL database...';
       await execa('docker', [
         'compose',
         '-f',
@@ -50,23 +55,64 @@ export async function backup(options) {
         'ante-postgres:/tmp/postgres.dump',
         join(tempDir, 'postgres.dump')
       ]);
-      
-      // Copy uploaded files
-      if (!options.databasesOnly) {
-        spinner.text = 'Backing up uploaded files...';
-        await execa('docker', [
-          'cp',
-          'ante-backend:/app/uploads',
-          join(tempDir, 'uploads')
-        ]);
+
+      // Backup MongoDB
+      spinner.text = 'Backing up MongoDB database...';
+
+      // Read MongoDB password from .env file
+      const envPath = join(installDir, '.env');
+      const envContent = readFileSync(envPath, 'utf8');
+
+      // Try to find MONGODB_URI first (development environment)
+      let mongoInfo;
+      const mongoUriMatch = envContent.match(/MONGODB_URI=(.+)/);
+
+      if (mongoUriMatch) {
+        // Development environment with full URI
+        const mongoUri = mongoUriMatch[1].trim();
+        mongoInfo = parseMongoUrl(mongoUri);
+      } else {
+        // CLI installation environment - construct URI from components
+        const mongoPasswordMatch = envContent.match(/MONGO_PASSWORD=(.+)/);
+
+        if (!mongoPasswordMatch) {
+          throw new Error('MONGO_PASSWORD not found in .env file');
+        }
+
+        const mongoPassword = mongoPasswordMatch[1].trim();
+
+        // Construct MongoDB connection info for CLI installation
+        mongoInfo = {
+          user: 'ante',
+          password: mongoPassword,
+          host: 'localhost',
+          port: '27017',
+          database: 'ante',
+          authDatabase: 'admin',
+          isSrv: false
+        };
+      }
+
+      // Create MongoDB dump in temporary directory
+      const mongoDumpTempDir = join(tempDir, 'mongodb-temp');
+      const mongoResult = await dumpDatabase(mongoInfo, mongoDumpTempDir);
+
+      if (!mongoResult.success) {
+        throw new Error(`MongoDB backup failed: ${mongoResult.error}`);
       }
-      
-      // Copy configuration
-      await execa('cp', [join(installDir, 'docker-compose.yml'), tempDir]);
-      await execa('cp', [join(installDir, '.env'), join(tempDir, 'env.backup')]);
-      
+
+      // Move MongoDB dump to final structure (mongodb/ folder)
+      await execa('mv', [
+        join(mongoDumpTempDir, mongoInfo.database),
+        join(tempDir, 'mongodb')
+      ]);
+
+      // Remove temporary MongoDB dump directory
+      await execa('rm', ['-rf', mongoDumpTempDir]);
+
       // Create tar.gz archive
       spinner.text = 'Creating compressed archive...';
+      await execa('mkdir', ['-p', backupDir]);
       await execa('tar', [
         '-czf',
         backupFile,
@@ -74,21 +120,24 @@ export async function backup(options) {
         tempDir,
         '.'
       ]);
-      
+
       // Cleanup
       await execa('rm', ['-rf', tempDir]);
-      
-      spinner.succeed(`Backup created: ${backupFile}`);
-      
-      // Show backup size
+
+      spinner.succeed(chalk.green('Database backup created successfully!'));
+
+      // Show backup details
       const { stdout: size } = await execa('du', ['-h', backupFile]);
-      console.log(chalk.gray(`Size: ${size.split('\t')[0]}\n`));
-      
+      console.log(chalk.white('\n✓ PostgreSQL database backed up'));
+      console.log(chalk.white(`✓ MongoDB database backed up (${mongoResult.collections} collections, ${mongoResult.size})`));
+      console.log(chalk.cyan(`\nBackup file: ${backupFile}`));
+      console.log(chalk.gray(`Total size: ${size.split('\t')[0]}\n`));
+
     } catch (error) {
       spinner.fail('Backup failed');
       throw error;
     }
-    
+
   } catch (error) {
     console.error(chalk.red('Error:'), error.message);
     process.exit(1);
@@ -102,42 +151,41 @@ export async function listBackups() {
   try {
     const installDir = getInstallDir();
     const backupDir = join(installDir, 'backups');
-    
+
     console.log(chalk.bold('\n💾 Available Backups\n'));
-    
+
     const files = readdirSync(backupDir)
       .filter(f => f.endsWith('.tar.gz'))
       .sort()
       .reverse();
-    
+
     if (files.length === 0) {
       console.log(chalk.yellow('No backups found\n'));
       return;
     }
-    
+
     const table = new Table({
       head: [chalk.cyan('Backup File'), chalk.cyan('Size'), chalk.cyan('Date')],
       style: { head: [], border: ['gray'] }
     });
-    
+
     for (const file of files) {
       const filePath = join(backupDir, file);
       const { stdout: size } = await execa('du', ['-h', filePath]);
       const { stdout: date } = await execa('stat', ['-c', '%y', filePath]);
-      
+
       table.push([
         file,
         size.split('\t')[0],
         date.split('.')[0]
       ]);
     }
-    
+
     console.log(table.toString());
     console.log();
-    
+
   } catch (error) {
     console.error(chalk.red('Error:'), error.message);
     process.exit(1);
   }
 }
-

package/src/commands/restore.js

@@ -8,7 +8,7 @@ import { getInstallDir } from '../utils/config.js';
 import { execInContainer, stopServices, startServices } from '../utils/docker.js';
 
 /**
- * Restore ANTE ERP from backup
+ * Restore ANTE ERP databases from backup (PostgreSQL and MongoDB only)
  */
 export async function restore(backupFile, options = {}) {
   try {
@@ -58,8 +58,8 @@ export async function restore(backupFile, options = {}) {
     }
 
     // Warning and confirmation
-    console.log(chalk.yellow('\n⚠  WARNING: This will restore ANTE from backup'));
-    console.log(chalk.gray('Current data will be replaced with backup data'));
+    console.log(chalk.yellow('\n⚠  WARNING: This will restore databases from backup'));
+    console.log(chalk.gray('Current database data will be replaced with backup data'));
     console.log(chalk.white('\nBackup file:'), chalk.cyan(basename(backupFile)));
 
     if (!options.force) {
@@ -136,42 +136,23 @@ export async function restore(backupFile, options = {}) {
       spinner.text = 'Restoring MongoDB database...';
       const mongoDumpDir = join(tempDir, 'mongodb');
       if (existsSync(mongoDumpDir)) {
+        // Copy MongoDB dump directory to container
+        // The backup structure is: mongodb/ contains the database files directly
         await execa('docker', [
           'cp',
           mongoDumpDir,
-          'ante-mongodb:/tmp/restore'
+          'ante-mongodb:/tmp/'
         ]);
 
+        // Restore from the mongodb directory (contains BSON files)
+        // Use --nsInclude to restore all collections from the dump
         await execInContainer(
           composeFile,
           'mongodb',
-          ['mongorestore', '--drop', '--db', 'ante', '/tmp/restore/ante']
+          ['mongorestore', '--drop', '--dir', '/tmp/mongodb', '--db', 'ante']
         );
       }
 
-      // Restore uploaded files
-      spinner.text = 'Restoring uploaded files...';
-      const uploadsDir = join(tempDir, 'uploads');
-      if (existsSync(uploadsDir)) {
-        await execa('docker', [
-          'cp',
-          uploadsDir,
-          'ante-backend:/app/'
-        ]);
-      }
-
-      // Restore configuration files
-      spinner.text = 'Restoring configuration...';
-      const envBackup = join(tempDir, 'env.backup');
-      if (existsSync(envBackup)) {
-        await execa('cp', [envBackup, join(installDir, '.env')]);
-      }
-
-      const composeBackup = join(tempDir, 'docker-compose.yml');
-      if (existsSync(composeBackup)) {
-        await execa('cp', [composeBackup, composeFile]);
-      }
-
       // Start all services
       spinner.text = 'Starting all services...';
       await startServices(composeFile);
@@ -180,15 +161,13 @@ export async function restore(backupFile, options = {}) {
       spinner.text = 'Cleaning up...';
       await execa('rm', ['-rf', tempDir]);
 
-      spinner.succeed(chalk.green('Restore completed successfully!'));
+      spinner.succeed(chalk.green('Database restore completed successfully!'));
 
       console.log(chalk.white('\n✓ PostgreSQL database restored'));
       console.log(chalk.white('✓ MongoDB database restored'));
-      console.log(chalk.white('✓ Uploaded files restored'));
-      console.log(chalk.white('✓ Configuration restored'));
       console.log(chalk.white('✓ All services started'));
 
-      console.log(chalk.cyan('\nANTE is now running with restored data'));
+      console.log(chalk.cyan('\nANTE is now running with restored database data'));
 
     } catch (error) {
       spinner.fail(chalk.red('Restore failed'));