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

package/dist/lib/commands/push.js

@@ -1,51 +1,38 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deploy = exports.push = void 0;
-const fs = require("fs");
-const dotenv_1 = require("dotenv");
-const chalk_1 = __importDefault(require("chalk"));
-const inquirer_1 = __importDefault(require("inquirer"));
-const json_bigint_1 = __importDefault(require("json-bigint"));
-const commander_1 = require("commander");
-const id_1 = __importDefault(require("../id"));
-const config_1 = require("../config");
-const spinner_1 = require("../spinner");
-const paginate_1 = require("../paginate");
-const questions_1 = require("../questions");
-const parser_1 = require("../parser");
-const proxy_1 = require("./proxy");
-const console_1 = require("./console");
-const sdks_1 = require("../sdks");
-const functions_1 = require("./functions");
-const sites_1 = require("./sites");
-const databases_1 = require("./databases");
-const tables_db_1 = require("./tables-db");
-const storage_1 = require("./storage");
-const messaging_1 = require("./messaging");
-const teams_1 = require("./teams");
-const projects_1 = require("./projects");
-const utils_1 = require("../utils");
-const JSONbigNative = (0, json_bigint_1.default)({ storeAsString: false });
+import fs from "fs";
+import { parse as parseDotenv } from "dotenv";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { Command } from "commander";
+import ID from "../id.js";
+import { localConfig, globalConfig, KeysAttributes, KeysFunction, KeysSite, whitelistKeys, KeysTopics, KeysStorage, KeysTeams, KeysCollection, KeysTable, } from "../config.js";
+import { Spinner, SPINNER_ARC, SPINNER_DOTS } from "../spinner.js";
+import { paginate } from "../paginate.js";
+import { questionsPushBuckets, questionsPushTeams, questionsPushFunctions, questionsPushSites, questionsGetEntrypoint, questionsPushCollections, questionsPushTables, questionPushChanges, questionPushChangesConfirmation, questionsPushMessagingTopics, questionsPushResources, } from "../questions.js";
+import { cliConfig, actionRunner, success, warn, log, hint, error, commandDescriptions, drawTable, } from "../parser.js";
+import { getProxyService, getConsoleService, getFunctionsService, getSitesService, getDatabasesService, getTablesDBService, getStorageService, getMessagingService, getTeamsService, getProjectsService, } from "../services.js";
+import { checkDeployConditions } from "../utils.js";
 const STEP_SIZE = 100; // Resources
 const POLL_DEBOUNCE = 2000; // Milliseconds
-const POLL_MAX_DEBOUNCE = 1800; // Times of POLL_DEBOUNCE (1 hour)
 const POLL_DEFAULT_VALUE = 30;
 let pollMaxDebounces = POLL_DEFAULT_VALUE;
-const changeableKeys = ['status', 'required', 'xdefault', 'elements', 'min', 'max', 'default', 'error'];
+const changeableKeys = [
+    "status",
+    "required",
+    "xdefault",
+    "elements",
+    "min",
+    "max",
+    "default",
+    "error",
+];
 const awaitPools = {
     wipeAttributes: async (databaseId, collectionId, iteration = 1) => {
         if (iteration > pollMaxDebounces) {
             return false;
         }
-        const { total } = await (0, databases_1.databasesListAttributes)({
-            databaseId,
-            collectionId,
-            queries: [JSON.stringify({ method: 'limit', values: [1] })],
-            parseOutput: false
-        });
+        const databasesService = await getDatabasesService();
+        const response = await databasesService.listAttributes(databaseId, collectionId, [JSON.stringify({ method: "limit", values: [1] })]);
+        const { total } = response;
         if (total === 0) {
             return true;
         }
@@ -53,22 +40,21 @@ const awaitPools = {
             let steps = Math.max(1, Math.ceil(total / STEP_SIZE));
             if (steps > 1 && iteration === 1) {
                 pollMaxDebounces *= steps;
-                (0, parser_1.log)('Found a large number of attributes, increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+                log("Found a large number of attributes, increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
             }
         }
-        await new Promise(resolve => setTimeout(resolve, POLL_DEBOUNCE));
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
         return await awaitPools.wipeAttributes(databaseId, collectionId, iteration + 1);
     },
     wipeIndexes: async (databaseId, collectionId, iteration = 1) => {
         if (iteration > pollMaxDebounces) {
             return false;
         }
-        const { total } = await (0, databases_1.databasesListIndexes)({
-            databaseId,
-            collectionId,
-            queries: [JSON.stringify({ method: 'limit', values: [1] })],
-            parseOutput: false
-        });
+        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;
         }
@@ -76,10 +62,12 @@ const awaitPools = {
             let steps = Math.max(1, Math.ceil(total / STEP_SIZE));
             if (steps > 1 && iteration === 1) {
                 pollMaxDebounces *= steps;
-                (0, parser_1.log)('Found a large number of indexes, increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+                log("Found a large number of indexes, increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
             }
         }
-        await new Promise(resolve => setTimeout(resolve, POLL_DEBOUNCE));
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
         return await awaitPools.wipeIndexes(databaseId, collectionId, iteration + 1);
     },
     deleteAttributes: async (databaseId, collectionId, attributeKeys, iteration = 1) => {
@@ -90,19 +78,23 @@ const awaitPools = {
             let steps = Math.max(1, Math.ceil(attributeKeys.length / STEP_SIZE));
             if (steps > 1 && iteration === 1) {
                 pollMaxDebounces *= steps;
-                (0, parser_1.log)('Found a large number of attributes to be deleted. Increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+                log("Found a large number of attributes to be deleted. Increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
             }
         }
-        const { attributes } = await (0, paginate_1.paginate)(databases_1.databasesListAttributes, {
+        const { attributes } = await paginate(async (args) => {
+            const databasesService = await getDatabasesService();
+            return await databasesService.listAttributes(args.databaseId, args.collectionId, args.queries || []);
+        }, {
             databaseId,
             collectionId,
-            parseOutput: false
-        }, 100, 'attributes');
+        }, 100, "attributes");
         const ready = attributeKeys.filter((attribute) => attributes.includes(attribute.key));
         if (ready.length === 0) {
             return true;
         }
-        await new Promise(resolve => setTimeout(resolve, POLL_DEBOUNCE));
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
         return await awaitPools.expectAttributes(databaseId, collectionId, attributeKeys, iteration + 1);
     },
     expectAttributes: async (databaseId, collectionId, attributeKeys, iteration = 1) => {
@@ -113,21 +105,25 @@ const awaitPools = {
             let steps = Math.max(1, Math.ceil(attributeKeys.length / STEP_SIZE));
             if (steps > 1 && iteration === 1) {
                 pollMaxDebounces *= steps;
-                (0, parser_1.log)('Creating a large number of attributes, increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+                log("Creating a large number of attributes, increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
             }
         }
-        const { attributes } = await (0, paginate_1.paginate)(databases_1.databasesListAttributes, {
+        const { attributes } = await paginate(async (args) => {
+            const databasesService = await getDatabasesService();
+            return await databasesService.listAttributes(args.databaseId, args.collectionId, args.queries || []);
+        }, {
             databaseId,
             collectionId,
-            parseOutput: false
-        }, 100, 'attributes');
+        }, 100, "attributes");
         const ready = attributes
             .filter((attribute) => {
             if (attributeKeys.includes(attribute.key)) {
-                if (['stuck', 'failed'].includes(attribute.status)) {
+                if (["stuck", "failed"].includes(attribute.status)) {
                     throw new Error(`Attribute '${attribute.key}' failed!`);
                 }
-                return attribute.status === 'available';
+                return attribute.status === "available";
             }
             return false;
         })
@@ -135,7 +131,7 @@ const awaitPools = {
         if (ready.length === attributeKeys.length) {
             return true;
         }
-        await new Promise(resolve => setTimeout(resolve, POLL_DEBOUNCE));
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
         return await awaitPools.expectAttributes(databaseId, collectionId, attributeKeys, iteration + 1);
     },
     deleteIndexes: async (databaseId, collectionId, indexesKeys, iteration = 1) => {
@@ -146,19 +142,23 @@ const awaitPools = {
             let steps = Math.max(1, Math.ceil(indexesKeys.length / STEP_SIZE));
             if (steps > 1 && iteration === 1) {
                 pollMaxDebounces *= steps;
-                (0, parser_1.log)('Found a large number of indexes to be deleted. Increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+                log("Found a large number of indexes to be deleted. Increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
             }
         }
-        const { indexes } = await (0, paginate_1.paginate)(databases_1.databasesListIndexes, {
+        const { indexes } = await paginate(async (args) => {
+            const databasesService = await getDatabasesService();
+            return await databasesService.listIndexes(args.databaseId, args.collectionId, args.queries || []);
+        }, {
             databaseId,
             collectionId,
-            parseOutput: false
-        }, 100, 'indexes');
+        }, 100, "indexes");
         const ready = indexesKeys.filter((index) => indexes.includes(index.key));
         if (ready.length === 0) {
             return true;
         }
-        await new Promise(resolve => setTimeout(resolve, POLL_DEBOUNCE));
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
         return await awaitPools.expectIndexes(databaseId, collectionId, indexesKeys, iteration + 1);
     },
     expectIndexes: async (databaseId, collectionId, indexKeys, iteration = 1) => {
@@ -169,21 +169,25 @@ const awaitPools = {
             let steps = Math.max(1, Math.ceil(indexKeys.length / STEP_SIZE));
             if (steps > 1 && iteration === 1) {
                 pollMaxDebounces *= steps;
-                (0, parser_1.log)('Creating a large number of indexes, increasing timeout to ' + (pollMaxDebounces * POLL_DEBOUNCE / 1000 / 60) + ' minutes');
+                log("Creating a large number of indexes, increasing timeout to " +
+                    (pollMaxDebounces * POLL_DEBOUNCE) / 1000 / 60 +
+                    " minutes");
             }
         }
-        const { indexes } = await (0, paginate_1.paginate)(databases_1.databasesListIndexes, {
+        const { indexes } = await paginate(async (args) => {
+            const databasesService = await getDatabasesService();
+            return await databasesService.listIndexes(args.databaseId, args.collectionId, args.queries || []);
+        }, {
             databaseId,
             collectionId,
-            parseOutput: false
-        }, 100, 'indexes');
+        }, 100, "indexes");
         const ready = indexes
             .filter((index) => {
             if (indexKeys.includes(index.key)) {
-                if (['stuck', 'failed'].includes(index.status)) {
+                if (["stuck", "failed"].includes(index.status)) {
                     throw new Error(`Index '${index.key}' failed!`);
                 }
-                return index.status === 'available';
+                return index.status === "available";
             }
             return false;
         })
@@ -191,46 +195,48 @@ const awaitPools = {
         if (ready.length >= indexKeys.length) {
             return true;
         }
-        await new Promise(resolve => setTimeout(resolve, POLL_DEBOUNCE));
+        await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE));
         return await awaitPools.expectIndexes(databaseId, collectionId, indexKeys, iteration + 1);
     },
 };
 const getConfirmation = async () => {
-    if (parser_1.cliConfig.force) {
+    if (cliConfig.force) {
         return true;
     }
     async function fixConfirmation() {
-        const answers = await inquirer_1.default.prompt(questions_1.questionPushChangesConfirmation);
-        if (answers.changes !== 'YES' && answers.changes !== 'NO') {
+        const answers = await inquirer.prompt(questionPushChangesConfirmation);
+        if (answers.changes !== "YES" && answers.changes !== "NO") {
             return await fixConfirmation();
         }
         return answers.changes;
     }
-    let answers = await inquirer_1.default.prompt(questions_1.questionPushChanges);
-    if (answers.changes !== 'YES' && answers.changes !== 'NO') {
+    let answers = await inquirer.prompt(questionPushChanges);
+    if (answers.changes !== "YES" && answers.changes !== "NO") {
         answers.changes = await fixConfirmation();
     }
-    if (answers.changes === 'YES') {
+    if (answers.changes === "YES") {
         return true;
     }
-    (0, parser_1.warn)('Skipping push action. Changes were not applied.');
+    warn("Skipping push action. Changes were not applied.");
     return false;
 };
-const isEmpty = (value) => (value === null || value === undefined || (typeof value === "string" && value.trim().length === 0) || (Array.isArray(value) && value.length === 0));
-const approveChanges = async (resource, resourceGetFunction, keys, resourceName, resourcePlural, skipKeys = [], secondId = '', secondResourceName = '') => {
-    (0, parser_1.log)('Checking for changes ...');
+const isEmpty = (value) => value === null ||
+    value === undefined ||
+    (typeof value === "string" && value.trim().length === 0) ||
+    (Array.isArray(value) && value.length === 0);
+const approveChanges = async (resource, resourceGetFunction, keys, resourceName, resourcePlural, skipKeys = [], secondId = "", secondResourceName = "") => {
+    log("Checking for changes ...");
     const changes = [];
     await Promise.all(resource.map(async (localResource) => {
         try {
             const options = {
-                [resourceName]: localResource['$id'],
-                parseOutput: false,
+                [resourceName]: localResource["$id"],
             };
-            if (secondId !== '' && secondResourceName !== '') {
+            if (secondId !== "" && secondResourceName !== "") {
                 options[secondResourceName] = localResource[secondId];
             }
             const remoteResource = await resourceGetFunction(options);
-            for (let [key, value] of Object.entries((0, config_1.whitelistKeys)(remoteResource, keys))) {
+            for (let [key, value] of Object.entries(whitelistKeys(remoteResource, keys))) {
                 if (skipKeys.includes(key)) {
                     continue;
                 }
@@ -240,19 +246,19 @@ const approveChanges = async (resource, resourceGetFunction, keys, resourceName,
                 if (Array.isArray(value) && Array.isArray(localResource[key])) {
                     if (JSON.stringify(value) !== JSON.stringify(localResource[key])) {
                         changes.push({
-                            id: localResource['$id'],
+                            id: localResource["$id"],
                             key,
-                            remote: chalk_1.default.red(value.join('\n')),
-                            local: chalk_1.default.green(localResource[key].join('\n'))
+                            remote: chalk.red(value.join("\n")),
+                            local: chalk.green(localResource[key].join("\n")),
                         });
                     }
                 }
                 else if (value !== localResource[key]) {
                     changes.push({
-                        id: localResource['$id'],
+                        id: localResource["$id"],
                         key,
-                        remote: chalk_1.default.red(value),
-                        local: chalk_1.default.green(localResource[key])
+                        remote: chalk.red(value),
+                        local: chalk.green(localResource[key]),
                     });
                 }
             }
@@ -266,18 +272,27 @@ const approveChanges = async (resource, resourceGetFunction, keys, resourceName,
     if (changes.length === 0) {
         return true;
     }
-    (0, parser_1.drawTable)(changes);
+    drawTable(changes);
     if ((await getConfirmation()) === true) {
         return true;
     }
-    (0, parser_1.success)(`Successfully pushed 0 ${resourcePlural}.`);
+    success(`Successfully pushed 0 ${resourcePlural}.`);
     return false;
 };
 const getObjectChanges = (remote, local, index, what) => {
     const changes = [];
-    if (remote[index] && local[index]) {
-        for (let [service, status] of Object.entries(remote[index])) {
-            const localValue = local[index][service];
+    const remoteNested = remote[index];
+    const localNested = local[index];
+    if (remoteNested &&
+        localNested &&
+        typeof remoteNested === "object" &&
+        !Array.isArray(remoteNested) &&
+        typeof localNested === "object" &&
+        !Array.isArray(localNested)) {
+        const remoteObj = remoteNested;
+        const localObj = localNested;
+        for (const [service, status] of Object.entries(remoteObj)) {
+            const localValue = localObj[service];
             let valuesEqual = false;
             if (Array.isArray(status) && Array.isArray(localValue)) {
                 valuesEqual = JSON.stringify(status) === JSON.stringify(localValue);
@@ -286,48 +301,51 @@ const getObjectChanges = (remote, local, index, what) => {
                 valuesEqual = status === localValue;
             }
             if (!valuesEqual) {
-                changes.push({ group: what, setting: service, remote: chalk_1.default.red(status), local: chalk_1.default.green(localValue) });
+                changes.push({
+                    group: what,
+                    setting: service,
+                    remote: chalk.red(String(status ?? "")),
+                    local: chalk.green(String(localValue ?? "")),
+                });
             }
         }
     }
     return changes;
 };
-const createAttribute = (databaseId, collectionId, attribute) => {
+const createAttribute = async (databaseId, collectionId, attribute) => {
+    const databasesService = await getDatabasesService();
     switch (attribute.type) {
-        case 'string':
+        case "string":
             switch (attribute.format) {
-                case 'email':
-                    return (0, databases_1.databasesCreateEmailAttribute)({
+                case "email":
+                    return databasesService.createEmailAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
                         required: attribute.required,
                         xdefault: attribute.default,
                         array: attribute.array,
-                        parseOutput: false
                     });
-                case 'url':
-                    return (0, databases_1.databasesCreateUrlAttribute)({
+                case "url":
+                    return databasesService.createUrlAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
                         required: attribute.required,
                         xdefault: attribute.default,
                         array: attribute.array,
-                        parseOutput: false
                     });
-                case 'ip':
-                    return (0, databases_1.databasesCreateIpAttribute)({
+                case "ip":
+                    return databasesService.createIpAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
                         required: attribute.required,
                         xdefault: attribute.default,
                         array: attribute.array,
-                        parseOutput: false
                     });
-                case 'enum':
-                    return (0, databases_1.databasesCreateEnumAttribute)({
+                case "enum":
+                    return databasesService.createEnumAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
@@ -335,10 +353,9 @@ const createAttribute = (databaseId, collectionId, attribute) => {
                         required: attribute.required,
                         xdefault: attribute.default,
                         array: attribute.array,
-                        parseOutput: false
                     });
                 default:
-                    return (0, databases_1.databasesCreateStringAttribute)({
+                    return databasesService.createStringAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
@@ -347,11 +364,10 @@ const createAttribute = (databaseId, collectionId, attribute) => {
                         xdefault: attribute.default,
                         array: attribute.array,
                         encrypt: attribute.encrypt,
-                        parseOutput: false
                     });
             }
-        case 'integer':
-            return (0, databases_1.databasesCreateIntegerAttribute)({
+        case "integer":
+            return databasesService.createIntegerAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
@@ -360,10 +376,9 @@ const createAttribute = (databaseId, collectionId, attribute) => {
                 max: attribute.max,
                 xdefault: attribute.default,
                 array: attribute.array,
-                parseOutput: false
             });
-        case 'double':
-            return (0, databases_1.databasesCreateFloatAttribute)({
+        case "double":
+            return databasesService.createFloatAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
@@ -372,30 +387,27 @@ const createAttribute = (databaseId, collectionId, attribute) => {
                 max: attribute.max,
                 xdefault: attribute.default,
                 array: attribute.array,
-                parseOutput: false
             });
-        case 'boolean':
-            return (0, databases_1.databasesCreateBooleanAttribute)({
+        case "boolean":
+            return databasesService.createBooleanAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
                 array: attribute.array,
-                parseOutput: false
             });
-        case 'datetime':
-            return (0, databases_1.databasesCreateDatetimeAttribute)({
+        case "datetime":
+            return databasesService.createDatetimeAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
                 array: attribute.array,
-                parseOutput: false
             });
-        case 'relationship':
-            return (0, databases_1.databasesCreateRelationshipAttribute)({
+        case "relationship":
+            return databasesService.createRelationshipAttribute({
                 databaseId,
                 collectionId,
                 relatedCollectionId: attribute.relatedTable ?? attribute.relatedCollection,
@@ -404,98 +416,84 @@ const createAttribute = (databaseId, collectionId, attribute) => {
                 key: attribute.key,
                 twoWayKey: attribute.twoWayKey,
                 onDelete: attribute.onDelete,
-                parseOutput: false
             });
-        case 'point':
-            return (0, databases_1.databasesCreatePointAttribute)({
+        case "point":
+            return databasesService.createPointAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
-                parseOutput: false
             });
-        case 'linestring':
-            return (0, databases_1.databasesCreateLineAttribute)({
+        case "linestring":
+            return databasesService.createLineAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
-                parseOutput: false
             });
-        case 'polygon':
-            return (0, databases_1.databasesCreatePolygonAttribute)({
+        case "polygon":
+            return databasesService.createPolygonAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
-                parseOutput: false
             });
         default:
             throw new Error(`Unsupported attribute type: ${attribute.type}`);
     }
 };
-const updateAttribute = (databaseId, collectionId, attribute) => {
+const updateAttribute = async (databaseId, collectionId, attribute) => {
+    const databasesService = await getDatabasesService();
     switch (attribute.type) {
-        case 'string':
+        case "string":
             switch (attribute.format) {
-                case 'email':
-                    return (0, databases_1.databasesUpdateEmailAttribute)({
+                case "email":
+                    return databasesService.updateEmailAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
                         required: attribute.required,
                         xdefault: attribute.default,
-                        array: attribute.array,
-                        parseOutput: false
                     });
-                case 'url':
-                    return (0, databases_1.databasesUpdateUrlAttribute)({
+                case "url":
+                    return databasesService.updateUrlAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
                         required: attribute.required,
                         xdefault: attribute.default,
-                        array: attribute.array,
-                        parseOutput: false
                     });
-                case 'ip':
-                    return (0, databases_1.databasesUpdateIpAttribute)({
+                case "ip":
+                    return databasesService.updateIpAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
                         required: attribute.required,
                         xdefault: attribute.default,
-                        array: attribute.array,
-                        parseOutput: false
                     });
-                case 'enum':
-                    return (0, databases_1.databasesUpdateEnumAttribute)({
+                case "enum":
+                    return databasesService.updateEnumAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
                         elements: attribute.elements,
                         required: attribute.required,
                         xdefault: attribute.default,
-                        array: attribute.array,
-                        parseOutput: false
                     });
                 default:
-                    return (0, databases_1.databasesUpdateStringAttribute)({
+                    return databasesService.updateStringAttribute({
                         databaseId,
                         collectionId,
                         key: attribute.key,
-                        size: attribute.size,
                         required: attribute.required,
                         xdefault: attribute.default,
-                        array: attribute.array,
-                        parseOutput: false
                     });
             }
-        case 'integer':
-            return (0, databases_1.databasesUpdateIntegerAttribute)({
+        case "integer":
+            return databasesService.updateIntegerAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
@@ -503,11 +501,9 @@ const updateAttribute = (databaseId, collectionId, attribute) => {
                 min: attribute.min,
                 max: attribute.max,
                 xdefault: attribute.default,
-                array: attribute.array,
-                parseOutput: false
             });
-        case 'double':
-            return (0, databases_1.databasesUpdateFloatAttribute)({
+        case "double":
+            return databasesService.updateFloatAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
@@ -515,106 +511,85 @@ const updateAttribute = (databaseId, collectionId, attribute) => {
                 min: attribute.min,
                 max: attribute.max,
                 xdefault: attribute.default,
-                array: attribute.array,
-                parseOutput: false
             });
-        case 'boolean':
-            return (0, databases_1.databasesUpdateBooleanAttribute)({
+        case "boolean":
+            return databasesService.updateBooleanAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
-                array: attribute.array,
-                parseOutput: false
             });
-        case 'datetime':
-            return (0, databases_1.databasesUpdateDatetimeAttribute)({
+        case "datetime":
+            return databasesService.updateDatetimeAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
-                array: attribute.array,
-                parseOutput: false
             });
-        case 'relationship':
-            return (0, databases_1.databasesUpdateRelationshipAttribute)({
+        case "relationship":
+            return databasesService.updateRelationshipAttribute({
                 databaseId,
                 collectionId,
-                relatedCollectionId: attribute.relatedTable ?? attribute.relatedCollection,
-                type: attribute.relationType,
-                twoWay: attribute.twoWay,
                 key: attribute.key,
-                twoWayKey: attribute.twoWayKey,
                 onDelete: attribute.onDelete,
-                parseOutput: false
             });
-        case 'point':
-            return (0, databases_1.databasesUpdatePointAttribute)({
+        case "point":
+            return databasesService.updatePointAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
-                parseOutput: false
             });
-        case 'linestring':
-            return (0, databases_1.databasesUpdateLineAttribute)({
+        case "linestring":
+            return databasesService.updateLineAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
-                parseOutput: false
             });
-        case 'polygon':
-            return (0, databases_1.databasesUpdatePolygonAttribute)({
+        case "polygon":
+            return databasesService.updatePolygonAttribute({
                 databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
                 xdefault: attribute.default,
-                parseOutput: false
             });
         default:
             throw new Error(`Unsupported attribute type: ${attribute.type}`);
     }
 };
 const deleteAttribute = async (collection, attribute, isIndex = false) => {
-    (0, parser_1.log)(`Deleting ${isIndex ? 'index' : 'attribute'} ${attribute.key} of ${collection.name} ( ${collection['$id']} )`);
+    log(`Deleting ${isIndex ? "index" : "attribute"} ${attribute.key} of ${collection.name} ( ${collection["$id"]} )`);
+    const databasesService = await getDatabasesService();
     if (isIndex) {
-        await (0, databases_1.databasesDeleteIndex)({
-            databaseId: collection['databaseId'],
-            collectionId: collection['$id'],
-            key: attribute.key,
-            parseOutput: false
-        });
+        await databasesService.deleteIndex(collection["databaseId"], collection["$id"], attribute.key);
         return;
     }
-    await (0, databases_1.databasesDeleteAttribute)({
-        databaseId: collection['databaseId'],
-        collectionId: collection['$id'],
-        key: attribute.key,
-        parseOutput: false
-    });
+    await databasesService.deleteAttribute(collection["databaseId"], collection["$id"], attribute.key);
 };
 const isEqual = (a, b) => {
     if (a === b)
         return true;
-    if (a && b && typeof a === 'object' && typeof b === 'object') {
-        if (a.constructor && a.constructor.name === 'BigNumber' &&
-            b.constructor && b.constructor.name === 'BigNumber') {
+    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') {
+        if (typeof a.equals === "function") {
             return a.equals(b);
         }
-        if (typeof a.eq === 'function') {
+        if (typeof a.eq === "function") {
             return a.eq(b);
         }
     }
-    if (typeof a === 'number' && typeof b === 'number') {
+    if (typeof a === "number" && typeof b === "number") {
         if (isNaN(a) && isNaN(b))
             return true;
         if (!isFinite(a) && !isFinite(b))
@@ -629,13 +604,13 @@ const compareAttribute = (remote, local, reason, key) => {
     }
     if (Array.isArray(remote) && Array.isArray(local)) {
         if (JSON.stringify(remote) !== JSON.stringify(local)) {
-            const bol = reason === '' ? '' : '\n';
-            reason += `${bol}${key} changed from ${chalk_1.default.red(remote)} to ${chalk_1.default.green(local)}`;
+            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_1.default.red(remote)} to ${chalk_1.default.green(local)}`;
+        const bol = reason === "" ? "" : "\n";
+        reason += `${bol}${key} changed from ${chalk.red(remote)} to ${chalk.green(local)}`;
     }
     return reason;
 };
@@ -647,12 +622,12 @@ const checkAttributeChanges = (remote, local, collection, recreating = true) =>
     if (local === undefined) {
         return undefined;
     }
-    const keyName = `${chalk_1.default.yellow(local.key)} in ${collection.name} (${collection['$id']})`;
-    const action = chalk_1.default.cyan(recreating ? 'recreating' : 'changing');
-    let reason = '';
+    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 (!config_1.KeysAttributes.has(key)) {
+        if (!KeysAttributes.has(key)) {
             continue;
         }
         if (changeableKeys.includes(key)) {
@@ -666,7 +641,9 @@ const checkAttributeChanges = (remote, local, collection, recreating = true) =>
         }
         reason = compareAttribute(remote[key], local[key], reason, key);
     }
-    return reason === '' ? undefined : { key: keyName, attribute, reason, action };
+    return reason === ""
+        ? undefined
+        : { key: keyName, attribute, reason, action };
 };
 /**
  * Check if attributes contain the given attribute
@@ -674,10 +651,12 @@ const checkAttributeChanges = (remote, local, collection, recreating = true) =>
 const attributesContains = (attribute, attributes) => attributes.find((attr) => attr.key === attribute.key);
 const generateChangesObject = (attribute, collection, isAdding) => {
     return {
-        key: `${chalk_1.default.yellow(attribute.key)} in ${collection.name} (${collection['$id']})`,
+        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_1.default.green('adding') : chalk_1.default.red('deleting')
+        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"),
     };
 };
 /**
@@ -685,32 +664,41 @@ const generateChangesObject = (attribute, collection, isAdding) => {
  * return list of attributes to create
  */
 const attributesToCreate = async (remoteAttributes, localAttributes, collection, isIndex = false) => {
-    const deleting = remoteAttributes.filter((attribute) => !attributesContains(attribute, localAttributes)).map((attr) => generateChangesObject(attr, collection, false));
-    const adding = localAttributes.filter((attribute) => !attributesContains(attribute, remoteAttributes)).map((attr) => generateChangesObject(attr, collection, true));
-    const conflicts = remoteAttributes.map((attribute) => checkAttributeChanges(attribute, attributesContains(attribute, localAttributes), collection)).filter(attribute => attribute !== undefined);
-    const changes = remoteAttributes.map((attribute) => checkAttributeChanges(attribute, attributesContains(attribute, localAttributes), collection, false))
-        .filter(attribute => attribute !== undefined)
-        .filter(attribute => conflicts.filter(attr => attribute.key === attr.key).length !== 1);
+    const deleting = remoteAttributes
+        .filter((attribute) => !attributesContains(attribute, localAttributes))
+        .map((attr) => generateChangesObject(attr, collection, false));
+    const adding = localAttributes
+        .filter((attribute) => !attributesContains(attribute, remoteAttributes))
+        .map((attr) => generateChangesObject(attr, collection, true));
+    const conflicts = remoteAttributes
+        .map((attribute) => checkAttributeChanges(attribute, attributesContains(attribute, localAttributes), collection))
+        .filter((attribute) => attribute !== undefined);
+    const changes = remoteAttributes
+        .map((attribute) => checkAttributeChanges(attribute, attributesContains(attribute, localAttributes), collection, false))
+        .filter((attribute) => attribute !== undefined)
+        .filter((attribute) => conflicts.filter((attr) => attribute.key === attr.key).length !== 1);
     let changedAttributes = [];
     const changing = [...deleting, ...adding, ...conflicts, ...changes];
     if (changing.length === 0) {
         return changedAttributes;
     }
-    (0, parser_1.log)(!parser_1.cliConfig.force ? 'There are pending changes in your collection deployment' : 'List of applied changes');
-    (0, parser_1.drawTable)(changing.map((change) => {
-        return { Key: change.key, Action: change.action, Reason: change.reason, };
+    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 (!parser_1.cliConfig.force) {
+    if (!cliConfig.force) {
         if (deleting.length > 0 && !isIndex) {
-            console.log(`${chalk_1.default.red('------------------------------------------------------')}`);
-            console.log(`${chalk_1.default.red('| WARNING: Attribute deletion may cause loss of data |')}`);
-            console.log(`${chalk_1.default.red('------------------------------------------------------')}`);
+            console.log(`${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_1.default.red('--------------------------------------------------------')}`);
-            console.log(`${chalk_1.default.red('| WARNING: Attribute recreation may cause loss of data |')}`);
-            console.log(`${chalk_1.default.red('--------------------------------------------------------')}`);
+            console.log(`${chalk.red("--------------------------------------------------------")}`);
+            console.log(`${chalk.red("| WARNING: Attribute recreation may cause loss of data |")}`);
+            console.log(`${chalk.red("--------------------------------------------------------")}`);
             console.log();
         }
         if ((await getConfirmation()) !== true) {
@@ -724,13 +712,16 @@ const attributesToCreate = async (remoteAttributes, localAttributes, collection,
     }
     if (changes.length > 0) {
         changedAttributes = changes.map((change) => change.attribute);
-        await Promise.all(changedAttributes.map((changed) => updateAttribute(collection['databaseId'], collection['$id'], changed)));
+        await Promise.all(changedAttributes.map((changed) => updateAttribute(collection["databaseId"], collection["$id"], changed)));
     }
     const deletingAttributes = deleting.map((change) => change.attribute);
     await Promise.all(deletingAttributes.map((attribute) => deleteAttribute(collection, attribute, isIndex)));
-    const attributeKeys = [...remoteAttributes.map((attribute) => attribute.key), ...deletingAttributes.map((attribute) => attribute.key)];
+    const attributeKeys = [
+        ...remoteAttributes.map((attribute) => attribute.key),
+        ...deletingAttributes.map((attribute) => attribute.key),
+    ];
     if (attributeKeys.length) {
-        const deleteAttributesPoolStatus = await awaitPools.deleteAttributes(collection['databaseId'], collection['$id'], attributeKeys);
+        const deleteAttributesPoolStatus = await awaitPools.deleteAttributes(collection["databaseId"], collection["$id"], attributeKeys);
         if (!deleteAttributesPoolStatus) {
             throw new Error("Attribute deletion timed out.");
         }
@@ -738,49 +729,46 @@ const attributesToCreate = async (remoteAttributes, localAttributes, collection,
     return localAttributes.filter((attribute) => !attributesContains(attribute, remoteAttributes));
 };
 const createIndexes = async (indexes, collection) => {
-    (0, parser_1.log)(`Creating indexes ...`);
+    log(`Creating indexes ...`);
+    const databasesService = await getDatabasesService();
     for (let index of indexes) {
-        await (0, databases_1.databasesCreateIndex)({
-            databaseId: collection['databaseId'],
-            collectionId: collection['$id'],
-            key: index.key,
-            type: index.type,
-            attributes: index.columns ?? index.attributes,
-            orders: index.orders,
-            parseOutput: false
-        });
+        await databasesService.createIndex(collection["databaseId"], collection["$id"], index.key, index.type, index.columns ?? index.attributes, index.orders);
     }
-    const result = await awaitPools.expectIndexes(collection['databaseId'], collection['$id'], indexes.map((index) => index.key));
+    const result = await awaitPools.expectIndexes(collection["databaseId"], collection["$id"], indexes.map((index) => index.key));
     if (!result) {
-        throw new Error('Index creation timed out.');
+        throw new Error("Index creation timed out.");
     }
-    (0, parser_1.success)(`Created ${indexes.length} indexes`);
+    success(`Created ${indexes.length} indexes`);
 };
 const createAttributes = async (attributes, collection) => {
     for (let attribute of attributes) {
-        if (attribute.side !== 'child') {
-            await createAttribute(collection['databaseId'], collection['$id'], attribute);
+        if (attribute.side !== "child") {
+            await createAttribute(collection["databaseId"], collection["$id"], attribute);
         }
     }
-    const result = await awaitPools.expectAttributes(collection['databaseId'], collection['$id'], collection.attributes.filter((attribute) => attribute.side !== 'child').map((attribute) => attribute.key));
+    const result = await awaitPools.expectAttributes(collection["databaseId"], collection["$id"], collection.attributes
+        .filter((attribute) => attribute.side !== "child")
+        .map((attribute) => attribute.key));
     if (!result) {
         throw new Error(`Attribute creation timed out.`);
     }
-    (0, parser_1.success)(`Created ${attributes.length} attributes`);
+    success(`Created ${attributes.length} attributes`);
 };
 const createColumns = async (columns, table) => {
     for (let column of columns) {
-        if (column.side !== 'child') {
-            await createAttribute(table['databaseId'], table['$id'], column);
+        if (column.side !== "child") {
+            await createAttribute(table["databaseId"], table["$id"], column);
         }
     }
-    const result = await awaitPools.expectAttributes(table['databaseId'], table['$id'], table.columns.filter((column) => column.side !== 'child').map((column) => column.key));
+    const result = await awaitPools.expectAttributes(table["databaseId"], table["$id"], table.columns
+        .filter((column) => column.side !== "child")
+        .map((column) => column.key));
     if (!result) {
         throw new Error(`Column creation timed out.`);
     }
-    (0, parser_1.success)(`Created ${columns.length} columns`);
+    success(`Created ${columns.length} columns`);
 };
-const pushResources = async () => {
+const pushResources = async ({ skipDeprecated = false, } = {}) => {
     const actions = {
         settings: pushSettings,
         functions: pushFunction,
@@ -789,184 +777,176 @@ const pushResources = async () => {
         tables: pushTable,
         buckets: pushBucket,
         teams: pushTeam,
-        messages: pushMessagingTopic
+        messages: pushMessagingTopic,
     };
-    if (parser_1.cliConfig.all) {
+    if (skipDeprecated) {
+        delete actions.collections;
+    }
+    if (cliConfig.all) {
         for (let action of Object.values(actions)) {
-            await action({ returnOnZero: true });
+            await action();
         }
     }
     else {
-        const answers = await inquirer_1.default.prompt(questions_1.questionsPushResources[0]);
+        const answers = await inquirer.prompt(questionsPushResources);
         const action = actions[answers.resource];
         if (action !== undefined) {
-            await action({ returnOnZero: true });
+            await action();
         }
     }
 };
 const pushSettings = async () => {
-    (0, utils_1.checkDeployConditions)(config_1.localConfig);
+    checkDeployConditions(localConfig);
     try {
-        let response = await (0, projects_1.projectsGet)({
-            parseOutput: false,
-            projectId: config_1.localConfig.getProject().projectId
-        });
-        const remoteSettings = config_1.localConfig.createSettingsObject(response ?? {});
-        const localSettings = config_1.localConfig.getProject().projectSettings ?? {};
-        (0, parser_1.log)('Checking for changes ...');
+        const projectsService = await getProjectsService();
+        let response = await projectsService.get(localConfig.getProject().projectId);
+        const remoteSettings = localConfig.createSettingsObject(response ?? {});
+        const localSettings = localConfig.getProject().projectSettings ?? {};
+        log("Checking for changes ...");
         const changes = [];
-        changes.push(...(getObjectChanges(remoteSettings, localSettings, 'services', 'Service')));
-        changes.push(...(getObjectChanges(remoteSettings['auth'] ?? {}, localSettings['auth'] ?? {}, 'methods', 'Auth method')));
-        changes.push(...(getObjectChanges(remoteSettings['auth'] ?? {}, localSettings['auth'] ?? {}, 'security', 'Auth security')));
+        changes.push(...getObjectChanges(remoteSettings, localSettings, "services", "Service"));
+        changes.push(...getObjectChanges(remoteSettings["auth"] ?? {}, localSettings["auth"] ?? {}, "methods", "Auth method"));
+        changes.push(...getObjectChanges(remoteSettings["auth"] ?? {}, localSettings["auth"] ?? {}, "security", "Auth security"));
         if (changes.length > 0) {
-            (0, parser_1.drawTable)(changes);
+            drawTable(changes);
             if ((await getConfirmation()) !== true) {
-                (0, parser_1.success)(`Successfully pushed 0 project settings.`);
+                success(`Successfully pushed 0 project settings.`);
                 return;
             }
         }
     }
-    catch (e) {
-    }
+    catch (e) { }
     try {
-        (0, parser_1.log)("Pushing project settings ...");
-        const projectId = config_1.localConfig.getProject().projectId;
-        const projectName = config_1.localConfig.getProject().projectName;
-        const settings = config_1.localConfig.getProject().projectSettings ?? {};
+        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) {
-            (0, parser_1.log)("Applying project name ...");
-            await (0, projects_1.projectsUpdate)({
-                projectId,
-                name: projectName,
-                parseOutput: false
-            });
+            log("Applying project name ...");
+            await projectsService.update(projectId, projectName);
         }
         if (settings.services) {
-            (0, parser_1.log)("Applying service statuses ...");
+            log("Applying service statuses ...");
             for (let [service, status] of Object.entries(settings.services)) {
-                await (0, projects_1.projectsUpdateServiceStatus)({
-                    projectId,
-                    service,
-                    status,
-                    parseOutput: false
-                });
+                await projectsService.updateServiceStatus(projectId, service, status);
             }
         }
         if (settings.auth) {
             if (settings.auth.security) {
-                (0, parser_1.log)("Applying auth security settings ...");
-                await (0, projects_1.projectsUpdateAuthDuration)({ projectId, duration: settings.auth.security.duration, parseOutput: false });
-                await (0, projects_1.projectsUpdateAuthLimit)({ projectId, limit: settings.auth.security.limit, parseOutput: false });
-                await (0, projects_1.projectsUpdateAuthSessionsLimit)({ projectId, limit: settings.auth.security.sessionsLimit, parseOutput: false });
-                await (0, projects_1.projectsUpdateAuthPasswordDictionary)({ projectId, enabled: settings.auth.security.passwordDictionary, parseOutput: false });
-                await (0, projects_1.projectsUpdateAuthPasswordHistory)({ projectId, limit: settings.auth.security.passwordHistory, parseOutput: false });
-                await (0, projects_1.projectsUpdatePersonalDataCheck)({ projectId, enabled: settings.auth.security.personalDataCheck, parseOutput: false });
-                await (0, projects_1.projectsUpdateSessionAlerts)({ projectId, alerts: settings.auth.security.sessionAlerts, parseOutput: false });
-                await (0, projects_1.projectsUpdateMockNumbers)({ projectId, numbers: settings.auth.security.mockNumbers, parseOutput: false });
+                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) {
-                (0, parser_1.log)("Applying auth methods statuses ...");
+                log("Applying auth methods statuses ...");
                 for (let [method, status] of Object.entries(settings.auth.methods)) {
-                    await (0, projects_1.projectsUpdateAuthStatus)({
-                        projectId,
-                        method,
-                        status,
-                        parseOutput: false
-                    });
+                    await projectsService.updateAuthStatus(projectId, method, status);
                 }
             }
         }
-        (0, parser_1.success)(`Successfully pushed ${chalk_1.default.bold('all')} project settings.`);
+        success(`Successfully pushed ${chalk.bold("all")} project settings.`);
     }
     catch (e) {
         throw e;
     }
 };
-const pushSite = async ({ siteId, async: asyncDeploy, code, withVariables } = { returnOnZero: false }) => {
-    process.chdir(config_1.localConfig.configDirectoryPath);
+const pushSite = async ({ siteId, async: asyncDeploy, code, withVariables, } = {}) => {
+    process.chdir(localConfig.configDirectoryPath);
     const siteIds = [];
     if (siteId) {
         siteIds.push(siteId);
     }
-    else if (parser_1.cliConfig.all) {
-        (0, utils_1.checkDeployConditions)(config_1.localConfig);
-        const sites = config_1.localConfig.getSites();
+    else if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        const sites = localConfig.getSites();
         siteIds.push(...sites.map((site) => {
             return site.$id;
         }));
     }
     if (siteIds.length <= 0) {
-        const answers = await inquirer_1.default.prompt(questions_1.questionsPushSites[0]);
+        const answers = await inquirer.prompt(questionsPushSites);
         if (answers.sites) {
             siteIds.push(...answers.sites);
         }
     }
     if (siteIds.length === 0) {
-        (0, parser_1.log)("No sites found.");
-        (0, parser_1.hint)("Use 'appwrite pull sites' to synchronize existing one, or use 'appwrite init site' to create a new one.");
+        log("No sites found.");
+        hint("Use 'appwrite pull sites' to synchronize existing one, or use 'appwrite init site' to create a new one.");
         return;
     }
     let sites = siteIds.map((id) => {
-        const sites = config_1.localConfig.getSites();
+        const sites = localConfig.getSites();
         const site = sites.find((s) => s.$id === id);
         if (!site) {
             throw new Error("Site '" + id + "' not found.");
         }
         return site;
     });
-    (0, parser_1.log)('Validating sites ...');
+    log("Validating sites ...");
     // Validation is done BEFORE pushing so the deployment process can be run in async with progress update
     for (let site of sites) {
         if (!site.buildCommand) {
-            (0, parser_1.log)(`Site ${site.name} is missing build command.`);
-            const answers = await inquirer_1.default.prompt(questions_1.questionsGetEntrypoint);
+            log(`Site ${site.name} is missing build command.`);
+            const answers = await inquirer.prompt(questionsGetEntrypoint);
             site.buildCommand = answers.entrypoint;
-            config_1.localConfig.addSite(site);
+            localConfig.addSite(site);
         }
     }
-    if (!(await approveChanges(sites, sites_1.sitesGet, config_1.KeysSite, 'siteId', 'sites', ['vars']))) {
+    if (!(await approveChanges(sites, async (args) => {
+        const sitesService = await getSitesService();
+        return await sitesService.get({ siteId: args.siteId });
+    }, KeysSite, "siteId", "sites", ["vars"]))) {
         return;
     }
-    (0, parser_1.log)('Pushing sites ...');
-    spinner_1.Spinner.start(false);
+    log("Pushing sites ...");
+    Spinner.start(false);
     let successfullyPushed = 0;
     let successfullyDeployed = 0;
     const failedDeployments = [];
     const errors = [];
     await Promise.all(sites.map(async (site) => {
         let response = {};
-        const ignore = site.ignore ? 'appwrite.config.json' : '.gitignore';
+        const ignore = site.ignore ? "appwrite.config.json" : ".gitignore";
         let siteExists = false;
         let deploymentCreated = false;
-        const updaterRow = new spinner_1.Spinner({ status: '', resource: site.name, id: site['$id'], end: `Ignoring using: ${ignore}` });
-        updaterRow.update({ status: 'Getting' }).startSpinner(spinner_1.SPINNER_DOTS);
+        const updaterRow = new Spinner({
+            status: "",
+            resource: site.name,
+            id: site["$id"],
+            end: `Ignoring using: ${ignore}`,
+        });
+        updaterRow.update({ status: "Getting" }).startSpinner(SPINNER_DOTS);
+        const sitesService = await getSitesService();
         try {
-            response = await (0, sites_1.sitesGet)({
-                siteId: site['$id'],
-                parseOutput: false,
-            });
+            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` });
+                updaterRow.fail({
+                    errorMessage: `Framework mismatch! (local=${site.framework},remote=${response.framework}) Please delete remote site or update your appwrite.config.json`,
+                });
                 return;
             }
-            updaterRow.update({ status: 'Updating' }).replaceSpinner(spinner_1.SPINNER_ARC);
-            response = await (0, sites_1.sitesUpdate)({
-                siteId: site['$id'],
+            updaterRow.update({ status: "Updating" }).replaceSpinner(SPINNER_ARC);
+            response = await sitesService.update({
+                siteId: site["$id"],
                 name: site.name,
                 framework: site.framework,
-                buildRuntime: site.buildRuntime,
-                specification: site.specification,
-                timeout: site.timeout,
                 enabled: site.enabled,
                 logging: site.logging,
-                adapter: site.adapter,
-                buildCommand: site.buildCommand,
+                timeout: site.timeout,
                 installCommand: site.installCommand,
+                buildCommand: site.buildCommand,
                 outputDirectory: site.outputDirectory,
-                fallbackFile: site.fallbackFile,
-                vars: JSON.stringify(response.vars),
-                parseOutput: false
+                buildRuntime: site.buildRuntime,
+                adapter: site.adapter,
+                specification: site.specification,
             });
         }
         catch (e) {
@@ -975,74 +955,79 @@ const pushSite = async ({ siteId, async: asyncDeploy, code, withVariables } = {
             }
             else {
                 errors.push(e);
-                updaterRow.fail({ errorMessage: e.message ?? 'General error occurs please try again' });
+                updaterRow.fail({
+                    errorMessage: e.message ?? "General error occurs please try again",
+                });
                 return;
             }
         }
         if (!siteExists) {
-            updaterRow.update({ status: 'Creating' }).replaceSpinner(spinner_1.SPINNER_DOTS);
+            updaterRow.update({ status: "Creating" }).replaceSpinner(SPINNER_DOTS);
             try {
-                response = await (0, sites_1.sitesCreate)({
+                response = await sitesService.create({
                     siteId: site.$id,
                     name: site.name,
                     framework: site.framework,
-                    specification: site.specification,
-                    buildRuntime: site.buildRuntime,
-                    buildCommand: site.buildCommand,
+                    enabled: site.enabled,
+                    logging: site.logging,
+                    timeout: site.timeout,
                     installCommand: site.installCommand,
+                    buildCommand: site.buildCommand,
                     outputDirectory: site.outputDirectory,
-                    fallbackFile: site.fallbackFile,
+                    buildRuntime: site.buildRuntime,
                     adapter: site.adapter,
-                    timeout: site.timeout,
-                    enabled: site.enabled,
-                    logging: site.logging,
-                    parseOutput: false
+                    specification: site.specification,
                 });
-                let domain = '';
+                let domain = "";
                 try {
-                    const variables = await (0, console_1.consoleVariables)({ parseOutput: false, sdk: await (0, sdks_1.sdkForConsole)() });
-                    domain = id_1.default.unique() + '.' + variables['_APP_DOMAIN_SITES'];
+                    const consoleService = await getConsoleService();
+                    const variables = await consoleService.variables();
+                    domain = ID.unique() + "." + variables["_APP_DOMAIN_SITES"];
                 }
                 catch (error) {
-                    console.error('Error fetching console variables.');
+                    console.error("Error fetching console variables.");
                     throw error;
                 }
                 try {
-                    const rule = await (0, proxy_1.proxyCreateSiteRule)({
-                        domain: domain,
-                        siteId: site.$id
-                    });
+                    const proxyService = await getProxyService();
+                    const rule = await proxyService.createSiteRule(domain, site.$id);
                 }
                 catch (error) {
-                    console.error('Error creating site rule.');
+                    console.error("Error creating site rule.");
                     throw error;
                 }
-                updaterRow.update({ status: 'Created' });
+                updaterRow.update({ status: "Created" });
             }
             catch (e) {
                 errors.push(e);
-                updaterRow.fail({ errorMessage: e.message ?? 'General error occurs please try again' });
+                updaterRow.fail({
+                    errorMessage: e.message ?? "General error occurs please try again",
+                });
                 return;
             }
         }
         if (withVariables) {
-            updaterRow.update({ status: 'Creating variables' }).replaceSpinner(spinner_1.SPINNER_ARC);
-            const { variables } = await (0, paginate_1.paginate)(sites_1.sitesListVariables, {
-                siteId: site['$id'],
-                parseOutput: false
-            }, 100, 'variables');
+            updaterRow
+                .update({ status: "Creating variables" })
+                .replaceSpinner(SPINNER_ARC);
+            const sitesService = await getSitesService();
+            const { variables } = await paginate(async (args) => {
+                return await sitesService.listVariables({ siteId: args.siteId });
+            }, {
+                siteId: site["$id"],
+            }, 100, "variables");
             await Promise.all(variables.map(async (variable) => {
-                await (0, sites_1.sitesDeleteVariable)({
-                    siteId: site['$id'],
-                    variableId: variable['$id'],
-                    parseOutput: false
+                const sitesService = await getSitesService();
+                await sitesService.deleteVariable({
+                    siteId: site["$id"],
+                    variableId: variable["$id"],
                 });
             }));
-            const envFileLocation = `${site['path']}/.env`;
+            const envFileLocation = `${site["path"]}/.env`;
             let envVariables = [];
             try {
                 if (fs.existsSync(envFileLocation)) {
-                    const envObject = (0, dotenv_1.parse)(fs.readFileSync(envFileLocation, 'utf8'));
+                    const envObject = parseDotenv(fs.readFileSync(envFileLocation, "utf8"));
                     envVariables = Object.entries(envObject || {}).map(([key, value]) => ({ key, value }));
                 }
             }
@@ -1051,196 +1036,229 @@ const pushSite = async ({ siteId, async: asyncDeploy, code, withVariables } = {
                 envVariables = [];
             }
             await Promise.all(envVariables.map(async (variable) => {
-                await (0, sites_1.sitesCreateVariable)({
-                    siteId: site['$id'],
+                const sitesService = await getSitesService();
+                await sitesService.createVariable({
+                    siteId: site["$id"],
                     key: variable.key,
                     value: variable.value,
-                    parseOutput: false,
-                    secret: false
+                    secret: false,
                 });
             }));
         }
         if (code === false) {
             successfullyPushed++;
             successfullyDeployed++;
-            updaterRow.update({ status: 'Pushed' });
+            updaterRow.update({ status: "Pushed" });
             updaterRow.stopSpinner();
             return;
         }
         try {
-            updaterRow.update({ status: 'Pushing' }).replaceSpinner(spinner_1.SPINNER_ARC);
-            response = await (0, sites_1.sitesCreateDeployment)({
-                siteId: site['$id'],
-                buildCommand: site.buildCommand,
+            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,
-                fallbackFile: site.fallbackFile,
                 code: site.path,
                 activate: true,
-                parseOutput: false
             });
-            updaterRow.update({ status: 'Pushed' });
+            updaterRow.update({ status: "Pushed" });
             deploymentCreated = true;
             successfullyPushed++;
         }
         catch (e) {
             errors.push(e);
             switch (e.code) {
-                case 'ENOENT':
-                    updaterRow.fail({ errorMessage: 'Not found in the current directory. Skipping...' });
+                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.' });
+                    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...' });
+                const deploymentId = response["$id"];
+                updaterRow.update({
+                    status: "Deploying",
+                    end: "Checking deployment status...",
+                });
                 let pollChecks = 0;
                 while (true) {
-                    response = await (0, sites_1.sitesGetDeployment)({
-                        siteId: site['$id'],
+                    const sitesService = await getSitesService();
+                    response = await sitesService.getDeployment({
+                        siteId: site["$id"],
                         deploymentId: deploymentId,
-                        parseOutput: false
                     });
-                    const status = response['status'];
-                    if (status === 'ready') {
+                    const status = response["status"];
+                    if (status === "ready") {
                         successfullyDeployed++;
-                        let url = '';
-                        const res = await (0, proxy_1.proxyListRules)({
-                            parseOutput: false,
-                            queries: [
-                                JSON.stringify({ method: 'limit', values: [1] }),
-                                JSON.stringify({ method: 'equal', "attribute": "deploymentResourceType", "values": ["site"] }),
-                                JSON.stringify({ method: 'equal', "attribute": "deploymentResourceId", "values": [site['$id']] }),
-                                JSON.stringify({ method: 'equal', "attribute": "trigger", "values": ["manual"] }),
-                            ],
-                        });
+                        let url = "";
+                        const proxyService = await getProxyService();
+                        const res = await proxyService.listRules([
+                            JSON.stringify({ method: "limit", values: [1] }),
+                            JSON.stringify({
+                                method: "equal",
+                                attribute: "deploymentResourceType",
+                                values: ["site"],
+                            }),
+                            JSON.stringify({
+                                method: "equal",
+                                attribute: "deploymentResourceId",
+                                values: [site["$id"]],
+                            }),
+                            JSON.stringify({
+                                method: "equal",
+                                attribute: "trigger",
+                                values: ["manual"],
+                            }),
+                        ]);
                         if (Number(res.total) === 1) {
                             url = res.rules[0].domain;
                         }
-                        updaterRow.update({ status: 'Deployed', end: url });
+                        updaterRow.update({ status: "Deployed", end: url });
                         break;
                     }
-                    else if (status === 'failed') {
-                        failedDeployments.push({ name: site['name'], $id: site['$id'], deployment: response['$id'] });
+                    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}` });
+                        updaterRow.update({
+                            status: "Deploying",
+                            end: `Current status: ${status}`,
+                        });
                     }
                     pollChecks++;
-                    await new Promise(resolve => setTimeout(resolve, POLL_DEBOUNCE * 1.5));
+                    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE * 1.5));
                 }
             }
             catch (e) {
                 errors.push(e);
-                updaterRow.fail({ errorMessage: e.message ?? 'Unknown error occurred. Please try again' });
+                updaterRow.fail({
+                    errorMessage: e.message ?? "Unknown error occurred. Please try again",
+                });
             }
         }
         updaterRow.stopSpinner();
     }));
-    spinner_1.Spinner.stop();
+    Spinner.stop();
     failedDeployments.forEach((failed) => {
         const { name, deployment, $id } = failed;
-        const failUrl = `${config_1.globalConfig.getEndpoint().slice(0, -3)}/console/project-${config_1.localConfig.getProject().projectId}/sites/site-${$id}/deployments/deployment-${deployment}`;
-        (0, parser_1.error)(`Deployment of ${name} has failed. Check at ${failUrl} for more details\n`);
+        const failUrl = `${globalConfig.getEndpoint().slice(0, -3)}/console/project-${localConfig.getProject().projectId}/sites/site-${$id}/deployments/deployment-${deployment}`;
+        error(`Deployment of ${name} has failed. Check at ${failUrl} for more details\n`);
     });
     if (!asyncDeploy) {
         if (successfullyPushed === 0) {
-            (0, parser_1.error)('No sites were pushed.');
+            error("No sites were pushed.");
         }
         else if (successfullyDeployed !== successfullyPushed) {
-            (0, parser_1.warn)(`Successfully pushed ${successfullyDeployed} of ${successfullyPushed} sites`);
+            warn(`Successfully pushed ${successfullyDeployed} of ${successfullyPushed} sites`);
         }
         else {
-            (0, parser_1.success)(`Successfully pushed ${successfullyPushed} sites.`);
+            success(`Successfully pushed ${successfullyPushed} sites.`);
         }
     }
     else {
-        (0, parser_1.success)(`Successfully pushed ${successfullyPushed} sites.`);
+        success(`Successfully pushed ${successfullyPushed} sites.`);
     }
-    if (parser_1.cliConfig.verbose) {
-        errors.forEach(e => {
+    if (cliConfig.verbose) {
+        errors.forEach((e) => {
             console.error(e);
         });
     }
 };
-const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariables } = { returnOnZero: false }) => {
-    process.chdir(config_1.localConfig.configDirectoryPath);
+const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariables, } = {}) => {
+    process.chdir(localConfig.configDirectoryPath);
     const functionIds = [];
     if (functionId) {
         functionIds.push(functionId);
     }
-    else if (parser_1.cliConfig.all) {
-        (0, utils_1.checkDeployConditions)(config_1.localConfig);
-        const functions = config_1.localConfig.getFunctions();
+    else if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        const functions = localConfig.getFunctions();
         functionIds.push(...functions.map((func) => {
             return func.$id;
         }));
     }
     if (functionIds.length <= 0) {
-        const answers = await inquirer_1.default.prompt(questions_1.questionsPushFunctions[0]);
+        const answers = await inquirer.prompt(questionsPushFunctions);
         if (answers.functions) {
             functionIds.push(...answers.functions);
         }
     }
     if (functionIds.length === 0) {
-        (0, parser_1.log)("No functions found.");
-        (0, parser_1.hint)("Use 'appwrite pull functions' to synchronize existing one, or use 'appwrite init function' to create a new one.");
+        log("No functions found.");
+        hint("Use 'appwrite pull functions' to synchronize existing one, or use 'appwrite init function' to create a new one.");
         return;
     }
     let functions = functionIds.map((id) => {
-        const functions = config_1.localConfig.getFunctions();
+        const functions = localConfig.getFunctions();
         const func = functions.find((f) => f.$id === id);
         if (!func) {
             throw new Error("Function '" + id + "' not found.");
         }
         return func;
     });
-    (0, parser_1.log)('Validating functions ...');
+    log("Validating functions ...");
     // Validation is done BEFORE pushing so the deployment process can be run in async with progress update
     for (let func of functions) {
         if (!func.entrypoint) {
-            (0, parser_1.log)(`Function ${func.name} is missing an entrypoint.`);
-            const answers = await inquirer_1.default.prompt(questions_1.questionsGetEntrypoint);
+            log(`Function ${func.name} is missing an entrypoint.`);
+            const answers = await inquirer.prompt(questionsGetEntrypoint);
             func.entrypoint = answers.entrypoint;
-            config_1.localConfig.addFunction(func);
+            localConfig.addFunction(func);
         }
     }
-    if (!(await approveChanges(functions, functions_1.functionsGet, config_1.KeysFunction, 'functionId', 'functions', ['vars']))) {
+    if (!(await approveChanges(functions, async (args) => {
+        const functionsService = await getFunctionsService();
+        return await functionsService.get({ functionId: args.functionId });
+    }, KeysFunction, "functionId", "functions", ["vars"]))) {
         return;
     }
-    (0, parser_1.log)('Pushing functions ...');
-    spinner_1.Spinner.start(false);
+    log("Pushing functions ...");
+    Spinner.start(false);
     let successfullyPushed = 0;
     let successfullyDeployed = 0;
     const failedDeployments = [];
     const errors = [];
     await Promise.all(functions.map(async (func) => {
         let response = {};
-        const ignore = func.ignore ? 'appwrite.config.json' : '.gitignore';
+        const ignore = func.ignore ? "appwrite.config.json" : ".gitignore";
         let functionExists = false;
         let deploymentCreated = false;
-        const updaterRow = new spinner_1.Spinner({ status: '', resource: func.name, id: func['$id'], end: `Ignoring using: ${ignore}` });
-        updaterRow.update({ status: 'Getting' }).startSpinner(spinner_1.SPINNER_DOTS);
+        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 (0, functions_1.functionsGet)({
-                functionId: func['$id'],
-                parseOutput: false,
-            });
+            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` });
+                updaterRow.fail({
+                    errorMessage: `Runtime mismatch! (local=${func.runtime},remote=${response.runtime}) Please delete remote function or update your appwrite.config.json`,
+                });
                 return;
             }
-            updaterRow.update({ status: 'Updating' }).replaceSpinner(spinner_1.SPINNER_ARC);
-            response = await (0, functions_1.functionsUpdate)({
-                functionId: func['$id'],
+            updaterRow.update({ status: "Updating" }).replaceSpinner(SPINNER_ARC);
+            response = await functionsService.update({
+                functionId: func["$id"],
                 name: func.name,
-                specification: func.specification,
+                runtime: func.runtime,
                 execute: func.execute,
                 events: func.events,
                 schedule: func.schedule,
@@ -1250,8 +1268,7 @@ const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariable
                 entrypoint: func.entrypoint,
                 commands: func.commands,
                 scopes: func.scopes,
-                vars: JSON.stringify(response.vars),
-                parseOutput: false
+                specification: func.specification,
             });
         }
         catch (e) {
@@ -1260,18 +1277,19 @@ const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariable
             }
             else {
                 errors.push(e);
-                updaterRow.fail({ errorMessage: e.message ?? 'General error occurs please try again' });
+                updaterRow.fail({
+                    errorMessage: e.message ?? "General error occurs please try again",
+                });
                 return;
             }
         }
         if (!functionExists) {
-            updaterRow.update({ status: 'Creating' }).replaceSpinner(spinner_1.SPINNER_DOTS);
+            updaterRow.update({ status: "Creating" }).replaceSpinner(SPINNER_DOTS);
             try {
-                response = await (0, functions_1.functionsCreate)({
+                response = await functionsService.create({
                     functionId: func.$id,
                     name: func.name,
                     runtime: func.runtime,
-                    specification: func.specification,
                     execute: func.execute,
                     events: func.events,
                     schedule: func.schedule,
@@ -1281,53 +1299,60 @@ const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariable
                     entrypoint: func.entrypoint,
                     commands: func.commands,
                     scopes: func.scopes,
-                    parseOutput: false
+                    specification: func.specification,
                 });
-                let domain = '';
+                let domain = "";
                 try {
-                    const variables = await (0, console_1.consoleVariables)({ parseOutput: false, sdk: await (0, sdks_1.sdkForConsole)() });
-                    domain = id_1.default.unique() + '.' + variables['_APP_DOMAIN_FUNCTIONS'];
+                    const consoleService = await getConsoleService();
+                    const variables = await consoleService.variables();
+                    domain = ID.unique() + "." + variables["_APP_DOMAIN_FUNCTIONS"];
                 }
                 catch (error) {
-                    console.error('Error fetching console variables.');
+                    console.error("Error fetching console variables.");
                     throw error;
                 }
                 try {
-                    const rule = await (0, proxy_1.proxyCreateFunctionRule)({
-                        domain: domain,
-                        functionId: func.$id
-                    });
+                    const proxyService = await getProxyService();
+                    const rule = await proxyService.createFunctionRule(domain, func.$id);
                 }
                 catch (error) {
-                    console.error('Error creating function rule.');
+                    console.error("Error creating function rule.");
                     throw error;
                 }
-                updaterRow.update({ status: 'Created' });
+                updaterRow.update({ status: "Created" });
             }
             catch (e) {
                 errors.push(e);
-                updaterRow.fail({ errorMessage: e.message ?? 'General error occurs please try again' });
+                updaterRow.fail({
+                    errorMessage: e.message ?? "General error occurs please try again",
+                });
                 return;
             }
         }
         if (withVariables) {
-            updaterRow.update({ status: 'Updating variables' }).replaceSpinner(spinner_1.SPINNER_ARC);
-            const { variables } = await (0, paginate_1.paginate)(functions_1.functionsListVariables, {
-                functionId: func['$id'],
-                parseOutput: false
-            }, 100, 'variables');
+            updaterRow
+                .update({ status: "Updating variables" })
+                .replaceSpinner(SPINNER_ARC);
+            const functionsService = await getFunctionsService();
+            const { variables } = await paginate(async (args) => {
+                return await functionsService.listVariables({
+                    functionId: args.functionId,
+                });
+            }, {
+                functionId: func["$id"],
+            }, 100, "variables");
             await Promise.all(variables.map(async (variable) => {
-                await (0, functions_1.functionsDeleteVariable)({
-                    functionId: func['$id'],
-                    variableId: variable['$id'],
-                    parseOutput: false
+                const functionsService = await getFunctionsService();
+                await functionsService.deleteVariable({
+                    functionId: func["$id"],
+                    variableId: variable["$id"],
                 });
             }));
-            const envFileLocation = `${func['path']}/.env`;
+            const envFileLocation = `${func["path"]}/.env`;
             let envVariables = [];
             try {
                 if (fs.existsSync(envFileLocation)) {
-                    const envObject = (0, dotenv_1.parse)(fs.readFileSync(envFileLocation, 'utf8'));
+                    const envObject = parseDotenv(fs.readFileSync(envFileLocation, "utf8"));
                     envVariables = Object.entries(envObject || {}).map(([key, value]) => ({ key, value }));
                 }
             }
@@ -1336,126 +1361,154 @@ const pushFunction = async ({ functionId, async: asyncDeploy, code, withVariable
                 envVariables = [];
             }
             await Promise.all(envVariables.map(async (variable) => {
-                await (0, functions_1.functionsCreateVariable)({
-                    functionId: func['$id'],
-                    variableId: id_1.default.unique(),
+                const functionsService = await getFunctionsService();
+                await functionsService.createVariable({
+                    functionId: func["$id"],
                     key: variable.key,
                     value: variable.value,
-                    parseOutput: false,
-                    secret: false
+                    secret: false,
                 });
             }));
         }
         if (code === false) {
             successfullyPushed++;
             successfullyDeployed++;
-            updaterRow.update({ status: 'Pushed' });
+            updaterRow.update({ status: "Pushed" });
             updaterRow.stopSpinner();
             return;
         }
         try {
-            updaterRow.update({ status: 'Pushing' }).replaceSpinner(spinner_1.SPINNER_ARC);
-            response = await (0, functions_1.functionsCreateDeployment)({
-                functionId: func['$id'],
+            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,
-                parseOutput: false
             });
-            updaterRow.update({ status: 'Pushed' });
+            updaterRow.update({ status: "Pushed" });
             deploymentCreated = true;
             successfullyPushed++;
         }
         catch (e) {
             errors.push(e);
             switch (e.code) {
-                case 'ENOENT':
-                    updaterRow.fail({ errorMessage: 'Not found in the current directory. Skipping...' });
+                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.' });
+                    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...' });
+                const deploymentId = response["$id"];
+                updaterRow.update({
+                    status: "Deploying",
+                    end: "Checking deployment status...",
+                });
                 let pollChecks = 0;
                 while (true) {
-                    response = await (0, functions_1.functionsGetDeployment)({
-                        functionId: func['$id'],
+                    const functionsService = await getFunctionsService();
+                    response = await functionsService.getDeployment({
+                        functionId: func["$id"],
                         deploymentId: deploymentId,
-                        parseOutput: false
                     });
-                    const status = response['status'];
-                    if (status === 'ready') {
+                    const status = response["status"];
+                    if (status === "ready") {
                         successfullyDeployed++;
-                        let url = '';
-                        const res = await (0, proxy_1.proxyListRules)({
-                            parseOutput: false,
-                            queries: [
-                                JSON.stringify({ method: 'limit', values: [1] }),
-                                JSON.stringify({ method: 'equal', "attribute": "deploymentResourceType", "values": ["function"] }),
-                                JSON.stringify({ method: 'equal', "attribute": "deploymentResourceId", "values": [func['$id']] }),
-                                JSON.stringify({ method: 'equal', "attribute": "trigger", "values": ["manual"] }),
-                            ],
-                        });
+                        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 });
+                        updaterRow.update({ status: "Deployed", end: url });
                         break;
                     }
-                    else if (status === 'failed') {
-                        failedDeployments.push({ name: func['name'], $id: func['$id'], deployment: response['$id'] });
+                    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}` });
+                        updaterRow.update({
+                            status: "Deploying",
+                            end: `Current status: ${status}`,
+                        });
                     }
                     pollChecks++;
-                    await new Promise(resolve => setTimeout(resolve, POLL_DEBOUNCE * 1.5));
+                    await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE * 1.5));
                 }
             }
             catch (e) {
                 errors.push(e);
-                updaterRow.fail({ errorMessage: e.message ?? 'Unknown error occurred. Please try again' });
+                updaterRow.fail({
+                    errorMessage: e.message ?? "Unknown error occurred. Please try again",
+                });
             }
         }
         updaterRow.stopSpinner();
     }));
-    spinner_1.Spinner.stop();
+    Spinner.stop();
     failedDeployments.forEach((failed) => {
         const { name, deployment, $id } = failed;
-        const failUrl = `${config_1.globalConfig.getEndpoint().slice(0, -3)}/console/project-${config_1.localConfig.getProject().projectId}/functions/function-${$id}/deployment-${deployment}`;
-        (0, parser_1.error)(`Deployment of ${name} has failed. Check at ${failUrl} for more details\n`);
+        const failUrl = `${globalConfig.getEndpoint().slice(0, -3)}/console/project-${localConfig.getProject().projectId}/functions/function-${$id}/deployment-${deployment}`;
+        error(`Deployment of ${name} has failed. Check at ${failUrl} for more details\n`);
     });
     if (!asyncDeploy) {
         if (successfullyPushed === 0) {
-            (0, parser_1.error)('No functions were pushed.');
+            error("No functions were pushed.");
         }
         else if (successfullyDeployed !== successfullyPushed) {
-            (0, parser_1.warn)(`Successfully pushed ${successfullyDeployed} of ${successfullyPushed} functions`);
+            warn(`Successfully pushed ${successfullyDeployed} of ${successfullyPushed} functions`);
         }
         else {
-            (0, parser_1.success)(`Successfully pushed ${successfullyPushed} functions.`);
+            success(`Successfully pushed ${successfullyPushed} functions.`);
         }
     }
     else {
-        (0, parser_1.success)(`Successfully pushed ${successfullyPushed} functions.`);
+        success(`Successfully pushed ${successfullyPushed} functions.`);
     }
-    if (parser_1.cliConfig.verbose) {
-        errors.forEach(e => {
+    if (cliConfig.verbose) {
+        errors.forEach((e) => {
             console.error(e);
         });
     }
 };
 const checkAndApplyTablesDBChanges = async () => {
-    (0, parser_1.log)('Checking for tablesDB changes ...');
-    const localTablesDBs = config_1.localConfig.getTablesDBs();
-    const { databases: remoteTablesDBs } = await (0, paginate_1.paginate)(tables_db_1.tablesDBList, { parseOutput: false }, 100, 'databases');
+    log("Checking for tablesDB changes ...");
+    const localTablesDBs = localConfig.getTablesDBs();
+    const { databases: remoteTablesDBs } = await paginate(async (args) => {
+        const tablesDBService = await getTablesDBService();
+        return await tablesDBService.list(args.queries || []);
+    }, {}, 100, "databases");
     if (localTablesDBs.length === 0 && remoteTablesDBs.length === 0) {
         return { applied: false, resyncNeeded: false };
     }
@@ -1470,10 +1523,10 @@ const checkAndApplyTablesDBChanges = async () => {
             toDelete.push(remoteDB);
             changes.push({
                 id: remoteDB.$id,
-                action: chalk_1.default.red('deleting'),
-                key: 'Database',
+                action: chalk.red("deleting"),
+                key: "Database",
                 remote: remoteDB.name,
-                local: '(deleted locally)'
+                local: "(deleted locally)",
             });
         }
     }
@@ -1484,10 +1537,10 @@ const checkAndApplyTablesDBChanges = async () => {
             toCreate.push(localDB);
             changes.push({
                 id: localDB.$id,
-                action: chalk_1.default.green('creating'),
-                key: 'Database',
-                remote: '(does not exist)',
-                local: localDB.name
+                action: chalk.green("creating"),
+                key: "Database",
+                remote: "(does not exist)",
+                local: localDB.name,
             });
         }
         else {
@@ -1496,20 +1549,20 @@ const checkAndApplyTablesDBChanges = async () => {
                 hasChanges = true;
                 changes.push({
                     id: localDB.$id,
-                    action: chalk_1.default.yellow('updating'),
-                    key: 'Name',
+                    action: chalk.yellow("updating"),
+                    key: "Name",
                     remote: remoteDB.name,
-                    local: localDB.name
+                    local: localDB.name,
                 });
             }
             if (remoteDB.enabled !== localDB.enabled) {
                 hasChanges = true;
                 changes.push({
                     id: localDB.$id,
-                    action: chalk_1.default.yellow('updating'),
-                    key: 'Enabled',
+                    action: chalk.yellow("updating"),
+                    key: "Enabled",
                     remote: remoteDB.enabled,
-                    local: localDB.enabled
+                    local: localDB.enabled,
                 });
             }
             if (hasChanges) {
@@ -1518,16 +1571,14 @@ const checkAndApplyTablesDBChanges = async () => {
         }
     }
     if (changes.length === 0) {
-        console.log('No changes found in tablesDB resource');
-        console.log();
         return { applied: false, resyncNeeded: false };
     }
-    (0, parser_1.log)('Found changes in tablesDB resource:');
-    (0, parser_1.drawTable)(changes);
+    log("Found changes in tablesDB resource:");
+    drawTable(changes);
     if (toDelete.length > 0) {
-        console.log(`${chalk_1.default.red('------------------------------------------------------------------')}`);
-        console.log(`${chalk_1.default.red('| WARNING: Database deletion will also delete all related tables |')}`);
-        console.log(`${chalk_1.default.red('------------------------------------------------------------------')}`);
+        console.log(`${chalk.red("------------------------------------------------------------------")}`);
+        console.log(`${chalk.red("| WARNING: Database deletion will also delete all related tables |")}`);
+        console.log(`${chalk.red("------------------------------------------------------------------")}`);
         console.log();
     }
     if ((await getConfirmation()) !== true) {
@@ -1537,50 +1588,40 @@ const checkAndApplyTablesDBChanges = async () => {
     let needsResync = false;
     for (const db of toDelete) {
         try {
-            (0, parser_1.log)(`Deleting database ${db.name} ( ${db.$id} ) ...`);
-            await (0, tables_db_1.tablesDBDelete)({
-                databaseId: db.$id,
-                parseOutput: false
-            });
-            (0, parser_1.success)(`Deleted ${db.name} ( ${db.$id} )`);
+            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) {
-            (0, parser_1.error)(`Failed to delete database ${db.name} ( ${db.$id} ): ${e.message}`);
+            error(`Failed to delete database ${db.name} ( ${db.$id} ): ${e.message}`);
             throw new Error(`Database sync failed during deletion of ${db.$id}. Some changes may have been applied.`);
         }
     }
     // Apply creations
     for (const db of toCreate) {
         try {
-            (0, parser_1.log)(`Creating database ${db.name} ( ${db.$id} ) ...`);
-            await (0, tables_db_1.tablesDBCreate)({
-                databaseId: db.$id,
-                name: db.name,
-                enabled: db.enabled,
-                parseOutput: false
-            });
-            (0, parser_1.success)(`Created ${db.name} ( ${db.$id} )`);
+            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) {
-            (0, parser_1.error)(`Failed to create database ${db.name} ( ${db.$id} ): ${e.message}`);
+            error(`Failed to create database ${db.name} ( ${db.$id} ): ${e.message}`);
             throw new Error(`Database sync failed during creation of ${db.$id}. Some changes may have been applied.`);
         }
     }
     // Apply updates
     for (const db of toUpdate) {
         try {
-            (0, parser_1.log)(`Updating database ${db.name} ( ${db.$id} ) ...`);
-            await (0, tables_db_1.tablesDBUpdate)({
-                databaseId: db.$id,
-                name: db.name,
-                enabled: db.enabled,
-                parseOutput: false
-            });
-            (0, parser_1.success)(`Updated ${db.name} ( ${db.$id} )`);
+            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) {
-            (0, parser_1.error)(`Failed to update database ${db.name} ( ${db.$id} ): ${e.message}`);
+            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.`);
         }
     }
@@ -1589,42 +1630,47 @@ const checkAndApplyTablesDBChanges = async () => {
     }
     return { applied: true, resyncNeeded: needsResync };
 };
-const pushTable = async ({ returnOnZero, attempts } = { returnOnZero: false }) => {
+const pushTable = async ({ attempts, } = {}) => {
     const tables = [];
     if (attempts) {
         pollMaxDebounces = attempts;
     }
     const { applied: tablesDBApplied, resyncNeeded } = await checkAndApplyTablesDBChanges();
     if (resyncNeeded) {
-        (0, parser_1.log)('Resyncing configuration due to tablesDB deletions ...');
-        const remoteTablesDBs = (await (0, paginate_1.paginate)(tables_db_1.tablesDBList, { parseOutput: false }, 100, 'databases')).databases;
-        const localTablesDBs = config_1.localConfig.getTablesDBs();
+        log("Resyncing configuration due to tablesDB deletions ...");
+        const remoteTablesDBs = (await paginate(async (args) => {
+            const tablesDBService = await getTablesDBService();
+            return await tablesDBService.list(args.queries || []);
+        }, {}, 100, "databases")).databases;
+        const localTablesDBs = localConfig.getTablesDBs();
         const remoteDatabaseIds = new Set(remoteTablesDBs.map((db) => db.$id));
-        const localTables = config_1.localConfig.getTables();
+        const localTables = localConfig.getTables();
         const validTables = localTables.filter((table) => remoteDatabaseIds.has(table.databaseId));
-        config_1.localConfig.set('tables', validTables);
+        localConfig.set("tables", validTables);
         const validTablesDBs = localTablesDBs.filter((db) => remoteDatabaseIds.has(db.$id));
-        config_1.localConfig.set('tablesDB', validTablesDBs);
-        (0, parser_1.success)('Configuration resynced successfully.');
+        localConfig.set("tablesDB", validTablesDBs);
+        success("Configuration resynced successfully.");
         console.log();
     }
-    (0, parser_1.log)('Checking for deleted tables ...');
-    const localTablesDBs = config_1.localConfig.getTablesDBs();
-    const localTables = config_1.localConfig.getTables();
+    log("Checking for deleted tables ...");
+    const localTablesDBs = localConfig.getTablesDBs();
+    const localTables = localConfig.getTables();
     const tablesToDelete = [];
     for (const db of localTablesDBs) {
         try {
-            const { tables: remoteTables } = await (0, paginate_1.paginate)(tables_db_1.tablesDBListTables, {
+            const { tables: remoteTables } = await paginate(async (args) => {
+                const tablesDBService = await getTablesDBService();
+                return await tablesDBService.listTables(args.databaseId, args.queries || []);
+            }, {
                 databaseId: db.$id,
-                parseOutput: false
-            }, 100, 'tables');
+            }, 100, "tables");
             for (const remoteTable of remoteTables) {
                 const localTable = localTables.find((t) => t.$id === remoteTable.$id && t.databaseId === db.$id);
                 if (!localTable) {
                     tablesToDelete.push({
                         ...remoteTable,
                         databaseId: db.$id,
-                        databaseName: db.name
+                        databaseName: db.name,
                     });
                 }
             }
@@ -1634,47 +1680,40 @@ const pushTable = async ({ returnOnZero, attempts } = { returnOnZero: false }) =
         }
     }
     if (tablesToDelete.length > 0) {
-        (0, parser_1.log)('Found tables that exist remotely but not locally:');
+        log("Found tables that exist remotely but not locally:");
         const deletionChanges = tablesToDelete.map((table) => ({
             id: table.$id,
-            action: chalk_1.default.red('deleting'),
-            key: 'Table',
+            action: chalk.red("deleting"),
+            key: "Table",
             database: table.databaseName,
             remote: table.name,
-            local: '(deleted locally)'
+            local: "(deleted locally)",
         }));
-        (0, parser_1.drawTable)(deletionChanges);
+        drawTable(deletionChanges);
         if ((await getConfirmation()) === true) {
             for (const table of tablesToDelete) {
                 try {
-                    (0, parser_1.log)(`Deleting table ${table.name} ( ${table.$id} ) from database ${table.databaseName} ...`);
-                    await (0, tables_db_1.tablesDBDeleteTable)({
-                        databaseId: table.databaseId,
-                        tableId: table.$id,
-                        parseOutput: false
-                    });
-                    (0, parser_1.success)(`Deleted ${table.name} ( ${table.$id} )`);
+                    log(`Deleting table ${table.name} ( ${table.$id} ) from database ${table.databaseName} ...`);
+                    const tablesDBService = await getTablesDBService();
+                    await tablesDBService.deleteTable(table.databaseId, table.$id);
+                    success(`Deleted ${table.name} ( ${table.$id} )`);
                 }
                 catch (e) {
-                    (0, parser_1.error)(`Failed to delete table ${table.name} ( ${table.$id} ): ${e.message}`);
+                    error(`Failed to delete table ${table.name} ( ${table.$id} ): ${e.message}`);
                 }
             }
         }
     }
-    else {
-        console.log('No tables found to delete');
-    }
-    console.log();
-    if (parser_1.cliConfig.all) {
-        (0, utils_1.checkDeployConditions)(config_1.localConfig);
-        tables.push(...config_1.localConfig.getTables());
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        tables.push(...localConfig.getTables());
     }
     else {
-        const answers = await inquirer_1.default.prompt(questions_1.questionsPushTables);
+        const answers = await inquirer.prompt(questionsPushTables);
         if (answers.tables) {
             const configTables = new Map();
-            config_1.localConfig.getTables().forEach((c) => {
-                configTables.set(`${c['databaseId']}|${c['$id']}`, c);
+            localConfig.getTables().forEach((c) => {
+                configTables.set(`${c["databaseId"]}|${c["$id"]}`, c);
             });
             answers.tables.forEach((a) => {
                 const table = configTables.get(a);
@@ -1683,59 +1722,47 @@ const pushTable = async ({ returnOnZero, attempts } = { returnOnZero: false }) =
         }
     }
     if (tables.length === 0) {
-        (0, parser_1.log)("No tables found.");
-        (0, parser_1.hint)("Use 'appwrite pull tables' to synchronize existing one, or use 'appwrite init table' to create a new one.");
+        log("No tables found.");
+        hint("Use 'appwrite pull tables' to synchronize existing one, or use 'appwrite init table' to create a new one.");
         return;
     }
-    if (!(await approveChanges(tables, tables_db_1.tablesDBGetTable, config_1.KeysTable, 'tableId', 'tables', ['columns', 'indexes'], 'databaseId', 'databaseId'))) {
+    if (!(await approveChanges(tables, async (args) => {
+        const tablesDBService = await getTablesDBService();
+        return await tablesDBService.getTable(args.databaseId, args.tableId);
+    }, KeysTable, "tableId", "tables", ["columns", "indexes"], "databaseId", "databaseId"))) {
         return;
     }
     let tablesChanged = new Set();
     // Parallel tables actions
     await Promise.all(tables.map(async (table) => {
         try {
-            const remoteTable = await (0, tables_db_1.tablesDBGetTable)({
-                databaseId: table['databaseId'],
-                tableId: table['$id'],
-                parseOutput: false,
-            });
+            const tablesDBService = await getTablesDBService();
+            const remoteTable = await tablesDBService.getTable(table["databaseId"], table["$id"]);
             const changes = [];
             if (remoteTable.name !== table.name)
-                changes.push('name');
+                changes.push("name");
             if (remoteTable.rowSecurity !== table.rowSecurity)
-                changes.push('rowSecurity');
+                changes.push("rowSecurity");
             if (remoteTable.enabled !== table.enabled)
-                changes.push('enabled');
-            if (JSON.stringify(remoteTable['$permissions']) !== JSON.stringify(table['$permissions']))
-                changes.push('permissions');
+                changes.push("enabled");
+            if (JSON.stringify(remoteTable["$permissions"]) !==
+                JSON.stringify(table["$permissions"]))
+                changes.push("permissions");
             if (changes.length > 0) {
-                await (0, tables_db_1.tablesDBUpdateTable)({
-                    databaseId: table['databaseId'],
-                    tableId: table['$id'],
-                    name: table.name,
-                    parseOutput: false,
-                    rowSecurity: table.rowSecurity,
-                    permissions: table['$permissions']
-                });
-                (0, parser_1.success)(`Updated ${table.name} ( ${table['$id']} ) - ${changes.join(', ')}`);
-                tablesChanged.add(table['$id']);
+                await tablesDBService.updateTable(table["databaseId"], table["$id"], table.name, table.rowSecurity, table["$permissions"]);
+                success(`Updated ${table.name} ( ${table["$id"]} ) - ${changes.join(", ")}`);
+                tablesChanged.add(table["$id"]);
             }
             table.remoteVersion = remoteTable;
             table.isExisted = true;
         }
         catch (e) {
             if (Number(e.code) === 404) {
-                (0, parser_1.log)(`Table ${table.name} does not exist in the project. Creating ... `);
-                await (0, tables_db_1.tablesDBCreateTable)({
-                    databaseId: table['databaseId'],
-                    tableId: table['$id'],
-                    name: table.name,
-                    rowSecurity: table.rowSecurity,
-                    permissions: table['$permissions'],
-                    parseOutput: false
-                });
-                (0, parser_1.success)(`Created ${table.name} ( ${table['$id']} )`);
-                tablesChanged.add(table['$id']);
+                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;
@@ -1749,11 +1776,14 @@ const pushTable = async ({ returnOnZero, attempts } = { returnOnZero: false }) =
         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)) {
+            if (Array.isArray(columns) &&
+                columns.length <= 0 &&
+                Array.isArray(indexes) &&
+                indexes.length <= 0) {
                 continue;
             }
         }
-        (0, parser_1.log)(`Pushing table ${table.name} ( ${table['databaseId']} - ${table['$id']} ) attributes`);
+        log(`Pushing table ${table.name} ( ${table["databaseId"]} - ${table["$id"]} ) attributes`);
         try {
             await createColumns(columns, table);
         }
@@ -1766,27 +1796,27 @@ const pushTable = async ({ returnOnZero, attempts } = { returnOnZero: false }) =
         catch (e) {
             throw e;
         }
-        tablesChanged.add(table['$id']);
-        (0, parser_1.success)(`Successfully pushed ${table.name} ( ${table['$id']} )`);
+        tablesChanged.add(table["$id"]);
+        success(`Successfully pushed ${table.name} ( ${table["$id"]} )`);
     }
-    (0, parser_1.success)(`Successfully pushed ${tablesChanged.size} tables`);
+    success(`Successfully pushed ${tablesChanged.size} tables`);
 };
-const pushCollection = async ({ returnOnZero, attempts } = { returnOnZero: false }) => {
-    (0, parser_1.warn)("appwrite push collection has been deprecated. Please consider using 'appwrite push tables' instead");
+const pushCollection = async ({ attempts }) => {
+    warn("appwrite push collection has been deprecated. Please consider using 'appwrite push tables' instead");
     const collections = [];
     if (attempts) {
         pollMaxDebounces = attempts;
     }
-    if (parser_1.cliConfig.all) {
-        (0, utils_1.checkDeployConditions)(config_1.localConfig);
-        collections.push(...config_1.localConfig.getCollections());
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
+        collections.push(...localConfig.getCollections());
     }
     else {
-        const answers = await inquirer_1.default.prompt(questions_1.questionsPushCollections);
+        const answers = await inquirer.prompt(questionsPushCollections);
         if (answers.collections) {
             const configCollections = new Map();
-            config_1.localConfig.getCollections().forEach((c) => {
-                configCollections.set(`${c['databaseId']}|${c['$id']}`, c);
+            localConfig.getCollections().forEach((c) => {
+                configCollections.set(`${c["databaseId"]}|${c["$id"]}`, c);
             });
             answers.collections.forEach((a) => {
                 const collection = configCollections.get(a);
@@ -1795,71 +1825,50 @@ const pushCollection = async ({ returnOnZero, attempts } = { returnOnZero: false
         }
     }
     if (collections.length === 0) {
-        (0, parser_1.log)("No collections found.");
-        (0, parser_1.hint)("Use 'appwrite pull collections' to synchronize existing one, or use 'appwrite init collection' to create a new one.");
+        log("No collections found.");
+        hint("Use 'appwrite pull collections' to synchronize existing one, or use 'appwrite init collection' to create a new one.");
         return;
     }
-    const databases = Array.from(new Set(collections.map((collection) => collection['databaseId'])));
+    const databases = Array.from(new Set(collections.map((collection) => collection["databaseId"])));
     // Parallel db actions
     await Promise.all(databases.map(async (databaseId) => {
-        const localDatabase = config_1.localConfig.getDatabase(databaseId);
+        const localDatabase = localConfig.getDatabase(databaseId);
+        const databasesService = await getDatabasesService();
         try {
-            const database = await (0, databases_1.databasesGet)({
-                databaseId: databaseId,
-                parseOutput: false,
-            });
+            const database = await databasesService.get(databaseId);
             if (database.name !== (localDatabase.name ?? databaseId)) {
-                await (0, databases_1.databasesUpdate)({
-                    databaseId: databaseId,
-                    name: localDatabase.name ?? databaseId,
-                    parseOutput: false
-                });
-                (0, parser_1.success)(`Updated ${localDatabase.name} ( ${databaseId} ) name`);
+                await databasesService.update(databaseId, localDatabase.name ?? databaseId);
+                success(`Updated ${localDatabase.name} ( ${databaseId} ) name`);
             }
         }
         catch (err) {
-            (0, parser_1.log)(`Database ${databaseId} not found. Creating it now ...`);
-            await (0, databases_1.databasesCreate)({
-                databaseId: databaseId,
-                name: localDatabase.name ?? databaseId,
-                parseOutput: false,
-            });
+            log(`Database ${databaseId} not found. Creating it now ...`);
+            await databasesService.create(databaseId, localDatabase.name ?? databaseId);
         }
     }));
-    if (!(await approveChanges(collections, databases_1.databasesGetCollection, config_1.KeysCollection, 'collectionId', 'collections', ['attributes', 'indexes'], 'databaseId', 'databaseId'))) {
+    if (!(await approveChanges(collections, async (args) => {
+        const databasesService = await getDatabasesService();
+        return await databasesService.getCollection(args.databaseId, args.collectionId);
+    }, KeysCollection, "collectionId", "collections", ["attributes", "indexes"], "databaseId", "databaseId"))) {
         return;
     }
     // Parallel collection actions
     await Promise.all(collections.map(async (collection) => {
         try {
-            const remoteCollection = await (0, databases_1.databasesGetCollection)({
-                databaseId: collection['databaseId'],
-                collectionId: collection['$id'],
-                parseOutput: false,
-            });
+            const databasesService = await getDatabasesService();
+            const remoteCollection = await databasesService.getCollection(collection["databaseId"], collection["$id"]);
             if (remoteCollection.name !== collection.name) {
-                await (0, databases_1.databasesUpdateCollection)({
-                    databaseId: collection['databaseId'],
-                    collectionId: collection['$id'],
-                    name: collection.name,
-                    parseOutput: false
-                });
-                (0, parser_1.success)(`Updated ${collection.name} ( ${collection['$id']} ) name`);
+                await databasesService.updateCollection(collection["databaseId"], collection["$id"], collection.name);
+                success(`Updated ${collection.name} ( ${collection["$id"]} ) name`);
             }
             collection.remoteVersion = remoteCollection;
             collection.isExisted = true;
         }
         catch (e) {
             if (Number(e.code) === 404) {
-                (0, parser_1.log)(`Collection ${collection.name} does not exist in the project. Creating ... `);
-                await (0, databases_1.databasesCreateCollection)({
-                    databaseId: collection['databaseId'],
-                    collectionId: collection['$id'],
-                    name: collection.name,
-                    documentSecurity: collection.documentSecurity,
-                    permissions: collection['$permissions'],
-                    parseOutput: false
-                });
+                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;
@@ -1874,11 +1883,14 @@ const pushCollection = async ({ returnOnZero, attempts } = { returnOnZero: false
         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)) {
+            if (Array.isArray(attributes) &&
+                attributes.length <= 0 &&
+                Array.isArray(indexes) &&
+                indexes.length <= 0) {
                 continue;
             }
         }
-        (0, parser_1.log)(`Pushing collection ${collection.name} ( ${collection['databaseId']} - ${collection['$id']} ) attributes`);
+        log(`Pushing collection ${collection.name} ( ${collection["databaseId"]} - ${collection["$id"]} ) attributes`);
         try {
             await createAttributes(attributes, collection);
         }
@@ -1892,27 +1904,27 @@ const pushCollection = async ({ returnOnZero, attempts } = { returnOnZero: false
             throw e;
         }
         numberOfCollections++;
-        (0, parser_1.success)(`Successfully pushed ${collection.name} ( ${collection['$id']} )`);
+        success(`Successfully pushed ${collection.name} ( ${collection["$id"]} )`);
     }
-    (0, parser_1.success)(`Successfully pushed ${numberOfCollections} collections`);
+    success(`Successfully pushed ${numberOfCollections} collections`);
 };
-const pushBucket = async ({ returnOnZero } = { returnOnZero: false }) => {
+const pushBucket = async () => {
     let response = {};
     let bucketIds = [];
-    const configBuckets = config_1.localConfig.getBuckets();
-    if (parser_1.cliConfig.all) {
-        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+    const configBuckets = localConfig.getBuckets();
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
         bucketIds.push(...configBuckets.map((b) => b.$id));
     }
     if (bucketIds.length === 0) {
-        const answers = await inquirer_1.default.prompt(questions_1.questionsPushBuckets[0]);
+        const answers = await inquirer.prompt(questionsPushBuckets);
         if (answers.buckets) {
             bucketIds.push(...answers.buckets);
         }
     }
     if (bucketIds.length === 0) {
-        (0, parser_1.log)("No buckets found.");
-        (0, parser_1.hint)("Use 'appwrite pull buckets' to synchronize existing one, or use 'appwrite init bucket' to create a new one.");
+        log("No buckets found.");
+        hint("Use 'appwrite pull buckets' to synchronize existing one, or use 'appwrite init bucket' to create a new one.");
         return;
     }
     let buckets = [];
@@ -1920,72 +1932,49 @@ const pushBucket = async ({ returnOnZero } = { returnOnZero: false }) => {
         const idBuckets = configBuckets.filter((b) => b.$id === bucketId);
         buckets.push(...idBuckets);
     }
-    if (!(await approveChanges(buckets, storage_1.storageGetBucket, config_1.KeysStorage, 'bucketId', 'buckets'))) {
+    if (!(await approveChanges(buckets, async (args) => {
+        const storageService = await getStorageService();
+        return await storageService.getBucket(args.bucketId);
+    }, KeysStorage, "bucketId", "buckets"))) {
         return;
     }
-    (0, parser_1.log)('Pushing buckets ...');
+    log("Pushing buckets ...");
     for (let bucket of buckets) {
-        (0, parser_1.log)(`Pushing bucket ${chalk_1.default.bold(bucket['name'])} ...`);
+        log(`Pushing bucket ${chalk.bold(bucket["name"])} ...`);
+        const storageService = await getStorageService();
         try {
-            response = await (0, storage_1.storageGetBucket)({
-                bucketId: bucket['$id'],
-                parseOutput: false,
-            });
-            await (0, storage_1.storageUpdateBucket)({
-                bucketId: bucket['$id'],
-                name: bucket.name,
-                permissions: bucket['$permissions'],
-                fileSecurity: bucket.fileSecurity,
-                enabled: bucket.enabled,
-                maximumFileSize: bucket.maximumFileSize,
-                allowedFileExtensions: bucket.allowedFileExtensions,
-                encryption: bucket.encryption,
-                antivirus: bucket.antivirus,
-                compression: bucket.compression,
-                parseOutput: false
-            });
+            response = await storageService.getBucket(bucket["$id"]);
+            await storageService.updateBucket(bucket["$id"], bucket.name, bucket["$permissions"], bucket.fileSecurity, bucket.enabled, bucket.maximumFileSize, bucket.allowedFileExtensions, bucket.encryption, bucket.antivirus, bucket.compression);
         }
         catch (e) {
             if (Number(e.code) === 404) {
-                (0, parser_1.log)(`Bucket ${bucket.name} does not exist in the project. Creating ... `);
-                response = await (0, storage_1.storageCreateBucket)({
-                    bucketId: bucket['$id'],
-                    name: bucket.name,
-                    permissions: bucket['$permissions'],
-                    fileSecurity: bucket.fileSecurity,
-                    enabled: bucket.enabled,
-                    maximumFileSize: bucket.maximumFileSize,
-                    allowedFileExtensions: bucket.allowedFileExtensions,
-                    compression: bucket.compression,
-                    encryption: bucket.encryption,
-                    antivirus: bucket.antivirus,
-                    parseOutput: false
-                });
+                log(`Bucket ${bucket.name} does not exist in the project. Creating ... `);
+                response = await storageService.createBucket(bucket["$id"], bucket.name, bucket["$permissions"], bucket.fileSecurity, bucket.enabled, bucket.maximumFileSize, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
             }
             else {
                 throw e;
             }
         }
     }
-    (0, parser_1.success)(`Successfully pushed ${buckets.length} buckets.`);
+    success(`Successfully pushed ${buckets.length} buckets.`);
 };
-const pushTeam = async ({ returnOnZero } = { returnOnZero: false }) => {
+const pushTeam = async () => {
     let response = {};
     let teamIds = [];
-    const configTeams = config_1.localConfig.getTeams();
-    if (parser_1.cliConfig.all) {
-        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+    const configTeams = localConfig.getTeams();
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
         teamIds.push(...configTeams.map((t) => t.$id));
     }
     if (teamIds.length === 0) {
-        const answers = await inquirer_1.default.prompt(questions_1.questionsPushTeams[0]);
+        const answers = await inquirer.prompt(questionsPushTeams);
         if (answers.teams) {
             teamIds.push(...answers.teams);
         }
     }
     if (teamIds.length === 0) {
-        (0, parser_1.log)("No teams found.");
-        (0, parser_1.hint)("Use 'appwrite pull teams' to synchronize existing one, or use 'appwrite init team' to create a new one.");
+        log("No teams found.");
+        hint("Use 'appwrite pull teams' to synchronize existing one, or use 'appwrite init team' to create a new one.");
         return;
     }
     let teams = [];
@@ -1993,56 +1982,49 @@ const pushTeam = async ({ returnOnZero } = { returnOnZero: false }) => {
         const idTeams = configTeams.filter((t) => t.$id === teamId);
         teams.push(...idTeams);
     }
-    if (!(await approveChanges(teams, teams_1.teamsGet, config_1.KeysTeams, 'teamId', 'teams'))) {
+    if (!(await approveChanges(teams, async (args) => {
+        const teamsService = await getTeamsService();
+        return await teamsService.get(args.teamId);
+    }, KeysTeams, "teamId", "teams"))) {
         return;
     }
-    (0, parser_1.log)('Pushing teams ...');
+    log("Pushing teams ...");
     for (let team of teams) {
-        (0, parser_1.log)(`Pushing team ${chalk_1.default.bold(team['name'])} ...`);
+        log(`Pushing team ${chalk.bold(team["name"])} ...`);
+        const teamsService = await getTeamsService();
         try {
-            response = await (0, teams_1.teamsGet)({
-                teamId: team['$id'],
-                parseOutput: false,
-            });
-            await (0, teams_1.teamsUpdateName)({
-                teamId: team['$id'],
-                name: team.name,
-                parseOutput: false
-            });
+            response = await teamsService.get(team["$id"]);
+            await teamsService.updateName(team["$id"], team.name);
         }
         catch (e) {
             if (Number(e.code) === 404) {
-                (0, parser_1.log)(`Team ${team.name} does not exist in the project. Creating ... `);
-                response = await (0, teams_1.teamsCreate)({
-                    teamId: team['$id'],
-                    name: team.name,
-                    parseOutput: false
-                });
+                log(`Team ${team.name} does not exist in the project. Creating ... `);
+                response = await teamsService.create(team["$id"], team.name);
             }
             else {
                 throw e;
             }
         }
     }
-    (0, parser_1.success)(`Successfully pushed ${teams.length} teams.`);
+    success(`Successfully pushed ${teams.length} teams.`);
 };
-const pushMessagingTopic = async ({ returnOnZero } = { returnOnZero: false }) => {
+const pushMessagingTopic = async () => {
     let response = {};
     let topicsIds = [];
-    const configTopics = config_1.localConfig.getMessagingTopics();
-    if (parser_1.cliConfig.all) {
-        (0, utils_1.checkDeployConditions)(config_1.localConfig);
+    const configTopics = localConfig.getMessagingTopics();
+    if (cliConfig.all) {
+        checkDeployConditions(localConfig);
         topicsIds.push(...configTopics.map((b) => b.$id));
     }
     if (topicsIds.length === 0) {
-        const answers = await inquirer_1.default.prompt(questions_1.questionsPushMessagingTopics[0]);
+        const answers = await inquirer.prompt(questionsPushMessagingTopics);
         if (answers.topics) {
             topicsIds.push(...answers.topics);
         }
     }
     if (topicsIds.length === 0) {
-        (0, parser_1.log)("No topics found.");
-        (0, parser_1.hint)("Use 'appwrite pull topics' to synchronize existing one, or use 'appwrite init topic' to create a new one.");
+        log("No topics found.");
+        hint("Use 'appwrite pull topics' to synchronize existing one, or use 'appwrite init topic' to create a new one.");
         return;
     }
     let topics = [];
@@ -2050,58 +2032,49 @@ const pushMessagingTopic = async ({ returnOnZero } = { returnOnZero: false }) =>
         const idTopic = configTopics.filter((b) => b.$id === topicId);
         topics.push(...idTopic);
     }
-    if (!(await approveChanges(topics, messaging_1.messagingGetTopic, config_1.KeysTopics, 'topicId', 'topics'))) {
+    if (!(await approveChanges(topics, async (args) => {
+        const messagingService = await getMessagingService();
+        return await messagingService.getTopic(args.topicId);
+    }, KeysTopics, "topicId", "topics"))) {
         return;
     }
-    (0, parser_1.log)('Pushing topics ...');
+    log("Pushing topics ...");
     for (let topic of topics) {
-        (0, parser_1.log)(`Pushing topic ${chalk_1.default.bold(topic['name'])} ...`);
+        log(`Pushing topic ${chalk.bold(topic["name"])} ...`);
+        const messagingService = await getMessagingService();
         try {
-            response = await (0, messaging_1.messagingGetTopic)({
-                topicId: topic['$id'],
-                parseOutput: false
-            });
-            (0, parser_1.log)(`Topic ${topic.name} ( ${topic['$id']} ) already exists.`);
-            await (0, messaging_1.messagingUpdateTopic)({
-                topicId: topic['$id'],
-                name: topic.name,
-                subscribe: topic.subscribe,
-                parseOutput: false
-            });
+            response = await messagingService.getTopic(topic["$id"]);
+            log(`Topic ${topic.name} ( ${topic["$id"]} ) already exists.`);
+            await messagingService.updateTopic(topic["$id"], topic.name, topic.subscribe);
         }
         catch (e) {
             if (Number(e.code) === 404) {
-                (0, parser_1.log)(`Topic ${topic.name} does not exist in the project. Creating ... `);
-                response = await (0, messaging_1.messagingCreateTopic)({
-                    topicId: topic['$id'],
-                    name: topic.name,
-                    subscribe: topic.subscribe,
-                    parseOutput: false
-                });
-                (0, parser_1.success)(`Created ${topic.name} ( ${topic['$id']} )`);
+                log(`Topic ${topic.name} does not exist in the project. Creating ... `);
+                response = await messagingService.createTopic(topic["$id"], topic.name, topic.subscribe);
+                success(`Created ${topic.name} ( ${topic["$id"]} )`);
             }
             else {
                 throw e;
             }
         }
     }
-    (0, parser_1.success)(`Successfully pushed ${topics.length} topics.`);
+    success(`Successfully pushed ${topics.length} topics.`);
 };
-exports.push = new commander_1.Command("push")
-    .description(parser_1.commandDescriptions['push'])
-    .action((0, parser_1.actionRunner)(pushResources));
-exports.push
+export const push = new Command("push")
+    .description(commandDescriptions["push"])
+    .action(actionRunner(() => pushResources({ skipDeprecated: true })));
+push
     .command("all")
     .description("Push all resource.")
-    .action((0, parser_1.actionRunner)(() => {
-    parser_1.cliConfig.all = true;
-    return pushResources();
+    .action(actionRunner(() => {
+    cliConfig.all = true;
+    return pushResources({ skipDeprecated: true });
 }));
-exports.push
+push
     .command("settings")
     .description("Push project name, services and auth settings")
-    .action((0, parser_1.actionRunner)(pushSettings));
-exports.push
+    .action(actionRunner(pushSettings));
+push
     .command("function")
     .alias("functions")
     .description("Push functions in the current directory.")
@@ -2109,8 +2082,8 @@ exports.push
     .option(`-A, --async`, `Don't wait for functions deployments status`)
     .option("--no-code", "Don't push the function's code")
     .option("--with-variables", `Push function variables.`)
-    .action((0, parser_1.actionRunner)(pushFunction));
-exports.push
+    .action(actionRunner(pushFunction));
+push
     .command("site")
     .alias("sites")
     .description("Push sites in the current directory.")
@@ -2118,37 +2091,37 @@ exports.push
     .option(`-A, --async`, `Don't wait for sites deployments status`)
     .option("--no-code", "Don't push the site's code")
     .option("--with-variables", `Push site variables.`)
-    .action((0, parser_1.actionRunner)(pushSite));
-exports.push
+    .action(actionRunner(pushSite));
+push
     .command("collection")
     .alias("collections")
     .description("Push collections in the current project. (deprecated, please use 'push tables' instead)")
     .option(`-a, --attempts <numberOfAttempts>`, `Max number of attempts before timing out. default: 30.`)
-    .action((0, parser_1.actionRunner)(pushCollection));
-exports.push
+    .action(actionRunner(pushCollection));
+push
     .command("table")
     .alias("tables")
     .description("Push tables in the current project.")
     .option(`-a, --attempts <numberOfAttempts>`, `Max number of attempts before timing out. default: 30.`)
-    .action((0, parser_1.actionRunner)(pushTable));
-exports.push
+    .action(actionRunner(pushTable));
+push
     .command("bucket")
     .alias("buckets")
     .description("Push buckets in the current project.")
-    .action((0, parser_1.actionRunner)(pushBucket));
-exports.push
+    .action(actionRunner(pushBucket));
+push
     .command("team")
     .alias("teams")
     .description("Push teams in the current project.")
-    .action((0, parser_1.actionRunner)(pushTeam));
-exports.push
+    .action(actionRunner(pushTeam));
+push
     .command("topic")
     .alias("topics")
     .description("Push messaging topics in the current project.")
-    .action((0, parser_1.actionRunner)(pushMessagingTopic));
-exports.deploy = new commander_1.Command("deploy")
-    .description('Removed. Use appwrite push instead')
-    .action((0, parser_1.actionRunner)(async () => {
-    (0, parser_1.warn)("appwrite deploy has been removed. Please use 'appwrite push' instead");
+    .action(actionRunner(pushMessagingTopic));
+export const deploy = new Command("deploy")
+    .description("Removed. Use appwrite push instead")
+    .action(actionRunner(async () => {
+    warn("appwrite deploy has been removed. Please use 'appwrite push' instead");
 }));
 //# sourceMappingURL=push.js.map