appwrite-utils-cli 1.7.9 → 1.8.2

package/dist/utils/configDiscovery.js

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs";
-import {} from "appwrite-utils";
+import { CollectionCreateSchema } from "appwrite-utils";
 import { register } from "tsx/esm/api";
 import { pathToFileURL } from "node:url";
 import yaml from "js-yaml";
@@ -185,7 +185,7 @@ export const loadYamlCollection = (filePath) => {
         const yamlData = yaml.load(fileContent);
         const parsedCollection = YamlCollectionSchema.parse(yamlData);
         // Convert YAML collection to CollectionCreate format
-        const collection = {
+        const collectionInput = {
             name: parsedCollection.name,
             $id: parsedCollection.id || parsedCollection.name.toLowerCase().replace(/\s+/g, '_'),
             documentSecurity: parsedCollection.documentSecurity,
@@ -210,7 +210,7 @@ export const loadYamlCollection = (filePath) => {
                 twoWayKey: attr.twoWayKey,
                 onDelete: attr.onDelete,
                 side: attr.side,
-                encrypted: attr.encrypt,
+                encrypt: attr.encrypt,
                 format: attr.format
             })),
             indexes: parsedCollection.indexes.map(idx => ({
@@ -221,6 +221,7 @@ export const loadYamlCollection = (filePath) => {
             })),
             importDefs: parsedCollection.importDefs && Array.isArray(parsedCollection.importDefs) && parsedCollection.importDefs.length > 0 ? parsedCollection.importDefs : []
         };
+        const collection = CollectionCreateSchema.parse(collectionInput);
         return collection;
     }
     catch (error) {

package/dist/utils/versionDetection.d.ts

@@ -46,10 +46,6 @@ export declare function isCloudAppwriteEndpoint(endpoint: string): boolean;
  * SDK feature detection as a fallback method
  * Attempts to dynamically import TablesDB to check availability
  */
-export declare function detectSdkSupport(): Promise<{
-    tablesDbAvailable: boolean;
-    legacyAvailable: boolean;
-}>;
 /**
  * Clear version detection cache (useful for testing)
  */

package/dist/utils/versionDetection.js

@@ -11,6 +11,7 @@
  */
 import { logger } from '../shared/logging.js';
 import { MessageFormatter } from '../shared/messageFormatter.js';
+import { Client, Databases, TablesDB, Query } from 'node-appwrite';
 /**
  * Detects Appwrite API version and TablesDB support
  *
@@ -43,179 +44,70 @@ export async function detectAppwriteVersion(endpoint, project, apiKey) {
             confidence: 'high'
         };
     }
-    // STEP 2: Only proceed with endpoint probe if version >= 1.8.0 or version unknown
-    // Try primary detection method: TablesDB endpoint probe
+    // STEP 2: If version is unknown, use SDK probe (no fake HTTP endpoints)
     try {
-        logger.debug('Attempting TablesDB endpoint probe', {
+        logger.debug('Attempting SDK-based TablesDB probe', {
             endpoint: cleanEndpoint,
-            serverVersion: serverVersion || 'unknown',
             operation: 'detectAppwriteVersion'
         });
-        const probeStartTime = Date.now();
-        const tablesDbResult = await probeTablesDbEndpoint(cleanEndpoint, project, apiKey);
-        const probeDuration = Date.now() - probeStartTime;
-        if (tablesDbResult.apiMode === 'tablesdb') {
-            logger.info('TablesDB detected via endpoint probe', {
-                endpoint: cleanEndpoint,
-                detectionMethod: tablesDbResult.detectionMethod,
-                confidence: tablesDbResult.confidence,
-                probeDuration,
-                totalDuration: Date.now() - startTime,
-                operation: 'detectAppwriteVersion'
-            });
-            return tablesDbResult;
+        const client = new Client().setEndpoint(cleanEndpoint).setProject(project);
+        if (apiKey && apiKey.trim().length > 0)
+            client.setKey(apiKey);
+        const databases = new Databases(client);
+        // Try to get a database id to probe tables listing
+        let dbId;
+        try {
+            const dbList = await databases.list([Query.limit(1)]);
+            dbId = dbList?.databases?.[0]?.$id || dbList?.databases?.[0]?.id || dbList?.[0]?.$id;
         }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        MessageFormatter.warning(`TablesDB endpoint probe failed: ${errorMessage}`, { prefix: "Version Detection" });
-        logger.warn('TablesDB endpoint probe failed', {
-            endpoint: cleanEndpoint,
-            error: errorMessage,
-            operation: 'detectAppwriteVersion'
-        });
-    }
-    // Try secondary detection method: SDK feature detection
-    try {
-        logger.debug('Attempting SDK capability probe', {
+        catch (e) {
+            // Ignore, we'll still attempt a conservative probe
+            logger.debug('Databases.list probe failed or returned no items', { operation: 'detectAppwriteVersion' });
+        }
+        const tables = new TablesDB(client);
+        if (dbId) {
+            // Probe listTables for the first database (limit 1)
+            await tables.listTables({ databaseId: dbId, queries: [Query.limit(1)] });
+        }
+        else {
+            // No databases to probe; assume TablesDB available (cannot falsify-positively without a db)
+            logger.debug('No databases found to probe tables; assuming TablesDB if SDK available', { operation: 'detectAppwriteVersion' });
+        }
+        const result = {
+            apiMode: 'tablesdb',
+            detectionMethod: 'endpoint_probe', // repurpose label for SDK probe
+            confidence: 'medium',
+            serverVersion: serverVersion || undefined
+        };
+        logger.info('TablesDB detected via SDK probe', {
             endpoint: cleanEndpoint,
+            result,
             operation: 'detectAppwriteVersion'
         });
-        const sdkProbeStartTime = Date.now();
-        const sdkResult = await probeSdkCapabilities();
-        const sdkProbeDuration = Date.now() - sdkProbeStartTime;
-        if (sdkResult.apiMode === 'tablesdb') {
-            logger.info('TablesDB detected via SDK capability probe', {
-                endpoint: cleanEndpoint,
-                detectionMethod: sdkResult.detectionMethod,
-                confidence: sdkResult.confidence,
-                sdkProbeDuration,
-                totalDuration: Date.now() - startTime,
-                operation: 'detectAppwriteVersion'
-            });
-            return sdkResult;
-        }
+        return result;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        MessageFormatter.warning(`SDK capability probe failed: ${errorMessage}`, { prefix: "Version Detection" });
-        logger.warn('SDK capability probe failed', {
+        logger.warn('SDK TablesDB probe failed; defaulting conservatively', {
             endpoint: cleanEndpoint,
             error: errorMessage,
             operation: 'detectAppwriteVersion'
         });
     }
-    // Fallback to legacy mode
+    // Final fallback: default to tablesdb for modern environments when version unknown
     const fallbackResult = {
-        apiMode: 'legacy',
+        apiMode: 'tablesdb',
         detectionMethod: 'fallback',
-        confidence: 'low'
+        confidence: 'low',
+        serverVersion: serverVersion || undefined
     };
-    logger.info('Falling back to legacy mode', {
+    logger.info('Defaulting to TablesDB mode (fallback)', {
         endpoint: cleanEndpoint,
-        totalDuration: Date.now() - startTime,
         result: fallbackResult,
         operation: 'detectAppwriteVersion'
     });
     return fallbackResult;
 }
-/**
- * Test TablesDB endpoint availability - most reliable detection method
- */
-async function probeTablesDbEndpoint(endpoint, project, apiKey) {
-    const startTime = Date.now();
-    const url = `${endpoint}/tablesdb/`;
-    logger.debug('Probing TablesDB endpoint', {
-        url,
-        project,
-        operation: 'probeTablesDbEndpoint'
-    });
-    const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-            'Content-Type': 'application/json',
-            'X-Appwrite-Project': project,
-            'X-Appwrite-Key': apiKey
-        },
-        // Short timeout for faster detection
-        signal: AbortSignal.timeout(5000)
-    });
-    const duration = Date.now() - startTime;
-    logger.debug('TablesDB endpoint response received', {
-        url,
-        status: response.status,
-        statusText: response.statusText,
-        duration,
-        operation: 'probeTablesDbEndpoint'
-    });
-    if (response.ok) {
-        // ONLY 200 OK means TablesDB available
-        // 404 means endpoint doesn't exist (server < 1.8.0)
-        const result = {
-            apiMode: 'tablesdb',
-            detectionMethod: 'endpoint_probe',
-            confidence: 'high'
-        };
-        logger.info('TablesDB endpoint probe successful', {
-            url,
-            status: response.status,
-            result,
-            duration,
-            operation: 'probeTablesDbEndpoint'
-        });
-        return result;
-    }
-    // 501 Not Implemented or other errors = no TablesDB support
-    const error = new Error(`TablesDB endpoint returned ${response.status}: ${response.statusText}`);
-    logger.debug('TablesDB endpoint probe failed', {
-        url,
-        status: response.status,
-        statusText: response.statusText,
-        duration,
-        operation: 'probeTablesDbEndpoint'
-    });
-    throw error;
-}
-/**
- * SDK capability detection as secondary method
- */
-async function probeSdkCapabilities() {
-    try {
-        // Try to import TablesDB SDK
-        let TablesDBModule;
-        try {
-            TablesDBModule = await import('node-appwrite-tablesdb');
-        }
-        catch (importError) {
-            // TablesDB SDK not available, will fall back to legacy
-        }
-        if (TablesDBModule?.TablesDB) {
-            return {
-                apiMode: 'tablesdb',
-                detectionMethod: 'endpoint_probe',
-                confidence: 'medium'
-            };
-        }
-    }
-    catch (error) {
-        // TablesDB SDK not available, assume legacy
-    }
-    // Check for legacy SDK availability
-    try {
-        const { Databases } = await import('node-appwrite');
-        if (Databases) {
-            return {
-                apiMode: 'legacy',
-                detectionMethod: 'endpoint_probe',
-                confidence: 'medium'
-            };
-        }
-    }
-    catch (error) {
-        throw new Error('No Appwrite SDK available');
-    }
-    throw new Error('Unable to determine SDK capabilities');
-}
 /**
  * Cached version detection to avoid repeated API calls
  */
@@ -320,31 +212,7 @@ export function isCloudAppwriteEndpoint(endpoint) {
  * SDK feature detection as a fallback method
  * Attempts to dynamically import TablesDB to check availability
  */
-export async function detectSdkSupport() {
-    const result = {
-        tablesDbAvailable: false,
-        legacyAvailable: false
-    };
-    // Test TablesDB SDK availability
-    try {
-        const tablesModule = await import('node-appwrite-tablesdb');
-        if (tablesModule) {
-            result.tablesDbAvailable = true;
-        }
-    }
-    catch (error) {
-        // TablesDB SDK not available
-    }
-    // Test legacy SDK availability  
-    try {
-        await import('node-appwrite');
-        result.legacyAvailable = true;
-    }
-    catch (error) {
-        // Legacy SDK not available
-    }
-    return result;
-}
+// Removed dynamic SDK capability checks to avoid confusion and side effects.
 /**
  * Clear version detection cache (useful for testing)
  */

package/dist/utils/yamlConverter.js

@@ -1,6 +1,86 @@
 import yaml from "js-yaml";
-// Threshold for treating min/max values as undefined (1 trillion)
-const MIN_MAX_THRESHOLD = 1_000_000_000_000;
+import { Decimal } from "decimal.js";
+// Extreme values that Appwrite may return, which should be treated as undefined
+const EXTREME_MIN_INTEGER = -9223372036854776000;
+const EXTREME_MAX_INTEGER = 9223372036854776000;
+const EXTREME_MIN_FLOAT = -1.7976931348623157e+308;
+const EXTREME_MAX_FLOAT = 1.7976931348623157e+308;
+/**
+ * Type guard to check if an attribute has min/max properties
+ */
+const hasMinMaxProperties = (yamlAttr) => {
+    return yamlAttr.type === 'integer' || yamlAttr.type === 'double' || yamlAttr.type === 'float';
+};
+/**
+ * Normalizes min/max values for integer and float attributes using Decimal.js for precision
+ * Validates that min < max and handles extreme database values
+ */
+const normalizeMinMaxValues = (yamlAttr) => {
+    if (!hasMinMaxProperties(yamlAttr)) {
+        return {};
+    }
+    const { type, min, max, key } = yamlAttr;
+    let normalizedMin = min;
+    let normalizedMax = max;
+    // Handle min value - only filter out extreme database values
+    if (normalizedMin !== undefined && normalizedMin !== null) {
+        const minValue = Number(normalizedMin);
+        const originalMin = normalizedMin;
+        // Check if it's an extreme database value (but don't filter out large numbers)
+        if (type === 'integer') {
+            if (minValue === EXTREME_MIN_INTEGER) {
+                console.debug(`Min value normalized to undefined for attribute '${yamlAttr.key}': extreme database value`);
+                normalizedMin = undefined;
+            }
+        }
+        else { // float/double
+            if (minValue === EXTREME_MIN_FLOAT) {
+                console.debug(`Min value normalized to undefined for attribute '${yamlAttr.key}': extreme database value`);
+                normalizedMin = undefined;
+            }
+        }
+    }
+    // Handle max value - only filter out extreme database values
+    if (normalizedMax !== undefined && normalizedMax !== null) {
+        const maxValue = Number(normalizedMax);
+        const originalMax = normalizedMax;
+        // Check if it's an extreme database value (but don't filter out large numbers)
+        if (type === 'integer') {
+            if (maxValue === EXTREME_MAX_INTEGER) {
+                console.debug(`Max value normalized to undefined for attribute '${yamlAttr.key}': extreme database value`);
+                normalizedMax = undefined;
+            }
+        }
+        else { // float/double
+            if (maxValue === EXTREME_MAX_FLOAT) {
+                console.debug(`Max value normalized to undefined for attribute '${yamlAttr.key}': extreme database value`);
+                normalizedMax = undefined;
+            }
+        }
+    }
+    // Validate that min < max using Decimal.js for safe comparison
+    if (normalizedMin !== undefined && normalizedMax !== undefined &&
+        normalizedMin !== null && normalizedMax !== null) {
+        try {
+            const minDecimal = new Decimal(normalizedMin.toString());
+            const maxDecimal = new Decimal(normalizedMax.toString());
+            if (minDecimal.greaterThanOrEqualTo(maxDecimal)) {
+                // Swap values to ensure min < max (graceful handling)
+                console.warn(`Swapping min/max values for attribute '${yamlAttr.key}' to fix validation: min (${normalizedMin}) must be less than max (${normalizedMax})`);
+                const temp = normalizedMin;
+                normalizedMin = normalizedMax;
+                normalizedMax = temp;
+            }
+        }
+        catch (error) {
+            console.error(`Error comparing min/max values for attribute '${yamlAttr.key}':`, error);
+            // If Decimal comparison fails, set both to undefined to avoid API errors
+            normalizedMin = undefined;
+            normalizedMax = undefined;
+        }
+    }
+    return { min: normalizedMin, max: normalizedMax };
+};
 /**
  * Converts a Collection object to YAML format with proper schema reference
  * Supports both collection and table terminology based on configuration
@@ -51,20 +131,13 @@ export function collectionToYaml(collection, config = {
             }
             if ('xdefault' in attr && attr.xdefault !== undefined)
                 yamlAttr.default = attr.xdefault;
-            // 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;
-                }
+            // Normalize min/max values using Decimal.js precision
+            if ('min' in attr || 'max' in attr) {
+                const { min, max } = normalizeMinMaxValues(attr);
+                if (min !== undefined)
+                    yamlAttr.min = min;
+                if (max !== undefined)
+                    yamlAttr.max = max;
             }
             if ('elements' in attr && attr.elements !== undefined)
                 yamlAttr.elements = attr.elements;

package/dist/utils/yamlLoader.d.ts

@@ -1,5 +1,5 @@
 import { type YamlCollectionData, type YamlTerminologyConfig } from "./yamlConverter.js";
-import type { CollectionCreate } from "appwrite-utils";
+import { type CollectionCreate } from "appwrite-utils";
 /**
  * Enhanced YAML loader with dual terminology support
  */

package/dist/utils/yamlLoader.js

@@ -3,6 +3,7 @@ import fs from "fs";
 import path from "path";
 import { logger } from "../shared/logging.js";
 import { normalizeYamlData, usesTableTerminology, convertTerminology } from "./yamlConverter.js";
+import { CollectionCreateSchema, } from "appwrite-utils";
 /**
  * Enhanced YAML loader with dual terminology support
  */
@@ -99,7 +100,7 @@ export class YamlLoader {
     yamlToCollectionCreate(yamlData) {
         // Always normalize to ensure consistent attribute terminology
         const normalized = normalizeYamlData(yamlData);
-        return {
+        const collectionInput = {
             name: normalized.name,
             $id: normalized.id || normalized.name.toLowerCase().replace(/\s+/g, '_'),
             enabled: normalized.enabled !== false,
@@ -123,7 +124,9 @@ export class YamlLoader {
                 twoWay: attr.twoWay,
                 twoWayKey: attr.twoWayKey,
                 onDelete: attr.onDelete,
-                side: attr.side
+                side: attr.side,
+                encrypt: attr.encrypt,
+                format: attr.format
             })) || [],
             indexes: normalized.indexes?.map(idx => ({
                 key: idx.key,
@@ -133,6 +136,7 @@ export class YamlLoader {
             })) || [],
             importDefs: normalized.importDefs || []
         };
+        return CollectionCreateSchema.parse(collectionInput);
     }
     /**
      * Saves YAML data with specified terminology

package/dist/utilsController.js

@@ -7,7 +7,7 @@ import { AppwriteToX } from "./migrations/appwriteToX.js";
 import { ImportController } from "./migrations/importController.js";
 import { ImportDataActions } from "./migrations/importDataActions.js";
 import { ensureDatabasesExist, wipeOtherDatabases, ensureCollectionsExist, } from "./databases/setup.js";
-import { createOrUpdateCollections, wipeDatabase, generateSchemas, fetchAllCollections, wipeCollection, } from "./collections/methods.js";
+import { createOrUpdateCollections, createOrUpdateCollectionsViaAdapter, wipeDatabase, generateSchemas, fetchAllCollections, wipeCollection, } from "./collections/methods.js";
 import { wipeAllTables, wipeTableRows } from "./collections/methods.js";
 import { backupDatabase, ensureDatabaseConfigBucketsExist, wipeDocumentStorage, } from "./storage/methods.js";
 import path from "path";
@@ -172,13 +172,19 @@ export class UtilsController {
         this.appwriteServer = client;
         this.adapter = adapter;
         this.config = config;
+        // Update config.apiMode from adapter if it's auto or not set
+        if (adapter && (!config.apiMode || config.apiMode === 'auto')) {
+            this.config.apiMode = adapter.getApiMode();
+            logger.debug(`Updated config.apiMode from adapter during init: ${this.config.apiMode}`, { prefix: "UtilsController" });
+        }
         this.database = new Databases(this.appwriteServer);
         this.storage = new Storage(this.appwriteServer);
         this.config.appwriteClient = this.appwriteServer;
         // Log only on FIRST initialization to avoid spam
         if (!this.isInitialized) {
             const apiMode = adapter.getApiMode();
-            MessageFormatter.info(`Database adapter initialized (apiMode: ${apiMode})`, { prefix: "Adapter" });
+            const configApiMode = this.config.apiMode;
+            MessageFormatter.info(`Database adapter initialized (apiMode: ${apiMode}, config.apiMode: ${configApiMode})`, { prefix: "Adapter" });
             this.isInitialized = true;
         }
         else {
@@ -443,7 +449,24 @@ export class UtilsController {
         await this.init();
         if (!this.database || !this.config)
             throw new Error("Database or config not initialized");
-        await createOrUpdateCollections(this.database, database.$id, this.config, deletedCollections, collections);
+        // Ensure apiMode is properly set from adapter
+        if (this.adapter && (!this.config.apiMode || this.config.apiMode === 'auto')) {
+            this.config.apiMode = this.adapter.getApiMode();
+            logger.debug(`Updated config.apiMode from adapter: ${this.config.apiMode}`, { prefix: "UtilsController" });
+        }
+        // Always prefer adapter path for unified behavior. LegacyAdapter internally translates when needed.
+        if (this.adapter) {
+            logger.debug("Using adapter for createOrUpdateCollections (unified path)", {
+                prefix: "UtilsController",
+                apiMode: this.adapter.getApiMode()
+            });
+            await createOrUpdateCollectionsViaAdapter(this.adapter, database.$id, this.config, deletedCollections, collections);
+        }
+        else {
+            // Fallback if adapter is unavailable for some reason
+            logger.debug("Adapter unavailable, falling back to legacy Databases path", { prefix: "UtilsController" });
+            await createOrUpdateCollections(this.database, database.$id, this.config, deletedCollections, collections);
+        }
     }
     async generateSchemas() {
         // Schema generation doesn't need Appwrite connection, just config
@@ -628,30 +651,44 @@ export class UtilsController {
             }
         }
         // PUSH OPERATION: Push local configuration to Appwrite
-        // Build selected collections/tables from databaseSelections
-        const selectedCollections = [];
+        // Build database-specific collection mappings from databaseSelections
+        const databaseCollectionsMap = new Map();
         // Get all collections/tables from config (they're at the root level, not nested in databases)
         const allCollections = this.config?.collections || this.config?.tables || [];
-        // Collect all selected table IDs from all database selections
-        const selectedTableIds = new Set();
+        // Create database-specific collection mapping to preserve relationships
         for (const dbSelection of databaseSelections) {
-            for (const tableId of dbSelection.tableIds) {
-                selectedTableIds.add(tableId);
-            }
-        }
-        // Filter to only the selected table IDs
-        for (const collection of allCollections) {
-            const collectionId = collection.$id || collection.id;
-            if (selectedTableIds.has(collectionId)) {
-                selectedCollections.push(collection);
+            const collectionsForDatabase = [];
+            MessageFormatter.info(`Processing collections for database: ${dbSelection.databaseId}`, { prefix: "Controller" });
+            // Filter collections that were selected for THIS specific database
+            for (const collection of allCollections) {
+                const collectionId = collection.$id || collection.id;
+                // Check if this collection was selected for THIS database
+                if (dbSelection.tableIds.includes(collectionId)) {
+                    collectionsForDatabase.push(collection);
+                    MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId}`, { prefix: "Controller" });
+                }
             }
+            databaseCollectionsMap.set(dbSelection.databaseId, collectionsForDatabase);
+            MessageFormatter.info(`Database ${dbSelection.databaseId}: ${collectionsForDatabase.length} collections selected`, { prefix: "Controller" });
         }
-        MessageFormatter.info(`Pushing ${selectedCollections.length} selected tables/collections to Appwrite`, { prefix: "Controller" });
+        // Calculate total collections for logging
+        const totalSelectedCollections = Array.from(databaseCollectionsMap.values())
+            .reduce((total, collections) => total + collections.length, 0);
+        MessageFormatter.info(`Pushing ${totalSelectedCollections} selected tables/collections to ${databaseCollectionsMap.size} databases`, { prefix: "Controller" });
         // Ensure databases exist
         await this.ensureDatabasesExist(selectedDatabases);
         await this.ensureDatabaseConfigBucketsExist(selectedDatabases);
-        // Create/update ONLY the selected collections/tables
-        await this.createOrUpdateCollectionsForDatabases(selectedDatabases, selectedCollections);
+        // Create/update collections with database-specific context
+        for (const database of selectedDatabases) {
+            const collectionsForThisDatabase = databaseCollectionsMap.get(database.$id) || [];
+            if (collectionsForThisDatabase.length > 0) {
+                MessageFormatter.info(`Pushing ${collectionsForThisDatabase.length} collections to database ${database.$id} (${database.name})`, { prefix: "Controller" });
+                await this.createOrUpdateCollections(database, undefined, collectionsForThisDatabase);
+            }
+            else {
+                MessageFormatter.info(`No collections selected for database ${database.$id} (${database.name})`, { prefix: "Controller" });
+            }
+        }
         MessageFormatter.success("Selective push completed successfully! Local config pushed to Appwrite.", { prefix: "Controller" });
     }
     async syncDb(databases = [], collections = []) {

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.7.9",
+  "version": "1.8.2",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -39,10 +39,11 @@
     "@types/inquirer": "^9.0.8",
     "@types/json-schema": "^7.0.15",
     "@types/yargs": "^17.0.33",
-    "appwrite-utils": "^1.6.1",
+    "appwrite-utils": "latest",
     "chalk": "^5.4.1",
     "cli-progress": "^3.12.0",
     "commander": "^12.1.0",
+    "decimal.js": "^10.6.0",
     "es-toolkit": "^1.39.4",
     "ignore": "^6.0.2",
     "inquirer": "^9.3.7",
@@ -50,8 +51,7 @@
     "jszip": "^3.10.1",
     "luxon": "^3.6.1",
     "nanostores": "^0.10.3",
-    "node-appwrite": "^17",
-    "node-appwrite-tablesdb": "npm:node-appwrite@^18.0.0",
+    "node-appwrite": "^20.2.1",
     "p-limit": "^6.2.0",
     "tar": "^7.4.3",
     "tsx": "^4.20.3",