@njdamstra/appwrite-utils-cli 1.8.9

package/dist/shared/selectionDialogs.js

@@ -0,0 +1,544 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { MessageFormatter } from "./messageFormatter.js";
+import { logger } from "./logging.js";
+/**
+ * Comprehensive selection dialog system for enhanced sync flow
+ *
+ * This class provides interactive dialogs for selecting databases, tables/collections,
+ * and storage buckets during sync operations. It supports both new and existing
+ * configurations with visual indicators and comprehensive confirmation flows.
+ *
+ * @example
+ * ```typescript
+ * import { SelectionDialogs } from './shared/selectionDialogs.js';
+ * import type { Models } from 'node-appwrite';
+ *
+ * // Example usage in a sync command
+ * const availableDatabases: Models.Database[] = await getAvailableDatabases();
+ * const configuredDatabases = config.databases || [];
+ *
+ * // Prompt about existing configuration
+ * const { syncExisting, modifyConfiguration } = await SelectionDialogs.promptForExistingConfig(configuredDatabases);
+ *
+ * if (modifyConfiguration) {
+ *   // Select databases
+ *   const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+ *     availableDatabases,
+ *     configuredDatabases,
+ *     { showSelectAll: true, allowNewOnly: !syncExisting }
+ *   );
+ *
+ *   // For each database, select tables
+ *   const tableSelectionsMap = new Map<string, string[]>();
+ *   const availableTablesMap = new Map<string, any[]>();
+ *
+ *   for (const databaseId of selectedDatabaseIds) {
+ *     const database = availableDatabases.find(db => db.$id === databaseId)!;
+ *     const availableTables = await getTablesForDatabase(databaseId);
+ *     const configuredTables = getConfiguredTablesForDatabase(databaseId);
+ *
+ *     availableTablesMap.set(databaseId, availableTables);
+ *
+ *     const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+ *       databaseId,
+ *       database.name,
+ *       availableTables,
+ *       configuredTables,
+ *       { showSelectAll: true, allowNewOnly: !syncExisting }
+ *     );
+ *
+ *     tableSelectionsMap.set(databaseId, selectedTableIds);
+ *   }
+ *
+ *   // Select buckets
+ *   const availableBuckets = await getAvailableBuckets();
+ *   const configuredBuckets = config.buckets || [];
+ *   const selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+ *     selectedDatabaseIds,
+ *     availableBuckets,
+ *     configuredBuckets,
+ *     { showSelectAll: true, groupByDatabase: true }
+ *   );
+ *
+ *   // Create selection objects
+ *   const databaseSelections = SelectionDialogs.createDatabaseSelection(
+ *     selectedDatabaseIds,
+ *     availableDatabases,
+ *     tableSelectionsMap,
+ *     configuredDatabases,
+ *     availableTablesMap
+ *   );
+ *
+ *   const bucketSelections = SelectionDialogs.createBucketSelection(
+ *     selectedBucketIds,
+ *     availableBuckets,
+ *     configuredBuckets,
+ *     availableDatabases
+ *   );
+ *
+ *   // Show final confirmation
+ *   const selectionSummary = SelectionDialogs.createSyncSelectionSummary(
+ *     databaseSelections,
+ *     bucketSelections
+ *   );
+ *
+ *   const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+ *
+ *   if (confirmed) {
+ *     // Proceed with sync operation
+ *     await performSync(databaseSelections, bucketSelections);
+ *   }
+ * }
+ * ```
+ */
+export class SelectionDialogs {
+    /**
+     * Prompts user about existing configuration
+     */
+    static async promptForExistingConfig(configuredItems) {
+        if (configuredItems.length === 0) {
+            return { syncExisting: false, modifyConfiguration: true };
+        }
+        MessageFormatter.section("Existing Configuration Found");
+        MessageFormatter.info(`Found ${configuredItems.length} configured items.`, { skipLogging: true });
+        const { syncExisting } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'syncExisting',
+                message: 'Sync existing configured items?',
+                default: true
+            }]);
+        if (!syncExisting) {
+            return { syncExisting: false, modifyConfiguration: true };
+        }
+        const { modifyConfiguration } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'modifyConfiguration',
+                message: 'Add/remove items from configuration?',
+                default: false
+            }]);
+        return { syncExisting, modifyConfiguration };
+    }
+    /**
+     * Shows database selection dialog with indicators for configured vs new databases
+     */
+    static async selectDatabases(availableDatabases, configuredDatabases, options = {}) {
+        const { showSelectAll = true, allowNewOnly = false, defaultSelected = [] } = options;
+        MessageFormatter.section("Database Selection");
+        const configuredIds = new Set(configuredDatabases.map(db => db.$id || db.id));
+        let choices = [];
+        if (showSelectAll && availableDatabases.length > 1) {
+            choices.push({
+                name: chalk.green.bold('📋 Select All Databases'),
+                value: '__SELECT_ALL__',
+                short: 'All databases'
+            });
+        }
+        availableDatabases.forEach(database => {
+            const isConfigured = configuredIds.has(database.$id);
+            const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+            const name = `${status} ${database.name} (${database.$id})`;
+            if (allowNewOnly && isConfigured) {
+                return; // Skip configured databases if only allowing new ones
+            }
+            choices.push({
+                name,
+                value: database.$id,
+                short: database.name,
+                // Do not preselect anything unless explicitly provided
+                checked: defaultSelected.includes(database.$id)
+            });
+        });
+        if (choices.length === 0) {
+            MessageFormatter.warning("No databases available for selection.", { skipLogging: true });
+            return [];
+        }
+        const { selectedDatabaseIds } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedDatabaseIds',
+                message: 'Select databases to sync:',
+                choices,
+                validate: (input) => {
+                    if (input.length === 0) {
+                        return chalk.red('Please select at least one database.');
+                    }
+                    if (input.includes('__SELECT_ALL__') && input.length > 1) {
+                        return chalk.red('Cannot select "Select All" with individual databases.');
+                    }
+                    return true;
+                }
+            }]);
+        // Handle select all
+        if (selectedDatabaseIds.includes('__SELECT_ALL__')) {
+            const allIds = availableDatabases.map(db => db.$id);
+            if (allowNewOnly) {
+                return allIds.filter(id => !configuredIds.has(id));
+            }
+            return allIds;
+        }
+        return selectedDatabaseIds;
+    }
+    /**
+     * Shows table/collection selection dialog for a specific database
+     */
+    static async selectTablesForDatabase(databaseId, databaseName, availableTables, configuredTables, options = {}) {
+        const { showSelectAll = true, allowNewOnly = false, defaultSelected = [], showDatabaseContext = true } = options;
+        if (showDatabaseContext) {
+            MessageFormatter.section(`Table Selection for ${databaseName}`);
+        }
+        const configuredIds = new Set(configuredTables.map(table => table.$id || table.id));
+        let choices = [];
+        if (showSelectAll && availableTables.length > 1) {
+            choices.push({
+                name: chalk.green.bold('📋 Select All Tables'),
+                value: '__SELECT_ALL__',
+                short: 'All tables'
+            });
+        }
+        availableTables.forEach(table => {
+            const isConfigured = configuredIds.has(table.$id);
+            const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+            const name = `${status} ${table.name} (${table.$id})`;
+            if (allowNewOnly && isConfigured) {
+                return; // Skip configured tables if only allowing new ones
+            }
+            choices.push({
+                name,
+                value: table.$id,
+                short: table.name,
+                // Do not preselect anything unless explicitly provided
+                checked: defaultSelected.includes(table.$id)
+            });
+        });
+        if (choices.length === 0) {
+            MessageFormatter.warning(`No tables available for database: ${databaseName}`, { skipLogging: true });
+            return [];
+        }
+        const { selectedTableIds } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedTableIds',
+                message: `Select tables to sync for ${databaseName}:`,
+                choices,
+                validate: (input) => {
+                    if (input.length === 0) {
+                        return chalk.red('Please select at least one table.');
+                    }
+                    if (input.includes('__SELECT_ALL__') && input.length > 1) {
+                        return chalk.red('Cannot select "Select All" with individual tables.');
+                    }
+                    return true;
+                }
+            }]);
+        // Handle select all
+        if (selectedTableIds.includes('__SELECT_ALL__')) {
+            const allIds = availableTables.map(table => table.$id);
+            if (allowNewOnly) {
+                return allIds.filter(id => !configuredIds.has(id));
+            }
+            return allIds;
+        }
+        return selectedTableIds;
+    }
+    /**
+     * Shows bucket selection dialog for selected databases
+     */
+    static async selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, options = {}) {
+        const { showSelectAll = true, allowNewOnly = false, defaultSelected = [], groupByDatabase = true } = options;
+        MessageFormatter.section("Storage Bucket Selection");
+        const configuredIds = new Set(configuredBuckets.map(bucket => bucket.$id || bucket.id));
+        // Filter buckets that are associated with selected databases
+        const relevantBuckets = availableBuckets.filter(bucket => {
+            if (selectedDatabaseIds.length === 0)
+                return true; // If no databases selected, show all buckets
+            return selectedDatabaseIds.includes(bucket.databaseId) || !bucket.databaseId;
+        });
+        if (relevantBuckets.length === 0) {
+            MessageFormatter.warning("No storage buckets available for selected databases.", { skipLogging: true });
+            return [];
+        }
+        let choices = [];
+        if (showSelectAll && relevantBuckets.length > 1) {
+            choices.push({
+                name: chalk.green.bold('📋 Select All Buckets'),
+                value: '__SELECT_ALL__',
+                short: 'All buckets'
+            });
+        }
+        if (groupByDatabase) {
+            // Group buckets by database
+            const bucketsByDatabase = new Map();
+            relevantBuckets.forEach(bucket => {
+                const dbId = bucket.databaseId || 'ungrouped';
+                if (!bucketsByDatabase.has(dbId)) {
+                    bucketsByDatabase.set(dbId, []);
+                }
+                bucketsByDatabase.get(dbId).push(bucket);
+            });
+            // Add buckets grouped by database
+            selectedDatabaseIds.forEach(dbId => {
+                const buckets = bucketsByDatabase.get(dbId) || [];
+                if (buckets.length > 0) {
+                    choices.push(new inquirer.Separator(chalk.cyan(`📁 Database: ${dbId}`)));
+                    buckets.forEach(bucket => {
+                        const isConfigured = configuredIds.has(bucket.$id);
+                        const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+                        const name = `${status} ${bucket.name} (${bucket.$id})`;
+                        if (allowNewOnly && isConfigured) {
+                            return; // Skip configured buckets if only allowing new ones
+                        }
+                        choices.push({
+                            name: `  ${name}`,
+                            value: bucket.$id,
+                            short: bucket.name,
+                            // Do not preselect anything unless explicitly provided
+                            checked: defaultSelected.includes(bucket.$id)
+                        });
+                    });
+                }
+            });
+            // Add ungrouped buckets
+            const ungroupedBuckets = bucketsByDatabase.get('ungrouped') || [];
+            if (ungroupedBuckets.length > 0) {
+                choices.push(new inquirer.Separator(chalk.cyan('📁 General Storage')));
+                ungroupedBuckets.forEach(bucket => {
+                    const isConfigured = configuredIds.has(bucket.$id);
+                    const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+                    const name = `${status} ${bucket.name} (${bucket.$id})`;
+                    if (allowNewOnly && isConfigured) {
+                        return; // Skip configured buckets if only allowing new ones
+                    }
+                    choices.push({
+                        name: `  ${name}`,
+                        value: bucket.$id,
+                        short: bucket.name,
+                        checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
+                    });
+                });
+            }
+        }
+        else {
+            // Flat list of buckets
+            relevantBuckets.forEach(bucket => {
+                const isConfigured = configuredIds.has(bucket.$id);
+                const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
+                const dbContext = bucket.databaseId ? ` [${bucket.databaseId}]` : '';
+                const name = `${status} ${bucket.name} (${bucket.$id})${dbContext}`;
+                if (allowNewOnly && isConfigured) {
+                    return; // Skip configured buckets if only allowing new ones
+                }
+                choices.push({
+                    name,
+                    value: bucket.$id,
+                    short: bucket.name,
+                    // Do not preselect anything unless explicitly provided
+                    checked: defaultSelected.includes(bucket.$id)
+                });
+            });
+        }
+        const { selectedBucketIds } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedBucketIds',
+                message: 'Select storage buckets to sync:',
+                choices,
+                validate: (input) => {
+                    if (input.length === 0) {
+                        return chalk.yellow('No storage buckets selected. Continue with databases only?') || true;
+                    }
+                    if (input.includes('__SELECT_ALL__') && input.length > 1) {
+                        return chalk.red('Cannot select "Select All" with individual buckets.');
+                    }
+                    return true;
+                }
+            }]);
+        // Handle select all
+        if (selectedBucketIds && selectedBucketIds.includes('__SELECT_ALL__')) {
+            const allIds = relevantBuckets.map(bucket => bucket.$id);
+            if (allowNewOnly) {
+                return allIds.filter(id => !configuredIds.has(id));
+            }
+            return allIds;
+        }
+        return selectedBucketIds || [];
+    }
+    /**
+     * Shows final confirmation dialog with sync selection summary
+     */
+    static async confirmSyncSelection(selectionSummary, operationType = 'sync') {
+        const labels = {
+            push: {
+                banner: "Push Selection Summary",
+                subtitle: "Review selections before pushing to Appwrite",
+                confirm: "Proceed with push operation?",
+                success: "Push operation confirmed.",
+                cancel: "Push operation cancelled."
+            },
+            pull: {
+                banner: "Pull Selection Summary",
+                subtitle: "Review selections before pulling from Appwrite",
+                confirm: "Proceed with pull operation?",
+                success: "Pull operation confirmed.",
+                cancel: "Pull operation cancelled."
+            },
+            sync: {
+                banner: "Sync Selection Summary",
+                subtitle: "Review your selections before proceeding",
+                confirm: "Proceed with sync operation?",
+                success: "Sync operation confirmed.",
+                cancel: "Sync operation cancelled."
+            }
+        };
+        const label = labels[operationType];
+        MessageFormatter.banner(label.banner, label.subtitle);
+        // Database summary
+        console.log(chalk.bold.cyan("\n📊 Databases:"));
+        console.log(`  Total: ${selectionSummary.totalDatabases}`);
+        console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.databases}`);
+        console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.databases}`);
+        if (selectionSummary.databases.length > 0) {
+            console.log(chalk.gray("\n  Selected databases:"));
+            selectionSummary.databases.forEach(db => {
+                const status = db.isNew ? chalk.blue('○') : chalk.green('✅');
+                console.log(`    ${status} ${db.databaseName} (${db.tableNames.length} tables)`);
+            });
+        }
+        // Table summary
+        console.log(chalk.bold.cyan("\n📋 Tables/Collections:"));
+        console.log(`  Total: ${selectionSummary.totalTables}`);
+        console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.tables}`);
+        console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.tables}`);
+        // Bucket summary
+        console.log(chalk.bold.cyan("\n🪣 Storage Buckets:"));
+        console.log(`  Total: ${selectionSummary.totalBuckets}`);
+        console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.buckets}`);
+        console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.buckets}`);
+        if (selectionSummary.buckets.length > 0) {
+            console.log(chalk.gray("\n  Selected buckets:"));
+            selectionSummary.buckets.forEach(bucket => {
+                const status = bucket.isNew ? chalk.blue('○') : chalk.green('✅');
+                const dbContext = bucket.databaseName ? ` [${bucket.databaseName}]` : '';
+                console.log(`    ${status} ${bucket.bucketName}${dbContext}`);
+            });
+        }
+        console.log(); // Add spacing
+        const { confirmed } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'confirmed',
+                message: chalk.green.bold(label.confirm),
+                default: true
+            }]);
+        if (confirmed) {
+            MessageFormatter.success(label.success, { skipLogging: true });
+            logger.info(`${operationType} selection confirmed`, {
+                databases: selectionSummary.totalDatabases,
+                tables: selectionSummary.totalTables,
+                buckets: selectionSummary.totalBuckets
+            });
+        }
+        else {
+            MessageFormatter.warning(label.cancel, { skipLogging: true });
+            logger.info(`${operationType} selection cancelled by user`);
+        }
+        return confirmed;
+    }
+    /**
+     * Creates a sync selection summary from selected items
+     */
+    static createSyncSelectionSummary(databaseSelections, bucketSelections) {
+        const totalDatabases = databaseSelections.length;
+        const totalTables = databaseSelections.reduce((sum, db) => sum + db.tableIds.length, 0);
+        const totalBuckets = bucketSelections.length;
+        const newDatabases = databaseSelections.filter(db => db.isNew).length;
+        const newTables = databaseSelections.reduce((sum, db) => sum + db.tableIds.length, 0); // TODO: Track which tables are new
+        const newBuckets = bucketSelections.filter(bucket => bucket.isNew).length;
+        const existingDatabases = totalDatabases - newDatabases;
+        const existingTables = totalTables - newTables;
+        const existingBuckets = totalBuckets - newBuckets;
+        return {
+            databases: databaseSelections,
+            buckets: bucketSelections,
+            totalDatabases,
+            totalTables,
+            totalBuckets,
+            newItems: {
+                databases: newDatabases,
+                tables: newTables,
+                buckets: newBuckets
+            },
+            existingItems: {
+                databases: existingDatabases,
+                tables: existingTables,
+                buckets: existingBuckets
+            }
+        };
+    }
+    /**
+     * Helper method to create database selection objects
+     */
+    static createDatabaseSelection(selectedDatabaseIds, availableDatabases, tableSelectionsMap, configuredDatabases, availableTablesMap = new Map()) {
+        const configuredIds = new Set(configuredDatabases.map(db => db.$id || db.id));
+        return selectedDatabaseIds.map(databaseId => {
+            const database = availableDatabases.find(db => db.$id === databaseId);
+            if (!database) {
+                throw new Error(`Database with ID ${databaseId} not found in available databases`);
+            }
+            const tableIds = tableSelectionsMap.get(databaseId) || [];
+            const tables = availableTablesMap.get(databaseId) || [];
+            const tableNames = tables.map(table => table.name || table.$id || `Table-${table.$id}`);
+            return {
+                databaseId,
+                databaseName: database.name,
+                tableIds,
+                tableNames,
+                isNew: !configuredIds.has(databaseId)
+            };
+        });
+    }
+    /**
+     * Helper method to create bucket selection objects
+     */
+    static createBucketSelection(selectedBucketIds, availableBuckets, configuredBuckets, availableDatabases) {
+        const configuredIds = new Set(configuredBuckets.map(bucket => bucket.$id || bucket.id));
+        return selectedBucketIds.map(bucketId => {
+            const bucket = availableBuckets.find(b => b.$id === bucketId);
+            if (!bucket) {
+                throw new Error(`Bucket with ID ${bucketId} not found in available buckets`);
+            }
+            const database = bucket.databaseId ?
+                availableDatabases.find(db => db.$id === bucket.databaseId) : undefined;
+            return {
+                bucketId,
+                bucketName: bucket.name,
+                databaseId: bucket.databaseId,
+                databaseName: database?.name,
+                isNew: !configuredIds.has(bucketId)
+            };
+        });
+    }
+    /**
+     * Shows a progress message during selection operations
+     */
+    static showProgress(message) {
+        MessageFormatter.progress(message, { skipLogging: true });
+    }
+    /**
+     * Shows an error message and handles graceful cancellation
+     */
+    static showError(message, error) {
+        MessageFormatter.error(message, error, { skipLogging: true });
+        logger.error(`Selection dialog error: ${message}`, { error: error?.message });
+    }
+    /**
+     * Shows a warning message
+     */
+    static showWarning(message) {
+        MessageFormatter.warning(message, { skipLogging: true });
+        logger.warn(`Selection dialog warning: ${message}`);
+    }
+    /**
+     * Shows a success message
+     */
+    static showSuccess(message) {
+        MessageFormatter.success(message, { skipLogging: true });
+        logger.info(`Selection dialog success: ${message}`);
+    }
+}

package/dist/storage/backupCompression.d.ts

@@ -0,0 +1,20 @@
+import type { BackupCreate } from "./schemas.js";
+export interface BackupCompressionOptions {
+    includeFiles?: boolean;
+    compressionLevel?: number;
+}
+/**
+ * Creates a compressed ZIP backup from backup data
+ *
+ * Structure:
+ * - metadata.json (backup metadata)
+ * - database.json (database config)
+ * - collections/*.json (one file per collection)
+ * - documents/*.json (one file per collection's documents)
+ * - files/ (optional, if includeFiles is true)
+ */
+export declare function createBackupZip(backupData: BackupCreate, options?: BackupCompressionOptions): Promise<Buffer>;
+/**
+ * Estimates compression ratio for backup data
+ */
+export declare function estimateCompressedSize(uncompressedSize: number, format?: string): number;

package/dist/storage/backupCompression.js

@@ -0,0 +1,67 @@
+import JSZip from "jszip";
+/**
+ * Creates a compressed ZIP backup from backup data
+ *
+ * Structure:
+ * - metadata.json (backup metadata)
+ * - database.json (database config)
+ * - collections/*.json (one file per collection)
+ * - documents/*.json (one file per collection's documents)
+ * - files/ (optional, if includeFiles is true)
+ */
+export async function createBackupZip(backupData, options = {}) {
+    const zip = new JSZip();
+    const compressionLevel = options.compressionLevel ?? 6;
+    // Add metadata.json
+    const metadata = {
+        version: "1.0",
+        createdAt: new Date().toISOString(),
+        databaseId: JSON.parse(backupData.database).$id,
+        format: "zip",
+        includesFiles: options.includeFiles ?? false
+    };
+    zip.file("metadata.json", JSON.stringify(metadata, null, 2));
+    // Add database.json
+    zip.file("database.json", backupData.database);
+    // Add collections/*.json
+    const collectionsFolder = zip.folder("collections");
+    if (collectionsFolder) {
+        backupData.collections.forEach((collectionStr, index) => {
+            const collection = JSON.parse(collectionStr);
+            collectionsFolder.file(`${collection.$id || `collection_${index}`}.json`, collectionStr);
+        });
+    }
+    // Add documents/*.json
+    const documentsFolder = zip.folder("documents");
+    if (documentsFolder) {
+        backupData.documents.forEach((docBatch) => {
+            const collectionId = docBatch.collectionId;
+            documentsFolder.file(`${collectionId}.json`, docBatch.data);
+        });
+    }
+    // TODO: Add files support in future task (C3.5)
+    if (options.includeFiles) {
+        // Placeholder for file backup support
+        const filesFolder = zip.folder("files");
+        if (filesFolder) {
+            filesFolder.file("file-manifest.json", JSON.stringify({
+                note: "File backup not yet implemented"
+            }, null, 2));
+        }
+    }
+    // Generate ZIP buffer
+    const buffer = await zip.generateAsync({
+        type: "nodebuffer",
+        compression: "DEFLATE",
+        compressionOptions: { level: compressionLevel }
+    });
+    return buffer;
+}
+/**
+ * Estimates compression ratio for backup data
+ */
+export function estimateCompressedSize(uncompressedSize, format = "json") {
+    // JSON typically compresses to 20-30% of original size with gzip
+    const compressionRatio = format === "json" ? 0.25 : 0.5;
+    return Math.ceil(uncompressedSize * compressionRatio);
+}

package/dist/storage/methods.d.ts

@@ -0,0 +1,32 @@
+import { Databases, Storage, type Models } from "node-appwrite";
+import { type AppwriteConfig } from "@njdamstra/appwrite-utils";
+export declare const getStorage: (config: AppwriteConfig) => Storage;
+export declare const listBuckets: (storage: Storage, queries?: string[], search?: string) => Promise<Models.BucketList>;
+export declare const getBucket: (storage: Storage, bucketId: string) => Promise<Models.Bucket>;
+export declare const createBucket: (storage: Storage, bucket: Omit<Models.Bucket, "$id" | "$createdAt" | "$updatedAt">, bucketId?: string) => Promise<Models.Bucket>;
+export declare const updateBucket: (storage: Storage, bucket: Models.Bucket, bucketId: string) => Promise<Models.Bucket>;
+export declare const deleteBucket: (storage: Storage, bucketId: string) => Promise<{}>;
+export declare const getFile: (storage: Storage, bucketId: string, fileId: string) => Promise<Models.File>;
+export declare const listFiles: (storage: Storage, bucketId: string, queries?: string[], search?: string) => Promise<Models.FileList>;
+export declare const deleteFile: (storage: Storage, bucketId: string, fileId: string) => Promise<{}>;
+export declare const ensureDatabaseConfigBucketsExist: (storage: Storage, config: AppwriteConfig, databases?: Models.Database[]) => Promise<void>;
+export declare const wipeDocumentStorage: (storage: Storage, bucketId: string, options?: {
+    skipConfirmation?: boolean;
+}) => Promise<void>;
+export declare const initOrGetDocumentStorage: (storage: Storage, config: AppwriteConfig, dbId: string, bucketName?: string) => Promise<Models.Bucket>;
+/**
+ * Initializes or gets the centralized backup bucket
+ * All backups are stored in a single "appwrite-backups" bucket
+ */
+export declare const initBackupBucket: (storage: Storage) => Promise<Models.Bucket | undefined>;
+export interface DatabaseBackupResult {
+    backupFileId: string;
+    backupFileName: string;
+    backupSizeBytes: number;
+    databaseId: string;
+    databaseName: string;
+    collectionCount: number;
+    documentCount: number;
+    format: 'json' | 'zip';
+}
+export declare const backupDatabase: (config: AppwriteConfig, database: Databases, databaseId: string, storage: Storage, format?: "json" | "zip") => Promise<DatabaseBackupResult>;