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

package/dist/lib/commands/pull.js

@@ -1,14 +1,420 @@
 import fs from "fs";
+import path from "path";
 import chalk from "chalk";
-import tar from "tar";
 import { Command } from "commander";
 import inquirer from "inquirer";
-import { getMessagingService, getTeamsService, getProjectsService, getFunctionsService, getSitesService, getDatabasesService, getTablesDBService, getStorageService, } from "../services.js";
+import { Databases, Functions, Messaging, Projects, Sites, Storage, TablesDB, Teams, Query, } from "@appwrite.io/console";
+import { getFunctionsService, getSitesService } from "../services.js";
+import { sdkForProject, sdkForConsole } from "../sdks.js";
 import { localConfig } from "../config.js";
 import { paginate } from "../paginate.js";
-import { questionsPullCollection, questionsPullFunctions, questionsPullFunctionsCode, questionsPullSites, questionsPullSitesCode, questionsPullResources, } from "../questions.js";
+import { questionsPullFunctions, questionsPullFunctionsCode, questionsPullSites, questionsPullSitesCode, questionsPullResources, } from "../questions.js";
 import { cliConfig, success, log, warn, error, actionRunner, commandDescriptions, } from "../parser.js";
-export const pullResources = async ({ skipDeprecated = false, } = {}) => {
+import { createSettingsObject } from "../utils.js";
+import { ProjectNotInitializedError } from "./errors.js";
+import { downloadDeploymentCode } from "./utils/deployment.js";
+async function createPullInstance() {
+    const projectClient = await sdkForProject();
+    const consoleClient = await sdkForConsole();
+    const pullInstance = new Pull(projectClient, consoleClient);
+    pullInstance.setConfigDirectoryPath(localConfig.configDirectoryPath);
+    return pullInstance;
+}
+export class Pull {
+    projectClient;
+    consoleClient;
+    configDirectoryPath;
+    silent;
+    constructor(projectClient, consoleClient, silent = false) {
+        this.projectClient = projectClient;
+        this.consoleClient = consoleClient;
+        this.configDirectoryPath = process.cwd();
+        this.silent = silent;
+    }
+    /**
+     * Set the base directory path for config files and resources
+     */
+    setConfigDirectoryPath(path) {
+        this.configDirectoryPath = path;
+    }
+    /**
+     * Log a message (respects silent mode)
+     */
+    log(message) {
+        if (!this.silent) {
+            log(message);
+        }
+    }
+    /**
+     * Log a success message (respects silent mode)
+     */
+    success(message) {
+        if (!this.silent) {
+            success(message);
+        }
+    }
+    /**
+     * Log a warning message (respects silent mode)
+     */
+    warn(message) {
+        if (!this.silent) {
+            warn(message);
+        }
+    }
+    /**
+     * Pull resources from Appwrite project and return updated config
+     *
+     * @param config - Current configuration object
+     * @param options - Pull options specifying which resources to pull
+     * @returns Updated configuration object with pulled resources
+     */
+    async pullResources(config, options = { all: true, skipDeprecated: true }) {
+        const { skipDeprecated = true } = options;
+        if (!config.projectId) {
+            throw new ProjectNotInitializedError();
+        }
+        const updatedConfig = { ...config };
+        const shouldPullAll = options.all === true;
+        if (shouldPullAll || options.settings) {
+            const settings = await this.pullSettings(config.projectId);
+            updatedConfig.settings = settings.settings;
+            updatedConfig.projectName = settings.projectName;
+        }
+        if (shouldPullAll || options.functions) {
+            const functions = await this.pullFunctions({
+                code: options.noCode === true ? false : true,
+                withVariables: options.withVariables,
+            });
+            updatedConfig.functions = functions;
+        }
+        if (shouldPullAll || options.sites) {
+            const sites = await this.pullSites({
+                code: options.noCode === true ? false : true,
+                withVariables: options.withVariables,
+            });
+            updatedConfig.sites = sites;
+        }
+        if (shouldPullAll || options.tables) {
+            const { databases, tables } = await this.pullTables();
+            updatedConfig.databases = databases;
+            updatedConfig.tables = tables;
+        }
+        if (options.collections || (shouldPullAll && !skipDeprecated)) {
+            const { databases, collections } = await this.pullCollections();
+            updatedConfig.databases = databases;
+            updatedConfig.collections = collections;
+        }
+        if (shouldPullAll || options.buckets) {
+            const buckets = await this.pullBuckets();
+            updatedConfig.buckets = buckets;
+        }
+        if (shouldPullAll || options.teams) {
+            const teams = await this.pullTeams();
+            updatedConfig.teams = teams;
+        }
+        if (shouldPullAll || options.topics) {
+            const topics = await this.pullMessagingTopics();
+            updatedConfig.topics = topics;
+        }
+        return updatedConfig;
+    }
+    /**
+     * Pull project settings
+     */
+    async pullSettings(projectId) {
+        this.log("Pulling project settings ...");
+        const projectsService = new Projects(this.consoleClient);
+        const project = await projectsService.get({ projectId: projectId });
+        this.success(`Successfully pulled ${chalk.bold("all")} project settings.`);
+        return {
+            projectName: project.name,
+            settings: createSettingsObject(project),
+            project,
+        };
+    }
+    /**
+     * Pull functions from the project
+     */
+    async pullFunctions(options = {}) {
+        this.log("Fetching functions ...");
+        const functionsService = new Functions(this.projectClient);
+        let functions;
+        if (options.functionIds && options.functionIds.length > 0) {
+            functions = await Promise.all(options.functionIds.map((id) => functionsService.get({
+                functionId: id,
+            })));
+        }
+        else {
+            const fetchResponse = await functionsService.list({
+                queries: [Query.limit(1)],
+            });
+            if (fetchResponse["functions"].length <= 0) {
+                this.log("No functions found.");
+                this.success(`Successfully pulled ${chalk.bold(0)} functions.`);
+                return [];
+            }
+            const { functions: allFunctions } = await paginate(async () => new Functions(this.projectClient).list(), {}, 100, "functions");
+            functions = allFunctions;
+        }
+        const result = [];
+        for (const func of functions) {
+            this.log(`Pulling function ${chalk.bold(func.name)} ...`);
+            const funcPath = `functions/${func.name}`;
+            const absoluteFuncPath = path.resolve(this.configDirectoryPath, funcPath);
+            const holdingVars = func.vars || [];
+            const functionConfig = {
+                $id: func.$id,
+                name: func.name,
+                runtime: func.runtime,
+                path: funcPath,
+                entrypoint: func.entrypoint,
+                execute: func.execute,
+                enabled: func.enabled,
+                logging: func.logging,
+                events: func.events,
+                schedule: func.schedule,
+                timeout: func.timeout,
+                commands: func.commands,
+                scopes: func.scopes,
+                specification: func.specification,
+            };
+            result.push(functionConfig);
+            if (!fs.existsSync(absoluteFuncPath)) {
+                fs.mkdirSync(absoluteFuncPath, { recursive: true });
+            }
+            if (options.code !== false) {
+                await downloadDeploymentCode({
+                    resourceId: func["$id"],
+                    resourcePath: absoluteFuncPath,
+                    holdingVars,
+                    withVariables: options.withVariables,
+                    listDeployments: () => functionsService.listDeployments({
+                        functionId: func["$id"],
+                        queries: [Query.limit(1), Query.orderDesc("$id")],
+                    }),
+                    getDownloadUrl: (deploymentId) => functionsService.getDeploymentDownload({
+                        functionId: func["$id"],
+                        deploymentId,
+                    }),
+                    projectClient: this.projectClient,
+                });
+            }
+        }
+        if (options.code === false) {
+            this.warn("Source code download skipped.");
+        }
+        this.success(`Successfully pulled ${chalk.bold(result.length)} functions.`);
+        return result;
+    }
+    /**
+     * Pull sites from the project
+     */
+    async pullSites(options = {}) {
+        this.log("Fetching sites ...");
+        const sitesService = new Sites(this.projectClient);
+        let sites;
+        if (options.siteIds && options.siteIds.length > 0) {
+            sites = await Promise.all(options.siteIds.map((id) => sitesService.get({
+                siteId: id,
+            })));
+        }
+        else {
+            const fetchResponse = await sitesService.list({
+                queries: [Query.limit(1)],
+            });
+            if (fetchResponse["sites"].length <= 0) {
+                this.log("No sites found.");
+                this.success(`Successfully pulled ${chalk.bold(0)} sites.`);
+                return [];
+            }
+            const { sites: fetchedSites } = await paginate(async () => new Sites(this.projectClient).list(), {}, 100, "sites");
+            sites = fetchedSites;
+        }
+        const result = [];
+        for (const site of sites) {
+            this.log(`Pulling site ${chalk.bold(site.name)} ...`);
+            const sitePath = `sites/${site.name}`;
+            const absoluteSitePath = path.resolve(this.configDirectoryPath, sitePath);
+            const holdingVars = site.vars || [];
+            const siteConfig = {
+                $id: site.$id,
+                name: site.name,
+                path: sitePath,
+                framework: site.framework,
+                enabled: site.enabled,
+                logging: site.logging,
+                timeout: site.timeout,
+                buildRuntime: site.buildRuntime,
+                adapter: site.adapter,
+                installCommand: site.installCommand,
+                buildCommand: site.buildCommand,
+                outputDirectory: site.outputDirectory,
+                fallbackFile: site.fallbackFile,
+                specification: site.specification,
+            };
+            result.push(siteConfig);
+            if (!fs.existsSync(absoluteSitePath)) {
+                fs.mkdirSync(absoluteSitePath, { recursive: true });
+            }
+            if (options.code !== false) {
+                await downloadDeploymentCode({
+                    resourceId: site["$id"],
+                    resourcePath: absoluteSitePath,
+                    holdingVars,
+                    withVariables: options.withVariables,
+                    listDeployments: () => sitesService.listDeployments({
+                        siteId: site["$id"],
+                        queries: [Query.limit(1), Query.orderDesc("$id")],
+                    }),
+                    getDownloadUrl: (deploymentId) => sitesService.getDeploymentDownload({
+                        siteId: site["$id"],
+                        deploymentId,
+                    }),
+                    projectClient: this.projectClient,
+                });
+            }
+        }
+        if (options.code === false) {
+            this.warn("Source code download skipped.");
+        }
+        this.success(`Successfully pulled ${chalk.bold(result.length)} sites.`);
+        return result;
+    }
+    /**
+     * Pull collections from the project (deprecated)
+     */
+    async pullCollections() {
+        this.warn("appwrite pull collection has been deprecated. Please consider using 'appwrite pull tables' instead");
+        this.log("Fetching collections ...");
+        const databasesService = new Databases(this.projectClient);
+        const fetchResponse = await databasesService.list([Query.limit(1)]);
+        if (fetchResponse["databases"].length <= 0) {
+            this.log("No collections found.");
+            this.success(`Successfully pulled ${chalk.bold(0)} collections from ${chalk.bold(0)} databases.`);
+            return { databases: [], collections: [] };
+        }
+        const { databases } = await paginate(async () => new Databases(this.projectClient).list(), {}, 100, "databases");
+        const allDatabases = [];
+        const allCollections = [];
+        for (const database of databases) {
+            this.log(`Pulling all collections from ${chalk.bold(database.name)} database ...`);
+            allDatabases.push(database);
+            const { collections } = await paginate(async () => new Databases(this.projectClient).listCollections(database.$id), {}, 100, "collections");
+            for (const collection of collections) {
+                allCollections.push({
+                    ...collection,
+                    $createdAt: undefined,
+                    $updatedAt: undefined,
+                });
+            }
+        }
+        this.success(`Successfully pulled ${chalk.bold(allCollections.length)} collections from ${chalk.bold(allDatabases.length)} databases.`);
+        return {
+            databases: allDatabases,
+            collections: allCollections,
+        };
+    }
+    /**
+     * Pull tables from the project
+     */
+    async pullTables() {
+        this.log("Fetching tables ...");
+        const tablesDBService = new TablesDB(this.projectClient);
+        const fetchResponse = await tablesDBService.list({
+            queries: [Query.limit(1)],
+        });
+        if (fetchResponse["databases"].length <= 0) {
+            this.log("No tables found.");
+            this.success(`Successfully pulled ${chalk.bold(0)} tables from ${chalk.bold(0)} tableDBs.`);
+            return { databases: [], tables: [] };
+        }
+        const { databases } = await paginate(async () => new TablesDB(this.projectClient).list(), {}, 100, "databases");
+        const allDatabases = [];
+        const allTables = [];
+        for (const database of databases) {
+            this.log(`Pulling all tables from ${chalk.bold(database.name)} database ...`);
+            allDatabases.push(database);
+            const { tables } = await paginate(async () => new TablesDB(this.projectClient).listTables(database.$id), {}, 100, "tables");
+            for (const table of tables) {
+                allTables.push({
+                    ...table,
+                    $createdAt: undefined,
+                    $updatedAt: undefined,
+                });
+            }
+        }
+        this.success(`Successfully pulled ${chalk.bold(allTables.length)} tables from ${chalk.bold(allDatabases.length)} tableDBs.`);
+        return {
+            databases: allDatabases,
+            tables: allTables,
+        };
+    }
+    /**
+     * Pull storage buckets from the project
+     */
+    async pullBuckets() {
+        this.log("Fetching buckets ...");
+        const storageService = new Storage(this.projectClient);
+        const fetchResponse = await storageService.listBuckets({
+            queries: [Query.limit(1)],
+        });
+        if (fetchResponse["buckets"].length <= 0) {
+            this.log("No buckets found.");
+            this.success(`Successfully pulled ${chalk.bold(0)} buckets.`);
+            return [];
+        }
+        const { buckets } = await paginate(async () => new Storage(this.projectClient).listBuckets(), {}, 100, "buckets");
+        for (const bucket of buckets) {
+            this.log(`Pulling bucket ${chalk.bold(bucket.name)} ...`);
+        }
+        this.success(`Successfully pulled ${chalk.bold(buckets.length)} buckets.`);
+        return buckets;
+    }
+    /**
+     * Pull teams from the project
+     */
+    async pullTeams() {
+        this.log("Fetching teams ...");
+        const teamsService = new Teams(this.projectClient);
+        const fetchResponse = await teamsService.list({
+            queries: [Query.limit(1)],
+        });
+        if (fetchResponse["teams"].length <= 0) {
+            this.log("No teams found.");
+            this.success(`Successfully pulled ${chalk.bold(0)} teams.`);
+            return [];
+        }
+        const { teams } = await paginate(async () => new Teams(this.projectClient).list(), {}, 100, "teams");
+        for (const team of teams) {
+            this.log(`Pulling team ${chalk.bold(team.name)} ...`);
+        }
+        this.success(`Successfully pulled ${chalk.bold(teams.length)} teams.`);
+        return teams;
+    }
+    /**
+     * Pull messaging topics from the project
+     */
+    async pullMessagingTopics() {
+        this.log("Fetching topics ...");
+        const messagingService = new Messaging(this.projectClient);
+        const fetchResponse = await messagingService.listTopics({
+            queries: [Query.limit(1)],
+        });
+        if (fetchResponse["topics"].length <= 0) {
+            this.log("No topics found.");
+            this.success(`Successfully pulled ${chalk.bold(0)} topics.`);
+            return [];
+        }
+        const { topics } = await paginate(async () => new Messaging(this.projectClient).listTopics(), {}, 100, "topics");
+        for (const topic of topics) {
+            this.log(`Pulling topic ${chalk.bold(topic.name)} ...`);
+        }
+        this.success(`Successfully pulled ${chalk.bold(topics.length)} topics.`);
+        return topics;
+    }
+}
+/** Helper methods for CLI commands */
+export const pullResources = async ({ skipDeprecated = true, } = {}) => {
     const project = localConfig.getProject();
     if (!project.projectId) {
         error("Project configuration not found. Please run 'appwrite init project' to initialize your project first.");
@@ -42,338 +448,121 @@ export const pullResources = async ({ skipDeprecated = false, } = {}) => {
     }
 };
 const pullSettings = async () => {
-    log("Pulling project settings ...");
-    try {
-        const projectsService = await getProjectsService();
-        let response = await projectsService.get(localConfig.getProject().projectId);
-        localConfig.setProject(response.$id, response.name, response);
-        success(`Successfully pulled ${chalk.bold("all")} project settings.`);
-    }
-    catch (e) {
-        throw e;
-    }
+    const pullInstance = await createPullInstance();
+    const projectId = localConfig.getProject().projectId;
+    const settings = await pullInstance.pullSettings(projectId);
+    localConfig.setProject(projectId, settings.projectName, settings.project);
 };
 const pullFunctions = async ({ code, withVariables, } = {}) => {
-    process.chdir(localConfig.configDirectoryPath);
-    log("Fetching functions ...");
-    let total = 0;
     const functionsService = await getFunctionsService();
-    const fetchResponse = await functionsService.list([
-        JSON.stringify({ method: "limit", values: [1] }),
-    ]);
+    const fetchResponse = await functionsService.list([Query.limit(1)]);
     if (fetchResponse["functions"].length <= 0) {
         log("No functions found.");
-        success(`Successfully pulled ${chalk.bold(total)} functions.`);
+        success(`Successfully pulled ${chalk.bold(0)} functions.`);
         return;
     }
-    const functions = cliConfig.all
+    const functionsToCheck = cliConfig.all
         ? (await paginate(async () => (await getFunctionsService()).list(), {}, 100, "functions")).functions
         : (await inquirer.prompt(questionsPullFunctions)).functions;
     let allowCodePull = cliConfig.force === true ? true : null;
-    for (let func of functions) {
-        total++;
-        log(`Pulling function ${chalk.bold(func["name"])} ...`);
+    if (code !== false && allowCodePull === null) {
+        const codeAnswer = await inquirer.prompt(questionsPullFunctionsCode);
+        allowCodePull = codeAnswer.override;
+    }
+    const shouldPullCode = code !== false && allowCodePull === true;
+    const selectedFunctionIds = functionsToCheck.map((f) => f.$id);
+    const pullInstance = await createPullInstance();
+    const functions = await pullInstance.pullFunctions({
+        code: shouldPullCode,
+        withVariables,
+        functionIds: selectedFunctionIds,
+    });
+    for (const func of functions) {
         const localFunction = localConfig.getFunction(func.$id);
-        func["path"] = localFunction["path"];
-        if (!localFunction["path"]) {
-            func["path"] = `functions/${func.name}`;
-        }
-        const holdingVars = func["vars"];
-        // We don't save var in to the config
-        delete func["vars"];
+        func["path"] = localFunction["path"] || func["path"];
         localConfig.addFunction(func);
-        if (!fs.existsSync(func["path"])) {
-            fs.mkdirSync(func["path"], { recursive: true });
-        }
-        if (code === false) {
-            warn("Source code download skipped.");
-            continue;
-        }
-        if (allowCodePull === null) {
-            const codeAnswer = await inquirer.prompt(questionsPullFunctionsCode);
-            allowCodePull = codeAnswer.override;
-        }
-        if (!allowCodePull) {
-            continue;
-        }
-        let deploymentId = null;
-        try {
-            const fetchResponse = await functionsService.listDeployments({
-                functionId: func["$id"],
-                queries: [
-                    JSON.stringify({ method: "limit", values: [1] }),
-                    JSON.stringify({ method: "orderDesc", values: ["$id"] }),
-                ],
-            });
-            if (fetchResponse["total"] > 0) {
-                deploymentId = fetchResponse["deployments"][0]["$id"];
-            }
-        }
-        catch { }
-        if (deploymentId === null) {
-            log("Source code download skipped because function doesn't have any available deployment");
-            continue;
-        }
-        log("Pulling latest deployment code ...");
-        const compressedFileName = `${func["$id"]}-${+new Date()}.tar.gz`;
-        const downloadUrl = functionsService.getDeploymentDownload({
-            functionId: func["$id"],
-            deploymentId: deploymentId,
-        });
-        const client = (await getFunctionsService()).client;
-        const downloadBuffer = await client.call("get", new URL(downloadUrl), {}, {}, "arrayBuffer");
-        fs.writeFileSync(compressedFileName, Buffer.from(downloadBuffer));
-        tar.extract({
-            sync: true,
-            cwd: func["path"],
-            file: compressedFileName,
-            strict: false,
-        });
-        fs.rmSync(compressedFileName);
-        if (withVariables) {
-            const envFileLocation = `${func["path"]}/.env`;
-            try {
-                fs.rmSync(envFileLocation);
-            }
-            catch { }
-            fs.writeFileSync(envFileLocation, holdingVars.map((r) => `${r.key}=${r.value}\n`).join(""));
-        }
     }
-    success(`Successfully pulled ${chalk.bold(total)} functions.`);
 };
 const pullSites = async ({ code, withVariables, } = {}) => {
-    process.chdir(localConfig.configDirectoryPath);
-    log("Fetching sites ...");
-    let total = 0;
     const sitesService = await getSitesService();
-    const fetchResponse = await sitesService.list([
-        JSON.stringify({ method: "limit", values: [1] }),
-    ]);
+    const fetchResponse = await sitesService.list({
+        queries: [Query.limit(1)],
+    });
     if (fetchResponse["sites"].length <= 0) {
         log("No sites found.");
-        success(`Successfully pulled ${chalk.bold(total)} sites.`);
+        success(`Successfully pulled ${chalk.bold(0)} sites.`);
         return;
     }
-    const sites = cliConfig.all
+    const sitesToCheck = cliConfig.all
         ? (await paginate(async () => (await getSitesService()).list(), {}, 100, "sites")).sites
         : (await inquirer.prompt(questionsPullSites)).sites;
     let allowCodePull = cliConfig.force === true ? true : null;
-    for (let site of sites) {
-        total++;
-        log(`Pulling site ${chalk.bold(site["name"])} ...`);
+    if (code !== false && allowCodePull === null) {
+        const codeAnswer = await inquirer.prompt(questionsPullSitesCode);
+        allowCodePull = codeAnswer.override;
+    }
+    const shouldPullCode = code !== false && allowCodePull === true;
+    const selectedSiteIds = sitesToCheck.map((s) => s.$id);
+    const pullInstance = await createPullInstance();
+    const sites = await pullInstance.pullSites({
+        code: shouldPullCode,
+        withVariables,
+        siteIds: selectedSiteIds,
+    });
+    for (const site of sites) {
         const localSite = localConfig.getSite(site.$id);
-        site["path"] = localSite["path"];
-        if (!localSite["path"]) {
-            site["path"] = `sites/${site.name}`;
-        }
-        const holdingVars = site["vars"];
-        // We don't save var in to the config
-        delete site["vars"];
+        site["path"] = localSite["path"] || site["path"];
         localConfig.addSite(site);
-        if (!fs.existsSync(site["path"])) {
-            fs.mkdirSync(site["path"], { recursive: true });
-        }
-        if (code === false) {
-            warn("Source code download skipped.");
-            continue;
-        }
-        if (allowCodePull === null) {
-            const codeAnswer = await inquirer.prompt(questionsPullSitesCode);
-            allowCodePull = codeAnswer.override;
-        }
-        if (!allowCodePull) {
-            continue;
-        }
-        let deploymentId = null;
-        try {
-            const fetchResponse = await sitesService.listDeployments({
-                siteId: site["$id"],
-                queries: [
-                    JSON.stringify({ method: "limit", values: [1] }),
-                    JSON.stringify({ method: "orderDesc", values: ["$id"] }),
-                ],
-            });
-            if (fetchResponse["total"] > 0) {
-                deploymentId = fetchResponse["deployments"][0]["$id"];
-            }
-        }
-        catch { }
-        if (deploymentId === null) {
-            log("Source code download skipped because site doesn't have any available deployment");
-            continue;
-        }
-        log("Pulling latest deployment code ...");
-        const compressedFileName = `${site["$id"]}-${+new Date()}.tar.gz`;
-        const downloadUrl = sitesService.getDeploymentDownload({
-            siteId: site["$id"],
-            deploymentId: deploymentId,
-        });
-        const client = (await getSitesService()).client;
-        const downloadBuffer = await client.call("get", new URL(downloadUrl), {}, {}, "arrayBuffer");
-        fs.writeFileSync(compressedFileName, Buffer.from(downloadBuffer));
-        tar.extract({
-            sync: true,
-            cwd: site["path"],
-            file: compressedFileName,
-            strict: false,
-        });
-        fs.rmSync(compressedFileName);
-        if (withVariables) {
-            const envFileLocation = `${site["path"]}/.env`;
-            try {
-                fs.rmSync(envFileLocation);
-            }
-            catch { }
-            fs.writeFileSync(envFileLocation, holdingVars.map((r) => `${r.key}=${r.value}\n`).join(""));
-        }
     }
-    success(`Successfully pulled ${chalk.bold(total)} sites.`);
 };
 const pullCollection = async () => {
-    warn("appwrite pull collection has been deprecated. Please consider using 'appwrite pull tables' instead");
-    log("Fetching collections ...");
-    let totalDatabases = 0;
-    let totalCollections = 0;
-    const databasesService = await getDatabasesService();
-    const fetchResponse = await databasesService.list([
-        JSON.stringify({ method: "limit", values: [1] }),
-    ]);
-    if (fetchResponse["databases"].length <= 0) {
-        log("No collections found.");
-        success(`Successfully pulled ${chalk.bold(totalCollections)} collections from ${chalk.bold(totalDatabases)} databases.`);
-        return;
-    }
-    let databases = cliConfig.ids;
-    if (databases.length === 0) {
-        if (cliConfig.all) {
-            databases = (await paginate(async () => (await getDatabasesService()).list(), {}, 100, "databases")).databases.map((database) => database.$id);
-        }
-        else {
-            databases = (await inquirer.prompt(questionsPullCollection)).databases;
-        }
-    }
-    for (const databaseId of databases) {
-        const database = await databasesService.get(databaseId);
-        totalDatabases++;
-        log(`Pulling all collections from ${chalk.bold(database["name"])} database ...`);
+    const pullInstance = await createPullInstance();
+    const { databases, collections } = await pullInstance.pullCollections();
+    for (const database of databases) {
         localConfig.addDatabase(database);
-        const { collections } = await paginate(async () => (await getDatabasesService()).listCollections(databaseId), {}, 100, "collections");
-        for (const collection of collections) {
-            totalCollections++;
-            localConfig.addCollection({
-                ...collection,
-                $createdAt: undefined,
-                $updatedAt: undefined,
-            });
-        }
     }
-    success(`Successfully pulled ${chalk.bold(totalCollections)} collections from ${chalk.bold(totalDatabases)} databases.`);
+    for (const collection of collections) {
+        localConfig.addCollection(collection);
+    }
 };
 const pullTable = async () => {
-    log("Fetching tables ...");
-    let totalTablesDBs = 0;
-    let totalTables = 0;
-    const tablesDBService = await getTablesDBService();
-    const fetchResponse = await tablesDBService.list([
-        JSON.stringify({ method: "limit", values: [1] }),
-    ]);
-    if (fetchResponse["databases"].length <= 0) {
-        log("No tables found.");
-        success(`Successfully pulled ${chalk.bold(totalTables)} tables from ${chalk.bold(totalTablesDBs)} tableDBs.`);
-        return;
-    }
-    let databases = cliConfig.ids;
-    if (databases.length === 0) {
-        if (cliConfig.all) {
-            databases = (await paginate(async () => (await getTablesDBService()).list(), {}, 100, "databases")).databases.map((database) => database.$id);
-        }
-        else {
-            databases = (await inquirer.prompt(questionsPullCollection)).databases;
-        }
-    }
-    for (const databaseId of databases) {
-        const database = await tablesDBService.get(databaseId);
-        totalTablesDBs++;
-        log(`Pulling all tables from ${chalk.bold(database["name"])} database ...`);
+    const pullInstance = await createPullInstance();
+    const { databases, tables } = await pullInstance.pullTables();
+    for (const database of databases) {
         localConfig.addTablesDB(database);
-        const { tables } = await paginate(async () => (await getTablesDBService()).listTables(databaseId), {}, 100, "tables");
-        for (const table of tables) {
-            totalTables++;
-            localConfig.addTable({
-                ...table,
-                $createdAt: undefined,
-                $updatedAt: undefined,
-            });
-        }
     }
-    success(`Successfully pulled ${chalk.bold(totalTables)} tables from ${chalk.bold(totalTablesDBs)} tableDBs.`);
+    for (const table of tables) {
+        localConfig.addTable(table);
+    }
 };
 const pullBucket = async () => {
-    log("Fetching buckets ...");
-    let total = 0;
-    const storageService = await getStorageService();
-    const fetchResponse = await storageService.listBuckets([
-        JSON.stringify({ method: "limit", values: [1] }),
-    ]);
-    if (fetchResponse["buckets"].length <= 0) {
-        log("No buckets found.");
-        success(`Successfully pulled ${chalk.bold(total)} buckets.`);
-        return;
-    }
-    const { buckets } = await paginate(async () => (await getStorageService()).listBuckets(), {}, 100, "buckets");
+    const pullInstance = await createPullInstance();
+    const buckets = await pullInstance.pullBuckets();
     for (const bucket of buckets) {
-        total++;
-        log(`Pulling bucket ${chalk.bold(bucket["name"])} ...`);
         localConfig.addBucket(bucket);
     }
-    success(`Successfully pulled ${chalk.bold(total)} buckets.`);
 };
 const pullTeam = async () => {
-    log("Fetching teams ...");
-    let total = 0;
-    const teamsService = await getTeamsService();
-    const fetchResponse = await teamsService.list([
-        JSON.stringify({ method: "limit", values: [1] }),
-    ]);
-    if (fetchResponse["teams"].length <= 0) {
-        log("No teams found.");
-        success(`Successfully pulled ${chalk.bold(total)} teams.`);
-        return;
-    }
-    const { teams } = await paginate(async () => (await getTeamsService()).list(), {}, 100, "teams");
+    const pullInstance = await createPullInstance();
+    const teams = await pullInstance.pullTeams();
     for (const team of teams) {
-        total++;
-        log(`Pulling team ${chalk.bold(team["name"])} ...`);
         localConfig.addTeam(team);
     }
-    success(`Successfully pulled ${chalk.bold(total)} teams.`);
 };
 const pullMessagingTopic = async () => {
-    log("Fetching topics ...");
-    let total = 0;
-    const messagingService = await getMessagingService();
-    const fetchResponse = await messagingService.listTopics([
-        JSON.stringify({ method: "limit", values: [1] }),
-    ]);
-    if (fetchResponse["topics"].length <= 0) {
-        log("No topics found.");
-        success(`Successfully pulled ${chalk.bold(total)} topics.`);
-        return;
-    }
-    const { topics } = await paginate(async () => (await getMessagingService()).listTopics(), {}, 100, "topics");
+    const pullInstance = await createPullInstance();
+    const topics = await pullInstance.pullMessagingTopics();
     for (const topic of topics) {
-        total++;
-        log(`Pulling topic ${chalk.bold(topic["name"])} ...`);
         localConfig.addMessagingTopic(topic);
     }
-    success(`Successfully pulled ${chalk.bold(total)} topics.`);
 };
+/** Commander.js exports */
 export const pull = new Command("pull")
     .description(commandDescriptions["pull"])
     .action(actionRunner(() => pullResources({ skipDeprecated: true })));
 pull
     .command("all")
-    .description("Pull all resource.")
+    .description("Pull all resources")
     .action(actionRunner(() => {
     cliConfig.all = true;
     return pullResources({