appwrite-cli 12.0.1 → 13.0.0-rc.2

package/dist/lib/commands/push.js

@@ -0,0 +1,2127 @@
+import fs from "fs";
+import { parse as parseDotenv } from "dotenv";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { Command } from "commander";
+import ID from "../id.js";
+import { localConfig, globalConfig, KeysAttributes, KeysFunction, KeysSite, whitelistKeys, KeysTopics, KeysStorage, KeysTeams, KeysCollection, KeysTable, } from "../config.js";
+import { Spinner, SPINNER_ARC, SPINNER_DOTS } from "../spinner.js";
+import { paginate } from "../paginate.js";
+import { questionsPushBuckets, questionsPushTeams, questionsPushFunctions, questionsPushSites, questionsGetEntrypoint, questionsPushCollections, questionsPushTables, questionPushChanges, questionPushChangesConfirmation, questionsPushMessagingTopics, questionsPushResources, } from "../questions.js";
+import { cliConfig, actionRunner, success, warn, log, hint, error, commandDescriptions, drawTable, } from "../parser.js";
+import { getProxyService, getConsoleService, getFunctionsService, getSitesService, getDatabasesService, getTablesDBService, getStorageService, getMessagingService, getTeamsService, getProjectsService, } from "../services.js";
+import { checkDeployConditions } from "../utils.js";
+const STEP_SIZE = 100; // Resources
+const POLL_DEBOUNCE = 2000; // Milliseconds
+const POLL_DEFAULT_VALUE = 30;
+let pollMaxDebounces = POLL_DEFAULT_VALUE;
+const changeableKeys = [
+    "status",
+    "required",
+    "xdefault",
+    "elements",
+    "min",
+    "max",
+    "default",
+    "error",
+];
+const awaitPools = {
+    wipeAttributes: async (databaseId, collectionId, iteration = 1) => {
+        if (iteration > pollMaxDebounces) {
+            return false;
+        }
+        const databasesService = await getDatabasesService();
+        const response = await databasesService.listAttributes(databaseId, collectionId, [JSON.stringify({ method: "limit", values: [1] })]);
+        const { total } = response;
+        if (total === 0) {
+            return true;
+        }
+        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
+            let steps = Math.max(1, Math.ceil(total / STEP_SIZE));
+            if (steps > 1 && iteration === 1) {
+                pollMaxDebounces *= steps;
+                log("Found a large number of attributes, increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
+        return await awaitPools.wipeAttributes(databaseId, collectionId, iteration + 1);
+    },
+    wipeIndexes: async (databaseId, collectionId, iteration = 1) => {
+        if (iteration > pollMaxDebounces) {
+            return false;
+        }
+        const databasesService = await getDatabasesService();
+        const response = await databasesService.listIndexes(databaseId, collectionId, [JSON.stringify({ method: "limit", values: [1] })]);
+        const { total } = response;
+        if (total === 0) {
+            return true;
+        }
+        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
+            let steps = Math.max(1, Math.ceil(total / STEP_SIZE));
+            if (steps > 1 && iteration === 1) {
+                pollMaxDebounces *= steps;
+                log("Found a large number of indexes, increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
+        return await awaitPools.wipeIndexes(databaseId, collectionId, iteration + 1);
+    },
+    deleteAttributes: async (databaseId, collectionId, attributeKeys, iteration = 1) => {
+        if (iteration > pollMaxDebounces) {
+            return false;
+        }
+        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
+            let steps = Math.max(1, Math.ceil(attributeKeys.length / STEP_SIZE));
+            if (steps > 1 && iteration === 1) {
+                pollMaxDebounces *= steps;
+                log("Found a large number of attributes to be deleted. Increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
+            }
+        }
+        const { attributes } = await paginate(async (args) => {
+            const databasesService = await getDatabasesService();
+            return await databasesService.listAttributes(args.databaseId, args.collectionId, args.queries || []);
+        }, {
+            databaseId,
+            collectionId,
+        }, 100, "attributes");
+        const ready = attributeKeys.filter((attribute) => attributes.includes(attribute.key));
+        if (ready.length === 0) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
+        return await awaitPools.expectAttributes(databaseId, collectionId, attributeKeys, iteration + 1);
+    },
+    expectAttributes: async (databaseId, collectionId, attributeKeys, iteration = 1) => {
+        if (iteration > pollMaxDebounces) {
+            return false;
+        }
+        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
+            let steps = Math.max(1, Math.ceil(attributeKeys.length / STEP_SIZE));
+            if (steps > 1 && iteration === 1) {
+                pollMaxDebounces *= steps;
+                log("Creating a large number of attributes, increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
+            }
+        }
+        const { attributes } = await paginate(async (args) => {
+            const databasesService = await getDatabasesService();
+            return await databasesService.listAttributes(args.databaseId, args.collectionId, args.queries || []);
+        }, {
+            databaseId,
+            collectionId,
+        }, 100, "attributes");
+        const ready = attributes
+            .filter((attribute) => {
+            if (attributeKeys.includes(attribute.key)) {
+                if (["stuck", "failed"].includes(attribute.status)) {
+                    throw new Error(`Attribute '${attribute.key}' failed!`);
+                }
+                return attribute.status === "available";
+            }
+            return false;
+        })
+            .map((attribute) => attribute.key);
+        if (ready.length === attributeKeys.length) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
+        return await awaitPools.expectAttributes(databaseId, collectionId, attributeKeys, iteration + 1);
+    },
+    deleteIndexes: async (databaseId, collectionId, indexesKeys, iteration = 1) => {
+        if (iteration > pollMaxDebounces) {
+            return false;
+        }
+        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
+            let steps = Math.max(1, Math.ceil(indexesKeys.length / STEP_SIZE));
+            if (steps > 1 && iteration === 1) {
+                pollMaxDebounces *= steps;
+                log("Found a large number of indexes to be deleted. Increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
+            }
+        }
+        const { indexes } = await paginate(async (args) => {
+            const databasesService = await getDatabasesService();
+            return await databasesService.listIndexes(args.databaseId, args.collectionId, args.queries || []);
+        }, {
+            databaseId,
+            collectionId,
+        }, 100, "indexes");
+        const ready = indexesKeys.filter((index) => indexes.includes(index.key));
+        if (ready.length === 0) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
+        return await awaitPools.expectIndexes(databaseId, collectionId, indexesKeys, iteration + 1);
+    },
+    expectIndexes: async (databaseId, collectionId, indexKeys, iteration = 1) => {
+        if (iteration > pollMaxDebounces) {
+            return false;
+        }
+        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
+            let steps = Math.max(1, Math.ceil(indexKeys.length / STEP_SIZE));
+            if (steps > 1 && iteration === 1) {
+                pollMaxDebounces *= steps;
+                log("Creating a large number of indexes, increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
+            }
+        }
+        const { indexes } = await paginate(async (args) => {
+            const databasesService = await getDatabasesService();
+            return await databasesService.listIndexes(args.databaseId, args.collectionId, args.queries || []);
+        }, {
+            databaseId,
+            collectionId,
+        }, 100, "indexes");
+        const ready = indexes
+            .filter((index) => {
+            if (indexKeys.includes(index.key)) {
+                if (["stuck", "failed"].includes(index.status)) {
+                    throw new Error(`Index '${index.key}' failed!`);
+                }
+                return index.status === "available";
+            }
+            return false;
+        })
+            .map((index) => index.key);
+        if (ready.length >= indexKeys.length) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
+        return await awaitPools.expectIndexes(databaseId, collectionId, indexKeys, iteration + 1);
+    },
+};
+const getConfirmation = async () => {
+    if (cliConfig.force) {
+        return true;
+    }
+    async function fixConfirmation() {
+        const answers = await inquirer.prompt(questionPushChangesConfirmation);
+        if (answers.changes !== "YES" && answers.changes !== "NO") {
+            return await fixConfirmation();
+        }
+        return answers.changes;
+    }
+    let answers = await inquirer.prompt(questionPushChanges);
+    if (answers.changes !== "YES" && answers.changes !== "NO") {
+        answers.changes = await fixConfirmation();
+    }
+    if (answers.changes === "YES") {
+        return true;
+    }
+    warn("Skipping push action. Changes were not applied.");
+    return false;
+};
+const isEmpty = (value) => value === null ||
+    value === undefined ||
+    (typeof value === "string" && value.trim().length === 0) ||
+    (Array.isArray(value) && value.length === 0);
+const approveChanges = async (resource, resourceGetFunction, keys, resourceName, resourcePlural, skipKeys = [], secondId = "", secondResourceName = "") => {
+    log("Checking for changes ...");
+    const changes = [];
+    await Promise.all(resource.map(async (localResource) => {
+        try {
+            const options = {
+                [resourceName]: localResource["$id"],
+            };
+            if (secondId !== "" && secondResourceName !== "") {
+                options[secondResourceName] = localResource[secondId];
+            }
+            const remoteResource = await resourceGetFunction(options);
+            for (let [key, value] of Object.entries(whitelistKeys(remoteResource, keys))) {
+                if (skipKeys.includes(key)) {
+                    continue;
+                }
+                if (isEmpty(value) && isEmpty(localResource[key])) {
+                    continue;
+                }
+                if (Array.isArray(value) && Array.isArray(localResource[key])) {
+                    if (JSON.stringify(value) !== JSON.stringify(localResource[key])) {
+                        changes.push({
+                            id: localResource["$id"],
+                            key,
+                            remote: chalk.red(value.join("\n")),
+                            local: chalk.green(localResource[key].join("\n")),
+                        });
+                    }
+                }
+                else if (value !== localResource[key]) {
+                    changes.push({
+                        id: localResource["$id"],
+                        key,
+                        remote: chalk.red(value),
+                        local: chalk.green(localResource[key]),
+                    });
+                }
+            }
+        }
+        catch (e) {
+            if (Number(e.code) !== 404) {
+                throw e;
+            }
+        }
+    }));
+    if (changes.length === 0) {
+        return true;
+    }
+    drawTable(changes);
+    if ((await getConfirmation()) === true) {
+        return true;
+    }
+    success(`Successfully pushed 0 ${resourcePlural}.`);
+    return false;
+};
+const getObjectChanges = (remote, local, index, what) => {
+    const changes = [];
+    const remoteNested = remote[index];
+    const localNested = local[index];
+    if (remoteNested &&
+        localNested &&
+        typeof remoteNested === "object" &&
+        !Array.isArray(remoteNested) &&
+        typeof localNested === "object" &&
+        !Array.isArray(localNested)) {
+        const remoteObj = remoteNested;
+        const localObj = localNested;
+        for (const [service, status] of Object.entries(remoteObj)) {
+            const localValue = localObj[service];
+            let valuesEqual = false;
+            if (Array.isArray(status) && Array.isArray(localValue)) {
+                valuesEqual = JSON.stringify(status) === JSON.stringify(localValue);
+            }
+            else {
+                valuesEqual = status === localValue;
+            }
+            if (!valuesEqual) {
+                changes.push({
+                    group: what,
+                    setting: service,
+                    remote: chalk.red(String(status ?? "")),
+                    local: chalk.green(String(localValue ?? "")),
+                });
+            }
+        }
+    }
+    return changes;
+};
+const createAttribute = async (databaseId, collectionId, attribute) => {
+    const databasesService = await getDatabasesService();
+    switch (attribute.type) {
+        case "string":
+            switch (attribute.format) {
+                case "email":
+                    return databasesService.createEmailAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                    });
+                case "url":
+                    return databasesService.createUrlAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                    });
+                case "ip":
+                    return databasesService.createIpAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                    });
+                case "enum":
+                    return databasesService.createEnumAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        elements: attribute.elements,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                    });
+                default:
+                    return databasesService.createStringAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        size: attribute.size,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        encrypt: attribute.encrypt,
+                    });
+            }
+        case "integer":
+            return databasesService.createIntegerAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                min: attribute.min,
+                max: attribute.max,
+                xdefault: attribute.default,
+                array: attribute.array,
+            });
+        case "double":
+            return databasesService.createFloatAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                min: attribute.min,
+                max: attribute.max,
+                xdefault: attribute.default,
+                array: attribute.array,
+            });
+        case "boolean":
+            return databasesService.createBooleanAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                array: attribute.array,
+            });
+        case "datetime":
+            return databasesService.createDatetimeAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                array: attribute.array,
+            });
+        case "relationship":
+            return databasesService.createRelationshipAttribute({
+                databaseId,
+                collectionId,
+                relatedCollectionId: attribute.relatedTable ?? attribute.relatedCollection,
+                type: attribute.relationType,
+                twoWay: attribute.twoWay,
+                key: attribute.key,
+                twoWayKey: attribute.twoWayKey,
+                onDelete: attribute.onDelete,
+            });
+        case "point":
+            return databasesService.createPointAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+            });
+        case "linestring":
+            return databasesService.createLineAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+            });
+        case "polygon":
+            return databasesService.createPolygonAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+            });
+        default:
+            throw new Error(`Unsupported attribute type: ${attribute.type}`);
+    }
+};
+const updateAttribute = async (databaseId, collectionId, attribute) => {
+    const databasesService = await getDatabasesService();
+    switch (attribute.type) {
+        case "string":
+            switch (attribute.format) {
+                case "email":
+                    return databasesService.updateEmailAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                    });
+                case "url":
+                    return databasesService.updateUrlAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                    });
+                case "ip":
+                    return databasesService.updateIpAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                    });
+                case "enum":
+                    return databasesService.updateEnumAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        elements: attribute.elements,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                    });
+                default:
+                    return databasesService.updateStringAttribute({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                    });
+            }
+        case "integer":
+            return databasesService.updateIntegerAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                min: attribute.min,
+                max: attribute.max,
+                xdefault: attribute.default,
+            });
+        case "double":
+            return databasesService.updateFloatAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                min: attribute.min,
+                max: attribute.max,
+                xdefault: attribute.default,
+            });
+        case "boolean":
+            return databasesService.updateBooleanAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+            });
+        case "datetime":
+            return databasesService.updateDatetimeAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+            });
+        case "relationship":
+            return databasesService.updateRelationshipAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                onDelete: attribute.onDelete,
+            });
+        case "point":
+            return databasesService.updatePointAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+            });
+        case "linestring":
+            return databasesService.updateLineAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+            });
+        case "polygon":
+            return databasesService.updatePolygonAttribute({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+            });
+        default:
+            throw new Error(`Unsupported attribute type: ${attribute.type}`);
+    }
+};
+const deleteAttribute = async (collection, attribute, isIndex = false) => {
+    log(`Deleting ${isIndex ? "index" : "attribute"} ${attribute.key} of ${collection.name} ( ${collection["$id"]} )`);
+    const databasesService = await getDatabasesService();
+    if (isIndex) {
+        await databasesService.deleteIndex(collection["databaseId"], collection["$id"], attribute.key);
+        return;
+    }
+    await databasesService.deleteAttribute(collection["databaseId"], collection["$id"], attribute.key);
+};
+const isEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (a && b && typeof a === "object" && typeof b === "object") {
+        if (a.constructor &&
+            a.constructor.name === "BigNumber" &&
+            b.constructor &&
+            b.constructor.name === "BigNumber") {
+            return a.eq(b);
+        }
+        if (typeof a.equals === "function") {
+            return a.equals(b);
+        }
+        if (typeof a.eq === "function") {
+            return a.eq(b);
+        }
+    }
+    if (typeof a === "number" && typeof b === "number") {
+        if (isNaN(a) && isNaN(b))
+            return true;
+        if (!isFinite(a) && !isFinite(b))
+            return a === b;
+        return Math.abs(a - b) < Number.EPSILON;
+    }
+    return false;
+};
+const compareAttribute = (remote, local, reason, key) => {
+    if (isEmpty(remote) && isEmpty(local)) {
+        return reason;
+    }
+    if (Array.isArray(remote) && Array.isArray(local)) {
+        if (JSON.stringify(remote) !== JSON.stringify(local)) {
+            const bol = reason === "" ? "" : "\n";
+            reason += `${bol}${key} changed from ${chalk.red(remote)} to ${chalk.green(local)}`;
+        }
+    }
+    else if (!isEqual(remote, local)) {
+        const bol = reason === "" ? "" : "\n";
+        reason += `${bol}${key} changed from ${chalk.red(remote)} to ${chalk.green(local)}`;
+    }
+    return reason;
+};
+/**
+ * Check if attribute non-changeable fields has been changed
+ * If so return the differences as an object.
+ */
+const checkAttributeChanges = (remote, local, collection, recreating = true) => {
+    if (local === undefined) {
+        return undefined;
+    }
+    const keyName = `${chalk.yellow(local.key)} in ${collection.name} (${collection["$id"]})`;
+    const action = chalk.cyan(recreating ? "recreating" : "changing");
+    let reason = "";
+    let attribute = recreating ? remote : local;
+    for (let key of Object.keys(remote)) {
+        if (!KeysAttributes.has(key)) {
+            continue;
+        }
+        if (changeableKeys.includes(key)) {
+            if (!recreating) {
+                reason = compareAttribute(remote[key], local[key], reason, key);
+            }
+            continue;
+        }
+        if (!recreating) {
+            continue;
+        }
+        reason = compareAttribute(remote[key], local[key], reason, key);
+    }
+    return reason === ""
+        ? undefined
+        : { key: keyName, attribute, reason, action };
+};
+/**
+ * Check if attributes contain the given attribute
+ */
+const attributesContains = (attribute, attributes) => attributes.find((attr) => attr.key === attribute.key);
+const generateChangesObject = (attribute, collection, isAdding) => {
+    return {
+        key: `${chalk.yellow(attribute.key)} in ${collection.name} (${collection["$id"]})`,
+        attribute: attribute,
+        reason: isAdding
+            ? "Field isn't present on the remote server"
+            : "Field isn't present on the appwrite.config.json file",
+        action: isAdding ? chalk.green("adding") : chalk.red("deleting"),
+    };
+};
+/**
+ * Filter deleted and recreated attributes,
+ * return list of attributes to create
+ */
+const attributesToCreate = async (remoteAttributes, localAttributes, collection, isIndex = false) => {
+    const deleting = remoteAttributes
+        .filter((attribute) => !attributesContains(attribute, localAttributes))
+        .map((attr) => generateChangesObject(attr, collection, false));
+    const adding = localAttributes
+        .filter((attribute) => !attributesContains(attribute, remoteAttributes))
+        .map((attr) => generateChangesObject(attr, collection, true));
+    const conflicts = remoteAttributes
+        .map((attribute) => checkAttributeChanges(attribute, attributesContains(attribute, localAttributes), collection))
+        .filter((attribute) => attribute !== undefined);
+    const changes = remoteAttributes
+        .map((attribute) => checkAttributeChanges(attribute, attributesContains(attribute, localAttributes), collection, false))
+        .filter((attribute) => attribute !== undefined)
+        .filter((attribute) => conflicts.filter((attr) => attribute.key === attr.key).length !== 1);
+    let changedAttributes = [];
+    const changing = [...deleting, ...adding, ...conflicts, ...changes];
+    if (changing.length === 0) {
+        return changedAttributes;
+    }
+    log(!cliConfig.force
+        ? "There are pending changes in your collection deployment"
+        : "List of applied changes");
+    drawTable(changing.map((change) => {
+        return { Key: change.key, Action: change.action, Reason: change.reason };
+    }));
+    if (!cliConfig.force) {
+        if (deleting.length > 0 && !isIndex) {
+            console.log(`${chalk.red("------------------------------------------------------")}`);
+            console.log(`${chalk.red("| WARNING: Attribute deletion may cause loss of data |")}`);
+            console.log(`${chalk.red("------------------------------------------------------")}`);
+            console.log();
+        }
+        if (conflicts.length > 0 && !isIndex) {
+            console.log(`${chalk.red("--------------------------------------------------------")}`);
+            console.log(`${chalk.red("| WARNING: Attribute recreation may cause loss of data |")}`);
+            console.log(`${chalk.red("--------------------------------------------------------")}`);
+            console.log();
+        }
+        if ((await getConfirmation()) !== true) {
+            return changedAttributes;
+        }
+    }
+    if (conflicts.length > 0) {
+        changedAttributes = conflicts.map((change) => change.attribute);
+        await Promise.all(changedAttributes.map((changed) => deleteAttribute(collection, changed, isIndex)));
+        remoteAttributes = remoteAttributes.filter((attribute) => !attributesContains(attribute, changedAttributes));
+    }
+    if (changes.length > 0) {
+        changedAttributes = changes.map((change) => change.attribute);
+        await Promise.all(changedAttributes.map((changed) => updateAttribute(collection["databaseId"], collection["$id"], changed)));
+    }
+    const deletingAttributes = deleting.map((change) => change.attribute);
+    await Promise.all(deletingAttributes.map((attribute) => deleteAttribute(collection, attribute, isIndex)));
+    const attributeKeys = [
+        ...remoteAttributes.map((attribute) => attribute.key),
+        ...deletingAttributes.map((attribute) => attribute.key),
+    ];
+    if (attributeKeys.length) {
+        const deleteAttributesPoolStatus = await awaitPools.deleteAttributes(collection["databaseId"], collection["$id"], attributeKeys);
+        if (!deleteAttributesPoolStatus) {
+            throw new Error("Attribute deletion timed out.");
+        }
+    }
+    return localAttributes.filter((attribute) => !attributesContains(attribute, remoteAttributes));
+};
+const createIndexes = async (indexes, collection) => {
+    log(`Creating indexes ...`);
+    const databasesService = await getDatabasesService();
+    for (let index of indexes) {
+        await databasesService.createIndex(collection["databaseId"], collection["$id"], index.key, index.type, index.columns ?? index.attributes, index.orders);
+    }
+    const result = await awaitPools.expectIndexes(collection["databaseId"], collection["$id"], indexes.map((index) => index.key));
+    if (!result) {
+        throw new Error("Index creation timed out.");
+    }
+    success(`Created ${indexes.length} indexes`);
+};
+const createAttributes = async (attributes, collection) => {
+    for (let attribute of attributes) {
+        if (attribute.side !== "child") {
+            await createAttribute(collection["databaseId"], collection["$id"], attribute);
+        }
+    }
+    const result = await awaitPools.expectAttributes(collection["databaseId"], collection["$id"], collection.attributes
+        .filter((attribute) => attribute.side !== "child")
+        .map((attribute) => attribute.key));
+    if (!result) {
+        throw new Error(`Attribute creation timed out.`);
+    }
+    success(`Created ${attributes.length} attributes`);
+};
+const createColumns = async (columns, table) => {
+    for (let column of columns) {
+        if (column.side !== "child") {
+            await createAttribute(table["databaseId"], table["$id"], column);
+        }
+    }
+    const result = await awaitPools.expectAttributes(table["databaseId"], table["$id"], table.columns
+        .filter((column) => column.side !== "child")
+        .map((column) => column.key));
+    if (!result) {
+        throw new Error(`Column creation timed out.`);
+    }
+    success(`Created ${columns.length} columns`);
+};
+const pushResources = async ({ skipDeprecated = false, } = {}) => {
+    const actions = {
+        settings: pushSettings,
+        functions: pushFunction,
+        sites: pushSite,
+        collections: pushCollection,
+        tables: pushTable,
+        buckets: pushBucket,
+        teams: pushTeam,
+        messages: pushMessagingTopic,
+    };
+    if (skipDeprecated) {
+        delete actions.collections;
+    }
+    if (cliConfig.all) {
+        for (let action of Object.values(actions)) {
+            await action();
+        }
+    }
+    else {
+        const answers = await inquirer.prompt(questionsPushResources);
+        const action = actions[answers.resource];
+        if (action !== undefined) {
+            await action();
+        }
+    }
+};
+const pushSettings = async () => {
+    checkDeployConditions(localConfig);
+    try {
+        const projectsService = await getProjectsService();
+        let response = await projectsService.get(localConfig.getProject().projectId);
+        const remoteSettings = localConfig.createSettingsObject(response ?? {});
+        const localSettings = localConfig.getProject().projectSettings ?? {};
+        log("Checking for changes ...");
+        const changes = [];
+        changes.push(...getObjectChanges(remoteSettings, localSettings, "services", "Service"));
+        changes.push(...getObjectChanges(remoteSettings["auth"] ?? {}, localSettings["auth"] ?? {}, "methods", "Auth method"));
+        changes.push(...getObjectChanges(remoteSettings["auth"] ?? {}, localSettings["auth"] ?? {}, "security", "Auth security"));
+        if (changes.length > 0) {
+            drawTable(changes);
+            if ((await getConfirmation()) !== true) {
+                success(`Successfully pushed 0 project settings.`);
+                return;
+            }
+        }
+    }
+    catch (e) { }
+    try {
+        log("Pushing project settings ...");
+        const projectsService = await getProjectsService();
+        const projectId = localConfig.getProject().projectId;
+        const projectName = localConfig.getProject().projectName;
+        const settings = localConfig.getProject().projectSettings ?? {};
+        if (projectName) {
+            log("Applying project name ...");
+            await projectsService.update(projectId, projectName);
+        }
+        if (settings.services) {
+            log("Applying service statuses ...");
+            for (let [service, status] of Object.entries(settings.services)) {
+                await projectsService.updateServiceStatus(projectId, service, status);
+            }
+        }
+        if (settings.auth) {
+            if (settings.auth.security) {
+                log("Applying auth security settings ...");
+                await projectsService.updateAuthDuration(projectId, settings.auth.security.duration);
+                await projectsService.updateAuthLimit(projectId, settings.auth.security.limit);
+                await projectsService.updateAuthSessionsLimit(projectId, settings.auth.security.sessionsLimit);
+                await projectsService.updateAuthPasswordDictionary(projectId, settings.auth.security.passwordDictionary);
+                await projectsService.updateAuthPasswordHistory(projectId, settings.auth.security.passwordHistory);
+                await projectsService.updatePersonalDataCheck(projectId, settings.auth.security.personalDataCheck);
+                await projectsService.updateSessionAlerts(projectId, settings.auth.security.sessionAlerts);
+                await projectsService.updateMockNumbers(projectId, settings.auth.security.mockNumbers);
+            }
+            if (settings.auth.methods) {
+                log("Applying auth methods statuses ...");
+                for (let [method, status] of Object.entries(settings.auth.methods)) {
+                    await projectsService.updateAuthStatus(projectId, method, status);
+                }
+            }
+        }
+        success(`Successfully pushed ${chalk.bold("all")} project settings.`);
+    }
+    catch (e) {
+        throw e;
+    }
+};
+const pushSite = async ({ siteId, async: asyncDeploy, code, withVariables, } = {}) => {
+    process.chdir(localConfig.configDirectoryPath);
+    const siteIds = [];
+    if (siteId) {
+        siteIds.push(siteId);
+    }
+    else if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        const sites = localConfig.getSites();
+        siteIds.push(...sites.map((site) => {
+            return site.$id;
+        }));
+    }
+    if (siteIds.length <= 0) {
+        const answers = await inquirer.prompt(questionsPushSites);
+        if (answers.sites) {
+            siteIds.push(...answers.sites);
+        }
+    }
+    if (siteIds.length === 0) {
+        log("No sites found.");
+        hint("Use 'appwrite pull sites' to synchronize existing one, or use 'appwrite init site' to create a new one.");
+        return;
+    }
+    let sites = siteIds.map((id) => {
+        const sites = localConfig.getSites();
+        const site = sites.find((s) => s.$id === id);
+        if (!site) {
+            throw new Error("Site '" + id + "' not found.");
+        }
+        return site;
+    });
+    log("Validating sites ...");
+    // Validation is done BEFORE pushing so the deployment process can be run in async with progress update
+    for (let site of sites) {
+        if (!site.buildCommand) {
+            log(`Site ${site.name} is missing build command.`);
+            const answers = await inquirer.prompt(questionsGetEntrypoint);
+            site.buildCommand = answers.entrypoint;
+            localConfig.addSite(site);
+        }
+    }
+    if (!(await approveChanges(sites, async (args) => {
+        const sitesService = await getSitesService();
+        return await sitesService.get({ siteId: args.siteId });
+    }, KeysSite, "siteId", "sites", ["vars"]))) {
+        return;
+    }
+    log("Pushing sites ...");
+    Spinner.start(false);
+    let successfullyPushed = 0;
+    let successfullyDeployed = 0;
+    const failedDeployments = [];
+    const errors = [];
+    await Promise.all(sites.map(async (site) => {
+        let response = {};
+        const ignore = site.ignore ? "appwrite.config.json" : ".gitignore";
+        let siteExists = false;
+        let deploymentCreated = false;
+        const updaterRow = new Spinner({
+            status: "",
+            resource: site.name,
+            id: site["$id"],
+            end: `Ignoring using: ${ignore}`,
+        });
+        updaterRow.update({ status: "Getting" }).startSpinner(SPINNER_DOTS);
+        const sitesService = await getSitesService();
+        try {
+            response = await sitesService.get({ siteId: site["$id"] });
+            siteExists = true;
+            if (response.framework !== site.framework) {
+                updaterRow.fail({
+                    errorMessage: `Framework mismatch! (local=${site.framework},remote=${response.framework}) Please delete remote site or update your appwrite.config.json`,
+                });
+                return;
+            }
+            updaterRow.update({ status: "Updating" }).replaceSpinner(SPINNER_ARC);
+            response = await sitesService.update({
+                siteId: site["$id"],
+                name: site.name,
+                framework: site.framework,
+                enabled: site.enabled,
+                logging: site.logging,
+                timeout: site.timeout,
+                installCommand: site.installCommand,
+                buildCommand: site.buildCommand,
+                outputDirectory: site.outputDirectory,
+                buildRuntime: site.buildRuntime,
+                adapter: site.adapter,
+                specification: site.specification,
+            });
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                siteExists = false;
+            }
+            else {
+                errors.push(e);
+                updaterRow.fail({
+                    errorMessage: e.message ?? "General error occurs please try again",
+                });
+                return;
+            }
+        }
+        if (!siteExists) {
+            updaterRow.update({ status: "Creating" }).replaceSpinner(SPINNER_DOTS);
+            try {
+                response = await sitesService.create({
+                    siteId: site.$id,
+                    name: site.name,
+                    framework: site.framework,
+                    enabled: site.enabled,
+                    logging: site.logging,
+                    timeout: site.timeout,
+                    installCommand: site.installCommand,
+                    buildCommand: site.buildCommand,
+                    outputDirectory: site.outputDirectory,
+                    buildRuntime: site.buildRuntime,
+                    adapter: site.adapter,
+                    specification: site.specification,
+                });
+                let domain = "";
+                try {
+                    const consoleService = await getConsoleService();
+                    const variables = await consoleService.variables();
+                    domain = ID.unique() + "." + variables["_APP_DOMAIN_SITES"];
+                }
+                catch (error) {
+                    console.error("Error fetching console variables.");
+                    throw error;
+                }
+                try {
+                    const proxyService = await getProxyService();
+                    const rule = await proxyService.createSiteRule(domain, site.$id);
+                }
+                catch (error) {
+                    console.error("Error creating site rule.");
+                    throw error;
+                }
+                updaterRow.update({ status: "Created" });
+            }
+            catch (e) {
+                errors.push(e);
+                updaterRow.fail({
+                    errorMessage: e.message ?? "General error occurs please try again",
+                });
+                return;
+            }
+        }
+        if (withVariables) {
+            updaterRow
+                .update({ status: "Creating variables" })
+                .replaceSpinner(SPINNER_ARC);
+            const sitesService = await getSitesService();
+            const { variables } = await paginate(async (args) => {
+                return await sitesService.listVariables({ siteId: args.siteId });
+            }, {
+                siteId: site["$id"],
+            }, 100, "variables");
+            await Promise.all(variables.map(async (variable) => {
+                const sitesService = await getSitesService();
+                await sitesService.deleteVariable({
+                    siteId: site["$id"],
+                    variableId: variable["$id"],
+                });
+            }));
+            const envFileLocation = `${site["path"]}/.env`;
+            let envVariables = [];
+            try {
+                if (fs.existsSync(envFileLocation)) {
+                    const envObject = parseDotenv(fs.readFileSync(envFileLocation, "utf8"));
+                    envVariables = Object.entries(envObject || {}).map(([key, value]) => ({ key, value }));
+                }
+            }
+            catch (error) {
+                // Handle parsing errors gracefully
+                envVariables = [];
+            }
+            await Promise.all(envVariables.map(async (variable) => {
+                const sitesService = await getSitesService();
+                await sitesService.createVariable({
+                    siteId: site["$id"],
+                    key: variable.key,
+                    value: variable.value,
+                    secret: false,
+                });
+            }));
+        }
+        if (code === false) {
+            successfullyPushed++;
+            successfullyDeployed++;
+            updaterRow.update({ status: "Pushed" });
+            updaterRow.stopSpinner();
+            return;
+        }
+        try {
+            updaterRow.update({ status: "Pushing" }).replaceSpinner(SPINNER_ARC);
+            const sitesService = await getSitesService();
+            response = await sitesService.createDeployment({
+                siteId: site["$id"],
+                installCommand: site.installCommand,
+                buildCommand: site.buildCommand,
+                outputDirectory: site.outputDirectory,
+                code: site.path,
+                activate: true,
+            });
+            updaterRow.update({ status: "Pushed" });
+            deploymentCreated = true;
+            successfullyPushed++;
+        }
+        catch (e) {
+            errors.push(e);
+            switch (e.code) {
+                case "ENOENT":
+                    updaterRow.fail({
+                        errorMessage: "Not found in the current directory. Skipping...",
+                    });
+                    break;
+                default:
+                    updaterRow.fail({
+                        errorMessage: e.message ?? "An unknown error occurred. Please try again.",
+                    });
+            }
+        }
+        if (deploymentCreated && !asyncDeploy) {
+            try {
+                const deploymentId = response["$id"];
+                updaterRow.update({
+                    status: "Deploying",
+                    end: "Checking deployment status...",
+                });
+                let pollChecks = 0;
+                while (true) {
+                    const sitesService = await getSitesService();
+                    response = await sitesService.getDeployment({
+                        siteId: site["$id"],
+                        deploymentId: deploymentId,
+                    });
+                    const status = response["status"];
+                    if (status === "ready") {
+                        successfullyDeployed++;
+                        let url = "";
+                        const proxyService = await getProxyService();
+                        const res = await proxyService.listRules([
+                            JSON.stringify({ method: "limit", values: [1] }),
+                            JSON.stringify({
+                                method: "equal",
+                                attribute: "deploymentResourceType",
+                                values: ["site"],
+                            }),
+                            JSON.stringify({
+                                method: "equal",
+                                attribute: "deploymentResourceId",
+                                values: [site["$id"]],
+                            }),
+                            JSON.stringify({
+                                method: "equal",
+                                attribute: "trigger",
+                                values: ["manual"],
+                            }),
+                        ]);
+                        if (Number(res.total) === 1) {
+                            url = res.rules[0].domain;
+                        }
+                        updaterRow.update({ status: "Deployed", end: url });
+                        break;
+                    }
+                    else if (status === "failed") {
+                        failedDeployments.push({
+                            name: site["name"],
+                            $id: site["$id"],
+                            deployment: response["$id"],
+                        });
+                        updaterRow.fail({ errorMessage: `Failed to deploy` });
+                        break;
+                    }
+                    else {
+                        updaterRow.update({
+                            status: "Deploying",
+                            end: `Current status: ${status}`,
+                        });
+                    }
+                    pollChecks++;
+                    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE * 1.5));
+                }
+            }
+            catch (e) {
+                errors.push(e);
+                updaterRow.fail({
+                    errorMessage: e.message ?? "Unknown error occurred. Please try again",
+                });
+            }
+        }
+        updaterRow.stopSpinner();
+    }));
+    Spinner.stop();
+    failedDeployments.forEach((failed) => {
+        const { name, deployment, $id } = failed;
+        const failUrl = `${globalConfig.getEndpoint().slice(0, -3)}/console/project-${localConfig.getProject().projectId}/sites/site-${$id}/deployments/deployment-${deployment}`;
+        error(`Deployment of ${name} has failed. Check at ${failUrl} for more details\n`);
+    });
+    if (!asyncDeploy) {
+        if (successfullyPushed === 0) {
+            error("No sites were pushed.");
+        }
+        else if (successfullyDeployed !== successfullyPushed) {
+            warn(`Successfully pushed ${successfullyDeployed} of ${successfullyPushed} sites`);
+        }
+        else {
+            success(`Successfully pushed ${successfullyPushed} sites.`);
+        }
+    }
+    else {
+        success(`Successfully pushed ${successfullyPushed} sites.`);
+    }
+    if (cliConfig.verbose) {
+        errors.forEach((e) => {
+            console.error(e);
+        });
+    }
+};
+const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariables, } = {}) => {
+    process.chdir(localConfig.configDirectoryPath);
+    const functionIds = [];
+    if (functionId) {
+        functionIds.push(functionId);
+    }
+    else if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        const functions = localConfig.getFunctions();
+        functionIds.push(...functions.map((func) => {
+            return func.$id;
+        }));
+    }
+    if (functionIds.length <= 0) {
+        const answers = await inquirer.prompt(questionsPushFunctions);
+        if (answers.functions) {
+            functionIds.push(...answers.functions);
+        }
+    }
+    if (functionIds.length === 0) {
+        log("No functions found.");
+        hint("Use 'appwrite pull functions' to synchronize existing one, or use 'appwrite init function' to create a new one.");
+        return;
+    }
+    let functions = functionIds.map((id) => {
+        const functions = localConfig.getFunctions();
+        const func = functions.find((f) => f.$id === id);
+        if (!func) {
+            throw new Error("Function '" + id + "' not found.");
+        }
+        return func;
+    });
+    log("Validating functions ...");
+    // Validation is done BEFORE pushing so the deployment process can be run in async with progress update
+    for (let func of functions) {
+        if (!func.entrypoint) {
+            log(`Function ${func.name} is missing an entrypoint.`);
+            const answers = await inquirer.prompt(questionsGetEntrypoint);
+            func.entrypoint = answers.entrypoint;
+            localConfig.addFunction(func);
+        }
+    }
+    if (!(await approveChanges(functions, async (args) => {
+        const functionsService = await getFunctionsService();
+        return await functionsService.get({ functionId: args.functionId });
+    }, KeysFunction, "functionId", "functions", ["vars"]))) {
+        return;
+    }
+    log("Pushing functions ...");
+    Spinner.start(false);
+    let successfullyPushed = 0;
+    let successfullyDeployed = 0;
+    const failedDeployments = [];
+    const errors = [];
+    await Promise.all(functions.map(async (func) => {
+        let response = {};
+        const ignore = func.ignore ? "appwrite.config.json" : ".gitignore";
+        let functionExists = false;
+        let deploymentCreated = false;
+        const updaterRow = new Spinner({
+            status: "",
+            resource: func.name,
+            id: func["$id"],
+            end: `Ignoring using: ${ignore}`,
+        });
+        updaterRow.update({ status: "Getting" }).startSpinner(SPINNER_DOTS);
+        const functionsService = await getFunctionsService();
+        try {
+            response = await functionsService.get({ functionId: func["$id"] });
+            functionExists = true;
+            if (response.runtime !== func.runtime) {
+                updaterRow.fail({
+                    errorMessage: `Runtime mismatch! (local=${func.runtime},remote=${response.runtime}) Please delete remote function or update your appwrite.config.json`,
+                });
+                return;
+            }
+            updaterRow.update({ status: "Updating" }).replaceSpinner(SPINNER_ARC);
+            response = await functionsService.update({
+                functionId: func["$id"],
+                name: func.name,
+                runtime: func.runtime,
+                execute: func.execute,
+                events: func.events,
+                schedule: func.schedule,
+                timeout: func.timeout,
+                enabled: func.enabled,
+                logging: func.logging,
+                entrypoint: func.entrypoint,
+                commands: func.commands,
+                scopes: func.scopes,
+                specification: func.specification,
+            });
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                functionExists = false;
+            }
+            else {
+                errors.push(e);
+                updaterRow.fail({
+                    errorMessage: e.message ?? "General error occurs please try again",
+                });
+                return;
+            }
+        }
+        if (!functionExists) {
+            updaterRow.update({ status: "Creating" }).replaceSpinner(SPINNER_DOTS);
+            try {
+                response = await functionsService.create({
+                    functionId: func.$id,
+                    name: func.name,
+                    runtime: func.runtime,
+                    execute: func.execute,
+                    events: func.events,
+                    schedule: func.schedule,
+                    timeout: func.timeout,
+                    enabled: func.enabled,
+                    logging: func.logging,
+                    entrypoint: func.entrypoint,
+                    commands: func.commands,
+                    scopes: func.scopes,
+                    specification: func.specification,
+                });
+                let domain = "";
+                try {
+                    const consoleService = await getConsoleService();
+                    const variables = await consoleService.variables();
+                    domain = ID.unique() + "." + variables["_APP_DOMAIN_FUNCTIONS"];
+                }
+                catch (error) {
+                    console.error("Error fetching console variables.");
+                    throw error;
+                }
+                try {
+                    const proxyService = await getProxyService();
+                    const rule = await proxyService.createFunctionRule(domain, func.$id);
+                }
+                catch (error) {
+                    console.error("Error creating function rule.");
+                    throw error;
+                }
+                updaterRow.update({ status: "Created" });
+            }
+            catch (e) {
+                errors.push(e);
+                updaterRow.fail({
+                    errorMessage: e.message ?? "General error occurs please try again",
+                });
+                return;
+            }
+        }
+        if (withVariables) {
+            updaterRow
+                .update({ status: "Updating variables" })
+                .replaceSpinner(SPINNER_ARC);
+            const functionsService = await getFunctionsService();
+            const { variables } = await paginate(async (args) => {
+                return await functionsService.listVariables({
+                    functionId: args.functionId,
+                });
+            }, {
+                functionId: func["$id"],
+            }, 100, "variables");
+            await Promise.all(variables.map(async (variable) => {
+                const functionsService = await getFunctionsService();
+                await functionsService.deleteVariable({
+                    functionId: func["$id"],
+                    variableId: variable["$id"],
+                });
+            }));
+            const envFileLocation = `${func["path"]}/.env`;
+            let envVariables = [];
+            try {
+                if (fs.existsSync(envFileLocation)) {
+                    const envObject = parseDotenv(fs.readFileSync(envFileLocation, "utf8"));
+                    envVariables = Object.entries(envObject || {}).map(([key, value]) => ({ key, value }));
+                }
+            }
+            catch (error) {
+                // Handle parsing errors gracefully
+                envVariables = [];
+            }
+            await Promise.all(envVariables.map(async (variable) => {
+                const functionsService = await getFunctionsService();
+                await functionsService.createVariable({
+                    functionId: func["$id"],
+                    key: variable.key,
+                    value: variable.value,
+                    secret: false,
+                });
+            }));
+        }
+        if (code === false) {
+            successfullyPushed++;
+            successfullyDeployed++;
+            updaterRow.update({ status: "Pushed" });
+            updaterRow.stopSpinner();
+            return;
+        }
+        try {
+            updaterRow.update({ status: "Pushing" }).replaceSpinner(SPINNER_ARC);
+            const functionsService = await getFunctionsService();
+            response = await functionsService.createDeployment({
+                functionId: func["$id"],
+                entrypoint: func.entrypoint,
+                commands: func.commands,
+                code: func.path,
+                activate: true,
+            });
+            updaterRow.update({ status: "Pushed" });
+            deploymentCreated = true;
+            successfullyPushed++;
+        }
+        catch (e) {
+            errors.push(e);
+            switch (e.code) {
+                case "ENOENT":
+                    updaterRow.fail({
+                        errorMessage: "Not found in the current directory. Skipping...",
+                    });
+                    break;
+                default:
+                    updaterRow.fail({
+                        errorMessage: e.message ?? "An unknown error occurred. Please try again.",
+                    });
+            }
+        }
+        if (deploymentCreated && !asyncDeploy) {
+            try {
+                const deploymentId = response["$id"];
+                updaterRow.update({
+                    status: "Deploying",
+                    end: "Checking deployment status...",
+                });
+                let pollChecks = 0;
+                while (true) {
+                    const functionsService = await getFunctionsService();
+                    response = await functionsService.getDeployment({
+                        functionId: func["$id"],
+                        deploymentId: deploymentId,
+                    });
+                    const status = response["status"];
+                    if (status === "ready") {
+                        successfullyDeployed++;
+                        let url = "";
+                        const proxyService = await getProxyService();
+                        const res = await proxyService.listRules([
+                            JSON.stringify({ method: "limit", values: [1] }),
+                            JSON.stringify({
+                                method: "equal",
+                                attribute: "deploymentResourceType",
+                                values: ["function"],
+                            }),
+                            JSON.stringify({
+                                method: "equal",
+                                attribute: "deploymentResourceId",
+                                values: [func["$id"]],
+                            }),
+                            JSON.stringify({
+                                method: "equal",
+                                attribute: "trigger",
+                                values: ["manual"],
+                            }),
+                        ]);
+                        if (Number(res.total) === 1) {
+                            url = res.rules[0].domain;
+                        }
+                        updaterRow.update({ status: "Deployed", end: url });
+                        break;
+                    }
+                    else if (status === "failed") {
+                        failedDeployments.push({
+                            name: func["name"],
+                            $id: func["$id"],
+                            deployment: response["$id"],
+                        });
+                        updaterRow.fail({ errorMessage: `Failed to deploy` });
+                        break;
+                    }
+                    else {
+                        updaterRow.update({
+                            status: "Deploying",
+                            end: `Current status: ${status}`,
+                        });
+                    }
+                    pollChecks++;
+                    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE * 1.5));
+                }
+            }
+            catch (e) {
+                errors.push(e);
+                updaterRow.fail({
+                    errorMessage: e.message ?? "Unknown error occurred. Please try again",
+                });
+            }
+        }
+        updaterRow.stopSpinner();
+    }));
+    Spinner.stop();
+    failedDeployments.forEach((failed) => {
+        const { name, deployment, $id } = failed;
+        const failUrl = `${globalConfig.getEndpoint().slice(0, -3)}/console/project-${localConfig.getProject().projectId}/functions/function-${$id}/deployment-${deployment}`;
+        error(`Deployment of ${name} has failed. Check at ${failUrl} for more details\n`);
+    });
+    if (!asyncDeploy) {
+        if (successfullyPushed === 0) {
+            error("No functions were pushed.");
+        }
+        else if (successfullyDeployed !== successfullyPushed) {
+            warn(`Successfully pushed ${successfullyDeployed} of ${successfullyPushed} functions`);
+        }
+        else {
+            success(`Successfully pushed ${successfullyPushed} functions.`);
+        }
+    }
+    else {
+        success(`Successfully pushed ${successfullyPushed} functions.`);
+    }
+    if (cliConfig.verbose) {
+        errors.forEach((e) => {
+            console.error(e);
+        });
+    }
+};
+const checkAndApplyTablesDBChanges = async () => {
+    log("Checking for tablesDB changes ...");
+    const localTablesDBs = localConfig.getTablesDBs();
+    const { databases: remoteTablesDBs } = await paginate(async (args) => {
+        const tablesDBService = await getTablesDBService();
+        return await tablesDBService.list(args.queries || []);
+    }, {}, 100, "databases");
+    if (localTablesDBs.length === 0 && remoteTablesDBs.length === 0) {
+        return { applied: false, resyncNeeded: false };
+    }
+    const changes = [];
+    const toCreate = [];
+    const toUpdate = [];
+    const toDelete = [];
+    // Check for deletions - remote DBs that aren't in local config
+    for (const remoteDB of remoteTablesDBs) {
+        const localDB = localTablesDBs.find((db) => db.$id === remoteDB.$id);
+        if (!localDB) {
+            toDelete.push(remoteDB);
+            changes.push({
+                id: remoteDB.$id,
+                action: chalk.red("deleting"),
+                key: "Database",
+                remote: remoteDB.name,
+                local: "(deleted locally)",
+            });
+        }
+    }
+    // Check for additions and updates
+    for (const localDB of localTablesDBs) {
+        const remoteDB = remoteTablesDBs.find((db) => db.$id === localDB.$id);
+        if (!remoteDB) {
+            toCreate.push(localDB);
+            changes.push({
+                id: localDB.$id,
+                action: chalk.green("creating"),
+                key: "Database",
+                remote: "(does not exist)",
+                local: localDB.name,
+            });
+        }
+        else {
+            let hasChanges = false;
+            if (remoteDB.name !== localDB.name) {
+                hasChanges = true;
+                changes.push({
+                    id: localDB.$id,
+                    action: chalk.yellow("updating"),
+                    key: "Name",
+                    remote: remoteDB.name,
+                    local: localDB.name,
+                });
+            }
+            if (remoteDB.enabled !== localDB.enabled) {
+                hasChanges = true;
+                changes.push({
+                    id: localDB.$id,
+                    action: chalk.yellow("updating"),
+                    key: "Enabled",
+                    remote: remoteDB.enabled,
+                    local: localDB.enabled,
+                });
+            }
+            if (hasChanges) {
+                toUpdate.push(localDB);
+            }
+        }
+    }
+    if (changes.length === 0) {
+        return { applied: false, resyncNeeded: false };
+    }
+    log("Found changes in tablesDB resource:");
+    drawTable(changes);
+    if (toDelete.length > 0) {
+        console.log(`${chalk.red("------------------------------------------------------------------")}`);
+        console.log(`${chalk.red("| WARNING: Database deletion will also delete all related tables |")}`);
+        console.log(`${chalk.red("------------------------------------------------------------------")}`);
+        console.log();
+    }
+    if ((await getConfirmation()) !== true) {
+        return { applied: false, resyncNeeded: false };
+    }
+    // Apply deletions first
+    let needsResync = false;
+    for (const db of toDelete) {
+        try {
+            log(`Deleting database ${db.name} ( ${db.$id} ) ...`);
+            const tablesDBService = await getTablesDBService();
+            await tablesDBService.delete(db.$id);
+            success(`Deleted ${db.name} ( ${db.$id} )`);
+            needsResync = true;
+        }
+        catch (e) {
+            error(`Failed to delete database ${db.name} ( ${db.$id} ): ${e.message}`);
+            throw new Error(`Database sync failed during deletion of ${db.$id}. Some changes may have been applied.`);
+        }
+    }
+    // Apply creations
+    for (const db of toCreate) {
+        try {
+            log(`Creating database ${db.name} ( ${db.$id} ) ...`);
+            const tablesDBService = await getTablesDBService();
+            await tablesDBService.create(db.$id, db.name, db.enabled);
+            success(`Created ${db.name} ( ${db.$id} )`);
+        }
+        catch (e) {
+            error(`Failed to create database ${db.name} ( ${db.$id} ): ${e.message}`);
+            throw new Error(`Database sync failed during creation of ${db.$id}. Some changes may have been applied.`);
+        }
+    }
+    // Apply updates
+    for (const db of toUpdate) {
+        try {
+            log(`Updating database ${db.name} ( ${db.$id} ) ...`);
+            const tablesDBService = await getTablesDBService();
+            await tablesDBService.update(db.$id, db.name, db.enabled);
+            success(`Updated ${db.name} ( ${db.$id} )`);
+        }
+        catch (e) {
+            error(`Failed to update database ${db.name} ( ${db.$id} ): ${e.message}`);
+            throw new Error(`Database sync failed during update of ${db.$id}. Some changes may have been applied.`);
+        }
+    }
+    if (toDelete.length === 0) {
+        console.log();
+    }
+    return { applied: true, resyncNeeded: needsResync };
+};
+const pushTable = async ({ attempts, } = {}) => {
+    const tables = [];
+    if (attempts) {
+        pollMaxDebounces = attempts;
+    }
+    const { applied: tablesDBApplied, resyncNeeded } = await checkAndApplyTablesDBChanges();
+    if (resyncNeeded) {
+        log("Resyncing configuration due to tablesDB deletions ...");
+        const remoteTablesDBs = (await paginate(async (args) => {
+            const tablesDBService = await getTablesDBService();
+            return await tablesDBService.list(args.queries || []);
+        }, {}, 100, "databases")).databases;
+        const localTablesDBs = localConfig.getTablesDBs();
+        const remoteDatabaseIds = new Set(remoteTablesDBs.map((db) => db.$id));
+        const localTables = localConfig.getTables();
+        const validTables = localTables.filter((table) => remoteDatabaseIds.has(table.databaseId));
+        localConfig.set("tables", validTables);
+        const validTablesDBs = localTablesDBs.filter((db) => remoteDatabaseIds.has(db.$id));
+        localConfig.set("tablesDB", validTablesDBs);
+        success("Configuration resynced successfully.");
+        console.log();
+    }
+    log("Checking for deleted tables ...");
+    const localTablesDBs = localConfig.getTablesDBs();
+    const localTables = localConfig.getTables();
+    const tablesToDelete = [];
+    for (const db of localTablesDBs) {
+        try {
+            const { tables: remoteTables } = await paginate(async (args) => {
+                const tablesDBService = await getTablesDBService();
+                return await tablesDBService.listTables(args.databaseId, args.queries || []);
+            }, {
+                databaseId: db.$id,
+            }, 100, "tables");
+            for (const remoteTable of remoteTables) {
+                const localTable = localTables.find((t) => t.$id === remoteTable.$id && t.databaseId === db.$id);
+                if (!localTable) {
+                    tablesToDelete.push({
+                        ...remoteTable,
+                        databaseId: db.$id,
+                        databaseName: db.name,
+                    });
+                }
+            }
+        }
+        catch (e) {
+            // Skip if database doesn't exist or other errors
+        }
+    }
+    if (tablesToDelete.length > 0) {
+        log("Found tables that exist remotely but not locally:");
+        const deletionChanges = tablesToDelete.map((table) => ({
+            id: table.$id,
+            action: chalk.red("deleting"),
+            key: "Table",
+            database: table.databaseName,
+            remote: table.name,
+            local: "(deleted locally)",
+        }));
+        drawTable(deletionChanges);
+        if ((await getConfirmation()) === true) {
+            for (const table of tablesToDelete) {
+                try {
+                    log(`Deleting table ${table.name} ( ${table.$id} ) from database ${table.databaseName} ...`);
+                    const tablesDBService = await getTablesDBService();
+                    await tablesDBService.deleteTable(table.databaseId, table.$id);
+                    success(`Deleted ${table.name} ( ${table.$id} )`);
+                }
+                catch (e) {
+                    error(`Failed to delete table ${table.name} ( ${table.$id} ): ${e.message}`);
+                }
+            }
+        }
+    }
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        tables.push(...localConfig.getTables());
+    }
+    else {
+        const answers = await inquirer.prompt(questionsPushTables);
+        if (answers.tables) {
+            const configTables = new Map();
+            localConfig.getTables().forEach((c) => {
+                configTables.set(`${c["databaseId"]}|${c["$id"]}`, c);
+            });
+            answers.tables.forEach((a) => {
+                const table = configTables.get(a);
+                tables.push(table);
+            });
+        }
+    }
+    if (tables.length === 0) {
+        log("No tables found.");
+        hint("Use 'appwrite pull tables' to synchronize existing one, or use 'appwrite init table' to create a new one.");
+        return;
+    }
+    if (!(await approveChanges(tables, async (args) => {
+        const tablesDBService = await getTablesDBService();
+        return await tablesDBService.getTable(args.databaseId, args.tableId);
+    }, KeysTable, "tableId", "tables", ["columns", "indexes"], "databaseId", "databaseId"))) {
+        return;
+    }
+    let tablesChanged = new Set();
+    // Parallel tables actions
+    await Promise.all(tables.map(async (table) => {
+        try {
+            const tablesDBService = await getTablesDBService();
+            const remoteTable = await tablesDBService.getTable(table["databaseId"], table["$id"]);
+            const changes = [];
+            if (remoteTable.name !== table.name)
+                changes.push("name");
+            if (remoteTable.rowSecurity !== table.rowSecurity)
+                changes.push("rowSecurity");
+            if (remoteTable.enabled !== table.enabled)
+                changes.push("enabled");
+            if (JSON.stringify(remoteTable["$permissions"]) !==
+                JSON.stringify(table["$permissions"]))
+                changes.push("permissions");
+            if (changes.length > 0) {
+                await tablesDBService.updateTable(table["databaseId"], table["$id"], table.name, table.rowSecurity, table["$permissions"]);
+                success(`Updated ${table.name} ( ${table["$id"]} ) - ${changes.join(", ")}`);
+                tablesChanged.add(table["$id"]);
+            }
+            table.remoteVersion = remoteTable;
+            table.isExisted = true;
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                log(`Table ${table.name} does not exist in the project. Creating ... `);
+                const tablesDBService = await getTablesDBService();
+                await tablesDBService.createTable(table["databaseId"], table["$id"], table.name, table.rowSecurity, table["$permissions"]);
+                success(`Created ${table.name} ( ${table["$id"]} )`);
+                tablesChanged.add(table["$id"]);
+            }
+            else {
+                throw e;
+            }
+        }
+    }));
+    // Serialize attribute actions
+    for (let table of tables) {
+        let columns = table.columns;
+        let indexes = table.indexes;
+        if (table.isExisted) {
+            columns = await attributesToCreate(table.remoteVersion.columns, table.columns, table);
+            indexes = await attributesToCreate(table.remoteVersion.indexes, table.indexes, table, true);
+            if (Array.isArray(columns) &&
+                columns.length <= 0 &&
+                Array.isArray(indexes) &&
+                indexes.length <= 0) {
+                continue;
+            }
+        }
+        log(`Pushing table ${table.name} ( ${table["databaseId"]} - ${table["$id"]} ) attributes`);
+        try {
+            await createColumns(columns, table);
+        }
+        catch (e) {
+            throw e;
+        }
+        try {
+            await createIndexes(indexes, table);
+        }
+        catch (e) {
+            throw e;
+        }
+        tablesChanged.add(table["$id"]);
+        success(`Successfully pushed ${table.name} ( ${table["$id"]} )`);
+    }
+    success(`Successfully pushed ${tablesChanged.size} tables`);
+};
+const pushCollection = async ({ attempts }) => {
+    warn("appwrite push collection has been deprecated. Please consider using 'appwrite push tables' instead");
+    const collections = [];
+    if (attempts) {
+        pollMaxDebounces = attempts;
+    }
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        collections.push(...localConfig.getCollections());
+    }
+    else {
+        const answers = await inquirer.prompt(questionsPushCollections);
+        if (answers.collections) {
+            const configCollections = new Map();
+            localConfig.getCollections().forEach((c) => {
+                configCollections.set(`${c["databaseId"]}|${c["$id"]}`, c);
+            });
+            answers.collections.forEach((a) => {
+                const collection = configCollections.get(a);
+                collections.push(collection);
+            });
+        }
+    }
+    if (collections.length === 0) {
+        log("No collections found.");
+        hint("Use 'appwrite pull collections' to synchronize existing one, or use 'appwrite init collection' to create a new one.");
+        return;
+    }
+    const databases = Array.from(new Set(collections.map((collection) => collection["databaseId"])));
+    // Parallel db actions
+    await Promise.all(databases.map(async (databaseId) => {
+        const localDatabase = localConfig.getDatabase(databaseId);
+        const databasesService = await getDatabasesService();
+        try {
+            const database = await databasesService.get(databaseId);
+            if (database.name !== (localDatabase.name ?? databaseId)) {
+                await databasesService.update(databaseId, localDatabase.name ?? databaseId);
+                success(`Updated ${localDatabase.name} ( ${databaseId} ) name`);
+            }
+        }
+        catch (err) {
+            log(`Database ${databaseId} not found. Creating it now ...`);
+            await databasesService.create(databaseId, localDatabase.name ?? databaseId);
+        }
+    }));
+    if (!(await approveChanges(collections, async (args) => {
+        const databasesService = await getDatabasesService();
+        return await databasesService.getCollection(args.databaseId, args.collectionId);
+    }, KeysCollection, "collectionId", "collections", ["attributes", "indexes"], "databaseId", "databaseId"))) {
+        return;
+    }
+    // Parallel collection actions
+    await Promise.all(collections.map(async (collection) => {
+        try {
+            const databasesService = await getDatabasesService();
+            const remoteCollection = await databasesService.getCollection(collection["databaseId"], collection["$id"]);
+            if (remoteCollection.name !== collection.name) {
+                await databasesService.updateCollection(collection["databaseId"], collection["$id"], collection.name);
+                success(`Updated ${collection.name} ( ${collection["$id"]} ) name`);
+            }
+            collection.remoteVersion = remoteCollection;
+            collection.isExisted = true;
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                log(`Collection ${collection.name} does not exist in the project. Creating ... `);
+                const databasesService = await getDatabasesService();
+                await databasesService.createCollection(collection["databaseId"], collection["$id"], collection.name, collection.documentSecurity, collection["$permissions"]);
+            }
+            else {
+                throw e;
+            }
+        }
+    }));
+    let numberOfCollections = 0;
+    // Serialize attribute actions
+    for (let collection of collections) {
+        let attributes = collection.attributes;
+        let indexes = collection.indexes;
+        if (collection.isExisted) {
+            attributes = await attributesToCreate(collection.remoteVersion.attributes, collection.attributes, collection);
+            indexes = await attributesToCreate(collection.remoteVersion.indexes, collection.indexes, collection, true);
+            if (Array.isArray(attributes) &&
+                attributes.length <= 0 &&
+                Array.isArray(indexes) &&
+                indexes.length <= 0) {
+                continue;
+            }
+        }
+        log(`Pushing collection ${collection.name} ( ${collection["databaseId"]} - ${collection["$id"]} ) attributes`);
+        try {
+            await createAttributes(attributes, collection);
+        }
+        catch (e) {
+            throw e;
+        }
+        try {
+            await createIndexes(indexes, collection);
+        }
+        catch (e) {
+            throw e;
+        }
+        numberOfCollections++;
+        success(`Successfully pushed ${collection.name} ( ${collection["$id"]} )`);
+    }
+    success(`Successfully pushed ${numberOfCollections} collections`);
+};
+const pushBucket = async () => {
+    let response = {};
+    let bucketIds = [];
+    const configBuckets = localConfig.getBuckets();
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        bucketIds.push(...configBuckets.map((b) => b.$id));
+    }
+    if (bucketIds.length === 0) {
+        const answers = await inquirer.prompt(questionsPushBuckets);
+        if (answers.buckets) {
+            bucketIds.push(...answers.buckets);
+        }
+    }
+    if (bucketIds.length === 0) {
+        log("No buckets found.");
+        hint("Use 'appwrite pull buckets' to synchronize existing one, or use 'appwrite init bucket' to create a new one.");
+        return;
+    }
+    let buckets = [];
+    for (const bucketId of bucketIds) {
+        const idBuckets = configBuckets.filter((b) => b.$id === bucketId);
+        buckets.push(...idBuckets);
+    }
+    if (!(await approveChanges(buckets, async (args) => {
+        const storageService = await getStorageService();
+        return await storageService.getBucket(args.bucketId);
+    }, KeysStorage, "bucketId", "buckets"))) {
+        return;
+    }
+    log("Pushing buckets ...");
+    for (let bucket of buckets) {
+        log(`Pushing bucket ${chalk.bold(bucket["name"])} ...`);
+        const storageService = await getStorageService();
+        try {
+            response = await storageService.getBucket(bucket["$id"]);
+            await storageService.updateBucket(bucket["$id"], bucket.name, bucket["$permissions"], bucket.fileSecurity, bucket.enabled, bucket.maximumFileSize, bucket.allowedFileExtensions, bucket.encryption, bucket.antivirus, bucket.compression);
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                log(`Bucket ${bucket.name} does not exist in the project. Creating ... `);
+                response = await storageService.createBucket(bucket["$id"], bucket.name, bucket["$permissions"], bucket.fileSecurity, bucket.enabled, bucket.maximumFileSize, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    success(`Successfully pushed ${buckets.length} buckets.`);
+};
+const pushTeam = async () => {
+    let response = {};
+    let teamIds = [];
+    const configTeams = localConfig.getTeams();
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        teamIds.push(...configTeams.map((t) => t.$id));
+    }
+    if (teamIds.length === 0) {
+        const answers = await inquirer.prompt(questionsPushTeams);
+        if (answers.teams) {
+            teamIds.push(...answers.teams);
+        }
+    }
+    if (teamIds.length === 0) {
+        log("No teams found.");
+        hint("Use 'appwrite pull teams' to synchronize existing one, or use 'appwrite init team' to create a new one.");
+        return;
+    }
+    let teams = [];
+    for (const teamId of teamIds) {
+        const idTeams = configTeams.filter((t) => t.$id === teamId);
+        teams.push(...idTeams);
+    }
+    if (!(await approveChanges(teams, async (args) => {
+        const teamsService = await getTeamsService();
+        return await teamsService.get(args.teamId);
+    }, KeysTeams, "teamId", "teams"))) {
+        return;
+    }
+    log("Pushing teams ...");
+    for (let team of teams) {
+        log(`Pushing team ${chalk.bold(team["name"])} ...`);
+        const teamsService = await getTeamsService();
+        try {
+            response = await teamsService.get(team["$id"]);
+            await teamsService.updateName(team["$id"], team.name);
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                log(`Team ${team.name} does not exist in the project. Creating ... `);
+                response = await teamsService.create(team["$id"], team.name);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    success(`Successfully pushed ${teams.length} teams.`);
+};
+const pushMessagingTopic = async () => {
+    let response = {};
+    let topicsIds = [];
+    const configTopics = localConfig.getMessagingTopics();
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        topicsIds.push(...configTopics.map((b) => b.$id));
+    }
+    if (topicsIds.length === 0) {
+        const answers = await inquirer.prompt(questionsPushMessagingTopics);
+        if (answers.topics) {
+            topicsIds.push(...answers.topics);
+        }
+    }
+    if (topicsIds.length === 0) {
+        log("No topics found.");
+        hint("Use 'appwrite pull topics' to synchronize existing one, or use 'appwrite init topic' to create a new one.");
+        return;
+    }
+    let topics = [];
+    for (const topicId of topicsIds) {
+        const idTopic = configTopics.filter((b) => b.$id === topicId);
+        topics.push(...idTopic);
+    }
+    if (!(await approveChanges(topics, async (args) => {
+        const messagingService = await getMessagingService();
+        return await messagingService.getTopic(args.topicId);
+    }, KeysTopics, "topicId", "topics"))) {
+        return;
+    }
+    log("Pushing topics ...");
+    for (let topic of topics) {
+        log(`Pushing topic ${chalk.bold(topic["name"])} ...`);
+        const messagingService = await getMessagingService();
+        try {
+            response = await messagingService.getTopic(topic["$id"]);
+            log(`Topic ${topic.name} ( ${topic["$id"]} ) already exists.`);
+            await messagingService.updateTopic(topic["$id"], topic.name, topic.subscribe);
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                log(`Topic ${topic.name} does not exist in the project. Creating ... `);
+                response = await messagingService.createTopic(topic["$id"], topic.name, topic.subscribe);
+                success(`Created ${topic.name} ( ${topic["$id"]} )`);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    success(`Successfully pushed ${topics.length} topics.`);
+};
+export const push = new Command("push")
+    .description(commandDescriptions["push"])
+    .action(actionRunner(() => pushResources({ skipDeprecated: true })));
+push
+    .command("all")
+    .description("Push all resource.")
+    .action(actionRunner(() => {
+    cliConfig.all = true;
+    return pushResources({ skipDeprecated: true });
+}));
+push
+    .command("settings")
+    .description("Push project name, services and auth settings")
+    .action(actionRunner(pushSettings));
+push
+    .command("function")
+    .alias("functions")
+    .description("Push functions in the current directory.")
+    .option(`-f, --function-id <function-id>`, `ID of function to run`)
+    .option(`-A, --async`, `Don't wait for functions deployments status`)
+    .option("--no-code", "Don't push the function's code")
+    .option("--with-variables", `Push function variables.`)
+    .action(actionRunner(pushFunction));
+push
+    .command("site")
+    .alias("sites")
+    .description("Push sites in the current directory.")
+    .option(`-f, --site-id <site-id>`, `ID of site to run`)
+    .option(`-A, --async`, `Don't wait for sites deployments status`)
+    .option("--no-code", "Don't push the site's code")
+    .option("--with-variables", `Push site variables.`)
+    .action(actionRunner(pushSite));
+push
+    .command("collection")
+    .alias("collections")
+    .description("Push collections in the current project. (deprecated, please use 'push tables' instead)")
+    .option(`-a, --attempts <numberOfAttempts>`, `Max number of attempts before timing out. default: 30.`)
+    .action(actionRunner(pushCollection));
+push
+    .command("table")
+    .alias("tables")
+    .description("Push tables in the current project.")
+    .option(`-a, --attempts <numberOfAttempts>`, `Max number of attempts before timing out. default: 30.`)
+    .action(actionRunner(pushTable));
+push
+    .command("bucket")
+    .alias("buckets")
+    .description("Push buckets in the current project.")
+    .action(actionRunner(pushBucket));
+push
+    .command("team")
+    .alias("teams")
+    .description("Push teams in the current project.")
+    .action(actionRunner(pushTeam));
+push
+    .command("topic")
+    .alias("topics")
+    .description("Push messaging topics in the current project.")
+    .action(actionRunner(pushMessagingTopic));
+export const deploy = new Command("deploy")
+    .description("Removed. Use appwrite push instead")
+    .action(actionRunner(async () => {
+    warn("appwrite deploy has been removed. Please use 'appwrite push' instead");
+}));
+//# sourceMappingURL=push.js.map