@njdamstra/appwrite-utils-cli 1.8.9

package/dist/utilsController.js

@@ -0,0 +1,863 @@
+import { Client, Databases, Query, Storage, Users, } from "node-appwrite";
+import {} from "@njdamstra/appwrite-utils";
+import { findAppwriteConfig, findFunctionsDir, } from "./utils/loadConfigs.js";
+import { normalizeFunctionName, validateFunctionDirectory } from './functions/pathResolution.js';
+import { UsersController } from "./users/methods.js";
+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, 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";
+import { converterFunctions, validationRules, } from "@njdamstra/appwrite-utils";
+import { afterImportActions } from "./migrations/afterImportActions.js";
+import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote, } from "./migrations/transfer.js";
+import { getClient, getClientWithAuth } from "./utils/getClientFromConfig.js";
+import { getAdapterFromConfig } from "./utils/getClientFromConfig.js";
+import { hasSessionAuth, findSessionByEndpointAndProject, isValidSessionCookie } from "./utils/sessionAuth.js";
+import { fetchAllDatabases } from "./databases/methods.js";
+import { listFunctions, updateFunctionSpecifications, } from "./functions/methods.js";
+import chalk from "chalk";
+import { deployLocalFunction } from "./functions/deployments.js";
+import fs from "node:fs";
+import { configureLogging, updateLogger, logger } from "./shared/logging.js";
+import { MessageFormatter, Messages } from "./shared/messageFormatter.js";
+import { SchemaGenerator } from "./shared/schemaGenerator.js";
+import { findYamlConfig } from "./config/yamlConfig.js";
+import { createImportSchemas } from "./migrations/yaml/generateImportSchemas.js";
+import { validateCollectionsTablesConfig, reportValidationResults, validateWithStrictMode } from "./config/configValidation.js";
+import { ConfigManager } from "./config/ConfigManager.js";
+import { ClientFactory } from "./utils/ClientFactory.js";
+export class UtilsController {
+    // ──────────────────────────────────────────────────
+    // SINGLETON PATTERN
+    // ──────────────────────────────────────────────────
+    static instance = null;
+    isInitialized = false;
+    /**
+     * Get the UtilsController singleton instance
+     */
+    static getInstance(currentUserDir, directConfig) {
+        // Clear instance if currentUserDir has changed
+        if (UtilsController.instance &&
+            UtilsController.instance.currentUserDir !== currentUserDir) {
+            logger.debug(`Clearing singleton: currentUserDir changed from ${UtilsController.instance.currentUserDir} to ${currentUserDir}`, { prefix: "UtilsController" });
+            UtilsController.clearInstance();
+        }
+        // Clear instance if directConfig endpoint or project has changed
+        if (UtilsController.instance && directConfig) {
+            const existingConfig = UtilsController.instance.config;
+            if (existingConfig) {
+                const endpointChanged = directConfig.appwriteEndpoint &&
+                    existingConfig.appwriteEndpoint !== directConfig.appwriteEndpoint;
+                const projectChanged = directConfig.appwriteProject &&
+                    existingConfig.appwriteProject !== directConfig.appwriteProject;
+                if (endpointChanged || projectChanged) {
+                    logger.debug("Clearing singleton: endpoint or project changed", { prefix: "UtilsController" });
+                    UtilsController.clearInstance();
+                }
+            }
+        }
+        if (!UtilsController.instance) {
+            UtilsController.instance = new UtilsController(currentUserDir, directConfig);
+        }
+        return UtilsController.instance;
+    }
+    /**
+     * Clear the singleton instance (useful for testing)
+     */
+    static clearInstance() {
+        UtilsController.instance = null;
+    }
+    // ──────────────────────────────────────────────────
+    // INSTANCE FIELDS
+    // ──────────────────────────────────────────────────
+    appwriteFolderPath;
+    appwriteConfigPath;
+    currentUserDir;
+    config;
+    appwriteServer;
+    database;
+    storage;
+    adapter;
+    converterDefinitions = converterFunctions;
+    validityRuleDefinitions = validationRules;
+    afterImportActionsDefinitions = afterImportActions;
+    constructor(currentUserDir, directConfig) {
+        this.currentUserDir = currentUserDir;
+        const basePath = currentUserDir;
+        if (directConfig) {
+            let hasErrors = false;
+            if (!directConfig.appwriteEndpoint) {
+                MessageFormatter.error("Appwrite endpoint is required", undefined, { prefix: "Config" });
+                hasErrors = true;
+            }
+            if (!directConfig.appwriteProject) {
+                MessageFormatter.error("Appwrite project is required", undefined, { prefix: "Config" });
+                hasErrors = true;
+            }
+            // Check authentication: either API key or session auth is required
+            const hasValidSession = directConfig.appwriteEndpoint && directConfig.appwriteProject &&
+                hasSessionAuth(directConfig.appwriteEndpoint, directConfig.appwriteProject);
+            if (!directConfig.appwriteKey && !hasValidSession) {
+                MessageFormatter.error("Authentication required: provide an API key or login with 'appwrite login'", undefined, { prefix: "Config" });
+                hasErrors = true;
+            }
+            else if (!directConfig.appwriteKey && hasValidSession) {
+                MessageFormatter.info("Using session authentication (no API key required)", { prefix: "Auth" });
+            }
+            else if (directConfig.appwriteKey && hasValidSession) {
+                MessageFormatter.info("API key provided, session authentication also available", { prefix: "Auth" });
+            }
+            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 || "",
+                    appwriteClient: null,
+                    apiMode: "auto", // Default to auto-detect for dual API support
+                    authMethod: "auto", // Default to auto-detect authentication method
+                    enableBackups: false,
+                    backupInterval: 0,
+                    backupRetention: 0,
+                    enableBackupCleanup: false,
+                    enableMockData: false,
+                    documentBucketId: "",
+                    usersCollectionName: "",
+                    databases: [],
+                    buckets: [],
+                    functions: [],
+                    logging: {
+                        enabled: false,
+                        level: "info",
+                        console: false,
+                    },
+                };
+            }
+        }
+        else {
+            // Try to find config file
+            const appwriteConfigFound = findAppwriteConfig(basePath);
+            if (!appwriteConfigFound) {
+                MessageFormatter.warning("No appwriteConfig.ts found and no direct configuration provided", { prefix: "Config" });
+                return;
+            }
+            this.appwriteConfigPath = appwriteConfigFound;
+            this.appwriteFolderPath = appwriteConfigFound; // For YAML configs, findAppwriteConfig already returns the correct directory
+        }
+    }
+    async init(options = {}) {
+        const { validate = false, strictMode = false } = options;
+        const configManager = ConfigManager.getInstance();
+        // Load config if not already loaded
+        if (!configManager.hasConfig()) {
+            await configManager.loadConfig({
+                configDir: this.currentUserDir,
+                validate,
+                strictMode,
+            });
+        }
+        const config = configManager.getConfig();
+        // Configure logging based on config
+        if (config.logging) {
+            configureLogging(config.logging);
+            updateLogger();
+        }
+        // Create client and adapter (session already in config from ConfigManager)
+        const { client, adapter } = await ClientFactory.createFromConfig(config);
+        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();
+            const configApiMode = this.config.apiMode;
+            MessageFormatter.info(`Database adapter initialized (apiMode: ${apiMode}, config.apiMode: ${configApiMode})`, { prefix: "Adapter" });
+            this.isInitialized = true;
+        }
+        else {
+            logger.debug("Adapter reused from cache", { prefix: "UtilsController" });
+        }
+    }
+    async reloadConfig() {
+        const configManager = ConfigManager.getInstance();
+        // Session preservation is automatic in ConfigManager
+        const config = await configManager.reloadConfig();
+        // Configure logging based on updated config
+        if (config.logging) {
+            configureLogging(config.logging);
+            updateLogger();
+        }
+        // Recreate client and adapter
+        const { client, adapter } = await ClientFactory.createFromConfig(config);
+        this.appwriteServer = client;
+        this.adapter = adapter;
+        this.config = config;
+        this.database = new Databases(this.appwriteServer);
+        this.storage = new Storage(this.appwriteServer);
+        this.config.appwriteClient = this.appwriteServer;
+        logger.debug("Config reloaded, adapter refreshed", { prefix: "UtilsController" });
+    }
+    async ensureDatabaseConfigBucketsExist(databases = []) {
+        await this.init();
+        if (!this.storage) {
+            MessageFormatter.error("Storage not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (!this.config) {
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        await ensureDatabaseConfigBucketsExist(this.storage, this.config, databases);
+    }
+    async ensureDatabasesExist(databases) {
+        await this.init();
+        if (!this.config) {
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        await this.ensureDatabaseConfigBucketsExist(databases);
+        await ensureDatabasesExist(this.config, databases);
+    }
+    async ensureCollectionsExist(database, collections) {
+        await this.init();
+        if (!this.config) {
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        await ensureCollectionsExist(this.config, database, collections);
+    }
+    async getDatabasesByIds(ids) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (ids.length === 0)
+            return [];
+        const dbs = await this.database.list([
+            Query.limit(500),
+            Query.equal("$id", ids),
+        ]);
+        return dbs.databases;
+    }
+    async fetchAllBuckets() {
+        await this.init();
+        if (!this.storage) {
+            MessageFormatter.warning("Storage not initialized - buckets will be empty", { prefix: "Controller" });
+            return { buckets: [] };
+        }
+        try {
+            const result = await this.storage.listBuckets([
+                Query.limit(1000) // Increase limit to get all buckets
+            ]);
+            MessageFormatter.success(`Found ${result.buckets.length} buckets`, { prefix: "Controller" });
+            return result;
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to fetch buckets: ${error.message || error}`, error instanceof Error ? error : undefined, { prefix: "Controller" });
+            return { buckets: [] };
+        }
+    }
+    async wipeOtherDatabases(databasesToKeep) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        await wipeOtherDatabases(this.database, databasesToKeep);
+    }
+    async wipeUsers() {
+        await this.init();
+        if (!this.config || !this.database) {
+            MessageFormatter.error("Config or database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        const usersController = new UsersController(this.config, this.database);
+        await usersController.wipeUsers();
+    }
+    async backupDatabase(database, format = 'json') {
+        await this.init();
+        if (!this.database || !this.storage || !this.config) {
+            MessageFormatter.error("Database, storage, or config not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        await backupDatabase(this.config, this.database, database.$id, this.storage, format);
+    }
+    async listAllFunctions() {
+        await this.init();
+        if (!this.appwriteServer) {
+            MessageFormatter.error("Appwrite server not initialized", undefined, { prefix: "Controller" });
+            return [];
+        }
+        const { functions } = await listFunctions(this.appwriteServer, [
+            Query.limit(1000),
+        ]);
+        return functions;
+    }
+    async findFunctionDirectories() {
+        if (!this.appwriteFolderPath) {
+            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
+            return new Map();
+        }
+        const functionsDir = findFunctionsDir(this.appwriteFolderPath);
+        if (!functionsDir) {
+            MessageFormatter.error("Failed to find functions directory", undefined, { prefix: "Controller" });
+            return new Map();
+        }
+        const functionDirMap = new Map();
+        const entries = fs.readdirSync(functionsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const functionPath = path.join(functionsDir, entry.name);
+                // Validate it's a function directory
+                if (!validateFunctionDirectory(functionPath)) {
+                    continue; // Skip invalid directories
+                }
+                // Match with config functions using normalized names
+                if (this.config?.functions) {
+                    const normalizedEntryName = normalizeFunctionName(entry.name);
+                    const matchingFunc = this.config.functions.find((f) => normalizeFunctionName(f.name) === normalizedEntryName);
+                    if (matchingFunc) {
+                        functionDirMap.set(matchingFunc.name, functionPath);
+                    }
+                }
+            }
+        }
+        return functionDirMap;
+    }
+    async deployFunction(functionName, functionPath, functionConfig) {
+        await this.init();
+        if (!this.appwriteServer) {
+            MessageFormatter.error("Appwrite server not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (!functionConfig) {
+            functionConfig = this.config?.functions?.find((f) => f.name === functionName);
+        }
+        if (!functionConfig) {
+            MessageFormatter.error(`Function ${functionName} not found in config`, undefined, { prefix: "Controller" });
+            return;
+        }
+        await deployLocalFunction(this.appwriteServer, functionName, functionConfig, functionPath);
+    }
+    async syncFunctions() {
+        await this.init();
+        if (!this.appwriteServer) {
+            MessageFormatter.error("Appwrite server not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        const localFunctions = this.config?.functions || [];
+        const remoteFunctions = await listFunctions(this.appwriteServer, [
+            Query.limit(1000),
+        ]);
+        for (const localFunction of localFunctions) {
+            MessageFormatter.progress(`Syncing function ${localFunction.name}...`, { prefix: "Functions" });
+            await this.deployFunction(localFunction.name);
+        }
+        MessageFormatter.success("All functions synchronized successfully!", { prefix: "Functions" });
+    }
+    async wipeDatabase(database, wipeBucket = false) {
+        await this.init();
+        if (!this.database || !this.config)
+            throw new Error("Database not initialized");
+        try {
+            // Session is already in config from ConfigManager
+            const { adapter, apiMode } = await getAdapterFromConfig(this.config, false);
+            if (apiMode === 'tablesdb') {
+                await wipeAllTables(adapter, database.$id);
+            }
+            else {
+                await wipeDatabase(this.database, database.$id);
+            }
+        }
+        catch {
+            await wipeDatabase(this.database, database.$id);
+        }
+        if (wipeBucket) {
+            await this.wipeBucketFromDatabase(database);
+        }
+    }
+    async wipeBucketFromDatabase(database) {
+        // Check configured bucket in database config
+        const configuredBucket = this.config?.databases?.find((db) => db.$id === database.$id)?.bucket;
+        if (configuredBucket?.$id) {
+            await this.wipeDocumentStorage(configuredBucket.$id);
+        }
+        // Also check for document bucket ID pattern
+        if (this.config?.documentBucketId) {
+            const documentBucketId = `${this.config.documentBucketId}_${database.$id
+                .toLowerCase()
+                .trim()
+                .replace(/\s+/g, "")}`;
+            try {
+                await this.wipeDocumentStorage(documentBucketId);
+            }
+            catch (error) {
+                // Ignore if bucket doesn't exist
+                if (error?.type !== "storage_bucket_not_found") {
+                    throw error;
+                }
+            }
+        }
+    }
+    async wipeCollection(database, collection) {
+        await this.init();
+        if (!this.database || !this.config)
+            throw new Error("Database not initialized");
+        try {
+            // Session is already in config from ConfigManager
+            const { adapter, apiMode } = await getAdapterFromConfig(this.config, false);
+            if (apiMode === 'tablesdb') {
+                await wipeTableRows(adapter, database.$id, collection.$id);
+            }
+            else {
+                await wipeCollection(this.database, database.$id, collection.$id);
+            }
+        }
+        catch {
+            await wipeCollection(this.database, database.$id, collection.$id);
+        }
+    }
+    async wipeDocumentStorage(bucketId) {
+        await this.init();
+        if (!this.storage)
+            throw new Error("Storage not initialized");
+        await wipeDocumentStorage(this.storage, bucketId);
+    }
+    async createOrUpdateCollectionsForDatabases(databases, collections = []) {
+        await this.init();
+        if (!this.database || !this.config)
+            throw new Error("Database or config not initialized");
+        for (const database of databases) {
+            await this.createOrUpdateCollections(database, undefined, collections);
+        }
+    }
+    async createOrUpdateCollections(database, deletedCollections, collections = []) {
+        await this.init();
+        if (!this.database || !this.config)
+            throw new Error("Database or config not initialized");
+        // 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" });
+        }
+        // Ensure we don't carry state between databases in a multi-db push
+        // This resets processed sets and name->id mapping per database
+        try {
+            const { clearProcessingState } = await import('./shared/operationQueue.js');
+            clearProcessingState();
+        }
+        catch { }
+        // 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
+        if (!this.config) {
+            MessageFormatter.progress("Loading config from ConfigManager...", { prefix: "Config" });
+            try {
+                const configManager = ConfigManager.getInstance();
+                // Load config if not already loaded
+                if (!configManager.hasConfig()) {
+                    await configManager.loadConfig({
+                        configDir: this.currentUserDir,
+                        validate: false,
+                        strictMode: false,
+                    });
+                }
+                this.config = configManager.getConfig();
+                MessageFormatter.info("Config loaded successfully from ConfigManager", { prefix: "Config" });
+            }
+            catch (error) {
+                MessageFormatter.error("Failed to load config", error instanceof Error ? error : undefined, { prefix: "Config" });
+                return;
+            }
+        }
+        if (!this.appwriteFolderPath) {
+            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
+            return;
+        }
+        await generateSchemas(this.config, this.appwriteFolderPath);
+    }
+    async importData(options = {}) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (!this.storage) {
+            MessageFormatter.error("Storage not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (!this.config) {
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (!this.appwriteFolderPath) {
+            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
+            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, databaseSelections, bucketSelections) {
+        await this.init();
+        if (!this.storage) {
+            MessageFormatter.error("Storage not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        const configToUse = config || this.config;
+        if (!configToUse) {
+            MessageFormatter.error("Config not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (!this.appwriteFolderPath) {
+            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
+            return;
+        }
+        // If selections are provided, filter the databases accordingly
+        let filteredDatabases = databases;
+        if (databaseSelections && databaseSelections.length > 0) {
+            // Convert selections to Models.Database format
+            filteredDatabases = [];
+            const allDatabases = databases ? databases : await fetchAllDatabases(this.database);
+            for (const selection of databaseSelections) {
+                const database = allDatabases.find(db => db.$id === selection.databaseId);
+                if (database) {
+                    filteredDatabases.push(database);
+                }
+                else {
+                    MessageFormatter.warning(`Database with ID ${selection.databaseId} not found`, { prefix: "Controller" });
+                }
+            }
+            MessageFormatter.info(`Syncing ${filteredDatabases.length} selected databases out of ${allDatabases.length} available`, { prefix: "Controller" });
+        }
+        const appwriteToX = new AppwriteToX(configToUse, this.appwriteFolderPath, this.storage);
+        await appwriteToX.toSchemas(filteredDatabases);
+        // Update the controller's config with the synchronized collections
+        this.config = appwriteToX.updatedConfig;
+        // Write the updated config back to disk
+        const generator = new SchemaGenerator(this.config, this.appwriteFolderPath);
+        const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
+        const isYamlProject = !!yamlConfigPath;
+        await generator.updateConfig(this.config, isYamlProject);
+        // Regenerate JSON schemas to reflect any table terminology fixes
+        try {
+            MessageFormatter.progress("Regenerating JSON schemas...", { prefix: "Sync" });
+            await createImportSchemas(this.appwriteFolderPath);
+            MessageFormatter.success("JSON schemas regenerated successfully", { prefix: "Sync" });
+        }
+        catch (error) {
+            // Log error but don't fail the sync process
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            MessageFormatter.warning(`Failed to regenerate JSON schemas, but sync completed: ${errorMessage}`, { prefix: "Sync" });
+            logger.warn("Schema regeneration failed during sync:", error);
+        }
+    }
+    async selectivePull(databaseSelections, bucketSelections) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        MessageFormatter.progress("Starting selective pull (Appwrite → local config)...", { prefix: "Controller" });
+        // Convert database selections to Models.Database format
+        const selectedDatabases = [];
+        for (const dbSelection of databaseSelections) {
+            // Get the full database object from the controller
+            const databases = await fetchAllDatabases(this.database);
+            const database = databases.find(db => db.$id === dbSelection.databaseId);
+            if (database) {
+                selectedDatabases.push(database);
+                MessageFormatter.info(`Selected database: ${database.name} (${database.$id})`, { prefix: "Controller" });
+                // Log selected tables for this database
+                if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+                    MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
+                }
+            }
+            else {
+                MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+            }
+        }
+        if (selectedDatabases.length === 0) {
+            MessageFormatter.warning("No valid databases selected for pull", { prefix: "Controller" });
+            return;
+        }
+        // Log bucket selections if provided
+        if (bucketSelections && bucketSelections.length > 0) {
+            MessageFormatter.info(`Selected ${bucketSelections.length} buckets:`, { prefix: "Controller" });
+            for (const bucketSelection of bucketSelections) {
+                const dbInfo = bucketSelection.databaseId ? ` (DB: ${bucketSelection.databaseId})` : '';
+                MessageFormatter.info(`  - ${bucketSelection.bucketName} (${bucketSelection.bucketId})${dbInfo}`, { prefix: "Controller" });
+            }
+        }
+        // Perform selective sync using the enhanced synchronizeConfigurations method
+        await this.synchronizeConfigurations(selectedDatabases, this.config, databaseSelections, bucketSelections);
+        MessageFormatter.success("Selective pull completed successfully! Remote config pulled to local.", { prefix: "Controller" });
+    }
+    async selectivePush(databaseSelections, bucketSelections) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        // Always reload config from disk so pushes use current local YAML/Ts definitions
+        try {
+            await this.reloadConfig();
+            MessageFormatter.info("Reloaded config from disk for push", { prefix: "Controller" });
+        }
+        catch (e) {
+            // Non-fatal; continue with existing config
+            MessageFormatter.warning("Could not reload config; continuing with current in-memory config", { prefix: "Controller" });
+        }
+        MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
+        // Convert database selections to Models.Database format
+        const selectedDatabases = [];
+        for (const dbSelection of databaseSelections) {
+            // Get the full database object from the controller
+            const databases = await fetchAllDatabases(this.database);
+            const database = databases.find(db => db.$id === dbSelection.databaseId);
+            if (database) {
+                selectedDatabases.push(database);
+                MessageFormatter.info(`Selected database: ${database.name} (${database.$id})`, { prefix: "Controller" });
+                // Log selected tables for this database
+                if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+                    MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
+                }
+            }
+            else {
+                MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+            }
+        }
+        if (selectedDatabases.length === 0) {
+            MessageFormatter.warning("No valid databases selected for push", { prefix: "Controller" });
+            return;
+        }
+        // Log bucket selections if provided
+        if (bucketSelections && bucketSelections.length > 0) {
+            MessageFormatter.info(`Selected ${bucketSelections.length} buckets:`, { prefix: "Controller" });
+            for (const bucketSelection of bucketSelections) {
+                const dbInfo = bucketSelection.databaseId ? ` (DB: ${bucketSelection.databaseId})` : '';
+                MessageFormatter.info(`  - ${bucketSelection.bucketName} (${bucketSelection.bucketId})${dbInfo}`, { prefix: "Controller" });
+            }
+        }
+        // PUSH OPERATION: Push local configuration to Appwrite
+        // 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 || [];
+        // Create database-specific collection mapping to preserve relationships
+        for (const dbSelection of databaseSelections) {
+            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);
+                    const source = collection._isFromTablesDir ? 'tables/' : 'collections/';
+                    MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId} [source: ${source}]`, { prefix: "Controller" });
+                }
+            }
+            databaseCollectionsMap.set(dbSelection.databaseId, collectionsForDatabase);
+            MessageFormatter.info(`Database ${dbSelection.databaseId}: ${collectionsForDatabase.length} collections selected`, { 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 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 = []) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (databases.length === 0) {
+            const allDatabases = await fetchAllDatabases(this.database);
+            databases = allDatabases;
+        }
+        // Ensure DBs exist
+        await this.ensureDatabasesExist(databases);
+        await this.ensureDatabaseConfigBucketsExist(databases);
+        await this.createOrUpdateCollectionsForDatabases(databases, collections);
+    }
+    getAppwriteFolderPath() {
+        return this.appwriteFolderPath;
+    }
+    async transferData(options) {
+        let sourceClient = this.database;
+        let targetClient;
+        let sourceDatabases = [];
+        let targetDatabases = [];
+        if (!sourceClient) {
+            MessageFormatter.error("Source database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        if (options.isRemote) {
+            if (!options.transferEndpoint ||
+                !options.transferProject ||
+                !options.transferKey) {
+                MessageFormatter.error("Remote transfer options are missing", undefined, { prefix: "Controller" });
+                return;
+            }
+            const remoteClient = getClient(options.transferEndpoint, options.transferProject, options.transferKey);
+            targetClient = new Databases(remoteClient);
+            sourceDatabases = await fetchAllDatabases(sourceClient);
+            targetDatabases = await fetchAllDatabases(targetClient);
+        }
+        else {
+            targetClient = sourceClient;
+            sourceDatabases = targetDatabases = await fetchAllDatabases(sourceClient);
+        }
+        // Always perform database transfer if databases are specified
+        if (options.fromDb && options.targetDb) {
+            const fromDb = sourceDatabases.find((db) => db.$id === options.fromDb.$id);
+            const targetDb = targetDatabases.find((db) => db.$id === options.targetDb.$id);
+            if (!fromDb || !targetDb) {
+                MessageFormatter.error("Source or target database not found", undefined, { prefix: "Controller" });
+                return;
+            }
+            if (options.isRemote && targetClient) {
+                await transferDatabaseLocalToRemote(sourceClient, options.transferEndpoint, options.transferProject, options.transferKey, fromDb.$id, targetDb.$id);
+            }
+            else {
+                await transferDatabaseLocalToLocal(sourceClient, fromDb.$id, targetDb.$id);
+            }
+        }
+        if (options.transferUsers) {
+            if (!options.isRemote) {
+                MessageFormatter.warning("User transfer is only supported for remote transfers. Skipping...", { prefix: "Controller" });
+            }
+            else if (!this.appwriteServer) {
+                MessageFormatter.error("Appwrite server not initialized", undefined, { prefix: "Controller" });
+                return;
+            }
+            else {
+                MessageFormatter.progress("Starting user transfer...", { prefix: "Transfer" });
+                const localUsers = new Users(this.appwriteServer);
+                await transferUsersLocalToRemote(localUsers, options.transferEndpoint, options.transferProject, options.transferKey);
+                MessageFormatter.success("User transfer completed", { prefix: "Transfer" });
+            }
+        }
+        // Handle storage transfer
+        if (this.storage && (options.sourceBucket || options.fromDb)) {
+            const sourceBucketId = options.sourceBucket?.$id ||
+                (options.fromDb &&
+                    this.config?.documentBucketId &&
+                    `${this.config.documentBucketId}_${options.fromDb.$id
+                        .toLowerCase()
+                        .trim()
+                        .replace(/\s+/g, "")}`);
+            const targetBucketId = options.targetBucket?.$id ||
+                (options.targetDb &&
+                    this.config?.documentBucketId &&
+                    `${this.config.documentBucketId}_${options.targetDb.$id
+                        .toLowerCase()
+                        .trim()
+                        .replace(/\s+/g, "")}`);
+            if (sourceBucketId && targetBucketId) {
+                MessageFormatter.progress(`Starting storage transfer from ${sourceBucketId} to ${targetBucketId}`, { prefix: "Transfer" });
+                if (options.isRemote) {
+                    await transferStorageLocalToRemote(this.storage, options.transferEndpoint, options.transferProject, options.transferKey, sourceBucketId, targetBucketId);
+                }
+                else {
+                    await transferStorageLocalToLocal(this.storage, sourceBucketId, targetBucketId);
+                }
+            }
+        }
+        MessageFormatter.success("Transfer completed", { prefix: "Transfer" });
+    }
+    async updateFunctionSpecifications(functionId, specification) {
+        await this.init();
+        if (!this.appwriteServer)
+            throw new Error("Appwrite server not initialized");
+        MessageFormatter.progress(`Updating function specifications for ${functionId} to ${specification}`, { prefix: "Functions" });
+        await updateFunctionSpecifications(this.appwriteServer, functionId, specification);
+        MessageFormatter.success(`Successfully updated function specifications for ${functionId} to ${specification}`, { prefix: "Functions" });
+    }
+    /**
+     * Validates the current configuration for collections/tables conflicts
+     */
+    async validateConfiguration(strictMode = false) {
+        await this.init();
+        if (!this.config) {
+            throw new Error("Configuration not loaded");
+        }
+        MessageFormatter.progress("Validating configuration...", { prefix: "Validation" });
+        const validation = strictMode
+            ? validateWithStrictMode(this.config, strictMode)
+            : validateCollectionsTablesConfig(this.config);
+        reportValidationResults(validation, { verbose: true });
+        if (validation.isValid) {
+            MessageFormatter.success("Configuration validation passed", { prefix: "Validation" });
+        }
+        else {
+            MessageFormatter.error(`Configuration validation failed with ${validation.errors.length} errors`, undefined, { prefix: "Validation" });
+        }
+        return validation;
+    }
+    /**
+     * Get current session information for debugging/logging purposes
+     * Delegates to ConfigManager for session info
+     */
+    async getSessionInfo() {
+        const configManager = ConfigManager.getInstance();
+        try {
+            const authStatus = await configManager.getAuthStatus();
+            return {
+                hasSession: authStatus.hasValidSession,
+                authMethod: authStatus.authMethod,
+                email: authStatus.sessionInfo?.email,
+                expiresAt: authStatus.sessionInfo?.expiresAt
+            };
+        }
+        catch (error) {
+            // If config not loaded, return empty status
+            return {
+                hasSession: false
+            };
+        }
+    }
+}