appwrite-utils-cli 0.10.75 → 0.10.77

package/README.md

@@ -115,6 +115,8 @@ npx appwrite-utils-cli appwrite-migrate --transfer --fromBucketId sourceBucketId
 
 ### Update Function Specifications
 
+**NOTE: IF IT DOES NOT WORK AND YOU ARE SELF-HOSTED, PLEASE SET MAX CPU_PER_FUNCTION AND RAM_PER_FUNCTION IN YOUR ENV VARS TO > 0, THIS IS A BUG IN 1.6.0**
+
 Update the CPU and RAM specifications for a function:
 
 ```bash
@@ -148,6 +150,8 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.10.77: Added disclaimer to update function specifications for bug
+- 0.10.76: Updated CLI commands to not require an `appwriteConfig.ts` if you set API Key, ProjectId, and Endpoint
 - 0.10.75: Fixed slight issue writing ZOD Schema for collection without any attributes
 - 0.10.74: Fix moving users, should update Labels now
 - 0.10.73: Fix moving users, passwords should work now (from Appwrite, Argon2)

package/dist/interactiveCLI.js

@@ -122,9 +122,9 @@ export class InteractiveCLI {
             }
         }
     }
-    async initControllerIfNeeded() {
+    async initControllerIfNeeded(directConfig) {
         if (!this.controller) {
-            this.controller = new UtilsController(this.currentDir);
+            this.controller = new UtilsController(this.currentDir, directConfig);
             await this.controller.init();
         }
     }

package/dist/main.js

@@ -159,12 +159,23 @@ async function main() {
         await cli.run();
     }
     else {
-        const controller = new UtilsController(process.cwd());
+        const directConfig = argv.endpoint || argv.projectId || argv.apiKey
+            ? {
+                appwriteEndpoint: argv.endpoint,
+                appwriteProject: argv.projectId,
+                appwriteKey: argv.apiKey,
+            }
+            : undefined;
+        const controller = new UtilsController(process.cwd(), directConfig);
         await controller.init();
         if (argv.setup) {
             await setupDirsFiles(false, process.cwd());
             return;
         }
+        if (!controller.config) {
+            console.log(chalk.red("No Appwrite connection found"));
+            return;
+        }
         const parsedArgv = argv;
         const options = {
             databases: parsedArgv.dbIds
@@ -280,7 +291,11 @@ async function main() {
             // Only fetch databases if database IDs are provided
             if (parsedArgv.fromDbId && parsedArgv.toDbId) {
                 console.log(chalk.blue(`Starting database transfer from ${parsedArgv.fromDbId} to ${parsedArgv.toDbId}`));
-                fromDb = (await controller.getDatabasesByIds([parsedArgv.fromDbId]))[0];
+                fromDb = (await controller.getDatabasesByIds([parsedArgv.fromDbId]))?.[0];
+                if (!fromDb) {
+                    console.log(chalk.red("Source database not found"));
+                    return;
+                }
                 if (isRemote) {
                     if (!parsedArgv.remoteEndpoint ||
                         !parsedArgv.remoteProjectId ||
@@ -292,12 +307,21 @@ async function main() {
                     targetStorage = new Storage(remoteClient);
                     const remoteDbs = await fetchAllDatabases(targetDatabases);
                     toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
+                    if (!toDb) {
+                        console.log(chalk.red("Target database not found"));
+                        return;
+                    }
                 }
                 else {
-                    toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))[0];
+                    toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))?.[0];
+                    if (!toDb) {
+                        console.log(chalk.red("Target database not found"));
+                        return;
+                    }
                 }
                 if (!fromDb || !toDb) {
-                    throw new Error("Source or target database not found");
+                    console.log(chalk.red("Source or target database not found"));
+                    return;
                 }
             }
             // Handle storage setup

package/dist/utilsController.d.ts

@@ -17,8 +17,8 @@ export interface SetupOptions {
     shouldWriteFile?: boolean;
 }
 export declare class UtilsController {
-    private appwriteFolderPath;
-    private appwriteConfigPath;
+    private appwriteFolderPath?;
+    private appwriteConfigPath?;
     config?: AppwriteConfig;
     appwriteServer?: Client;
     database?: Databases;
@@ -26,14 +26,18 @@ export declare class UtilsController {
     converterDefinitions: ConverterFunctions;
     validityRuleDefinitions: ValidationRules;
     afterImportActionsDefinitions: AfterImportActions;
-    constructor(currentUserDir: string);
+    constructor(currentUserDir: string, directConfig?: {
+        appwriteEndpoint?: string;
+        appwriteProject?: string;
+        appwriteKey?: string;
+    });
     init(): Promise<void>;
     reloadConfig(): Promise<void>;
     setupMigrationDatabase(): Promise<void>;
     ensureDatabaseConfigBucketsExist(databases?: Models.Database[]): Promise<void>;
     ensureDatabasesExist(databases?: Models.Database[]): Promise<void>;
     ensureCollectionsExist(database: Models.Database, collections?: Models.Collection[]): Promise<void>;
-    getDatabasesByIds(ids: string[]): Promise<Models.Database[]>;
+    getDatabasesByIds(ids: string[]): Promise<Models.Database[] | undefined>;
     wipeOtherDatabases(databasesToKeep: Models.Database[]): Promise<void>;
     wipeUsers(): Promise<void>;
     backupDatabase(database: Models.Database): Promise<void>;
@@ -54,7 +58,7 @@ export declare class UtilsController {
     importData(options?: SetupOptions): Promise<void>;
     synchronizeConfigurations(databases?: Models.Database[], config?: AppwriteConfig): Promise<void>;
     syncDb(databases?: Models.Database[], collections?: Models.Collection[]): Promise<void>;
-    getAppwriteFolderPath(): string;
+    getAppwriteFolderPath(): string | undefined;
     transferData(options: TransferOptions): Promise<void>;
     updateFunctionSpecifications(functionId: string, specification: Specification): Promise<void>;
 }

package/dist/utilsController.js

@@ -28,37 +28,87 @@ export class UtilsController {
     converterDefinitions = converterFunctions;
     validityRuleDefinitions = validationRules;
     afterImportActionsDefinitions = afterImportActions;
-    constructor(currentUserDir) {
+    constructor(currentUserDir, directConfig) {
         const basePath = currentUserDir;
-        const appwriteConfigFound = findAppwriteConfig(basePath);
-        if (!appwriteConfigFound) {
-            throw new Error("Failed to find appwriteConfig.ts");
+        if (directConfig) {
+            let hasErrors = false;
+            if (!directConfig.appwriteEndpoint) {
+                console.log(chalk.red("Appwrite endpoint is required"));
+                hasErrors = true;
+            }
+            if (!directConfig.appwriteProject) {
+                console.log(chalk.red("Appwrite project is required"));
+                hasErrors = true;
+            }
+            if (!directConfig.appwriteKey) {
+                console.log(chalk.red("Appwrite key is required"));
+                hasErrors = true;
+            }
+            if (!hasErrors) {
+                // Only set config if we have all required fields
+                this.appwriteFolderPath = basePath;
+                this.config = {
+                    appwriteEndpoint: directConfig.appwriteEndpoint,
+                    appwriteProject: directConfig.appwriteProject,
+                    appwriteKey: directConfig.appwriteKey,
+                    enableBackups: false,
+                    backupInterval: 0,
+                    backupRetention: 0,
+                    enableBackupCleanup: false,
+                    enableMockData: false,
+                    documentBucketId: "",
+                    usersCollectionName: "",
+                    databases: [],
+                    buckets: [],
+                    functions: [],
+                };
+            }
         }
-        this.appwriteConfigPath = appwriteConfigFound;
-        this.appwriteFolderPath = path.dirname(appwriteConfigFound);
-        if (!this.appwriteFolderPath) {
-            throw new Error("Failed to get appwriteFolderPath");
+        else {
+            // Try to find config file
+            const appwriteConfigFound = findAppwriteConfig(basePath);
+            if (!appwriteConfigFound) {
+                console.log(chalk.yellow("No appwriteConfig.ts found and no direct configuration provided"));
+                return;
+            }
+            this.appwriteConfigPath = appwriteConfigFound;
+            this.appwriteFolderPath = path.dirname(appwriteConfigFound);
         }
     }
     async init() {
         if (!this.config) {
-            console.log("Initializing appwrite client & loading config...");
-            this.config = await loadConfig(this.appwriteFolderPath);
-            if (!this.config) {
-                throw new Error("Failed to load config");
+            if (this.appwriteFolderPath && this.appwriteConfigPath) {
+                console.log("Loading config from file...");
+                this.config = await loadConfig(this.appwriteFolderPath);
+                if (!this.config) {
+                    console.log(chalk.red("Failed to load config from file"));
+                    return;
+                }
+            }
+            else {
+                console.log(chalk.red("No configuration available"));
+                return;
             }
-            this.appwriteServer = new Client();
-            this.appwriteServer
-                .setEndpoint(this.config.appwriteEndpoint)
-                .setProject(this.config.appwriteProject)
-                .setKey(this.config.appwriteKey);
-            this.database = new Databases(this.appwriteServer);
-            this.storage = new Storage(this.appwriteServer);
-            this.config.appwriteClient = this.appwriteServer;
         }
+        this.appwriteServer = new Client();
+        this.appwriteServer
+            .setEndpoint(this.config.appwriteEndpoint)
+            .setProject(this.config.appwriteProject)
+            .setKey(this.config.appwriteKey);
+        this.database = new Databases(this.appwriteServer);
+        this.storage = new Storage(this.appwriteServer);
+        this.config.appwriteClient = this.appwriteServer;
     }
     async reloadConfig() {
+        if (!this.appwriteFolderPath) {
+            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            return;
+        }
         this.config = await loadConfig(this.appwriteFolderPath);
+        if (!this.config) {
+            console.log(chalk.red("Failed to load config"));
+            return;
+        }
         this.appwriteServer = new Client();
         this.appwriteServer
             .setEndpoint(this.config.appwriteEndpoint)
@@ -70,36 +120,48 @@ export class UtilsController {
     }
     async setupMigrationDatabase() {
         await this.init();
-        if (!this.config)
-            throw new Error("Config not initialized");
+        if (!this.config) {
+            console.log(chalk.red("Config not initialized"));
+            return;
+        }
         await setupMigrationDatabase(this.config);
     }
     async ensureDatabaseConfigBucketsExist(databases = []) {
         await this.init();
-        if (!this.storage)
-            throw new Error("Storage not initialized");
-        if (!this.config)
-            throw new Error("Config not initialized");
+        if (!this.storage) {
+            console.log(chalk.red("Storage not initialized"));
+            return;
+        }
+        if (!this.config) {
+            console.log(chalk.red("Config not initialized"));
+            return;
+        }
         await ensureDatabaseConfigBucketsExist(this.storage, this.config, databases);
     }
     async ensureDatabasesExist(databases) {
         await this.init();
-        if (!this.config)
-            throw new Error("Config not initialized");
+        if (!this.config) {
+            console.log(chalk.red("Config not initialized"));
+            return;
+        }
         await this.setupMigrationDatabase();
         await this.ensureDatabaseConfigBucketsExist(databases);
         await ensureDatabasesExist(this.config, databases);
     }
     async ensureCollectionsExist(database, collections) {
         await this.init();
-        if (!this.config)
-            throw new Error("Config not initialized");
+        if (!this.config) {
+            console.log(chalk.red("Config not initialized"));
+            return;
+        }
         await ensureCollectionsExist(this.config, database, collections);
     }
     async getDatabasesByIds(ids) {
         await this.init();
-        if (!this.database)
-            throw new Error("Database not initialized");
+        if (!this.database) {
+            console.log(chalk.red("Database not initialized"));
+            return;
+        }
         if (ids.length === 0)
             return [];
         const dbs = await this.database.list([
@@ -110,36 +172,50 @@ export class UtilsController {
     }
     async wipeOtherDatabases(databasesToKeep) {
         await this.init();
-        if (!this.database)
-            throw new Error("Database not initialized");
+        if (!this.database) {
+            console.log(chalk.red("Database not initialized"));
+            return;
+        }
         await wipeOtherDatabases(this.database, databasesToKeep);
     }
     async wipeUsers() {
         await this.init();
-        if (!this.config || !this.database)
-            throw new Error("Config or database not initialized");
+        if (!this.config || !this.database) {
+            console.log(chalk.red("Config or database not initialized"));
+            return;
+        }
         const usersController = new UsersController(this.config, this.database);
         await usersController.wipeUsers();
     }
     async backupDatabase(database) {
         await this.init();
-        if (!this.database || !this.storage || !this.config)
-            throw new Error("Database, storage, or config not initialized");
+        if (!this.database || !this.storage || !this.config) {
+            console.log(chalk.red("Database, storage, or config not initialized"));
+            return;
+        }
         await backupDatabase(this.config, this.database, database.$id, this.storage);
     }
     async listAllFunctions() {
         await this.init();
-        if (!this.appwriteServer)
-            throw new Error("Appwrite server not initialized");
+        if (!this.appwriteServer) {
+            console.log(chalk.red("Appwrite server not initialized"));
+            return [];
+        }
         const { functions } = await listFunctions(this.appwriteServer, [
             Query.limit(1000),
         ]);
         return functions;
     }
     async findFunctionDirectories() {
+        if (!this.appwriteFolderPath) {
+            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            return new Map();
+        }
         const functionsDir = findFunctionsDir(this.appwriteFolderPath);
-        if (!functionsDir)
+        if (!functionsDir) {
+            console.log(chalk.red("Failed to find functions directory"));
             return new Map();
+        }
         const functionDirMap = new Map();
         const entries = fs.readdirSync(functionsDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -158,19 +234,25 @@ export class UtilsController {
     }
     async deployFunction(functionName, functionPath, functionConfig) {
         await this.init();
-        if (!this.appwriteServer)
-            throw new Error("Appwrite server not initialized");
+        if (!this.appwriteServer) {
+            console.log(chalk.red("Appwrite server not initialized"));
+            return;
+        }
         if (!functionConfig) {
             functionConfig = this.config?.functions?.find((f) => f.name === functionName);
         }
-        if (!functionConfig)
-            throw new Error(`Function ${functionName} not found in config`);
+        if (!functionConfig) {
+            console.log(chalk.red(`Function ${functionName} not found in config`));
+            return;
+        }
         await deployLocalFunction(this.appwriteServer, functionName, functionConfig, functionPath);
     }
     async syncFunctions() {
         await this.init();
-        if (!this.appwriteServer)
-            throw new Error("Appwrite server not initialized");
+        if (!this.appwriteServer) {
+            console.log(chalk.red("Appwrite server not initialized"));
+            return;
+        }
         const localFunctions = this.config?.functions || [];
         const remoteFunctions = await listFunctions(this.appwriteServer, [
             Query.limit(1000),
@@ -243,36 +325,62 @@ export class UtilsController {
     }
     async generateSchemas() {
         await this.init();
-        if (!this.config)
-            throw new Error("Config not initialized");
+        if (!this.config) {
+            console.log(chalk.red("Config not initialized"));
+            return;
+        }
+        if (!this.appwriteFolderPath) {
+            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            return;
+        }
         await generateSchemas(this.config, this.appwriteFolderPath);
     }
     async importData(options = {}) {
         await this.init();
-        if (!this.database)
-            throw new Error("Database not initialized");
-        if (!this.storage)
-            throw new Error("Storage not initialized");
-        if (!this.config)
-            throw new Error("Config not initialized");
+        if (!this.database) {
+            console.log(chalk.red("Database not initialized"));
+            return;
+        }
+        if (!this.storage) {
+            console.log(chalk.red("Storage not initialized"));
+            return;
+        }
+        if (!this.config) {
+            console.log(chalk.red("Config not initialized"));
+            return;
+        }
+        if (!this.appwriteFolderPath) {
+            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            return;
+        }
         const importDataActions = new ImportDataActions(this.database, this.storage, this.config, this.converterDefinitions, this.validityRuleDefinitions, this.afterImportActionsDefinitions);
         const importController = new ImportController(this.config, this.database, this.storage, this.appwriteFolderPath, importDataActions, options, options.databases);
         await importController.run(options.collections);
     }
     async synchronizeConfigurations(databases, config) {
         await this.init();
-        if (!this.storage)
-            throw new Error("Storage not initialized");
+        if (!this.storage) {
+            console.log(chalk.red("Storage not initialized"));
+            return;
+        }
         const configToUse = config || this.config;
-        if (!configToUse)
-            throw new Error("Config not initialized");
+        if (!configToUse) {
+            console.log(chalk.red("Config not initialized"));
+            return;
+        }
+        if (!this.appwriteFolderPath) {
+            console.log(chalk.red("Failed to get appwriteFolderPath"));
+            return;
+        }
         const appwriteToX = new AppwriteToX(configToUse, this.appwriteFolderPath, this.storage);
         await appwriteToX.toSchemas(databases);
     }
     async syncDb(databases = [], collections = []) {
         await this.init();
-        if (!this.database)
-            throw new Error("Database not initialized");
+        if (!this.database) {
+            console.log(chalk.red("Database not initialized"));
+            return;
+        }
         if (databases.length === 0) {
             const allDatabases = await fetchAllDatabases(this.database);
             databases = allDatabases;
@@ -290,13 +398,15 @@ export class UtilsController {
         let sourceDatabases = [];
         let targetDatabases = [];
         if (!sourceClient) {
-            throw new Error("Source database not initialized");
+            console.log(chalk.red("Source database not initialized"));
+            return;
         }
         if (options.isRemote) {
             if (!options.transferEndpoint ||
                 !options.transferProject ||
                 !options.transferKey) {
-                throw new Error("Remote transfer options are missing");
+                console.log(chalk.red("Remote transfer options are missing"));
+                return;
             }
             const remoteClient = getClient(options.transferEndpoint, options.transferProject, options.transferKey);
             targetClient = new Databases(remoteClient);
@@ -312,7 +422,8 @@ export class UtilsController {
             const fromDb = sourceDatabases.find((db) => db.$id === options.fromDb.$id);
             const targetDb = targetDatabases.find((db) => db.$id === options.targetDb.$id);
             if (!fromDb || !targetDb) {
-                throw new Error("Source or target database not found");
+                console.log(chalk.red("Source or target database not found"));
+                return;
             }
             if (options.isRemote && targetClient) {
                 await transferDatabaseLocalToRemote(sourceClient, options.transferEndpoint, options.transferProject, options.transferKey, fromDb.$id, targetDb.$id);
@@ -326,7 +437,8 @@ export class UtilsController {
                 console.log(chalk.yellow("User transfer is only supported for remote transfers. Skipping..."));
             }
             else if (!this.appwriteServer) {
-                throw new Error("Appwrite server not initialized");
+                console.log(chalk.red("Appwrite server not initialized"));
+                return;
             }
             else {
                 console.log(chalk.blue("Starting user transfer..."));

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

package/src/interactiveCLI.ts

@@ -159,9 +159,13 @@ export class InteractiveCLI {
     }
   }
 
-  private async initControllerIfNeeded(): Promise<void> {
+  private async initControllerIfNeeded(directConfig?: {
+    appwriteEndpoint: string;
+    appwriteProject: string;
+    appwriteKey: string;
+  }): Promise<void> {
     if (!this.controller) {
-      this.controller = new UtilsController(this.currentDir);
+      this.controller = new UtilsController(this.currentDir, directConfig);
       await this.controller.init();
     }
   }
@@ -522,7 +526,7 @@ export class InteractiveCLI {
         functionConfig.dirPath,
         // 2. Appwrite config folder/functions/name
         join(
-          this.controller.getAppwriteFolderPath(),
+          this.controller.getAppwriteFolderPath()!,
           "functions",
           functionNameLower
         ),
@@ -553,7 +557,7 @@ export class InteractiveCLI {
 
         // Search in both appwrite config directory and current working directory
         functionPath = await this.findFunctionInSubdirectories(
-          [this.controller.getAppwriteFolderPath(), process.cwd()],
+          [this.controller.getAppwriteFolderPath()!, process.cwd()],
           functionNameLower
         );
       }
@@ -576,7 +580,7 @@ export class InteractiveCLI {
               await downloadLatestFunctionDeployment(
                 this.controller.appwriteServer!,
                 functionConfig.$id,
-                join(this.controller.getAppwriteFolderPath(), "functions")
+                join(this.controller.getAppwriteFolderPath()!, "functions")
               );
             console.log(
               chalk.green(`✨ Function downloaded to ${downloadedPath}`)
@@ -1140,7 +1144,7 @@ export class InteractiveCLI {
         if (hasLocal && hasRemote) {
           // First try to find the function locally
           let functionPath = join(
-            this.controller!.getAppwriteFolderPath(),
+            this.controller!.getAppwriteFolderPath()!,
             "functions",
             func.name
           );
@@ -1152,7 +1156,7 @@ export class InteractiveCLI {
               )
             );
             const foundPath = await this.findFunctionInSubdirectories(
-              [this.controller!.getAppwriteFolderPath(), process.cwd()],
+              [this.controller!.getAppwriteFolderPath()!, process.cwd()],
               func.name
             );
 
@@ -1191,7 +1195,7 @@ export class InteractiveCLI {
             await downloadLatestFunctionDeployment(
               this.controller!.appwriteServer!,
               func.$id,
-              join(this.controller!.getAppwriteFolderPath(), "functions")
+              join(this.controller!.getAppwriteFolderPath()!, "functions")
             );
           } else if (preference === "config") {
             const remoteFunction = await getFunction(
@@ -1236,14 +1240,14 @@ export class InteractiveCLI {
         } else if (hasLocal) {
           // Similar check for local-only functions
           let functionPath = join(
-            this.controller!.getAppwriteFolderPath(),
+            this.controller!.getAppwriteFolderPath()!,
             "functions",
             func.name
           );
 
           if (!fs.existsSync(functionPath)) {
             const foundPath = await this.findFunctionInSubdirectories(
-              [this.controller!.getAppwriteFolderPath(), process.cwd()],
+              [this.controller!.getAppwriteFolderPath()!, process.cwd()],
               func.name
             );
 
@@ -1294,7 +1298,7 @@ export class InteractiveCLI {
             await downloadLatestFunctionDeployment(
               this.controller!.appwriteServer!,
               func.$id,
-              join(this.controller!.getAppwriteFolderPath(), "functions")
+              join(this.controller!.getAppwriteFolderPath()!, "functions")
             );
           } else if (action === "config") {
             const remoteFunction = await getFunction(
@@ -1336,7 +1340,7 @@ export class InteractiveCLI {
       // Update schemas after all changes
       const schemaGenerator = new SchemaGenerator(
         this.controller!.config!,
-        this.controller!.getAppwriteFolderPath()
+        this.controller!.getAppwriteFolderPath()!
       );
       schemaGenerator.updateConfig(this.controller!.config!);
     }

package/src/main.ts

@@ -202,7 +202,15 @@ async function main() {
     const cli = new InteractiveCLI(process.cwd());
     await cli.run();
   } else {
-    const controller = new UtilsController(process.cwd());
+    const directConfig =
+      argv.endpoint || argv.projectId || argv.apiKey
+        ? {
+            appwriteEndpoint: argv.endpoint,
+            appwriteProject: argv.projectId,
+            appwriteKey: argv.apiKey,
+          }
+        : undefined;
+    const controller = new UtilsController(process.cwd(), directConfig);
     await controller.init();
 
     if (argv.setup) {
@@ -210,6 +218,11 @@ async function main() {
       return;
     }
 
+    if (!controller.config) {
+      console.log(chalk.red("No Appwrite connection found"));
+      return;
+    }
+
     const parsedArgv = argv;
 
     const options: SetupOptions = {
@@ -372,8 +385,13 @@ async function main() {
             `Starting database transfer from ${parsedArgv.fromDbId} to ${parsedArgv.toDbId}`
           )
         );
-        fromDb = (await controller.getDatabasesByIds([parsedArgv.fromDbId]))[0];
-
+        fromDb = (
+          await controller.getDatabasesByIds([parsedArgv.fromDbId])
+        )?.[0];
+        if (!fromDb) {
+          console.log(chalk.red("Source database not found"));
+          return;
+        }
         if (isRemote) {
           if (
             !parsedArgv.remoteEndpoint ||
@@ -391,12 +409,21 @@ async function main() {
           targetStorage = new Storage(remoteClient);
           const remoteDbs = await fetchAllDatabases(targetDatabases);
           toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
+          if (!toDb) {
+            console.log(chalk.red("Target database not found"));
+            return;
+          }
         } else {
-          toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))[0];
+          toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))?.[0];
+          if (!toDb) {
+            console.log(chalk.red("Target database not found"));
+            return;
+          }
         }
 
         if (!fromDb || !toDb) {
-          throw new Error("Source or target database not found");
+          console.log(chalk.red("Source or target database not found"));
+          return;
         }
       }
 

package/src/utilsController.ts

@@ -82,8 +82,8 @@ export interface SetupOptions {
 }
 
 export class UtilsController {
-  private appwriteFolderPath: string;
-  private appwriteConfigPath: string;
+  private appwriteFolderPath?: string;
+  private appwriteConfigPath?: string;
   public config?: AppwriteConfig;
   public appwriteServer?: Client;
   public database?: Databases;
@@ -92,39 +92,101 @@ export class UtilsController {
   public validityRuleDefinitions: ValidationRules = validationRules;
   public afterImportActionsDefinitions: AfterImportActions = afterImportActions;
 
-  constructor(currentUserDir: string) {
-    const basePath = currentUserDir;
-    const appwriteConfigFound = findAppwriteConfig(basePath);
-    if (!appwriteConfigFound) {
-      throw new Error("Failed to find appwriteConfig.ts");
+  constructor(
+    currentUserDir: string,
+    directConfig?: {
+      appwriteEndpoint?: string;
+      appwriteProject?: string;
+      appwriteKey?: string;
     }
-    this.appwriteConfigPath = appwriteConfigFound;
-    this.appwriteFolderPath = path.dirname(appwriteConfigFound);
-    if (!this.appwriteFolderPath) {
-      throw new Error("Failed to get appwriteFolderPath");
+  ) {
+    const basePath = currentUserDir;
+
+    if (directConfig) {
+      let hasErrors = false;
+      if (!directConfig.appwriteEndpoint) {
+        console.log(chalk.red("Appwrite endpoint is required"));
+        hasErrors = true;
+      }
+      if (!directConfig.appwriteProject) {
+        console.log(chalk.red("Appwrite project is required"));
+        hasErrors = true;
+      }
+      if (!directConfig.appwriteKey) {
+        console.log(chalk.red("Appwrite key is required"));
+        hasErrors = true;
+      }
+      if (!hasErrors) {
+        // Only set config if we have all required fields
+        this.appwriteFolderPath = basePath;
+        this.config = {
+          appwriteEndpoint: directConfig.appwriteEndpoint!,
+          appwriteProject: directConfig.appwriteProject!,
+          appwriteKey: directConfig.appwriteKey!,
+          enableBackups: false,
+          backupInterval: 0,
+          backupRetention: 0,
+          enableBackupCleanup: false,
+          enableMockData: false,
+          documentBucketId: "",
+          usersCollectionName: "",
+          databases: [],
+          buckets: [],
+          functions: [],
+        };
+      }
+    } else {
+      // Try to find config file
+      const appwriteConfigFound = findAppwriteConfig(basePath);
+      if (!appwriteConfigFound) {
+        console.log(
+          chalk.yellow(
+            "No appwriteConfig.ts found and no direct configuration provided"
+          )
+        );
+        return;
+      }
+      this.appwriteConfigPath = appwriteConfigFound;
+      this.appwriteFolderPath = path.dirname(appwriteConfigFound);
     }
   }
 
   async init() {
     if (!this.config) {
-      console.log("Initializing appwrite client & loading config...");
-      this.config = await loadConfig(this.appwriteFolderPath);
-      if (!this.config) {
-        throw new Error("Failed to load config");
+      if (this.appwriteFolderPath && this.appwriteConfigPath) {
+        console.log("Loading config from file...");
+        this.config = await loadConfig(this.appwriteFolderPath);
+        if (!this.config) {
+          console.log(chalk.red("Failed to load config from file"));
+          return;
+        }
+      } else {
+        console.log(chalk.red("No configuration available"));
+        return;
       }
-      this.appwriteServer = new Client();
-      this.appwriteServer
-        .setEndpoint(this.config.appwriteEndpoint)
-        .setProject(this.config.appwriteProject)
-        .setKey(this.config.appwriteKey);
-      this.database = new Databases(this.appwriteServer);
-      this.storage = new Storage(this.appwriteServer);
-      this.config.appwriteClient = this.appwriteServer;
     }
+
+    this.appwriteServer = new Client();
+    this.appwriteServer
+      .setEndpoint(this.config.appwriteEndpoint)
+      .setProject(this.config.appwriteProject)
+      .setKey(this.config.appwriteKey);
+
+    this.database = new Databases(this.appwriteServer);
+    this.storage = new Storage(this.appwriteServer);
+    this.config.appwriteClient = this.appwriteServer;
   }
 
   async reloadConfig() {
+    if (!this.appwriteFolderPath) {
+      console.log(chalk.red("Failed to get appwriteFolderPath"));
+      return;
+    }
     this.config = await loadConfig(this.appwriteFolderPath);
+    if (!this.config) {
+      console.log(chalk.red("Failed to load config"));
+      return;
+    }
     this.appwriteServer = new Client();
     this.appwriteServer
       .setEndpoint(this.config.appwriteEndpoint)
@@ -137,14 +199,23 @@ export class UtilsController {
 
   async setupMigrationDatabase() {
     await this.init();
-    if (!this.config) throw new Error("Config not initialized");
+    if (!this.config) {
+      console.log(chalk.red("Config not initialized"));
+      return;
+    }
     await setupMigrationDatabase(this.config);
   }
 
   async ensureDatabaseConfigBucketsExist(databases: Models.Database[] = []) {
     await this.init();
-    if (!this.storage) throw new Error("Storage not initialized");
-    if (!this.config) throw new Error("Config not initialized");
+    if (!this.storage) {
+      console.log(chalk.red("Storage not initialized"));
+      return;
+    }
+    if (!this.config) {
+      console.log(chalk.red("Config not initialized"));
+      return;
+    }
     await ensureDatabaseConfigBucketsExist(
       this.storage,
       this.config,
@@ -154,7 +225,10 @@ export class UtilsController {
 
   async ensureDatabasesExist(databases?: Models.Database[]) {
     await this.init();
-    if (!this.config) throw new Error("Config not initialized");
+    if (!this.config) {
+      console.log(chalk.red("Config not initialized"));
+      return;
+    }
     await this.setupMigrationDatabase();
     await this.ensureDatabaseConfigBucketsExist(databases);
     await ensureDatabasesExist(this.config, databases);
@@ -165,13 +239,19 @@ export class UtilsController {
     collections?: Models.Collection[]
   ) {
     await this.init();
-    if (!this.config) throw new Error("Config not initialized");
+    if (!this.config) {
+      console.log(chalk.red("Config not initialized"));
+      return;
+    }
     await ensureCollectionsExist(this.config, database, collections);
   }
 
   async getDatabasesByIds(ids: string[]) {
     await this.init();
-    if (!this.database) throw new Error("Database not initialized");
+    if (!this.database) {
+      console.log(chalk.red("Database not initialized"));
+      return;
+    }
     if (ids.length === 0) return [];
     const dbs = await this.database.list([
       Query.limit(500),
@@ -182,22 +262,29 @@ export class UtilsController {
 
   async wipeOtherDatabases(databasesToKeep: Models.Database[]) {
     await this.init();
-    if (!this.database) throw new Error("Database not initialized");
+    if (!this.database) {
+      console.log(chalk.red("Database not initialized"));
+      return;
+    }
     await wipeOtherDatabases(this.database, databasesToKeep);
   }
 
   async wipeUsers() {
     await this.init();
-    if (!this.config || !this.database)
-      throw new Error("Config or database not initialized");
+    if (!this.config || !this.database) {
+      console.log(chalk.red("Config or database not initialized"));
+      return;
+    }
     const usersController = new UsersController(this.config, this.database);
     await usersController.wipeUsers();
   }
 
   async backupDatabase(database: Models.Database) {
     await this.init();
-    if (!this.database || !this.storage || !this.config)
-      throw new Error("Database, storage, or config not initialized");
+    if (!this.database || !this.storage || !this.config) {
+      console.log(chalk.red("Database, storage, or config not initialized"));
+      return;
+    }
     await backupDatabase(
       this.config,
       this.database,
@@ -208,8 +295,10 @@ export class UtilsController {
 
   async listAllFunctions() {
     await this.init();
-    if (!this.appwriteServer)
-      throw new Error("Appwrite server not initialized");
+    if (!this.appwriteServer) {
+      console.log(chalk.red("Appwrite server not initialized"));
+      return [];
+    }
     const { functions } = await listFunctions(this.appwriteServer, [
       Query.limit(1000),
     ]);
@@ -217,8 +306,15 @@ export class UtilsController {
   }
 
   async findFunctionDirectories() {
+    if (!this.appwriteFolderPath) {
+      console.log(chalk.red("Failed to get appwriteFolderPath"));
+      return new Map();
+    }
     const functionsDir = findFunctionsDir(this.appwriteFolderPath);
-    if (!functionsDir) return new Map();
+    if (!functionsDir) {
+      console.log(chalk.red("Failed to find functions directory"));
+      return new Map();
+    }
 
     const functionDirMap = new Map<string, string>();
     const entries = fs.readdirSync(functionsDir, { withFileTypes: true });
@@ -246,16 +342,20 @@ export class UtilsController {
     functionConfig?: AppwriteFunction
   ) {
     await this.init();
-    if (!this.appwriteServer)
-      throw new Error("Appwrite server not initialized");
+    if (!this.appwriteServer) {
+      console.log(chalk.red("Appwrite server not initialized"));
+      return;
+    }
 
     if (!functionConfig) {
       functionConfig = this.config?.functions?.find(
         (f) => f.name === functionName
       );
     }
-    if (!functionConfig)
-      throw new Error(`Function ${functionName} not found in config`);
+    if (!functionConfig) {
+      console.log(chalk.red(`Function ${functionName} not found in config`));
+      return;
+    }
 
     await deployLocalFunction(
       this.appwriteServer,
@@ -267,8 +367,10 @@ export class UtilsController {
 
   async syncFunctions() {
     await this.init();
-    if (!this.appwriteServer)
-      throw new Error("Appwrite server not initialized");
+    if (!this.appwriteServer) {
+      console.log(chalk.red("Appwrite server not initialized"));
+      return;
+    }
 
     const localFunctions = this.config?.functions || [];
     const remoteFunctions = await listFunctions(this.appwriteServer, [
@@ -365,15 +467,35 @@ export class UtilsController {
 
   async generateSchemas() {
     await this.init();
-    if (!this.config) throw new Error("Config not initialized");
+    if (!this.config) {
+      console.log(chalk.red("Config not initialized"));
+      return;
+    }
+    if (!this.appwriteFolderPath) {
+      console.log(chalk.red("Failed to get appwriteFolderPath"));
+      return;
+    }
     await generateSchemas(this.config, this.appwriteFolderPath);
   }
 
   async importData(options: SetupOptions = {}) {
     await this.init();
-    if (!this.database) throw new Error("Database not initialized");
-    if (!this.storage) throw new Error("Storage not initialized");
-    if (!this.config) throw new Error("Config not initialized");
+    if (!this.database) {
+      console.log(chalk.red("Database not initialized"));
+      return;
+    }
+    if (!this.storage) {
+      console.log(chalk.red("Storage not initialized"));
+      return;
+    }
+    if (!this.config) {
+      console.log(chalk.red("Config not initialized"));
+      return;
+    }
+    if (!this.appwriteFolderPath) {
+      console.log(chalk.red("Failed to get appwriteFolderPath"));
+      return;
+    }
 
     const importDataActions = new ImportDataActions(
       this.database,
@@ -401,9 +523,19 @@ export class UtilsController {
     config?: AppwriteConfig
   ) {
     await this.init();
-    if (!this.storage) throw new Error("Storage not initialized");
+    if (!this.storage) {
+      console.log(chalk.red("Storage not initialized"));
+      return;
+    }
     const configToUse = config || this.config;
-    if (!configToUse) throw new Error("Config not initialized");
+    if (!configToUse) {
+      console.log(chalk.red("Config not initialized"));
+      return;
+    }
+    if (!this.appwriteFolderPath) {
+      console.log(chalk.red("Failed to get appwriteFolderPath"));
+      return;
+    }
     const appwriteToX = new AppwriteToX(
       configToUse,
       this.appwriteFolderPath,
@@ -417,7 +549,10 @@ export class UtilsController {
     collections: Models.Collection[] = []
   ) {
     await this.init();
-    if (!this.database) throw new Error("Database not initialized");
+    if (!this.database) {
+      console.log(chalk.red("Database not initialized"));
+      return;
+    }
     if (databases.length === 0) {
       const allDatabases = await fetchAllDatabases(this.database);
       databases = allDatabases;
@@ -438,7 +573,8 @@ export class UtilsController {
     let targetDatabases: Models.Database[] = [];
 
     if (!sourceClient) {
-      throw new Error("Source database not initialized");
+      console.log(chalk.red("Source database not initialized"));
+      return;
     }
 
     if (options.isRemote) {
@@ -447,7 +583,8 @@ export class UtilsController {
         !options.transferProject ||
         !options.transferKey
       ) {
-        throw new Error("Remote transfer options are missing");
+        console.log(chalk.red("Remote transfer options are missing"));
+        return;
       }
 
       const remoteClient = getClient(
@@ -474,7 +611,8 @@ export class UtilsController {
       );
 
       if (!fromDb || !targetDb) {
-        throw new Error("Source or target database not found");
+        console.log(chalk.red("Source or target database not found"));
+        return;
       }
 
       if (options.isRemote && targetClient) {
@@ -503,7 +641,8 @@ export class UtilsController {
           )
         );
       } else if (!this.appwriteServer) {
-        throw new Error("Appwrite server not initialized");
+        console.log(chalk.red("Appwrite server not initialized"));
+        return;
       } else {
         console.log(chalk.blue("Starting user transfer..."));
         const localUsers = new Users(this.appwriteServer);