@magentrix-corp/magentrix-cli 1.3.9 → 1.3.11

package/utils/iris/backup.js

@@ -2,9 +2,21 @@ import fs from 'fs';
 import path from 'path';
 import { createIrisZip } from './zipper.js';
 import { extractIrisZip } from './zipper.js';
+import {
+    detectErrorType,
+    ErrorTypes,
+    formatPermissionError,
+    formatDiskFullError,
+    formatFileLockError
+} from './errors.js';
 
 const BACKUP_DIR = '.magentrix/iris-backups';
 
+/**
+ * Maximum backup age in days. Older backups will be cleaned up.
+ */
+const MAX_BACKUP_AGE_DAYS = 30;
+
 /**
  * Create a backup of an Iris app before deletion.
  *
@@ -16,20 +28,89 @@ const BACKUP_DIR = '.magentrix/iris-backups';
  * @returns {Promise<{success: boolean, backupPath: string | null, error: string | null}>}
  */
 export async function backupIrisApp(appPath, metadata) {
-    try {
-        const { slug } = metadata;
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-        const backupName = `${slug}-${timestamp}`;
-        const backupPath = path.join(process.cwd(), BACKUP_DIR, backupName);
+    const { slug } = metadata;
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const backupName = `${slug}-${timestamp}`;
+    const backupPath = path.join(process.cwd(), BACKUP_DIR, backupName);
 
-        // Create backup directory
+    try {
+        // Ensure backup directory exists
         fs.mkdirSync(backupPath, { recursive: true });
+    } catch (err) {
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                backupPath: null,
+                error: formatPermissionError({
+                    operation: 'create backup directory',
+                    path: backupPath
+                }),
+                isPermissionError: true
+            };
+        }
+        if (errorType === ErrorTypes.DISK_FULL) {
+            return {
+                success: false,
+                backupPath: null,
+                error: formatDiskFullError({
+                    operation: 'create backup',
+                    path: backupPath
+                }),
+                isDiskFull: true
+            };
+        }
+        return {
+            success: false,
+            backupPath: null,
+            error: `Failed to create backup directory: ${err.message}`
+        };
+    }
 
+    try {
         // Create ZIP of app files
         const zipBuffer = await createIrisZip(appPath, slug);
         const zipPath = path.join(backupPath, `${slug}.zip`);
         fs.writeFileSync(zipPath, zipBuffer);
+    } catch (err) {
+        // Clean up partial backup
+        try {
+            fs.rmSync(backupPath, { recursive: true, force: true });
+        } catch {
+            // Ignore cleanup errors
+        }
+
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                backupPath: null,
+                error: formatPermissionError({
+                    operation: 'write backup files',
+                    path: backupPath
+                }),
+                isPermissionError: true
+            };
+        }
+        if (errorType === ErrorTypes.DISK_FULL) {
+            return {
+                success: false,
+                backupPath: null,
+                error: formatDiskFullError({
+                    operation: 'create backup',
+                    path: backupPath
+                }),
+                isDiskFull: true
+            };
+        }
+        return {
+            success: false,
+            backupPath: null,
+            error: `Failed to create backup ZIP: ${err.message}`
+        };
+    }
 
+    try {
         // Save metadata
         const metadataPath = path.join(backupPath, 'metadata.json');
         fs.writeFileSync(metadataPath, JSON.stringify({
@@ -38,19 +119,25 @@ export async function backupIrisApp(appPath, metadata) {
             backupName,
             originalPath: appPath
         }, null, 2));
-
-        return {
-            success: true,
-            backupPath,
-            error: null
-        };
-    } catch (error) {
+    } catch (err) {
+        // Clean up partial backup
+        try {
+            fs.rmSync(backupPath, { recursive: true, force: true });
+        } catch {
+            // Ignore cleanup errors
+        }
         return {
             success: false,
             backupPath: null,
-            error: error.message
+            error: `Failed to save backup metadata: ${err.message}`
         };
     }
+
+    return {
+        success: true,
+        backupPath,
+        error: null
+    };
 }
 
 /**
@@ -128,74 +215,197 @@ export async function restoreIrisApp(backupPath, options = {}) {
         warnings: [],
         error: null,
         isPermissionError: false,
+        isFileLocked: false,
+        isCorrupted: false,
         targetPath: null
     };
 
+    // Read metadata
+    const metadataPath = path.join(backupPath, 'metadata.json');
+    if (!fs.existsSync(metadataPath)) {
+        result.error = 'Backup metadata not found. The backup may be incomplete or corrupted.';
+        result.isCorrupted = true;
+        return result;
+    }
+
+    let metadata;
     try {
-        // Read metadata
-        const metadataPath = path.join(backupPath, 'metadata.json');
-        if (!fs.existsSync(metadataPath)) {
-            result.error = 'Backup metadata not found';
-            return result;
+        const metadataContent = fs.readFileSync(metadataPath, 'utf-8');
+        metadata = JSON.parse(metadataContent);
+    } catch (err) {
+        if (err instanceof SyntaxError) {
+            result.error = 'Backup metadata is corrupted (invalid JSON). The backup may be damaged.';
+            result.isCorrupted = true;
+        } else {
+            result.error = `Failed to read backup metadata: ${err.message}`;
         }
+        return result;
+    }
 
-        const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
-        const { slug, linkedProject } = metadata;
+    const { slug, linkedProject } = metadata;
 
-        // Restore local files
-        if (restoreLocal) {
-            const zipPath = path.join(backupPath, `${slug}.zip`);
-            if (!fs.existsSync(zipPath)) {
-                result.error = 'Backup ZIP file not found';
-                return result;
+    if (!slug) {
+        result.error = 'Backup metadata is missing required "slug" field. The backup may be corrupted.';
+        result.isCorrupted = true;
+        return result;
+    }
+
+    // Restore local files
+    if (restoreLocal) {
+        const zipPath = path.join(backupPath, `${slug}.zip`);
+        if (!fs.existsSync(zipPath)) {
+            result.error = 'Backup ZIP file not found. The backup may be incomplete.';
+            result.isCorrupted = true;
+            return result;
+        }
+
+        let zipBuffer;
+        try {
+            zipBuffer = fs.readFileSync(zipPath);
+        } catch (err) {
+            const errorType = detectErrorType(err);
+            if (errorType === ErrorTypes.PERMISSION) {
+                result.error = formatPermissionError({
+                    operation: 'read backup file',
+                    path: zipPath
+                });
+                result.isPermissionError = true;
+            } else if (errorType === ErrorTypes.FILE_LOCKED) {
+                result.error = formatFileLockError({ path: zipPath });
+                result.isFileLocked = true;
+            } else {
+                result.error = `Failed to read backup file: ${err.message}`;
             }
+            return result;
+        }
 
-            const zipBuffer = fs.readFileSync(zipPath);
-            const targetDir = path.join(process.cwd(), 'src', 'iris-apps');
-            const appTargetDir = path.join(targetDir, slug);
-            result.targetPath = appTargetDir;
+        const targetDir = path.join(process.cwd(), 'src', 'iris-apps');
+        const appTargetDir = path.join(targetDir, slug);
+        result.targetPath = appTargetDir;
 
-            // Ensure target directory exists
+        // Ensure target directory exists
+        try {
             fs.mkdirSync(targetDir, { recursive: true });
+        } catch (err) {
+            const errorType = detectErrorType(err);
+            if (errorType === ErrorTypes.PERMISSION) {
+                result.error = formatPermissionError({
+                    operation: 'create restore directory',
+                    path: targetDir
+                });
+                result.isPermissionError = true;
+            } else {
+                result.error = `Failed to create restore directory: ${err.message}`;
+            }
+            return result;
+        }
 
-            // Extract backup
+        // Extract backup
+        try {
             await extractIrisZip(zipBuffer, targetDir);
             result.restoredFiles = true;
-        }
-
-        // Restore linked project
-        if (restoreLink && linkedProject) {
-            // Check if the linked project path still exists
-            if (!fs.existsSync(linkedProject.path)) {
-                result.linkedProjectPathExists = false;
-                result.warnings.push(
-                    `Linked Vue project no longer exists at: ${linkedProject.path}`
-                );
+        } catch (err) {
+            const errorType = detectErrorType(err);
+            if (errorType === ErrorTypes.PERMISSION) {
+                result.error = formatPermissionError({
+                    operation: 'extract backup files',
+                    path: appTargetDir
+                });
+                result.isPermissionError = true;
+            } else if (errorType === ErrorTypes.FILE_LOCKED) {
+                result.error = formatFileLockError({ path: appTargetDir });
+                result.isFileLocked = true;
+            } else if (errorType === ErrorTypes.DISK_FULL) {
+                result.error = formatDiskFullError({
+                    operation: 'restore backup',
+                    path: appTargetDir
+                });
+            } else if (err.message?.includes('invalid') || err.message?.includes('corrupt')) {
+                result.error = 'Backup ZIP file appears to be corrupted. The backup cannot be restored.';
+                result.isCorrupted = true;
             } else {
-                result.restoredLink = true;
+                result.error = `Failed to extract backup: ${err.message}`;
             }
+            return result;
         }
+    }
 
-        result.success = true;
-        return result;
-    } catch (error) {
-        result.error = error.message;
-        result.isPermissionError = error.code === 'EACCES' || error.code === 'EPERM';
-        return result;
+    // Restore linked project
+    if (restoreLink && linkedProject) {
+        // Check if the linked project path still exists
+        if (!fs.existsSync(linkedProject.path)) {
+            result.linkedProjectPathExists = false;
+            result.warnings.push(
+                `Linked Vue project no longer exists at: ${linkedProject.path}`
+            );
+        } else {
+            result.restoredLink = true;
+        }
     }
+
+    result.success = true;
+    return result;
 }
 
 /**
  * Delete a backup folder.
  *
  * @param {string} backupPath - Path to the backup folder
+ * @returns {{success: boolean, error: string | null}}
  */
 export function deleteBackup(backupPath) {
     try {
         if (fs.existsSync(backupPath)) {
             fs.rmSync(backupPath, { recursive: true, force: true });
         }
-    } catch {
-        // Ignore errors
+        return { success: true, error: null };
+    } catch (err) {
+        const errorType = detectErrorType(err);
+        if (errorType === ErrorTypes.PERMISSION) {
+            return {
+                success: false,
+                error: formatPermissionError({
+                    operation: 'delete backup',
+                    path: backupPath
+                })
+            };
+        }
+        if (errorType === ErrorTypes.FILE_LOCKED) {
+            return {
+                success: false,
+                error: formatFileLockError({ path: backupPath })
+            };
+        }
+        return {
+            success: false,
+            error: `Failed to delete backup: ${err.message}`
+        };
     }
 }
+
+/**
+ * Clean up old backups (older than MAX_BACKUP_AGE_DAYS).
+ *
+ * @returns {{cleaned: number, errors: number}}
+ */
+export function cleanupOldBackups() {
+    const result = { cleaned: 0, errors: 0 };
+    const backups = listBackups();
+
+    const now = Date.now();
+    const maxAge = MAX_BACKUP_AGE_DAYS * 24 * 60 * 60 * 1000;
+
+    for (const backup of backups) {
+        const age = now - new Date(backup.deletedAt).getTime();
+        if (age > maxAge) {
+            const deleteResult = deleteBackup(backup.backupPath);
+            if (deleteResult.success) {
+                result.cleaned++;
+            } else {
+                result.errors++;
+            }
+        }
+    }
+
+    return result;
+}