appwrite-utils-cli 1.2.2 → 1.2.4

package/dist/migrations/appwriteToX.d.ts

@@ -114,6 +114,7 @@ export declare class AppwriteToX {
     })[]>;
     appwriteFolderPath: string;
     constructor(config: AppwriteConfig, appwriteFolderPath: string, storage: Storage);
+    private ensureClientInitialized;
     parsePermissionString: (permissionString: string) => {
         permission: string;
         target: string;

package/dist/migrations/appwriteToX.js

@@ -18,6 +18,17 @@ export class AppwriteToX {
         this.updatedConfig = config;
         this.storage = storage;
         this.appwriteFolderPath = appwriteFolderPath;
+        this.ensureClientInitialized();
+    }
+    ensureClientInitialized() {
+        if (!this.config.appwriteClient) {
+            const client = new Client();
+            client
+                .setEndpoint(this.config.appwriteEndpoint)
+                .setProject(this.config.appwriteProject)
+                .setKey(this.config.appwriteKey);
+            this.config.appwriteClient = client;
+        }
     }
     // Function to parse a single permission string
     parsePermissionString = (permissionString) => {

package/dist/migrations/comprehensiveTransfer.d.ts

@@ -53,6 +53,7 @@ export declare class ComprehensiveTransfer {
     private results;
     private startTime;
     private tempDir;
+    private cachedMaxFileSize?;
     constructor(options: ComprehensiveTransferOptions);
     execute(): Promise<TransferResults>;
     private transferAllUsers;
@@ -66,6 +67,7 @@ export declare class ComprehensiveTransfer {
      */
     private transferDatabaseDocuments;
     private transferAllBuckets;
+    private createBucketWithFallback;
     private transferBucketFiles;
     private validateAndDownloadFile;
     private transferAllFunctions;

package/dist/migrations/comprehensiveTransfer.js

@@ -29,6 +29,7 @@ export class ComprehensiveTransfer {
     results;
     startTime;
     tempDir;
+    cachedMaxFileSize; // Cache successful maximumFileSize for subsequent buckets
     constructor(options) {
         this.options = options;
         this.sourceClient = getClient(options.sourceEndpoint, options.sourceProject, options.sourceKey);
@@ -289,8 +290,8 @@ export class ComprehensiveTransfer {
                     // Check if bucket exists in target
                     const existingBucket = allTargetBuckets.find(tb => tb.$id === bucket.$id);
                     if (!existingBucket) {
-                        // Create bucket in target
-                        await this.targetStorage.createBucket(bucket.$id, bucket.name, bucket.$permissions, bucket.fileSecurity, bucket.enabled, bucket.maximumFileSize, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
+                        // Create bucket with fallback strategy for maximumFileSize
+                        await this.createBucketWithFallback(bucket);
                         MessageFormatter.success(`Created bucket: ${bucket.name}`, { prefix: "Transfer" });
                     }
                     // Transfer bucket files with enhanced validation
@@ -310,6 +311,95 @@ export class ComprehensiveTransfer {
             MessageFormatter.error("Bucket transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
         }
     }
+    async createBucketWithFallback(bucket) {
+        // Determine the optimal size to try first
+        let sizeToTry;
+        if (this.cachedMaxFileSize) {
+            // Use cached size if it's smaller than or equal to the bucket's original size
+            if (bucket.maximumFileSize >= this.cachedMaxFileSize) {
+                sizeToTry = this.cachedMaxFileSize;
+                MessageFormatter.info(`Bucket ${bucket.name}: Using cached maximumFileSize ${sizeToTry} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+            }
+            else {
+                // Original size is smaller than cached size, try original first
+                sizeToTry = bucket.maximumFileSize;
+            }
+        }
+        else {
+            // No cached size yet, try original size first
+            sizeToTry = bucket.maximumFileSize;
+        }
+        // Try the optimal size first
+        try {
+            await this.targetStorage.createBucket(bucket.$id, bucket.name, bucket.$permissions, bucket.fileSecurity, bucket.enabled, sizeToTry, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
+            // Success - cache this size if it's not already cached or is smaller than cached
+            if (!this.cachedMaxFileSize || sizeToTry < this.cachedMaxFileSize) {
+                this.cachedMaxFileSize = sizeToTry;
+                MessageFormatter.info(`Bucket ${bucket.name}: Cached successful maximumFileSize ${sizeToTry} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+            }
+            // Log if we used a different size than original
+            if (sizeToTry !== bucket.maximumFileSize) {
+                MessageFormatter.warning(`Bucket ${bucket.name}: maximumFileSize used ${sizeToTry} instead of original ${bucket.maximumFileSize} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+            }
+            return; // Success, exit the function
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            // Check if the error is related to maximumFileSize validation
+            if (err.message.includes('maximumFileSize') || err.message.includes('valid range')) {
+                MessageFormatter.warning(`Bucket ${bucket.name}: Failed with maximumFileSize ${sizeToTry}, falling back to smaller sizes...`, { prefix: "Transfer" });
+                // Continue to fallback logic below
+            }
+            else {
+                // Different error, don't retry
+                throw err;
+            }
+        }
+        // Fallback to progressively smaller sizes
+        const fallbackSizes = [
+            5_000_000_000, // 5GB
+            2_500_000_000, // 2.5GB
+            2_000_000_000, // 2GB
+            1_000_000_000, // 1GB
+            500_000_000, // 500MB
+            100_000_000 // 100MB
+        ];
+        // Remove sizes that are larger than or equal to the already-tried size
+        const validSizes = fallbackSizes
+            .filter(size => size < sizeToTry)
+            .sort((a, b) => b - a); // Sort descending
+        let lastError = null;
+        for (const fileSize of validSizes) {
+            try {
+                await this.targetStorage.createBucket(bucket.$id, bucket.name, bucket.$permissions, bucket.fileSecurity, bucket.enabled, fileSize, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
+                // Success - cache this size if it's not already cached or is smaller than cached
+                if (!this.cachedMaxFileSize || fileSize < this.cachedMaxFileSize) {
+                    this.cachedMaxFileSize = fileSize;
+                    MessageFormatter.info(`Bucket ${bucket.name}: Cached successful maximumFileSize ${fileSize} (${(fileSize / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+                }
+                // Log if we had to reduce the file size
+                if (fileSize !== bucket.maximumFileSize) {
+                    MessageFormatter.warning(`Bucket ${bucket.name}: maximumFileSize reduced from ${bucket.maximumFileSize} to ${fileSize} (${(fileSize / 1_000_000_000).toFixed(1)}GB)`, { prefix: "Transfer" });
+                }
+                return; // Success, exit the function
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                // Check if the error is related to maximumFileSize validation
+                if (lastError.message.includes('maximumFileSize') || lastError.message.includes('valid range')) {
+                    MessageFormatter.warning(`Bucket ${bucket.name}: Failed with maximumFileSize ${fileSize}, trying smaller size...`, { prefix: "Transfer" });
+                    continue; // Try next smaller size
+                }
+                else {
+                    // Different error, don't retry
+                    throw lastError;
+                }
+            }
+        }
+        // If we get here, all fallback sizes failed
+        MessageFormatter.error(`Bucket ${bucket.name}: All fallback file sizes failed. Last error: ${lastError?.message}`, lastError || undefined, { prefix: "Transfer" });
+        throw lastError || new Error('All fallback file sizes failed');
+    }
     async transferBucketFiles(sourceBucketId, targetBucketId) {
         let lastFileId;
         let transferredFiles = 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/migrations/appwriteToX.ts

@@ -45,6 +45,18 @@ export class AppwriteToX {
     this.updatedConfig = config;
     this.storage = storage;
     this.appwriteFolderPath = appwriteFolderPath;
+    this.ensureClientInitialized();
+  }
+
+  private ensureClientInitialized() {
+    if (!this.config.appwriteClient) {
+      const client = new Client();
+      client
+        .setEndpoint(this.config.appwriteEndpoint)
+        .setProject(this.config.appwriteProject)
+        .setKey(this.config.appwriteKey);
+      this.config.appwriteClient = client;
+    }
   }
 
   // Function to parse a single permission string

package/src/migrations/comprehensiveTransfer.ts

@@ -68,6 +68,7 @@ export class ComprehensiveTransfer {
   private results: TransferResults;
   private startTime: number;
   private tempDir: string;
+  private cachedMaxFileSize?: number; // Cache successful maximumFileSize for subsequent buckets
 
   constructor(private options: ComprehensiveTransferOptions) {
     this.sourceClient = getClient(
@@ -429,19 +430,8 @@ export class ComprehensiveTransfer {
             const existingBucket = allTargetBuckets.find(tb => tb.$id === bucket.$id);
             
             if (!existingBucket) {
-              // Create bucket in target
-              await this.targetStorage.createBucket(
-                bucket.$id,
-                bucket.name,
-                bucket.$permissions,
-                bucket.fileSecurity,
-                bucket.enabled,
-                bucket.maximumFileSize,
-                bucket.allowedFileExtensions,
-                bucket.compression as any,
-                bucket.encryption,
-                bucket.antivirus
-              );
+              // Create bucket with fallback strategy for maximumFileSize
+              await this.createBucketWithFallback(bucket);
               MessageFormatter.success(`Created bucket: ${bucket.name}`, { prefix: "Transfer" });
             }
 
@@ -464,6 +454,152 @@ export class ComprehensiveTransfer {
     }
   }
 
+  private async createBucketWithFallback(bucket: Models.Bucket): Promise<void> {
+    // Determine the optimal size to try first
+    let sizeToTry: number;
+    
+    if (this.cachedMaxFileSize) {
+      // Use cached size if it's smaller than or equal to the bucket's original size
+      if (bucket.maximumFileSize >= this.cachedMaxFileSize) {
+        sizeToTry = this.cachedMaxFileSize;
+        MessageFormatter.info(
+          `Bucket ${bucket.name}: Using cached maximumFileSize ${sizeToTry} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`,
+          { prefix: "Transfer" }
+        );
+      } else {
+        // Original size is smaller than cached size, try original first
+        sizeToTry = bucket.maximumFileSize;
+      }
+    } else {
+      // No cached size yet, try original size first
+      sizeToTry = bucket.maximumFileSize;
+    }
+
+    // Try the optimal size first
+    try {
+      await this.targetStorage.createBucket(
+        bucket.$id,
+        bucket.name,
+        bucket.$permissions,
+        bucket.fileSecurity,
+        bucket.enabled,
+        sizeToTry,
+        bucket.allowedFileExtensions,
+        bucket.compression as any,
+        bucket.encryption,
+        bucket.antivirus
+      );
+      
+      // Success - cache this size if it's not already cached or is smaller than cached
+      if (!this.cachedMaxFileSize || sizeToTry < this.cachedMaxFileSize) {
+        this.cachedMaxFileSize = sizeToTry;
+        MessageFormatter.info(
+          `Bucket ${bucket.name}: Cached successful maximumFileSize ${sizeToTry} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`,
+          { prefix: "Transfer" }
+        );
+      }
+      
+      // Log if we used a different size than original
+      if (sizeToTry !== bucket.maximumFileSize) {
+        MessageFormatter.warning(
+          `Bucket ${bucket.name}: maximumFileSize used ${sizeToTry} instead of original ${bucket.maximumFileSize} (${(sizeToTry / 1_000_000_000).toFixed(1)}GB)`,
+          { prefix: "Transfer" }
+        );
+      }
+      
+      return; // Success, exit the function
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      
+      // Check if the error is related to maximumFileSize validation
+      if (err.message.includes('maximumFileSize') || err.message.includes('valid range')) {
+        MessageFormatter.warning(
+          `Bucket ${bucket.name}: Failed with maximumFileSize ${sizeToTry}, falling back to smaller sizes...`,
+          { prefix: "Transfer" }
+        );
+        // Continue to fallback logic below
+      } else {
+        // Different error, don't retry
+        throw err;
+      }
+    }
+
+    // Fallback to progressively smaller sizes
+    const fallbackSizes = [
+      5_000_000_000, // 5GB
+      2_500_000_000, // 2.5GB
+      2_000_000_000, // 2GB
+      1_000_000_000, // 1GB
+      500_000_000,   // 500MB
+      100_000_000    // 100MB
+    ];
+
+    // Remove sizes that are larger than or equal to the already-tried size
+    const validSizes = fallbackSizes
+      .filter(size => size < sizeToTry)
+      .sort((a, b) => b - a); // Sort descending
+
+    let lastError: Error | null = null;
+    
+    for (const fileSize of validSizes) {
+      try {
+        await this.targetStorage.createBucket(
+          bucket.$id,
+          bucket.name,
+          bucket.$permissions,
+          bucket.fileSecurity,
+          bucket.enabled,
+          fileSize,
+          bucket.allowedFileExtensions,
+          bucket.compression as any,
+          bucket.encryption,
+          bucket.antivirus
+        );
+        
+        // Success - cache this size if it's not already cached or is smaller than cached
+        if (!this.cachedMaxFileSize || fileSize < this.cachedMaxFileSize) {
+          this.cachedMaxFileSize = fileSize;
+          MessageFormatter.info(
+            `Bucket ${bucket.name}: Cached successful maximumFileSize ${fileSize} (${(fileSize / 1_000_000_000).toFixed(1)}GB)`,
+            { prefix: "Transfer" }
+          );
+        }
+        
+        // Log if we had to reduce the file size
+        if (fileSize !== bucket.maximumFileSize) {
+          MessageFormatter.warning(
+            `Bucket ${bucket.name}: maximumFileSize reduced from ${bucket.maximumFileSize} to ${fileSize} (${(fileSize / 1_000_000_000).toFixed(1)}GB)`,
+            { prefix: "Transfer" }
+          );
+        }
+        
+        return; // Success, exit the function
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        
+        // Check if the error is related to maximumFileSize validation
+        if (lastError.message.includes('maximumFileSize') || lastError.message.includes('valid range')) {
+          MessageFormatter.warning(
+            `Bucket ${bucket.name}: Failed with maximumFileSize ${fileSize}, trying smaller size...`,
+            { prefix: "Transfer" }
+          );
+          continue; // Try next smaller size
+        } else {
+          // Different error, don't retry
+          throw lastError;
+        }
+      }
+    }
+    
+    // If we get here, all fallback sizes failed
+    MessageFormatter.error(
+      `Bucket ${bucket.name}: All fallback file sizes failed. Last error: ${lastError?.message}`,
+      lastError || undefined,
+      { prefix: "Transfer" }
+    );
+    throw lastError || new Error('All fallback file sizes failed');
+  }
+
   private async transferBucketFiles(sourceBucketId: string, targetBucketId: string): Promise<void> {
     let lastFileId: string | undefined;
     let transferredFiles = 0;