appwrite-utils-cli 1.9.7 → 1.12.0

package/src/users/methods.ts

@@ -1,359 +0,0 @@
-import type { AppwriteConfig, ConfigCollection } from "appwrite-utils";
-import {
-  AppwriteException,
-  Databases,
-  ID,
-  Query,
-  Users,
-  type Models,
-} from "node-appwrite";
-import {
-  AuthUserSchema,
-  type AuthUser,
-  type AuthUserCreate,
-} from "../schemas/authUser.js";
-import { logger } from "../shared/logging.js";
-import { splitIntoBatches } from "../shared/migrationHelpers.js";
-import {
-  getAppwriteClient,
-  tryAwaitWithRetry,
-} from "../utils/helperFunctions.js";
-import { isUndefined } from "es-toolkit/compat";
-import { isEmpty } from "es-toolkit/compat";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-
-export class UsersController {
-  private config: AppwriteConfig;
-  private users: Users;
-  static userFields = [
-    "email",
-    "name",
-    "password",
-    "phone",
-    "labels",
-    "prefs",
-    "userId",
-    "$createdAt",
-    "$updatedAt",
-  ];
-
-  constructor(config: AppwriteConfig, db: Databases) {
-    this.config = config;
-    this.users = new Users(this.config.appwriteClient!);
-  }
-
-  async wipeUsers() {
-    const allUsers = await this.getAllUsers();
-    MessageFormatter.progress("Deleting all users...", { prefix: "Users" });
-
-    const createBatches = (finalData: any[], batchSize: number) => {
-      const finalBatches: any[][] = [];
-      for (let i = 0; i < finalData.length; i += batchSize) {
-        finalBatches.push(finalData.slice(i, i + batchSize));
-      }
-      return finalBatches;
-    };
-
-    let usersDeleted = 0;
-    if (allUsers.length > 0) {
-      const batchedUserPromises = createBatches(allUsers, 25); // Batch size of 25
-
-      for (const batch of batchedUserPromises) {
-        MessageFormatter.progress(`Deleting ${batch.length} users...`, { prefix: "Users" });
-        await Promise.all(
-          batch.map((user) =>
-            tryAwaitWithRetry(async () => await this.users.delete(user.$id))
-          )
-        );
-        usersDeleted += batch.length;
-        if (usersDeleted % 100 === 0) {
-          MessageFormatter.progress(`Deleted ${usersDeleted} users...`, { prefix: "Users" });
-        }
-      }
-    } else {
-      MessageFormatter.info("No users to delete", { prefix: "Users" });
-    }
-  }
-
-  async getAllUsers() {
-    const allUsers: Models.User<Models.Preferences>[] = [];
-    const users = await tryAwaitWithRetry(
-      async () => await this.users.list([Query.limit(200)])
-    );
-    if (users.users.length === 0) {
-      return [];
-    }
-    if (users.users.length === 200) {
-      let lastDocumentId = users.users[users.users.length - 1].$id;
-      allUsers.push(...users.users);
-      while (lastDocumentId) {
-        const moreUsers = await tryAwaitWithRetry(
-          async () =>
-            await this.users.list([
-              Query.limit(200),
-              Query.cursorAfter(lastDocumentId),
-            ])
-        );
-        allUsers.push(...moreUsers.users);
-        if (moreUsers.users.length < 200) {
-          break;
-        }
-        lastDocumentId = moreUsers.users[moreUsers.users.length - 1].$id;
-      }
-    } else {
-      allUsers.push(...users.users);
-    }
-    return allUsers;
-  }
-
-  async createUsersAndReturn(items: AuthUserCreate[]): Promise<any[]> {
-    const users = await Promise.all(
-      items.map((item) => this.createUserAndReturn(item))
-    );
-    return users;
-  }
-
-  async createUserAndReturn(item: AuthUserCreate): Promise<any> {
-    try {
-      const user = await tryAwaitWithRetry(async () => {
-        const createdUser = await this.users.create(
-          item.userId || ID.unique(),
-          item.email || undefined,
-          item.phone && item.phone.length < 15 && item.phone.startsWith("+")
-            ? item.phone
-            : undefined,
-          `changeMe${item.email?.toLowerCase()}` || `changeMePlease`,
-          item.name || undefined
-        );
-
-        if (item.labels) {
-          await this.users.updateLabels(createdUser.$id, item.labels);
-        }
-        if (item.prefs) {
-          await this.users.updatePrefs(createdUser.$id, item.prefs);
-        }
-
-        return createdUser;
-      }); // Set throwError to true since we want to handle errors
-
-      return user;
-    } catch (e) {
-      if (e instanceof Error) {
-        logger.error("FAILED CREATING USER: ", e.message, item);
-      }
-    }
-  }
-
-  async createAndCheckForUserAndReturn(item: AuthUserCreate) {
-    let userToReturn: Models.User<Models.Preferences> | undefined = undefined;
-    try {
-      // Attempt to find an existing user by email or phone.
-      let foundUsers: Models.User<Models.Preferences>[] = [];
-      if (item.email) {
-        const foundUsersByEmail = await this.users.list([
-          Query.equal("email", item.email),
-        ]);
-        foundUsers = foundUsersByEmail.users;
-      }
-      if (item.phone) {
-        const foundUsersByPhone = await this.users.list([
-          Query.equal("phone", item.phone),
-        ]);
-        foundUsers = foundUsers.length
-          ? foundUsers.concat(foundUsersByPhone.users)
-          : foundUsersByPhone.users;
-      }
-
-      userToReturn = foundUsers[0] || undefined;
-
-      if (!userToReturn) {
-        userToReturn = await this.users.create(
-          item.userId || ID.unique(),
-          item.email || undefined,
-          item.phone && item.phone.length < 15 && item.phone.startsWith("+")
-            ? item.phone
-            : undefined,
-          item.password?.toLowerCase() ||
-            `changeMe${item.email?.toLowerCase()}` ||
-            `changeMePlease`,
-          item.name || undefined
-        );
-      } else {
-        // Update user details as necessary, ensuring email uniqueness if attempting an update.
-        if (
-          item.email &&
-          item.email !== userToReturn.email &&
-          !isEmpty(item.email) &&
-          !isUndefined(item.email)
-        ) {
-          const emailExists = await this.users.list([
-            Query.equal("email", item.email),
-          ]);
-          if (emailExists.users.length === 0) {
-            userToReturn = await this.users.updateEmail(
-              userToReturn.$id,
-              item.email
-            );
-          } else {
-            MessageFormatter.warning("Email update skipped: Email already exists.", { prefix: "Users" });
-          }
-        }
-        if (item.password) {
-          userToReturn = await this.users.updatePassword(
-            userToReturn.$id,
-            item.password.toLowerCase()
-          );
-        }
-        if (item.name && item.name !== userToReturn.name) {
-          userToReturn = await this.users.updateName(
-            userToReturn.$id,
-            item.name
-          );
-        }
-        if (
-          item.phone &&
-          item.phone !== userToReturn.phone &&
-          item.phone.length < 15 &&
-          item.phone.startsWith("+") &&
-          (isUndefined(userToReturn.phone) || isEmpty(userToReturn.phone))
-        ) {
-          const userFoundWithPhone = await this.users.list([
-            Query.equal("phone", item.phone),
-          ]);
-          if (userFoundWithPhone.total === 0) {
-            userToReturn = await this.users.updatePhone(
-              userToReturn.$id,
-              item.phone
-            );
-          }
-        }
-      }
-      if (item.$createdAt && item.$updatedAt) {
-        MessageFormatter.warning(
-          "$createdAt and $updatedAt are not yet supported, sorry about that!",
-          { prefix: "Users" }
-        );
-      }
-      if (item.labels && item.labels.length) {
-        userToReturn = await this.users.updateLabels(
-          userToReturn.$id,
-          item.labels
-        );
-      }
-      if (item.prefs && Object.keys(item.prefs).length) {
-        await this.users.updatePrefs(userToReturn.$id, item.prefs);
-        userToReturn.prefs = item.prefs;
-      }
-      return userToReturn;
-    } catch (error) {
-      return userToReturn;
-    }
-  }
-
-  async getUserIdByEmailOrPhone(email?: string, phone?: string) {
-    if (!email && !phone) {
-      return undefined;
-    }
-    if (email && phone) {
-      const foundUsersByEmail = await this.users.list([
-        // @ts-ignore
-        Query.or([Query.equal("email", email), Query.equal("phone", phone)]),
-      ]);
-      if (foundUsersByEmail.users.length > 0) {
-        return foundUsersByEmail.users[0]?.$id;
-      }
-    } else if (email) {
-      const foundUsersByEmail = await this.users.list([
-        Query.equal("email", email),
-      ]);
-      if (foundUsersByEmail.users.length > 0) {
-        return foundUsersByEmail.users[0]?.$id;
-      } else {
-        if (!phone) {
-          return undefined;
-        } else {
-          const foundUsersByPhone = await this.users.list([
-            Query.equal("phone", phone),
-          ]);
-          if (foundUsersByPhone.users.length > 0) {
-            return foundUsersByPhone.users[0]?.$id;
-          } else {
-            return undefined;
-          }
-        }
-      }
-    }
-    if (phone) {
-      const foundUsersByPhone = await this.users.list([
-        Query.equal("phone", phone),
-      ]);
-      if (foundUsersByPhone.users.length > 0) {
-        return foundUsersByPhone.users[0]?.$id;
-      } else {
-        return undefined;
-      }
-    }
-  }
-
-  transferUsersBetweenDbsLocalToRemote = async (
-    endpoint: string,
-    projectId: string,
-    apiKey: string
-  ) => {
-    const localUsers = this.users;
-    const client = getAppwriteClient(endpoint, projectId, apiKey);
-    const remoteUsers = new Users(client);
-
-    let fromUsers = await localUsers.list([Query.limit(50)]);
-
-    if (fromUsers.users.length === 0) {
-      MessageFormatter.info("No users found", { prefix: "Users" });
-      return;
-    } else if (fromUsers.users.length < 50) {
-      MessageFormatter.progress(`Transferring ${fromUsers.users.length} users to remote`, { prefix: "Users" });
-      const batchedPromises = fromUsers.users.map((user) => {
-        return tryAwaitWithRetry(async () => {
-          const toCreateObject: Partial<typeof user> = {
-            ...user,
-          };
-          delete toCreateObject.$id;
-          delete toCreateObject.$createdAt;
-          delete toCreateObject.$updatedAt;
-          await remoteUsers.create(
-            user.$id,
-            user.email,
-            user.phone,
-            user.password,
-            user.name
-          );
-        });
-      });
-      await Promise.all(batchedPromises);
-    } else {
-      while (fromUsers.users.length === 50) {
-        fromUsers = await localUsers.list([
-          Query.limit(50),
-          Query.cursorAfter(fromUsers.users[fromUsers.users.length - 1].$id),
-        ]);
-        const batchedPromises = fromUsers.users.map((user) => {
-          return tryAwaitWithRetry(async () => {
-            const toCreateObject: Partial<typeof user> = {
-              ...user,
-            };
-            delete toCreateObject.$id;
-            delete toCreateObject.$createdAt;
-            delete toCreateObject.$updatedAt;
-            await remoteUsers.create(
-              user.$id,
-              user.email,
-              user.phone,
-              user.password,
-              user.name
-            );
-          });
-        });
-        await Promise.all(batchedPromises);
-      }
-    }
-  };
-}

package/src/utils/ClientFactory.ts

@@ -1,240 +0,0 @@
-import { Client } from "node-appwrite";
-import type { AppwriteConfig } from "appwrite-utils";
-import { AdapterFactory } from "../adapters/AdapterFactory.js";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-import { logger } from "../shared/logging.js";
-
-/**
- * Factory for creating authenticated Appwrite clients and database adapters.
- *
- * This factory provides a clean separation of concerns by taking pre-configured
- * AppwriteConfig objects (with authentication already resolved by ConfigManager)
- * and creating the necessary client and adapter instances.
- *
- * Key features:
- * - Takes pre-authenticated config from ConfigManager
- * - Creates client with appropriate authentication method
- * - Creates adapter with automatic version detection
- * - Leverages AdapterFactory's internal caching for performance
- *
- * @example
- * ```typescript
- * const configManager = ConfigManager.getInstance();
- * const config = await configManager.loadConfig();
- *
- * // Config already has session or API key resolved
- * const { client, adapter } = await ClientFactory.createFromConfig(config);
- * ```
- */
-export class ClientFactory {
-  /**
-   * Create authenticated client and database adapter from configuration.
-   *
-   * This method expects the config to have authentication already resolved:
-   * - Either `sessionCookie` is set (from ConfigManager's session loading)
-   * - Or `appwriteKey` is set (from config file or CLI overrides)
-   *
-   * The ConfigManager handles all session discovery and authentication priority,
-   * so this factory simply applies the resolved authentication to the client.
-   *
-   * @param config - AppwriteConfig with resolved authentication
-   * @returns Object containing authenticated client and database adapter
-   * @throws Error if no authentication method is available in config
-   *
-   * @example
-   * ```typescript
-   * const config = await ConfigManager.getInstance().loadConfig();
-   * const { client, adapter } = await ClientFactory.createFromConfig(config);
-   *
-   * // Client is now authenticated and ready to use
-   * const databases = new Databases(client);
-   * const collections = await adapter.listCollections(databaseId);
-   * ```
-   */
-  public static async createFromConfig(
-    config: AppwriteConfig
-  ): Promise<{ client: Client; adapter: DatabaseAdapter }> {
-    logger.debug("Creating client from config", {
-      prefix: "ClientFactory",
-      hasSession: !!config.sessionCookie,
-      hasApiKey: !!config.appwriteKey,
-      endpoint: config.appwriteEndpoint,
-      project: config.appwriteProject,
-    });
-
-    // Create base client with endpoint and project
-    const client = new Client()
-      .setEndpoint(config.appwriteEndpoint)
-      .setProject(config.appwriteProject);
-
-    // Apply authentication based on authMethod preference with mode headers
-    // Mode headers: "admin" for sessions (elevated permissions), "default" for API keys
-    const authMethod = config.authMethod || "auto";
-
-    logger.debug("Applying authentication with mode headers", {
-      prefix: "ClientFactory",
-      authMethod,
-      hasApiKey: !!config.appwriteKey,
-      hasSession: !!config.sessionCookie,
-    });
-
-    if (authMethod === "session") {
-      // Explicit session preference - use only session with admin mode
-      if (!config.sessionCookie) {
-        const error = new Error(
-          "authMethod set to 'session' but no session cookie available.\n\n" +
-          "Either:\n" +
-          "  - Run 'appwrite login' to create a session\n" +
-          "  - Change authMethod to 'apikey' or 'auto'\n" +
-          "  - Provide --sessionCookie flag"
-        );
-        logger.error("Failed to create client - session required", { prefix: "ClientFactory" });
-        throw error;
-      }
-      client.setSession(config.sessionCookie);
-      client.headers['X-Appwrite-Mode'] =  'admin';
-      logger.debug("Applied session authentication with admin mode (explicit preference)", {
-        prefix: "ClientFactory",
-        email: config.sessionMetadata?.email,
-      });
-
-    } else if (authMethod === "apikey") {
-      // Explicit API key preference - use only API key with default mode
-      if (!config.appwriteKey || config.appwriteKey.trim().length === 0) {
-        const error = new Error(
-          "authMethod set to 'apikey' but no API key provided.\n\n" +
-          "Either:\n" +
-          "  - Set appwriteKey in your config file\n" +
-          "  - Provide --apiKey flag\n" +
-          "  - Set APPWRITE_API_KEY environment variable"
-        );
-        logger.error("Failed to create client - API key required", { prefix: "ClientFactory" });
-        throw error;
-      }
-      client.setKey(config.appwriteKey);
-      client.headers['X-Appwrite-Mode'] = 'default';
-      logger.debug("Applied API key authentication with default mode (explicit preference)", {
-        prefix: "ClientFactory",
-      });
-
-    } else {
-      // Auto mode: Prefer session with admin mode (like official CLI), fallback to API key
-      if (config.sessionCookie) {
-        client.setSession(config.sessionCookie);
-        client.headers['X-Appwrite-Mode'] = 'admin';
-        logger.debug("Applied session authentication with admin mode (auto - preferred)", {
-          prefix: "ClientFactory",
-          email: config.sessionMetadata?.email,
-        });
-      } else if (config.appwriteKey && config.appwriteKey.trim().length > 0) {
-        client.setKey(config.appwriteKey);
-        client.headers['X-Appwrite-Mode'] = 'default';
-        logger.debug("Applied API key authentication with default mode (auto - fallback)", {
-          prefix: "ClientFactory",
-        });
-      } else {
-        // No authentication available
-        const error = new Error(
-          "No authentication method available in configuration.\n\n" +
-          "Expected either:\n" +
-          "  - config.sessionCookie (from session authentication via 'appwrite login')\n" +
-          "  - config.appwriteKey (from config file, CLI flags, or environment)\n\n" +
-          "Suggestion:\n" +
-          "  - Run 'appwrite login' to create a session, OR\n" +
-          "  - Add appwriteKey to your config file, OR\n" +
-          "  - Provide --apiKey flag"
-        );
-        logger.error("Failed to create client - no authentication", { prefix: "ClientFactory" });
-        throw error;
-      }
-    }
-
-    // Create adapter with version detection
-    // AdapterFactory uses internal caching, so repeated calls are fast
-    logger.debug("Creating database adapter", {
-      prefix: "ClientFactory",
-      apiMode: config.apiMode || "auto",
-    });
-
-    const { adapter } = await AdapterFactory.createFromConfig(config);
-
-    logger.debug("Client and adapter created successfully", {
-      prefix: "ClientFactory",
-      adapterType: adapter.getApiMode(),
-    });
-
-    return { client, adapter };
-  }
-
-  /**
-   * Create client and adapter from individual parameters.
-   *
-   * This is a lower-level method for cases where you don't have a full
-   * AppwriteConfig object. For most use cases, prefer createFromConfig().
-   *
-   * @param endpoint - Appwrite endpoint URL
-   * @param project - Appwrite project ID
-   * @param options - Authentication and API mode options
-   * @returns Object containing authenticated client and database adapter
-   * @throws Error if no authentication method is provided
-   *
-   * @example
-   * ```typescript
-   * const { client, adapter } = await ClientFactory.create(
-   *   "https://cloud.appwrite.io/v1",
-   *   "my-project-id",
-   *   {
-   *     apiKey: "my-api-key",
-   *     apiMode: "auto"
-   *   }
-   * );
-   * ```
-   */
-  public static async create(
-    endpoint: string,
-    project: string,
-    options: {
-      apiKey?: string;
-      sessionCookie?: string;
-      apiMode?: "auto" | "legacy" | "tablesdb";
-    } = {}
-  ): Promise<{ client: Client; adapter: DatabaseAdapter }> {
-    logger.debug("Creating client from parameters", {
-      prefix: "ClientFactory",
-      hasSession: !!options.sessionCookie,
-      hasApiKey: !!options.apiKey,
-      endpoint,
-      project,
-    });
-
-    // Create minimal config object
-    const config: AppwriteConfig = {
-      appwriteEndpoint: endpoint,
-      appwriteProject: project,
-      appwriteKey: options.apiKey || "",
-      sessionCookie: options.sessionCookie,
-      apiMode: options.apiMode || "auto",
-      // Minimal required fields
-      appwriteClient: null,
-      authMethod: options.sessionCookie ? "session" : "apikey",
-      enableBackups: false,
-      backupInterval: 0,
-      backupRetention: 0,
-      enableBackupCleanup: false,
-      enableMockData: false,
-      documentBucketId: "",
-      usersCollectionName: "",
-      databases: [],
-      buckets: [],
-      functions: [],
-      logging: {
-        enabled: false,
-        level: "info",
-        console: false,
-      },
-    };
-
-    // Use main createFromConfig method
-    return this.createFromConfig(config);
-  }
-}