appwrite-utils-cli 1.3.4 → 1.4.0

package/dist/migrations/users.js

@@ -1,276 +0,0 @@
-import { AppwriteException, Databases, ID, Query, Users, } from "node-appwrite";
-import { AuthUserSchema, } from "../schemas/authUser.js";
-import { logger } from "./logging.js";
-import { splitIntoBatches } from "./migrationHelper.js";
-import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
-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();
-        console.log("Deleting all 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) {
-                console.log(`Deleting ${batch.length} users...`);
-                await Promise.all(batch.map((user) => tryAwaitWithRetry(async () => await this.users.delete(user.$id))));
-                usersDeleted += batch.length;
-                if (usersDeleted % 100 === 0) {
-                    console.log(`Deleted ${usersDeleted} users...`);
-                }
-            }
-        }
-        else {
-            console.log("No users to delete");
-        }
-    }
-    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 {
-                        console.log("Email update skipped: Email already exists.");
-                    }
-                }
-                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) {
-                console.log("$createdAt and $updatedAt are not yet supported, sorry about that!");
-            }
-            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) {
-            console.log(`No users found`);
-            return;
-        }
-        else if (fromUsers.users.length < 50) {
-            console.log(`Transferring ${fromUsers.users.length} users to remote`);
-            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/migrations/validationRules.d.ts

@@ -1,43 +0,0 @@
-export interface ValidationRules {
-    [key: string]: (value: any, ...args: any[]) => boolean;
-}
-export declare const validationRules: {
-    isNumber: (value: any) => boolean;
-    isString: (value: any) => boolean;
-    isBoolean: (value: any) => boolean;
-    isArray: (value: any) => boolean;
-    isObject: (value: any) => boolean;
-    isNull: (value: any) => boolean;
-    isValidEmail: (value: string) => boolean;
-    isValidPhone: (value: string) => boolean;
-    isValidPassword: (value: string) => boolean;
-    isValidUrl: (value: string) => boolean;
-    isValidHex: (value: string) => boolean;
-    isValidHexColor: (value: string) => boolean;
-    isValidHexAlpha: (value: string) => boolean;
-    isValidDate: (value: string) => boolean;
-    isValidTime: (value: string) => boolean;
-    isNullish: (value: any) => boolean;
-    isUndefined: (value: any) => boolean;
-    isDefined: (value: any) => boolean;
-    isDate: (value: any) => boolean;
-    isEmpty: (value: any) => boolean;
-    isInteger: (value: any) => boolean;
-    isFloat: (value: any) => boolean;
-    isArrayLike: (value: any) => boolean;
-    isArrayLikeObject: (value: any) => boolean;
-    isFunction: (value: any) => boolean;
-    isLength: (value: any) => boolean;
-    isMap: (value: any) => boolean;
-    isSet: (value: any) => boolean;
-    isRegExp: (value: any) => boolean;
-    isSymbol: (value: any) => boolean;
-    isObjectLike: (value: any) => boolean;
-    isPlainObject: (value: any) => boolean;
-    isSafeInteger: (value: any) => boolean;
-    isTypedArray: (value: any) => boolean;
-    isEqual: (value: any, other: any) => boolean;
-    isMatch: (object: any, source: any) => boolean;
-    has: (object: any, path: string) => boolean;
-    get: (object: any, path: string, defaultValue: any) => any;
-};

package/dist/migrations/validationRules.js

@@ -1,42 +0,0 @@
-import { isNumber, isString, isBoolean, isArray, isPlainObject, isNull, isUndefined, isDate, isEmpty, isInteger, isArrayLike, isArrayLikeObject, isFunction, isLength, isMap, isSet, isRegExp, isSymbol, isObjectLike, isSafeInteger, isTypedArray, isEqual, isMatch, has, get, } from "es-toolkit/compat";
-export const validationRules = {
-    isNumber: (value) => isNumber(value),
-    isString: (value) => isString(value),
-    isBoolean: (value) => isBoolean(value),
-    isArray: (value) => isArray(value),
-    isObject: (value) => isPlainObject(value) && !isArray(value) && !isFunction(value),
-    isNull: (value) => isNull(value),
-    isValidEmail: (value) => value.match(/^[\w\-\.]+@([\w-]+\.)+[\w-]{2,}$/) !== null,
-    isValidPhone: (value) => value.match(/^[+]?[(]?[0-9]{3}[)]?[-\s.]?[0-9]{3}[-\s.]?[0-9]{4,6}$/im) !==
-        null,
-    isValidPassword: (value) => value.match(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$/) !== null,
-    isValidUrl: (value) => value.match(/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/) !== null,
-    isValidHex: (value) => value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
-    isValidHexColor: (value) => value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
-    isValidHexAlpha: (value) => value.match(/^#([a-f0-9]{8}|[a-f0-9]{4})$/i) !== null,
-    isValidDate: (value) => value.match(/^\d{4}-\d{2}-\d{2}$/) !== null,
-    isValidTime: (value) => value.match(/^\d{2}:\d{2}(:\d{2})?$/) !== null,
-    isNullish: (value) => isNull(value) || isUndefined(value),
-    isUndefined: (value) => isUndefined(value),
-    isDefined: (value) => !isUndefined(value) && !isNull(value) && !isEmpty(value),
-    isDate: (value) => isDate(value),
-    isEmpty: (value) => isEmpty(value),
-    isInteger: (value) => isInteger(value),
-    isFloat: (value) => isNumber(value) && !isInteger(value),
-    isArrayLike: (value) => isArrayLike(value),
-    isArrayLikeObject: (value) => isArrayLikeObject(value),
-    isFunction: (value) => isFunction(value),
-    isLength: (value) => isLength(value),
-    isMap: (value) => isMap(value),
-    isSet: (value) => isSet(value),
-    isRegExp: (value) => isRegExp(value),
-    isSymbol: (value) => isSymbol(value),
-    isObjectLike: (value) => isObjectLike(value),
-    isPlainObject: (value) => isPlainObject(value),
-    isSafeInteger: (value) => isSafeInteger(value),
-    isTypedArray: (value) => isTypedArray(value),
-    isEqual: (value, other) => isEqual(value, other),
-    isMatch: (object, source) => isMatch(object, source),
-    has: (object, path) => has(object, path),
-    get: (object, path, defaultValue) => get(object, path, defaultValue),
-};

package/dist/shared/attributeManager.d.ts

@@ -1,17 +0,0 @@
-import { type Databases, type Models } from "node-appwrite";
-import { type Attribute, type CollectionCreate } from "appwrite-utils";
-export declare const attributesSame: (databaseAttribute: Attribute, configAttribute: Attribute) => boolean;
-export declare const createOrUpdateAttribute: (db: Databases, dbId: string, collection: Models.Collection, attribute: Attribute, options?: {
-    updateEnabled?: boolean;
-    useQueue?: boolean;
-    verbose?: boolean;
-}) => Promise<void>;
-export declare const createUpdateCollectionAttributes: (db: Databases, dbId: string, collection: Models.Collection, collectionConfig: CollectionCreate, options?: {
-    updateEnabled?: boolean;
-    useQueue?: boolean;
-    verbose?: boolean;
-}) => Promise<void>;
-export declare const deleteObsoleteAttributes: (db: Databases, dbId: string, collection: Models.Collection, collectionConfig: CollectionCreate, options?: {
-    useQueue?: boolean;
-    verbose?: boolean;
-}) => Promise<void>;

package/dist/shared/attributeManager.js

@@ -1,272 +0,0 @@
-import {} from "node-appwrite";
-import { parseAttribute, } from "appwrite-utils";
-import { nameToIdMapping, enqueueOperation } from "./operationQueue.js";
-import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import chalk from "chalk";
-import pLimit from "p-limit";
-// Concurrency limits for different operations
-const attributeLimit = pLimit(3); // Low limit for attribute operations
-const queryLimit = pLimit(25); // Higher limit for read operations
-export const attributesSame = (databaseAttribute, configAttribute) => {
-    const attributesToCheck = [
-        "key",
-        "type",
-        "array",
-        "encrypted",
-        "required",
-        "size",
-        "min",
-        "max",
-        "xdefault",
-        "elements",
-        "relationType",
-        "twoWay",
-        "twoWayKey",
-        "onDelete",
-        "relatedCollection",
-    ];
-    return attributesToCheck.every((attr) => {
-        // Special handling for min/max values
-        if (attr === "min" || attr === "max") {
-            const dbValue = databaseAttribute[attr];
-            const configValue = configAttribute[attr];
-            // Use type-specific default values when comparing
-            if (databaseAttribute.type === "integer") {
-                if (attr === "min") {
-                    return (dbValue ?? -2147483647) === (configValue ?? -2147483647);
-                }
-                else { // attr === "max"
-                    return (dbValue ?? 2147483647) === (configValue ?? 2147483647);
-                }
-            }
-            if (databaseAttribute.type === "double" || databaseAttribute.type === "float") {
-                if (attr === "min") {
-                    return (dbValue ?? -2147483647) === (configValue ?? -2147483647);
-                }
-                else { // attr === "max"
-                    return (dbValue ?? 2147483647) === (configValue ?? 2147483647);
-                }
-            }
-        }
-        // Check if both objects have the attribute
-        const dbHasAttr = attr in databaseAttribute;
-        const configHasAttr = attr in configAttribute;
-        // If both have the attribute, compare values
-        if (dbHasAttr && configHasAttr) {
-            const dbValue = databaseAttribute[attr];
-            const configValue = configAttribute[attr];
-            // Consider undefined and null as equivalent
-            if ((dbValue === undefined || dbValue === null) &&
-                (configValue === undefined || configValue === null)) {
-                return true;
-            }
-            return dbValue === configValue;
-        }
-        // If neither has the attribute, consider it the same
-        if (!dbHasAttr && !configHasAttr) {
-            return true;
-        }
-        // If one has the attribute and the other doesn't, check if it's undefined or null
-        if (dbHasAttr && !configHasAttr) {
-            const dbValue = databaseAttribute[attr];
-            return dbValue === undefined || dbValue === null;
-        }
-        if (!dbHasAttr && configHasAttr) {
-            const configValue = configAttribute[attr];
-            return configValue === undefined || configValue === null;
-        }
-        // If we reach here, the attributes are different
-        return false;
-    });
-};
-export const createOrUpdateAttribute = async (db, dbId, collection, attribute, options = {}) => {
-    const { updateEnabled = true, useQueue = true, verbose = false } = options;
-    let action = "create";
-    let foundAttribute;
-    let finalAttribute = attribute;
-    try {
-        const collectionAttr = collection.attributes.find((attr) => attr.key === attribute.key);
-        foundAttribute = parseAttribute(collectionAttr);
-        if (verbose) {
-            console.log(`Found attribute: ${JSON.stringify(foundAttribute)}`);
-        }
-    }
-    catch (error) {
-        foundAttribute = undefined;
-    }
-    if (foundAttribute &&
-        attributesSame(foundAttribute, attribute) &&
-        updateEnabled) {
-        if (verbose) {
-            console.log(chalk.green(`✓ Attribute ${attribute.key} is up to date`));
-        }
-        return;
-    }
-    if (foundAttribute) {
-        action = "update";
-        if (verbose) {
-            console.log(chalk.yellow(`⚠ Updating attribute ${attribute.key}`));
-        }
-    }
-    else {
-        if (verbose) {
-            console.log(chalk.blue(`+ Creating attribute ${attribute.key}`));
-        }
-    }
-    // Handle relationship attributes with nameToIdMapping
-    if (attribute.type === "relationship" && attribute.relatedCollection) {
-        const relatedCollectionId = nameToIdMapping.get(attribute.relatedCollection);
-        if (relatedCollectionId) {
-            finalAttribute = {
-                ...attribute,
-                relatedCollection: relatedCollectionId,
-            };
-        }
-    }
-    // Handle BigInt values for integer, double and float types
-    if (attribute.type === "integer" || attribute.type === "double" || attribute.type === "float") {
-        if (typeof finalAttribute.min === "bigint") {
-            finalAttribute.min = Number(finalAttribute.min);
-        }
-        if (typeof finalAttribute.max === "bigint") {
-            finalAttribute.max = Number(finalAttribute.max);
-        }
-    }
-    const queuedOperation = {
-        type: "attribute",
-        collectionId: collection.$id,
-        attribute: finalAttribute,
-        collection,
-    };
-    const executeOperation = async () => {
-        await attributeLimit(async () => {
-            if (action === "update" && foundAttribute) {
-                // Delete existing attribute first
-                await tryAwaitWithRetry(async () => {
-                    await db.deleteAttribute(dbId, collection.$id, attribute.key);
-                });
-                await delay(250);
-            }
-            // Create attribute based on type
-            switch (finalAttribute.type) {
-                case "string":
-                    await tryAwaitWithRetry(async () => {
-                        await db.createStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.size, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array, finalAttribute.encrypted);
-                    });
-                    break;
-                case "integer":
-                    await tryAwaitWithRetry(async () => {
-                        await db.createIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.min, finalAttribute.max, finalAttribute.xdefault, finalAttribute.array);
-                    });
-                    break;
-                case "double":
-                case "float": // Backward compatibility
-                    await tryAwaitWithRetry(async () => {
-                        await db.createFloatAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.min, finalAttribute.max, finalAttribute.xdefault, finalAttribute.array);
-                    });
-                    break;
-                case "boolean":
-                    await tryAwaitWithRetry(async () => {
-                        await db.createBooleanAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
-                    });
-                    break;
-                case "datetime":
-                    await tryAwaitWithRetry(async () => {
-                        await db.createDatetimeAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
-                    });
-                    break;
-                case "email":
-                    await tryAwaitWithRetry(async () => {
-                        await db.createEmailAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
-                    });
-                    break;
-                case "ip":
-                    await tryAwaitWithRetry(async () => {
-                        await db.createIpAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
-                    });
-                    break;
-                case "url":
-                    await tryAwaitWithRetry(async () => {
-                        await db.createUrlAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
-                    });
-                    break;
-                case "enum":
-                    await tryAwaitWithRetry(async () => {
-                        await db.createEnumAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.elements, finalAttribute.required, finalAttribute.xdefault, finalAttribute.array);
-                    });
-                    break;
-                case "relationship":
-                    await tryAwaitWithRetry(async () => {
-                        await db.createRelationshipAttribute(dbId, collection.$id, finalAttribute.relatedCollection, finalAttribute.relationType, finalAttribute.twoWay, finalAttribute.key, finalAttribute.twoWayKey, finalAttribute.onDelete);
-                    });
-                    break;
-                default:
-                    throw new Error(`Unknown attribute type: ${finalAttribute.type}`);
-            }
-        });
-    };
-    if (useQueue) {
-        enqueueOperation(queuedOperation);
-    }
-    else {
-        await executeOperation();
-    }
-};
-export const createUpdateCollectionAttributes = async (db, dbId, collection, collectionConfig, options = {}) => {
-    if (!collectionConfig.attributes)
-        return;
-    const { verbose = false } = options;
-    if (verbose) {
-        console.log(chalk.blue(`Processing ${collectionConfig.attributes.length} attributes for collection ${collection.name}`));
-    }
-    for (const attribute of collectionConfig.attributes) {
-        try {
-            await createOrUpdateAttribute(db, dbId, collection, attribute, options);
-            if (verbose) {
-                console.log(chalk.green(`✓ Processed attribute ${attribute.key}`));
-            }
-            // Add delay between attribute operations to prevent rate limiting
-            await delay(250);
-        }
-        catch (error) {
-            console.error(chalk.red(`❌ Failed to process attribute ${attribute.key}:`), error);
-            throw error;
-        }
-    }
-};
-export const deleteObsoleteAttributes = async (db, dbId, collection, collectionConfig, options = {}) => {
-    const { useQueue = true, verbose = false } = options;
-    const configAttributes = collectionConfig.attributes || [];
-    const configAttributeKeys = new Set(configAttributes.map(attr => attr.key));
-    // Find attributes that exist in the database but not in the config
-    const obsoleteAttributes = collection.attributes.filter((attr) => !configAttributeKeys.has(attr.key));
-    if (obsoleteAttributes.length === 0) {
-        return;
-    }
-    if (verbose) {
-        console.log(chalk.yellow(`🗑️ Removing ${obsoleteAttributes.length} obsolete attributes from collection ${collection.name}`));
-    }
-    for (const attr of obsoleteAttributes) {
-        const queuedOperation = {
-            type: "attribute",
-            collectionId: collection.$id,
-            attribute: { key: attr.key, type: "delete" },
-            collection,
-        };
-        const executeOperation = async () => {
-            await attributeLimit(() => tryAwaitWithRetry(async () => {
-                await db.deleteAttribute(dbId, collection.$id, attr.key);
-            }));
-        };
-        if (useQueue) {
-            enqueueOperation(queuedOperation);
-        }
-        else {
-            await executeOperation();
-            await delay(250);
-        }
-        if (verbose) {
-            console.log(chalk.gray(`🗑️ Deleted obsolete attribute ${attr.key}`));
-        }
-    }
-};