appwrite-cli 12.0.1 → 13.0.0-rc.1

package/dist/lib/commands/push.js

@@ -0,0 +1,2154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = exports.push = void 0;
+const fs = require("fs");
+const dotenv_1 = require("dotenv");
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const json_bigint_1 = __importDefault(require("json-bigint"));
+const commander_1 = require("commander");
+const id_1 = __importDefault(require("../id"));
+const config_1 = require("../config");
+const spinner_1 = require("../spinner");
+const paginate_1 = require("../paginate");
+const questions_1 = require("../questions");
+const parser_1 = require("../parser");
+const proxy_1 = require("./proxy");
+const console_1 = require("./console");
+const sdks_1 = require("../sdks");
+const functions_1 = require("./functions");
+const sites_1 = require("./sites");
+const databases_1 = require("./databases");
+const tables_db_1 = require("./tables-db");
+const storage_1 = require("./storage");
+const messaging_1 = require("./messaging");
+const teams_1 = require("./teams");
+const projects_1 = require("./projects");
+const utils_1 = require("../utils");
+const JSONbigNative = (0, json_bigint_1.default)({ storeAsString: false });
+const STEP_SIZE = 100; // Resources
+const POLL_DEBOUNCE = 2000; // Milliseconds
+const POLL_MAX_DEBOUNCE = 1800; // Times of POLL_DEBOUNCE (1 hour)
+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 { total } = await (0, databases_1.databasesListAttributes)({
+            databaseId,
+            collectionId,
+            queries: [JSON.stringify({ method: 'limit', values: [1] })],
+            parseOutput: false
+        });
+        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;
+                (0, parser_1.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 { total } = await (0, databases_1.databasesListIndexes)({
+            databaseId,
+            collectionId,
+            queries: [JSON.stringify({ method: 'limit', values: [1] })],
+            parseOutput: false
+        });
+        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;
+                (0, parser_1.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;
+                (0, parser_1.log)('Found a large number of attributes to be deleted. Increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+            }
+        }
+        const { attributes } = await (0, paginate_1.paginate)(databases_1.databasesListAttributes, {
+            databaseId,
+            collectionId,
+            parseOutput: false
+        }, 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;
+                (0, parser_1.log)('Creating a large number of attributes, increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+            }
+        }
+        const { attributes } = await (0, paginate_1.paginate)(databases_1.databasesListAttributes, {
+            databaseId,
+            collectionId,
+            parseOutput: false
+        }, 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;
+                (0, parser_1.log)('Found a large number of indexes to be deleted. Increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+            }
+        }
+        const { indexes } = await (0, paginate_1.paginate)(databases_1.databasesListIndexes, {
+            databaseId,
+            collectionId,
+            parseOutput: false
+        }, 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;
+                (0, parser_1.log)('Creating a large number of indexes, increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+            }
+        }
+        const { indexes } = await (0, paginate_1.paginate)(databases_1.databasesListIndexes, {
+            databaseId,
+            collectionId,
+            parseOutput: false
+        }, 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 (parser_1.cliConfig.force) {
+        return true;
+    }
+    async function fixConfirmation() {
+        const answers = await inquirer_1.default.prompt(questions_1.questionPushChangesConfirmation);
+        if (answers.changes !== 'YES' && answers.changes !== 'NO') {
+            return await fixConfirmation();
+        }
+        return answers.changes;
+    }
+    let answers = await inquirer_1.default.prompt(questions_1.questionPushChanges);
+    if (answers.changes !== 'YES' && answers.changes !== 'NO') {
+        answers.changes = await fixConfirmation();
+    }
+    if (answers.changes === 'YES') {
+        return true;
+    }
+    (0, parser_1.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 = '') => {
+    (0, parser_1.log)('Checking for changes ...');
+    const changes = [];
+    await Promise.all(resource.map(async (localResource) => {
+        try {
+            const options = {
+                [resourceName]: localResource['$id'],
+                parseOutput: false,
+            };
+            if (secondId !== '' && secondResourceName !== '') {
+                options[secondResourceName] = localResource[secondId];
+            }
+            const remoteResource = await resourceGetFunction(options);
+            for (let [key, value] of Object.entries((0, config_1.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_1.default.red(value.join('\n')),
+                            local: chalk_1.default.green(localResource[key].join('\n'))
+                        });
+                    }
+                }
+                else if (value !== localResource[key]) {
+                    changes.push({
+                        id: localResource['$id'],
+                        key,
+                        remote: chalk_1.default.red(value),
+                        local: chalk_1.default.green(localResource[key])
+                    });
+                }
+            }
+        }
+        catch (e) {
+            if (Number(e.code) !== 404) {
+                throw e;
+            }
+        }
+    }));
+    if (changes.length === 0) {
+        return true;
+    }
+    (0, parser_1.drawTable)(changes);
+    if ((await getConfirmation()) === true) {
+        return true;
+    }
+    (0, parser_1.success)(`Successfully pushed 0 ${resourcePlural}.`);
+    return false;
+};
+const getObjectChanges = (remote, local, index, what) => {
+    const changes = [];
+    if (remote[index] && local[index]) {
+        for (let [service, status] of Object.entries(remote[index])) {
+            const localValue = local[index][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_1.default.red(status), local: chalk_1.default.green(localValue) });
+            }
+        }
+    }
+    return changes;
+};
+const createAttribute = (databaseId, collectionId, attribute) => {
+    switch (attribute.type) {
+        case 'string':
+            switch (attribute.format) {
+                case 'email':
+                    return (0, databases_1.databasesCreateEmailAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        parseOutput: false
+                    });
+                case 'url':
+                    return (0, databases_1.databasesCreateUrlAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        parseOutput: false
+                    });
+                case 'ip':
+                    return (0, databases_1.databasesCreateIpAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        parseOutput: false
+                    });
+                case 'enum':
+                    return (0, databases_1.databasesCreateEnumAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        elements: attribute.elements,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        parseOutput: false
+                    });
+                default:
+                    return (0, databases_1.databasesCreateStringAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        size: attribute.size,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        encrypt: attribute.encrypt,
+                        parseOutput: false
+                    });
+            }
+        case 'integer':
+            return (0, databases_1.databasesCreateIntegerAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                min: attribute.min,
+                max: attribute.max,
+                xdefault: attribute.default,
+                array: attribute.array,
+                parseOutput: false
+            });
+        case 'double':
+            return (0, databases_1.databasesCreateFloatAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                min: attribute.min,
+                max: attribute.max,
+                xdefault: attribute.default,
+                array: attribute.array,
+                parseOutput: false
+            });
+        case 'boolean':
+            return (0, databases_1.databasesCreateBooleanAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                array: attribute.array,
+                parseOutput: false
+            });
+        case 'datetime':
+            return (0, databases_1.databasesCreateDatetimeAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                array: attribute.array,
+                parseOutput: false
+            });
+        case 'relationship':
+            return (0, databases_1.databasesCreateRelationshipAttribute)({
+                databaseId,
+                collectionId,
+                relatedCollectionId: attribute.relatedTable ?? attribute.relatedCollection,
+                type: attribute.relationType,
+                twoWay: attribute.twoWay,
+                key: attribute.key,
+                twoWayKey: attribute.twoWayKey,
+                onDelete: attribute.onDelete,
+                parseOutput: false
+            });
+        case 'point':
+            return (0, databases_1.databasesCreatePointAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                parseOutput: false
+            });
+        case 'linestring':
+            return (0, databases_1.databasesCreateLineAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                parseOutput: false
+            });
+        case 'polygon':
+            return (0, databases_1.databasesCreatePolygonAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                parseOutput: false
+            });
+        default:
+            throw new Error(`Unsupported attribute type: ${attribute.type}`);
+    }
+};
+const updateAttribute = (databaseId, collectionId, attribute) => {
+    switch (attribute.type) {
+        case 'string':
+            switch (attribute.format) {
+                case 'email':
+                    return (0, databases_1.databasesUpdateEmailAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        parseOutput: false
+                    });
+                case 'url':
+                    return (0, databases_1.databasesUpdateUrlAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        parseOutput: false
+                    });
+                case 'ip':
+                    return (0, databases_1.databasesUpdateIpAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        parseOutput: false
+                    });
+                case 'enum':
+                    return (0, databases_1.databasesUpdateEnumAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        elements: attribute.elements,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        parseOutput: false
+                    });
+                default:
+                    return (0, databases_1.databasesUpdateStringAttribute)({
+                        databaseId,
+                        collectionId,
+                        key: attribute.key,
+                        size: attribute.size,
+                        required: attribute.required,
+                        xdefault: attribute.default,
+                        array: attribute.array,
+                        parseOutput: false
+                    });
+            }
+        case 'integer':
+            return (0, databases_1.databasesUpdateIntegerAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                min: attribute.min,
+                max: attribute.max,
+                xdefault: attribute.default,
+                array: attribute.array,
+                parseOutput: false
+            });
+        case 'double':
+            return (0, databases_1.databasesUpdateFloatAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                min: attribute.min,
+                max: attribute.max,
+                xdefault: attribute.default,
+                array: attribute.array,
+                parseOutput: false
+            });
+        case 'boolean':
+            return (0, databases_1.databasesUpdateBooleanAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                array: attribute.array,
+                parseOutput: false
+            });
+        case 'datetime':
+            return (0, databases_1.databasesUpdateDatetimeAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                array: attribute.array,
+                parseOutput: false
+            });
+        case 'relationship':
+            return (0, databases_1.databasesUpdateRelationshipAttribute)({
+                databaseId,
+                collectionId,
+                relatedCollectionId: attribute.relatedTable ?? attribute.relatedCollection,
+                type: attribute.relationType,
+                twoWay: attribute.twoWay,
+                key: attribute.key,
+                twoWayKey: attribute.twoWayKey,
+                onDelete: attribute.onDelete,
+                parseOutput: false
+            });
+        case 'point':
+            return (0, databases_1.databasesUpdatePointAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                parseOutput: false
+            });
+        case 'linestring':
+            return (0, databases_1.databasesUpdateLineAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                parseOutput: false
+            });
+        case 'polygon':
+            return (0, databases_1.databasesUpdatePolygonAttribute)({
+                databaseId,
+                collectionId,
+                key: attribute.key,
+                required: attribute.required,
+                xdefault: attribute.default,
+                parseOutput: false
+            });
+        default:
+            throw new Error(`Unsupported attribute type: ${attribute.type}`);
+    }
+};
+const deleteAttribute = async (collection, attribute, isIndex = false) => {
+    (0, parser_1.log)(`Deleting ${isIndex ? 'index' : 'attribute'} ${attribute.key} of ${collection.name} ( ${collection['$id']} )`);
+    if (isIndex) {
+        await (0, databases_1.databasesDeleteIndex)({
+            databaseId: collection['databaseId'],
+            collectionId: collection['$id'],
+            key: attribute.key,
+            parseOutput: false
+        });
+        return;
+    }
+    await (0, databases_1.databasesDeleteAttribute)({
+        databaseId: collection['databaseId'],
+        collectionId: collection['$id'],
+        key: attribute.key,
+        parseOutput: false
+    });
+};
+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_1.default.red(remote)} to ${chalk_1.default.green(local)}`;
+        }
+    }
+    else if (!isEqual(remote, local)) {
+        const bol = reason === '' ? '' : '\n';
+        reason += `${bol}${key} changed from ${chalk_1.default.red(remote)} to ${chalk_1.default.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_1.default.yellow(local.key)} in ${collection.name} (${collection['$id']})`;
+    const action = chalk_1.default.cyan(recreating ? 'recreating' : 'changing');
+    let reason = '';
+    let attribute = recreating ? remote : local;
+    for (let key of Object.keys(remote)) {
+        if (!config_1.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_1.default.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_1.default.green('adding') : chalk_1.default.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;
+    }
+    (0, parser_1.log)(!parser_1.cliConfig.force ? 'There are pending changes in your collection deployment' : 'List of applied changes');
+    (0, parser_1.drawTable)(changing.map((change) => {
+        return { Key: change.key, Action: change.action, Reason: change.reason, };
+    }));
+    if (!parser_1.cliConfig.force) {
+        if (deleting.length > 0 && !isIndex) {
+            console.log(`${chalk_1.default.red('------------------------------------------------------')}`);
+            console.log(`${chalk_1.default.red('| WARNING: Attribute deletion may cause loss of data |')}`);
+            console.log(`${chalk_1.default.red('------------------------------------------------------')}`);
+            console.log();
+        }
+        if (conflicts.length > 0 && !isIndex) {
+            console.log(`${chalk_1.default.red('--------------------------------------------------------')}`);
+            console.log(`${chalk_1.default.red('| WARNING: Attribute recreation may cause loss of data |')}`);
+            console.log(`${chalk_1.default.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) => {
+    (0, parser_1.log)(`Creating indexes ...`);
+    for (let index of indexes) {
+        await (0, databases_1.databasesCreateIndex)({
+            databaseId: collection['databaseId'],
+            collectionId: collection['$id'],
+            key: index.key,
+            type: index.type,
+            attributes: index.columns ?? index.attributes,
+            orders: index.orders,
+            parseOutput: false
+        });
+    }
+    const result = await awaitPools.expectIndexes(collection['databaseId'], collection['$id'], indexes.map((index) => index.key));
+    if (!result) {
+        throw new Error('Index creation timed out.');
+    }
+    (0, parser_1.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.`);
+    }
+    (0, parser_1.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.`);
+    }
+    (0, parser_1.success)(`Created ${columns.length} columns`);
+};
+const pushResources = async () => {
+    const actions = {
+        settings: pushSettings,
+        functions: pushFunction,
+        sites: pushSite,
+        collections: pushCollection,
+        tables: pushTable,
+        buckets: pushBucket,
+        teams: pushTeam,
+        messages: pushMessagingTopic
+    };
+    if (parser_1.cliConfig.all) {
+        for (let action of Object.values(actions)) {
+            await action({ returnOnZero: true });
+        }
+    }
+    else {
+        const answers = await inquirer_1.default.prompt(questions_1.questionsPushResources[0]);
+        const action = actions[answers.resource];
+        if (action !== undefined) {
+            await action({ returnOnZero: true });
+        }
+    }
+};
+const pushSettings = async () => {
+    (0, utils_1.checkDeployConditions)(config_1.localConfig);
+    try {
+        let response = await (0, projects_1.projectsGet)({
+            parseOutput: false,
+            projectId: config_1.localConfig.getProject().projectId
+        });
+        const remoteSettings = config_1.localConfig.createSettingsObject(response ?? {});
+        const localSettings = config_1.localConfig.getProject().projectSettings ?? {};
+        (0, parser_1.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) {
+            (0, parser_1.drawTable)(changes);
+            if ((await getConfirmation()) !== true) {
+                (0, parser_1.success)(`Successfully pushed 0 project settings.`);
+                return;
+            }
+        }
+    }
+    catch (e) {
+    }
+    try {
+        (0, parser_1.log)("Pushing project settings ...");
+        const projectId = config_1.localConfig.getProject().projectId;
+        const projectName = config_1.localConfig.getProject().projectName;
+        const settings = config_1.localConfig.getProject().projectSettings ?? {};
+        if (projectName) {
+            (0, parser_1.log)("Applying project name ...");
+            await (0, projects_1.projectsUpdate)({
+                projectId,
+                name: projectName,
+                parseOutput: false
+            });
+        }
+        if (settings.services) {
+            (0, parser_1.log)("Applying service statuses ...");
+            for (let [service, status] of Object.entries(settings.services)) {
+                await (0, projects_1.projectsUpdateServiceStatus)({
+                    projectId,
+                    service,
+                    status,
+                    parseOutput: false
+                });
+            }
+        }
+        if (settings.auth) {
+            if (settings.auth.security) {
+                (0, parser_1.log)("Applying auth security settings ...");
+                await (0, projects_1.projectsUpdateAuthDuration)({ projectId, duration: settings.auth.security.duration, parseOutput: false });
+                await (0, projects_1.projectsUpdateAuthLimit)({ projectId, limit: settings.auth.security.limit, parseOutput: false });
+                await (0, projects_1.projectsUpdateAuthSessionsLimit)({ projectId, limit: settings.auth.security.sessionsLimit, parseOutput: false });
+                await (0, projects_1.projectsUpdateAuthPasswordDictionary)({ projectId, enabled: settings.auth.security.passwordDictionary, parseOutput: false });
+                await (0, projects_1.projectsUpdateAuthPasswordHistory)({ projectId, limit: settings.auth.security.passwordHistory, parseOutput: false });
+                await (0, projects_1.projectsUpdatePersonalDataCheck)({ projectId, enabled: settings.auth.security.personalDataCheck, parseOutput: false });
+                await (0, projects_1.projectsUpdateSessionAlerts)({ projectId, alerts: settings.auth.security.sessionAlerts, parseOutput: false });
+                await (0, projects_1.projectsUpdateMockNumbers)({ projectId, numbers: settings.auth.security.mockNumbers, parseOutput: false });
+            }
+            if (settings.auth.methods) {
+                (0, parser_1.log)("Applying auth methods statuses ...");
+                for (let [method, status] of Object.entries(settings.auth.methods)) {
+                    await (0, projects_1.projectsUpdateAuthStatus)({
+                        projectId,
+                        method,
+                        status,
+                        parseOutput: false
+                    });
+                }
+            }
+        }
+        (0, parser_1.success)(`Successfully pushed ${chalk_1.default.bold('all')} project settings.`);
+    }
+    catch (e) {
+        throw e;
+    }
+};
+const pushSite = async ({ siteId, async: asyncDeploy, code, withVariables } = { returnOnZero: false }) => {
+    process.chdir(config_1.localConfig.configDirectoryPath);
+    const siteIds = [];
+    if (siteId) {
+        siteIds.push(siteId);
+    }
+    else if (parser_1.cliConfig.all) {
+        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+        const sites = config_1.localConfig.getSites();
+        siteIds.push(...sites.map((site) => {
+            return site.$id;
+        }));
+    }
+    if (siteIds.length <= 0) {
+        const answers = await inquirer_1.default.prompt(questions_1.questionsPushSites[0]);
+        if (answers.sites) {
+            siteIds.push(...answers.sites);
+        }
+    }
+    if (siteIds.length === 0) {
+        (0, parser_1.log)("No sites found.");
+        (0, parser_1.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 = config_1.localConfig.getSites();
+        const site = sites.find((s) => s.$id === id);
+        if (!site) {
+            throw new Error("Site '" + id + "' not found.");
+        }
+        return site;
+    });
+    (0, parser_1.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) {
+            (0, parser_1.log)(`Site ${site.name} is missing build command.`);
+            const answers = await inquirer_1.default.prompt(questions_1.questionsGetEntrypoint);
+            site.buildCommand = answers.entrypoint;
+            config_1.localConfig.addSite(site);
+        }
+    }
+    if (!(await approveChanges(sites, sites_1.sitesGet, config_1.KeysSite, 'siteId', 'sites', ['vars']))) {
+        return;
+    }
+    (0, parser_1.log)('Pushing sites ...');
+    spinner_1.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_1.Spinner({ status: '', resource: site.name, id: site['$id'], end: `Ignoring using: ${ignore}` });
+        updaterRow.update({ status: 'Getting' }).startSpinner(spinner_1.SPINNER_DOTS);
+        try {
+            response = await (0, sites_1.sitesGet)({
+                siteId: site['$id'],
+                parseOutput: false,
+            });
+            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_1.SPINNER_ARC);
+            response = await (0, sites_1.sitesUpdate)({
+                siteId: site['$id'],
+                name: site.name,
+                framework: site.framework,
+                buildRuntime: site.buildRuntime,
+                specification: site.specification,
+                timeout: site.timeout,
+                enabled: site.enabled,
+                logging: site.logging,
+                adapter: site.adapter,
+                buildCommand: site.buildCommand,
+                installCommand: site.installCommand,
+                outputDirectory: site.outputDirectory,
+                fallbackFile: site.fallbackFile,
+                vars: JSON.stringify(response.vars),
+                parseOutput: false
+            });
+        }
+        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_1.SPINNER_DOTS);
+            try {
+                response = await (0, sites_1.sitesCreate)({
+                    siteId: site.$id,
+                    name: site.name,
+                    framework: site.framework,
+                    specification: site.specification,
+                    buildRuntime: site.buildRuntime,
+                    buildCommand: site.buildCommand,
+                    installCommand: site.installCommand,
+                    outputDirectory: site.outputDirectory,
+                    fallbackFile: site.fallbackFile,
+                    adapter: site.adapter,
+                    timeout: site.timeout,
+                    enabled: site.enabled,
+                    logging: site.logging,
+                    parseOutput: false
+                });
+                let domain = '';
+                try {
+                    const variables = await (0, console_1.consoleVariables)({ parseOutput: false, sdk: await (0, sdks_1.sdkForConsole)() });
+                    domain = id_1.default.unique() + '.' + variables['_APP_DOMAIN_SITES'];
+                }
+                catch (error) {
+                    console.error('Error fetching console variables.');
+                    throw error;
+                }
+                try {
+                    const rule = await (0, proxy_1.proxyCreateSiteRule)({
+                        domain: domain,
+                        siteId: 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_1.SPINNER_ARC);
+            const { variables } = await (0, paginate_1.paginate)(sites_1.sitesListVariables, {
+                siteId: site['$id'],
+                parseOutput: false
+            }, 100, 'variables');
+            await Promise.all(variables.map(async (variable) => {
+                await (0, sites_1.sitesDeleteVariable)({
+                    siteId: site['$id'],
+                    variableId: variable['$id'],
+                    parseOutput: false
+                });
+            }));
+            const envFileLocation = `${site['path']}/.env`;
+            let envVariables = [];
+            try {
+                if (fs.existsSync(envFileLocation)) {
+                    const envObject = (0, dotenv_1.parse)(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) => {
+                await (0, sites_1.sitesCreateVariable)({
+                    siteId: site['$id'],
+                    key: variable.key,
+                    value: variable.value,
+                    parseOutput: false,
+                    secret: false
+                });
+            }));
+        }
+        if (code === false) {
+            successfullyPushed++;
+            successfullyDeployed++;
+            updaterRow.update({ status: 'Pushed' });
+            updaterRow.stopSpinner();
+            return;
+        }
+        try {
+            updaterRow.update({ status: 'Pushing' }).replaceSpinner(spinner_1.SPINNER_ARC);
+            response = await (0, sites_1.sitesCreateDeployment)({
+                siteId: site['$id'],
+                buildCommand: site.buildCommand,
+                installCommand: site.installCommand,
+                outputDirectory: site.outputDirectory,
+                fallbackFile: site.fallbackFile,
+                code: site.path,
+                activate: true,
+                parseOutput: false
+            });
+            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) {
+                    response = await (0, sites_1.sitesGetDeployment)({
+                        siteId: site['$id'],
+                        deploymentId: deploymentId,
+                        parseOutput: false
+                    });
+                    const status = response['status'];
+                    if (status === 'ready') {
+                        successfullyDeployed++;
+                        let url = '';
+                        const res = await (0, proxy_1.proxyListRules)({
+                            parseOutput: false,
+                            queries: [
+                                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_1.Spinner.stop();
+    failedDeployments.forEach((failed) => {
+        const { name, deployment, $id } = failed;
+        const failUrl = `${config_1.globalConfig.getEndpoint().slice(0, -3)}/console/project-${config_1.localConfig.getProject().projectId}/sites/site-${$id}/deployments/deployment-${deployment}`;
+        (0, parser_1.error)(`Deployment of ${name} has failed. Check at ${failUrl} for more details\n`);
+    });
+    if (!asyncDeploy) {
+        if (successfullyPushed === 0) {
+            (0, parser_1.error)('No sites were pushed.');
+        }
+        else if (successfullyDeployed !== successfullyPushed) {
+            (0, parser_1.warn)(`Successfully pushed ${successfullyDeployed} of ${successfullyPushed} sites`);
+        }
+        else {
+            (0, parser_1.success)(`Successfully pushed ${successfullyPushed} sites.`);
+        }
+    }
+    else {
+        (0, parser_1.success)(`Successfully pushed ${successfullyPushed} sites.`);
+    }
+    if (parser_1.cliConfig.verbose) {
+        errors.forEach(e => {
+            console.error(e);
+        });
+    }
+};
+const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariables } = { returnOnZero: false }) => {
+    process.chdir(config_1.localConfig.configDirectoryPath);
+    const functionIds = [];
+    if (functionId) {
+        functionIds.push(functionId);
+    }
+    else if (parser_1.cliConfig.all) {
+        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+        const functions = config_1.localConfig.getFunctions();
+        functionIds.push(...functions.map((func) => {
+            return func.$id;
+        }));
+    }
+    if (functionIds.length <= 0) {
+        const answers = await inquirer_1.default.prompt(questions_1.questionsPushFunctions[0]);
+        if (answers.functions) {
+            functionIds.push(...answers.functions);
+        }
+    }
+    if (functionIds.length === 0) {
+        (0, parser_1.log)("No functions found.");
+        (0, parser_1.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 = config_1.localConfig.getFunctions();
+        const func = functions.find((f) => f.$id === id);
+        if (!func) {
+            throw new Error("Function '" + id + "' not found.");
+        }
+        return func;
+    });
+    (0, parser_1.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) {
+            (0, parser_1.log)(`Function ${func.name} is missing an entrypoint.`);
+            const answers = await inquirer_1.default.prompt(questions_1.questionsGetEntrypoint);
+            func.entrypoint = answers.entrypoint;
+            config_1.localConfig.addFunction(func);
+        }
+    }
+    if (!(await approveChanges(functions, functions_1.functionsGet, config_1.KeysFunction, 'functionId', 'functions', ['vars']))) {
+        return;
+    }
+    (0, parser_1.log)('Pushing functions ...');
+    spinner_1.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_1.Spinner({ status: '', resource: func.name, id: func['$id'], end: `Ignoring using: ${ignore}` });
+        updaterRow.update({ status: 'Getting' }).startSpinner(spinner_1.SPINNER_DOTS);
+        try {
+            response = await (0, functions_1.functionsGet)({
+                functionId: func['$id'],
+                parseOutput: false,
+            });
+            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_1.SPINNER_ARC);
+            response = await (0, functions_1.functionsUpdate)({
+                functionId: func['$id'],
+                name: func.name,
+                specification: func.specification,
+                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,
+                vars: JSON.stringify(response.vars),
+                parseOutput: false
+            });
+        }
+        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_1.SPINNER_DOTS);
+            try {
+                response = await (0, functions_1.functionsCreate)({
+                    functionId: func.$id,
+                    name: func.name,
+                    runtime: func.runtime,
+                    specification: func.specification,
+                    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,
+                    parseOutput: false
+                });
+                let domain = '';
+                try {
+                    const variables = await (0, console_1.consoleVariables)({ parseOutput: false, sdk: await (0, sdks_1.sdkForConsole)() });
+                    domain = id_1.default.unique() + '.' + variables['_APP_DOMAIN_FUNCTIONS'];
+                }
+                catch (error) {
+                    console.error('Error fetching console variables.');
+                    throw error;
+                }
+                try {
+                    const rule = await (0, proxy_1.proxyCreateFunctionRule)({
+                        domain: domain,
+                        functionId: 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_1.SPINNER_ARC);
+            const { variables } = await (0, paginate_1.paginate)(functions_1.functionsListVariables, {
+                functionId: func['$id'],
+                parseOutput: false
+            }, 100, 'variables');
+            await Promise.all(variables.map(async (variable) => {
+                await (0, functions_1.functionsDeleteVariable)({
+                    functionId: func['$id'],
+                    variableId: variable['$id'],
+                    parseOutput: false
+                });
+            }));
+            const envFileLocation = `${func['path']}/.env`;
+            let envVariables = [];
+            try {
+                if (fs.existsSync(envFileLocation)) {
+                    const envObject = (0, dotenv_1.parse)(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) => {
+                await (0, functions_1.functionsCreateVariable)({
+                    functionId: func['$id'],
+                    variableId: id_1.default.unique(),
+                    key: variable.key,
+                    value: variable.value,
+                    parseOutput: false,
+                    secret: false
+                });
+            }));
+        }
+        if (code === false) {
+            successfullyPushed++;
+            successfullyDeployed++;
+            updaterRow.update({ status: 'Pushed' });
+            updaterRow.stopSpinner();
+            return;
+        }
+        try {
+            updaterRow.update({ status: 'Pushing' }).replaceSpinner(spinner_1.SPINNER_ARC);
+            response = await (0, functions_1.functionsCreateDeployment)({
+                functionId: func['$id'],
+                entrypoint: func.entrypoint,
+                commands: func.commands,
+                code: func.path,
+                activate: true,
+                parseOutput: false
+            });
+            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) {
+                    response = await (0, functions_1.functionsGetDeployment)({
+                        functionId: func['$id'],
+                        deploymentId: deploymentId,
+                        parseOutput: false
+                    });
+                    const status = response['status'];
+                    if (status === 'ready') {
+                        successfullyDeployed++;
+                        let url = '';
+                        const res = await (0, proxy_1.proxyListRules)({
+                            parseOutput: false,
+                            queries: [
+                                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_1.Spinner.stop();
+    failedDeployments.forEach((failed) => {
+        const { name, deployment, $id } = failed;
+        const failUrl = `${config_1.globalConfig.getEndpoint().slice(0, -3)}/console/project-${config_1.localConfig.getProject().projectId}/functions/function-${$id}/deployment-${deployment}`;
+        (0, parser_1.error)(`Deployment of ${name} has failed. Check at ${failUrl} for more details\n`);
+    });
+    if (!asyncDeploy) {
+        if (successfullyPushed === 0) {
+            (0, parser_1.error)('No functions were pushed.');
+        }
+        else if (successfullyDeployed !== successfullyPushed) {
+            (0, parser_1.warn)(`Successfully pushed ${successfullyDeployed} of ${successfullyPushed} functions`);
+        }
+        else {
+            (0, parser_1.success)(`Successfully pushed ${successfullyPushed} functions.`);
+        }
+    }
+    else {
+        (0, parser_1.success)(`Successfully pushed ${successfullyPushed} functions.`);
+    }
+    if (parser_1.cliConfig.verbose) {
+        errors.forEach(e => {
+            console.error(e);
+        });
+    }
+};
+const checkAndApplyTablesDBChanges = async () => {
+    (0, parser_1.log)('Checking for tablesDB changes ...');
+    const localTablesDBs = config_1.localConfig.getTablesDBs();
+    const { databases: remoteTablesDBs } = await (0, paginate_1.paginate)(tables_db_1.tablesDBList, { parseOutput: false }, 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_1.default.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_1.default.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_1.default.yellow('updating'),
+                    key: 'Name',
+                    remote: remoteDB.name,
+                    local: localDB.name
+                });
+            }
+            if (remoteDB.enabled !== localDB.enabled) {
+                hasChanges = true;
+                changes.push({
+                    id: localDB.$id,
+                    action: chalk_1.default.yellow('updating'),
+                    key: 'Enabled',
+                    remote: remoteDB.enabled,
+                    local: localDB.enabled
+                });
+            }
+            if (hasChanges) {
+                toUpdate.push(localDB);
+            }
+        }
+    }
+    if (changes.length === 0) {
+        console.log('No changes found in tablesDB resource');
+        console.log();
+        return { applied: false, resyncNeeded: false };
+    }
+    (0, parser_1.log)('Found changes in tablesDB resource:');
+    (0, parser_1.drawTable)(changes);
+    if (toDelete.length > 0) {
+        console.log(`${chalk_1.default.red('------------------------------------------------------------------')}`);
+        console.log(`${chalk_1.default.red('| WARNING: Database deletion will also delete all related tables |')}`);
+        console.log(`${chalk_1.default.red('------------------------------------------------------------------')}`);
+        console.log();
+    }
+    if ((await getConfirmation()) !== true) {
+        return { applied: false, resyncNeeded: false };
+    }
+    // Apply deletions first
+    let needsResync = false;
+    for (const db of toDelete) {
+        try {
+            (0, parser_1.log)(`Deleting database ${db.name} ( ${db.$id} ) ...`);
+            await (0, tables_db_1.tablesDBDelete)({
+                databaseId: db.$id,
+                parseOutput: false
+            });
+            (0, parser_1.success)(`Deleted ${db.name} ( ${db.$id} )`);
+            needsResync = true;
+        }
+        catch (e) {
+            (0, parser_1.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 {
+            (0, parser_1.log)(`Creating database ${db.name} ( ${db.$id} ) ...`);
+            await (0, tables_db_1.tablesDBCreate)({
+                databaseId: db.$id,
+                name: db.name,
+                enabled: db.enabled,
+                parseOutput: false
+            });
+            (0, parser_1.success)(`Created ${db.name} ( ${db.$id} )`);
+        }
+        catch (e) {
+            (0, parser_1.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 {
+            (0, parser_1.log)(`Updating database ${db.name} ( ${db.$id} ) ...`);
+            await (0, tables_db_1.tablesDBUpdate)({
+                databaseId: db.$id,
+                name: db.name,
+                enabled: db.enabled,
+                parseOutput: false
+            });
+            (0, parser_1.success)(`Updated ${db.name} ( ${db.$id} )`);
+        }
+        catch (e) {
+            (0, parser_1.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 ({ returnOnZero, attempts } = { returnOnZero: false }) => {
+    const tables = [];
+    if (attempts) {
+        pollMaxDebounces = attempts;
+    }
+    const { applied: tablesDBApplied, resyncNeeded } = await checkAndApplyTablesDBChanges();
+    if (resyncNeeded) {
+        (0, parser_1.log)('Resyncing configuration due to tablesDB deletions ...');
+        const remoteTablesDBs = (await (0, paginate_1.paginate)(tables_db_1.tablesDBList, { parseOutput: false }, 100, 'databases')).databases;
+        const localTablesDBs = config_1.localConfig.getTablesDBs();
+        const remoteDatabaseIds = new Set(remoteTablesDBs.map((db) => db.$id));
+        const localTables = config_1.localConfig.getTables();
+        const validTables = localTables.filter((table) => remoteDatabaseIds.has(table.databaseId));
+        config_1.localConfig.set('tables', validTables);
+        const validTablesDBs = localTablesDBs.filter((db) => remoteDatabaseIds.has(db.$id));
+        config_1.localConfig.set('tablesDB', validTablesDBs);
+        (0, parser_1.success)('Configuration resynced successfully.');
+        console.log();
+    }
+    (0, parser_1.log)('Checking for deleted tables ...');
+    const localTablesDBs = config_1.localConfig.getTablesDBs();
+    const localTables = config_1.localConfig.getTables();
+    const tablesToDelete = [];
+    for (const db of localTablesDBs) {
+        try {
+            const { tables: remoteTables } = await (0, paginate_1.paginate)(tables_db_1.tablesDBListTables, {
+                databaseId: db.$id,
+                parseOutput: false
+            }, 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) {
+        (0, parser_1.log)('Found tables that exist remotely but not locally:');
+        const deletionChanges = tablesToDelete.map((table) => ({
+            id: table.$id,
+            action: chalk_1.default.red('deleting'),
+            key: 'Table',
+            database: table.databaseName,
+            remote: table.name,
+            local: '(deleted locally)'
+        }));
+        (0, parser_1.drawTable)(deletionChanges);
+        if ((await getConfirmation()) === true) {
+            for (const table of tablesToDelete) {
+                try {
+                    (0, parser_1.log)(`Deleting table ${table.name} ( ${table.$id} ) from database ${table.databaseName} ...`);
+                    await (0, tables_db_1.tablesDBDeleteTable)({
+                        databaseId: table.databaseId,
+                        tableId: table.$id,
+                        parseOutput: false
+                    });
+                    (0, parser_1.success)(`Deleted ${table.name} ( ${table.$id} )`);
+                }
+                catch (e) {
+                    (0, parser_1.error)(`Failed to delete table ${table.name} ( ${table.$id} ): ${e.message}`);
+                }
+            }
+        }
+    }
+    else {
+        console.log('No tables found to delete');
+    }
+    console.log();
+    if (parser_1.cliConfig.all) {
+        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+        tables.push(...config_1.localConfig.getTables());
+    }
+    else {
+        const answers = await inquirer_1.default.prompt(questions_1.questionsPushTables);
+        if (answers.tables) {
+            const configTables = new Map();
+            config_1.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) {
+        (0, parser_1.log)("No tables found.");
+        (0, parser_1.hint)("Use 'appwrite pull tables' to synchronize existing one, or use 'appwrite init table' to create a new one.");
+        return;
+    }
+    if (!(await approveChanges(tables, tables_db_1.tablesDBGetTable, config_1.KeysTable, 'tableId', 'tables', ['columns', 'indexes'], 'databaseId', 'databaseId'))) {
+        return;
+    }
+    let tablesChanged = new Set();
+    // Parallel tables actions
+    await Promise.all(tables.map(async (table) => {
+        try {
+            const remoteTable = await (0, tables_db_1.tablesDBGetTable)({
+                databaseId: table['databaseId'],
+                tableId: table['$id'],
+                parseOutput: false,
+            });
+            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 (0, tables_db_1.tablesDBUpdateTable)({
+                    databaseId: table['databaseId'],
+                    tableId: table['$id'],
+                    name: table.name,
+                    parseOutput: false,
+                    rowSecurity: table.rowSecurity,
+                    permissions: table['$permissions']
+                });
+                (0, parser_1.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) {
+                (0, parser_1.log)(`Table ${table.name} does not exist in the project. Creating ... `);
+                await (0, tables_db_1.tablesDBCreateTable)({
+                    databaseId: table['databaseId'],
+                    tableId: table['$id'],
+                    name: table.name,
+                    rowSecurity: table.rowSecurity,
+                    permissions: table['$permissions'],
+                    parseOutput: false
+                });
+                (0, parser_1.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;
+            }
+        }
+        (0, parser_1.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']);
+        (0, parser_1.success)(`Successfully pushed ${table.name} ( ${table['$id']} )`);
+    }
+    (0, parser_1.success)(`Successfully pushed ${tablesChanged.size} tables`);
+};
+const pushCollection = async ({ returnOnZero, attempts } = { returnOnZero: false }) => {
+    (0, parser_1.warn)("appwrite push collection has been deprecated. Please consider using 'appwrite push tables' instead");
+    const collections = [];
+    if (attempts) {
+        pollMaxDebounces = attempts;
+    }
+    if (parser_1.cliConfig.all) {
+        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+        collections.push(...config_1.localConfig.getCollections());
+    }
+    else {
+        const answers = await inquirer_1.default.prompt(questions_1.questionsPushCollections);
+        if (answers.collections) {
+            const configCollections = new Map();
+            config_1.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) {
+        (0, parser_1.log)("No collections found.");
+        (0, parser_1.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 = config_1.localConfig.getDatabase(databaseId);
+        try {
+            const database = await (0, databases_1.databasesGet)({
+                databaseId: databaseId,
+                parseOutput: false,
+            });
+            if (database.name !== (localDatabase.name ?? databaseId)) {
+                await (0, databases_1.databasesUpdate)({
+                    databaseId: databaseId,
+                    name: localDatabase.name ?? databaseId,
+                    parseOutput: false
+                });
+                (0, parser_1.success)(`Updated ${localDatabase.name} ( ${databaseId} ) name`);
+            }
+        }
+        catch (err) {
+            (0, parser_1.log)(`Database ${databaseId} not found. Creating it now ...`);
+            await (0, databases_1.databasesCreate)({
+                databaseId: databaseId,
+                name: localDatabase.name ?? databaseId,
+                parseOutput: false,
+            });
+        }
+    }));
+    if (!(await approveChanges(collections, databases_1.databasesGetCollection, config_1.KeysCollection, 'collectionId', 'collections', ['attributes', 'indexes'], 'databaseId', 'databaseId'))) {
+        return;
+    }
+    // Parallel collection actions
+    await Promise.all(collections.map(async (collection) => {
+        try {
+            const remoteCollection = await (0, databases_1.databasesGetCollection)({
+                databaseId: collection['databaseId'],
+                collectionId: collection['$id'],
+                parseOutput: false,
+            });
+            if (remoteCollection.name !== collection.name) {
+                await (0, databases_1.databasesUpdateCollection)({
+                    databaseId: collection['databaseId'],
+                    collectionId: collection['$id'],
+                    name: collection.name,
+                    parseOutput: false
+                });
+                (0, parser_1.success)(`Updated ${collection.name} ( ${collection['$id']} ) name`);
+            }
+            collection.remoteVersion = remoteCollection;
+            collection.isExisted = true;
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                (0, parser_1.log)(`Collection ${collection.name} does not exist in the project. Creating ... `);
+                await (0, databases_1.databasesCreateCollection)({
+                    databaseId: collection['databaseId'],
+                    collectionId: collection['$id'],
+                    name: collection.name,
+                    documentSecurity: collection.documentSecurity,
+                    permissions: collection['$permissions'],
+                    parseOutput: false
+                });
+            }
+            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;
+            }
+        }
+        (0, parser_1.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++;
+        (0, parser_1.success)(`Successfully pushed ${collection.name} ( ${collection['$id']} )`);
+    }
+    (0, parser_1.success)(`Successfully pushed ${numberOfCollections} collections`);
+};
+const pushBucket = async ({ returnOnZero } = { returnOnZero: false }) => {
+    let response = {};
+    let bucketIds = [];
+    const configBuckets = config_1.localConfig.getBuckets();
+    if (parser_1.cliConfig.all) {
+        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+        bucketIds.push(...configBuckets.map((b) => b.$id));
+    }
+    if (bucketIds.length === 0) {
+        const answers = await inquirer_1.default.prompt(questions_1.questionsPushBuckets[0]);
+        if (answers.buckets) {
+            bucketIds.push(...answers.buckets);
+        }
+    }
+    if (bucketIds.length === 0) {
+        (0, parser_1.log)("No buckets found.");
+        (0, parser_1.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, storage_1.storageGetBucket, config_1.KeysStorage, 'bucketId', 'buckets'))) {
+        return;
+    }
+    (0, parser_1.log)('Pushing buckets ...');
+    for (let bucket of buckets) {
+        (0, parser_1.log)(`Pushing bucket ${chalk_1.default.bold(bucket['name'])} ...`);
+        try {
+            response = await (0, storage_1.storageGetBucket)({
+                bucketId: bucket['$id'],
+                parseOutput: false,
+            });
+            await (0, storage_1.storageUpdateBucket)({
+                bucketId: bucket['$id'],
+                name: bucket.name,
+                permissions: bucket['$permissions'],
+                fileSecurity: bucket.fileSecurity,
+                enabled: bucket.enabled,
+                maximumFileSize: bucket.maximumFileSize,
+                allowedFileExtensions: bucket.allowedFileExtensions,
+                encryption: bucket.encryption,
+                antivirus: bucket.antivirus,
+                compression: bucket.compression,
+                parseOutput: false
+            });
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                (0, parser_1.log)(`Bucket ${bucket.name} does not exist in the project. Creating ... `);
+                response = await (0, storage_1.storageCreateBucket)({
+                    bucketId: bucket['$id'],
+                    name: bucket.name,
+                    permissions: bucket['$permissions'],
+                    fileSecurity: bucket.fileSecurity,
+                    enabled: bucket.enabled,
+                    maximumFileSize: bucket.maximumFileSize,
+                    allowedFileExtensions: bucket.allowedFileExtensions,
+                    compression: bucket.compression,
+                    encryption: bucket.encryption,
+                    antivirus: bucket.antivirus,
+                    parseOutput: false
+                });
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    (0, parser_1.success)(`Successfully pushed ${buckets.length} buckets.`);
+};
+const pushTeam = async ({ returnOnZero } = { returnOnZero: false }) => {
+    let response = {};
+    let teamIds = [];
+    const configTeams = config_1.localConfig.getTeams();
+    if (parser_1.cliConfig.all) {
+        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+        teamIds.push(...configTeams.map((t) => t.$id));
+    }
+    if (teamIds.length === 0) {
+        const answers = await inquirer_1.default.prompt(questions_1.questionsPushTeams[0]);
+        if (answers.teams) {
+            teamIds.push(...answers.teams);
+        }
+    }
+    if (teamIds.length === 0) {
+        (0, parser_1.log)("No teams found.");
+        (0, parser_1.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, teams_1.teamsGet, config_1.KeysTeams, 'teamId', 'teams'))) {
+        return;
+    }
+    (0, parser_1.log)('Pushing teams ...');
+    for (let team of teams) {
+        (0, parser_1.log)(`Pushing team ${chalk_1.default.bold(team['name'])} ...`);
+        try {
+            response = await (0, teams_1.teamsGet)({
+                teamId: team['$id'],
+                parseOutput: false,
+            });
+            await (0, teams_1.teamsUpdateName)({
+                teamId: team['$id'],
+                name: team.name,
+                parseOutput: false
+            });
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                (0, parser_1.log)(`Team ${team.name} does not exist in the project. Creating ... `);
+                response = await (0, teams_1.teamsCreate)({
+                    teamId: team['$id'],
+                    name: team.name,
+                    parseOutput: false
+                });
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    (0, parser_1.success)(`Successfully pushed ${teams.length} teams.`);
+};
+const pushMessagingTopic = async ({ returnOnZero } = { returnOnZero: false }) => {
+    let response = {};
+    let topicsIds = [];
+    const configTopics = config_1.localConfig.getMessagingTopics();
+    if (parser_1.cliConfig.all) {
+        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+        topicsIds.push(...configTopics.map((b) => b.$id));
+    }
+    if (topicsIds.length === 0) {
+        const answers = await inquirer_1.default.prompt(questions_1.questionsPushMessagingTopics[0]);
+        if (answers.topics) {
+            topicsIds.push(...answers.topics);
+        }
+    }
+    if (topicsIds.length === 0) {
+        (0, parser_1.log)("No topics found.");
+        (0, parser_1.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, messaging_1.messagingGetTopic, config_1.KeysTopics, 'topicId', 'topics'))) {
+        return;
+    }
+    (0, parser_1.log)('Pushing topics ...');
+    for (let topic of topics) {
+        (0, parser_1.log)(`Pushing topic ${chalk_1.default.bold(topic['name'])} ...`);
+        try {
+            response = await (0, messaging_1.messagingGetTopic)({
+                topicId: topic['$id'],
+                parseOutput: false
+            });
+            (0, parser_1.log)(`Topic ${topic.name} ( ${topic['$id']} ) already exists.`);
+            await (0, messaging_1.messagingUpdateTopic)({
+                topicId: topic['$id'],
+                name: topic.name,
+                subscribe: topic.subscribe,
+                parseOutput: false
+            });
+        }
+        catch (e) {
+            if (Number(e.code) === 404) {
+                (0, parser_1.log)(`Topic ${topic.name} does not exist in the project. Creating ... `);
+                response = await (0, messaging_1.messagingCreateTopic)({
+                    topicId: topic['$id'],
+                    name: topic.name,
+                    subscribe: topic.subscribe,
+                    parseOutput: false
+                });
+                (0, parser_1.success)(`Created ${topic.name} ( ${topic['$id']} )`);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    (0, parser_1.success)(`Successfully pushed ${topics.length} topics.`);
+};
+exports.push = new commander_1.Command("push")
+    .description(parser_1.commandDescriptions['push'])
+    .action((0, parser_1.actionRunner)(pushResources));
+exports.push
+    .command("all")
+    .description("Push all resource.")
+    .action((0, parser_1.actionRunner)(() => {
+    parser_1.cliConfig.all = true;
+    return pushResources();
+}));
+exports.push
+    .command("settings")
+    .description("Push project name, services and auth settings")
+    .action((0, parser_1.actionRunner)(pushSettings));
+exports.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((0, parser_1.actionRunner)(pushFunction));
+exports.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((0, parser_1.actionRunner)(pushSite));
+exports.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((0, parser_1.actionRunner)(pushCollection));
+exports.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((0, parser_1.actionRunner)(pushTable));
+exports.push
+    .command("bucket")
+    .alias("buckets")
+    .description("Push buckets in the current project.")
+    .action((0, parser_1.actionRunner)(pushBucket));
+exports.push
+    .command("team")
+    .alias("teams")
+    .description("Push teams in the current project.")
+    .action((0, parser_1.actionRunner)(pushTeam));
+exports.push
+    .command("topic")
+    .alias("topics")
+    .description("Push messaging topics in the current project.")
+    .action((0, parser_1.actionRunner)(pushMessagingTopic));
+exports.deploy = new commander_1.Command("deploy")
+    .description('Removed. Use appwrite push instead')
+    .action((0, parser_1.actionRunner)(async () => {
+    (0, parser_1.warn)("appwrite deploy has been removed. Please use 'appwrite push' instead");
+}));
+//# sourceMappingURL=push.js.map