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

package/lib/commands/push.ts

@@ -4,21 +4,23 @@ import chalk from "chalk";
 import inquirer from "inquirer";
 import { Command } from "commander";
 import ID from "../id.js";
+import { EXECUTABLE_NAME } from "../constants.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 type { SettingsType, ConfigType } from "./config.js";
+import { createSettingsObject } from "../utils.js";
+import { Spinner, SPINNER_DOTS } from "../spinner.js";
 import { paginate } from "../paginate.js";
+import { pushDeployment } from "./utils/deployment.js";
 import {
   questionsPushBuckets,
   questionsPushTeams,
@@ -27,8 +29,6 @@ import {
   questionsGetEntrypoint,
   questionsPushCollections,
   questionsPushTables,
-  questionPushChanges,
-  questionPushChangesConfirmation,
   questionsPushMessagingTopics,
   questionsPushResources,
 } from "../questions.js";
@@ -55,44 +55,53 @@ import {
   getTeamsService,
   getProjectsService,
 } from "../services.js";
-import { ApiService, AuthMethod } from "@appwrite.io/console";
+import { sdkForProject, sdkForConsole } from "../sdks.js";
+import {
+  ApiService,
+  AuthMethod,
+  AppwriteException,
+  Client,
+  Query,
+} from "@appwrite.io/console";
 import { checkDeployConditions } from "../utils.js";
+import { Pools } from "./utils/pools.js";
+import { Attributes, Collection } from "./utils/attributes.js";
+import {
+  getConfirmation,
+  approveChanges,
+  getObjectChanges,
+} from "./utils/change-approval.js";
+import { checkAndApplyTablesDBChanges } from "./utils/database-sync.js";
 
-const STEP_SIZE = 100; // Resources
 const POLL_DEBOUNCE = 2000; // Milliseconds
 const POLL_DEFAULT_VALUE = 30;
-
-let pollMaxDebounces = POLL_DEFAULT_VALUE;
-
-const changeableKeys = [
-  "status",
-  "required",
-  "xdefault",
-  "elements",
-  "min",
-  "max",
-  "default",
-  "error",
-];
-
-interface ObjectChange {
-  group: string;
-  setting: string;
-  remote: string;
-  local: string;
-}
-
-type ComparableValue = boolean | number | string | any[] | undefined;
-
-interface AttributeChange {
-  key: string;
-  attribute: any;
-  reason: string;
-  action: string;
-}
-
-interface PushResourcesOptions {
+const DEPLOYMENT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+
+export interface PushOptions {
+  all?: boolean;
+  settings?: boolean;
+  functions?: boolean;
+  sites?: boolean;
+  collections?: boolean;
+  tables?: boolean;
+  buckets?: boolean;
+  teams?: boolean;
+  topics?: boolean;
   skipDeprecated?: boolean;
+  skipConfirmation?: boolean;
+  functionOptions?: {
+    async?: boolean;
+    code?: boolean;
+    withVariables?: boolean;
+  };
+  siteOptions?: {
+    async?: boolean;
+    code?: boolean;
+    withVariables?: boolean;
+  };
+  tableOptions?: {
+    attempts?: number;
+  };
 }
 
 interface PushSiteOptions {
@@ -109,1473 +118,890 @@ interface PushFunctionOptions {
   withVariables?: boolean;
 }
 
-interface TablesDBChangesResult {
-  applied: boolean;
-  resyncNeeded: boolean;
-}
-
 interface PushTableOptions {
   attempts?: number;
+  skipConfirmation?: boolean;
 }
 
-interface AwaitPools {
-  wipeAttributes: (
-    databaseId: string,
-    collectionId: string,
-    iteration?: number,
-  ) => Promise<boolean>;
-
-  wipeIndexes: (
-    databaseId: string,
-    collectionId: string,
-    iteration?: number,
-  ) => Promise<boolean>;
-
-  deleteAttributes: (
-    databaseId: string,
-    collectionId: string,
-    attributeKeys: any[],
-    iteration?: number,
-  ) => Promise<boolean>;
-
-  expectAttributes: (
-    databaseId: string,
-    collectionId: string,
-    attributeKeys: string[],
-    iteration?: number,
-  ) => Promise<boolean>;
-
-  deleteIndexes: (
-    databaseId: string,
-    collectionId: string,
-    indexesKeys: any[],
-    iteration?: number,
-  ) => Promise<boolean>;
-
-  expectIndexes: (
-    databaseId: string,
-    collectionId: string,
-    indexKeys: string[],
-    iteration?: number,
-  ) => Promise<boolean>;
-}
-
-const awaitPools: AwaitPools = {
-  wipeAttributes: async (
-    databaseId: string,
-    collectionId: string,
-    iteration: number = 1,
-  ): Promise<boolean> => {
-    if (iteration > pollMaxDebounces) {
-      return false;
-    }
+export class Push {
+  private projectClient: Client;
+  private consoleClient: Client;
+  private silent: boolean;
 
-    const databasesService = await getDatabasesService();
-    const response = await databasesService.listAttributes(
-      databaseId,
-      collectionId,
-      [JSON.stringify({ method: "limit", values: [1] })],
-    );
-    const { total } = response;
+  constructor(projectClient: Client, consoleClient: Client, silent = false) {
+    this.projectClient = projectClient;
+    this.consoleClient = consoleClient;
+    this.silent = silent;
+  }
 
-    if (total === 0) {
-      return true;
+  /**
+   * Log a message (respects silent mode)
+   */
+  private log(message: string): void {
+    if (!this.silent) {
+      log(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",
-        );
-      }
+  /**
+   * Log a success message (respects silent mode)
+   */
+  private success(message: string): void {
+    if (!this.silent) {
+      success(message);
     }
+  }
 
-    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
-
-    return await awaitPools.wipeAttributes(
-      databaseId,
-      collectionId,
-      iteration + 1,
-    );
-  },
-  wipeIndexes: async (
-    databaseId: string,
-    collectionId: string,
-    iteration: number = 1,
-  ): Promise<boolean> => {
-    if (iteration > pollMaxDebounces) {
-      return false;
+  /**
+   * Log a warning message (respects silent mode)
+   */
+  private warn(message: string): void {
+    if (!this.silent) {
+      warn(message);
     }
+  }
 
-    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;
+  /**
+   * Log an error message (respects silent mode)
+   */
+  private error(message: string): void {
+    if (!this.silent) {
+      error(message);
     }
+  }
 
-    if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
-      let steps = Math.max(1, Math.ceil(total / STEP_SIZE));
-      if (steps > 1 && iteration === 1) {
-        pollMaxDebounces *= steps;
+  public async pushResources(
+    config: ConfigType,
+    options: PushOptions = { all: true, skipDeprecated: true },
+  ): Promise<{
+    results: Record<string, any>;
+    errors: any[];
+  }> {
+    const { skipDeprecated = true } = options;
+    const results: Record<string, any> = {};
+    const allErrors: any[] = [];
+    const shouldPushAll = options.all === true;
 
-        log(
-          "Found a large number of indexes, increasing timeout to " +
-            (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
-            " minutes",
+    // 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: any) {
+        allErrors.push(e);
+        results.settings = { success: false, error: e.message };
       }
     }
 
-    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
-
-    return await awaitPools.wipeIndexes(
-      databaseId,
-      collectionId,
-      iteration + 1,
-    );
-  },
-  deleteAttributes: async (
-    databaseId: string,
-    collectionId: string,
-    attributeKeys: any[],
-    iteration: number = 1,
-  ): Promise<boolean> => {
-    if (iteration > pollMaxDebounces) {
-      return false;
-    }
-
-    if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
-      let steps = Math.max(1, Math.ceil(attributeKeys.length / STEP_SIZE));
-      if (steps > 1 && iteration === 1) {
-        pollMaxDebounces *= steps;
-
-        log(
-          "Found a large number of attributes to be deleted. Increasing timeout to " +
-            (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
-            " minutes",
+    // 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: any) {
+        allErrors.push(e);
+        results.buckets = { successfullyPushed: 0, errors: [e] };
       }
     }
 
-    const { attributes } = await paginate(
-      async (args: any) => {
-        const databasesService = await getDatabasesService();
-        return await databasesService.listAttributes(
-          args.databaseId,
-          args.collectionId,
-          args.queries || [],
+    // 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.`,
         );
-      },
-      {
-        databaseId,
-        collectionId,
-      },
-      100,
-      "attributes",
-    );
-
-    const ready = attributeKeys.filter((attribute: any) =>
-      attributes.includes(attribute.key),
-    );
-
-    if (ready.length === 0) {
-      return true;
+        results.teams = result;
+        allErrors.push(...result.errors);
+      } catch (e: any) {
+        allErrors.push(e);
+        results.teams = { successfullyPushed: 0, errors: [e] };
+      }
     }
 
-    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
-
-    return await awaitPools.expectAttributes(
-      databaseId,
-      collectionId,
-      attributeKeys,
-      iteration + 1,
-    );
-  },
-  expectAttributes: async (
-    databaseId: string,
-    collectionId: string,
-    attributeKeys: string[],
-    iteration: number = 1,
-  ): Promise<boolean> => {
-    if (iteration > pollMaxDebounces) {
-      return false;
+    // 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: any) {
+        allErrors.push(e);
+        results.topics = { successfullyPushed: 0, 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(
-          "Creating a large number of attributes, 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: any) {
+        allErrors.push(e);
+        results.functions = {
+          successfullyPushed: 0,
+          successfullyDeployed: 0,
+          failedDeployments: [],
+          errors: [e],
+        };
       }
     }
 
-    const { attributes } = await paginate(
-      async (args: any) => {
-        const databasesService = await getDatabasesService();
-        return await databasesService.listAttributes(
-          args.databaseId,
-          args.collectionId,
-          args.queries || [],
+    // 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.`,
         );
-      },
-      {
-        databaseId,
-        collectionId,
-      },
-      100,
-      "attributes",
-    );
-
-    const ready = attributes
-      .filter((attribute: any) => {
-        if (attributeKeys.includes(attribute.key)) {
-          if (["stuck", "failed"].includes(attribute.status)) {
-            throw new Error(`Attribute '${attribute.key}' failed!`);
-          }
-
-          return attribute.status === "available";
-        }
-
-        return false;
-      })
-      .map((attribute: any) => attribute.key);
-
-    if (ready.length === attributeKeys.length) {
-      return true;
+        results.sites = result;
+        allErrors.push(...result.errors);
+      } catch (e: any) {
+        allErrors.push(e);
+        results.sites = {
+          successfullyPushed: 0,
+          successfullyDeployed: 0,
+          failedDeployments: [],
+          errors: [e],
+        };
+      }
     }
 
-    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
-
-    return await awaitPools.expectAttributes(
-      databaseId,
-      collectionId,
-      attributeKeys,
-      iteration + 1,
-    );
-  },
-  deleteIndexes: async (
-    databaseId: string,
-    collectionId: string,
-    indexesKeys: any[],
-    iteration: number = 1,
-  ): Promise<boolean> => {
-    if (iteration > pollMaxDebounces) {
-      return false;
+    // 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: any) {
+        allErrors.push(e);
+        results.tables = { successfullyPushed: 0, errors: [e] };
+      }
     }
 
-    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",
+    // 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: any) => {
+            const database = config.databases?.find(
+              (db: any) => 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: any) {
+        allErrors.push(e);
+        results.collections = { successfullyPushed: 0, errors: [e] };
       }
     }
 
-    const { indexes } = await paginate(
-      async (args: any) => {
-        const databasesService = await getDatabasesService();
-        return await databasesService.listIndexes(
-          args.databaseId,
-          args.collectionId,
-          args.queries || [],
-        );
-      },
-      {
-        databaseId,
-        collectionId,
-      },
-      100,
-      "indexes",
-    );
+    return {
+      results,
+      errors: allErrors,
+    };
+  }
 
-    const ready = indexesKeys.filter((index: any) =>
-      indexes.includes(index.key),
-    );
+  public async pushSettings(config: {
+    projectId: string;
+    projectName?: string;
+    settings?: SettingsType;
+  }): Promise<void> {
+    const projectsService = await getProjectsService(this.consoleClient);
+    const projectId = config.projectId;
+    const projectName = config.projectName;
+    const settings = config.settings ?? {};
 
-    if (ready.length === 0) {
-      return true;
+    if (projectName) {
+      this.log("Applying project name ...");
+      await projectsService.update({
+        projectId: projectId,
+        name: projectName,
+      });
     }
 
-    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
-
-    return await awaitPools.expectIndexes(
-      databaseId,
-      collectionId,
-      indexesKeys,
-      iteration + 1,
-    );
-  },
-  expectIndexes: async (
-    databaseId: string,
-    collectionId: string,
-    indexKeys: string[],
-    iteration: number = 1,
-  ): Promise<boolean> => {
-    if (iteration > pollMaxDebounces) {
-      return false;
+    if (settings.services) {
+      this.log("Applying service statuses ...");
+      for (let [service, status] of Object.entries(settings.services)) {
+        await projectsService.updateServiceStatus({
+          projectId: projectId,
+          service: service as ApiService,
+          status: status,
+        });
+      }
     }
 
-    if (pollMaxDebounces === POLL_DEFAULT_VALUE) {
-      let steps = Math.max(1, Math.ceil(indexKeys.length / STEP_SIZE));
-      if (steps > 1 && iteration === 1) {
-        pollMaxDebounces *= steps;
+    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,
+        });
+      }
 
-        log(
-          "Creating a large number of indexes, increasing timeout to " +
-            (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
-            " minutes",
-        );
+      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 as AuthMethod,
+            status: status,
+          });
+        }
       }
     }
+  }
 
-    const { indexes } = await paginate(
-      async (args: any) => {
-        const databasesService = await getDatabasesService();
-        return await databasesService.listIndexes(
-          args.databaseId,
-          args.collectionId,
-          args.queries || [],
-        );
-      },
-      {
-        databaseId,
-        collectionId,
-      },
-      100,
-      "indexes",
-    );
+  public async pushBuckets(buckets: any[]): Promise<{
+    successfullyPushed: number;
+    errors: any[];
+  }> {
+    let successfullyPushed = 0;
+    const errors: any[] = [];
 
-    const ready = indexes
-      .filter((index: any) => {
-        if (indexKeys.includes(index.key)) {
-          if (["stuck", "failed"].includes(index.status)) {
-            throw new Error(`Index '${index.key}' failed!`);
-          }
+    for (const bucket of buckets) {
+      try {
+        this.log(`Pushing bucket ${chalk.bold(bucket["name"])} ...`);
+        const storageService = await getStorageService(this.projectClient);
 
-          return index.status === "available";
+        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: unknown) {
+          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;
+          }
         }
 
-        return false;
-      })
-      .map((index: any) => index.key);
-
-    if (ready.length >= indexKeys.length) {
-      return true;
+        successfullyPushed++;
+      } catch (e: any) {
+        errors.push(e);
+        this.error(`Failed to push bucket ${bucket["name"]}: ${e.message}`);
+      }
     }
 
-    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
-
-    return await awaitPools.expectIndexes(
-      databaseId,
-      collectionId,
-      indexKeys,
-      iteration + 1,
-    );
-  },
-};
-
-const getConfirmation = async (): Promise<boolean> => {
-  if (cliConfig.force) {
-    return true;
+    return {
+      successfullyPushed,
+      errors,
+    };
   }
 
-  async function fixConfirmation(): Promise<string> {
-    const answers = await inquirer.prompt(questionPushChangesConfirmation);
-    if (answers.changes !== "YES" && answers.changes !== "NO") {
-      return await fixConfirmation();
-    }
+  public async pushTeams(teams: any[]): Promise<{
+    successfullyPushed: number;
+    errors: any[];
+  }> {
+    let successfullyPushed = 0;
+    const errors: any[] = [];
 
-    return answers.changes;
-  }
+    for (const team of teams) {
+      try {
+        this.log(`Pushing team ${chalk.bold(team["name"])} ...`);
+        const teamsService = await getTeamsService(this.projectClient);
 
-  let answers = await inquirer.prompt(questionPushChanges);
+        try {
+          await teamsService.get(team["$id"]);
+          await teamsService.updateName({
+            teamId: team["$id"],
+            name: team.name,
+          });
+        } catch (e: unknown) {
+          if (e instanceof AppwriteException && Number(e.code) === 404) {
+            await teamsService.create({
+              teamId: team["$id"],
+              name: team.name,
+            });
+          } else {
+            throw e;
+          }
+        }
 
-  if (answers.changes !== "YES" && answers.changes !== "NO") {
-    answers.changes = await fixConfirmation();
-  }
+        successfullyPushed++;
+      } catch (e: any) {
+        errors.push(e);
+        this.error(`Failed to push team ${team["name"]}: ${e.message}`);
+      }
+    }
 
-  if (answers.changes === "YES") {
-    return true;
+    return {
+      successfullyPushed,
+      errors,
+    };
   }
 
-  warn("Skipping push action. Changes were not applied.");
-  return false;
-};
-const isEmpty = (value: any): boolean =>
-  value === null ||
-  value === undefined ||
-  (typeof value === "string" && value.trim().length === 0) ||
-  (Array.isArray(value) && value.length === 0);
-
-const approveChanges = async (
-  resource: any[],
-  resourceGetFunction: Function,
-  keys: Set<string>,
-  resourceName: string,
-  resourcePlural: string,
-  skipKeys: string[] = [],
-  secondId: string = "",
-  secondResourceName: string = "",
-): Promise<boolean> => {
-  log("Checking for changes ...");
-  const changes: any[] = [];
-
-  await Promise.all(
-    resource.map(async (localResource) => {
+  public async pushMessagingTopics(topics: any[]): Promise<{
+    successfullyPushed: number;
+    errors: any[];
+  }> {
+    let successfullyPushed = 0;
+    const errors: any[] = [];
+
+    for (const topic of topics) {
       try {
-        const options: Record<string, any> = {
-          [resourceName]: localResource["$id"],
-        };
+        this.log(`Pushing topic ${chalk.bold(topic["name"])} ...`);
+        const messagingService = await getMessagingService(this.projectClient);
 
-        if (secondId !== "" && secondResourceName !== "") {
-          options[secondResourceName] = localResource[secondId];
+        try {
+          await messagingService.getTopic(topic["$id"]);
+          await messagingService.updateTopic({
+            topicId: topic["$id"],
+            name: topic.name,
+            subscribe: topic.subscribe,
+          });
+        } catch (e: unknown) {
+          if (e instanceof AppwriteException && Number(e.code) === 404) {
+            await messagingService.createTopic({
+              topicId: topic["$id"],
+              name: topic.name,
+              subscribe: topic.subscribe,
+            });
+          } else {
+            throw e;
+          }
         }
 
-        const remoteResource = await resourceGetFunction(options);
+        this.success(`Pushed ${topic.name} ( ${topic["$id"]} )`);
+        successfullyPushed++;
+      } catch (e: any) {
+        errors.push(e);
+        this.error(`Failed to push topic ${topic["name"]}: ${e.message}`);
+      }
+    }
+
+    return {
+      successfullyPushed,
+      errors,
+    };
+  }
+
+  public async pushFunctions(
+    functions: any[],
+    options: {
+      async?: boolean;
+      code?: boolean;
+      withVariables?: boolean;
+    } = {},
+  ): Promise<{
+    successfullyPushed: number;
+    successfullyDeployed: number;
+    failedDeployments: any[];
+    errors: any[];
+  }> {
+    const { async: asyncDeploy, code, withVariables } = options;
+
+    Spinner.start(false);
+    let successfullyPushed = 0;
+    let successfullyDeployed = 0;
+    const failedDeployments: any[] = [];
+    const errors: any[] = [];
 
-        for (let [key, value] of Object.entries(
-          whitelistKeys(remoteResource, keys),
-        )) {
-          if (skipKeys.includes(key)) {
-            continue;
-          }
+    await Promise.all(
+      functions.map(async (func: any) => {
+        let response: any = {};
+
+        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}`,
+        });
 
-          if (isEmpty(value) && isEmpty(localResource[key])) {
-            continue;
+        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 (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 as string[]).join("\n")),
-                local: chalk.green(localResource[key].join("\n")),
-              });
-            }
-          } else if (value !== localResource[key]) {
-            changes.push({
-              id: localResource["$id"],
-              key,
-              remote: chalk.red(value),
-              local: chalk.green(localResource[key]),
+          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: any) {
+          if (Number(e.code) === 404) {
+            functionExists = false;
+          } else {
+            errors.push(e);
+            updaterRow.fail({
+              errorMessage:
+                e.message ?? "General error occurs please try again",
             });
+            return;
           }
         }
-      } catch (e: any) {
-        if (Number(e.code) !== 404) {
-          throw e;
-        }
-      }
-    }),
-  );
 
-  if (changes.length === 0) {
-    return true;
-  }
+        if (!functionExists) {
+          updaterRow
+            .update({ status: "Creating" })
+            .replaceSpinner(SPINNER_DOTS);
 
-  drawTable(changes);
-  if ((await getConfirmation()) === true) {
-    return true;
-  }
+          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,
+            });
 
-  success(`Successfully pushed 0 ${resourcePlural}.`);
-  return false;
-};
+            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;
+            }
 
-const getObjectChanges = <T extends Record<string, any>>(
-  remote: T,
-  local: T,
-  index: keyof T,
-  what: string,
-): ObjectChange[] => {
-  const changes: ObjectChange[] = [];
+            try {
+              const proxyService = await getProxyService(this.projectClient);
+              await proxyService.createFunctionRule(domain, func.$id);
+            } catch (err) {
+              this.error("Error creating function rule.");
+              throw err;
+            }
 
-  const remoteNested = remote[index];
-  const localNested = local[index];
+            updaterRow.update({ status: "Created" });
+          } catch (e: any) {
+            errors.push(e);
+            updaterRow.fail({
+              errorMessage:
+                e.message ?? "General error occurs please try again",
+            });
+            return;
+          }
+        }
 
-  if (
-    remoteNested &&
-    localNested &&
-    typeof remoteNested === "object" &&
-    !Array.isArray(remoteNested) &&
-    typeof localNested === "object" &&
-    !Array.isArray(localNested)
-  ) {
-    const remoteObj = remoteNested as Record<string, ComparableValue>;
-    const localObj = localNested as Record<string, ComparableValue>;
+        if (withVariables) {
+          updaterRow
+            .update({ status: "Updating variables" })
+            .replaceSpinner(SPINNER_DOTS);
 
-    for (const [service, status] of Object.entries(remoteObj)) {
-      const localValue = localObj[service];
-      let valuesEqual = false;
+          const functionsServiceForVars = await getFunctionsService(
+            this.projectClient,
+          );
+          const { variables } = await paginate(
+            async (args: any) => {
+              return await functionsServiceForVars.listVariables({
+                functionId: args.functionId,
+              });
+            },
+            {
+              functionId: func["$id"],
+            },
+            100,
+            "variables",
+          );
 
-      if (Array.isArray(status) && Array.isArray(localValue)) {
-        valuesEqual = JSON.stringify(status) === JSON.stringify(localValue);
-      } else {
-        valuesEqual = status === localValue;
-      }
+          await Promise.all(
+            variables.map(async (variable: any) => {
+              const functionsServiceDel = await getFunctionsService(
+                this.projectClient,
+              );
+              await functionsServiceDel.deleteVariable({
+                functionId: func["$id"],
+                variableId: variable["$id"],
+              });
+            }),
+          );
 
-      if (!valuesEqual) {
-        changes.push({
-          group: what,
-          setting: service,
-          remote: chalk.red(String(status ?? "")),
-          local: chalk.green(String(localValue ?? "")),
-        });
-      }
-    }
-  }
-
-  return changes;
-};
-
-const createAttribute = async (
-  databaseId: string,
-  collectionId: string,
-  attribute: any,
-): Promise<any> => {
-  const databasesService = await getDatabasesService();
-  switch (attribute.type) {
-    case "string":
-      switch (attribute.format) {
-        case "email":
-          return databasesService.createEmailAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            required: attribute.required,
-            xdefault: attribute.default,
-            array: attribute.array,
-          });
-        case "url":
-          return databasesService.createUrlAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            required: attribute.required,
-            xdefault: attribute.default,
-            array: attribute.array,
-          });
-        case "ip":
-          return databasesService.createIpAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            required: attribute.required,
-            xdefault: attribute.default,
-            array: attribute.array,
-          });
-        case "enum":
-          return databasesService.createEnumAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            elements: attribute.elements,
-            required: attribute.required,
-            xdefault: attribute.default,
-            array: attribute.array,
-          });
-        default:
-          return databasesService.createStringAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            size: attribute.size,
-            required: attribute.required,
-            xdefault: attribute.default,
-            array: attribute.array,
-            encrypt: attribute.encrypt,
-          });
-      }
-    case "integer":
-      return databasesService.createIntegerAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        min: attribute.min,
-        max: attribute.max,
-        xdefault: attribute.default,
-        array: attribute.array,
-      });
-    case "double":
-      return databasesService.createFloatAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        min: attribute.min,
-        max: attribute.max,
-        xdefault: attribute.default,
-        array: attribute.array,
-      });
-    case "boolean":
-      return databasesService.createBooleanAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-        array: attribute.array,
-      });
-    case "datetime":
-      return databasesService.createDatetimeAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-        array: attribute.array,
-      });
-    case "relationship":
-      return databasesService.createRelationshipAttribute({
-        databaseId,
-        collectionId,
-        relatedCollectionId:
-          attribute.relatedTable ?? attribute.relatedCollection,
-        type: attribute.relationType,
-        twoWay: attribute.twoWay,
-        key: attribute.key,
-        twoWayKey: attribute.twoWayKey,
-        onDelete: attribute.onDelete,
-      });
-    case "point":
-      return databasesService.createPointAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-      });
-    case "linestring":
-      return databasesService.createLineAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-      });
-    case "polygon":
-      return databasesService.createPolygonAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-      });
-    default:
-      throw new Error(`Unsupported attribute type: ${attribute.type}`);
-  }
-};
-
-const updateAttribute = async (
-  databaseId: string,
-  collectionId: string,
-  attribute: any,
-): Promise<any> => {
-  const databasesService = await getDatabasesService();
-  switch (attribute.type) {
-    case "string":
-      switch (attribute.format) {
-        case "email":
-          return databasesService.updateEmailAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            required: attribute.required,
-            xdefault: attribute.default,
-          });
-        case "url":
-          return databasesService.updateUrlAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            required: attribute.required,
-            xdefault: attribute.default,
-          });
-        case "ip":
-          return databasesService.updateIpAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            required: attribute.required,
-            xdefault: attribute.default,
-          });
-        case "enum":
-          return databasesService.updateEnumAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            elements: attribute.elements,
-            required: attribute.required,
-            xdefault: attribute.default,
-          });
-        default:
-          return databasesService.updateStringAttribute({
-            databaseId,
-            collectionId,
-            key: attribute.key,
-            required: attribute.required,
-            xdefault: attribute.default,
-          });
-      }
-    case "integer":
-      return databasesService.updateIntegerAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        min: attribute.min,
-        max: attribute.max,
-        xdefault: attribute.default,
-      });
-    case "double":
-      return databasesService.updateFloatAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        min: attribute.min,
-        max: attribute.max,
-        xdefault: attribute.default,
-      });
-    case "boolean":
-      return databasesService.updateBooleanAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-      });
-    case "datetime":
-      return databasesService.updateDatetimeAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-      });
-    case "relationship":
-      return databasesService.updateRelationshipAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        onDelete: attribute.onDelete,
-      });
-    case "point":
-      return databasesService.updatePointAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-      });
-    case "linestring":
-      return databasesService.updateLineAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-      });
-    case "polygon":
-      return databasesService.updatePolygonAttribute({
-        databaseId,
-        collectionId,
-        key: attribute.key,
-        required: attribute.required,
-        xdefault: attribute.default,
-      });
-    default:
-      throw new Error(`Unsupported attribute type: ${attribute.type}`);
-  }
-};
-const deleteAttribute = async (
-  collection: any,
-  attribute: any,
-  isIndex: boolean = false,
-): Promise<void> => {
-  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: any, b: any): boolean => {
-  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: any,
-  local: any,
-  reason: string,
-  key: string,
-): string => {
-  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: any,
-  local: any,
-  collection: any,
-  recreating: boolean = true,
-): AttributeChange | undefined => {
-  if (local === undefined) {
-    return undefined;
-  }
-
-  const keyName = `${chalk.yellow(local.key)} in ${collection.name} (${collection["$id"]})`;
-  const action = chalk.cyan(recreating ? "recreating" : "changing");
-  let reason = "";
-  let attribute = recreating ? remote : local;
-
-  for (let key of Object.keys(remote)) {
-    if (!KeysAttributes.has(key)) {
-      continue;
-    }
-
-    if (changeableKeys.includes(key)) {
-      if (!recreating) {
-        reason = compareAttribute(remote[key], local[key], reason, key);
-      }
-      continue;
-    }
-
-    if (!recreating) {
-      continue;
-    }
-
-    reason = compareAttribute(remote[key], local[key], reason, key);
-  }
-
-  return reason === ""
-    ? undefined
-    : { key: keyName, attribute, reason, action };
-};
-
-/**
- * Check if attributes contain the given attribute
- */
-const attributesContains = (attribute: any, attributes: any[]): any =>
-  attributes.find((attr) => attr.key === attribute.key);
-
-const generateChangesObject = (
-  attribute: any,
-  collection: any,
-  isAdding: boolean,
-): AttributeChange => {
-  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: any[],
-  localAttributes: any[],
-  collection: any,
-  isIndex: boolean = false,
-): Promise<any[]> => {
-  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) as AttributeChange[];
-  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,
-    ) as AttributeChange[];
-
-  let changedAttributes: any[] = [];
-  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: any) => attribute.key),
-    ...deletingAttributes.map((attribute: any) => 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: any[],
-  collection: any,
-): Promise<void> => {
-  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: any) => index.key),
-  );
-
-  if (!result) {
-    throw new Error("Index creation timed out.");
-  }
-
-  success(`Created ${indexes.length} indexes`);
-};
-
-const createAttributes = async (
-  attributes: any[],
-  collection: any,
-): Promise<void> => {
-  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: any) => attribute.side !== "child")
-      .map((attribute: any) => attribute.key),
-  );
-
-  if (!result) {
-    throw new Error(`Attribute creation timed out.`);
-  }
-
-  success(`Created ${attributes.length} attributes`);
-};
-
-const createColumns = async (columns: any[], table: any): Promise<void> => {
-  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: any) => column.side !== "child")
-      .map((column: any) => column.key),
-  );
-
-  if (!result) {
-    throw new Error(`Column creation timed out.`);
-  }
-
-  success(`Created ${columns.length} columns`);
-};
-
-const pushResources = async ({
-  skipDeprecated = false,
-}: PushResourcesOptions = {}): Promise<void> => {
-  const actions: Record<string, (options?: any) => Promise<void>> = {
-    settings: pushSettings,
-    functions: pushFunction,
-    sites: pushSite,
-    collections: pushCollection,
-    tables: pushTable,
-    buckets: pushBucket,
-    teams: pushTeam,
-    messages: pushMessagingTopic,
-  };
-
-  if (skipDeprecated) {
-    delete actions.collections;
-  }
-
-  if (cliConfig.all) {
-    for (let action of Object.values(actions)) {
-      await action();
-    }
-  } else {
-    const answers = await inquirer.prompt(questionsPushResources);
-
-    const action = actions[answers.resource];
-    if (action !== undefined) {
-      await action();
-    }
-  }
-};
-
-const pushSettings = async (): Promise<void> => {
-  checkDeployConditions(localConfig);
-
-  try {
-    const projectsService = await getProjectsService();
-    let response = await projectsService.get(
-      localConfig.getProject().projectId,
-    );
-
-    const remoteSettings = localConfig.createSettingsObject(response ?? {});
-    const localSettings = localConfig.getProject().projectSettings ?? {};
-
-    log("Checking for changes ...");
-    const changes: any[] = [];
-
-    changes.push(
-      ...getObjectChanges(remoteSettings, localSettings, "services", "Service"),
-    );
-    changes.push(
-      ...getObjectChanges(
-        remoteSettings["auth"] ?? {},
-        localSettings["auth"] ?? {},
-        "methods",
-        "Auth method",
-      ),
-    );
-    changes.push(
-      ...getObjectChanges(
-        remoteSettings["auth"] ?? {},
-        localSettings["auth"] ?? {},
-        "security",
-        "Auth security",
-      ),
-    );
-
-    if (changes.length > 0) {
-      drawTable(changes);
-      if ((await getConfirmation()) !== true) {
-        success(`Successfully pushed 0 project settings.`);
-        return;
-      }
-    }
-  } catch (e) {}
-
-  try {
-    log("Pushing project settings ...");
-
-    const projectsService = await getProjectsService();
-    const projectId = localConfig.getProject().projectId;
-    const projectName = localConfig.getProject().projectName;
-    const settings = localConfig.getProject().projectSettings ?? {};
-
-    if (projectName) {
-      log("Applying project name ...");
-      await projectsService.update(projectId, projectName);
-    }
-
-    if (settings.services) {
-      log("Applying service statuses ...");
-      for (let [service, status] of Object.entries(settings.services)) {
-        await projectsService.updateServiceStatus(
-          projectId,
-          service as ApiService,
-          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 as AuthMethod,
-            status,
+          const envFileLocation = `${func["path"]}/.env`;
+          let envVariables: Array<{ key: string; value: string }> = [];
+          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,
+              });
+            }),
           );
         }
-      }
-    }
 
-    success(`Successfully pushed ${chalk.bold("all")} project settings.`);
-  } catch (e) {
-    throw e;
-  }
-};
-
-const pushSite = async ({
-  siteId,
-  async: asyncDeploy,
-  code,
-  withVariables,
-}: PushSiteOptions = {}): Promise<void> => {
-  process.chdir(localConfig.configDirectoryPath);
-
-  const siteIds: string[] = [];
-
-  if (siteId) {
-    siteIds.push(siteId);
-  } else if (cliConfig.all) {
-    checkDeployConditions(localConfig);
-    const sites = localConfig.getSites();
-    siteIds.push(
-      ...sites.map((site: any) => {
-        return site.$id;
-      }),
-    );
-  }
-
-  if (siteIds.length <= 0) {
-    const answers = await inquirer.prompt(questionsPushSites);
-    if (answers.sites) {
-      siteIds.push(...answers.sites);
-    }
-  }
-
-  if (siteIds.length === 0) {
-    log("No sites found.");
-    hint(
-      "Use 'appwrite pull sites' to synchronize existing one, or use 'appwrite init site' to create a new one.",
-    );
-    return;
-  }
+        if (code === false) {
+          successfullyPushed++;
+          successfullyDeployed++;
+          updaterRow.update({ status: "Pushed" });
+          updaterRow.stopSpinner();
+          return;
+        }
 
-  let sites = siteIds.map((id: string) => {
-    const sites = localConfig.getSites();
-    const site = sites.find((s: any) => s.$id === id);
+        try {
+          updaterRow.update({ status: "Pushing" }).replaceSpinner(SPINNER_DOTS);
+          const functionsServiceDeploy = await getFunctionsService(
+            this.projectClient,
+          );
 
-    if (!site) {
-      throw new Error("Site '" + id + "' not found.");
-    }
+          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,
+          });
 
-    return site;
-  });
+          response = result.deployment;
+          updaterRow.update({ status: "Pushed" });
 
-  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);
-    }
-  }
+          deploymentCreated = true;
+          successfullyPushed++;
+        } catch (e: any) {
+          errors.push(e);
 
-  if (
-    !(await approveChanges(
-      sites,
-      async (args: any) => {
-        const sitesService = await getSitesService();
-        return await sitesService.get({ siteId: args.siteId });
-      },
-      KeysSite,
-      "siteId",
-      "sites",
-      ["vars"],
-    ))
-  ) {
-    return;
-  }
+          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.",
+              });
+          }
+        }
 
-  log("Pushing sites ...");
+        if (deploymentCreated && !asyncDeploy) {
+          try {
+            const deploymentId = response["$id"];
+            updaterRow.update({
+              status: "Deploying",
+              end: "Checking deployment status...",
+            });
 
-  Spinner.start(false);
-  let successfullyPushed = 0;
-  let successfullyDeployed = 0;
-  const failedDeployments: any[] = [];
-  const errors: any[] = [];
-
-  await Promise.all(
-    sites.map(async (site: any) => {
-      let response: any = {};
-
-      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}`,
-      });
+            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;
+              }
 
-      updaterRow.update({ status: "Getting" }).startSpinner(SPINNER_DOTS);
+              const functionsServicePoll = await getFunctionsService(
+                this.projectClient,
+              );
+              response = await functionsServicePoll.getDeployment({
+                functionId: func["$id"],
+                deploymentId: deploymentId,
+              });
 
-      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;
+              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: any) {
+            errors.push(e);
+            updaterRow.fail({
+              errorMessage:
+                e.message ?? "Unknown error occurred. Please try again",
+            });
+          }
         }
 
-        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,
+        updaterRow.stopSpinner();
+      }),
+    );
+
+    Spinner.stop();
+
+    return {
+      successfullyPushed,
+      successfullyDeployed,
+      failedDeployments,
+      errors,
+    };
+  }
+
+  public async pushSites(
+    sites: any[],
+    options: {
+      async?: boolean;
+      code?: boolean;
+      withVariables?: boolean;
+    } = {},
+  ): Promise<{
+    successfullyPushed: number;
+    successfullyDeployed: number;
+    failedDeployments: any[];
+    errors: any[];
+  }> {
+    const { async: asyncDeploy, code, withVariables } = options;
+
+    Spinner.start(false);
+    let successfullyPushed = 0;
+    let successfullyDeployed = 0;
+    const failedDeployments: any[] = [];
+    const errors: any[] = [];
+
+    await Promise.all(
+      sites.map(async (site: any) => {
+        let response: any = {};
+
+        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}`,
         });
-      } catch (e: any) {
-        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);
+        updaterRow.update({ status: "Getting" }).startSpinner(SPINNER_DOTS);
 
+        const sitesService = await getSitesService(this.projectClient);
         try {
-          response = await sitesService.create({
-            siteId: site.$id,
+          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,
@@ -1588,617 +1014,774 @@ const pushSite = async ({
             adapter: site.adapter,
             specification: site.specification,
           });
+        } catch (e: any) {
+          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);
 
-          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;
+            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(
+                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: any) {
+            errors.push(e);
+            updaterRow.fail({
+              errorMessage:
+                e.message ?? "General error occurs please try again",
+            });
+            return;
           }
+        }
+
+        if (withVariables) {
+          updaterRow
+            .update({ status: "Creating variables" })
+            .replaceSpinner(SPINNER_DOTS);
+
+          const sitesServiceForVars = await getSitesService(this.projectClient);
+          const { variables } = await paginate(
+            async (args: any) => {
+              return await sitesServiceForVars.listVariables({
+                siteId: args.siteId,
+              });
+            },
+            {
+              siteId: site["$id"],
+            },
+            100,
+            "variables",
+          );
+
+          await Promise.all(
+            variables.map(async (variable: any) => {
+              const sitesServiceDel = await getSitesService(this.projectClient);
+              await sitesServiceDel.deleteVariable({
+                siteId: site["$id"],
+                variableId: variable["$id"],
+              });
+            }),
+          );
 
+          const envFileLocation = `${site["path"]}/.env`;
+          let envVariables: Array<{ key: string; value: string }> = [];
           try {
-            const proxyService = await getProxyService();
-            const rule = await proxyService.createSiteRule(domain, site.$id);
+            if (fs.existsSync(envFileLocation)) {
+              const envObject = parseDotenv(
+                fs.readFileSync(envFileLocation, "utf8"),
+              );
+              envVariables = Object.entries(envObject || {}).map(
+                ([key, value]) => ({ key, value }),
+              );
+            }
           } catch (error) {
-            console.error("Error creating site rule.");
-            throw 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,
+              });
+            }),
+          );
+        }
+
+        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,
+          });
 
-          updaterRow.update({ status: "Created" });
+          response = result.deployment;
+          updaterRow.update({ status: "Pushed" });
+          deploymentCreated = true;
+          successfullyPushed++;
         } catch (e: any) {
           errors.push(e);
-          updaterRow.fail({
-            errorMessage: e.message ?? "General error occurs please try again",
-          });
-          return;
+
+          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 (withVariables) {
-        updaterRow
-          .update({ status: "Creating variables" })
-          .replaceSpinner(SPINNER_ARC);
+        if (deploymentCreated && !asyncDeploy) {
+          try {
+            const deploymentId = response["$id"];
+            updaterRow.update({
+              status: "Deploying",
+              end: "Checking deployment status...",
+            });
 
-        const sitesService = await getSitesService();
-        const { variables } = await paginate(
-          async (args: any) => {
-            return await sitesService.listVariables({ siteId: args.siteId });
-          },
-          {
-            siteId: site["$id"],
-          },
-          100,
-          "variables",
-        );
+            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;
+              }
 
-        await Promise.all(
-          variables.map(async (variable: any) => {
-            const sitesService = await getSitesService();
-            await sitesService.deleteVariable({
-              siteId: site["$id"],
-              variableId: variable["$id"],
+              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: any) {
+            errors.push(e);
+            updaterRow.fail({
+              errorMessage:
+                e.message ?? "Unknown error occurred. Please try again",
             });
-          }),
-        );
+          }
+        }
+
+        updaterRow.stopSpinner();
+      }),
+    );
+
+    Spinner.stop();
+
+    return {
+      successfullyPushed,
+      successfullyDeployed,
+      failedDeployments,
+      errors,
+    };
+  }
+
+  public async pushTables(
+    tables: any[],
+    options: PushTableOptions = {},
+  ): Promise<{
+    successfullyPushed: number;
+    errors: any[];
+  }> {
+    const { attempts, skipConfirmation = false } = options;
+    const pollMaxDebounces = attempts ?? POLL_DEFAULT_VALUE;
+    const pools = new Pools(pollMaxDebounces);
+    const attributes = new Attributes(pools, skipConfirmation);
 
-        const envFileLocation = `${site["path"]}/.env`;
-        let envVariables: Array<{ key: string; value: string }> = [];
+    let tablesChanged = new Set();
+    const errors: any[] = [];
+
+    // Parallel tables actions
+    await Promise.all(
+      tables.map(async (table: any) => {
         try {
-          if (fs.existsSync(envFileLocation)) {
-            const envObject = parseDotenv(
-              fs.readFileSync(envFileLocation, "utf8"),
+          const tablesService = await getTablesDBService(this.projectClient);
+          const remoteTable = await tablesService.getTable({
+            databaseId: table["databaseId"],
+            tableId: table["$id"],
+          });
+
+          const changes: string[] = [];
+          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"],
+            });
+
+            this.success(
+              `Updated ${table.name} ( ${table["$id"]} ) - ${changes.join(", ")}`,
             );
-            envVariables = Object.entries(envObject || {}).map(
-              ([key, value]) => ({ key, value }),
+            tablesChanged.add(table["$id"]);
+          }
+          table.remoteVersion = remoteTable;
+
+          table.isExisted = true;
+        } catch (e: any) {
+          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,
+            });
+
+            this.success(`Created ${table.name} ( ${table["$id"]} )`);
+            tablesChanged.add(table["$id"]);
+          } else {
+            errors.push(e);
+            throw e;
           }
-        } 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,
-            });
-          }),
+      }),
+    );
+
+    // 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 as Collection,
+        );
+        indexes = await attributes.attributesToCreate(
+          table.remoteVersion.indexes,
+          table.indexes,
+          table as Collection,
+          true,
         );
-      }
 
-      if (code === false) {
-        successfullyPushed++;
-        successfullyDeployed++;
-        updaterRow.update({ status: "Pushed" });
-        updaterRow.stopSpinner();
-        return;
+        if (
+          Array.isArray(columns) &&
+          columns.length <= 0 &&
+          Array.isArray(indexes) &&
+          indexes.length <= 0
+        ) {
+          continue;
+        }
       }
 
-      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,
-        });
+      this.log(
+        `Pushing table ${table.name} ( ${table["databaseId"]} - ${table["$id"]} ) attributes`,
+      );
 
-        updaterRow.update({ status: "Pushed" });
-        deploymentCreated = true;
-        successfullyPushed++;
-      } catch (e: any) {
+      try {
+        await attributes.createColumns(columns, table as Collection);
+      } catch (e) {
         errors.push(e);
+        throw 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.",
-            });
-        }
+      try {
+        await attributes.createIndexes(indexes, table as Collection);
+      } catch (e) {
+        errors.push(e);
+        throw e;
       }
+      tablesChanged.add(table["$id"]);
+      this.success(`Successfully pushed ${table.name} ( ${table["$id"]} )`);
+    }
+
+    return {
+      successfullyPushed: tablesChanged.size,
+      errors,
+    };
+  }
+
+  public async pushCollections(
+    collections: any[],
+    options: { skipConfirmation?: boolean } = {},
+  ): Promise<{
+    successfullyPushed: number;
+    errors: any[];
+  }> {
+    const { skipConfirmation = false } = options;
+    const pools = new Pools(POLL_DEFAULT_VALUE);
+    const attributes = new Attributes(pools, skipConfirmation);
+
+    const errors: any[] = [];
+
+    const databases = Array.from(
+      new Set(collections.map((collection: any) => collection["databaseId"])),
+    );
 
-      if (deploymentCreated && !asyncDeploy) {
+    // Parallel db actions
+    await Promise.all(
+      databases.map(async (databaseId: any) => {
+        const databasesService = await getDatabasesService(this.projectClient);
         try {
-          const deploymentId = response["$id"];
-          updaterRow.update({
-            status: "Deploying",
-            end: "Checking deployment status...",
-          });
-          let pollChecks = 0;
+          const database = await databasesService.get(databaseId);
 
-          while (true) {
-            const sitesService = await getSitesService();
-            response = await sitesService.getDeployment({
-              siteId: site["$id"],
-              deploymentId: deploymentId,
-            });
+          // 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: any) => c.databaseId === databaseId)
+              ?.databaseName ?? databaseId;
 
-            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;
-              }
+          if (database.name !== localDatabaseName) {
+            await databasesService.update(databaseId, localDatabaseName);
 
-              updaterRow.update({ status: "Deployed", end: url });
+            this.success(`Updated ${localDatabaseName} ( ${databaseId} ) name`);
+          }
+        } catch (err: any) {
+          if (Number(err.code) === 404) {
+            this.log(`Database ${databaseId} not found. Creating it now ...`);
 
-              break;
-            } else if (status === "failed") {
-              failedDeployments.push({
-                name: site["name"],
-                $id: site["$id"],
-                deployment: response["$id"],
-              });
-              updaterRow.fail({ errorMessage: `Failed to deploy` });
+            const localDatabaseName =
+              collections.find((c: any) => c.databaseId === databaseId)
+                ?.databaseName ?? databaseId;
 
-              break;
-            } else {
-              updaterRow.update({
-                status: "Deploying",
-                end: `Current status: ${status}`,
-              });
-            }
+            await databasesService.create(databaseId, localDatabaseName);
+          } else {
+            throw err;
+          }
+        }
+      }),
+    );
 
-            pollChecks++;
-            await new Promise((resolve) =>
-              setTimeout(resolve, POLL_DEBOUNCE * 1.5),
+    // Parallel collection actions
+    await Promise.all(
+      collections.map(async (collection: any) => {
+        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: any) {
-          errors.push(e);
-          updaterRow.fail({
-            errorMessage:
-              e.message ?? "Unknown error occurred. Please try again",
-          });
+          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;
+          }
         }
+      }),
+    );
+
+    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 as Collection,
+        );
+        indexes = await attributes.attributesToCreate(
+          collection.remoteVersion.indexes,
+          collection.indexes,
+          collection as Collection,
+          true,
+        );
+
+        if (
+          Array.isArray(collectionAttributes) &&
+          collectionAttributes.length <= 0 &&
+          Array.isArray(indexes) &&
+          indexes.length <= 0
+        ) {
+          continue;
+        }
+      }
+
+      this.log(
+        `Pushing collection ${collection.name} ( ${collection["databaseId"]} - ${collection["$id"]} ) attributes`,
+      );
+
+      try {
+        await attributes.createAttributes(
+          collectionAttributes,
+          collection as Collection,
+        );
+      } catch (e) {
+        errors.push(e);
+        throw e;
       }
 
-      updaterRow.stopSpinner();
-    }),
-  );
+      try {
+        await attributes.createIndexes(indexes, collection as 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): Promise<Push> {
+  const projectClient = await sdkForProject();
+  const consoleClient = await sdkForConsole();
+  return new Push(projectClient, consoleClient, silent);
+}
+
+const pushResources = async ({
+  skipDeprecated = false,
+}: {
+  skipDeprecated?: boolean;
+} = {}): Promise<void> => {
+  if (cliConfig.all) {
+    checkDeployConditions(localConfig);
+
+    const pushInstance = await createPushInstance();
+    const config = localConfig.getProject() as ConfigType;
+
+    await pushInstance.pushResources(config, {
+      skipDeprecated,
+      functionOptions: { code: true, withVariables: false },
+      siteOptions: { code: true, withVariables: false },
+    });
+  } else {
+    const actions: Record<string, (options?: any) => Promise<void>> = {
+      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) {
+      await action();
+    }
+  }
+};
+
+const pushSettings = async (): Promise<void> => {
+  checkDeployConditions(localConfig);
 
-  Spinner.stop();
+  try {
+    const projectsService = await getProjectsService();
+    let response = await projectsService.get(
+      localConfig.getProject().projectId,
+    );
 
-  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}`;
+    const remoteSettings = createSettingsObject(response);
+    const localSettings = localConfig.getProject().projectSettings ?? {};
 
-    error(
-      `Deployment of ${name} has failed. Check at ${failUrl} for more details\n`,
+    log("Checking for changes ...");
+    const changes: any[] = [];
+
+    changes.push(
+      ...getObjectChanges(remoteSettings, localSettings, "services", "Service"),
+    );
+    changes.push(
+      ...getObjectChanges(
+        remoteSettings["auth"] ?? {},
+        localSettings["auth"] ?? {},
+        "methods",
+        "Auth method",
+      ),
+    );
+    changes.push(
+      ...getObjectChanges(
+        remoteSettings["auth"] ?? {},
+        localSettings["auth"] ?? {},
+        "security",
+        "Auth security",
+      ),
     );
-  });
 
-  if (!asyncDeploy) {
-    if (successfullyPushed === 0) {
-      error("No sites were pushed.");
-    } else if (successfullyDeployed !== successfullyPushed) {
-      warn(
-        `Successfully pushed ${successfullyDeployed} of ${successfullyPushed} sites`,
-      );
-    } else {
-      success(`Successfully pushed ${successfullyPushed} sites.`);
+    if (changes.length > 0) {
+      drawTable(changes);
+      if ((await getConfirmation()) !== true) {
+        success(`Successfully pushed 0 project settings.`);
+        return;
+      }
     }
-  } else {
-    success(`Successfully pushed ${successfullyPushed} sites.`);
-  }
+  } catch (e) {}
 
-  if (cliConfig.verbose) {
-    errors.forEach((e) => {
-      console.error(e);
+  try {
+    log("Pushing project settings ...");
+
+    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) {
+    throw e;
   }
 };
 
-const pushFunction = async ({
-  functionId,
+const pushSite = async ({
+  siteId,
   async: asyncDeploy,
   code,
   withVariables,
-}: PushFunctionOptions = {}): Promise<void> => {
+}: PushSiteOptions = {}): Promise<void> => {
   process.chdir(localConfig.configDirectoryPath);
 
-  const functionIds: string[] = [];
+  const siteIds: string[] = [];
 
-  if (functionId) {
-    functionIds.push(functionId);
+  if (siteId) {
+    siteIds.push(siteId);
   } else if (cliConfig.all) {
     checkDeployConditions(localConfig);
-    const functions = localConfig.getFunctions();
-    functionIds.push(
-      ...functions.map((func: any) => {
-        return func.$id;
+    const sites = localConfig.getSites();
+    siteIds.push(
+      ...sites.map((site: any) => {
+        return site.$id;
       }),
     );
   }
 
-  if (functionIds.length <= 0) {
-    const answers = await inquirer.prompt(questionsPushFunctions);
-    if (answers.functions) {
-      functionIds.push(...answers.functions);
+  if (siteIds.length <= 0) {
+    const answers = await inquirer.prompt(questionsPushSites);
+    if (answers.sites) {
+      siteIds.push(...answers.sites);
     }
   }
 
-  if (functionIds.length === 0) {
-    log("No functions found.");
+  if (siteIds.length === 0) {
+    log("No sites found.");
     hint(
-      "Use 'appwrite pull functions' to synchronize existing one, or use 'appwrite init function' to create a new one.",
+      `Use '${EXECUTABLE_NAME} pull sites' to synchronize existing one, or use '${EXECUTABLE_NAME} init site' to create a new one.`,
     );
     return;
   }
 
-  let functions = functionIds.map((id: string) => {
-    const functions = localConfig.getFunctions();
-    const func = functions.find((f: any) => f.$id === id);
+  let sites = siteIds.map((id: string) => {
+    const sites = localConfig.getSites();
+    const site = sites.find((s: any) => s.$id === id);
 
-    if (!func) {
-      throw new Error("Function '" + id + "' not found.");
+    if (!site) {
+      throw new Error("Site '" + id + "' not found.");
     }
 
-    return func;
+    return site;
   });
 
-  log("Validating functions ...");
+  log("Validating sites ...");
   // 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.`);
+  for (let site of sites) {
+    if (!site.buildCommand) {
+      log(`Site ${site.name} is missing build command.`);
       const answers = await inquirer.prompt(questionsGetEntrypoint);
-      func.entrypoint = answers.entrypoint;
-      localConfig.addFunction(func);
+      site.buildCommand = answers.entrypoint;
+      localConfig.addSite(site);
     }
   }
 
   if (
     !(await approveChanges(
-      functions,
+      sites,
       async (args: any) => {
-        const functionsService = await getFunctionsService();
-        return await functionsService.get({ functionId: args.functionId });
+        const sitesService = await getSitesService();
+        return await sitesService.get({ siteId: args.siteId });
       },
-      KeysFunction,
-      "functionId",
-      "functions",
+      KeysSite,
+      "siteId",
+      "sites",
       ["vars"],
     ))
   ) {
     return;
   }
 
-  log("Pushing functions ...");
-
-  Spinner.start(false);
-  let successfullyPushed = 0;
-  let successfullyDeployed = 0;
-  const failedDeployments: any[] = [];
-  const errors: any[] = [];
-
-  await Promise.all(
-    functions.map(async (func: any) => {
-      let response: any = {};
-
-      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: any) {
-        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: any) {
-          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: any) => {
-            return await functionsService.listVariables({
-              functionId: args.functionId,
-            });
-          },
-          {
-            functionId: func["$id"],
-          },
-          100,
-          "variables",
-        );
-
-        await Promise.all(
-          variables.map(async (variable: any) => {
-            const functionsService = await getFunctionsService();
-            await functionsService.deleteVariable({
-              functionId: func["$id"],
-              variableId: variable["$id"],
-            });
-          }),
-        );
-
-        const envFileLocation = `${func["path"]}/.env`;
-        let envVariables: Array<{ key: string; value: string }> = [];
-        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: any) {
-        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: any) {
-          errors.push(e);
-          updaterRow.fail({
-            errorMessage:
-              e.message ?? "Unknown error occurred. Please try again",
-          });
-        }
-      }
+  log("Pushing sites ...");
 
-      updaterRow.stopSpinner();
-    }),
-  );
+  const pushInstance = await createPushInstance();
+  const result = await pushInstance.pushSites(sites, {
+    async: asyncDeploy,
+    code,
+    withVariables,
+  });
 
-  Spinner.stop();
+  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}`;
+    const failUrl = `${globalConfig.getEndpoint().slice(0, -3)}/console/project-${localConfig.getProject().projectId}/sites/site-${$id}/deployments/deployment-${deployment}`;
 
     error(
       `Deployment of ${name} has failed. Check at ${failUrl} for more details\n`,
@@ -2207,16 +1790,16 @@ const pushFunction = async ({
 
   if (!asyncDeploy) {
     if (successfullyPushed === 0) {
-      error("No functions were pushed.");
+      error("No sites were pushed.");
     } else if (successfullyDeployed !== successfullyPushed) {
       warn(
-        `Successfully pushed ${successfullyDeployed} of ${successfullyPushed} functions`,
+        `Successfully pushed ${successfullyDeployed} of ${successfullyPushed} sites`,
       );
     } else {
-      success(`Successfully pushed ${successfullyPushed} functions.`);
+      success(`Successfully pushed ${successfullyPushed} sites.`);
     }
   } else {
-    success(`Successfully pushed ${successfullyPushed} functions.`);
+    success(`Successfully pushed ${successfullyPushed} sites.`);
   }
 
   if (cliConfig.verbose) {
@@ -2226,194 +1809,140 @@ const pushFunction = async ({
   }
 };
 
-const checkAndApplyTablesDBChanges =
-  async (): Promise<TablesDBChangesResult> => {
-    log("Checking for tablesDB changes ...");
+const pushFunction = async ({
+  functionId,
+  async: asyncDeploy,
+  code,
+  withVariables,
+}: PushFunctionOptions = {}): Promise<void> => {
+  process.chdir(localConfig.configDirectoryPath);
+
+  const functionIds: string[] = [];
 
-    const localTablesDBs = localConfig.getTablesDBs();
-    const { databases: remoteTablesDBs } = await paginate(
-      async (args: any) => {
-        const tablesDBService = await getTablesDBService();
-        return await tablesDBService.list(args.queries || []);
-      },
-      {},
-      100,
-      "databases",
+  if (functionId) {
+    functionIds.push(functionId);
+  } else if (cliConfig.all) {
+    checkDeployConditions(localConfig);
+    const functions = localConfig.getFunctions();
+    functionIds.push(
+      ...functions.map((func: any) => {
+        return func.$id;
+      }),
     );
+  }
 
-    if (localTablesDBs.length === 0 && remoteTablesDBs.length === 0) {
-      return { applied: false, resyncNeeded: false };
-    }
-
-    const changes: any[] = [];
-    const toCreate: any[] = [];
-    const toUpdate: any[] = [];
-    const toDelete: any[] = [];
-
-    // Check for deletions - remote DBs that aren't in local config
-    for (const remoteDB of remoteTablesDBs) {
-      const localDB = localTablesDBs.find((db: any) => 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)",
-        });
-      }
+  if (functionIds.length <= 0) {
+    const answers = await inquirer.prompt(questionsPushFunctions);
+    if (answers.functions) {
+      functionIds.push(...answers.functions);
     }
+  }
 
-    // Check for additions and updates
-    for (const localDB of localTablesDBs) {
-      const remoteDB = remoteTablesDBs.find(
-        (db: any) => 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 (functionIds.length === 0) {
+    log("No functions found.");
+    hint(
+      `Use '${EXECUTABLE_NAME} pull functions' to synchronize existing one, or use '${EXECUTABLE_NAME} init function' to create a new one.`,
+    );
+    return;
+  }
 
-        if (remoteDB.enabled !== localDB.enabled) {
-          hasChanges = true;
-          changes.push({
-            id: localDB.$id,
-            action: chalk.yellow("updating"),
-            key: "Enabled",
-            remote: remoteDB.enabled,
-            local: localDB.enabled,
-          });
-        }
+  let functions = functionIds.map((id: string) => {
+    const functions = localConfig.getFunctions();
+    const func = functions.find((f: any) => f.$id === id);
 
-        if (hasChanges) {
-          toUpdate.push(localDB);
-        }
-      }
+    if (!func) {
+      throw new Error("Function '" + id + "' not found.");
     }
 
-    if (changes.length === 0) {
-      return { applied: false, resyncNeeded: false };
+    return func;
+  });
+
+  log("Validating functions ...");
+  for (let func of functions) {
+    if (!func.entrypoint) {
+      log(`Function ${func.name} is missing an entrypoint.`);
+      const answers = await inquirer.prompt(questionsGetEntrypoint);
+      func.entrypoint = answers.entrypoint;
+      localConfig.addFunction(func);
     }
+  }
 
-    log("Found changes in tablesDB resource:");
-    drawTable(changes);
+  if (
+    !(await approveChanges(
+      functions,
+      async (args: any) => {
+        const functionsService = await getFunctionsService();
+        return await functionsService.get({ functionId: args.functionId });
+      },
+      KeysFunction,
+      "functionId",
+      "functions",
+      ["vars"],
+    ))
+  ) {
+    return;
+  }
 
-    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();
-    }
+  log("Pushing functions ...");
 
-    if ((await getConfirmation()) !== true) {
-      return { applied: false, resyncNeeded: false };
-    }
+  const pushInstance = await createPushInstance();
+  const result = await pushInstance.pushFunctions(functions, {
+    async: asyncDeploy,
+    code,
+    withVariables,
+  });
 
-    // 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: any) {
-        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.`,
-        );
-      }
-    }
+  const {
+    successfullyPushed,
+    successfullyDeployed,
+    failedDeployments,
+    errors,
+  } = result;
 
-    // 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: any) {
-        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.`,
-        );
-      }
-    }
+  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}`;
 
-    // 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: any) {
-        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.`,
-        );
-      }
-    }
+    error(
+      `Deployment of ${name} has failed. Check at ${failUrl} for more details\n`,
+    );
+  });
 
-    if (toDelete.length === 0) {
-      console.log();
+  if (!asyncDeploy) {
+    if (successfullyPushed === 0) {
+      error("No functions were pushed.");
+    } else if (successfullyDeployed !== successfullyPushed) {
+      warn(
+        `Successfully pushed ${successfullyDeployed} of ${successfullyPushed} functions`,
+      );
+    } else {
+      success(`Successfully pushed ${successfullyPushed} functions.`);
     }
+  } else {
+    success(`Successfully pushed ${successfullyPushed} functions.`);
+  }
 
-    return { applied: true, resyncNeeded: needsResync };
-  };
+  if (cliConfig.verbose) {
+    errors.forEach((e) => {
+      console.error(e);
+    });
+  }
+};
 
 const pushTable = async ({
   attempts,
 }: PushTableOptions = {}): Promise<void> => {
   const tables: any[] = [];
 
-  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: any) => {
-          const tablesDBService = await getTablesDBService();
-          return await tablesDBService.list(args.queries || []);
+          const tablesService = await getTablesDBService();
+          return await tablesService.list(args.queries || []);
         },
         {},
         100,
@@ -2448,8 +1977,8 @@ const pushTable = async ({
     try {
       const { tables: remoteTables } = await paginate(
         async (args: any) => {
-          const tablesDBService = await getTablesDBService();
-          return await tablesDBService.listTables(
+          const tablesService = await getTablesDBService();
+          return await tablesService.listTables(
             args.databaseId,
             args.queries || [],
           );
@@ -2496,8 +2025,8 @@ const pushTable = async ({
           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: any) {
           error(
@@ -2528,7 +2057,7 @@ const pushTable = async ({
   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.",
+      `Use '${EXECUTABLE_NAME} pull tables' to synchronize existing one, or use '${EXECUTABLE_NAME} init table' to create a new one.`,
     );
     return;
   }
@@ -2537,8 +2066,8 @@ const pushTable = async ({
     !(await approveChanges(
       tables,
       async (args: any) => {
-        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",
@@ -2550,129 +2079,31 @@ const pushTable = async ({
   ) {
     return;
   }
-  let tablesChanged = new Set();
-
-  // Parallel tables actions
-  await Promise.all(
-    tables.map(async (table: any) => {
-      try {
-        const tablesDBService = await getTablesDBService();
-        const remoteTable = await tablesDBService.getTable(
-          table["databaseId"],
-          table["$id"],
-        );
-
-        const changes: string[] = [];
-        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: any) {
-        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 tables ...");
 
-    log(
-      `Pushing table ${table.name} ( ${table["databaseId"]} - ${table["$id"]} ) attributes`,
-    );
+  const pushInstance = await createPushInstance();
+  const result = await pushInstance.pushTables(tables, { attempts });
 
-    try {
-      await createColumns(columns, table);
-    } catch (e) {
-      throw e;
-    }
+  const { successfullyPushed, errors } = result;
 
-    try {
-      await createIndexes(indexes, table);
-    } catch (e) {
-      throw e;
-    }
-    tablesChanged.add(table["$id"]);
-    success(`Successfully pushed ${table.name} ( ${table["$id"]} )`);
+  if (successfullyPushed === 0) {
+    error("No tables were pushed.");
+  } else {
+    success(`Successfully pushed ${successfullyPushed} tables.`);
   }
 
-  success(`Successfully pushed ${tablesChanged.size} tables`);
+  if (cliConfig.verbose) {
+    errors.forEach((e) => console.error(e));
+  }
 };
 
-const pushCollection = async ({ attempts }): Promise<void> => {
+const pushCollection = async (): Promise<void> => {
   warn(
-    "appwrite push collection has been deprecated. Please consider using 'appwrite push tables' instead",
+    `${EXECUTABLE_NAME} push collection has been deprecated. Please consider using '${EXECUTABLE_NAME} push tables' instead`,
   );
   const collections: any[] = [];
 
-  if (attempts) {
-    pollMaxDebounces = attempts;
-  }
-
   if (cliConfig.all) {
     checkDeployConditions(localConfig);
     collections.push(...localConfig.getCollections());
@@ -2693,42 +2124,16 @@ const pushCollection = async ({ attempts }): Promise<void> => {
   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.",
+      `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: any) => collection["databaseId"])),
-  );
-
-  // Parallel db actions
-  await Promise.all(
-    databases.map(async (databaseId: any) => {
-      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: any) => {
+    const localDatabase = localConfig.getDatabase(collection.databaseId);
+    collection.databaseName = localDatabase.name ?? collection.databaseId;
+  });
 
   if (
     !(await approveChanges(
@@ -2750,101 +2155,26 @@ const pushCollection = async ({ attempts }): Promise<void> => {
   ) {
     return;
   }
-  // Parallel collection actions
-  await Promise.all(
-    collections.map(async (collection: any) => {
-      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: any) {
-        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 collections ...");
 
-    log(
-      `Pushing collection ${collection.name} ( ${collection["databaseId"]} - ${collection["$id"]} ) attributes`,
-    );
+  const pushInstance = await createPushInstance();
+  const result = await pushInstance.pushCollections(collections);
 
-    try {
-      await createAttributes(attributes, collection);
-    } catch (e) {
-      throw e;
-    }
+  const { successfullyPushed, errors } = result;
 
-    try {
-      await createIndexes(indexes, collection);
-    } catch (e) {
-      throw e;
-    }
-    numberOfCollections++;
-    success(`Successfully pushed ${collection.name} ( ${collection["$id"]} )`);
+  if (successfullyPushed === 0) {
+    error("No collections were pushed.");
+  } else {
+    success(`Successfully pushed ${successfullyPushed} collections.`);
   }
 
-  success(`Successfully pushed ${numberOfCollections} collections`);
+  if (cliConfig.verbose) {
+    errors.forEach((e) => console.error(e));
+  }
 };
 
 const pushBucket = async (): Promise<void> => {
-  let response: any = {};
-
   let bucketIds: string[] = [];
   const configBuckets = localConfig.getBuckets();
 
@@ -2863,7 +2193,7 @@ const pushBucket = async (): Promise<void> => {
   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.",
+      `Use '${EXECUTABLE_NAME} pull buckets' to synchronize existing one, or use '${EXECUTABLE_NAME} init bucket' to create a new one.`,
     );
     return;
   }
@@ -2892,55 +2222,23 @@ const pushBucket = async (): Promise<void> => {
 
   log("Pushing buckets ...");
 
-  for (let bucket of buckets) {
-    log(`Pushing bucket ${chalk.bold(bucket["name"])} ...`);
+  const pushInstance = await createPushInstance();
+  const result = await pushInstance.pushBuckets(buckets);
 
-    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: any) {
-      if (Number(e.code) === 404) {
-        log(
-          `Bucket ${bucket.name} does not exist in the project. Creating ... `,
-        );
+  const { successfullyPushed, errors } = result;
 
-        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;
-      }
-    }
+  if (successfullyPushed === 0) {
+    error("No buckets were pushed.");
+  } else {
+    success(`Successfully pushed ${successfullyPushed} buckets.`);
   }
 
-  success(`Successfully pushed ${buckets.length} buckets.`);
+  if (cliConfig.verbose) {
+    errors.forEach((e) => console.error(e));
+  }
 };
 
 const pushTeam = async (): Promise<void> => {
-  let response: any = {};
-
   let teamIds: string[] = [];
   const configTeams = localConfig.getTeams();
 
@@ -2959,7 +2257,7 @@ const pushTeam = async (): Promise<void> => {
   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.",
+      `Use '${EXECUTABLE_NAME} pull teams' to synchronize existing one, or use '${EXECUTABLE_NAME} init team' to create a new one.`,
     );
     return;
   }
@@ -2988,31 +2286,23 @@ const pushTeam = async (): Promise<void> => {
 
   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"]);
+  const pushInstance = await createPushInstance();
+  const result = await pushInstance.pushTeams(teams);
 
-      await teamsService.updateName(team["$id"], team.name);
-    } catch (e: any) {
-      if (Number(e.code) === 404) {
-        log(`Team ${team.name} does not exist in the project. Creating ... `);
+  const { successfullyPushed, errors } = result;
 
-        response = await teamsService.create(team["$id"], team.name);
-      } else {
-        throw e;
-      }
-    }
+  if (successfullyPushed === 0) {
+    error("No teams were pushed.");
+  } else {
+    success(`Successfully pushed ${successfullyPushed} teams.`);
   }
 
-  success(`Successfully pushed ${teams.length} teams.`);
+  if (cliConfig.verbose) {
+    errors.forEach((e) => console.error(e));
+  }
 };
 
 const pushMessagingTopic = async (): Promise<void> => {
-  let response: any = {};
-
   let topicsIds: string[] = [];
   const configTopics = localConfig.getMessagingTopics();
 
@@ -3031,7 +2321,7 @@ const pushMessagingTopic = async (): Promise<void> => {
   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.",
+      `Use '${EXECUTABLE_NAME} pull topics' to synchronize existing one, or use '${EXECUTABLE_NAME} init topic' to create a new one.`,
     );
     return;
   }
@@ -3060,37 +2350,20 @@ const pushMessagingTopic = async (): Promise<void> => {
 
   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.`);
+  const pushInstance = await createPushInstance();
+  const result = await pushInstance.pushMessagingTopics(topics);
 
-      await messagingService.updateTopic(
-        topic["$id"],
-        topic.name,
-        topic.subscribe,
-      );
-    } catch (e: any) {
-      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,
-        );
+  const { successfullyPushed, errors } = result;
 
-        success(`Created ${topic.name} ( ${topic["$id"]} )`);
-      } else {
-        throw e;
-      }
-    }
+  if (successfullyPushed === 0) {
+    error("No topics were pushed.");
+  } else {
+    success(`Successfully pushed ${successfullyPushed} topics.`);
   }
 
-  success(`Successfully pushed ${topics.length} topics.`);
+  if (cliConfig.verbose) {
+    errors.forEach((e) => console.error(e));
+  }
 };
 
 export const push = new Command("push")
@@ -3173,11 +2446,11 @@ push
   .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",
+        `${EXECUTABLE_NAME} deploy has been removed. Please use '${EXECUTABLE_NAME} push' instead`,
       );
     }),
   );