appwrite-cli 13.0.0-rc.2 → 13.0.0-rc.3

package/dist/lib/commands/push.js

@@ -4,790 +4,1195 @@ import chalk from "chalk";
 import inquirer from "inquirer";
 import { Command } from "commander";
 import ID from "../id.js";
-import { localConfig, globalConfig, KeysAttributes, KeysFunction, KeysSite, whitelistKeys, KeysTopics, KeysStorage, KeysTeams, KeysCollection, KeysTable, } from "../config.js";
-import { Spinner, SPINNER_ARC, SPINNER_DOTS } from "../spinner.js";
+import { EXECUTABLE_NAME } from "../constants.js";
+import { localConfig, globalConfig, KeysFunction, KeysSite, KeysTopics, KeysStorage, KeysTeams, KeysCollection, KeysTable, } from "../config.js";
+import { createSettingsObject } from "../utils.js";
+import { Spinner, SPINNER_DOTS } from "../spinner.js";
 import { paginate } from "../paginate.js";
-import { questionsPushBuckets, questionsPushTeams, questionsPushFunctions, questionsPushSites, questionsGetEntrypoint, questionsPushCollections, questionsPushTables, questionPushChanges, questionPushChangesConfirmation, questionsPushMessagingTopics, questionsPushResources, } from "../questions.js";
+import { pushDeployment } from "./utils/deployment.js";
+import { questionsPushBuckets, questionsPushTeams, questionsPushFunctions, questionsPushSites, questionsGetEntrypoint, questionsPushCollections, questionsPushTables, questionsPushMessagingTopics, questionsPushResources, } from "../questions.js";
 import { cliConfig, actionRunner, success, warn, log, hint, error, commandDescriptions, drawTable, } from "../parser.js";
 import { getProxyService, getConsoleService, getFunctionsService, getSitesService, getDatabasesService, getTablesDBService, getStorageService, getMessagingService, getTeamsService, getProjectsService, } from "../services.js";
+import { sdkForProject, sdkForConsole } from "../sdks.js";
+import { AppwriteException, Query, } from "@appwrite.io/console";
 import { checkDeployConditions } from "../utils.js";
-const STEP_SIZE = 100; // Resources
+import { Pools } from "./utils/pools.js";
+import { Attributes } from "./utils/attributes.js";
+import { getConfirmation, approveChanges, getObjectChanges, } from "./utils/change-approval.js";
+import { checkAndApplyTablesDBChanges } from "./utils/database-sync.js";
 const POLL_DEBOUNCE = 2000; // Milliseconds
 const POLL_DEFAULT_VALUE = 30;
-let pollMaxDebounces = POLL_DEFAULT_VALUE;
-const changeableKeys = [
-    "status",
-    "required",
-    "xdefault",
-    "elements",
-    "min",
-    "max",
-    "default",
-    "error",
-];
-const awaitPools = {
-    wipeAttributes: async (databaseId, collectionId, iteration = 1) => {
-        if (iteration > pollMaxDebounces) {
-            return false;
-        }
-        const databasesService = await getDatabasesService();
-        const response = await databasesService.listAttributes(databaseId, collectionId, [JSON.stringify({ method: "limit", values: [1] })]);
-        const { total } = response;
-        if (total === 0) {
-            return true;
+const DEPLOYMENT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+export class Push {
+    projectClient;
+    consoleClient;
+    silent;
+    constructor(projectClient, consoleClient, silent = false) {
+        this.projectClient = projectClient;
+        this.consoleClient = consoleClient;
+        this.silent = silent;
+    }
+    /**
+     * Log a message (respects silent mode)
+     */
+    log(message) {
+        if (!this.silent) {
+            log(message);
+        }
+    }
+    /**
+     * Log a success message (respects silent mode)
+     */
+    success(message) {
+        if (!this.silent) {
+            success(message);
+        }
+    }
+    /**
+     * Log a warning message (respects silent mode)
+     */
+    warn(message) {
+        if (!this.silent) {
+            warn(message);
+        }
+    }
+    /**
+     * Log an error message (respects silent mode)
+     */
+    error(message) {
+        if (!this.silent) {
+            error(message);
+        }
+    }
+    async pushResources(config, options = { all: true, skipDeprecated: true }) {
+        const { skipDeprecated = true } = options;
+        const results = {};
+        const allErrors = [];
+        const shouldPushAll = options.all === true;
+        // Push settings
+        if ((shouldPushAll || options.settings) &&
+            (config.projectName || config.settings)) {
+            try {
+                this.log("Pushing settings ...");
+                await this.pushSettings({
+                    projectId: config.projectId,
+                    projectName: config.projectName,
+                    settings: config.settings,
+                });
+                this.success(`Successfully pushed ${chalk.bold("all")} project settings.`);
+                results.settings = { success: true };
+            }
+            catch (e) {
+                allErrors.push(e);
+                results.settings = { success: false, error: e.message };
+            }
         }
-        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
-            let steps = Math.max(1, Math.ceil(total / STEP_SIZE));
-            if (steps > 1 && iteration === 1) {
-                pollMaxDebounces *= steps;
-                log("Found a large number of attributes, increasing timeout to " +
-                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
-                    " minutes");
+        // Push buckets
+        if ((shouldPushAll || options.buckets) &&
+            config.buckets &&
+            config.buckets.length > 0) {
+            try {
+                this.log("Pushing buckets ...");
+                const result = await this.pushBuckets(config.buckets);
+                this.success(`Successfully pushed ${chalk.bold(result.successfullyPushed)} buckets.`);
+                results.buckets = result;
+                allErrors.push(...result.errors);
+            }
+            catch (e) {
+                allErrors.push(e);
+                results.buckets = { successfullyPushed: 0, errors: [e] };
             }
         }
-        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;
+        // Push teams
+        if ((shouldPushAll || options.teams) &&
+            config.teams &&
+            config.teams.length > 0) {
+            try {
+                this.log("Pushing teams ...");
+                const result = await this.pushTeams(config.teams);
+                this.success(`Successfully pushed ${chalk.bold(result.successfullyPushed)} teams.`);
+                results.teams = result;
+                allErrors.push(...result.errors);
+            }
+            catch (e) {
+                allErrors.push(e);
+                results.teams = { successfullyPushed: 0, errors: [e] };
+            }
         }
-        const databasesService = await getDatabasesService();
-        const response = await databasesService.listIndexes(databaseId, collectionId, [JSON.stringify({ method: "limit", values: [1] })]);
-        const { total } = response;
-        if (total === 0) {
-            return true;
+        // Push messaging topics
+        if ((shouldPushAll || options.topics) &&
+            config.topics &&
+            config.topics.length > 0) {
+            try {
+                this.log("Pushing topics ...");
+                const result = await this.pushMessagingTopics(config.topics);
+                this.success(`Successfully pushed ${chalk.bold(result.successfullyPushed)} topics.`);
+                results.topics = result;
+                allErrors.push(...result.errors);
+            }
+            catch (e) {
+                allErrors.push(e);
+                results.topics = { successfullyPushed: 0, errors: [e] };
+            }
         }
-        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
-            let steps = Math.max(1, Math.ceil(total / STEP_SIZE));
-            if (steps > 1 && iteration === 1) {
-                pollMaxDebounces *= steps;
-                log("Found a large number of indexes, increasing timeout to " +
-                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
-                    " minutes");
+        // Push functions
+        if ((shouldPushAll || options.functions) &&
+            config.functions &&
+            config.functions.length > 0) {
+            try {
+                this.log("Pushing functions ...");
+                const result = await this.pushFunctions(config.functions, options.functionOptions);
+                this.success(`Successfully pushed ${chalk.bold(result.successfullyPushed)} functions.`);
+                results.functions = result;
+                allErrors.push(...result.errors);
+            }
+            catch (e) {
+                allErrors.push(e);
+                results.functions = {
+                    successfullyPushed: 0,
+                    successfullyDeployed: 0,
+                    failedDeployments: [],
+                    errors: [e],
+                };
             }
         }
-        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;
+        // Push sites
+        if ((shouldPushAll || options.sites) &&
+            config.sites &&
+            config.sites.length > 0) {
+            try {
+                this.log("Pushing sites ...");
+                const result = await this.pushSites(config.sites, options.siteOptions);
+                this.success(`Successfully pushed ${chalk.bold(result.successfullyPushed)} sites.`);
+                results.sites = result;
+                allErrors.push(...result.errors);
+            }
+            catch (e) {
+                allErrors.push(e);
+                results.sites = {
+                    successfullyPushed: 0,
+                    successfullyDeployed: 0,
+                    failedDeployments: [],
+                    errors: [e],
+                };
+            }
         }
-        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
-            let steps = Math.max(1, Math.ceil(attributeKeys.length / STEP_SIZE));
-            if (steps > 1 && iteration === 1) {
-                pollMaxDebounces *= steps;
-                log("Found a large number of attributes to be deleted. Increasing timeout to " +
-                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
-                    " minutes");
+        // Push tables
+        if ((shouldPushAll || options.tables) &&
+            config.tables &&
+            config.tables.length > 0) {
+            try {
+                this.log("Pushing tables ...");
+                const result = await this.pushTables(config.tables, {
+                    attempts: options.tableOptions?.attempts,
+                    skipConfirmation: options.skipConfirmation,
+                });
+                this.success(`Successfully pushed ${chalk.bold(result.successfullyPushed)} tables.`);
+                results.tables = result;
+                allErrors.push(...result.errors);
+            }
+            catch (e) {
+                allErrors.push(e);
+                results.tables = { successfullyPushed: 0, errors: [e] };
             }
         }
-        const { attributes } = await paginate(async (args) => {
-            const databasesService = await getDatabasesService();
-            return await databasesService.listAttributes(args.databaseId, args.collectionId, args.queries || []);
-        }, {
-            databaseId,
-            collectionId,
-        }, 100, "attributes");
-        const ready = attributeKeys.filter((attribute) => attributes.includes(attribute.key));
-        if (ready.length === 0) {
-            return true;
+        // Push collections (skipDeprecated only applies when pushing all, explicit collections option takes precedence)
+        if ((options.collections || (shouldPushAll && !skipDeprecated)) &&
+            config.collections &&
+            config.collections.length > 0) {
+            try {
+                this.log("Pushing collections ...");
+                // Add database names to collections
+                const collectionsWithDbNames = config.collections.map((collection) => {
+                    const database = config.databases?.find((db) => db.$id === collection.databaseId);
+                    return {
+                        ...collection,
+                        databaseName: database?.name ?? collection.databaseId,
+                    };
+                });
+                const result = await this.pushCollections(collectionsWithDbNames, {
+                    skipConfirmation: options.skipConfirmation,
+                });
+                this.success(`Successfully pushed ${chalk.bold(result.successfullyPushed)} collections.`);
+                results.collections = result;
+                allErrors.push(...result.errors);
+            }
+            catch (e) {
+                allErrors.push(e);
+                results.collections = { successfullyPushed: 0, errors: [e] };
+            }
         }
-        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;
+        return {
+            results,
+            errors: allErrors,
+        };
+    }
+    async pushSettings(config) {
+        const projectsService = await getProjectsService(this.consoleClient);
+        const projectId = config.projectId;
+        const projectName = config.projectName;
+        const settings = config.settings ?? {};
+        if (projectName) {
+            this.log("Applying project name ...");
+            await projectsService.update({
+                projectId: projectId,
+                name: projectName,
+            });
         }
-        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
-            let steps = Math.max(1, Math.ceil(attributeKeys.length / STEP_SIZE));
-            if (steps > 1 && iteration === 1) {
-                pollMaxDebounces *= steps;
-                log("Creating a large number of attributes, increasing timeout to " +
-                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
-                    " minutes");
+        if (settings.services) {
+            this.log("Applying service statuses ...");
+            for (let [service, status] of Object.entries(settings.services)) {
+                await projectsService.updateServiceStatus({
+                    projectId: projectId,
+                    service: service,
+                    status: status,
+                });
             }
         }
-        const { attributes } = await paginate(async (args) => {
-            const databasesService = await getDatabasesService();
-            return await databasesService.listAttributes(args.databaseId, args.collectionId, args.queries || []);
-        }, {
-            databaseId,
-            collectionId,
-        }, 100, "attributes");
-        const ready = attributes
-            .filter((attribute) => {
-            if (attributeKeys.includes(attribute.key)) {
-                if (["stuck", "failed"].includes(attribute.status)) {
-                    throw new Error(`Attribute '${attribute.key}' failed!`);
+        if (settings.auth) {
+            if (settings.auth.security) {
+                this.log("Applying auth security settings ...");
+                await projectsService.updateAuthDuration({
+                    projectId,
+                    duration: settings.auth.security.duration,
+                });
+                await projectsService.updateAuthLimit({
+                    projectId,
+                    limit: settings.auth.security.limit,
+                });
+                await projectsService.updateAuthSessionsLimit({
+                    projectId,
+                    limit: settings.auth.security.sessionsLimit,
+                });
+                await projectsService.updateAuthPasswordDictionary({
+                    projectId,
+                    enabled: settings.auth.security.passwordDictionary,
+                });
+                await projectsService.updateAuthPasswordHistory({
+                    projectId,
+                    limit: settings.auth.security.passwordHistory,
+                });
+                await projectsService.updatePersonalDataCheck({
+                    projectId,
+                    enabled: settings.auth.security.personalDataCheck,
+                });
+                await projectsService.updateSessionAlerts({
+                    projectId,
+                    alerts: settings.auth.security.sessionAlerts,
+                });
+                await projectsService.updateMockNumbers({
+                    projectId,
+                    numbers: settings.auth.security.mockNumbers,
+                });
+            }
+            if (settings.auth.methods) {
+                this.log("Applying auth methods statuses ...");
+                for (let [method, status] of Object.entries(settings.auth.methods)) {
+                    await projectsService.updateAuthStatus({
+                        projectId,
+                        method: method,
+                        status: status,
+                    });
                 }
-                return attribute.status === "available";
             }
-            return false;
-        })
-            .map((attribute) => attribute.key);
-        if (ready.length === attributeKeys.length) {
-            return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
-        return await awaitPools.expectAttributes(databaseId, collectionId, attributeKeys, iteration + 1);
-    },
-    deleteIndexes: async (databaseId, collectionId, indexesKeys, iteration = 1) => {
-        if (iteration > pollMaxDebounces) {
-            return false;
         }
-        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
-            let steps = Math.max(1, Math.ceil(indexesKeys.length / STEP_SIZE));
-            if (steps > 1 && iteration === 1) {
-                pollMaxDebounces *= steps;
-                log("Found a large number of indexes to be deleted. Increasing timeout to " +
-                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
-                    " minutes");
+    }
+    async pushBuckets(buckets) {
+        let successfullyPushed = 0;
+        const errors = [];
+        for (const bucket of buckets) {
+            try {
+                this.log(`Pushing bucket ${chalk.bold(bucket["name"])} ...`);
+                const storageService = await getStorageService(this.projectClient);
+                try {
+                    await storageService.getBucket(bucket["$id"]);
+                    await storageService.updateBucket({
+                        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,
+                    });
+                }
+                catch (e) {
+                    if (e instanceof AppwriteException && Number(e.code) === 404) {
+                        await storageService.createBucket({
+                            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,
+                        });
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+                successfullyPushed++;
             }
-        }
-        const { indexes } = await paginate(async (args) => {
-            const databasesService = await getDatabasesService();
-            return await databasesService.listIndexes(args.databaseId, args.collectionId, args.queries || []);
-        }, {
-            databaseId,
-            collectionId,
-        }, 100, "indexes");
-        const ready = indexesKeys.filter((index) => indexes.includes(index.key));
-        if (ready.length === 0) {
-            return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
-        return await awaitPools.expectIndexes(databaseId, collectionId, indexesKeys, iteration + 1);
-    },
-    expectIndexes: async (databaseId, collectionId, indexKeys, iteration = 1) => {
-        if (iteration > pollMaxDebounces) {
-            return false;
-        }
-        if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
-            let steps = Math.max(1, Math.ceil(indexKeys.length / STEP_SIZE));
-            if (steps > 1 && iteration === 1) {
-                pollMaxDebounces *= steps;
-                log("Creating a large number of indexes, increasing timeout to " +
-                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
-                    " minutes");
+            catch (e) {
+                errors.push(e);
+                this.error(`Failed to push bucket ${bucket["name"]}: ${e.message}`);
             }
         }
-        const { indexes } = await paginate(async (args) => {
-            const databasesService = await getDatabasesService();
-            return await databasesService.listIndexes(args.databaseId, args.collectionId, args.queries || []);
-        }, {
-            databaseId,
-            collectionId,
-        }, 100, "indexes");
-        const ready = indexes
-            .filter((index) => {
-            if (indexKeys.includes(index.key)) {
-                if (["stuck", "failed"].includes(index.status)) {
-                    throw new Error(`Index '${index.key}' failed!`);
+        return {
+            successfullyPushed,
+            errors,
+        };
+    }
+    async pushTeams(teams) {
+        let successfullyPushed = 0;
+        const errors = [];
+        for (const team of teams) {
+            try {
+                this.log(`Pushing team ${chalk.bold(team["name"])} ...`);
+                const teamsService = await getTeamsService(this.projectClient);
+                try {
+                    await teamsService.get(team["$id"]);
+                    await teamsService.updateName({
+                        teamId: team["$id"],
+                        name: team.name,
+                    });
+                }
+                catch (e) {
+                    if (e instanceof AppwriteException && Number(e.code) === 404) {
+                        await teamsService.create({
+                            teamId: team["$id"],
+                            name: team.name,
+                        });
+                    }
+                    else {
+                        throw e;
+                    }
                 }
-                return index.status === "available";
+                successfullyPushed++;
+            }
+            catch (e) {
+                errors.push(e);
+                this.error(`Failed to push team ${team["name"]}: ${e.message}`);
             }
-            return false;
-        })
-            .map((index) => index.key);
-        if (ready.length >= indexKeys.length) {
-            return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
-        return await awaitPools.expectIndexes(databaseId, collectionId, indexKeys, iteration + 1);
-    },
-};
-const getConfirmation = async () => {
-    if (cliConfig.force) {
-        return true;
-    }
-    async function fixConfirmation() {
-        const answers = await inquirer.prompt(questionPushChangesConfirmation);
-        if (answers.changes !== "YES" && answers.changes !== "NO") {
-            return await fixConfirmation();
         }
-        return answers.changes;
-    }
-    let answers = await inquirer.prompt(questionPushChanges);
-    if (answers.changes !== "YES" && answers.changes !== "NO") {
-        answers.changes = await fixConfirmation();
-    }
-    if (answers.changes === "YES") {
-        return true;
+        return {
+            successfullyPushed,
+            errors,
+        };
     }
-    warn("Skipping push action. Changes were not applied.");
-    return false;
-};
-const isEmpty = (value) => value === null ||
-    value === undefined ||
-    (typeof value === "string" && value.trim().length === 0) ||
-    (Array.isArray(value) && value.length === 0);
-const approveChanges = async (resource, resourceGetFunction, keys, resourceName, resourcePlural, skipKeys = [], secondId = "", secondResourceName = "") => {
-    log("Checking for changes ...");
-    const changes = [];
-    await Promise.all(resource.map(async (localResource) => {
-        try {
-            const options = {
-                [resourceName]: localResource["$id"],
-            };
-            if (secondId !== "" && secondResourceName !== "") {
-                options[secondResourceName] = localResource[secondId];
+    async pushMessagingTopics(topics) {
+        let successfullyPushed = 0;
+        const errors = [];
+        for (const topic of topics) {
+            try {
+                this.log(`Pushing topic ${chalk.bold(topic["name"])} ...`);
+                const messagingService = await getMessagingService(this.projectClient);
+                try {
+                    await messagingService.getTopic(topic["$id"]);
+                    await messagingService.updateTopic({
+                        topicId: topic["$id"],
+                        name: topic.name,
+                        subscribe: topic.subscribe,
+                    });
+                }
+                catch (e) {
+                    if (e instanceof AppwriteException && Number(e.code) === 404) {
+                        await messagingService.createTopic({
+                            topicId: topic["$id"],
+                            name: topic.name,
+                            subscribe: topic.subscribe,
+                        });
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+                this.success(`Pushed ${topic.name} ( ${topic["$id"]} )`);
+                successfullyPushed++;
             }
-            const remoteResource = await resourceGetFunction(options);
-            for (let [key, value] of Object.entries(whitelistKeys(remoteResource, keys))) {
-                if (skipKeys.includes(key)) {
-                    continue;
+            catch (e) {
+                errors.push(e);
+                this.error(`Failed to push topic ${topic["name"]}: ${e.message}`);
+            }
+        }
+        return {
+            successfullyPushed,
+            errors,
+        };
+    }
+    async pushFunctions(functions, options = {}) {
+        const { async: asyncDeploy, code, withVariables } = options;
+        Spinner.start(false);
+        let successfullyPushed = 0;
+        let successfullyDeployed = 0;
+        const failedDeployments = [];
+        const errors = [];
+        await Promise.all(functions.map(async (func) => {
+            let response = {};
+            const ignore = func.ignore ? "appwrite.config.json" : ".gitignore";
+            let functionExists = false;
+            let deploymentCreated = false;
+            const updaterRow = new Spinner({
+                status: "",
+                resource: func.name,
+                id: func["$id"],
+                end: `Ignoring using: ${ignore}`,
+            });
+            updaterRow.update({ status: "Getting" }).startSpinner(SPINNER_DOTS);
+            const functionsService = await getFunctionsService(this.projectClient);
+            try {
+                response = await functionsService.get({ functionId: func["$id"] });
+                functionExists = true;
+                if (response.runtime !== func.runtime) {
+                    updaterRow.fail({
+                        errorMessage: `Runtime mismatch! (local=${func.runtime},remote=${response.runtime}) Please delete remote function or update your appwrite.config.json`,
+                    });
+                    return;
                 }
-                if (isEmpty(value) && isEmpty(localResource[key])) {
-                    continue;
+                updaterRow
+                    .update({ status: "Updating" })
+                    .replaceSpinner(SPINNER_DOTS);
+                response = await functionsService.update({
+                    functionId: func["$id"],
+                    name: func.name,
+                    runtime: func.runtime,
+                    execute: func.execute,
+                    events: func.events,
+                    schedule: func.schedule,
+                    timeout: func.timeout,
+                    enabled: func.enabled,
+                    logging: func.logging,
+                    entrypoint: func.entrypoint,
+                    commands: func.commands,
+                    scopes: func.scopes,
+                    specification: func.specification,
+                });
+            }
+            catch (e) {
+                if (Number(e.code) === 404) {
+                    functionExists = false;
                 }
-                if (Array.isArray(value) && Array.isArray(localResource[key])) {
-                    if (JSON.stringify(value) !== JSON.stringify(localResource[key])) {
-                        changes.push({
-                            id: localResource["$id"],
-                            key,
-                            remote: chalk.red(value.join("\n")),
-                            local: chalk.green(localResource[key].join("\n")),
-                        });
+                else {
+                    errors.push(e);
+                    updaterRow.fail({
+                        errorMessage: e.message ?? "General error occurs please try again",
+                    });
+                    return;
+                }
+            }
+            if (!functionExists) {
+                updaterRow
+                    .update({ status: "Creating" })
+                    .replaceSpinner(SPINNER_DOTS);
+                try {
+                    response = await functionsService.create({
+                        functionId: func.$id,
+                        name: func.name,
+                        runtime: func.runtime,
+                        execute: func.execute,
+                        events: func.events,
+                        schedule: func.schedule,
+                        timeout: func.timeout,
+                        enabled: func.enabled,
+                        logging: func.logging,
+                        entrypoint: func.entrypoint,
+                        commands: func.commands,
+                        scopes: func.scopes,
+                        specification: func.specification,
+                    });
+                    let domain = "";
+                    try {
+                        const consoleService = await getConsoleService(this.consoleClient);
+                        const variables = await consoleService.variables();
+                        domain = ID.unique() + "." + variables["_APP_DOMAIN_FUNCTIONS"];
+                    }
+                    catch (err) {
+                        this.error("Error fetching console variables.");
+                        throw err;
+                    }
+                    try {
+                        const proxyService = await getProxyService(this.projectClient);
+                        await proxyService.createFunctionRule(domain, func.$id);
+                    }
+                    catch (err) {
+                        this.error("Error creating function rule.");
+                        throw err;
                     }
+                    updaterRow.update({ status: "Created" });
                 }
-                else if (value !== localResource[key]) {
-                    changes.push({
-                        id: localResource["$id"],
-                        key,
-                        remote: chalk.red(value),
-                        local: chalk.green(localResource[key]),
+                catch (e) {
+                    errors.push(e);
+                    updaterRow.fail({
+                        errorMessage: e.message ?? "General error occurs please try again",
                     });
+                    return;
                 }
             }
-        }
-        catch (e) {
-            if (Number(e.code) !== 404) {
-                throw e;
+            if (withVariables) {
+                updaterRow
+                    .update({ status: "Updating variables" })
+                    .replaceSpinner(SPINNER_DOTS);
+                const functionsServiceForVars = await getFunctionsService(this.projectClient);
+                const { variables } = await paginate(async (args) => {
+                    return await functionsServiceForVars.listVariables({
+                        functionId: args.functionId,
+                    });
+                }, {
+                    functionId: func["$id"],
+                }, 100, "variables");
+                await Promise.all(variables.map(async (variable) => {
+                    const functionsServiceDel = await getFunctionsService(this.projectClient);
+                    await functionsServiceDel.deleteVariable({
+                        functionId: func["$id"],
+                        variableId: variable["$id"],
+                    });
+                }));
+                const envFileLocation = `${func["path"]}/.env`;
+                let envVariables = [];
+                try {
+                    if (fs.existsSync(envFileLocation)) {
+                        const envObject = parseDotenv(fs.readFileSync(envFileLocation, "utf8"));
+                        envVariables = Object.entries(envObject || {}).map(([key, value]) => ({ key, value }));
+                    }
+                }
+                catch (error) {
+                    envVariables = [];
+                }
+                await Promise.all(envVariables.map(async (variable) => {
+                    const functionsServiceCreate = await getFunctionsService(this.projectClient);
+                    await functionsServiceCreate.createVariable({
+                        functionId: func["$id"],
+                        key: variable.key,
+                        value: variable.value,
+                        secret: false,
+                    });
+                }));
             }
-        }
-    }));
-    if (changes.length === 0) {
-        return true;
-    }
-    drawTable(changes);
-    if ((await getConfirmation()) === true) {
-        return true;
-    }
-    success(`Successfully pushed 0 ${resourcePlural}.`);
-    return false;
-};
-const getObjectChanges = (remote, local, index, what) => {
-    const changes = [];
-    const remoteNested = remote[index];
-    const localNested = local[index];
-    if (remoteNested &&
-        localNested &&
-        typeof remoteNested === "object" &&
-        !Array.isArray(remoteNested) &&
-        typeof localNested === "object" &&
-        !Array.isArray(localNested)) {
-        const remoteObj = remoteNested;
-        const localObj = localNested;
-        for (const [service, status] of Object.entries(remoteObj)) {
-            const localValue = localObj[service];
-            let valuesEqual = false;
-            if (Array.isArray(status) && Array.isArray(localValue)) {
-                valuesEqual = JSON.stringify(status) === JSON.stringify(localValue);
+            if (code === false) {
+                successfullyPushed++;
+                successfullyDeployed++;
+                updaterRow.update({ status: "Pushed" });
+                updaterRow.stopSpinner();
+                return;
             }
-            else {
-                valuesEqual = status === localValue;
+            try {
+                updaterRow.update({ status: "Pushing" }).replaceSpinner(SPINNER_DOTS);
+                const functionsServiceDeploy = await getFunctionsService(this.projectClient);
+                const result = await pushDeployment({
+                    resourcePath: func.path,
+                    createDeployment: async (codeFile) => {
+                        return await functionsServiceDeploy.createDeployment({
+                            functionId: func["$id"],
+                            entrypoint: func.entrypoint,
+                            commands: func.commands,
+                            code: codeFile,
+                            activate: true,
+                        });
+                    },
+                    pollForStatus: false,
+                });
+                response = result.deployment;
+                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 (!valuesEqual) {
-                changes.push({
-                    group: what,
-                    setting: service,
-                    remote: chalk.red(String(status ?? "")),
-                    local: chalk.green(String(localValue ?? "")),
+            if (deploymentCreated && !asyncDeploy) {
+                try {
+                    const deploymentId = response["$id"];
+                    updaterRow.update({
+                        status: "Deploying",
+                        end: "Checking deployment status...",
+                    });
+                    const timeoutDeadline = Date.now() + DEPLOYMENT_TIMEOUT_MS;
+                    while (true) {
+                        if (Date.now() > timeoutDeadline) {
+                            failedDeployments.push({
+                                name: func["name"],
+                                $id: func["$id"],
+                                deployment: deploymentId,
+                            });
+                            updaterRow.fail({
+                                errorMessage: "Deployment timed out after 10 minutes",
+                            });
+                            break;
+                        }
+                        const functionsServicePoll = await getFunctionsService(this.projectClient);
+                        response = await functionsServicePoll.getDeployment({
+                            functionId: func["$id"],
+                            deploymentId: deploymentId,
+                        });
+                        const status = response["status"];
+                        if (status === "ready") {
+                            successfullyDeployed++;
+                            let url = "";
+                            const proxyServiceUrl = await getProxyService(this.projectClient);
+                            const res = await proxyServiceUrl.listRules({
+                                queries: [
+                                    Query.limit(1),
+                                    Query.equal("deploymentResourceType", "function"),
+                                    Query.equal("deploymentResourceId", func["$id"]),
+                                    Query.equal("trigger", "manual"),
+                                ],
+                            });
+                            if (Number(res.total) === 1) {
+                                url = `https://${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}`,
+                            });
+                        }
+                        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
+                    }
+                }
+                catch (e) {
+                    errors.push(e);
+                    updaterRow.fail({
+                        errorMessage: e.message ?? "Unknown error occurred. Please try again",
+                    });
+                }
+            }
+            updaterRow.stopSpinner();
+        }));
+        Spinner.stop();
+        return {
+            successfullyPushed,
+            successfullyDeployed,
+            failedDeployments,
+            errors,
+        };
+    }
+    async pushSites(sites, options = {}) {
+        const { async: asyncDeploy, code, withVariables } = options;
+        Spinner.start(false);
+        let successfullyPushed = 0;
+        let successfullyDeployed = 0;
+        const failedDeployments = [];
+        const errors = [];
+        await Promise.all(sites.map(async (site) => {
+            let response = {};
+            const ignore = site.ignore ? "appwrite.config.json" : ".gitignore";
+            let siteExists = false;
+            let deploymentCreated = false;
+            const updaterRow = new Spinner({
+                status: "",
+                resource: site.name,
+                id: site["$id"],
+                end: `Ignoring using: ${ignore}`,
+            });
+            updaterRow.update({ status: "Getting" }).startSpinner(SPINNER_DOTS);
+            const sitesService = await getSitesService(this.projectClient);
+            try {
+                response = await sitesService.get({ siteId: site["$id"] });
+                siteExists = true;
+                if (response.framework !== site.framework) {
+                    updaterRow.fail({
+                        errorMessage: `Framework mismatch! (local=${site.framework},remote=${response.framework}) Please delete remote site or update your appwrite.config.json`,
+                    });
+                    return;
+                }
+                updaterRow
+                    .update({ status: "Updating" })
+                    .replaceSpinner(SPINNER_DOTS);
+                response = await sitesService.update({
+                    siteId: site["$id"],
+                    name: site.name,
+                    framework: site.framework,
+                    enabled: site.enabled,
+                    logging: site.logging,
+                    timeout: site.timeout,
+                    installCommand: site.installCommand,
+                    buildCommand: site.buildCommand,
+                    outputDirectory: site.outputDirectory,
+                    buildRuntime: site.buildRuntime,
+                    adapter: site.adapter,
+                    specification: site.specification,
                 });
             }
-        }
-    }
-    return changes;
-};
-const createAttribute = async (databaseId, collectionId, attribute) => {
-    const databasesService = await getDatabasesService();
-    switch (attribute.type) {
-        case "string":
-            switch (attribute.format) {
-                case "email":
-                    return databasesService.createEmailAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        required: attribute.required,
-                        xdefault: attribute.default,
-                        array: attribute.array,
+            catch (e) {
+                if (Number(e.code) === 404) {
+                    siteExists = false;
+                }
+                else {
+                    errors.push(e);
+                    updaterRow.fail({
+                        errorMessage: e.message ?? "General error occurs please try again",
                     });
-                case "url":
-                    return databasesService.createUrlAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        required: attribute.required,
-                        xdefault: attribute.default,
-                        array: attribute.array,
+                    return;
+                }
+            }
+            if (!siteExists) {
+                updaterRow
+                    .update({ status: "Creating" })
+                    .replaceSpinner(SPINNER_DOTS);
+                try {
+                    response = await sitesService.create({
+                        siteId: site.$id,
+                        name: site.name,
+                        framework: site.framework,
+                        enabled: site.enabled,
+                        logging: site.logging,
+                        timeout: site.timeout,
+                        installCommand: site.installCommand,
+                        buildCommand: site.buildCommand,
+                        outputDirectory: site.outputDirectory,
+                        buildRuntime: site.buildRuntime,
+                        adapter: site.adapter,
+                        specification: site.specification,
                     });
-                case "ip":
-                    return databasesService.createIpAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        required: attribute.required,
-                        xdefault: attribute.default,
-                        array: attribute.array,
+                    let domain = "";
+                    try {
+                        const consoleService = await getConsoleService(this.consoleClient);
+                        const variables = await consoleService.variables();
+                        domain = ID.unique() + "." + variables["_APP_DOMAIN_SITES"];
+                    }
+                    catch (err) {
+                        this.error("Error fetching console variables.");
+                        throw err;
+                    }
+                    try {
+                        const proxyService = await getProxyService(this.projectClient);
+                        await proxyService.createSiteRule(domain, site.$id);
+                    }
+                    catch (err) {
+                        this.error("Error creating site rule.");
+                        throw err;
+                    }
+                    updaterRow.update({ status: "Created" });
+                }
+                catch (e) {
+                    errors.push(e);
+                    updaterRow.fail({
+                        errorMessage: e.message ?? "General error occurs please try again",
                     });
-                case "enum":
-                    return databasesService.createEnumAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        elements: attribute.elements,
-                        required: attribute.required,
-                        xdefault: attribute.default,
-                        array: attribute.array,
+                    return;
+                }
+            }
+            if (withVariables) {
+                updaterRow
+                    .update({ status: "Creating variables" })
+                    .replaceSpinner(SPINNER_DOTS);
+                const sitesServiceForVars = await getSitesService(this.projectClient);
+                const { variables } = await paginate(async (args) => {
+                    return await sitesServiceForVars.listVariables({
+                        siteId: args.siteId,
                     });
-                default:
-                    return databasesService.createStringAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        size: attribute.size,
-                        required: attribute.required,
-                        xdefault: attribute.default,
-                        array: attribute.array,
-                        encrypt: attribute.encrypt,
+                }, {
+                    siteId: site["$id"],
+                }, 100, "variables");
+                await Promise.all(variables.map(async (variable) => {
+                    const sitesServiceDel = await getSitesService(this.projectClient);
+                    await sitesServiceDel.deleteVariable({
+                        siteId: site["$id"],
+                        variableId: variable["$id"],
                     });
+                }));
+                const envFileLocation = `${site["path"]}/.env`;
+                let envVariables = [];
+                try {
+                    if (fs.existsSync(envFileLocation)) {
+                        const envObject = parseDotenv(fs.readFileSync(envFileLocation, "utf8"));
+                        envVariables = Object.entries(envObject || {}).map(([key, value]) => ({ key, value }));
+                    }
+                }
+                catch (error) {
+                    envVariables = [];
+                }
+                await Promise.all(envVariables.map(async (variable) => {
+                    const sitesServiceCreate = await getSitesService(this.projectClient);
+                    await sitesServiceCreate.createVariable({
+                        siteId: site["$id"],
+                        key: variable.key,
+                        value: variable.value,
+                        secret: false,
+                    });
+                }));
             }
-        case "integer":
-            return databasesService.createIntegerAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                min: attribute.min,
-                max: attribute.max,
-                xdefault: attribute.default,
-                array: attribute.array,
-            });
-        case "double":
-            return databasesService.createFloatAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                min: attribute.min,
-                max: attribute.max,
-                xdefault: attribute.default,
-                array: attribute.array,
-            });
-        case "boolean":
-            return databasesService.createBooleanAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-                array: attribute.array,
-            });
-        case "datetime":
-            return databasesService.createDatetimeAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-                array: attribute.array,
-            });
-        case "relationship":
-            return databasesService.createRelationshipAttribute({
-                databaseId,
-                collectionId,
-                relatedCollectionId: attribute.relatedTable ?? attribute.relatedCollection,
-                type: attribute.relationType,
-                twoWay: attribute.twoWay,
-                key: attribute.key,
-                twoWayKey: attribute.twoWayKey,
-                onDelete: attribute.onDelete,
-            });
-        case "point":
-            return databasesService.createPointAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-            });
-        case "linestring":
-            return databasesService.createLineAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-            });
-        case "polygon":
-            return databasesService.createPolygonAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-            });
-        default:
-            throw new Error(`Unsupported attribute type: ${attribute.type}`);
-    }
-};
-const updateAttribute = async (databaseId, collectionId, attribute) => {
-    const databasesService = await getDatabasesService();
-    switch (attribute.type) {
-        case "string":
-            switch (attribute.format) {
-                case "email":
-                    return databasesService.updateEmailAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        required: attribute.required,
-                        xdefault: attribute.default,
+            if (code === false) {
+                successfullyPushed++;
+                successfullyDeployed++;
+                updaterRow.update({ status: "Pushed" });
+                updaterRow.stopSpinner();
+                return;
+            }
+            try {
+                updaterRow.update({ status: "Pushing" }).replaceSpinner(SPINNER_DOTS);
+                const sitesServiceDeploy = await getSitesService(this.projectClient);
+                const result = await pushDeployment({
+                    resourcePath: site.path,
+                    createDeployment: async (codeFile) => {
+                        return await sitesServiceDeploy.createDeployment({
+                            siteId: site["$id"],
+                            installCommand: site.installCommand,
+                            buildCommand: site.buildCommand,
+                            outputDirectory: site.outputDirectory,
+                            code: codeFile,
+                            activate: true,
+                        });
+                    },
+                    pollForStatus: false,
+                });
+                response = result.deployment;
+                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...",
                     });
-                case "url":
-                    return databasesService.updateUrlAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        required: attribute.required,
-                        xdefault: attribute.default,
+                    const timeoutDeadline = Date.now() + DEPLOYMENT_TIMEOUT_MS;
+                    while (true) {
+                        if (Date.now() > timeoutDeadline) {
+                            failedDeployments.push({
+                                name: site["name"],
+                                $id: site["$id"],
+                                deployment: deploymentId,
+                            });
+                            updaterRow.fail({
+                                errorMessage: "Deployment timed out after 10 minutes",
+                            });
+                            break;
+                        }
+                        const sitesServicePoll = await getSitesService(this.projectClient);
+                        response = await sitesServicePoll.getDeployment({
+                            siteId: site["$id"],
+                            deploymentId: deploymentId,
+                        });
+                        const status = response["status"];
+                        if (status === "ready") {
+                            successfullyDeployed++;
+                            let url = "";
+                            const proxyServiceUrl = await getProxyService(this.projectClient);
+                            const res = await proxyServiceUrl.listRules({
+                                queries: [
+                                    Query.limit(1),
+                                    Query.equal("deploymentResourceType", "site"),
+                                    Query.equal("deploymentResourceId", site["$id"]),
+                                    Query.equal("trigger", "manual"),
+                                ],
+                            });
+                            if (Number(res.total) === 1) {
+                                url = `https://${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}`,
+                            });
+                        }
+                        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
+                    }
+                }
+                catch (e) {
+                    errors.push(e);
+                    updaterRow.fail({
+                        errorMessage: e.message ?? "Unknown error occurred. Please try again",
                     });
-                case "ip":
-                    return databasesService.updateIpAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        required: attribute.required,
-                        xdefault: attribute.default,
+                }
+            }
+            updaterRow.stopSpinner();
+        }));
+        Spinner.stop();
+        return {
+            successfullyPushed,
+            successfullyDeployed,
+            failedDeployments,
+            errors,
+        };
+    }
+    async pushTables(tables, options = {}) {
+        const { attempts, skipConfirmation = false } = options;
+        const pollMaxDebounces = attempts ?? POLL_DEFAULT_VALUE;
+        const pools = new Pools(pollMaxDebounces);
+        const attributes = new Attributes(pools, skipConfirmation);
+        let tablesChanged = new Set();
+        const errors = [];
+        // Parallel tables actions
+        await Promise.all(tables.map(async (table) => {
+            try {
+                const tablesService = await getTablesDBService(this.projectClient);
+                const remoteTable = await tablesService.getTable({
+                    databaseId: table["databaseId"],
+                    tableId: table["$id"],
+                });
+                const changes = [];
+                if (remoteTable.name !== table.name)
+                    changes.push("name");
+                if (remoteTable.rowSecurity !== table.rowSecurity)
+                    changes.push("rowSecurity");
+                if (remoteTable.enabled !== table.enabled)
+                    changes.push("enabled");
+                if (JSON.stringify(remoteTable["$permissions"]) !==
+                    JSON.stringify(table["$permissions"]))
+                    changes.push("permissions");
+                if (changes.length > 0) {
+                    await tablesService.updateTable({
+                        databaseId: table["databaseId"],
+                        tableId: table["$id"],
+                        name: table.name,
+                        rowSecurity: table.rowSecurity,
+                        permissions: table["$permissions"],
                     });
-                case "enum":
-                    return databasesService.updateEnumAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        elements: attribute.elements,
-                        required: attribute.required,
-                        xdefault: attribute.default,
+                    this.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) {
+                    this.log(`Table ${table.name} does not exist in the project. Creating ... `);
+                    const tablesService = await getTablesDBService(this.projectClient);
+                    await tablesService.createTable({
+                        databaseId: table["databaseId"],
+                        tableId: table["$id"],
+                        name: table.name,
+                        rowSecurity: table.rowSecurity,
+                        permissions: table["$permissions"]
+                            ? [...table["$permissions"]]
+                            : undefined,
                     });
-                default:
-                    return databasesService.updateStringAttribute({
-                        databaseId,
-                        collectionId,
-                        key: attribute.key,
-                        required: attribute.required,
-                        xdefault: attribute.default,
+                    this.success(`Created ${table.name} ( ${table["$id"]} )`);
+                    tablesChanged.add(table["$id"]);
+                }
+                else {
+                    errors.push(e);
+                    throw e;
+                }
+            }
+        }));
+        // Serialize attribute actions
+        for (let table of tables) {
+            let columns = table.columns;
+            let indexes = table.indexes;
+            if (table.isExisted) {
+                columns = await attributes.attributesToCreate(table.remoteVersion.columns, table.columns, table);
+                indexes = await attributes.attributesToCreate(table.remoteVersion.indexes, table.indexes, table, true);
+                if (Array.isArray(columns) &&
+                    columns.length <= 0 &&
+                    Array.isArray(indexes) &&
+                    indexes.length <= 0) {
+                    continue;
+                }
+            }
+            this.log(`Pushing table ${table.name} ( ${table["databaseId"]} - ${table["$id"]} ) attributes`);
+            try {
+                await attributes.createColumns(columns, table);
+            }
+            catch (e) {
+                errors.push(e);
+                throw e;
+            }
+            try {
+                await attributes.createIndexes(indexes, table);
+            }
+            catch (e) {
+                errors.push(e);
+                throw e;
+            }
+            tablesChanged.add(table["$id"]);
+            this.success(`Successfully pushed ${table.name} ( ${table["$id"]} )`);
+        }
+        return {
+            successfullyPushed: tablesChanged.size,
+            errors,
+        };
+    }
+    async pushCollections(collections, options = {}) {
+        const { skipConfirmation = false } = options;
+        const pools = new Pools(POLL_DEFAULT_VALUE);
+        const attributes = new Attributes(pools, skipConfirmation);
+        const errors = [];
+        const databases = Array.from(new Set(collections.map((collection) => collection["databaseId"])));
+        // Parallel db actions
+        await Promise.all(databases.map(async (databaseId) => {
+            const databasesService = await getDatabasesService(this.projectClient);
+            try {
+                const database = await databasesService.get(databaseId);
+                // Note: We can't get the local database name here since we don't have access to localConfig
+                // This will need to be handled by the caller if needed
+                const localDatabaseName = collections.find((c) => c.databaseId === databaseId)
+                    ?.databaseName ?? databaseId;
+                if (database.name !== localDatabaseName) {
+                    await databasesService.update(databaseId, localDatabaseName);
+                    this.success(`Updated ${localDatabaseName} ( ${databaseId} ) name`);
+                }
+            }
+            catch (err) {
+                if (Number(err.code) === 404) {
+                    this.log(`Database ${databaseId} not found. Creating it now ...`);
+                    const localDatabaseName = collections.find((c) => c.databaseId === databaseId)
+                        ?.databaseName ?? databaseId;
+                    await databasesService.create(databaseId, localDatabaseName);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }));
+        // Parallel collection actions
+        await Promise.all(collections.map(async (collection) => {
+            try {
+                const databasesService = await getDatabasesService(this.projectClient);
+                const remoteCollection = await databasesService.getCollection(collection["databaseId"], collection["$id"]);
+                if (remoteCollection.name !== collection.name) {
+                    await databasesService.updateCollection(collection["databaseId"], collection["$id"], collection.name);
+                    this.success(`Updated ${collection.name} ( ${collection["$id"]} ) name`);
+                }
+                collection.remoteVersion = remoteCollection;
+                collection.isExisted = true;
+            }
+            catch (e) {
+                if (Number(e.code) === 404) {
+                    this.log(`Collection ${collection.name} does not exist in the project. Creating ... `);
+                    const databasesService = await getDatabasesService(this.projectClient);
+                    await databasesService.createCollection({
+                        databaseId: collection["databaseId"],
+                        collectionId: collection["$id"],
+                        name: collection.name,
+                        documentSecurity: collection.documentSecurity,
+                        permissions: collection["$permissions"],
                     });
+                }
+                else {
+                    errors.push(e);
+                    throw e;
+                }
             }
-        case "integer":
-            return databasesService.updateIntegerAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                min: attribute.min,
-                max: attribute.max,
-                xdefault: attribute.default,
-            });
-        case "double":
-            return databasesService.updateFloatAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                min: attribute.min,
-                max: attribute.max,
-                xdefault: attribute.default,
-            });
-        case "boolean":
-            return databasesService.updateBooleanAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-            });
-        case "datetime":
-            return databasesService.updateDatetimeAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-            });
-        case "relationship":
-            return databasesService.updateRelationshipAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                onDelete: attribute.onDelete,
-            });
-        case "point":
-            return databasesService.updatePointAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-            });
-        case "linestring":
-            return databasesService.updateLineAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-            });
-        case "polygon":
-            return databasesService.updatePolygonAttribute({
-                databaseId,
-                collectionId,
-                key: attribute.key,
-                required: attribute.required,
-                xdefault: attribute.default,
-            });
-        default:
-            throw new Error(`Unsupported attribute type: ${attribute.type}`);
-    }
-};
-const deleteAttribute = async (collection, attribute, isIndex = false) => {
-    log(`Deleting ${isIndex ? "index" : "attribute"} ${attribute.key} of ${collection.name} ( ${collection["$id"]} )`);
-    const databasesService = await getDatabasesService();
-    if (isIndex) {
-        await databasesService.deleteIndex(collection["databaseId"], collection["$id"], attribute.key);
-        return;
-    }
-    await databasesService.deleteAttribute(collection["databaseId"], collection["$id"], attribute.key);
-};
-const isEqual = (a, b) => {
-    if (a === b)
-        return true;
-    if (a && b && typeof a === "object" && typeof b === "object") {
-        if (a.constructor &&
-            a.constructor.name === "BigNumber" &&
-            b.constructor &&
-            b.constructor.name === "BigNumber") {
-            return a.eq(b);
-        }
-        if (typeof a.equals === "function") {
-            return a.equals(b);
-        }
-        if (typeof a.eq === "function") {
-            return a.eq(b);
-        }
-    }
-    if (typeof a === "number" && typeof b === "number") {
-        if (isNaN(a) && isNaN(b))
-            return true;
-        if (!isFinite(a) && !isFinite(b))
-            return a === b;
-        return Math.abs(a - b) < Number.EPSILON;
-    }
-    return false;
-};
-const compareAttribute = (remote, local, reason, key) => {
-    if (isEmpty(remote) && isEmpty(local)) {
-        return reason;
-    }
-    if (Array.isArray(remote) && Array.isArray(local)) {
-        if (JSON.stringify(remote) !== JSON.stringify(local)) {
-            const bol = reason === "" ? "" : "\n";
-            reason += `${bol}${key} changed from ${chalk.red(remote)} to ${chalk.green(local)}`;
-        }
-    }
-    else if (!isEqual(remote, local)) {
-        const bol = reason === "" ? "" : "\n";
-        reason += `${bol}${key} changed from ${chalk.red(remote)} to ${chalk.green(local)}`;
-    }
-    return reason;
-};
-/**
- * Check if attribute non-changeable fields has been changed
- * If so return the differences as an object.
- */
-const checkAttributeChanges = (remote, local, collection, recreating = true) => {
-    if (local === undefined) {
-        return undefined;
-    }
-    const keyName = `${chalk.yellow(local.key)} in ${collection.name} (${collection["$id"]})`;
-    const action = chalk.cyan(recreating ? "recreating" : "changing");
-    let reason = "";
-    let attribute = recreating ? remote : local;
-    for (let key of Object.keys(remote)) {
-        if (!KeysAttributes.has(key)) {
-            continue;
-        }
-        if (changeableKeys.includes(key)) {
-            if (!recreating) {
-                reason = compareAttribute(remote[key], local[key], reason, key);
+        }));
+        let numberOfCollections = 0;
+        // Serialize attribute actions
+        for (let collection of collections) {
+            let collectionAttributes = collection.attributes;
+            let indexes = collection.indexes;
+            if (collection.isExisted) {
+                collectionAttributes = await attributes.attributesToCreate(collection.remoteVersion.attributes, collection.attributes, collection);
+                indexes = await attributes.attributesToCreate(collection.remoteVersion.indexes, collection.indexes, collection, true);
+                if (Array.isArray(collectionAttributes) &&
+                    collectionAttributes.length <= 0 &&
+                    Array.isArray(indexes) &&
+                    indexes.length <= 0) {
+                    continue;
+                }
             }
-            continue;
-        }
-        if (!recreating) {
-            continue;
-        }
-        reason = compareAttribute(remote[key], local[key], reason, key);
-    }
-    return reason === ""
-        ? undefined
-        : { key: keyName, attribute, reason, action };
-};
-/**
- * Check if attributes contain the given attribute
- */
-const attributesContains = (attribute, attributes) => attributes.find((attr) => attr.key === attribute.key);
-const generateChangesObject = (attribute, collection, isAdding) => {
-    return {
-        key: `${chalk.yellow(attribute.key)} in ${collection.name} (${collection["$id"]})`,
-        attribute: attribute,
-        reason: isAdding
-            ? "Field isn't present on the remote server"
-            : "Field isn't present on the appwrite.config.json file",
-        action: isAdding ? chalk.green("adding") : chalk.red("deleting"),
-    };
-};
-/**
- * Filter deleted and recreated attributes,
- * return list of attributes to create
- */
-const attributesToCreate = async (remoteAttributes, localAttributes, collection, isIndex = false) => {
-    const deleting = remoteAttributes
-        .filter((attribute) => !attributesContains(attribute, localAttributes))
-        .map((attr) => generateChangesObject(attr, collection, false));
-    const adding = localAttributes
-        .filter((attribute) => !attributesContains(attribute, remoteAttributes))
-        .map((attr) => generateChangesObject(attr, collection, true));
-    const conflicts = remoteAttributes
-        .map((attribute) => checkAttributeChanges(attribute, attributesContains(attribute, localAttributes), collection))
-        .filter((attribute) => attribute !== undefined);
-    const changes = remoteAttributes
-        .map((attribute) => checkAttributeChanges(attribute, attributesContains(attribute, localAttributes), collection, false))
-        .filter((attribute) => attribute !== undefined)
-        .filter((attribute) => conflicts.filter((attr) => attribute.key === attr.key).length !== 1);
-    let changedAttributes = [];
-    const changing = [...deleting, ...adding, ...conflicts, ...changes];
-    if (changing.length === 0) {
-        return changedAttributes;
-    }
-    log(!cliConfig.force
-        ? "There are pending changes in your collection deployment"
-        : "List of applied changes");
-    drawTable(changing.map((change) => {
-        return { Key: change.key, Action: change.action, Reason: change.reason };
-    }));
-    if (!cliConfig.force) {
-        if (deleting.length > 0 && !isIndex) {
-            console.log(`${chalk.red("------------------------------------------------------")}`);
-            console.log(`${chalk.red("| WARNING: Attribute deletion may cause loss of data |")}`);
-            console.log(`${chalk.red("------------------------------------------------------")}`);
-            console.log();
-        }
-        if (conflicts.length > 0 && !isIndex) {
-            console.log(`${chalk.red("--------------------------------------------------------")}`);
-            console.log(`${chalk.red("| WARNING: Attribute recreation may cause loss of data |")}`);
-            console.log(`${chalk.red("--------------------------------------------------------")}`);
-            console.log();
-        }
-        if ((await getConfirmation()) !== true) {
-            return changedAttributes;
-        }
-    }
-    if (conflicts.length > 0) {
-        changedAttributes = conflicts.map((change) => change.attribute);
-        await Promise.all(changedAttributes.map((changed) => deleteAttribute(collection, changed, isIndex)));
-        remoteAttributes = remoteAttributes.filter((attribute) => !attributesContains(attribute, changedAttributes));
-    }
-    if (changes.length > 0) {
-        changedAttributes = changes.map((change) => change.attribute);
-        await Promise.all(changedAttributes.map((changed) => updateAttribute(collection["databaseId"], collection["$id"], changed)));
-    }
-    const deletingAttributes = deleting.map((change) => change.attribute);
-    await Promise.all(deletingAttributes.map((attribute) => deleteAttribute(collection, attribute, isIndex)));
-    const attributeKeys = [
-        ...remoteAttributes.map((attribute) => attribute.key),
-        ...deletingAttributes.map((attribute) => attribute.key),
-    ];
-    if (attributeKeys.length) {
-        const deleteAttributesPoolStatus = await awaitPools.deleteAttributes(collection["databaseId"], collection["$id"], attributeKeys);
-        if (!deleteAttributesPoolStatus) {
-            throw new Error("Attribute deletion timed out.");
-        }
-    }
-    return localAttributes.filter((attribute) => !attributesContains(attribute, remoteAttributes));
-};
-const createIndexes = async (indexes, collection) => {
-    log(`Creating indexes ...`);
-    const databasesService = await getDatabasesService();
-    for (let index of indexes) {
-        await databasesService.createIndex(collection["databaseId"], collection["$id"], index.key, index.type, index.columns ?? index.attributes, index.orders);
-    }
-    const result = await awaitPools.expectIndexes(collection["databaseId"], collection["$id"], indexes.map((index) => index.key));
-    if (!result) {
-        throw new Error("Index creation timed out.");
-    }
-    success(`Created ${indexes.length} indexes`);
-};
-const createAttributes = async (attributes, collection) => {
-    for (let attribute of attributes) {
-        if (attribute.side !== "child") {
-            await createAttribute(collection["databaseId"], collection["$id"], attribute);
-        }
-    }
-    const result = await awaitPools.expectAttributes(collection["databaseId"], collection["$id"], collection.attributes
-        .filter((attribute) => attribute.side !== "child")
-        .map((attribute) => attribute.key));
-    if (!result) {
-        throw new Error(`Attribute creation timed out.`);
-    }
-    success(`Created ${attributes.length} attributes`);
-};
-const createColumns = async (columns, table) => {
-    for (let column of columns) {
-        if (column.side !== "child") {
-            await createAttribute(table["databaseId"], table["$id"], column);
-        }
-    }
-    const result = await awaitPools.expectAttributes(table["databaseId"], table["$id"], table.columns
-        .filter((column) => column.side !== "child")
-        .map((column) => column.key));
-    if (!result) {
-        throw new Error(`Column creation timed out.`);
-    }
-    success(`Created ${columns.length} columns`);
-};
+            this.log(`Pushing collection ${collection.name} ( ${collection["databaseId"]} - ${collection["$id"]} ) attributes`);
+            try {
+                await attributes.createAttributes(collectionAttributes, collection);
+            }
+            catch (e) {
+                errors.push(e);
+                throw e;
+            }
+            try {
+                await attributes.createIndexes(indexes, collection);
+            }
+            catch (e) {
+                errors.push(e);
+                throw e;
+            }
+            numberOfCollections++;
+            this.success(`Successfully pushed ${collection.name} ( ${collection["$id"]} )`);
+        }
+        return {
+            successfullyPushed: numberOfCollections,
+            errors,
+        };
+    }
+}
+async function createPushInstance(silent = false) {
+    const projectClient = await sdkForProject();
+    const consoleClient = await sdkForConsole();
+    return new Push(projectClient, consoleClient, silent);
+}
 const pushResources = async ({ skipDeprecated = false, } = {}) => {
-    const actions = {
-        settings: pushSettings,
-        functions: pushFunction,
-        sites: pushSite,
-        collections: pushCollection,
-        tables: pushTable,
-        buckets: pushBucket,
-        teams: pushTeam,
-        messages: pushMessagingTopic,
-    };
-    if (skipDeprecated) {
-        delete actions.collections;
-    }
     if (cliConfig.all) {
-        for (let action of Object.values(actions)) {
-            await action();
-        }
+        checkDeployConditions(localConfig);
+        const pushInstance = await createPushInstance();
+        const config = localConfig.getProject();
+        await pushInstance.pushResources(config, {
+            skipDeprecated,
+            functionOptions: { code: true, withVariables: false },
+            siteOptions: { code: true, withVariables: false },
+        });
     }
     else {
+        const actions = {
+            settings: pushSettings,
+            functions: pushFunction,
+            sites: pushSite,
+            collections: pushCollection,
+            tables: pushTable,
+            buckets: pushBucket,
+            teams: pushTeam,
+            messages: pushMessagingTopic,
+        };
+        if (skipDeprecated) {
+            delete actions.collections;
+        }
         const answers = await inquirer.prompt(questionsPushResources);
         const action = actions[answers.resource];
         if (action !== undefined) {
@@ -800,7 +1205,7 @@ const pushSettings = async () => {
     try {
         const projectsService = await getProjectsService();
         let response = await projectsService.get(localConfig.getProject().projectId);
-        const remoteSettings = localConfig.createSettingsObject(response ?? {});
+        const remoteSettings = createSettingsObject(response);
         const localSettings = localConfig.getProject().projectSettings ?? {};
         log("Checking for changes ...");
         const changes = [];
@@ -818,39 +1223,13 @@ const pushSettings = async () => {
     catch (e) { }
     try {
         log("Pushing project settings ...");
-        const projectsService = await getProjectsService();
-        const projectId = localConfig.getProject().projectId;
-        const projectName = localConfig.getProject().projectName;
-        const settings = localConfig.getProject().projectSettings ?? {};
-        if (projectName) {
-            log("Applying project name ...");
-            await projectsService.update(projectId, projectName);
-        }
-        if (settings.services) {
-            log("Applying service statuses ...");
-            for (let [service, status] of Object.entries(settings.services)) {
-                await projectsService.updateServiceStatus(projectId, service, status);
-            }
-        }
-        if (settings.auth) {
-            if (settings.auth.security) {
-                log("Applying auth security settings ...");
-                await projectsService.updateAuthDuration(projectId, settings.auth.security.duration);
-                await projectsService.updateAuthLimit(projectId, settings.auth.security.limit);
-                await projectsService.updateAuthSessionsLimit(projectId, settings.auth.security.sessionsLimit);
-                await projectsService.updateAuthPasswordDictionary(projectId, settings.auth.security.passwordDictionary);
-                await projectsService.updateAuthPasswordHistory(projectId, settings.auth.security.passwordHistory);
-                await projectsService.updatePersonalDataCheck(projectId, settings.auth.security.personalDataCheck);
-                await projectsService.updateSessionAlerts(projectId, settings.auth.security.sessionAlerts);
-                await projectsService.updateMockNumbers(projectId, settings.auth.security.mockNumbers);
-            }
-            if (settings.auth.methods) {
-                log("Applying auth methods statuses ...");
-                for (let [method, status] of Object.entries(settings.auth.methods)) {
-                    await projectsService.updateAuthStatus(projectId, method, status);
-                }
-            }
-        }
+        const pushInstance = await createPushInstance();
+        const config = localConfig.getProject();
+        await pushInstance.pushSettings({
+            projectId: config.projectId,
+            projectName: config.projectName,
+            settings: config.projectSettings,
+        });
         success(`Successfully pushed ${chalk.bold("all")} project settings.`);
     }
     catch (e) {
@@ -878,281 +1257,41 @@ const pushSite = async ({ siteId, async: asyncDeploy, code, withVariables, } = {
     }
     if (siteIds.length === 0) {
         log("No sites found.");
-        hint("Use 'appwrite pull sites' to synchronize existing one, or use 'appwrite init site' to create a new one.");
+        hint(`Use '${EXECUTABLE_NAME} pull sites' to synchronize existing one, or use '${EXECUTABLE_NAME} init site' to create a new one.`);
         return;
     }
-    let sites = siteIds.map((id) => {
-        const sites = localConfig.getSites();
-        const site = sites.find((s) => s.$id === id);
-        if (!site) {
-            throw new Error("Site '" + id + "' not found.");
-        }
-        return site;
-    });
-    log("Validating sites ...");
-    // Validation is done BEFORE pushing so the deployment process can be run in async with progress update
-    for (let site of sites) {
-        if (!site.buildCommand) {
-            log(`Site ${site.name} is missing build command.`);
-            const answers = await inquirer.prompt(questionsGetEntrypoint);
-            site.buildCommand = answers.entrypoint;
-            localConfig.addSite(site);
-        }
-    }
-    if (!(await approveChanges(sites, async (args) => {
-        const sitesService = await getSitesService();
-        return await sitesService.get({ siteId: args.siteId });
-    }, KeysSite, "siteId", "sites", ["vars"]))) {
-        return;
-    }
-    log("Pushing sites ...");
-    Spinner.start(false);
-    let successfullyPushed = 0;
-    let successfullyDeployed = 0;
-    const failedDeployments = [];
-    const errors = [];
-    await Promise.all(sites.map(async (site) => {
-        let response = {};
-        const ignore = site.ignore ? "appwrite.config.json" : ".gitignore";
-        let siteExists = false;
-        let deploymentCreated = false;
-        const updaterRow = new Spinner({
-            status: "",
-            resource: site.name,
-            id: site["$id"],
-            end: `Ignoring using: ${ignore}`,
-        });
-        updaterRow.update({ status: "Getting" }).startSpinner(SPINNER_DOTS);
-        const sitesService = await getSitesService();
-        try {
-            response = await sitesService.get({ siteId: site["$id"] });
-            siteExists = true;
-            if (response.framework !== site.framework) {
-                updaterRow.fail({
-                    errorMessage: `Framework mismatch! (local=${site.framework},remote=${response.framework}) Please delete remote site or update your appwrite.config.json`,
-                });
-                return;
-            }
-            updaterRow.update({ status: "Updating" }).replaceSpinner(SPINNER_ARC);
-            response = await sitesService.update({
-                siteId: site["$id"],
-                name: site.name,
-                framework: site.framework,
-                enabled: site.enabled,
-                logging: site.logging,
-                timeout: site.timeout,
-                installCommand: site.installCommand,
-                buildCommand: site.buildCommand,
-                outputDirectory: site.outputDirectory,
-                buildRuntime: site.buildRuntime,
-                adapter: site.adapter,
-                specification: site.specification,
-            });
-        }
-        catch (e) {
-            if (Number(e.code) === 404) {
-                siteExists = false;
-            }
-            else {
-                errors.push(e);
-                updaterRow.fail({
-                    errorMessage: e.message ?? "General error occurs please try again",
-                });
-                return;
-            }
-        }
-        if (!siteExists) {
-            updaterRow.update({ status: "Creating" }).replaceSpinner(SPINNER_DOTS);
-            try {
-                response = await sitesService.create({
-                    siteId: site.$id,
-                    name: site.name,
-                    framework: site.framework,
-                    enabled: site.enabled,
-                    logging: site.logging,
-                    timeout: site.timeout,
-                    installCommand: site.installCommand,
-                    buildCommand: site.buildCommand,
-                    outputDirectory: site.outputDirectory,
-                    buildRuntime: site.buildRuntime,
-                    adapter: site.adapter,
-                    specification: site.specification,
-                });
-                let domain = "";
-                try {
-                    const consoleService = await getConsoleService();
-                    const variables = await consoleService.variables();
-                    domain = ID.unique() + "." + variables["_APP_DOMAIN_SITES"];
-                }
-                catch (error) {
-                    console.error("Error fetching console variables.");
-                    throw error;
-                }
-                try {
-                    const proxyService = await getProxyService();
-                    const rule = await proxyService.createSiteRule(domain, site.$id);
-                }
-                catch (error) {
-                    console.error("Error creating site rule.");
-                    throw error;
-                }
-                updaterRow.update({ status: "Created" });
-            }
-            catch (e) {
-                errors.push(e);
-                updaterRow.fail({
-                    errorMessage: e.message ?? "General error occurs please try again",
-                });
-                return;
-            }
-        }
-        if (withVariables) {
-            updaterRow
-                .update({ status: "Creating variables" })
-                .replaceSpinner(SPINNER_ARC);
-            const sitesService = await getSitesService();
-            const { variables } = await paginate(async (args) => {
-                return await sitesService.listVariables({ siteId: args.siteId });
-            }, {
-                siteId: site["$id"],
-            }, 100, "variables");
-            await Promise.all(variables.map(async (variable) => {
-                const sitesService = await getSitesService();
-                await sitesService.deleteVariable({
-                    siteId: site["$id"],
-                    variableId: variable["$id"],
-                });
-            }));
-            const envFileLocation = `${site["path"]}/.env`;
-            let envVariables = [];
-            try {
-                if (fs.existsSync(envFileLocation)) {
-                    const envObject = parseDotenv(fs.readFileSync(envFileLocation, "utf8"));
-                    envVariables = Object.entries(envObject || {}).map(([key, value]) => ({ key, value }));
-                }
-            }
-            catch (error) {
-                // Handle parsing errors gracefully
-                envVariables = [];
-            }
-            await Promise.all(envVariables.map(async (variable) => {
-                const sitesService = await getSitesService();
-                await sitesService.createVariable({
-                    siteId: site["$id"],
-                    key: variable.key,
-                    value: variable.value,
-                    secret: false,
-                });
-            }));
-        }
-        if (code === false) {
-            successfullyPushed++;
-            successfullyDeployed++;
-            updaterRow.update({ status: "Pushed" });
-            updaterRow.stopSpinner();
-            return;
-        }
-        try {
-            updaterRow.update({ status: "Pushing" }).replaceSpinner(SPINNER_ARC);
-            const sitesService = await getSitesService();
-            response = await sitesService.createDeployment({
-                siteId: site["$id"],
-                installCommand: site.installCommand,
-                buildCommand: site.buildCommand,
-                outputDirectory: site.outputDirectory,
-                code: site.path,
-                activate: true,
-            });
-            updaterRow.update({ status: "Pushed" });
-            deploymentCreated = true;
-            successfullyPushed++;
-        }
-        catch (e) {
-            errors.push(e);
-            switch (e.code) {
-                case "ENOENT":
-                    updaterRow.fail({
-                        errorMessage: "Not found in the current directory. Skipping...",
-                    });
-                    break;
-                default:
-                    updaterRow.fail({
-                        errorMessage: e.message ?? "An unknown error occurred. Please try again.",
-                    });
-            }
+    let sites = siteIds.map((id) => {
+        const sites = localConfig.getSites();
+        const site = sites.find((s) => s.$id === id);
+        if (!site) {
+            throw new Error("Site '" + id + "' not found.");
         }
-        if (deploymentCreated && !asyncDeploy) {
-            try {
-                const deploymentId = response["$id"];
-                updaterRow.update({
-                    status: "Deploying",
-                    end: "Checking deployment status...",
-                });
-                let pollChecks = 0;
-                while (true) {
-                    const sitesService = await getSitesService();
-                    response = await sitesService.getDeployment({
-                        siteId: site["$id"],
-                        deploymentId: deploymentId,
-                    });
-                    const status = response["status"];
-                    if (status === "ready") {
-                        successfullyDeployed++;
-                        let url = "";
-                        const proxyService = await getProxyService();
-                        const res = await proxyService.listRules([
-                            JSON.stringify({ method: "limit", values: [1] }),
-                            JSON.stringify({
-                                method: "equal",
-                                attribute: "deploymentResourceType",
-                                values: ["site"],
-                            }),
-                            JSON.stringify({
-                                method: "equal",
-                                attribute: "deploymentResourceId",
-                                values: [site["$id"]],
-                            }),
-                            JSON.stringify({
-                                method: "equal",
-                                attribute: "trigger",
-                                values: ["manual"],
-                            }),
-                        ]);
-                        if (Number(res.total) === 1) {
-                            url = res.rules[0].domain;
-                        }
-                        updaterRow.update({ status: "Deployed", end: url });
-                        break;
-                    }
-                    else if (status === "failed") {
-                        failedDeployments.push({
-                            name: site["name"],
-                            $id: site["$id"],
-                            deployment: response["$id"],
-                        });
-                        updaterRow.fail({ errorMessage: `Failed to deploy` });
-                        break;
-                    }
-                    else {
-                        updaterRow.update({
-                            status: "Deploying",
-                            end: `Current status: ${status}`,
-                        });
-                    }
-                    pollChecks++;
-                    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE * 1.5));
-                }
-            }
-            catch (e) {
-                errors.push(e);
-                updaterRow.fail({
-                    errorMessage: e.message ?? "Unknown error occurred. Please try again",
-                });
-            }
+        return site;
+    });
+    log("Validating sites ...");
+    // Validation is done BEFORE pushing so the deployment process can be run in async with progress update
+    for (let site of sites) {
+        if (!site.buildCommand) {
+            log(`Site ${site.name} is missing build command.`);
+            const answers = await inquirer.prompt(questionsGetEntrypoint);
+            site.buildCommand = answers.entrypoint;
+            localConfig.addSite(site);
         }
-        updaterRow.stopSpinner();
-    }));
-    Spinner.stop();
+    }
+    if (!(await approveChanges(sites, async (args) => {
+        const sitesService = await getSitesService();
+        return await sitesService.get({ siteId: args.siteId });
+    }, KeysSite, "siteId", "sites", ["vars"]))) {
+        return;
+    }
+    log("Pushing sites ...");
+    const pushInstance = await createPushInstance();
+    const result = await pushInstance.pushSites(sites, {
+        async: asyncDeploy,
+        code,
+        withVariables,
+    });
+    const { successfullyPushed, successfullyDeployed, failedDeployments, errors, } = result;
     failedDeployments.forEach((failed) => {
         const { name, deployment, $id } = failed;
         const failUrl = `${globalConfig.getEndpoint().slice(0, -3)}/console/project-${localConfig.getProject().projectId}/sites/site-${$id}/deployments/deployment-${deployment}`;
@@ -1199,7 +1338,7 @@ const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariable
     }
     if (functionIds.length === 0) {
         log("No functions found.");
-        hint("Use 'appwrite pull functions' to synchronize existing one, or use 'appwrite init function' to create a new one.");
+        hint(`Use '${EXECUTABLE_NAME} pull functions' to synchronize existing one, or use '${EXECUTABLE_NAME} init function' to create a new one.`);
         return;
     }
     let functions = functionIds.map((id) => {
@@ -1211,7 +1350,6 @@ const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariable
         return func;
     });
     log("Validating functions ...");
-    // Validation is done BEFORE pushing so the deployment process can be run in async with progress update
     for (let func of functions) {
         if (!func.entrypoint) {
             log(`Function ${func.name} is missing an entrypoint.`);
@@ -1227,256 +1365,13 @@ const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariable
         return;
     }
     log("Pushing functions ...");
-    Spinner.start(false);
-    let successfullyPushed = 0;
-    let successfullyDeployed = 0;
-    const failedDeployments = [];
-    const errors = [];
-    await Promise.all(functions.map(async (func) => {
-        let response = {};
-        const ignore = func.ignore ? "appwrite.config.json" : ".gitignore";
-        let functionExists = false;
-        let deploymentCreated = false;
-        const updaterRow = new Spinner({
-            status: "",
-            resource: func.name,
-            id: func["$id"],
-            end: `Ignoring using: ${ignore}`,
-        });
-        updaterRow.update({ status: "Getting" }).startSpinner(SPINNER_DOTS);
-        const functionsService = await getFunctionsService();
-        try {
-            response = await functionsService.get({ functionId: func["$id"] });
-            functionExists = true;
-            if (response.runtime !== func.runtime) {
-                updaterRow.fail({
-                    errorMessage: `Runtime mismatch! (local=${func.runtime},remote=${response.runtime}) Please delete remote function or update your appwrite.config.json`,
-                });
-                return;
-            }
-            updaterRow.update({ status: "Updating" }).replaceSpinner(SPINNER_ARC);
-            response = await functionsService.update({
-                functionId: func["$id"],
-                name: func.name,
-                runtime: func.runtime,
-                execute: func.execute,
-                events: func.events,
-                schedule: func.schedule,
-                timeout: func.timeout,
-                enabled: func.enabled,
-                logging: func.logging,
-                entrypoint: func.entrypoint,
-                commands: func.commands,
-                scopes: func.scopes,
-                specification: func.specification,
-            });
-        }
-        catch (e) {
-            if (Number(e.code) === 404) {
-                functionExists = false;
-            }
-            else {
-                errors.push(e);
-                updaterRow.fail({
-                    errorMessage: e.message ?? "General error occurs please try again",
-                });
-                return;
-            }
-        }
-        if (!functionExists) {
-            updaterRow.update({ status: "Creating" }).replaceSpinner(SPINNER_DOTS);
-            try {
-                response = await functionsService.create({
-                    functionId: func.$id,
-                    name: func.name,
-                    runtime: func.runtime,
-                    execute: func.execute,
-                    events: func.events,
-                    schedule: func.schedule,
-                    timeout: func.timeout,
-                    enabled: func.enabled,
-                    logging: func.logging,
-                    entrypoint: func.entrypoint,
-                    commands: func.commands,
-                    scopes: func.scopes,
-                    specification: func.specification,
-                });
-                let domain = "";
-                try {
-                    const consoleService = await getConsoleService();
-                    const variables = await consoleService.variables();
-                    domain = ID.unique() + "." + variables["_APP_DOMAIN_FUNCTIONS"];
-                }
-                catch (error) {
-                    console.error("Error fetching console variables.");
-                    throw error;
-                }
-                try {
-                    const proxyService = await getProxyService();
-                    const rule = await proxyService.createFunctionRule(domain, func.$id);
-                }
-                catch (error) {
-                    console.error("Error creating function rule.");
-                    throw error;
-                }
-                updaterRow.update({ status: "Created" });
-            }
-            catch (e) {
-                errors.push(e);
-                updaterRow.fail({
-                    errorMessage: e.message ?? "General error occurs please try again",
-                });
-                return;
-            }
-        }
-        if (withVariables) {
-            updaterRow
-                .update({ status: "Updating variables" })
-                .replaceSpinner(SPINNER_ARC);
-            const functionsService = await getFunctionsService();
-            const { variables } = await paginate(async (args) => {
-                return await functionsService.listVariables({
-                    functionId: args.functionId,
-                });
-            }, {
-                functionId: func["$id"],
-            }, 100, "variables");
-            await Promise.all(variables.map(async (variable) => {
-                const functionsService = await getFunctionsService();
-                await functionsService.deleteVariable({
-                    functionId: func["$id"],
-                    variableId: variable["$id"],
-                });
-            }));
-            const envFileLocation = `${func["path"]}/.env`;
-            let envVariables = [];
-            try {
-                if (fs.existsSync(envFileLocation)) {
-                    const envObject = parseDotenv(fs.readFileSync(envFileLocation, "utf8"));
-                    envVariables = Object.entries(envObject || {}).map(([key, value]) => ({ key, value }));
-                }
-            }
-            catch (error) {
-                // Handle parsing errors gracefully
-                envVariables = [];
-            }
-            await Promise.all(envVariables.map(async (variable) => {
-                const functionsService = await getFunctionsService();
-                await functionsService.createVariable({
-                    functionId: func["$id"],
-                    key: variable.key,
-                    value: variable.value,
-                    secret: false,
-                });
-            }));
-        }
-        if (code === false) {
-            successfullyPushed++;
-            successfullyDeployed++;
-            updaterRow.update({ status: "Pushed" });
-            updaterRow.stopSpinner();
-            return;
-        }
-        try {
-            updaterRow.update({ status: "Pushing" }).replaceSpinner(SPINNER_ARC);
-            const functionsService = await getFunctionsService();
-            response = await functionsService.createDeployment({
-                functionId: func["$id"],
-                entrypoint: func.entrypoint,
-                commands: func.commands,
-                code: func.path,
-                activate: true,
-            });
-            updaterRow.update({ status: "Pushed" });
-            deploymentCreated = true;
-            successfullyPushed++;
-        }
-        catch (e) {
-            errors.push(e);
-            switch (e.code) {
-                case "ENOENT":
-                    updaterRow.fail({
-                        errorMessage: "Not found in the current directory. Skipping...",
-                    });
-                    break;
-                default:
-                    updaterRow.fail({
-                        errorMessage: e.message ?? "An unknown error occurred. Please try again.",
-                    });
-            }
-        }
-        if (deploymentCreated && !asyncDeploy) {
-            try {
-                const deploymentId = response["$id"];
-                updaterRow.update({
-                    status: "Deploying",
-                    end: "Checking deployment status...",
-                });
-                let pollChecks = 0;
-                while (true) {
-                    const functionsService = await getFunctionsService();
-                    response = await functionsService.getDeployment({
-                        functionId: func["$id"],
-                        deploymentId: deploymentId,
-                    });
-                    const status = response["status"];
-                    if (status === "ready") {
-                        successfullyDeployed++;
-                        let url = "";
-                        const proxyService = await getProxyService();
-                        const res = await proxyService.listRules([
-                            JSON.stringify({ method: "limit", values: [1] }),
-                            JSON.stringify({
-                                method: "equal",
-                                attribute: "deploymentResourceType",
-                                values: ["function"],
-                            }),
-                            JSON.stringify({
-                                method: "equal",
-                                attribute: "deploymentResourceId",
-                                values: [func["$id"]],
-                            }),
-                            JSON.stringify({
-                                method: "equal",
-                                attribute: "trigger",
-                                values: ["manual"],
-                            }),
-                        ]);
-                        if (Number(res.total) === 1) {
-                            url = res.rules[0].domain;
-                        }
-                        updaterRow.update({ status: "Deployed", end: url });
-                        break;
-                    }
-                    else if (status === "failed") {
-                        failedDeployments.push({
-                            name: func["name"],
-                            $id: func["$id"],
-                            deployment: response["$id"],
-                        });
-                        updaterRow.fail({ errorMessage: `Failed to deploy` });
-                        break;
-                    }
-                    else {
-                        updaterRow.update({
-                            status: "Deploying",
-                            end: `Current status: ${status}`,
-                        });
-                    }
-                    pollChecks++;
-                    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE * 1.5));
-                }
-            }
-            catch (e) {
-                errors.push(e);
-                updaterRow.fail({
-                    errorMessage: e.message ?? "Unknown error occurred. Please try again",
-                });
-            }
-        }
-        updaterRow.stopSpinner();
-    }));
-    Spinner.stop();
+    const pushInstance = await createPushInstance();
+    const result = await pushInstance.pushFunctions(functions, {
+        async: asyncDeploy,
+        code,
+        withVariables,
+    });
+    const { successfullyPushed, successfullyDeployed, failedDeployments, errors, } = result;
     failedDeployments.forEach((failed) => {
         const { name, deployment, $id } = failed;
         const failUrl = `${globalConfig.getEndpoint().slice(0, -3)}/console/project-${localConfig.getProject().projectId}/functions/function-${$id}/deployment-${deployment}`;
@@ -1502,145 +1397,14 @@ const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariable
         });
     }
 };
-const checkAndApplyTablesDBChanges = async () => {
-    log("Checking for tablesDB changes ...");
-    const localTablesDBs = localConfig.getTablesDBs();
-    const { databases: remoteTablesDBs } = await paginate(async (args) => {
-        const tablesDBService = await getTablesDBService();
-        return await tablesDBService.list(args.queries || []);
-    }, {}, 100, "databases");
-    if (localTablesDBs.length === 0 && remoteTablesDBs.length === 0) {
-        return { applied: false, resyncNeeded: false };
-    }
-    const changes = [];
-    const toCreate = [];
-    const toUpdate = [];
-    const toDelete = [];
-    // Check for deletions - remote DBs that aren't in local config
-    for (const remoteDB of remoteTablesDBs) {
-        const localDB = localTablesDBs.find((db) => db.$id === remoteDB.$id);
-        if (!localDB) {
-            toDelete.push(remoteDB);
-            changes.push({
-                id: remoteDB.$id,
-                action: chalk.red("deleting"),
-                key: "Database",
-                remote: remoteDB.name,
-                local: "(deleted locally)",
-            });
-        }
-    }
-    // Check for additions and updates
-    for (const localDB of localTablesDBs) {
-        const remoteDB = remoteTablesDBs.find((db) => db.$id === localDB.$id);
-        if (!remoteDB) {
-            toCreate.push(localDB);
-            changes.push({
-                id: localDB.$id,
-                action: chalk.green("creating"),
-                key: "Database",
-                remote: "(does not exist)",
-                local: localDB.name,
-            });
-        }
-        else {
-            let hasChanges = false;
-            if (remoteDB.name !== localDB.name) {
-                hasChanges = true;
-                changes.push({
-                    id: localDB.$id,
-                    action: chalk.yellow("updating"),
-                    key: "Name",
-                    remote: remoteDB.name,
-                    local: localDB.name,
-                });
-            }
-            if (remoteDB.enabled !== localDB.enabled) {
-                hasChanges = true;
-                changes.push({
-                    id: localDB.$id,
-                    action: chalk.yellow("updating"),
-                    key: "Enabled",
-                    remote: remoteDB.enabled,
-                    local: localDB.enabled,
-                });
-            }
-            if (hasChanges) {
-                toUpdate.push(localDB);
-            }
-        }
-    }
-    if (changes.length === 0) {
-        return { applied: false, resyncNeeded: false };
-    }
-    log("Found changes in tablesDB resource:");
-    drawTable(changes);
-    if (toDelete.length > 0) {
-        console.log(`${chalk.red("------------------------------------------------------------------")}`);
-        console.log(`${chalk.red("| WARNING: Database deletion will also delete all related tables |")}`);
-        console.log(`${chalk.red("------------------------------------------------------------------")}`);
-        console.log();
-    }
-    if ((await getConfirmation()) !== true) {
-        return { applied: false, resyncNeeded: false };
-    }
-    // Apply deletions first
-    let needsResync = false;
-    for (const db of toDelete) {
-        try {
-            log(`Deleting database ${db.name} ( ${db.$id} ) ...`);
-            const tablesDBService = await getTablesDBService();
-            await tablesDBService.delete(db.$id);
-            success(`Deleted ${db.name} ( ${db.$id} )`);
-            needsResync = true;
-        }
-        catch (e) {
-            error(`Failed to delete database ${db.name} ( ${db.$id} ): ${e.message}`);
-            throw new Error(`Database sync failed during deletion of ${db.$id}. Some changes may have been applied.`);
-        }
-    }
-    // Apply creations
-    for (const db of toCreate) {
-        try {
-            log(`Creating database ${db.name} ( ${db.$id} ) ...`);
-            const tablesDBService = await getTablesDBService();
-            await tablesDBService.create(db.$id, db.name, db.enabled);
-            success(`Created ${db.name} ( ${db.$id} )`);
-        }
-        catch (e) {
-            error(`Failed to create database ${db.name} ( ${db.$id} ): ${e.message}`);
-            throw new Error(`Database sync failed during creation of ${db.$id}. Some changes may have been applied.`);
-        }
-    }
-    // Apply updates
-    for (const db of toUpdate) {
-        try {
-            log(`Updating database ${db.name} ( ${db.$id} ) ...`);
-            const tablesDBService = await getTablesDBService();
-            await tablesDBService.update(db.$id, db.name, db.enabled);
-            success(`Updated ${db.name} ( ${db.$id} )`);
-        }
-        catch (e) {
-            error(`Failed to update database ${db.name} ( ${db.$id} ): ${e.message}`);
-            throw new Error(`Database sync failed during update of ${db.$id}. Some changes may have been applied.`);
-        }
-    }
-    if (toDelete.length === 0) {
-        console.log();
-    }
-    return { applied: true, resyncNeeded: needsResync };
-};
 const pushTable = async ({ attempts, } = {}) => {
     const tables = [];
-    if (attempts) {
-        pollMaxDebounces = attempts;
-    }
-    const { applied: tablesDBApplied, resyncNeeded } = await checkAndApplyTablesDBChanges();
+    const { resyncNeeded } = await checkAndApplyTablesDBChanges();
     if (resyncNeeded) {
-        log("Resyncing configuration due to tablesDB deletions ...");
+        log("Resyncing configuration due to tables deletions ...");
         const remoteTablesDBs = (await paginate(async (args) => {
-            const tablesDBService = await getTablesDBService();
-            return await tablesDBService.list(args.queries || []);
+            const tablesService = await getTablesDBService();
+            return await tablesService.list(args.queries || []);
         }, {}, 100, "databases")).databases;
         const localTablesDBs = localConfig.getTablesDBs();
         const remoteDatabaseIds = new Set(remoteTablesDBs.map((db) => db.$id));
@@ -1659,8 +1423,8 @@ const pushTable = async ({ attempts, } = {}) => {
     for (const db of localTablesDBs) {
         try {
             const { tables: remoteTables } = await paginate(async (args) => {
-                const tablesDBService = await getTablesDBService();
-                return await tablesDBService.listTables(args.databaseId, args.queries || []);
+                const tablesService = await getTablesDBService();
+                return await tablesService.listTables(args.databaseId, args.queries || []);
             }, {
                 databaseId: db.$id,
             }, 100, "tables");
@@ -1694,8 +1458,8 @@ const pushTable = async ({ attempts, } = {}) => {
             for (const table of tablesToDelete) {
                 try {
                     log(`Deleting table ${table.name} ( ${table.$id} ) from database ${table.databaseName} ...`);
-                    const tablesDBService = await getTablesDBService();
-                    await tablesDBService.deleteTable(table.databaseId, table.$id);
+                    const tablesService = await getTablesDBService();
+                    await tablesService.deleteTable(table.databaseId, table.$id);
                     success(`Deleted ${table.name} ( ${table.$id} )`);
                 }
                 catch (e) {
@@ -1723,90 +1487,32 @@ const pushTable = async ({ attempts, } = {}) => {
     }
     if (tables.length === 0) {
         log("No tables found.");
-        hint("Use 'appwrite pull tables' to synchronize existing one, or use 'appwrite init table' to create a new one.");
+        hint(`Use '${EXECUTABLE_NAME} pull tables' to synchronize existing one, or use '${EXECUTABLE_NAME} init table' to create a new one.`);
         return;
     }
     if (!(await approveChanges(tables, async (args) => {
-        const tablesDBService = await getTablesDBService();
-        return await tablesDBService.getTable(args.databaseId, args.tableId);
+        const tablesService = await getTablesDBService();
+        return await tablesService.getTable(args.databaseId, args.tableId);
     }, KeysTable, "tableId", "tables", ["columns", "indexes"], "databaseId", "databaseId"))) {
         return;
     }
-    let tablesChanged = new Set();
-    // Parallel tables actions
-    await Promise.all(tables.map(async (table) => {
-        try {
-            const tablesDBService = await getTablesDBService();
-            const remoteTable = await tablesDBService.getTable(table["databaseId"], table["$id"]);
-            const changes = [];
-            if (remoteTable.name !== table.name)
-                changes.push("name");
-            if (remoteTable.rowSecurity !== table.rowSecurity)
-                changes.push("rowSecurity");
-            if (remoteTable.enabled !== table.enabled)
-                changes.push("enabled");
-            if (JSON.stringify(remoteTable["$permissions"]) !==
-                JSON.stringify(table["$permissions"]))
-                changes.push("permissions");
-            if (changes.length > 0) {
-                await tablesDBService.updateTable(table["databaseId"], table["$id"], table.name, table.rowSecurity, table["$permissions"]);
-                success(`Updated ${table.name} ( ${table["$id"]} ) - ${changes.join(", ")}`);
-                tablesChanged.add(table["$id"]);
-            }
-            table.remoteVersion = remoteTable;
-            table.isExisted = true;
-        }
-        catch (e) {
-            if (Number(e.code) === 404) {
-                log(`Table ${table.name} does not exist in the project. Creating ... `);
-                const tablesDBService = await getTablesDBService();
-                await tablesDBService.createTable(table["databaseId"], table["$id"], table.name, table.rowSecurity, table["$permissions"]);
-                success(`Created ${table.name} ( ${table["$id"]} )`);
-                tablesChanged.add(table["$id"]);
-            }
-            else {
-                throw e;
-            }
-        }
-    }));
-    // Serialize attribute actions
-    for (let table of tables) {
-        let columns = table.columns;
-        let indexes = table.indexes;
-        if (table.isExisted) {
-            columns = await attributesToCreate(table.remoteVersion.columns, table.columns, table);
-            indexes = await attributesToCreate(table.remoteVersion.indexes, table.indexes, table, true);
-            if (Array.isArray(columns) &&
-                columns.length <= 0 &&
-                Array.isArray(indexes) &&
-                indexes.length <= 0) {
-                continue;
-            }
-        }
-        log(`Pushing table ${table.name} ( ${table["databaseId"]} - ${table["$id"]} ) attributes`);
-        try {
-            await createColumns(columns, table);
-        }
-        catch (e) {
-            throw e;
-        }
-        try {
-            await createIndexes(indexes, table);
-        }
-        catch (e) {
-            throw e;
-        }
-        tablesChanged.add(table["$id"]);
-        success(`Successfully pushed ${table.name} ( ${table["$id"]} )`);
+    log("Pushing tables ...");
+    const pushInstance = await createPushInstance();
+    const result = await pushInstance.pushTables(tables, { attempts });
+    const { successfullyPushed, errors } = result;
+    if (successfullyPushed === 0) {
+        error("No tables were pushed.");
+    }
+    else {
+        success(`Successfully pushed ${successfullyPushed} tables.`);
+    }
+    if (cliConfig.verbose) {
+        errors.forEach((e) => console.error(e));
     }
-    success(`Successfully pushed ${tablesChanged.size} tables`);
 };
-const pushCollection = async ({ attempts }) => {
-    warn("appwrite push collection has been deprecated. Please consider using 'appwrite push tables' instead");
+const pushCollection = async () => {
+    warn(`${EXECUTABLE_NAME} push collection has been deprecated. Please consider using '${EXECUTABLE_NAME} push tables' instead`);
     const collections = [];
-    if (attempts) {
-        pollMaxDebounces = attempts;
-    }
     if (cliConfig.all) {
         checkDeployConditions(localConfig);
         collections.push(...localConfig.getCollections());
@@ -1826,90 +1532,35 @@ const pushCollection = async ({ attempts }) => {
     }
     if (collections.length === 0) {
         log("No collections found.");
-        hint("Use 'appwrite pull collections' to synchronize existing one, or use 'appwrite init collection' to create a new one.");
+        hint(`Use '${EXECUTABLE_NAME} pull collections' to synchronize existing one, or use '${EXECUTABLE_NAME} init collection' to create a new one.`);
         return;
     }
-    const databases = Array.from(new Set(collections.map((collection) => collection["databaseId"])));
-    // Parallel db actions
-    await Promise.all(databases.map(async (databaseId) => {
-        const localDatabase = localConfig.getDatabase(databaseId);
-        const databasesService = await getDatabasesService();
-        try {
-            const database = await databasesService.get(databaseId);
-            if (database.name !== (localDatabase.name ?? databaseId)) {
-                await databasesService.update(databaseId, localDatabase.name ?? databaseId);
-                success(`Updated ${localDatabase.name} ( ${databaseId} ) name`);
-            }
-        }
-        catch (err) {
-            log(`Database ${databaseId} not found. Creating it now ...`);
-            await databasesService.create(databaseId, localDatabase.name ?? databaseId);
-        }
-    }));
+    // Add database names to collections for the class method
+    collections.forEach((collection) => {
+        const localDatabase = localConfig.getDatabase(collection.databaseId);
+        collection.databaseName = localDatabase.name ?? collection.databaseId;
+    });
     if (!(await approveChanges(collections, async (args) => {
         const databasesService = await getDatabasesService();
         return await databasesService.getCollection(args.databaseId, args.collectionId);
     }, KeysCollection, "collectionId", "collections", ["attributes", "indexes"], "databaseId", "databaseId"))) {
         return;
     }
-    // Parallel collection actions
-    await Promise.all(collections.map(async (collection) => {
-        try {
-            const databasesService = await getDatabasesService();
-            const remoteCollection = await databasesService.getCollection(collection["databaseId"], collection["$id"]);
-            if (remoteCollection.name !== collection.name) {
-                await databasesService.updateCollection(collection["databaseId"], collection["$id"], collection.name);
-                success(`Updated ${collection.name} ( ${collection["$id"]} ) name`);
-            }
-            collection.remoteVersion = remoteCollection;
-            collection.isExisted = true;
-        }
-        catch (e) {
-            if (Number(e.code) === 404) {
-                log(`Collection ${collection.name} does not exist in the project. Creating ... `);
-                const databasesService = await getDatabasesService();
-                await databasesService.createCollection(collection["databaseId"], collection["$id"], collection.name, collection.documentSecurity, collection["$permissions"]);
-            }
-            else {
-                throw e;
-            }
-        }
-    }));
-    let numberOfCollections = 0;
-    // Serialize attribute actions
-    for (let collection of collections) {
-        let attributes = collection.attributes;
-        let indexes = collection.indexes;
-        if (collection.isExisted) {
-            attributes = await attributesToCreate(collection.remoteVersion.attributes, collection.attributes, collection);
-            indexes = await attributesToCreate(collection.remoteVersion.indexes, collection.indexes, collection, true);
-            if (Array.isArray(attributes) &&
-                attributes.length <= 0 &&
-                Array.isArray(indexes) &&
-                indexes.length <= 0) {
-                continue;
-            }
-        }
-        log(`Pushing collection ${collection.name} ( ${collection["databaseId"]} - ${collection["$id"]} ) attributes`);
-        try {
-            await createAttributes(attributes, collection);
-        }
-        catch (e) {
-            throw e;
-        }
-        try {
-            await createIndexes(indexes, collection);
-        }
-        catch (e) {
-            throw e;
-        }
-        numberOfCollections++;
-        success(`Successfully pushed ${collection.name} ( ${collection["$id"]} )`);
+    log("Pushing collections ...");
+    const pushInstance = await createPushInstance();
+    const result = await pushInstance.pushCollections(collections);
+    const { successfullyPushed, errors } = result;
+    if (successfullyPushed === 0) {
+        error("No collections were pushed.");
+    }
+    else {
+        success(`Successfully pushed ${successfullyPushed} collections.`);
+    }
+    if (cliConfig.verbose) {
+        errors.forEach((e) => console.error(e));
     }
-    success(`Successfully pushed ${numberOfCollections} collections`);
 };
 const pushBucket = async () => {
-    let response = {};
     let bucketIds = [];
     const configBuckets = localConfig.getBuckets();
     if (cliConfig.all) {
@@ -1924,7 +1575,7 @@ const pushBucket = async () => {
     }
     if (bucketIds.length === 0) {
         log("No buckets found.");
-        hint("Use 'appwrite pull buckets' to synchronize existing one, or use 'appwrite init bucket' to create a new one.");
+        hint(`Use '${EXECUTABLE_NAME} pull buckets' to synchronize existing one, or use '${EXECUTABLE_NAME} init bucket' to create a new one.`);
         return;
     }
     let buckets = [];
@@ -1939,27 +1590,20 @@ const pushBucket = async () => {
         return;
     }
     log("Pushing buckets ...");
-    for (let bucket of buckets) {
-        log(`Pushing bucket ${chalk.bold(bucket["name"])} ...`);
-        const storageService = await getStorageService();
-        try {
-            response = await storageService.getBucket(bucket["$id"]);
-            await storageService.updateBucket(bucket["$id"], bucket.name, bucket["$permissions"], bucket.fileSecurity, bucket.enabled, bucket.maximumFileSize, bucket.allowedFileExtensions, bucket.encryption, bucket.antivirus, bucket.compression);
-        }
-        catch (e) {
-            if (Number(e.code) === 404) {
-                log(`Bucket ${bucket.name} does not exist in the project. Creating ... `);
-                response = await storageService.createBucket(bucket["$id"], bucket.name, bucket["$permissions"], bucket.fileSecurity, bucket.enabled, bucket.maximumFileSize, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
-            }
-            else {
-                throw e;
-            }
-        }
+    const pushInstance = await createPushInstance();
+    const result = await pushInstance.pushBuckets(buckets);
+    const { successfullyPushed, errors } = result;
+    if (successfullyPushed === 0) {
+        error("No buckets were pushed.");
+    }
+    else {
+        success(`Successfully pushed ${successfullyPushed} buckets.`);
+    }
+    if (cliConfig.verbose) {
+        errors.forEach((e) => console.error(e));
     }
-    success(`Successfully pushed ${buckets.length} buckets.`);
 };
 const pushTeam = async () => {
-    let response = {};
     let teamIds = [];
     const configTeams = localConfig.getTeams();
     if (cliConfig.all) {
@@ -1974,7 +1618,7 @@ const pushTeam = async () => {
     }
     if (teamIds.length === 0) {
         log("No teams found.");
-        hint("Use 'appwrite pull teams' to synchronize existing one, or use 'appwrite init team' to create a new one.");
+        hint(`Use '${EXECUTABLE_NAME} pull teams' to synchronize existing one, or use '${EXECUTABLE_NAME} init team' to create a new one.`);
         return;
     }
     let teams = [];
@@ -1989,27 +1633,20 @@ const pushTeam = async () => {
         return;
     }
     log("Pushing teams ...");
-    for (let team of teams) {
-        log(`Pushing team ${chalk.bold(team["name"])} ...`);
-        const teamsService = await getTeamsService();
-        try {
-            response = await teamsService.get(team["$id"]);
-            await teamsService.updateName(team["$id"], team.name);
-        }
-        catch (e) {
-            if (Number(e.code) === 404) {
-                log(`Team ${team.name} does not exist in the project. Creating ... `);
-                response = await teamsService.create(team["$id"], team.name);
-            }
-            else {
-                throw e;
-            }
-        }
+    const pushInstance = await createPushInstance();
+    const result = await pushInstance.pushTeams(teams);
+    const { successfullyPushed, errors } = result;
+    if (successfullyPushed === 0) {
+        error("No teams were pushed.");
+    }
+    else {
+        success(`Successfully pushed ${successfullyPushed} teams.`);
+    }
+    if (cliConfig.verbose) {
+        errors.forEach((e) => console.error(e));
     }
-    success(`Successfully pushed ${teams.length} teams.`);
 };
 const pushMessagingTopic = async () => {
-    let response = {};
     let topicsIds = [];
     const configTopics = localConfig.getMessagingTopics();
     if (cliConfig.all) {
@@ -2024,7 +1661,7 @@ const pushMessagingTopic = async () => {
     }
     if (topicsIds.length === 0) {
         log("No topics found.");
-        hint("Use 'appwrite pull topics' to synchronize existing one, or use 'appwrite init topic' to create a new one.");
+        hint(`Use '${EXECUTABLE_NAME} pull topics' to synchronize existing one, or use '${EXECUTABLE_NAME} init topic' to create a new one.`);
         return;
     }
     let topics = [];
@@ -2039,26 +1676,18 @@ const pushMessagingTopic = async () => {
         return;
     }
     log("Pushing topics ...");
-    for (let topic of topics) {
-        log(`Pushing topic ${chalk.bold(topic["name"])} ...`);
-        const messagingService = await getMessagingService();
-        try {
-            response = await messagingService.getTopic(topic["$id"]);
-            log(`Topic ${topic.name} ( ${topic["$id"]} ) already exists.`);
-            await messagingService.updateTopic(topic["$id"], topic.name, topic.subscribe);
-        }
-        catch (e) {
-            if (Number(e.code) === 404) {
-                log(`Topic ${topic.name} does not exist in the project. Creating ... `);
-                response = await messagingService.createTopic(topic["$id"], topic.name, topic.subscribe);
-                success(`Created ${topic.name} ( ${topic["$id"]} )`);
-            }
-            else {
-                throw e;
-            }
-        }
+    const pushInstance = await createPushInstance();
+    const result = await pushInstance.pushMessagingTopics(topics);
+    const { successfullyPushed, errors } = result;
+    if (successfullyPushed === 0) {
+        error("No topics were pushed.");
+    }
+    else {
+        success(`Successfully pushed ${successfullyPushed} topics.`);
+    }
+    if (cliConfig.verbose) {
+        errors.forEach((e) => console.error(e));
     }
-    success(`Successfully pushed ${topics.length} topics.`);
 };
 export const push = new Command("push")
     .description(commandDescriptions["push"])
@@ -2120,8 +1749,8 @@ push
     .description("Push messaging topics in the current project.")
     .action(actionRunner(pushMessagingTopic));
 export const deploy = new Command("deploy")
-    .description("Removed. Use appwrite push instead")
+    .description(`Removed. Use ${EXECUTABLE_NAME} push instead`)
     .action(actionRunner(async () => {
-    warn("appwrite deploy has been removed. Please use 'appwrite push' instead");
+    warn(`${EXECUTABLE_NAME} deploy has been removed. Please use '${EXECUTABLE_NAME} push' instead`);
 }));
 //# sourceMappingURL=push.js.map