appwrite-utils-cli 1.11.0 → 1.12.0

package/dist/users/methods.js

@@ -0,0 +1,276 @@
+import { AppwriteException, Databases, ID, Query, Users, } from "node-appwrite";
+import { AuthUserSchema, } 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 {
+    config;
+    users;
+    static userFields = [
+        "email",
+        "name",
+        "password",
+        "phone",
+        "labels",
+        "prefs",
+        "userId",
+        "$createdAt",
+        "$updatedAt",
+    ];
+    constructor(config, db) {
+        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, batchSize) => {
+            const finalBatches = [];
+            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 = [];
+        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) {
+        const users = await Promise.all(items.map((item) => this.createUserAndReturn(item)));
+        return users;
+    }
+    async createUserAndReturn(item) {
+        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) {
+        let userToReturn = undefined;
+        try {
+            // Attempt to find an existing user by email or phone.
+            let foundUsers = [];
+            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, phone) {
+        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, projectId, apiKey) => {
+        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 = {
+                        ...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 = {
+                            ...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/dist/utils/configMigration.d.ts

@@ -0,0 +1 @@
+export declare function migrateConfig(workingDir: string): Promise<void>;

package/dist/utils/configMigration.js

@@ -0,0 +1,261 @@
+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";
+export async function migrateConfig(workingDir) {
+    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) {
+    const configFiles = [];
+    const checkDir = async (currentDir) => {
+        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, workingDir) {
+    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) {
+    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;
+        }
+        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) {
+    // Convert the config to the nested YAML structure
+    const yamlConfig = {
+        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) => ({
+                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) => ({
+            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, targetDir) {
+    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) => ({
+                    permission: p.permission,
+                    target: p.target
+                })),
+                attributes: (collection.attributes || []).map((attr) => ({
+                    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) => ({
+                    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" });
+    }
+}

package/dist/utils/index.js

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

package/dist/utils/loadConfigs.d.ts

@@ -0,0 +1,50 @@
+import { type AppwriteConfig } from "appwrite-utils";
+import { type ValidationResult } from "appwrite-utils-helpers";
+/**
+ * Session authentication preservation options for config loading
+ */
+export interface SessionPreservationOptions {
+    sessionCookie?: string;
+    authMethod?: "session" | "apikey" | "auto";
+    sessionMetadata?: {
+        email?: string;
+        expiresAt?: string;
+    };
+}
+/**
+ * Configuration loading options
+ */
+export interface ConfigLoadingOptions {
+    validate?: boolean;
+    strictMode?: boolean;
+    reportValidation?: boolean;
+    preserveAuth?: SessionPreservationOptions;
+}
+/**
+ * Helper function to create session preservation options from session data
+ * @param sessionCookie The session cookie string
+ * @param email Optional email associated with the session
+ * @param expiresAt Optional expiration timestamp
+ * @returns SessionPreservationOptions object
+ */
+export declare function createSessionPreservation(sessionCookie: string, email?: string, expiresAt?: string): SessionPreservationOptions;
+export { findAppwriteConfig, findFunctionsDir } from '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.
+ * @param options Loading options including validation settings and session preservation.
+ * @returns Object containing the config, path, and validation results.
+ */
+export declare const loadConfigWithPath: (configDir: string, options?: ConfigLoadingOptions) => Promise<{
+    config: AppwriteConfig;
+    actualConfigPath: string;
+    validation?: ValidationResult;
+}>;
+/**
+ * Loads the Appwrite configuration and all collection configurations from a specified directory.
+ * Supports both YAML and TypeScript config formats with backward compatibility.
+ * @param configDir The directory containing the config file and collections folder.
+ * @param options Loading options including validation settings and session preservation.
+ * @returns The loaded Appwrite configuration including collections.
+ */
+export declare const loadConfig: (configDir: string, options?: ConfigLoadingOptions) => Promise<AppwriteConfig>;