appwrite-utils-cli 0.9.77 → 0.9.79

package/README.md

@@ -61,6 +61,7 @@ Available options:
 - `--collectionIds`: Comma-separated list of collection IDs to operate on
 - `--bucketIds`: Comma-separated list of bucket IDs to operate on
 - `--wipe`: Wipe data (all: everything, docs: only documents, users: only user data)
+- `--wipeCollections`: Wipe collections (wipes specified collections from collectionIds -- does this non-destructively, deletes all documents)
 - `--generate`: Generate TypeScript schemas from database schemas
 - `--import`: Import data into your databases
 - `--backup`: Perform a backup of your databases
@@ -124,6 +125,8 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.9.79: Fixed local collections not being considered for the synchronization unless all de-selected
+- 0.9.78: Added colored text! And also added a lot more customization options as to what to wipe, update, etc.
 - 0.9.75: Fixed attribute bug
 - 0.9.72: Fixed my own null bug
 - 0.9.71: Reverted `node-appwrite` to 14, this seems to fix the xdefault error

package/dist/collections/attributes.js

@@ -3,6 +3,7 @@ import { attributeSchema, parseAttribute, } from "appwrite-utils";
 import { nameToIdMapping, enqueueOperation } from "../migrations/queue.js";
 import _ from "lodash";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import chalk from "chalk";
 const attributesSame = (databaseAttribute, configAttribute) => {
     const attributesToCheck = [
         'key',
@@ -62,6 +63,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         // @ts-expect-error
         (attr) => attr.key === attribute.key);
         foundAttribute = parseAttribute(collectionAttr);
+        // console.log(`Found attribute: ${JSON.stringify(foundAttribute)}`);
     }
     catch (error) {
         foundAttribute = undefined;
@@ -74,7 +76,10 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
         // console.log(
         //   `Updating attribute with same key ${attribute.key} but different values`
         // );
-        finalAttribute = attribute;
+        finalAttribute = {
+            ...foundAttribute,
+            ...attribute,
+        };
         action = "update";
     }
     else if (!updateEnabled && foundAttribute && !attributesSame(foundAttribute, attribute)) {
@@ -93,7 +98,9 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
                 collectionFoundViaRelatedCollection = await db.getCollection(dbId, relatedCollectionId);
             }
             catch (e) {
-                console.log(`Collection not found: ${finalAttribute.relatedCollection} when nameToIdMapping was set`);
+                // console.log(
+                //   `Collection not found: ${finalAttribute.relatedCollection} when nameToIdMapping was set`
+                // );
                 collectionFoundViaRelatedCollection = undefined;
             }
         }
@@ -108,7 +115,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
             }
         }
         if (!(relatedCollectionId && collectionFoundViaRelatedCollection)) {
-            console.log(`Enqueueing operation for attribute: ${finalAttribute.key}`);
+            // console.log(`Enqueueing operation for attribute: ${finalAttribute.key}`);
             enqueueOperation({
                 type: "attribute",
                 collectionId: collection.$id,
@@ -119,7 +126,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
             return;
         }
     }
-    finalAttribute = attributeSchema.parse(finalAttribute);
+    finalAttribute = parseAttribute(finalAttribute);
     // console.log(`Final Attribute: ${JSON.stringify(finalAttribute)}`);
     switch (finalAttribute.type) {
         case "string":
@@ -224,7 +231,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
     }
 };
 export const createUpdateCollectionAttributes = async (db, dbId, collection, attributes) => {
-    console.log(`Creating/Updating attributes for collection: ${collection.name}`);
+    console.log(chalk.green(`Creating/Updating attributes for collection: ${collection.name}`));
     const batchSize = 3;
     for (let i = 0; i < attributes.length; i += batchSize) {
         const batch = attributes.slice(i, i + batchSize);

package/dist/collections/methods.d.ts

@@ -7,10 +7,11 @@ export declare const wipeDatabase: (database: Databases, databaseId: string) =>
     collectionId: string;
     collectionName: string;
 }[]>;
+export declare const wipeCollection: (database: Databases, databaseId: string, collectionId: string) => Promise<void>;
 export declare const generateSchemas: (config: AppwriteConfig, appwriteFolderPath: string) => Promise<void>;
 export declare const createOrUpdateCollections: (database: Databases, databaseId: string, config: AppwriteConfig, deletedCollections?: {
     collectionId: string;
     collectionName: string;
-}[]) => Promise<void>;
+}[], selectedCollections?: Models.Collection[]) => Promise<void>;
 export declare const generateMockData: (database: Databases, databaseId: string, configCollections: any[]) => Promise<void>;
 export declare const fetchAllCollections: (dbId: string, database: Databases) => Promise<Models.Collection[]>;

package/dist/collections/methods.js

@@ -86,6 +86,21 @@ export const fetchAndCacheCollectionByName = async (db, dbId, collectionName) =>
         }
     }
 };
+async function wipeDocumentsFromCollection(database, databaseId, collectionId) {
+    const initialDocuments = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
+    let documents = initialDocuments.documents;
+    while (documents.length === 1000) {
+        const docsResponse = await database.listDocuments(databaseId, collectionId, [Query.limit(1000)]);
+        documents = documents.concat(docsResponse.documents);
+    }
+    const batchDeletePromises = documents.map(doc => database.deleteDocument(databaseId, collectionId, doc.$id));
+    const maxStackSize = 100;
+    for (let i = 0; i < batchDeletePromises.length; i += maxStackSize) {
+        await Promise.all(batchDeletePromises.slice(i, i + maxStackSize));
+        await delay(100);
+    }
+    console.log(`Deleted ${documents.length} documents from collection ${collectionId}`);
+}
 export const wipeDatabase = async (database, databaseId) => {
     console.log(`Wiping database: ${databaseId}`);
     const existingCollections = await fetchAllCollections(databaseId, database);
@@ -101,56 +116,71 @@ export const wipeDatabase = async (database, databaseId) => {
     }
     return collectionsDeleted;
 };
+export const wipeCollection = async (database, databaseId, collectionId) => {
+    const collections = await database.listCollections(databaseId, [Query.equal("$id", collectionId)]);
+    if (collections.total === 0) {
+        console.log(`Collection ${collectionId} not found`);
+        return;
+    }
+    const collection = collections.collections[0];
+    await wipeDocumentsFromCollection(database, databaseId, collection.$id);
+};
 export const generateSchemas = async (config, appwriteFolderPath) => {
     const schemaGenerator = new SchemaGenerator(config, appwriteFolderPath);
     schemaGenerator.generateSchemas();
 };
-export const createOrUpdateCollections = async (database, databaseId, config, deletedCollections) => {
-    const configCollections = config.collections;
-    if (!configCollections) {
+export const createOrUpdateCollections = async (database, databaseId, config, deletedCollections, selectedCollections = []) => {
+    const collectionsToProcess = selectedCollections.length > 0 ? selectedCollections : config.collections;
+    if (!collectionsToProcess) {
         return;
     }
     const usedIds = new Set();
-    for (const { attributes, indexes, ...collection } of configCollections) {
+    for (const collection of collectionsToProcess) {
+        const { attributes, indexes, ...collectionData } = collection;
         // Prepare permissions for the collection
         const permissions = [];
         if (collection.$permissions && collection.$permissions.length > 0) {
             for (const permission of collection.$permissions) {
-                switch (permission.permission) {
-                    case "read":
-                        permissions.push(Permission.read(permission.target));
-                        break;
-                    case "create":
-                        permissions.push(Permission.create(permission.target));
-                        break;
-                    case "update":
-                        permissions.push(Permission.update(permission.target));
-                        break;
-                    case "delete":
-                        permissions.push(Permission.delete(permission.target));
-                        break;
-                    case "write":
-                        permissions.push(Permission.write(permission.target));
-                        break;
-                    default:
-                        console.log(`Unknown permission: ${permission.permission}`);
-                        break;
+                if (typeof permission === 'string') {
+                    permissions.push(permission);
+                }
+                else {
+                    switch (permission.permission) {
+                        case "read":
+                            permissions.push(Permission.read(permission.target));
+                            break;
+                        case "create":
+                            permissions.push(Permission.create(permission.target));
+                            break;
+                        case "update":
+                            permissions.push(Permission.update(permission.target));
+                            break;
+                        case "delete":
+                            permissions.push(Permission.delete(permission.target));
+                            break;
+                        case "write":
+                            permissions.push(Permission.write(permission.target));
+                            break;
+                        default:
+                            console.log(`Unknown permission: ${permission.permission}`);
+                            break;
+                    }
                 }
             }
         }
         // Check if the collection already exists by name
         let collectionsFound = await tryAwaitWithRetry(async () => await database.listCollections(databaseId, [
-            Query.equal("name", collection.name),
+            Query.equal("name", collectionData.name),
         ]));
         let collectionToUse = collectionsFound.total > 0 ? collectionsFound.collections[0] : null;
         // Determine the correct ID for the collection
         let collectionId;
         if (!collectionToUse) {
-            console.log(`Creating collection: ${collection.name}`);
+            console.log(`Creating collection: ${collectionData.name}`);
             let foundColl = deletedCollections?.find((coll) => coll.collectionName.toLowerCase().trim().replace(" ", "") ===
-                collection.name.toLowerCase().trim().replace(" ", ""));
-            if (collection.$id) {
-                collectionId = collection.$id;
+                collectionData.name.toLowerCase().trim().replace(" ", ""));
+            if (collectionData.$id) {
+                collectionId = collectionData.$id;
             }
             else if (foundColl && !usedIds.has(foundColl.collectionId)) {
                 collectionId = foundColl.collectionId;
@@ -161,28 +191,30 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
             usedIds.add(collectionId);
             // Create the collection with the determined ID
             try {
-                collectionToUse = await tryAwaitWithRetry(async () => await database.createCollection(databaseId, collectionId, collection.name, permissions, collection.documentSecurity ?? false, collection.enabled ?? true));
-                collection.$id = collectionToUse.$id;
-                nameToIdMapping.set(collection.name, collectionToUse.$id);
+                collectionToUse = await tryAwaitWithRetry(async () => await database.createCollection(databaseId, collectionId, collectionData.name, permissions, collectionData.documentSecurity ?? false, collectionData.enabled ?? true));
+                collectionData.$id = collectionToUse.$id;
+                nameToIdMapping.set(collectionData.name, collectionToUse.$id);
             }
             catch (error) {
-                console.error(`Failed to create collection ${collection.name} with ID ${collectionId}: ${error}`);
+                console.error(`Failed to create collection ${collectionData.name} with ID ${collectionId}: ${error}`);
                 continue;
             }
         }
         else {
-            console.log(`Collection ${collection.name} exists, updating it`);
-            await tryAwaitWithRetry(async () => await database.updateCollection(databaseId, collectionToUse.$id, collection.name, permissions, collection.documentSecurity ?? false, collection.enabled ?? true));
+            console.log(`Collection ${collectionData.name} exists, updating it`);
+            await tryAwaitWithRetry(async () => await database.updateCollection(databaseId, collectionToUse.$id, collectionData.name, permissions, collectionData.documentSecurity ?? false, collectionData.enabled ?? true));
         }
         // Add delay after creating/updating collection
         await delay(250);
         // Update attributes and indexes for the collection
         console.log("Creating Attributes");
-        await createUpdateCollectionAttributes(database, databaseId, collectionToUse, attributes);
+        await createUpdateCollectionAttributes(database, databaseId, collectionToUse, 
+        // @ts-expect-error
+        attributes);
         // Add delay after creating attributes
         await delay(250);
         console.log("Creating Indexes");
-        await createOrUpdateIndexes(databaseId, database, collectionToUse.$id, indexes ?? []);
+        await createOrUpdateIndexes(databaseId, database, collectionToUse.$id, (indexes ?? []));
         // Add delay after creating indexes
         await delay(250);
     }

package/dist/interactiveCLI.d.ts

@@ -14,7 +14,11 @@ export declare class InteractiveCLI {
     private synchronizeConfigurations;
     private backupDatabase;
     private wipeDatabase;
+    private wipeCollections;
     private generateSchemas;
     private importData;
     private transferData;
+    private getLocalCollections;
+    private getLocalDatabases;
+    private reloadConfig;
 }

package/dist/interactiveCLI.js

@@ -6,7 +6,10 @@ import { fetchAllCollections } from "./collections/methods.js";
 import { listBuckets, createBucket } from "./storage/methods.js";
 import { Databases, Storage, Client, Compression, } from "node-appwrite";
 import { getClient } from "./utils/getClientFromConfig.js";
+import { parseAttribute, PermissionToAppwritePermission } from "appwrite-utils";
 import { ulid } from "ulidx";
+import chalk from "chalk";
+import { DateTime } from "luxon";
 var CHOICES;
 (function (CHOICES) {
     CHOICES["CREATE_COLLECTION_CONFIG"] = "Create collection config file";
@@ -17,8 +20,10 @@ var CHOICES;
     CHOICES["TRANSFER_DATA"] = "Transfer data";
     CHOICES["BACKUP_DATABASE"] = "Backup database";
     CHOICES["WIPE_DATABASE"] = "Wipe database";
+    CHOICES["WIPE_COLLECTIONS"] = "Wipe collections";
     CHOICES["GENERATE_SCHEMAS"] = "Generate schemas";
     CHOICES["IMPORT_DATA"] = "Import data";
+    CHOICES["RELOAD_CONFIG"] = "Reload configuration files";
     CHOICES["EXIT"] = "Exit";
 })(CHOICES || (CHOICES = {}));
 export class InteractiveCLI {
@@ -28,17 +33,18 @@ export class InteractiveCLI {
         this.currentDir = currentDir;
     }
     async run() {
-        console.log("Welcome to Appwrite Utils CLI Tool by Zach Handley");
-        console.log("For more information, visit https://github.com/zachhandley/AppwriteUtils");
+        console.log(chalk.green("Welcome to Appwrite Utils CLI Tool by Zach Handley"));
+        console.log(chalk.blue("For more information, visit https://github.com/zachhandley/AppwriteUtils"));
         while (true) {
             const { action } = await inquirer.prompt([
                 {
                     type: "list",
                     name: "action",
-                    message: "What would you like to do?",
+                    message: chalk.yellow("What would you like to do?"),
                     choices: Object.values(CHOICES),
                 },
             ]);
+            await this.initControllerIfNeeded();
             switch (action) {
                 case CHOICES.CREATE_COLLECTION_CONFIG:
                     await this.createCollectionConfig();
@@ -69,6 +75,10 @@ export class InteractiveCLI {
                     await this.initControllerIfNeeded();
                     await this.wipeDatabase();
                     break;
+                case CHOICES.WIPE_COLLECTIONS:
+                    await this.initControllerIfNeeded();
+                    await this.wipeCollections();
+                    break;
                 case CHOICES.GENERATE_SCHEMAS:
                     await this.initControllerIfNeeded();
                     await this.generateSchemas();
@@ -77,8 +87,12 @@ export class InteractiveCLI {
                     await this.initControllerIfNeeded();
                     await this.importData();
                     break;
+                case CHOICES.RELOAD_CONFIG:
+                    await this.initControllerIfNeeded();
+                    await this.reloadConfig();
+                    break;
                 case CHOICES.EXIT:
-                    console.log("Exiting...");
+                    console.log(chalk.green("Goodbye!"));
                     return;
             }
         }
@@ -90,12 +104,14 @@ export class InteractiveCLI {
         }
     }
     async selectDatabases(databases, message, multiSelect = true) {
-        const choices = databases.map((db) => ({ name: db.name, value: db }));
+        const choices = databases.map((db) => ({ name: db.name, value: db })).filter((db) => db.name.toLowerCase() !== "migrations");
+        const configDatabases = this.getLocalDatabases();
+        const allDatabases = Array.from(new Set([...databases, ...configDatabases]));
         const { selectedDatabases } = await inquirer.prompt([
             {
                 type: multiSelect ? "checkbox" : "list",
                 name: "selectedDatabases",
-                message,
+                message: chalk.blue(message),
                 choices,
                 loop: false,
                 pageSize: 10,
@@ -105,7 +121,9 @@ export class InteractiveCLI {
     }
     async selectCollections(database, databasesClient, message, multiSelect = true) {
         const collections = await fetchAllCollections(database.$id, databasesClient);
-        const choices = collections.map((collection) => ({
+        const configCollections = this.getLocalCollections();
+        const allCollections = Array.from(new Set([...collections, ...configCollections]));
+        const choices = allCollections.map((collection) => ({
             name: collection.name,
             value: collection,
         }));
@@ -113,7 +131,7 @@ export class InteractiveCLI {
             {
                 type: multiSelect ? "checkbox" : "list",
                 name: "selectedCollections",
-                message,
+                message: chalk.blue(message),
                 choices,
                 loop: false,
                 pageSize: 10,
@@ -130,7 +148,7 @@ export class InteractiveCLI {
             {
                 type: multiSelect ? "checkbox" : "list",
                 name: "selectedBuckets",
-                message,
+                message: chalk.blue(message),
                 choices,
                 loop: false,
                 pageSize: 10,
@@ -143,11 +161,11 @@ export class InteractiveCLI {
             {
                 type: "input",
                 name: "collectionName",
-                message: "Enter the name of the collection:",
+                message: chalk.blue("Enter the name of the collection:"),
                 validate: (input) => input.trim() !== "" || "Collection name cannot be empty.",
             },
         ]);
-        console.log(`Creating collection config file for '${collectionName}'...`);
+        console.log(chalk.green(`Creating collection config file for '${collectionName}'...`));
         createEmptyCollection(collectionName);
     }
     async configureBuckets(config, databases) {
@@ -163,7 +181,7 @@ export class InteractiveCLI {
                     {
                         type: "confirm",
                         name: "wantCreateBucket",
-                        message: `There are no buckets. Do you want to create a bucket for the database "${database.name}"?`,
+                        message: chalk.blue(`There are no buckets. Do you want to create a bucket for the database "${database.name}"?`),
                         default: true,
                     },
                 ]);
@@ -322,7 +340,11 @@ export class InteractiveCLI {
         }, bucketId.length > 0 ? bucketId : ulid());
     }
     async syncDb() {
-        await this.controller.syncDb();
+        console.log(chalk.yellow("Syncing database..."));
+        const databases = await this.selectDatabases(await fetchAllDatabases(this.controller.database), chalk.blue("Select databases to synchronize:"), true);
+        const collections = await this.selectCollections(databases[0], this.controller.database, chalk.blue("Select collections to synchronize:"), true);
+        await this.controller.syncDb(databases, collections);
+        console.log(chalk.green("Database sync completed."));
     }
     async synchronizeConfigurations() {
         if (!this.controller.database) {
@@ -330,10 +352,11 @@ export class InteractiveCLI {
         }
         const databases = await fetchAllDatabases(this.controller.database);
         const selectedDatabases = await this.selectDatabases(databases, "Select databases to synchronize:");
-        console.log("Configuring storage buckets...");
+        console.log(chalk.yellow("Configuring storage buckets..."));
         const updatedConfig = await this.configureBuckets(this.controller.config, selectedDatabases);
-        console.log("Synchronizing configurations...");
+        console.log(chalk.yellow("Synchronizing configurations..."));
         await this.controller.synchronizeConfigurations(selectedDatabases, updatedConfig);
+        console.log(chalk.green("Configuration synchronization completed."));
     }
     async backupDatabase() {
         if (!this.controller.database) {
@@ -342,9 +365,10 @@ export class InteractiveCLI {
         const databases = await fetchAllDatabases(this.controller.database);
         const selectedDatabases = await this.selectDatabases(databases, "Select databases to backup:");
         for (const db of selectedDatabases) {
-            console.log(`Backing up database: ${db.name}`);
+            console.log(chalk.yellow(`Backing up database: ${db.name}`));
             await this.controller.backupDatabase(db);
         }
+        console.log(chalk.green("Database backup completed."));
     }
     async wipeDatabase() {
         if (!this.controller.database || !this.controller.storage) {
@@ -373,12 +397,12 @@ export class InteractiveCLI {
             {
                 type: "confirm",
                 name: "confirm",
-                message: "Are you sure you want to wipe the selected items? This action cannot be undone.",
+                message: chalk.red("Are you sure you want to wipe the selected items? This action cannot be undone."),
                 default: false,
             },
         ]);
         if (confirm) {
-            console.log("Wiping selected items...");
+            console.log(chalk.yellow("Wiping selected items..."));
             for (const db of selectedDatabases) {
                 await this.controller.wipeDatabase(db);
             }
@@ -388,26 +412,58 @@ export class InteractiveCLI {
             if (wipeUsers) {
                 await this.controller.wipeUsers();
             }
+            console.log(chalk.green("Wipe operation completed."));
         }
         else {
-            console.log("Wipe operation cancelled.");
+            console.log(chalk.blue("Wipe operation cancelled."));
         }
     }
-    async generateSchemas() {
-        console.log("Generating schemas...");
-        await this.controller.generateSchemas();
-    }
-    async importData() {
+    async wipeCollections() {
         if (!this.controller.database) {
             throw new Error("Database is not initialized, is the config file correct & created?");
         }
         const databases = await fetchAllDatabases(this.controller.database);
-        const selectedDatabases = await this.selectDatabases(databases, "Select the database(s) to import data into:");
-        let selectedCollections = [];
-        for (const db of selectedDatabases) {
-            const dbCollections = await this.selectCollections(db, this.controller.database, `Select collections to import data into for database ${db.name}:`, true);
-            selectedCollections = [...selectedCollections, ...dbCollections];
+        const selectedDatabases = await this.selectDatabases(databases, "Select the database(s) containing the collections to wipe:", true);
+        for (const database of selectedDatabases) {
+            const collections = await this.selectCollections(database, this.controller.database, `Select collections to wipe from ${database.name}:`, true);
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: chalk.red(`Are you sure you want to wipe the selected collections from ${database.name}? This action cannot be undone.`),
+                    default: false,
+                },
+            ]);
+            if (confirm) {
+                console.log(chalk.yellow(`Wiping selected collections from ${database.name}...`));
+                for (const collection of collections) {
+                    await this.controller.wipeCollection(database, collection);
+                    console.log(chalk.green(`Collection ${collection.name} wiped successfully.`));
+                }
+            }
+            else {
+                console.log(chalk.blue(`Wipe operation cancelled for ${database.name}.`));
+            }
         }
+        console.log(chalk.green("Wipe collections operation completed."));
+    }
+    async generateSchemas() {
+        console.log(chalk.yellow("Generating schemas..."));
+        await this.controller.generateSchemas();
+        console.log(chalk.green("Schema generation completed."));
+    }
+    async importData() {
+        console.log(chalk.yellow("Importing data..."));
+        const { doBackup } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "doBackup",
+                message: "Do you want to perform a backup before importing?",
+                default: true,
+            },
+        ]);
+        const databases = await this.selectDatabases(await fetchAllDatabases(this.controller.database), "Select databases to import data into:", true);
+        const collections = await this.selectCollections(databases[0], this.controller.database, "Select collections to import data into (leave empty for all):", true);
         const { shouldWriteFile } = await inquirer.prompt([
             {
                 type: "confirm",
@@ -416,24 +472,20 @@ export class InteractiveCLI {
                 default: false,
             },
         ]);
-        // const { checkDuplicates } = await inquirer.prompt([
-        //   {
-        //     type: "confirm",
-        //     name: "checkDuplicates",
-        //     message: "Do you want to check for duplicates during import?",
-        //     default: true,
-        //   },
-        // ]);
-        console.log("Importing data...");
-        await this.controller.importData({
-            databases: selectedDatabases,
-            collections: selectedCollections.length > 0
-                ? selectedCollections.map((c) => c.$id)
-                : undefined,
+        const options = {
+            databases,
+            collections: collections.map(c => c.name),
+            doBackup,
+            importData: true,
             shouldWriteFile,
-            checkDuplicates: false,
-            // checkDuplicates,
-        });
+        };
+        try {
+            await this.controller.importData(options);
+            console.log(chalk.green("Data import completed successfully."));
+        }
+        catch (error) {
+            console.error(chalk.red("Error importing data:"), error);
+        }
     }
     async transferData() {
         if (!this.controller.database) {
@@ -481,18 +533,17 @@ export class InteractiveCLI {
             sourceDatabases = targetDatabases = allDatabases;
         }
         const fromDbs = await this.selectDatabases(sourceDatabases, "Select the source database:", false);
-        console.log(fromDbs);
-        const fromDb = fromDbs;
+        const fromDb = fromDbs[0];
         if (!fromDb) {
             throw new Error("No source database selected");
         }
         const availableDbs = targetDatabases.filter((db) => db.$id !== fromDb.$id);
         const targetDbs = await this.selectDatabases(availableDbs, "Select the target database:", false);
-        const targetDb = targetDbs;
+        const targetDb = targetDbs[0];
         if (!targetDb) {
             throw new Error("No target database selected");
         }
-        const selectedCollections = await this.selectCollections(fromDb, sourceClient, "Select collections to transfer):");
+        const selectedCollections = await this.selectCollections(fromDb, sourceClient, "Select collections to transfer:");
         const { transferStorage } = await inquirer.prompt([
             {
                 type: "confirm",
@@ -513,8 +564,8 @@ export class InteractiveCLI {
                 : sourceBuckets;
             const sourceBucketPicked = await this.selectBuckets(sourceBuckets.buckets, "Select the source bucket:", false);
             const targetBucketPicked = await this.selectBuckets(targetBuckets.buckets, "Select the target bucket:", false);
-            sourceBucket = sourceBucketPicked;
-            targetBucket = targetBucketPicked;
+            sourceBucket = sourceBucketPicked[0];
+            targetBucket = targetBucketPicked[0];
         }
         let transferOptions = {
             fromDb,
@@ -532,7 +583,44 @@ export class InteractiveCLI {
                 ...remoteOptions,
             };
         }
-        console.log("Transferring data...");
+        console.log(chalk.yellow("Transferring data..."));
         await this.controller.transferData(transferOptions);
+        console.log(chalk.green("Data transfer completed."));
+    }
+    getLocalCollections() {
+        const configCollections = this.controller.config.collections || [];
+        // @ts-expect-error - appwrite invalid types
+        return configCollections.map(c => ({
+            $id: c.$id || ulid(),
+            $createdAt: DateTime.now().toISO(),
+            $updatedAt: DateTime.now().toISO(),
+            name: c.name,
+            enabled: c.enabled || true,
+            documentSecurity: c.documentSecurity || false,
+            attributes: c.attributes || [],
+            indexes: c.indexes || [],
+            $permissions: PermissionToAppwritePermission(c.$permissions) || [],
+            databaseId: c.databaseId,
+        }));
+    }
+    getLocalDatabases() {
+        const configDatabases = this.controller.config.databases || [];
+        return configDatabases.map(db => ({
+            $id: db.$id || ulid(),
+            $createdAt: DateTime.now().toISO(),
+            $updatedAt: DateTime.now().toISO(),
+            name: db.name,
+            enabled: true,
+        }));
+    }
+    async reloadConfig() {
+        console.log(chalk.yellow("Reloading configuration files..."));
+        try {
+            await this.controller.reloadConfig();
+            console.log(chalk.green("Configuration files reloaded successfully."));
+        }
+        catch (error) {
+            console.error(chalk.red("Error reloading configuration files:"), error);
+        }
     }
 }