appwrite-utils-cli 1.6.3 → 1.6.5

package/dist/collections/methods.js

@@ -68,7 +68,8 @@ export const checkForCollection = async (db, dbId, collection) => {
         const items = isLegacyDatabases(db) ? response.collections : (response.tables || response.collections);
         if (items && items.length > 0) {
             MessageFormatter.info(`Collection found: ${items[0].$id}`, { prefix: "Collections" });
-            return { ...collection, ...items[0] };
+            // Return remote collection for update operations (don't merge local config over it)
+            return items[0];
         }
         else {
             MessageFormatter.info(`No collection found with name: ${collection.name}`, { prefix: "Collections" });
@@ -223,10 +224,8 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         attributes);
         // Add delay after creating attributes
         await delay(250);
-        const indexesToUse = indexes && indexes.length > 0
-            ? indexes
-            : config.collections?.find((c) => c.$id === collectionToUse.$id)
-                ?.indexes ?? [];
+        // For PUSH operations, only use indexes from local config (not remote)
+        const indexesToUse = indexes || [];
         MessageFormatter.progress("Creating Indexes", { prefix: "Collections" });
         await createOrUpdateIndexesWithStatusCheck(databaseId, database, collectionToUse.$id, collectionToUse, indexesToUse);
         // Mark this collection as fully processed to prevent re-processing

package/dist/config/ConfigManager.d.ts

@@ -0,0 +1,445 @@
+import type { AppwriteConfig, Collection, CollectionCreate, AppwriteFunction } from "appwrite-utils";
+import { type ConfigOverrides, type SessionAuthInfo, type AuthenticationStatus, type ValidationResult } from "./services/index.js";
+/**
+ * Database type from AppwriteConfig
+ */
+type Database = {
+    $id: string;
+    name: string;
+    bucket?: any;
+};
+/**
+ * Bucket type from AppwriteConfig
+ */
+type Bucket = {
+    $id: string;
+    name: string;
+    $permissions?: any[];
+    [key: string]: any;
+};
+/**
+ * Options for loading configuration
+ */
+export interface ConfigLoadOptions {
+    /**
+     * Directory to start searching for config files
+     * @default process.cwd()
+     */
+    configDir?: string;
+    /**
+     * Force reload configuration even if cached
+     * @default false
+     */
+    forceReload?: boolean;
+    /**
+     * Validate configuration after loading
+     * @default false
+     */
+    validate?: boolean;
+    /**
+     * Use strict validation mode (warnings as errors)
+     * @default false
+     */
+    strictMode?: boolean;
+    /**
+     * Report validation results to console
+     * @default false
+     */
+    reportValidation?: boolean;
+    /**
+     * Override configuration values
+     */
+    overrides?: ConfigOverrides;
+    /**
+     * Override session authentication (used for preserving session on reload)
+     */
+    sessionOverride?: SessionAuthInfo;
+}
+/**
+ * Filter function for collections (accepts both Collection and CollectionCreate)
+ */
+export type CollectionFilter = (collection: Collection | CollectionCreate) => boolean;
+/**
+ * Centralized configuration manager with intelligent caching and session management.
+ *
+ * This singleton provides a unified interface for:
+ * - Configuration discovery and loading (YAML, TypeScript, JSON)
+ * - Session authentication with automatic caching
+ * - Configuration validation and merging
+ * - Session preservation across reloads
+ * - File watching for configuration changes
+ *
+ * @example
+ * ```typescript
+ * const configManager = ConfigManager.getInstance();
+ *
+ * // Load configuration (cached after first call)
+ * const config = await configManager.loadConfig({
+ *   validate: true,
+ *   reportValidation: true,
+ * });
+ *
+ * // Get cached config synchronously
+ * const cachedConfig = configManager.getConfig();
+ *
+ * // Reload with session preservation
+ * const reloadedConfig = await configManager.reloadConfig();
+ *
+ * // Watch for config changes
+ * const unwatch = configManager.watchConfig(async (config) => {
+ *   console.log("Config changed:", config);
+ * });
+ * ```
+ */
+export declare class ConfigManager {
+    private static instance;
+    /**
+     * Get the ConfigManager singleton instance
+     *
+     * @returns The singleton ConfigManager instance
+     *
+     * @example
+     * ```typescript
+     * const configManager = ConfigManager.getInstance();
+     * ```
+     */
+    static getInstance(): ConfigManager;
+    /**
+     * Reset the singleton instance (useful for testing)
+     *
+     * @example
+     * ```typescript
+     * ConfigManager.resetInstance();
+     * const newInstance = ConfigManager.getInstance();
+     * ```
+     */
+    static resetInstance(): void;
+    private cachedConfig;
+    private cachedConfigPath;
+    private cachedSession;
+    private lastLoadTimestamp;
+    private isInitialized;
+    private discoveryService;
+    private loaderService;
+    private validationService;
+    private sessionService;
+    private mergeService;
+    /**
+     * Private constructor to enforce singleton pattern.
+     * Use ConfigManager.getInstance() instead.
+     */
+    private constructor();
+    /**
+     * Load configuration with intelligent caching and session management.
+     *
+     * This method orchestrates the entire configuration loading flow:
+     * 1. Returns cached config if available (unless forceReload is true)
+     * 2. Discovers config file using ConfigDiscoveryService
+     * 3. Loads config from file using ConfigLoaderService
+     * 4. Loads and merges session authentication using SessionAuthService
+     * 5. Applies CLI/environment overrides using ConfigMergeService
+     * 6. Validates configuration if requested
+     * 7. Caches the result for future calls
+     *
+     * @param options - Configuration loading options
+     * @returns The loaded and processed configuration
+     * @throws Error if no configuration file is found
+     * @throws Error if validation fails in strict mode
+     *
+     * @example
+     * ```typescript
+     * const config = await configManager.loadConfig({
+     *   configDir: process.cwd(),
+     *   validate: true,
+     *   strictMode: true,
+     *   reportValidation: true,
+     *   overrides: {
+     *     appwriteEndpoint: "https://custom.endpoint.com/v1"
+     *   }
+     * });
+     * ```
+     */
+    loadConfig(options?: ConfigLoadOptions): Promise<AppwriteConfig>;
+    /**
+     * Get the cached configuration synchronously.
+     *
+     * @returns The cached configuration
+     * @throws Error if configuration has not been loaded yet
+     *
+     * @example
+     * ```typescript
+     * const config = configManager.getConfig();
+     * ```
+     */
+    getConfig(): AppwriteConfig;
+    /**
+     * Get the path to the loaded configuration file.
+     *
+     * @returns The configuration file path, or null if not loaded
+     *
+     * @example
+     * ```typescript
+     * const configPath = configManager.getConfigPath();
+     * console.log(`Config loaded from: ${configPath}`);
+     * ```
+     */
+    getConfigPath(): string | null;
+    /**
+     * Check if configuration has been loaded.
+     *
+     * @returns True if configuration is loaded and cached
+     *
+     * @example
+     * ```typescript
+     * if (!configManager.hasConfig()) {
+     *   await configManager.loadConfig();
+     * }
+     * ```
+     */
+    hasConfig(): boolean;
+    /**
+     * Check if the ConfigManager has been initialized.
+     *
+     * @returns True if initialized (config loaded at least once)
+     *
+     * @example
+     * ```typescript
+     * if (configManager.isConfigInitialized()) {
+     *   console.log("Config ready");
+     * }
+     * ```
+     */
+    isConfigInitialized(): boolean;
+    /**
+     * Invalidate the configuration cache.
+     * Next call to loadConfig() will reload from disk.
+     *
+     * @example
+     * ```typescript
+     * configManager.invalidateCache();
+     * const freshConfig = await configManager.loadConfig();
+     * ```
+     */
+    invalidateCache(): void;
+    /**
+     * Reload configuration from disk, preserving current session.
+     *
+     * This is a convenience method that combines invalidation and reloading
+     * while automatically preserving the current session authentication.
+     *
+     * @param options - Configuration loading options (forceReload is automatically set)
+     * @returns The reloaded configuration
+     *
+     * @example
+     * ```typescript
+     * // Reload config after manual file changes
+     * const config = await configManager.reloadConfig({
+     *   validate: true,
+     *   reportValidation: true
+     * });
+     * ```
+     */
+    reloadConfig(options?: Omit<ConfigLoadOptions, "forceReload">): Promise<AppwriteConfig>;
+    /**
+     * Get the current session information.
+     *
+     * @returns The cached session info, or null if no session
+     *
+     * @example
+     * ```typescript
+     * const session = configManager.getSession();
+     * if (session) {
+     *   console.log(`Authenticated as: ${session.email}`);
+     * }
+     * ```
+     */
+    getSession(): SessionAuthInfo | null;
+    /**
+     * Check if a session is available.
+     *
+     * @returns True if a session is cached
+     *
+     * @example
+     * ```typescript
+     * if (configManager.hasSession()) {
+     *   console.log("Using session authentication");
+     * } else {
+     *   console.log("Using API key authentication");
+     * }
+     * ```
+     */
+    hasSession(): boolean;
+    /**
+     * Refresh session from disk (bypasses session cache).
+     *
+     * This forces SessionAuthService to reload from ~/.appwrite/prefs.json
+     * and update the cached session.
+     *
+     * @returns The refreshed session, or null if no session found
+     *
+     * @example
+     * ```typescript
+     * // After logging in via appwrite CLI
+     * const session = await configManager.refreshSession();
+     * if (session) {
+     *   console.log("Session refreshed successfully");
+     * }
+     * ```
+     */
+    refreshSession(): Promise<SessionAuthInfo | null>;
+    /**
+     * Get authentication status for the current configuration.
+     *
+     * @returns Authentication status object with details about current auth method
+     * @throws Error if configuration has not been loaded
+     *
+     * @example
+     * ```typescript
+     * const authStatus = await configManager.getAuthStatus();
+     * console.log(`Auth method: ${authStatus.authMethod}`);
+     * console.log(`Has valid session: ${authStatus.hasValidSession}`);
+     * ```
+     */
+    getAuthStatus(): Promise<AuthenticationStatus>;
+    /**
+     * Clear the cached session.
+     * Next load will attempt to find a new session.
+     *
+     * @example
+     * ```typescript
+     * configManager.clearSession();
+     * const config = await configManager.reloadConfig();
+     * ```
+     */
+    clearSession(): void;
+    /**
+     * Validate the current configuration (warnings allowed).
+     *
+     * @param reportResults - Whether to report validation results to console
+     * @returns Validation result with errors and warnings
+     * @throws Error if configuration has not been loaded
+     *
+     * @example
+     * ```typescript
+     * const validation = configManager.validateConfig(true);
+     * if (!validation.isValid) {
+     *   console.log(`Found ${validation.errors.length} errors`);
+     * }
+     * ```
+     */
+    validateConfig(reportResults?: boolean): ValidationResult;
+    /**
+     * Validate the current configuration in strict mode (warnings as errors).
+     *
+     * @param reportResults - Whether to report validation results to console
+     * @returns Validation result with errors and warnings (warnings treated as errors)
+     * @throws Error if configuration has not been loaded
+     *
+     * @example
+     * ```typescript
+     * const validation = configManager.validateConfigStrict(true);
+     * if (!validation.isValid) {
+     *   console.log("Config validation failed (strict mode)");
+     * }
+     * ```
+     */
+    validateConfigStrict(reportResults?: boolean): ValidationResult;
+    /**
+     * Watch configuration file for changes and reload automatically.
+     *
+     * Returns a function to stop watching.
+     *
+     * @param callback - Function to call when config changes
+     * @returns Function to stop watching
+     *
+     * @example
+     * ```typescript
+     * const unwatch = configManager.watchConfig(async (config) => {
+     *   console.log("Config changed, reloading...");
+     *   // Handle config change
+     * });
+     *
+     * // Later, stop watching
+     * unwatch();
+     * ```
+     */
+    watchConfig(callback: (config: AppwriteConfig) => void | Promise<void>): () => void;
+    /**
+     * Merge overrides into the current configuration without persisting.
+     *
+     * This creates a new config object with overrides applied, without
+     * affecting the cached configuration.
+     *
+     * @param overrides - Configuration overrides to apply
+     * @returns New configuration with overrides applied
+     * @throws Error if configuration has not been loaded
+     *
+     * @example
+     * ```typescript
+     * const customConfig = configManager.mergeOverrides({
+     *   appwriteEndpoint: "https://test.endpoint.com/v1"
+     * });
+     * ```
+     */
+    mergeOverrides(overrides: ConfigOverrides): AppwriteConfig;
+    /**
+     * Get collections from the configuration, optionally filtered.
+     *
+     * @param filter - Optional filter function for collections
+     * @returns Array of collections (or tables, depending on API mode)
+     *
+     * @example
+     * ```typescript
+     * // Get all collections
+     * const allCollections = configManager.getCollections();
+     *
+     * // Get enabled collections only
+     * const enabledCollections = configManager.getCollections(
+     *   (c) => c.enabled !== false
+     * );
+     * ```
+     */
+    getCollections(filter?: CollectionFilter): (Collection | CollectionCreate)[];
+    /**
+     * Get databases from the configuration.
+     *
+     * @returns Array of databases
+     *
+     * @example
+     * ```typescript
+     * const databases = configManager.getDatabases();
+     * console.log(`Found ${databases.length} databases`);
+     * ```
+     */
+    getDatabases(): Database[];
+    /**
+     * Get buckets from the configuration.
+     *
+     * @returns Array of buckets
+     *
+     * @example
+     * ```typescript
+     * const buckets = configManager.getBuckets();
+     * console.log(`Found ${buckets.length} buckets`);
+     * ```
+     */
+    getBuckets(): Bucket[];
+    /**
+     * Get functions from the configuration.
+     *
+     * @returns Array of functions
+     *
+     * @example
+     * ```typescript
+     * const functions = configManager.getFunctions();
+     * console.log(`Found ${functions.length} functions`);
+     * ```
+     */
+    getFunctions(): AppwriteFunction[];
+    /**
+     * Get cached config with optional overrides applied.
+     * Used internally to avoid reloading when only overrides change.
+     */
+    private getCachedConfigWithOverrides;
+}
+export {};