appwrite-utils-cli 1.11.0 → 1.12.0

package/src/users/methods.ts

@@ -1,358 +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, MessageFormatter } from "appwrite-utils-helpers";
-import { splitIntoBatches } from "../shared/migrationHelpers.js";
-import {
-  getAppwriteClient,
-  tryAwaitWithRetry,
-} from "appwrite-utils-helpers";
-import { isUndefined } from "es-toolkit/compat";
-import { isEmpty } from "es-toolkit/compat";
-
-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/configMigration.ts

@@ -1,348 +0,0 @@
-import { promises as fs } from "fs";
-import path from "path";
-import { existsSync } from "fs";
-import { MessageFormatter } from "appwrite-utils-helpers";
-import { ConfirmationDialogs } from "../shared/confirmationDialogs.js";
-import yaml from "js-yaml";
-
-interface AppwriteConfigTS {
-  appwriteEndpoint: string;
-  appwriteProject: string;
-  appwriteKey: string;
-  enableBackups?: boolean;
-  backupInterval?: number;
-  backupRetention?: number;
-  enableBackupCleanup?: boolean;
-  enableMockData?: boolean;
-  documentBucketId?: string;
-  usersCollectionName?: string;
-  databases: Array<{ $id: string; name: string }>;
-  buckets: Array<any>;
-  [key: string]: any;
-}
-
-interface AppwriteConfigYAML {
-  appwrite: {
-    endpoint: string;
-    project: string;
-    key: string;
-  };
-  logging: {
-    enabled: boolean;
-    level: string;
-    console: boolean;
-    logDirectory: string;
-  };
-  backups: {
-    enabled: boolean;
-    interval: number;
-    retention: number;
-    cleanup: boolean;
-  };
-  data: {
-    enableMockData: boolean;
-    documentBucketId: string;
-    usersCollectionName: string;
-    importDirectory: string;
-  };
-  schemas: {
-    outputDirectory: string;
-    yamlSchemaDirectory: string;
-  };
-  migrations: {
-    enabled: boolean;
-  };
-  databases: Array<{ id: string; name: string; collections?: string[] }>;
-  buckets: Array<any>;
-  functions: Array<any>;
-}
-
-export async function migrateConfig(workingDir: string): Promise<void> {
-  try {
-    // Look for appwriteConfig.ts files in the working directory and subdirectories
-    const configFiles = await findAppwriteConfigFiles(workingDir);
-    
-    if (configFiles.length === 0) {
-      MessageFormatter.info("No appwriteConfig.ts files found to migrate", { prefix: "Migration" });
-      return;
-    }
-
-    MessageFormatter.info(`Found ${configFiles.length} appwriteConfig.ts file(s) to migrate`, { prefix: "Migration" });
-
-    for (const configFile of configFiles) {
-      await migrateConfigFile(configFile, workingDir);
-    }
-
-    MessageFormatter.success("Migration completed successfully", { prefix: "Migration" });
-  } catch (error) {
-    MessageFormatter.error("Migration failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
-    throw error;
-  }
-}
-
-async function findAppwriteConfigFiles(dir: string): Promise<string[]> {
-  const configFiles: string[] = [];
-  
-  const checkDir = async (currentDir: string) => {
-    try {
-      const entries = await fs.readdir(currentDir, { withFileTypes: true });
-      
-      for (const entry of entries) {
-        const fullPath = path.join(currentDir, entry.name);
-        
-        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-          await checkDir(fullPath);
-        } else if (entry.isFile() && entry.name === 'appwriteConfig.ts') {
-          configFiles.push(fullPath);
-        }
-      }
-    } catch (error) {
-      // Ignore directory access errors
-    }
-  };
-
-  await checkDir(dir);
-  return configFiles;
-}
-
-async function migrateConfigFile(configFilePath: string, workingDir: string): Promise<void> {
-  const configDir = path.dirname(configFilePath);
-  const appwriteDir = path.join(path.dirname(configDir), '.appwrite');
-  
-  MessageFormatter.info(`Migrating ${path.relative(workingDir, configFilePath)}`, { prefix: "Migration" });
-
-  // Check if .appwrite directory already exists
-  if (existsSync(appwriteDir)) {
-    const shouldOverwrite = await ConfirmationDialogs.confirmOverwrite(
-      `.appwrite directory already exists at ${path.relative(workingDir, appwriteDir)}`
-    );
-    if (!shouldOverwrite) {
-      MessageFormatter.info("Skipping migration for this config", { prefix: "Migration" });
-      return;
-    }
-  }
-
-  // Load and parse the TypeScript config
-  const config = await parseTypeScriptConfig(configFilePath);
-
-  // Create .appwrite directory
-  await fs.mkdir(appwriteDir, { recursive: true });
-
-  // Convert config to YAML and save
-  const yamlConfig = convertToYAMLConfig(config);
-  const yamlContent = yaml.dump(yamlConfig, { 
-    indent: 2,
-    lineWidth: 120,
-    noRefs: true 
-  });
-  await fs.writeFile(path.join(appwriteDir, 'config.yaml'), yamlContent);
-
-  // Copy all directories except collections and schemas (we handle collections separately, skip schemas entirely)
-  const entries = await fs.readdir(configDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isDirectory() && entry.name !== 'collections' && entry.name !== 'schemas') {
-      const sourcePath = path.join(configDir, entry.name);
-      const targetPath = path.join(appwriteDir, entry.name);
-      
-      await fs.cp(sourcePath, targetPath, { recursive: true });
-      MessageFormatter.info(`Copied ${entry.name}/ to .appwrite/${entry.name}/`, { prefix: "Migration" });
-    }
-  }
-
-  // Convert TypeScript collections to YAML collections
-  const collectionsPath = path.join(configDir, 'collections');
-  if (existsSync(collectionsPath)) {
-    const targetCollectionsPath = path.join(appwriteDir, 'collections');
-    await fs.mkdir(targetCollectionsPath, { recursive: true });
-    
-    const collectionFiles = await fs.readdir(collectionsPath);
-    for (const file of collectionFiles) {
-      if (file.endsWith('.ts')) {
-        await convertCollectionToYaml(path.join(collectionsPath, file), targetCollectionsPath);
-      }
-    }
-    MessageFormatter.info(`Converted TypeScript collections to YAML in .appwrite/collections/`, { prefix: "Migration" });
-  }
-
-  // Keep original config file in place (no backup needed since we're not deleting it)
-
-  MessageFormatter.success(`Migration completed for ${path.relative(workingDir, configFilePath)}`, { prefix: "Migration" });
-}
-
-async function parseTypeScriptConfig(configFilePath: string): Promise<AppwriteConfigTS> {
-  try {
-    // Use tsx to import the TypeScript config file directly
-    const { register } = await import("tsx/esm/api");
-    const { pathToFileURL } = await import("node:url");
-    
-    const unregister = register();
-    
-    try {
-      const configUrl = pathToFileURL(configFilePath).href;
-      const configModule = await import(configUrl);
-      const config = configModule.default?.default || configModule.default || configModule;
-      
-      if (!config) {
-        throw new Error("Failed to load config from TypeScript file");
-      }
-      
-      return config as AppwriteConfigTS;
-    } finally {
-      unregister();
-    }
-  } catch (error) {
-    MessageFormatter.error("Could not load TypeScript config", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
-    throw new Error('Failed to load TypeScript configuration file. Please ensure it exports a valid config object.');
-  }
-}
-
-function convertToYAMLConfig(config: AppwriteConfigTS): AppwriteConfigYAML {
-  // Convert the config to the nested YAML structure
-  const yamlConfig: AppwriteConfigYAML = {
-    appwrite: {
-      endpoint: config.appwriteEndpoint,
-      project: config.appwriteProject,
-      key: config.appwriteKey
-    },
-    logging: {
-      enabled: config.logging?.enabled ?? false,
-      level: config.logging?.level ?? "info",
-      console: config.logging?.console ?? false,
-      logDirectory: "./logs"
-    },
-    backups: {
-      enabled: config.enableBackups ?? false,
-      interval: config.backupInterval ?? 3600,
-      retention: config.backupRetention ?? 30,
-      cleanup: config.enableBackupCleanup ?? false
-    },
-    data: {
-      enableMockData: config.enableMockData ?? false,
-      documentBucketId: config.documentBucketId ?? "documents",
-      usersCollectionName: config.usersCollectionName ?? "Users",
-      importDirectory: "importData"
-    },
-    schemas: {
-      outputDirectory: "schemas",
-      yamlSchemaDirectory: ".yaml_schemas"
-    },
-    migrations: {
-      enabled: true
-    },
-    databases: (config.databases || []).map(db => ({
-      id: db.$id,
-      name: db.name,
-      collections: [] // Collections will be handled separately
-    })),
-    buckets: (config.buckets || []).map(bucket => ({
-      id: bucket.$id,
-      name: bucket.name,
-      permissions: bucket.$permissions?.map((p: any) => ({
-        permission: p.permission,
-        target: p.target
-      })) || [],
-      fileSecurity: bucket.fileSecurity ?? false,
-      enabled: bucket.enabled ?? true,
-      maximumFileSize: bucket.maximumFileSize ?? 30000000,
-      allowedFileExtensions: bucket.allowedFileExtensions || [],
-      compression: bucket.compression || "gzip",
-      encryption: bucket.encryption ?? false,
-      antivirus: bucket.antivirus ?? false
-    })),
-    functions: (config.functions || []).map((func: any) => ({
-      id: func.$id,
-      name: func.name,
-      runtime: func.runtime,
-      execute: func.execute || [],
-      events: func.events || [],
-      schedule: func.schedule || "",
-      timeout: func.timeout ?? 15,
-      enabled: func.enabled ?? true,
-      logging: func.logging ?? false,
-      entrypoint: func.entrypoint || "src/main.js",
-      commands: func.commands || "",
-      scopes: func.scopes || [],
-      specification: func.specification || "s-1vcpu-512mb"
-    }))
-  };
-
-  return yamlConfig;
-}
-
-async function convertCollectionToYaml(tsFilePath: string, targetDir: string): Promise<void> {
-  try {
-    // Load the TypeScript collection using tsx
-    const { register } = await import("tsx/esm/api");
-    const { pathToFileURL } = await import("node:url");
-    
-    const unregister = register();
-    
-    try {
-      const configUrl = pathToFileURL(tsFilePath).href;
-      const collectionModule = await import(configUrl);
-      const collection = collectionModule.default?.default || collectionModule.default || collectionModule;
-      
-      if (!collection) {
-        throw new Error("Failed to load collection from TypeScript file");
-      }
-
-      // Convert collection to YAML format
-      const yamlCollection = {
-        name: collection.name,
-        id: collection.$id,
-        documentSecurity: collection.documentSecurity ?? false,
-        enabled: collection.enabled ?? true,
-        permissions: (collection.permissions || collection.$permissions || []).map((p: any) => ({
-          permission: p.permission,
-          target: p.target
-        })),
-        attributes: (collection.attributes || []).map((attr: any) => ({
-          key: attr.key,
-          type: attr.type,
-          size: attr.size,
-          required: attr.required ?? false,
-          array: attr.array,
-          default: attr.xdefault || attr.default,
-          min: attr.min,
-          max: attr.max,
-          elements: attr.elements,
-          relatedCollection: attr.relatedCollection,
-          relationType: attr.relationType,
-          twoWay: attr.twoWay,
-          twoWayKey: attr.twoWayKey,
-          onDelete: attr.onDelete,
-          side: attr.side
-        })),
-        indexes: (collection.indexes || []).map((idx: any) => ({
-          key: idx.key,
-          type: idx.type,
-          attributes: idx.attributes,
-          orders: idx.orders
-        })),
-        importDefs: collection.importDefs || []
-      };
-
-      // Remove undefined values
-      const cleanYamlCollection = JSON.parse(JSON.stringify(yamlCollection, (key, value) => 
-        value === undefined ? undefined : value
-      ));
-
-      // Write YAML file
-      const fileName = path.basename(tsFilePath, '.ts') + '.yaml';
-      const targetPath = path.join(targetDir, fileName);
-      const yamlContent = yaml.dump(cleanYamlCollection, { 
-        indent: 2,
-        lineWidth: 120,
-        noRefs: true 
-      });
-      
-      await fs.writeFile(targetPath, yamlContent);
-      MessageFormatter.info(`Converted ${path.basename(tsFilePath)} to ${fileName}`, { prefix: "Migration" });
-      
-    } finally {
-      unregister();
-    }
-  } catch (error) {
-    MessageFormatter.error(`Failed to convert collection ${path.basename(tsFilePath)}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
-  }
-}