appwrite-utils-cli 1.6.3 → 1.6.4

package/dist/utils/helperFunctions.js

@@ -83,6 +83,7 @@ export const finalizeByAttributeMap = async (appwriteFolderPath, collection, ite
 export let numTimesFailedTotal = 0;
 /**
  * Tries to execute the given createFunction and retries up to 5 times if it fails.
+ * Only retries on transient errors (network failures, 5xx errors). Does NOT retry validation errors (4xx).
  *
  * @param {() => Promise<any>} createFunction - The function to be executed.
  * @param {number} [attemptNum=0] - The number of attempts made so far (default: 0).
@@ -93,11 +94,25 @@ export const tryAwaitWithRetry = async (createFunction, attemptNum = 0, throwErr
         return await createFunction();
     }
     catch (error) {
-        if ((error instanceof AppwriteException &&
-            (error.message.toLowerCase().includes("fetch failed") ||
-                error.message.toLowerCase().includes("server error"))) ||
-            (error.code === 522 || error.code === "522")) {
-            if (error.code === 522) {
+        const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+        const errorCode = error.code;
+        // Check if this is a validation error that should NOT be retried
+        const isValidationError = errorCode === 400 || errorCode === 409 || errorCode === 422 ||
+            errorMessage.includes("already exists") ||
+            errorMessage.includes("attribute with the same key") ||
+            errorMessage.includes("invalid") && !errorMessage.includes("fetch failed") ||
+            errorMessage.includes("conflict") ||
+            errorMessage.includes("bad request");
+        // Check if this is a transient error that SHOULD be retried
+        const isTransientError = errorCode === 522 || errorCode === "522" || // Cloudflare error
+            errorCode >= 500 && errorCode < 600 || // 5xx server errors
+            errorMessage.includes("fetch failed") || // Network failures
+            errorMessage.includes("timeout") ||
+            errorMessage.includes("econnrefused") ||
+            errorMessage.includes("network error");
+        // Only retry if it's a transient error AND not a validation error
+        if (isTransientError && !isValidationError) {
+            if (errorCode === 522 || errorCode === "522") {
                 console.log("Cloudflare error. Retrying...");
             }
             else {
@@ -110,6 +125,7 @@ export const tryAwaitWithRetry = async (createFunction, attemptNum = 0, throwErr
             await delay(2500);
             return tryAwaitWithRetry(createFunction, attemptNum + 1);
         }
+        // For validation errors or non-transient errors, throw immediately
         if (throwError) {
             throw error;
         }

package/dist/utils/yamlConverter.d.ts

@@ -14,7 +14,7 @@ export interface YamlCollectionData {
         size?: number;
         required?: boolean;
         array?: boolean;
-        encrypt?: boolean;
+        encrypted?: boolean;
         default?: any;
         min?: number;
         max?: number;
@@ -32,7 +32,7 @@ export interface YamlCollectionData {
         size?: number;
         required?: boolean;
         array?: boolean;
-        encrypt?: boolean;
+        encrypted?: boolean;
         default?: any;
         min?: number;
         max?: number;

package/dist/utils/yamlConverter.js

@@ -39,9 +39,9 @@ export function collectionToYaml(collection, config = {
                 yamlAttr.required = attr.required;
             if (attr.array !== undefined)
                 yamlAttr.array = attr.array;
-            // Always include encrypt field for string attributes (default to false)
+            // Always include encrypted field for string attributes (default to false)
             if (attr.type === 'string') {
-                yamlAttr.encrypt = ('encrypted' in attr && attr.encrypted === true) ? true : false;
+                yamlAttr.encrypted = ('encrypted' in attr && attr.encrypted === true) ? true : false;
             }
             if ('xdefault' in attr && attr.xdefault !== undefined)
                 yamlAttr.default = attr.xdefault;

package/dist/utilsController.d.ts

@@ -19,8 +19,23 @@ export interface SetupOptions {
     shouldWriteFile?: boolean;
 }
 export declare class UtilsController {
+    private static instance;
+    private isInitialized;
+    /**
+     * Get the UtilsController singleton instance
+     */
+    static getInstance(currentUserDir: string, directConfig?: {
+        appwriteEndpoint?: string;
+        appwriteProject?: string;
+        appwriteKey?: string;
+    }): UtilsController;
+    /**
+     * Clear the singleton instance (useful for testing)
+     */
+    static clearInstance(): void;
     private appwriteFolderPath?;
     private appwriteConfigPath?;
+    private currentUserDir;
     config?: AppwriteConfig;
     appwriteServer?: Client;
     database?: Databases;
@@ -29,9 +44,6 @@ export declare class UtilsController {
     converterDefinitions: ConverterFunctions;
     validityRuleDefinitions: ValidationRules;
     afterImportActionsDefinitions: AfterImportActions;
-    private sessionCookie?;
-    private authMethod?;
-    private sessionMetadata?;
     constructor(currentUserDir: string, directConfig?: {
         appwriteEndpoint?: string;
         appwriteProject?: string;
@@ -75,23 +87,14 @@ export declare class UtilsController {
      * Validates the current configuration for collections/tables conflicts
      */
     validateConfiguration(strictMode?: boolean): Promise<ValidationResult>;
-    /**
-     * Extract session information from the current authenticated client
-     * This preserves session context for use across config reloads and adapter operations
-     */
-    private extractSessionInfo;
-    /**
-     * Create session preservation options for passing to loadConfig
-     * Returns current session state to maintain authentication across config reloads
-     */
-    private createSessionPreservationOptions;
     /**
      * Get current session information for debugging/logging purposes
+     * Delegates to ConfigManager for session info
      */
-    getSessionInfo(): {
+    getSessionInfo(): Promise<{
         hasSession: boolean;
         authMethod?: string;
         email?: string;
         expiresAt?: string;
-    };
+    }>;
 }

package/dist/utilsController.js

@@ -16,20 +16,45 @@ import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferSt
 import { getClient, getClientWithAuth } from "./utils/getClientFromConfig.js";
 import { getAdapterFromConfig } from "./utils/getClientFromConfig.js";
 import { hasSessionAuth, findSessionByEndpointAndProject, isValidSessionCookie } from "./utils/sessionAuth.js";
-import { createSessionPreservation } from "./utils/loadConfigs.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 } from "./shared/logging.js";
+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 { 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) {
+        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;
@@ -38,11 +63,8 @@ export class UtilsController {
     converterDefinitions = converterFunctions;
     validityRuleDefinitions = validationRules;
     afterImportActionsDefinitions = afterImportActions;
-    // Session preservation fields
-    sessionCookie;
-    authMethod;
-    sessionMetadata;
     constructor(currentUserDir, directConfig) {
+        this.currentUserDir = currentUserDir;
         const basePath = currentUserDir;
         if (directConfig) {
             let hasErrors = false;
@@ -107,96 +129,58 @@ export class UtilsController {
         }
     }
     async init(options = {}) {
-        const { validate = false, strictMode = false, useSession = false, sessionCookie } = options;
-        if (!this.config) {
-            if (this.appwriteFolderPath && this.appwriteConfigPath) {
-                MessageFormatter.progress("Loading config from file...", { prefix: "Config" });
-                try {
-                    const { config, actualConfigPath, validation } = await loadConfigWithPath(this.appwriteFolderPath, { validate, strictMode, reportValidation: false });
-                    this.config = config;
-                    MessageFormatter.info(`Loaded config from: ${actualConfigPath}`, { prefix: "Config" });
-                    // Report validation results if validation was requested
-                    if (validation && validate) {
-                        reportValidationResults(validation, { verbose: false });
-                        // In strict mode, throw if validation fails
-                        if (strictMode && !validation.isValid) {
-                            throw new Error(`Configuration validation failed in strict mode. Found ${validation.errors.length} validation errors.`);
-                        }
-                    }
-                }
-                catch (error) {
-                    MessageFormatter.error("Failed to load config from file", error instanceof Error ? error : undefined, { prefix: "Config" });
-                    return;
-                }
-            }
-            else {
-                MessageFormatter.error("No configuration available", undefined, { prefix: "Config" });
-                return;
-            }
+        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 (this.config.logging) {
-            configureLogging(this.config.logging);
+        if (config.logging) {
+            configureLogging(config.logging);
             updateLogger();
         }
-        // Use enhanced client with session authentication support
-        // Pass session cookie from options if provided
-        const clientSessionCookie = sessionCookie || this.sessionCookie;
-        this.appwriteServer = getClientWithAuth(this.config.appwriteEndpoint, this.config.appwriteProject, this.config.appwriteKey || undefined, clientSessionCookie);
+        // 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;
         this.database = new Databases(this.appwriteServer);
         this.storage = new Storage(this.appwriteServer);
         this.config.appwriteClient = this.appwriteServer;
-        // Initialize adapter with version detection
-        try {
-            const { adapter, apiMode } = await getAdapterFromConfig(this.config, false, clientSessionCookie);
-            this.adapter = adapter;
-            MessageFormatter.info(`Database adapter initialized (apiMode: ${apiMode})`, {
-                prefix: "Adapter"
-            });
+        // Log only on FIRST initialization to avoid spam
+        if (!this.isInitialized) {
+            const apiMode = adapter.getApiMode();
+            MessageFormatter.info(`Database adapter initialized (apiMode: ${apiMode})`, { prefix: "Adapter" });
+            this.isInitialized = true;
         }
-        catch (error) {
-            MessageFormatter.warning('Database adapter initialization failed - some features may not work', { prefix: "Adapter" });
+        else {
+            logger.debug("Adapter reused from cache", { prefix: "UtilsController" });
         }
-        // Extract and store session information after successful authentication
-        this.extractSessionInfo();
     }
     async reloadConfig() {
-        if (!this.appwriteFolderPath) {
-            MessageFormatter.error("Failed to get appwriteFolderPath", undefined, { prefix: "Controller" });
-            return;
-        }
-        // Preserve session authentication during config reload
-        const preserveAuth = this.createSessionPreservationOptions();
-        this.config = await loadConfig(this.appwriteFolderPath, {
-            preserveAuth
-        });
-        if (!this.config) {
-            MessageFormatter.error("Failed to load config", undefined, { prefix: "Controller" });
-            return;
-        }
+        const configManager = ConfigManager.getInstance();
+        // Session preservation is automatic in ConfigManager
+        const config = await configManager.reloadConfig();
         // Configure logging based on updated config
-        if (this.config.logging) {
-            configureLogging(this.config.logging);
+        if (config.logging) {
+            configureLogging(config.logging);
             updateLogger();
         }
-        // Use enhanced client with session authentication support, passing preserved session
-        this.appwriteServer = getClientWithAuth(this.config.appwriteEndpoint, this.config.appwriteProject, this.config.appwriteKey || undefined, this.sessionCookie);
+        // 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;
-        // Re-initialize adapter with version detection after config reload
-        try {
-            const { adapter, apiMode } = await getAdapterFromConfig(this.config, false, this.sessionCookie);
-            this.adapter = adapter;
-            MessageFormatter.info(`Database adapter re-initialized (apiMode: ${apiMode})`, {
-                prefix: "Adapter"
-            });
-        }
-        catch (error) {
-            MessageFormatter.warning('Database adapter re-initialization failed - some features may not work', { prefix: "Adapter" });
-        }
-        // Re-extract session information after reload
-        this.extractSessionInfo();
+        logger.debug("Config reloaded, adapter refreshed", { prefix: "UtilsController" });
     }
     async ensureDatabaseConfigBucketsExist(databases = []) {
         await this.init();
@@ -339,7 +323,8 @@ export class UtilsController {
         if (!this.database || !this.config)
             throw new Error("Database not initialized");
         try {
-            const { adapter, apiMode } = await getAdapterFromConfig(this.config, false, this.sessionCookie);
+            // Session is already in config from ConfigManager
+            const { adapter, apiMode } = await getAdapterFromConfig(this.config, false);
             if (apiMode === 'tablesdb') {
                 await wipeAllTables(adapter, database.$id);
             }
@@ -382,7 +367,8 @@ export class UtilsController {
         if (!this.database || !this.config)
             throw new Error("Database not initialized");
         try {
-            const { adapter, apiMode } = await getAdapterFromConfig(this.config, false, this.sessionCookie);
+            // 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);
             }
@@ -618,59 +604,25 @@ export class UtilsController {
         return validation;
     }
     /**
-     * Extract session information from the current authenticated client
-     * This preserves session context for use across config reloads and adapter operations
+     * Get current session information for debugging/logging purposes
+     * Delegates to ConfigManager for session info
      */
-    extractSessionInfo() {
-        if (!this.config) {
-            return;
-        }
-        // Try to extract session from current config first
-        if (this.config.sessionCookie && isValidSessionCookie(this.config.sessionCookie)) {
-            this.sessionCookie = this.config.sessionCookie;
-            this.authMethod = "session";
-            this.sessionMetadata = this.config.sessionMetadata;
-            MessageFormatter.debug("Extracted session from config", { prefix: "Session" });
-            return;
-        }
-        // Fall back to finding session from Appwrite CLI preferences
-        const sessionAuth = findSessionByEndpointAndProject(this.config.appwriteEndpoint, this.config.appwriteProject);
-        if (sessionAuth && isValidSessionCookie(sessionAuth.sessionCookie)) {
-            this.sessionCookie = sessionAuth.sessionCookie;
-            this.authMethod = "session";
-            this.sessionMetadata = {
-                email: sessionAuth.email
+    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
             };
-            MessageFormatter.debug(`Extracted session from CLI preferences for ${sessionAuth.email || 'unknown user'}`, { prefix: "Session" });
-            return;
         }
-        // No session found, using API key authentication
-        if (this.config.appwriteKey) {
-            this.authMethod = "apikey";
-            this.sessionCookie = undefined;
-            this.sessionMetadata = undefined;
-            MessageFormatter.debug("Using API key authentication", { prefix: "Session" });
-        }
-    }
-    /**
-     * Create session preservation options for passing to loadConfig
-     * Returns current session state to maintain authentication across config reloads
-     */
-    createSessionPreservationOptions() {
-        if (!this.sessionCookie || !isValidSessionCookie(this.sessionCookie)) {
-            return undefined;
+        catch (error) {
+            // If config not loaded, return empty status
+            return {
+                hasSession: false
+            };
         }
-        return createSessionPreservation(this.sessionCookie, this.sessionMetadata?.email, this.sessionMetadata?.expiresAt);
-    }
-    /**
-     * Get current session information for debugging/logging purposes
-     */
-    getSessionInfo() {
-        return {
-            hasSession: !!this.sessionCookie && isValidSessionCookie(this.sessionCookie),
-            authMethod: this.authMethod,
-            email: this.sessionMetadata?.email,
-            expiresAt: this.sessionMetadata?.expiresAt
-        };
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/cli/commands/configCommands.ts

@@ -14,6 +14,8 @@ import {
 import { createEmptyCollection } from "../../utils/setupFiles.js";
 import chalk from "chalk";
 import type { InteractiveCLI } from "../../interactiveCLI.js";
+import { ConfigManager } from "../../config/ConfigManager.js";
+import { UtilsController } from "../../utilsController.js";
 
 export const configCommands = {
   async migrateTypeScriptConfig(cli: InteractiveCLI): Promise<void> {
@@ -23,6 +25,10 @@ export const configCommands = {
       // Perform the migration
       await migrateConfig((cli as any).currentDir);
 
+      // Clear instances after migration to reload new config
+      UtilsController.clearInstance();
+      ConfigManager.resetInstance();
+
       // Reset the detection flag
       (cli as any).isUsingTypeScriptConfig = false;
 
@@ -173,7 +179,8 @@ export const configCommands = {
           }
 
           // Reinitialize controller with session preservation
-          (cli as any).controller = new UtilsController((cli as any).currentDir, directConfig);
+          UtilsController.clearInstance();
+          (cli as any).controller = UtilsController.getInstance((cli as any).currentDir, directConfig);
           await (cli as any).controller.init();
 
           MessageFormatter.success("Configuration reloaded with session preserved", { prefix: "Config" });