appwrite-utils-cli 1.6.1 → 1.6.3

package/dist/cli/commands/databaseCommands.js

@@ -14,23 +14,31 @@ export const databaseCommands = {
             MessageFormatter.warning("No databases selected. Skipping database sync.", { prefix: "Database" });
             return;
         }
-        const collections = await cli.selectCollectionsAndTables(databases[0], cli.controller.database, chalk.blue("Select local collections/tables to push:"), true, // multiSelect
-        true // prefer local
-        // shouldFilterByDatabase removed - user will be prompted interactively
-        );
-        const { syncFunctions } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "syncFunctions",
-                message: "Do you want to push local functions to remote?",
-                default: false,
-            },
-        ]);
         try {
-            // First sync databases and collections
-            await cli.controller.syncDb(databases, collections);
-            MessageFormatter.success("Database and collections pushed successfully", { prefix: "Database" });
+            // Loop through each database and prompt for collections specific to that database
+            for (const database of databases) {
+                MessageFormatter.info(`\n📦 Configuring push for database: ${database.name}`, { prefix: "Database" });
+                const collections = await cli.selectCollectionsAndTables(database, cli.controller.database, chalk.blue(`Select collections/tables to push to "${database.name}":`), true, // multiSelect
+                true // prefer local
+                );
+                if (collections.length === 0) {
+                    MessageFormatter.warning(`No collections selected for database "${database.name}". Skipping.`, { prefix: "Database" });
+                    continue;
+                }
+                // Push selected collections to this specific database
+                await cli.controller.syncDb([database], collections);
+                MessageFormatter.success(`Pushed ${collections.length} collection(s) to database "${database.name}"`, { prefix: "Database" });
+            }
+            MessageFormatter.success("\n✅ All database configurations pushed successfully!", { prefix: "Database" });
             // Then handle functions if requested
+            const { syncFunctions } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "syncFunctions",
+                    message: "Do you want to push local functions to remote?",
+                    default: false,
+                },
+            ]);
             if (syncFunctions && cli.controller.config?.functions?.length) {
                 const functions = await cli.selectFunctions(chalk.blue("Select local functions to push:"), true, true // prefer local
                 );

package/dist/collections/attributes.d.ts

@@ -5,7 +5,7 @@ import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
  * Enhanced attribute creation with proper status monitoring and retry logic
  */
 export declare const createOrUpdateAttributeWithStatusCheck: (db: Databases | DatabaseAdapter, dbId: string, collection: Models.Collection, attribute: Attribute, retryCount?: number, maxRetries?: number) => Promise<boolean>;
-export declare const createOrUpdateAttribute: (db: Databases | DatabaseAdapter, dbId: string, collection: Models.Collection, attribute: Attribute) => Promise<"queued" | "processed">;
+export declare const createOrUpdateAttribute: (db: Databases | DatabaseAdapter, dbId: string, collection: Models.Collection, attribute: Attribute) => Promise<"queued" | "processed" | "error">;
 /**
  * Enhanced collection attribute creation with proper status monitoring
  */

package/dist/collections/attributes.js

@@ -6,8 +6,8 @@ import chalk from "chalk";
 import { logger } from "../shared/logging.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { isDatabaseAdapter } from "../utils/typeGuards.js";
-// Threshold for treating min/max values as undefined (10 billion)
-const MIN_MAX_THRESHOLD = 10_000_000_000;
+// Threshold for treating min/max values as undefined (1 trillion)
+const MIN_MAX_THRESHOLD = 1_000_000_000_000;
 // Extreme values that Appwrite may return, which should be treated as undefined
 const EXTREME_MIN_INTEGER = -9223372036854776000;
 const EXTREME_MAX_INTEGER = 9223372036854776000;
@@ -296,32 +296,32 @@ const updateLegacyAttribute = async (db, dbId, collectionId, attribute) => {
     const { min: normalizedMin, max: normalizedMax } = normalizeMinMaxValues(attribute);
     switch (attribute.type) {
         case "string":
-            await db.updateStringAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, attribute.size);
+            await db.updateStringAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null, attribute.size);
             break;
         case "integer":
-            await db.updateIntegerAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && !attribute.required ? attribute.xdefault : undefined, normalizedMin !== undefined ? parseInt(String(normalizedMin)) : undefined, normalizedMax !== undefined ? parseInt(String(normalizedMax)) : undefined);
+            await db.updateIntegerAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null, normalizedMin !== undefined ? parseInt(String(normalizedMin)) : undefined, normalizedMax !== undefined ? parseInt(String(normalizedMax)) : undefined);
             break;
         case "double":
         case "float":
-            await db.updateFloatAttribute(dbId, collectionId, attribute.key, attribute.required || false, normalizedMin !== undefined ? Number(normalizedMin) : undefined, normalizedMax !== undefined ? Number(normalizedMax) : undefined, attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            await db.updateFloatAttribute(dbId, collectionId, attribute.key, attribute.required || false, normalizedMin !== undefined ? Number(normalizedMin) : undefined, normalizedMax !== undefined ? Number(normalizedMax) : undefined, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
             break;
         case "boolean":
-            await db.updateBooleanAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            await db.updateBooleanAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
             break;
         case "datetime":
-            await db.updateDatetimeAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            await db.updateDatetimeAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
             break;
         case "email":
-            await db.updateEmailAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            await db.updateEmailAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
             break;
         case "ip":
-            await db.updateIpAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            await db.updateIpAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
             break;
         case "url":
-            await db.updateUrlAttribute(dbId, collectionId, attribute.key, attribute.required || false, attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            await db.updateUrlAttribute(dbId, collectionId, attribute.key, attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
             break;
         case "enum":
-            await db.updateEnumAttribute(dbId, collectionId, attribute.key, attribute.elements || [], attribute.required || false, attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined);
+            await db.updateEnumAttribute(dbId, collectionId, attribute.key, attribute.elements || [], attribute.required || false, !attribute.required && attribute.xdefault !== undefined ? attribute.xdefault : null);
             break;
         case "relationship":
             await db.updateRelationshipAttribute(dbId, collectionId, attribute.key, attribute.onDelete);
@@ -348,12 +348,8 @@ retryCount = 0, maxRetries = 5) => {
     // Calculate exponential backoff: 2s, 4s, 8s, 16s, 30s (capped at 30s)
     if (retryCount > 0) {
         const exponentialDelay = calculateExponentialBackoff(retryCount);
-        MessageFormatter.info(chalk.blue(`Waiting for attribute '${attributeKey}' to become available (retry ${retryCount}, backoff: ${exponentialDelay}ms)...`));
         await delay(exponentialDelay);
     }
-    else {
-        MessageFormatter.info(chalk.blue(`Waiting for attribute '${attributeKey}' to become available...`));
-    }
     while (Date.now() - startTime < maxWaitTime) {
         try {
             const collection = isDatabaseAdapter(db)
@@ -364,7 +360,6 @@ retryCount = 0, maxRetries = 5) => {
                 MessageFormatter.error(`Attribute '${attributeKey}' not found`);
                 return false;
             }
-            MessageFormatter.info(chalk.gray(`Attribute '${attributeKey}' status: ${attribute.status}`));
             const statusInfo = {
                 attributeKey,
                 status: attribute.status,
@@ -376,15 +371,12 @@ retryCount = 0, maxRetries = 5) => {
             };
             switch (attribute.status) {
                 case "available":
-                    MessageFormatter.info(chalk.green(`✅ Attribute '${attributeKey}' is now available`));
                     logger.info(`Attribute '${attributeKey}' became available`, statusInfo);
                     return true;
                 case "failed":
-                    MessageFormatter.info(chalk.red(`❌ Attribute '${attributeKey}' failed: ${attribute.error}`));
                     logger.error(`Attribute '${attributeKey}' failed`, statusInfo);
                     return false;
                 case "stuck":
-                    MessageFormatter.info(chalk.yellow(`⚠️ Attribute '${attributeKey}' is stuck, will retry...`));
                     logger.warn(`Attribute '${attributeKey}' is stuck`, statusInfo);
                     return false;
                 case "processing":
@@ -549,7 +541,6 @@ const attributesSame = (databaseAttribute, configAttribute) => {
  * Enhanced attribute creation with proper status monitoring and retry logic
  */
 export const createOrUpdateAttributeWithStatusCheck = async (db, dbId, collection, attribute, retryCount = 0, maxRetries = 5) => {
-    MessageFormatter.info(chalk.blue(`Creating/updating attribute '${attribute.key}' (attempt ${retryCount + 1}/${maxRetries + 1})`));
     try {
         // First, try to create/update the attribute using existing logic
         const result = await createOrUpdateAttribute(db, dbId, collection, attribute);
@@ -559,6 +550,11 @@ export const createOrUpdateAttributeWithStatusCheck = async (db, dbId, collectio
             MessageFormatter.info(chalk.yellow(`⏭️  Deferred relationship attribute '${attribute.key}' — queued for later once dependencies are available`));
             return true;
         }
+        // If collection creation failed, return false to indicate failure
+        if (result === "error") {
+            MessageFormatter.error(`Failed to create collection for attribute '${attribute.key}'`);
+            return false;
+        }
         // Now wait for the attribute to become available
         const success = await waitForAttributeAvailable(db, dbId, collection.$id, attribute.key, 60000, // 1 minute timeout
         retryCount, maxRetries);
@@ -724,6 +720,45 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         }
     }
     finalAttribute = parseAttribute(finalAttribute);
+    // Ensure collection/table exists - create it if it doesn't
+    try {
+        await (isDatabaseAdapter(db)
+            ? db.getTable({ databaseId: dbId, tableId: collection.$id })
+            : db.getCollection(dbId, collection.$id));
+    }
+    catch (error) {
+        // Collection doesn't exist - create it
+        if (error.code === 404 ||
+            (error instanceof Error && (error.message.includes('collection_not_found') ||
+                error.message.includes('Collection with the requested ID could not be found')))) {
+            MessageFormatter.info(`Collection '${collection.name}' doesn't exist, creating it first...`);
+            try {
+                if (isDatabaseAdapter(db)) {
+                    await db.createTable({
+                        databaseId: dbId,
+                        id: collection.$id,
+                        name: collection.name,
+                        permissions: collection.$permissions || [],
+                        documentSecurity: collection.documentSecurity ?? false,
+                        enabled: collection.enabled ?? true
+                    });
+                }
+                else {
+                    await db.createCollection(dbId, collection.$id, collection.name, collection.$permissions || [], collection.documentSecurity ?? false, collection.enabled ?? true);
+                }
+                MessageFormatter.success(`Created collection '${collection.name}'`);
+                await delay(500); // Wait for collection to be ready
+            }
+            catch (createError) {
+                MessageFormatter.error(`Failed to create collection '${collection.name}'`, createError instanceof Error ? createError : new Error(String(createError)));
+                return "error";
+            }
+        }
+        else {
+            // Other error - re-throw
+            throw error;
+        }
+    }
     // Use adapter-based attribute creation/update
     if (action === "create") {
         await tryAwaitWithRetry(async () => await createAttributeViaAdapter(db, dbId, collection.$id, finalAttribute));
@@ -737,7 +772,6 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
  * Enhanced collection attribute creation with proper status monitoring
  */
 export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId, collection, attributes) => {
-    MessageFormatter.info(chalk.green(`Creating/Updating attributes for collection: ${collection.name} with status monitoring`));
     const existingAttributes = 
     // @ts-expect-error
     collection.attributes.map((attr) => parseAttribute(attr)) || [];
@@ -775,7 +809,6 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
         }
     }
     // First, get fresh collection data and determine which attributes actually need processing
-    MessageFormatter.info(chalk.blue(`Analyzing ${attributes.length} attributes to determine which need processing...`));
     let currentCollection = collection;
     try {
         currentCollection = isDatabaseAdapter(db)
@@ -799,28 +832,25 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
     const attributesToProcess = attributes.filter((attribute) => {
         // Skip if already processed in this session
         if (isAttributeProcessed(currentCollection.$id, attribute.key)) {
-            MessageFormatter.info(chalk.gray(`⏭️ Attribute '${attribute.key}' already processed in this session (skipping)`));
             return false;
         }
         const existing = existingAttributesMap.get(attribute.key);
         if (!existing) {
-            MessageFormatter.info(`➕ New attribute: ${attribute.key}`);
+            MessageFormatter.info(`➕ ${attribute.key}`);
             return true;
         }
         const needsUpdate = !attributesSame(existing, attribute);
         if (needsUpdate) {
-            MessageFormatter.info(`🔄 Changed attribute: ${attribute.key}`);
+            MessageFormatter.info(`🔄 ${attribute.key}`);
         }
         else {
-            MessageFormatter.info(chalk.gray(`✅ Unchanged attribute: ${attribute.key} (skipping)`));
+            MessageFormatter.info(chalk.gray(`✅ ${attribute.key}`));
         }
         return needsUpdate;
     });
     if (attributesToProcess.length === 0) {
-        MessageFormatter.info(chalk.green(`✅ All ${attributes.length} attributes are already up to date for collection: ${collection.name}`));
         return true;
     }
-    MessageFormatter.info(chalk.blue(`Creating ${attributesToProcess.length} attributes sequentially with status monitoring...`));
     let remainingAttributes = [...attributesToProcess];
     let overallRetryCount = 0;
     const maxOverallRetries = 3;
@@ -828,12 +858,9 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
         overallRetryCount < maxOverallRetries) {
         const attributesToProcessThisRound = [...remainingAttributes];
         remainingAttributes = []; // Reset for next iteration
-        MessageFormatter.info(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${attributesToProcessThisRound.length} attributes ===`));
         for (const attribute of attributesToProcessThisRound) {
-            MessageFormatter.info(chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`));
             const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, currentCollection, attribute);
             if (success) {
-                MessageFormatter.info(chalk.green(`✅ Successfully created attribute: ${attribute.key}`));
                 // Mark this specific attribute as processed
                 markAttributeProcessed(currentCollection.$id, attribute.key);
                 // Get updated collection data for next iteration
@@ -849,27 +876,25 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
                 await delay(1000);
             }
             else {
-                MessageFormatter.info(chalk.red(`❌ Failed to create attribute: ${attribute.key}, will retry in next round`));
+                MessageFormatter.info(chalk.red(`❌ ${attribute.key}`));
                 remainingAttributes.push(attribute); // Add back to retry list
             }
         }
         if (remainingAttributes.length === 0) {
-            MessageFormatter.info(chalk.green(`\n✅ Successfully created all ${attributesToProcess.length} attributes for collection: ${collection.name}`));
             return true;
         }
         overallRetryCount++;
         if (overallRetryCount < maxOverallRetries) {
-            MessageFormatter.info(chalk.yellow(`\n⏳ Waiting 5 seconds before retrying ${attributesToProcess.length} failed attributes...`));
+            MessageFormatter.info(chalk.yellow(`⏳ Retrying ${remainingAttributes.length} failed attributes...`));
             await delay(5000);
             // Refresh collection data before retry
             try {
                 currentCollection = isDatabaseAdapter(db)
                     ? (await db.getTable({ databaseId: dbId, tableId: collection.$id })).data
                     : await db.getCollection(dbId, collection.$id);
-                MessageFormatter.info(`Refreshed collection data for retry`);
             }
             catch (error) {
-                MessageFormatter.info(chalk.yellow(`Warning: Could not refresh collection data for retry: ${error}`));
+                // Silently continue if refresh fails
             }
         }
     }

package/dist/collections/indexes.js

@@ -13,12 +13,8 @@ retryCount = 0, maxRetries = 5) => {
     // Calculate exponential backoff: 2s, 4s, 8s, 16s, 30s (capped at 30s)
     if (retryCount > 0) {
         const exponentialDelay = calculateExponentialBackoff(retryCount);
-        MessageFormatter.info(`Waiting for index '${indexKey}' to become available (retry ${retryCount}, backoff: ${exponentialDelay}ms)...`);
         await delay(exponentialDelay);
     }
-    else {
-        MessageFormatter.info(`Waiting for index '${indexKey}' to become available...`);
-    }
     while (Date.now() - startTime < maxWaitTime) {
         try {
             const indexList = await (isLegacyDatabases(db)
@@ -32,15 +28,8 @@ retryCount = 0, maxRetries = 5) => {
                 MessageFormatter.error(`Index '${indexKey}' not found in database '${dbId}' collection '${collectionId}'`);
                 return false;
             }
-            if (isLegacyDatabases(db)) {
-                MessageFormatter.debug(`Index '${indexKey}' status: ${index.status}`);
-            }
-            else {
-                MessageFormatter.debug(`Index '${indexKey}' detected (TablesDB)`);
-            }
             switch (index.status) {
                 case 'available':
-                    MessageFormatter.success(`Index '${indexKey}' is now available (type: ${index.type}, attributes: [${index.attributes.join(', ')}])`);
                     return true;
                 case 'failed':
                     MessageFormatter.error(`Index '${indexKey}' failed: ${index.error} (type: ${index.type}, attributes: [${index.attributes.join(', ')}])`);
@@ -139,27 +128,24 @@ export const createOrUpdateIndexesWithStatusCheck = async (dbId, db, collectionI
     while (indexesToProcess.length > 0 && overallRetryCount < maxOverallRetries) {
         const remainingIndexes = [...indexesToProcess];
         indexesToProcess = []; // Reset for next iteration
-        MessageFormatter.info(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingIndexes.length} indexes ===`);
         for (const index of remainingIndexes) {
-            MessageFormatter.info(`\n--- Processing index: ${index.key} (type: ${index.type}, attributes: [${index.attributes.join(', ')}]) ---`);
             const success = await createOrUpdateIndexWithStatusCheck(dbId, db, collectionId, collection, index);
             if (success) {
-                MessageFormatter.success(`Successfully created index: ${index.key} (type: ${index.type})`);
+                MessageFormatter.info(`✅ ${index.key} (${index.type})`);
                 // Add delay between successful indexes
                 await delay(1000);
             }
             else {
-                MessageFormatter.error(`Failed to create index: ${index.key} (type: ${index.type}), will retry in next round`);
+                MessageFormatter.info(`❌ ${index.key} (${index.type})`);
                 indexesToProcess.push(index); // Add back to retry list
             }
         }
         if (indexesToProcess.length === 0) {
-            MessageFormatter.success(`\nSuccessfully created all ${indexes.length} indexes for collection '${collectionId}'`);
             return true;
         }
         overallRetryCount++;
         if (overallRetryCount < maxOverallRetries) {
-            MessageFormatter.warning(`\nWaiting 5 seconds before retrying ${indexesToProcess.length} failed indexes...`);
+            MessageFormatter.warning(`⏳ Retrying ${indexesToProcess.length} failed indexes...`);
             await delay(5000);
         }
     }

package/dist/collections/methods.js

@@ -387,6 +387,44 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 relQueue.push({ tableId, attr: attr });
             }
         }
+        // Wait for all attributes to become available before creating indexes
+        const allAttrKeys = [
+            ...nonRel.map((a) => a.key),
+            ...rels.filter((a) => a.relatedCollection).map((a) => a.key)
+        ];
+        if (allAttrKeys.length > 0) {
+            for (const attrKey of allAttrKeys) {
+                const maxWait = 60000; // 60 seconds
+                const startTime = Date.now();
+                let lastStatus = '';
+                while (Date.now() - startTime < maxWait) {
+                    try {
+                        const tableData = await adapter.getTable({ databaseId, tableId });
+                        const attrs = tableData.attributes || [];
+                        const attr = attrs.find((a) => a.key === attrKey);
+                        if (attr) {
+                            if (attr.status === 'available') {
+                                break; // Attribute is ready
+                            }
+                            if (attr.status === 'failed' || attr.status === 'stuck') {
+                                throw new Error(`Attribute ${attrKey} failed to create: ${attr.error || 'unknown error'}`);
+                            }
+                            // Still processing, continue waiting
+                            lastStatus = attr.status;
+                        }
+                        await delay(2000); // Check every 2 seconds
+                    }
+                    catch (e) {
+                        // If we can't check status, assume it's processing and continue
+                        await delay(2000);
+                    }
+                }
+                // Timeout check
+                if (Date.now() - startTime >= maxWait) {
+                    MessageFormatter.warning(`Attribute ${attrKey} did not become available within ${maxWait / 1000}s (last status: ${lastStatus}). Proceeding anyway.`, { prefix: 'Attributes' });
+                }
+            }
+        }
         // Indexes
         const idxs = (indexes || []);
         for (const idx of idxs) {

package/dist/interactiveCLI.js

@@ -253,19 +253,13 @@ export class InteractiveCLI {
                 ...configCollections.filter((c) => !remoteCollections.some((rc) => rc.name === c.name)),
             ];
         if (shouldFilterByDatabase) {
-            // Enhanced filtering for tables with optional databaseId
+            // Show collections that EITHER exist in the remote database OR have matching local databaseId metadata
             allCollections = allCollections.filter((c) => {
-                // For remote collections, they should match the selected database
-                if (remoteCollections.some((rc) => rc.name === c.name)) {
-                    return c.databaseId === database.$id;
-                }
-                // For local collections/tables:
-                // - Collections without databaseId are kept (backward compatibility)
-                // - Tables with databaseId must match the selected database
-                // - Tables without databaseId are kept (fallback for misconfigured tables)
-                if (!c.databaseId)
-                    return true;
-                return c.databaseId === database.$id;
+                // Include if it exists remotely in this database
+                const existsInRemoteDb = remoteCollections.some((rc) => rc.name === c.name);
+                // Include if local metadata claims it belongs to this database
+                const hasMatchingLocalMetadata = c.databaseId === database.$id;
+                return existsInRemoteDb || hasMatchingLocalMetadata;
             });
         }
         // Filter out system tables (those starting with underscore)

package/dist/utils/yamlConverter.d.ts

@@ -14,6 +14,7 @@ export interface YamlCollectionData {
         size?: number;
         required?: boolean;
         array?: boolean;
+        encrypt?: boolean;
         default?: any;
         min?: number;
         max?: number;
@@ -31,6 +32,7 @@ export interface YamlCollectionData {
         size?: number;
         required?: boolean;
         array?: boolean;
+        encrypt?: boolean;
         default?: any;
         min?: number;
         max?: number;

package/dist/utils/yamlConverter.js

@@ -1,4 +1,6 @@
 import yaml from "js-yaml";
+// Threshold for treating min/max values as undefined (1 trillion)
+const MIN_MAX_THRESHOLD = 1_000_000_000_000;
 /**
  * Converts a Collection object to YAML format with proper schema reference
  * Supports both collection and table terminology based on configuration
@@ -37,12 +39,27 @@ export function collectionToYaml(collection, config = {
                 yamlAttr.required = attr.required;
             if (attr.array !== undefined)
                 yamlAttr.array = attr.array;
+            // Always include encrypt field for string attributes (default to false)
+            if (attr.type === 'string') {
+                yamlAttr.encrypt = ('encrypted' in attr && attr.encrypted === true) ? true : false;
+            }
             if ('xdefault' in attr && attr.xdefault !== undefined)
                 yamlAttr.default = attr.xdefault;
-            if ('min' in attr && attr.min !== undefined)
-                yamlAttr.min = attr.min;
-            if ('max' in attr && attr.max !== undefined)
-                yamlAttr.max = attr.max;
+            // Normalize min/max values - filter out extreme database values
+            if ('min' in attr && attr.min !== undefined) {
+                const minValue = Number(attr.min);
+                // Only include min if it's within reasonable range (< 1 trillion)
+                if (Math.abs(minValue) < MIN_MAX_THRESHOLD) {
+                    yamlAttr.min = attr.min;
+                }
+            }
+            if ('max' in attr && attr.max !== undefined) {
+                const maxValue = Number(attr.max);
+                // Only include max if it's within reasonable range (< 1 trillion)
+                if (Math.abs(maxValue) < MIN_MAX_THRESHOLD) {
+                    yamlAttr.max = attr.max;
+                }
+            }
             if ('elements' in attr && attr.elements !== undefined)
                 yamlAttr.elements = attr.elements;
             if ('relatedCollection' in attr && attr.relatedCollection !== undefined)

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.6.1",
+  "version": "1.6.3",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/cli/commands/databaseCommands.ts

@@ -23,30 +23,44 @@ export const databaseCommands = {
       return;
     }
 
-    const collections = await (cli as any).selectCollectionsAndTables(
-      databases[0],
-      (cli as any).controller!.database!,
-      chalk.blue("Select local collections/tables to push:"),
-      true,  // multiSelect
-      true   // prefer local
-      // shouldFilterByDatabase removed - user will be prompted interactively
-    );
+    try {
+      // Loop through each database and prompt for collections specific to that database
+      for (const database of databases) {
+        MessageFormatter.info(`\n📦 Configuring push for database: ${database.name}`, { prefix: "Database" });
+
+        const collections = await (cli as any).selectCollectionsAndTables(
+          database,
+          (cli as any).controller!.database!,
+          chalk.blue(`Select collections/tables to push to "${database.name}":`),
+          true,  // multiSelect
+          true   // prefer local
+        );
 
-    const { syncFunctions } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "syncFunctions",
-        message: "Do you want to push local functions to remote?",
-        default: false,
-      },
-    ]);
+        if (collections.length === 0) {
+          MessageFormatter.warning(`No collections selected for database "${database.name}". Skipping.`, { prefix: "Database" });
+          continue;
+        }
 
-    try {
-      // First sync databases and collections
-      await (cli as any).controller!.syncDb(databases, collections);
-      MessageFormatter.success("Database and collections pushed successfully", { prefix: "Database" });
+        // Push selected collections to this specific database
+        await (cli as any).controller!.syncDb([database], collections);
+        MessageFormatter.success(
+          `Pushed ${collections.length} collection(s) to database "${database.name}"`,
+          { prefix: "Database" }
+        );
+      }
+
+      MessageFormatter.success("\n✅ All database configurations pushed successfully!", { prefix: "Database" });
 
       // Then handle functions if requested
+      const { syncFunctions } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "syncFunctions",
+          message: "Do you want to push local functions to remote?",
+          default: false,
+        },
+      ]);
+
       if (syncFunctions && (cli as any).controller!.config?.functions?.length) {
         const functions = await (cli as any).selectFunctions(
           chalk.blue("Select local functions to push:"),

package/src/collections/attributes.ts

@@ -17,8 +17,8 @@ import { logger } from "../shared/logging.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { isDatabaseAdapter } from "../utils/typeGuards.js";
 
-// Threshold for treating min/max values as undefined (10 billion)
-const MIN_MAX_THRESHOLD = 10_000_000_000;
+// Threshold for treating min/max values as undefined (1 trillion)
+const MIN_MAX_THRESHOLD = 1_000_000_000_000;
 
 // Extreme values that Appwrite may return, which should be treated as undefined
 const EXTREME_MIN_INTEGER = -9223372036854776000;
@@ -434,7 +434,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        (attribute as any).xdefault !== undefined && !attribute.required ? (attribute as any).xdefault : undefined,
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null,
         attribute.size
       );
       break;
@@ -444,7 +444,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        (attribute as any).xdefault !== undefined && !attribute.required ? (attribute as any).xdefault : undefined,
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null,
         normalizedMin !== undefined ? parseInt(String(normalizedMin)) : undefined,
         normalizedMax !== undefined ? parseInt(String(normalizedMax)) : undefined
       );
@@ -458,7 +458,7 @@ const updateLegacyAttribute = async (
         attribute.required || false,
         normalizedMin !== undefined ? Number(normalizedMin) : undefined,
         normalizedMax !== undefined ? Number(normalizedMax) : undefined,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "boolean":
@@ -467,7 +467,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "datetime":
@@ -476,7 +476,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "email":
@@ -485,7 +485,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "ip":
@@ -494,7 +494,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "url":
@@ -503,7 +503,7 @@ const updateLegacyAttribute = async (
         collectionId,
         attribute.key,
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "enum":
@@ -513,7 +513,7 @@ const updateLegacyAttribute = async (
         attribute.key,
         (attribute as any).elements || [],
         attribute.required || false,
-        attribute.xdefault !== undefined && attribute.xdefault !== null && !attribute.required ? attribute.xdefault : undefined
+        !attribute.required && (attribute as any).xdefault !== undefined ? (attribute as any).xdefault : null
       );
       break;
     case "relationship":
@@ -569,18 +569,7 @@ const waitForAttributeAvailable = async (
   // Calculate exponential backoff: 2s, 4s, 8s, 16s, 30s (capped at 30s)
   if (retryCount > 0) {
     const exponentialDelay = calculateExponentialBackoff(retryCount);
-    MessageFormatter.info(
-      chalk.blue(
-        `Waiting for attribute '${attributeKey}' to become available (retry ${retryCount}, backoff: ${exponentialDelay}ms)...`
-      )
-    );
     await delay(exponentialDelay);
-  } else {
-    MessageFormatter.info(
-      chalk.blue(
-        `Waiting for attribute '${attributeKey}' to become available...`
-      )
-    );
   }
 
   while (Date.now() - startTime < maxWaitTime) {
@@ -597,10 +586,6 @@ const waitForAttributeAvailable = async (
         return false;
       }
 
-      MessageFormatter.info(
-        chalk.gray(`Attribute '${attributeKey}' status: ${attribute.status}`)
-      );
-
       const statusInfo = {
         attributeKey,
         status: attribute.status,
@@ -613,27 +598,14 @@ const waitForAttributeAvailable = async (
 
       switch (attribute.status) {
         case "available":
-          MessageFormatter.info(
-            chalk.green(`✅ Attribute '${attributeKey}' is now available`)
-          );
           logger.info(`Attribute '${attributeKey}' became available`, statusInfo);
           return true;
 
         case "failed":
-          MessageFormatter.info(
-            chalk.red(
-              `❌ Attribute '${attributeKey}' failed: ${attribute.error}`
-            )
-          );
           logger.error(`Attribute '${attributeKey}' failed`, statusInfo);
           return false;
 
         case "stuck":
-          MessageFormatter.info(
-            chalk.yellow(
-              `⚠️ Attribute '${attributeKey}' is stuck, will retry...`
-            )
-          );
           logger.warn(`Attribute '${attributeKey}' is stuck`, statusInfo);
           return false;
 
@@ -890,14 +862,6 @@ export const createOrUpdateAttributeWithStatusCheck = async (
   retryCount: number = 0,
   maxRetries: number = 5
 ): Promise<boolean> => {
-  MessageFormatter.info(
-    chalk.blue(
-      `Creating/updating attribute '${attribute.key}' (attempt ${
-        retryCount + 1
-      }/${maxRetries + 1})`
-    )
-  );
-
   try {
     // First, try to create/update the attribute using existing logic
     const result = await createOrUpdateAttribute(db, dbId, collection, attribute);
@@ -913,6 +877,12 @@ export const createOrUpdateAttributeWithStatusCheck = async (
       return true;
     }
 
+    // If collection creation failed, return false to indicate failure
+    if (result === "error") {
+      MessageFormatter.error(`Failed to create collection for attribute '${attribute.key}'`);
+      return false;
+    }
+
     // Now wait for the attribute to become available
     const success = await waitForAttributeAvailable(
       db,
@@ -1059,7 +1029,7 @@ export const createOrUpdateAttribute = async (
   dbId: string,
   collection: Models.Collection,
   attribute: Attribute
-): Promise<"queued" | "processed"> => {
+): Promise<"queued" | "processed" | "error"> => {
   let action = "create";
   let foundAttribute: Attribute | undefined;
   const updateEnabled = true;
@@ -1069,7 +1039,7 @@ export const createOrUpdateAttribute = async (
       (attr: any) => attr.key === attribute.key
     ) as unknown as any;
     foundAttribute = parseAttribute(collectionAttr);
-
+
   } catch (error) {
     foundAttribute = undefined;
   }
@@ -1110,7 +1080,7 @@ export const createOrUpdateAttribute = async (
     return "processed";
   }
 
-
+
 
   // Relationship attribute logic with adjustments
   let collectionFoundViaRelatedCollection: Models.Collection | undefined;
@@ -1181,7 +1151,57 @@ export const createOrUpdateAttribute = async (
     }
   }
   finalAttribute = parseAttribute(finalAttribute);
-
+
+  // Ensure collection/table exists - create it if it doesn't
+  try {
+    await (isDatabaseAdapter(db)
+      ? db.getTable({ databaseId: dbId, tableId: collection.$id })
+      : db.getCollection(dbId, collection.$id));
+  } catch (error) {
+    // Collection doesn't exist - create it
+    if ((error as any).code === 404 ||
+        (error instanceof Error && (
+          error.message.includes('collection_not_found') ||
+          error.message.includes('Collection with the requested ID could not be found')
+        ))) {
+
+      MessageFormatter.info(`Collection '${collection.name}' doesn't exist, creating it first...`);
+
+      try {
+        if (isDatabaseAdapter(db)) {
+          await db.createTable({
+            databaseId: dbId,
+            id: collection.$id,
+            name: collection.name,
+            permissions: collection.$permissions || [],
+            documentSecurity: collection.documentSecurity ?? false,
+            enabled: collection.enabled ?? true
+          });
+        } else {
+          await db.createCollection(
+            dbId,
+            collection.$id,
+            collection.name,
+            collection.$permissions || [],
+            collection.documentSecurity ?? false,
+            collection.enabled ?? true
+          );
+        }
+
+        MessageFormatter.success(`Created collection '${collection.name}'`);
+        await delay(500); // Wait for collection to be ready
+      } catch (createError) {
+        MessageFormatter.error(
+          `Failed to create collection '${collection.name}'`,
+          createError instanceof Error ? createError : new Error(String(createError))
+        );
+        return "error";
+      }
+    } else {
+      // Other error - re-throw
+      throw error;
+    }
+  }
 
   // Use adapter-based attribute creation/update
   if (action === "create") {
@@ -1205,12 +1225,6 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
   collection: Models.Collection,
   attributes: Attribute[]
 ): Promise<boolean> => {
-  MessageFormatter.info(
-    chalk.green(
-      `Creating/Updating attributes for collection: ${collection.name} with status monitoring`
-    )
-  );
-
   const existingAttributes: Attribute[] =
     // @ts-expect-error
     collection.attributes.map((attr) => parseAttribute(attr)) || [];
@@ -1265,12 +1279,6 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
   }
 
   // First, get fresh collection data and determine which attributes actually need processing
-  MessageFormatter.info(
-    chalk.blue(
-      `Analyzing ${attributes.length} attributes to determine which need processing...`
-    )
-  );
-
   let currentCollection = collection;
   try {
     currentCollection = isDatabaseAdapter(db)
@@ -1301,44 +1309,28 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
   const attributesToProcess = attributes.filter((attribute) => {
     // Skip if already processed in this session
     if (isAttributeProcessed(currentCollection.$id, attribute.key)) {
-      MessageFormatter.info(
-        chalk.gray(`⏭️ Attribute '${attribute.key}' already processed in this session (skipping)`)
-      );
       return false;
     }
 
     const existing = existingAttributesMap.get(attribute.key);
     if (!existing) {
-      MessageFormatter.info(`➕ New attribute: ${attribute.key}`);
+      MessageFormatter.info(`➕ ${attribute.key}`);
       return true;
     }
 
     const needsUpdate = !attributesSame(existing, attribute);
     if (needsUpdate) {
-      MessageFormatter.info(`🔄 Changed attribute: ${attribute.key}`);
+      MessageFormatter.info(`🔄 ${attribute.key}`);
     } else {
-      MessageFormatter.info(
-        chalk.gray(`✅ Unchanged attribute: ${attribute.key} (skipping)`)
-      );
+      MessageFormatter.info(chalk.gray(`✅ ${attribute.key}`));
     }
     return needsUpdate;
   });
 
   if (attributesToProcess.length === 0) {
-    MessageFormatter.info(
-      chalk.green(
-        `✅ All ${attributes.length} attributes are already up to date for collection: ${collection.name}`
-      )
-    );
     return true;
   }
 
-  MessageFormatter.info(
-    chalk.blue(
-      `Creating ${attributesToProcess.length} attributes sequentially with status monitoring...`
-    )
-  );
-
   let remainingAttributes = [...attributesToProcess];
   let overallRetryCount = 0;
   const maxOverallRetries = 3;
@@ -1350,21 +1342,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
     const attributesToProcessThisRound = [...remainingAttributes];
     remainingAttributes = []; // Reset for next iteration
 
-    MessageFormatter.info(
-      chalk.blue(
-        `\n=== Attempt ${
-          overallRetryCount + 1
-        }/${maxOverallRetries} - Processing ${
-          attributesToProcessThisRound.length
-        } attributes ===`
-      )
-    );
-
     for (const attribute of attributesToProcessThisRound) {
-      MessageFormatter.info(
-        chalk.blue(`\n--- Processing attribute: ${attribute.key} ---`)
-      );
-
       const success = await createOrUpdateAttributeWithStatusCheck(
         db,
         dbId,
@@ -1373,10 +1351,6 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
       );
 
       if (success) {
-        MessageFormatter.info(
-          chalk.green(`✅ Successfully created attribute: ${attribute.key}`)
-        );
-
         // Mark this specific attribute as processed
         markAttributeProcessed(currentCollection.$id, attribute.key);
 
@@ -1394,21 +1368,12 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
         // Add delay between successful attributes
         await delay(1000);
       } else {
-        MessageFormatter.info(
-          chalk.red(
-            `❌ Failed to create attribute: ${attribute.key}, will retry in next round`
-          )
-        );
+        MessageFormatter.info(chalk.red(`❌ ${attribute.key}`));
         remainingAttributes.push(attribute); // Add back to retry list
       }
     }
 
     if (remainingAttributes.length === 0) {
-      MessageFormatter.info(
-        chalk.green(
-          `\n✅ Successfully created all ${attributesToProcess.length} attributes for collection: ${collection.name}`
-        )
-      );
       return true;
     }
 
@@ -1416,9 +1381,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
 
     if (overallRetryCount < maxOverallRetries) {
       MessageFormatter.info(
-        chalk.yellow(
-          `\n⏳ Waiting 5 seconds before retrying ${attributesToProcess.length} failed attributes...`
-        )
+        chalk.yellow(`⏳ Retrying ${remainingAttributes.length} failed attributes...`)
       );
       await delay(5000);
 
@@ -1427,13 +1390,8 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
         currentCollection = isDatabaseAdapter(db)
       ? (await db.getTable({ databaseId: dbId, tableId: collection.$id })).data as Models.Collection
       : await db.getCollection(dbId, collection.$id);
-        MessageFormatter.info(`Refreshed collection data for retry`);
       } catch (error) {
-        MessageFormatter.info(
-          chalk.yellow(
-            `Warning: Could not refresh collection data for retry: ${error}`
-          )
-        );
+        // Silently continue if refresh fails
       }
     }
   }

package/src/collections/indexes.ts

@@ -35,12 +35,9 @@ const waitForIndexAvailable = async (
   // Calculate exponential backoff: 2s, 4s, 8s, 16s, 30s (capped at 30s)
   if (retryCount > 0) {
     const exponentialDelay = calculateExponentialBackoff(retryCount);
-    MessageFormatter.info(`Waiting for index '${indexKey}' to become available (retry ${retryCount}, backoff: ${exponentialDelay}ms)...`);
     await delay(exponentialDelay);
-  } else {
-    MessageFormatter.info(`Waiting for index '${indexKey}' to become available...`);
   }
-  
+
   while (Date.now() - startTime < maxWaitTime) {
     try {
       const indexList = await (isLegacyDatabases(db)
@@ -56,15 +53,8 @@ const waitForIndexAvailable = async (
         return false;
       }
 
-      if (isLegacyDatabases(db)) {
-        MessageFormatter.debug(`Index '${indexKey}' status: ${(index as any).status}`);
-      } else {
-        MessageFormatter.debug(`Index '${indexKey}' detected (TablesDB)`);
-      }
-      
       switch (index.status) {
         case 'available':
-          MessageFormatter.success(`Index '${indexKey}' is now available (type: ${index.type}, attributes: [${index.attributes.join(', ')}])`);
           return true;
 
         case 'failed':
@@ -229,11 +219,7 @@ export const createOrUpdateIndexesWithStatusCheck = async (
     const remainingIndexes = [...indexesToProcess];
     indexesToProcess = []; // Reset for next iteration
 
-    MessageFormatter.info(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${remainingIndexes.length} indexes ===`);
-    
     for (const index of remainingIndexes) {
-      MessageFormatter.info(`\n--- Processing index: ${index.key} (type: ${index.type}, attributes: [${index.attributes.join(', ')}]) ---`);
-
       const success = await createOrUpdateIndexWithStatusCheck(
         dbId,
         db,
@@ -243,25 +229,24 @@ export const createOrUpdateIndexesWithStatusCheck = async (
       );
 
       if (success) {
-        MessageFormatter.success(`Successfully created index: ${index.key} (type: ${index.type})`);
+        MessageFormatter.info(`✅ ${index.key} (${index.type})`);
 
         // Add delay between successful indexes
         await delay(1000);
       } else {
-        MessageFormatter.error(`Failed to create index: ${index.key} (type: ${index.type}), will retry in next round`);
+        MessageFormatter.info(`❌ ${index.key} (${index.type})`);
         indexesToProcess.push(index); // Add back to retry list
       }
     }
 
     if (indexesToProcess.length === 0) {
-      MessageFormatter.success(`\nSuccessfully created all ${indexes.length} indexes for collection '${collectionId}'`);
       return true;
     }
 
     overallRetryCount++;
 
     if (overallRetryCount < maxOverallRetries) {
-      MessageFormatter.warning(`\nWaiting 5 seconds before retrying ${indexesToProcess.length} failed indexes...`);
+      MessageFormatter.warning(`⏳ Retrying ${indexesToProcess.length} failed indexes...`);
       await delay(5000);
     }
   }

package/src/collections/methods.ts

@@ -518,6 +518,52 @@ export const createOrUpdateCollectionsViaAdapter = async (
       }
     }
 
+    // Wait for all attributes to become available before creating indexes
+    const allAttrKeys = [
+      ...nonRel.map((a: any) => a.key),
+      ...rels.filter((a: any) => a.relatedCollection).map((a: any) => a.key)
+    ];
+
+    if (allAttrKeys.length > 0) {
+      for (const attrKey of allAttrKeys) {
+        const maxWait = 60000; // 60 seconds
+        const startTime = Date.now();
+        let lastStatus = '';
+
+        while (Date.now() - startTime < maxWait) {
+          try {
+            const tableData = await adapter.getTable({ databaseId, tableId });
+            const attrs = (tableData as any).attributes || [];
+            const attr = attrs.find((a: any) => a.key === attrKey);
+
+            if (attr) {
+              if (attr.status === 'available') {
+                break; // Attribute is ready
+              }
+              if (attr.status === 'failed' || attr.status === 'stuck') {
+                throw new Error(`Attribute ${attrKey} failed to create: ${attr.error || 'unknown error'}`);
+              }
+              // Still processing, continue waiting
+              lastStatus = attr.status;
+            }
+
+            await delay(2000); // Check every 2 seconds
+          } catch (e) {
+            // If we can't check status, assume it's processing and continue
+            await delay(2000);
+          }
+        }
+
+        // Timeout check
+        if (Date.now() - startTime >= maxWait) {
+          MessageFormatter.warning(
+            `Attribute ${attrKey} did not become available within ${maxWait / 1000}s (last status: ${lastStatus}). Proceeding anyway.`,
+            { prefix: 'Attributes' }
+          );
+        }
+      }
+    }
+
     // Indexes
     const idxs = (indexes || []) as any[];
     for (const idx of idxs) {

package/src/interactiveCLI.ts

@@ -324,19 +324,15 @@ export class InteractiveCLI {
         ];
 
     if (shouldFilterByDatabase) {
-      // Enhanced filtering for tables with optional databaseId
+      // Show collections that EITHER exist in the remote database OR have matching local databaseId metadata
       allCollections = allCollections.filter((c: any) => {
-        // For remote collections, they should match the selected database
-        if (remoteCollections.some((rc) => rc.name === c.name)) {
-          return c.databaseId === database.$id;
-        }
+        // Include if it exists remotely in this database
+        const existsInRemoteDb = remoteCollections.some((rc) => rc.name === c.name);
+
+        // Include if local metadata claims it belongs to this database
+        const hasMatchingLocalMetadata = c.databaseId === database.$id;
 
-        // For local collections/tables:
-        // - Collections without databaseId are kept (backward compatibility)
-        // - Tables with databaseId must match the selected database
-        // - Tables without databaseId are kept (fallback for misconfigured tables)
-        if (!c.databaseId) return true;
-        return c.databaseId === database.$id;
+        return existsInRemoteDb || hasMatchingLocalMetadata;
       });
     }
 

package/src/utils/yamlConverter.ts

@@ -1,6 +1,9 @@
 import yaml from "js-yaml";
 import type { Collection, CollectionCreate } from "appwrite-utils";
 
+// Threshold for treating min/max values as undefined (1 trillion)
+const MIN_MAX_THRESHOLD = 1_000_000_000_000;
+
 export interface YamlCollectionData {
   name: string;
   id?: string;
@@ -16,6 +19,7 @@ export interface YamlCollectionData {
     size?: number;
     required?: boolean;
     array?: boolean;
+    encrypt?: boolean;
     default?: any;
     min?: number;
     max?: number;
@@ -34,6 +38,7 @@ export interface YamlCollectionData {
     size?: number;
     required?: boolean;
     array?: boolean;
+    encrypt?: boolean;
     default?: any;
     min?: number;
     max?: number;
@@ -105,9 +110,30 @@ export function collectionToYaml(
       if ('size' in attr && attr.size !== undefined) yamlAttr.size = attr.size;
       if (attr.required !== undefined) yamlAttr.required = attr.required;
       if (attr.array !== undefined) yamlAttr.array = attr.array;
+
+      // Always include encrypt field for string attributes (default to false)
+      if (attr.type === 'string') {
+        yamlAttr.encrypt = ('encrypted' in attr && attr.encrypted === true) ? true : false;
+      }
+
       if ('xdefault' in attr && attr.xdefault !== undefined) yamlAttr.default = attr.xdefault;
-      if ('min' in attr && attr.min !== undefined) yamlAttr.min = attr.min;
-      if ('max' in attr && attr.max !== undefined) yamlAttr.max = attr.max;
+
+      // Normalize min/max values - filter out extreme database values
+      if ('min' in attr && attr.min !== undefined) {
+        const minValue = Number(attr.min);
+        // Only include min if it's within reasonable range (< 1 trillion)
+        if (Math.abs(minValue) < MIN_MAX_THRESHOLD) {
+          yamlAttr.min = attr.min;
+        }
+      }
+
+      if ('max' in attr && attr.max !== undefined) {
+        const maxValue = Number(attr.max);
+        // Only include max if it's within reasonable range (< 1 trillion)
+        if (Math.abs(maxValue) < MIN_MAX_THRESHOLD) {
+          yamlAttr.max = attr.max;
+        }
+      }
       if ('elements' in attr && attr.elements !== undefined) yamlAttr.elements = attr.elements;
       if ('relatedCollection' in attr && attr.relatedCollection !== undefined) yamlAttr.relatedCollection = attr.relatedCollection;
       if ('relationType' in attr && attr.relationType !== undefined) yamlAttr.relationType = attr.relationType;