@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.1

package/dist/tables/indexManager.js

@@ -0,0 +1,294 @@
+import { isIndexEqualToIndex } from "../collections/tableOperations.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
+import { delay, tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
+/**
+ * Plan index operations by comparing desired indexes with existing ones
+ * Uses the existing isIndexEqualToIndex function for consistent comparison
+ */
+export function planIndexOperations(desiredIndexes, existingIndexes) {
+    const plan = {
+        toCreate: [],
+        toUpdate: [],
+        toSkip: [],
+        toDelete: []
+    };
+    for (const desiredIndex of desiredIndexes) {
+        const existingIndex = existingIndexes.find(idx => idx.key === desiredIndex.key);
+        if (!existingIndex) {
+            // Index doesn't exist - create it
+            plan.toCreate.push({
+                type: 'create',
+                index: desiredIndex,
+                reason: 'New index'
+            });
+        }
+        else if (isIndexEqualToIndex(existingIndex, desiredIndex)) {
+            // Index exists and is identical - skip it
+            plan.toSkip.push({
+                type: 'skip',
+                index: desiredIndex,
+                existingIndex,
+                reason: 'Index unchanged'
+            });
+        }
+        else {
+            // Index exists but is different - update it
+            plan.toUpdate.push({
+                type: 'update',
+                index: desiredIndex,
+                existingIndex,
+                reason: 'Index configuration changed'
+            });
+        }
+    }
+    return plan;
+}
+/**
+ * Plan index deletions for indexes that exist but aren't in the desired configuration
+ */
+export function planIndexDeletions(desiredIndexKeys, existingIndexes) {
+    const deletions = [];
+    for (const existingIndex of existingIndexes) {
+        if (!desiredIndexKeys.has(existingIndex.key)) {
+            deletions.push({
+                type: 'delete',
+                index: existingIndex, // Convert Models.Index to Index for compatibility
+                reason: 'Obsolete index'
+            });
+        }
+    }
+    return deletions;
+}
+/**
+ * Execute index operations with proper error handling and status monitoring
+ */
+export async function executeIndexOperations(adapter, databaseId, tableId, plan) {
+    const result = {
+        created: [],
+        updated: [],
+        skipped: [],
+        deleted: [],
+        errors: [],
+        summary: {
+            total: 0,
+            created: 0,
+            updated: 0,
+            skipped: 0,
+            deleted: 0,
+            errors: 0
+        }
+    };
+    // Execute creates
+    for (const operation of plan.toCreate) {
+        try {
+            await adapter.createIndex({
+                databaseId,
+                tableId,
+                key: operation.index.key,
+                type: operation.index.type,
+                attributes: operation.index.attributes,
+                orders: operation.index.orders || []
+            });
+            result.created.push(operation.index.key);
+            MessageFormatter.success(`Created index ${operation.index.key}`, { prefix: 'Indexes' });
+            // Wait for index to become available
+            await waitForIndexAvailable(adapter, databaseId, tableId, operation.index.key);
+            await delay(150); // Brief delay between operations
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            result.errors.push({ key: operation.index.key, error: errorMessage });
+            MessageFormatter.error(`Failed to create index ${operation.index.key}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
+        }
+    }
+    // Execute updates (delete + recreate)
+    for (const operation of plan.toUpdate) {
+        try {
+            // Delete existing index first
+            await adapter.deleteIndex({
+                databaseId,
+                tableId,
+                key: operation.index.key
+            });
+            await delay(100); // Brief delay for deletion to settle
+            // Create new index
+            await adapter.createIndex({
+                databaseId,
+                tableId,
+                key: operation.index.key,
+                type: operation.index.type,
+                attributes: operation.index.attributes,
+                orders: operation.index.orders || operation.existingIndex?.orders || []
+            });
+            result.updated.push(operation.index.key);
+            MessageFormatter.success(`Updated index ${operation.index.key}`, { prefix: 'Indexes' });
+            // Wait for index to become available
+            await waitForIndexAvailable(adapter, databaseId, tableId, operation.index.key);
+            await delay(150); // Brief delay between operations
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            result.errors.push({ key: operation.index.key, error: errorMessage });
+            MessageFormatter.error(`Failed to update index ${operation.index.key}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
+        }
+    }
+    // Execute skips
+    for (const operation of plan.toSkip) {
+        result.skipped.push(operation.index.key);
+        MessageFormatter.info(`Index ${operation.index.key} unchanged`, { prefix: 'Indexes' });
+    }
+    // Calculate summary
+    result.summary.total = result.created.length + result.updated.length + result.skipped.length + result.deleted.length;
+    result.summary.created = result.created.length;
+    result.summary.updated = result.updated.length;
+    result.summary.skipped = result.skipped.length;
+    result.summary.deleted = result.deleted.length;
+    result.summary.errors = result.errors.length;
+    return result;
+}
+/**
+ * Execute index deletions with proper error handling
+ */
+export async function executeIndexDeletions(adapter, databaseId, tableId, deletions) {
+    const result = {
+        deleted: [],
+        errors: []
+    };
+    for (const operation of deletions) {
+        try {
+            await adapter.deleteIndex({
+                databaseId,
+                tableId,
+                key: operation.index.key
+            });
+            result.deleted.push(operation.index.key);
+            MessageFormatter.info(`Deleted obsolete index ${operation.index.key}`, { prefix: 'Indexes' });
+            // Wait briefly for deletion to settle
+            await delay(500);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            result.errors.push({ key: operation.index.key, error: errorMessage });
+            MessageFormatter.error(`Failed to delete index ${operation.index.key}`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
+        }
+    }
+    return result;
+}
+/**
+ * Wait for an index to become available with timeout and retry logic
+ * This is an adapter-aware version of the logic from collections/indexes.ts
+ */
+async function waitForIndexAvailable(adapter, databaseId, tableId, indexKey, maxWaitTime = 60000, // 1 minute
+checkInterval = 2000 // 2 seconds
+) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitTime) {
+        try {
+            const indexList = await adapter.listIndexes({ databaseId, tableId });
+            const indexes = indexList.data || indexList.indexes || [];
+            const index = indexes.find((idx) => idx.key === indexKey);
+            if (!index) {
+                MessageFormatter.error(`Index '${indexKey}' not found after creation`, undefined, { prefix: 'Indexes' });
+                return false;
+            }
+            switch (index.status) {
+                case 'available':
+                    return true;
+                case 'failed':
+                    MessageFormatter.error(`Index '${indexKey}' failed: ${index.error || 'unknown error'}`, undefined, { prefix: 'Indexes' });
+                    return false;
+                case 'stuck':
+                    MessageFormatter.warning(`Index '${indexKey}' is stuck`, { prefix: 'Indexes' });
+                    return false;
+                case 'processing':
+                case 'deleting':
+                    // Continue waiting
+                    break;
+                default:
+                    MessageFormatter.warning(`Unknown status '${index.status}' for index '${indexKey}'`, { prefix: 'Indexes' });
+                    break;
+            }
+        }
+        catch (error) {
+            MessageFormatter.error(`Error checking index '${indexKey}' status: ${error}`, undefined, { prefix: 'Indexes' });
+        }
+        await delay(checkInterval);
+    }
+    MessageFormatter.warning(`Timeout waiting for index '${indexKey}' to become available (${maxWaitTime}ms)`, { prefix: 'Indexes' });
+    return false;
+}
+/**
+ * Main function to create/update indexes via adapter
+ * This replaces the messy inline code in methods.ts
+ */
+export async function createOrUpdateIndexesViaAdapter(adapter, databaseId, tableId, desiredIndexes, configIndexes) {
+    if (!desiredIndexes || desiredIndexes.length === 0) {
+        MessageFormatter.info('No indexes to process', { prefix: 'Indexes' });
+        return;
+    }
+    MessageFormatter.info(`Processing ${desiredIndexes.length} indexes for table ${tableId}`, { prefix: 'Indexes' });
+    try {
+        // Get existing indexes
+        const existingIdxRes = await adapter.listIndexes({ databaseId, tableId });
+        const existingIndexes = existingIdxRes.data || existingIdxRes.indexes || [];
+        // Plan operations
+        const plan = planIndexOperations(desiredIndexes, existingIndexes);
+        // Show plan with icons (consistent with attribute handling)
+        const planParts = [];
+        if (plan.toCreate.length)
+            planParts.push(`➕  ${plan.toCreate.length} (${plan.toCreate.map(op => op.index.key).join(', ')})`);
+        if (plan.toUpdate.length)
+            planParts.push(`🔧  ${plan.toUpdate.length} (${plan.toUpdate.map(op => op.index.key).join(', ')})`);
+        if (plan.toSkip.length)
+            planParts.push(`⏭️  ${plan.toSkip.length}`);
+        MessageFormatter.info(`Plan → ${planParts.join('  |  ') || 'no changes'}`, { prefix: 'Indexes' });
+        // Execute operations
+        const result = await executeIndexOperations(adapter, databaseId, tableId, plan);
+        // Show summary
+        MessageFormatter.info(`Summary → ➕  ${result.summary.created}  |  🔧  ${result.summary.updated}  |  ⏭️  ${result.summary.skipped}`, { prefix: 'Indexes' });
+        // Handle errors if any
+        if (result.errors.length > 0) {
+            MessageFormatter.error(`${result.errors.length} index operations failed:`, undefined, { prefix: 'Indexes' });
+            for (const error of result.errors) {
+                MessageFormatter.error(`  ${error.key}: ${error.error}`, undefined, { prefix: 'Indexes' });
+            }
+        }
+    }
+    catch (error) {
+        MessageFormatter.error('Failed to process indexes', error instanceof Error ? error : new Error(String(error)), { prefix: 'Indexes' });
+        throw error;
+    }
+}
+/**
+ * Handle index deletions for obsolete indexes
+ */
+export async function deleteObsoleteIndexesViaAdapter(adapter, databaseId, tableId, desiredIndexKeys) {
+    try {
+        // Get existing indexes
+        const existingIdxRes = await adapter.listIndexes({ databaseId, tableId });
+        const existingIndexes = existingIdxRes.data || existingIdxRes.indexes || [];
+        // Plan deletions
+        const deletions = planIndexDeletions(desiredIndexKeys, existingIndexes);
+        if (deletions.length === 0) {
+            MessageFormatter.info('Plan → 🗑️  0 indexes', { prefix: 'Indexes' });
+            return;
+        }
+        // Show deletion plan
+        MessageFormatter.info(`Plan → 🗑️  ${deletions.length} (${deletions.map(op => op.index.key).join(', ')})`, { prefix: 'Indexes' });
+        // Execute deletions
+        const result = await executeIndexDeletions(adapter, databaseId, tableId, deletions);
+        // Show results
+        if (result.deleted.length > 0) {
+            MessageFormatter.success(`Deleted ${result.deleted.length} indexes: ${result.deleted.join(', ')}`, { prefix: 'Indexes' });
+        }
+        if (result.errors.length > 0) {
+            MessageFormatter.error(`${result.errors.length} index deletions failed:`, undefined, { prefix: 'Indexes' });
+            for (const error of result.errors) {
+                MessageFormatter.error(`  ${error.key}: ${error.error}`, undefined, { prefix: 'Indexes' });
+            }
+        }
+    }
+    catch (error) {
+        MessageFormatter.warning(`Could not evaluate index deletions: ${error?.message || error}`, { prefix: 'Indexes' });
+    }
+}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export type { ValidationRules } from "./utils/validationRules.js";
+export type { ValidationRules } from "@njdamstra/appwrite-utils-helpers";
 export { type AuthUserCreate, AuthUserCreateSchema, type AuthUser, AuthUserSchema, } from "./schemas/authUser.js";
-export { validationRules } from "./utils/validationRules.js";
+export { validationRules } from "@njdamstra/appwrite-utils-helpers";
 export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/types.js

@@ -1,3 +1,3 @@
 export { AuthUserCreateSchema, AuthUserSchema, } from "./schemas/authUser.js";
-export { validationRules } from "./utils/validationRules.js";
+export { validationRules } from "@njdamstra/appwrite-utils-helpers";
 export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/users/methods.js

@@ -1,11 +1,10 @@
 import { AppwriteException, Databases, ID, Query, Users, } from "node-appwrite";
 import { AuthUserSchema, } from "../schemas/authUser.js";
-import { logger } from "../shared/logging.js";
+import { logger, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import { splitIntoBatches } from "../shared/migrationHelpers.js";
-import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
+import { getAppwriteClient, tryAwaitWithRetry, } from "@njdamstra/appwrite-utils-helpers";
 import { isUndefined } from "es-toolkit/compat";
 import { isEmpty } from "es-toolkit/compat";
-import { MessageFormatter } from "../shared/messageFormatter.js";
 export class UsersController {
     config;
     users;

package/dist/utils/configMigration.js

@@ -1,7 +1,7 @@
 import { promises as fs } from "fs";
 import path from "path";
 import { existsSync } from "fs";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import { ConfirmationDialogs } from "../shared/confirmationDialogs.js";
 import yaml from "js-yaml";
 export async function migrateConfig(workingDir) {

package/dist/utils/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./helperFunctions.js";
+export * from '@njdamstra/appwrite-utils-helpers';
 export * from "./setupFiles.js";

package/dist/utils/index.js

@@ -1,2 +1,2 @@
-export * from "./helperFunctions.js";
+export * from '@njdamstra/appwrite-utils-helpers';
 export * from "./setupFiles.js";

package/dist/utils/loadConfigs.d.ts

@@ -1,5 +1,5 @@
 import { type AppwriteConfig } from "@njdamstra/appwrite-utils";
-import { type ValidationResult } from "../config/configValidation.js";
+import { type ValidationResult } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Session authentication preservation options for config loading
  */
@@ -28,7 +28,7 @@ export interface ConfigLoadingOptions {
  * @returns SessionPreservationOptions object
  */
 export declare function createSessionPreservation(sessionCookie: string, email?: string, expiresAt?: string): SessionPreservationOptions;
-export { findAppwriteConfig, findFunctionsDir } from "./configDiscovery.js";
+export { findAppwriteConfig, findFunctionsDir } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Loads the Appwrite configuration and returns both config and the path where it was found.
  * @param configDir The directory to search for config files.

package/dist/utils/loadConfigs.js

@@ -4,12 +4,11 @@ import {} from "@njdamstra/appwrite-utils";
 import { register } from "tsx/esm/api"; // Import the register function
 import { pathToFileURL } from "node:url";
 import chalk from "chalk";
-import { findYamlConfig, loadYamlConfig, loadYamlConfigWithSession, extractSessionOptionsFromConfig } from "../config/yamlConfig.js";
-import { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from "./versionDetection.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { validateCollectionsTablesConfig, reportValidationResults } from "../config/configValidation.js";
-import { resolveCollectionsDir, resolveTablesDir } from "./pathResolvers.js";
-import { findAppwriteConfig, findAppwriteConfigTS, findFunctionsDir, discoverCollections, discoverTables, discoverLegacyDirectory } from "./configDiscovery.js";
+import { findYamlConfig, loadYamlConfig, loadYamlConfigWithSession, extractSessionOptionsFromConfig, validateCollectionsTablesConfig, reportValidationResults } from "@njdamstra/appwrite-utils-helpers";
+import { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from '@njdamstra/appwrite-utils-helpers';
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
+import { resolveCollectionsDir, resolveTablesDir } from '@njdamstra/appwrite-utils-helpers';
+import { findAppwriteConfig, findAppwriteConfigTS, findFunctionsDir, discoverCollections, discoverTables, discoverLegacyDirectory } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Helper function to create session preservation options from session data
  * @param sessionCookie The session cookie string
@@ -28,7 +27,7 @@ export function createSessionPreservation(sessionCookie, email, expiresAt) {
     };
 }
 // Re-export config discovery functions for backward compatibility
-export { findAppwriteConfig, findFunctionsDir } from "./configDiscovery.js";
+export { findAppwriteConfig, findFunctionsDir } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Loads the Appwrite configuration and returns both config and the path where it was found.
  * @param configDir The directory to search for config files.

package/dist/utils/setupFiles.js

@@ -1,15 +1,13 @@
 import { mkdirSync, writeFileSync, existsSync } from "node:fs";
 import path from "node:path";
 import { findAppwriteConfig } from "./loadConfigs.js";
-import { loadYamlConfig } from "../config/yamlConfig.js";
-import { fetchServerVersion, isVersionAtLeast } from "./versionDetection.js";
-import { findYamlConfig } from "../config/yamlConfig.js";
+import { loadYamlConfig, findYamlConfig, generateYamlConfigTemplate } from "@njdamstra/appwrite-utils-helpers";
+import { fetchServerVersion, isVersionAtLeast } from '@njdamstra/appwrite-utils-helpers';
 import { ID } from "node-appwrite";
 import { ulid } from "ulidx";
-import { generateYamlConfigTemplate } from "../config/yamlConfig.js";
-import { loadAppwriteProjectConfig, findAppwriteProjectConfig, getProjectDirectoryName, isTablesDBProject } from "./projectConfig.js";
-import { hasSessionAuth, getSessionAuth } from "./sessionAuth.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { loadAppwriteProjectConfig, findAppwriteProjectConfig, getProjectDirectoryName, isTablesDBProject } from '@njdamstra/appwrite-utils-helpers';
+import { hasSessionAuth, getSessionAuth } from '@njdamstra/appwrite-utils-helpers';
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 // Example base configuration using types from appwrite-utils
 const baseConfig = {
     appwriteEndpoint: "https://cloud.appwrite.io/v1",

package/dist/utilsController.d.ts

@@ -2,8 +2,8 @@ import { Client, Databases, Storage, type Models } from "node-appwrite";
 import { type AppwriteConfig, type AppwriteFunction, type Specification } from "@njdamstra/appwrite-utils";
 import { type AfterImportActions, type ConverterFunctions, type ValidationRules } from "@njdamstra/appwrite-utils";
 import { type TransferOptions } from "./migrations/transfer.js";
-import type { DatabaseAdapter } from './adapters/DatabaseAdapter.js';
-import { type ValidationResult } from "./config/configValidation.js";
+import type { DatabaseAdapter } from '@njdamstra/appwrite-utils-helpers';
+import { type ValidationResult } from "@njdamstra/appwrite-utils-helpers";
 import type { DatabaseSelection, BucketSelection } from "./shared/selectionDialogs.js";
 export interface SetupOptions {
     databases?: Models.Database[];
@@ -19,6 +19,18 @@ export interface SetupOptions {
     checkDuplicates?: boolean;
     shouldWriteFile?: boolean;
 }
+export interface ControllerInitOptions {
+    validate?: boolean;
+    strictMode?: boolean;
+    useSession?: boolean;
+    sessionCookie?: string;
+    preferJson?: boolean;
+    overrides?: {
+        appwriteEndpoint?: string;
+        appwriteProject?: string;
+        appwriteKey?: string;
+    };
+}
 export declare class UtilsController {
     private static instance;
     private isInitialized;
@@ -50,12 +62,7 @@ export declare class UtilsController {
         appwriteProject?: string;
         appwriteKey?: string;
     });
-    init(options?: {
-        validate?: boolean;
-        strictMode?: boolean;
-        useSession?: boolean;
-        sessionCookie?: string;
-    }): Promise<void>;
+    init(options?: ControllerInitOptions): Promise<void>;
     reloadConfig(): Promise<void>;
     ensureDatabaseConfigBucketsExist(databases?: Models.Database[]): Promise<void>;
     ensureDatabasesExist(databases?: Models.Database[]): Promise<void>;

package/dist/utilsController.js

@@ -1,7 +1,7 @@
 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 { normalizeFunctionName, validateFunctionDirectory } from '@njdamstra/appwrite-utils-helpers';
 import { UsersController } from "./users/methods.js";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
 import { ImportController } from "./migrations/importController.js";
@@ -14,22 +14,18 @@ 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 { getClient, getClientWithAuth } from "@njdamstra/appwrite-utils-helpers";
+import { getAdapterFromConfig } from "@njdamstra/appwrite-utils-helpers";
+import { hasSessionAuth, findSessionByEndpointAndProject, isValidSessionCookie } from "@njdamstra/appwrite-utils-helpers";
 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 { configureLogging, updateLogger, logger, MessageFormatter, Messages, SchemaGenerator, findYamlConfig, validateCollectionsTablesConfig, reportValidationResults, validateWithStrictMode, ConfigManager } from "@njdamstra/appwrite-utils-helpers";
 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";
+import { ClientFactory } from "@njdamstra/appwrite-utils-helpers";
+import { clearProcessingState, processQueue } from "./shared/operationQueue.js";
 export class UtilsController {
     // ──────────────────────────────────────────────────
     // SINGLETON PATTERN
@@ -151,7 +147,7 @@ export class UtilsController {
         }
     }
     async init(options = {}) {
-        const { validate = false, strictMode = false } = options;
+        const { validate = false, strictMode = false, preferJson = false, useSession, sessionCookie, overrides } = options;
         const configManager = ConfigManager.getInstance();
         // Load config if not already loaded
         if (!configManager.hasConfig()) {
@@ -159,6 +155,10 @@ export class UtilsController {
                 configDir: this.currentUserDir,
                 validate,
                 strictMode,
+                preferJson,
+                useSession,
+                explicitSessionCookie: sessionCookie,
+                overrides,
             });
         }
         const config = configManager.getConfig();
@@ -351,7 +351,7 @@ export class UtilsController {
             MessageFormatter.error(`Function ${functionName} not found in config`, undefined, { prefix: "Controller" });
             return;
         }
-        await deployLocalFunction(this.appwriteServer, functionName, functionConfig, functionPath);
+        await deployLocalFunction(this.appwriteServer, functionName, functionConfig, functionPath, this.appwriteFolderPath);
     }
     async syncFunctions() {
         await this.init();
@@ -457,7 +457,6 @@ export class 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 { }
@@ -474,6 +473,15 @@ export class UtilsController {
             logger.debug("Adapter unavailable, falling back to legacy Databases path", { prefix: "UtilsController" });
             await createOrUpdateCollections(this.database, database.$id, this.config, deletedCollections, collections);
         }
+        // Safety net: Process any remaining queued operations to complete relationship sync
+        try {
+            MessageFormatter.info(`🔄 Processing final operation queue for database ${database.$id}`, { prefix: "UtilsController" });
+            await processQueue(this.adapter || this.database, database.$id);
+            MessageFormatter.info(`✅ Operation queue processing completed`, { prefix: "UtilsController" });
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to process operation queue`, error instanceof Error ? error : new Error(String(error)), { prefix: 'UtilsController' });
+        }
     }
     async generateSchemas() {
         // Schema generation doesn't need Appwrite connection, just config
@@ -638,20 +646,38 @@ export class UtilsController {
         MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
         // Convert database selections to Models.Database format
         const selectedDatabases = [];
+        const serverDatabases = await fetchAllDatabases(this.database);
+        const configuredDatabases = this.config?.databases || [];
         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" });
-                }
+            // First try to find on server
+            const serverDb = serverDatabases.find(db => db.$id === dbSelection.databaseId);
+            if (serverDb) {
+                selectedDatabases.push(serverDb);
+                MessageFormatter.info(`Selected database: ${serverDb.name} (${serverDb.$id})`, { prefix: "Controller" });
             }
             else {
-                MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+                // Database doesn't exist on server - check if it's in local config
+                const configDb = configuredDatabases.find((db) => db.$id === dbSelection.databaseId);
+                if (configDb) {
+                    // Create a pseudo-database object that ensureDatabasesExist will create
+                    const dbId = configDb.$id;
+                    selectedDatabases.push({
+                        $id: dbId,
+                        name: configDb.name || dbId,
+                        $createdAt: new Date().toISOString(),
+                        $updatedAt: new Date().toISOString(),
+                        enabled: true,
+                    });
+                    MessageFormatter.info(`Selected database: ${configDb.name || dbId} (${dbId}) [will be created]`, { prefix: "Controller" });
+                }
+                else {
+                    MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found in server or local config`, { prefix: "Controller" });
+                    continue;
+                }
+            }
+            // Log selected tables for this database
+            if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+                MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
             }
         }
         if (selectedDatabases.length === 0) {
@@ -670,7 +696,10 @@ export class UtilsController {
         // 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 || [];
+        const allCollections = [
+            ...(this.config?.collections || []),
+            ...(this.config?.tables || [])
+        ];
         // Create database-specific collection mapping to preserve relationships
         for (const dbSelection of databaseSelections) {
             const collectionsForDatabase = [];
@@ -760,10 +789,10 @@ export class UtilsController {
                 return;
             }
             if (options.isRemote && targetClient) {
-                await transferDatabaseLocalToRemote(sourceClient, options.transferEndpoint, options.transferProject, options.transferKey, fromDb.$id, targetDb.$id);
+                await transferDatabaseLocalToRemote(sourceClient, options.transferEndpoint, options.transferProject, options.transferKey, fromDb.$id, targetDb.$id, options.collections);
             }
             else {
-                await transferDatabaseLocalToLocal(sourceClient, fromDb.$id, targetDb.$id);
+                await transferDatabaseLocalToLocal(sourceClient, fromDb.$id, targetDb.$id, options.collections, this.adapter);
             }
         }
         if (options.transferUsers) {