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

package/lib/commands/pull.ts

@@ -1,22 +1,26 @@
 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";
+  Databases,
+  Functions,
+  Messaging,
+  Projects,
+  Sites,
+  Storage,
+  TablesDB,
+  Teams,
+  Client,
+  Query,
+  Models,
+} 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,
@@ -32,573 +36,832 @@ import {
   actionRunner,
   commandDescriptions,
 } from "../parser.js";
-
-interface PullResourcesOptions {
+import type { ConfigType } from "./config.js";
+import { createSettingsObject } from "../utils.js";
+import { ProjectNotInitializedError } from "./errors.js";
+import type { SettingsType, FunctionType, SiteType } from "./config.js";
+import { downloadDeploymentCode } from "./utils/deployment.js";
+
+export interface PullOptions {
+  all?: boolean;
+  settings?: boolean;
+  functions?: boolean;
+  sites?: boolean;
+  collections?: boolean;
+  tables?: boolean;
+  buckets?: boolean;
+  teams?: boolean;
+  topics?: boolean;
   skipDeprecated?: boolean;
+  withVariables?: boolean;
+  noCode?: boolean;
 }
 
 interface PullFunctionsOptions {
   code?: boolean;
   withVariables?: boolean;
+  functionIds?: string[];
 }
 
 interface PullSitesOptions {
   code?: boolean;
   withVariables?: boolean;
+  siteIds?: string[];
 }
 
-export const pullResources = async ({
-  skipDeprecated = false,
-}: PullResourcesOptions = {}): Promise<void> => {
-  const project = localConfig.getProject();
-  if (!project.projectId) {
-    error(
-      "Project configuration not found. Please run 'appwrite init project' to initialize your project first.",
-    );
-    process.exit(1);
+export interface PullSettingsResult {
+  projectName: string;
+  settings: SettingsType;
+  project: Models.Project;
+}
+
+async function createPullInstance(): Promise<Pull> {
+  const projectClient = await sdkForProject();
+  const consoleClient = await sdkForConsole();
+  const pullInstance = new Pull(projectClient, consoleClient);
+
+  pullInstance.setConfigDirectoryPath(localConfig.configDirectoryPath);
+  return pullInstance;
+}
+
+export class Pull {
+  private projectClient: Client;
+  private consoleClient: Client;
+  private configDirectoryPath: string;
+  private silent: boolean;
+
+  constructor(projectClient: Client, consoleClient: Client, silent = false) {
+    this.projectClient = projectClient;
+    this.consoleClient = consoleClient;
+    this.configDirectoryPath = process.cwd();
+    this.silent = silent;
   }
 
-  const actions: Record<string, (options?: any) => Promise<void>> = {
-    settings: pullSettings,
-    functions: pullFunctions,
-    sites: pullSites,
-    collections: pullCollection,
-    tables: pullTable,
-    buckets: pullBucket,
-    teams: pullTeam,
-    messages: pullMessagingTopic,
-  };
+  /**
+   * Set the base directory path for config files and resources
+   */
+  public setConfigDirectoryPath(path: string): void {
+    this.configDirectoryPath = path;
+  }
 
-  if (skipDeprecated) {
-    delete actions.collections;
+  /**
+   * Log a message (respects silent mode)
+   */
+  private log(message: string): void {
+    if (!this.silent) {
+      log(message);
+    }
   }
 
-  if (cliConfig.all) {
-    for (let action of Object.values(actions)) {
-      cliConfig.all = true;
-      await action({ returnOnZero: true });
+  /**
+   * Log a success message (respects silent mode)
+   */
+  private success(message: string): void {
+    if (!this.silent) {
+      success(message);
     }
-  } else {
-    const answers = await inquirer.prompt([questionsPullResources[0]]);
+  }
 
-    const action = actions[answers.resource];
-    if (action !== undefined) {
-      await action({ returnOnZero: true });
+  /**
+   * Log a warning message (respects silent mode)
+   */
+  private warn(message: string): void {
+    if (!this.silent) {
+      warn(message);
     }
   }
-};
 
-const pullSettings = async (): Promise<void> => {
-  log("Pulling project settings ...");
+  /**
+   * 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
+   */
+  public async pullResources(
+    config: ConfigType,
+    options: PullOptions = { all: true, skipDeprecated: true },
+  ): Promise<ConfigType> {
+    const { skipDeprecated = true } = options;
+    if (!config.projectId) {
+      throw new ProjectNotInitializedError();
+    }
 
-  try {
-    const projectsService = await getProjectsService();
-    let response = await projectsService.get(
-      localConfig.getProject().projectId,
-    );
+    const updatedConfig: ConfigType = { ...config };
+    const shouldPullAll = options.all === true;
 
-    localConfig.setProject(response.$id, response.name, response);
+    if (shouldPullAll || options.settings) {
+      const settings = await this.pullSettings(config.projectId);
+      updatedConfig.settings = settings.settings;
+      updatedConfig.projectName = settings.projectName;
+    }
 
-    success(`Successfully pulled ${chalk.bold("all")} project settings.`);
-  } catch (e) {
-    throw e;
-  }
-};
+    if (shouldPullAll || options.functions) {
+      const functions = await this.pullFunctions({
+        code: options.noCode === true ? false : true,
+        withVariables: options.withVariables,
+      });
+      updatedConfig.functions = functions;
+    }
 
-const pullFunctions = async ({
-  code,
-  withVariables,
-}: PullFunctionsOptions = {}): Promise<void> => {
-  process.chdir(localConfig.configDirectoryPath);
+    if (shouldPullAll || options.sites) {
+      const sites = await this.pullSites({
+        code: options.noCode === true ? false : true,
+        withVariables: options.withVariables,
+      });
+      updatedConfig.sites = sites;
+    }
 
-  log("Fetching functions ...");
-  let total = 0;
+    if (shouldPullAll || options.tables) {
+      const { databases, tables } = await this.pullTables();
+      updatedConfig.databases = databases;
+      updatedConfig.tables = tables;
+    }
 
-  const functionsService = await getFunctionsService();
-  const fetchResponse = await functionsService.list([
-    JSON.stringify({ method: "limit", values: [1] }),
-  ]);
-  if (fetchResponse["functions"].length <= 0) {
-    log("No functions found.");
-    success(`Successfully pulled ${chalk.bold(total)} functions.`);
-    return;
+    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;
   }
 
-  const functions = cliConfig.all
-    ? (
-        await paginate(
-          async () => (await getFunctionsService()).list(),
-          {},
-          100,
-          "functions",
-        )
-      ).functions
-    : (await inquirer.prompt(questionsPullFunctions)).functions;
+  /**
+   * Pull project settings
+   */
+  public async pullSettings(projectId: string): Promise<PullSettingsResult> {
+    this.log("Pulling project settings ...");
 
-  let allowCodePull: boolean | null = cliConfig.force === true ? true : null;
+    const projectsService = new Projects(this.consoleClient);
+    const project = await projectsService.get({ projectId: projectId });
 
-  for (let func of functions) {
-    total++;
-    log(`Pulling function ${chalk.bold(func["name"])} ...`);
+    this.success(`Successfully pulled ${chalk.bold("all")} project settings.`);
 
-    const localFunction = localConfig.getFunction(func.$id);
+    return {
+      projectName: project.name,
+      settings: createSettingsObject(project),
+      project,
+    };
+  }
 
-    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"];
-    localConfig.addFunction(func);
+  /**
+   * Pull functions from the project
+   */
+  public async pullFunctions(
+    options: PullFunctionsOptions = {},
+  ): Promise<FunctionType[]> {
+    this.log("Fetching functions ...");
+
+    const functionsService = new Functions(this.projectClient);
+    let functions: Models.Function[];
+
+    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 (!fs.existsSync(func["path"])) {
-      fs.mkdirSync(func["path"], { recursive: true });
-    }
+      if (fetchResponse["functions"].length <= 0) {
+        this.log("No functions found.");
+        this.success(`Successfully pulled ${chalk.bold(0)} functions.`);
+        return [];
+      }
 
-    if (code === false) {
-      warn("Source code download skipped.");
-      continue;
+      const { functions: allFunctions } = await paginate(
+        async () => new Functions(this.projectClient).list(),
+        {},
+        100,
+        "functions",
+      );
+      functions = allFunctions;
     }
 
-    if (allowCodePull === null) {
-      const codeAnswer = await inquirer.prompt(questionsPullFunctionsCode);
-      allowCodePull = codeAnswer.override;
+    const result: FunctionType[] = [];
+
+    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: FunctionType = {
+        $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 (!allowCodePull) {
-      continue;
+    if (options.code === false) {
+      this.warn("Source code download skipped.");
     }
 
-    let deploymentId: string | null = null;
+    this.success(`Successfully pulled ${chalk.bold(result.length)} functions.`);
+    return result;
+  }
 
-    try {
-      const fetchResponse = await functionsService.listDeployments({
-        functionId: func["$id"],
-        queries: [
-          JSON.stringify({ method: "limit", values: [1] }),
-          JSON.stringify({ method: "orderDesc", values: ["$id"] }),
-        ],
+  /**
+   * Pull sites from the project
+   */
+  public async pullSites(options: PullSitesOptions = {}): Promise<SiteType[]> {
+    this.log("Fetching sites ...");
+
+    const sitesService = new Sites(this.projectClient);
+    let sites: Models.Site[];
+
+    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["total"] > 0) {
-        deploymentId = fetchResponse["deployments"][0]["$id"];
+      if (fetchResponse["sites"].length <= 0) {
+        this.log("No sites found.");
+        this.success(`Successfully pulled ${chalk.bold(0)} sites.`);
+        return [];
       }
-    } catch {}
 
-    if (deploymentId === null) {
-      log(
-        "Source code download skipped because function doesn't have any available deployment",
+      const { sites: fetchedSites } = await paginate(
+        async () => new Sites(this.projectClient).list(),
+        {},
+        100,
+        "sites",
       );
-      continue;
+      sites = fetchedSites;
     }
 
-    log("Pulling latest deployment code ...");
+    const result: SiteType[] = [];
+
+    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: SiteType = {
+        $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 });
+      }
 
-    const compressedFileName = `${func["$id"]}-${+new Date()}.tar.gz`;
-    const downloadUrl = functionsService.getDeploymentDownload({
-      functionId: func["$id"],
-      deploymentId: deploymentId,
-    });
+      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,
+        });
+      }
+    }
 
-    const client = (await getFunctionsService()).client;
-    const downloadBuffer = await client.call(
-      "get",
-      new URL(downloadUrl),
-      {},
-      {},
-      "arrayBuffer",
+    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)
+   */
+  public async pullCollections(): Promise<{
+    databases: any[];
+    collections: any[];
+  }> {
+    this.warn(
+      "appwrite pull collection has been deprecated. Please consider using 'appwrite pull tables' instead",
     );
+    this.log("Fetching collections ...");
 
-    fs.writeFileSync(compressedFileName, Buffer.from(downloadBuffer as any));
+    const databasesService = new Databases(this.projectClient);
 
-    tar.extract({
-      sync: true,
-      cwd: func["path"],
-      file: compressedFileName,
-      strict: false,
-    });
+    const fetchResponse = await databasesService.list([Query.limit(1)]);
 
-    fs.rmSync(compressedFileName);
+    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: [] };
+    }
 
-    if (withVariables) {
-      const envFileLocation = `${func["path"]}/.env`;
-      try {
-        fs.rmSync(envFileLocation);
-      } catch {}
+    const { databases } = await paginate(
+      async () => new Databases(this.projectClient).list(),
+      {},
+      100,
+      "databases",
+    );
 
-      fs.writeFileSync(
-        envFileLocation,
-        holdingVars.map((r: any) => `${r.key}=${r.value}\n`).join(""),
+    const allDatabases: any[] = [];
+    const allCollections: any[] = [];
+
+    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,
+    };
   }
 
-  success(`Successfully pulled ${chalk.bold(total)} functions.`);
-};
+  /**
+   * Pull tables from the project
+   */
+  public async pullTables(): Promise<{
+    databases: any[];
+    tables: any[];
+  }> {
+    this.log("Fetching tables ...");
 
-const pullSites = async ({
-  code,
-  withVariables,
-}: PullSitesOptions = {}): Promise<void> => {
-  process.chdir(localConfig.configDirectoryPath);
+    const tablesDBService = new TablesDB(this.projectClient);
 
-  log("Fetching sites ...");
-  let total = 0;
+    const fetchResponse = await tablesDBService.list({
+      queries: [Query.limit(1)],
+    });
 
-  const sitesService = await getSitesService();
-  const fetchResponse = await sitesService.list([
-    JSON.stringify({ method: "limit", values: [1] }),
-  ]);
-  if (fetchResponse["sites"].length <= 0) {
-    log("No sites found.");
-    success(`Successfully pulled ${chalk.bold(total)} sites.`);
-    return;
-  }
+    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 sites = cliConfig.all
-    ? (
-        await paginate(
-          async () => (await getSitesService()).list(),
-          {},
-          100,
-          "sites",
-        )
-      ).sites
-    : (await inquirer.prompt(questionsPullSites)).sites;
+    const { databases } = await paginate(
+      async () => new TablesDB(this.projectClient).list(),
+      {},
+      100,
+      "databases",
+    );
 
-  let allowCodePull: boolean | null = cliConfig.force === true ? true : null;
+    const allDatabases: any[] = [];
+    const allTables: any[] = [];
 
-  for (let site of sites) {
-    total++;
-    log(`Pulling site ${chalk.bold(site["name"])} ...`);
+    for (const database of databases) {
+      this.log(
+        `Pulling all tables from ${chalk.bold(database.name)} database ...`,
+      );
+      allDatabases.push(database);
 
-    const localSite = localConfig.getSite(site.$id);
+      const { tables } = await paginate(
+        async () => new TablesDB(this.projectClient).listTables(database.$id),
+        {},
+        100,
+        "tables",
+      );
 
-    site["path"] = localSite["path"];
-    if (!localSite["path"]) {
-      site["path"] = `sites/${site.name}`;
+      for (const table of tables) {
+        allTables.push({
+          ...table,
+          $createdAt: undefined,
+          $updatedAt: undefined,
+        });
+      }
     }
-    const holdingVars = site["vars"];
-    // We don't save var in to the config
-    delete site["vars"];
-    localConfig.addSite(site);
 
-    if (!fs.existsSync(site["path"])) {
-      fs.mkdirSync(site["path"], { recursive: true });
-    }
+    this.success(
+      `Successfully pulled ${chalk.bold(allTables.length)} tables from ${chalk.bold(allDatabases.length)} tableDBs.`,
+    );
 
-    if (code === false) {
-      warn("Source code download skipped.");
-      continue;
-    }
+    return {
+      databases: allDatabases,
+      tables: allTables,
+    };
+  }
+
+  /**
+   * Pull storage buckets from the project
+   */
+  public async pullBuckets(): Promise<any[]> {
+    this.log("Fetching buckets ...");
+
+    const storageService = new Storage(this.projectClient);
 
-    if (allowCodePull === null) {
-      const codeAnswer = await inquirer.prompt(questionsPullSitesCode);
-      allowCodePull = codeAnswer.override;
+    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 [];
     }
 
-    if (!allowCodePull) {
-      continue;
+    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)} ...`);
     }
 
-    let deploymentId: string | null = null;
+    this.success(`Successfully pulled ${chalk.bold(buckets.length)} buckets.`);
 
-    try {
-      const fetchResponse = await sitesService.listDeployments({
-        siteId: site["$id"],
-        queries: [
-          JSON.stringify({ method: "limit", values: [1] }),
-          JSON.stringify({ method: "orderDesc", values: ["$id"] }),
-        ],
-      });
+    return buckets;
+  }
 
-      if (fetchResponse["total"] > 0) {
-        deploymentId = fetchResponse["deployments"][0]["$id"];
-      }
-    } catch {}
+  /**
+   * Pull teams from the project
+   */
+  public async pullTeams(): Promise<any[]> {
+    this.log("Fetching teams ...");
 
-    if (deploymentId === null) {
-      log(
-        "Source code download skipped because site doesn't have any available deployment",
-      );
-      continue;
+    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)} ...`);
     }
 
-    log("Pulling latest deployment code ...");
+    this.success(`Successfully pulled ${chalk.bold(teams.length)} teams.`);
 
-    const compressedFileName = `${site["$id"]}-${+new Date()}.tar.gz`;
-    const downloadUrl = sitesService.getDeploymentDownload({
-      siteId: site["$id"],
-      deploymentId: deploymentId,
+    return teams;
+  }
+
+  /**
+   * Pull messaging topics from the project
+   */
+  public async pullMessagingTopics(): Promise<any[]> {
+    this.log("Fetching topics ...");
+
+    const messagingService = new Messaging(this.projectClient);
+
+    const fetchResponse = await messagingService.listTopics({
+      queries: [Query.limit(1)],
     });
 
-    const client = (await getSitesService()).client;
-    const downloadBuffer = await client.call(
-      "get",
-      new URL(downloadUrl),
-      {},
+    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(),
       {},
-      "arrayBuffer",
+      100,
+      "topics",
     );
 
-    fs.writeFileSync(compressedFileName, Buffer.from(downloadBuffer as any));
+    for (const topic of topics) {
+      this.log(`Pulling topic ${chalk.bold(topic.name)} ...`);
+    }
 
-    tar.extract({
-      sync: true,
-      cwd: site["path"],
-      file: compressedFileName,
-      strict: false,
-    });
+    this.success(`Successfully pulled ${chalk.bold(topics.length)} topics.`);
 
-    fs.rmSync(compressedFileName);
+    return topics;
+  }
+}
 
-    if (withVariables) {
-      const envFileLocation = `${site["path"]}/.env`;
-      try {
-        fs.rmSync(envFileLocation);
-      } catch {}
+/** Helper methods for CLI commands */
 
-      fs.writeFileSync(
-        envFileLocation,
-        holdingVars.map((r: any) => `${r.key}=${r.value}\n`).join(""),
-      );
+export const pullResources = async ({
+  skipDeprecated = true,
+}: {
+  skipDeprecated?: boolean;
+} = {}): Promise<void> => {
+  const project = localConfig.getProject();
+  if (!project.projectId) {
+    error(
+      "Project configuration not found. Please run 'appwrite init project' to initialize your project first.",
+    );
+    process.exit(1);
+  }
+
+  const actions: Record<string, (options?: any) => Promise<void>> = {
+    settings: pullSettings,
+    functions: pullFunctions,
+    sites: pullSites,
+    collections: pullCollection,
+    tables: pullTable,
+    buckets: pullBucket,
+    teams: pullTeam,
+    messages: pullMessagingTopic,
+  };
+
+  if (skipDeprecated) {
+    delete actions.collections;
+  }
+
+  if (cliConfig.all) {
+    for (let action of Object.values(actions)) {
+      cliConfig.all = true;
+      await action({ returnOnZero: true });
+    }
+  } else {
+    const answers = await inquirer.prompt([questionsPullResources[0]]);
+
+    const action = actions[answers.resource];
+    if (action !== undefined) {
+      await action({ returnOnZero: true });
     }
   }
+};
+
+const pullSettings = async (): Promise<void> => {
+  const pullInstance = await createPullInstance();
+  const projectId = localConfig.getProject().projectId;
+  const settings = await pullInstance.pullSettings(projectId);
 
-  success(`Successfully pulled ${chalk.bold(total)} sites.`);
+  localConfig.setProject(projectId, settings.projectName, settings.project);
 };
 
-const pullCollection = async (): Promise<void> => {
-  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.`,
-    );
+const pullFunctions = async ({
+  code,
+  withVariables,
+}: PullFunctionsOptions = {}): Promise<void> => {
+  const functionsService = await getFunctionsService();
+  const fetchResponse = await functionsService.list([Query.limit(1)]);
+  if (fetchResponse["functions"].length <= 0) {
+    log("No functions found.");
+    success(`Successfully pulled ${chalk.bold(0)} functions.`);
     return;
   }
 
-  let databases: string[] = cliConfig.ids;
-
-  if (databases.length === 0) {
-    if (cliConfig.all) {
-      databases = (
+  const functionsToCheck = cliConfig.all
+    ? (
         await paginate(
-          async () => (await getDatabasesService()).list(),
+          async () => (await getFunctionsService()).list(),
           {},
           100,
-          "databases",
+          "functions",
         )
-      ).databases.map((database: any) => database.$id);
-    } else {
-      databases = (await inquirer.prompt(questionsPullCollection)).databases;
-    }
-  }
-
-  for (const databaseId of databases) {
-    const database = await databasesService.get(databaseId);
+      ).functions
+    : (await inquirer.prompt(questionsPullFunctions)).functions;
 
-    totalDatabases++;
-    log(
-      `Pulling all collections from ${chalk.bold(database["name"])} database ...`,
-    );
+  let allowCodePull: boolean | null = cliConfig.force === true ? true : null;
+  if (code !== false && allowCodePull === null) {
+    const codeAnswer = await inquirer.prompt(questionsPullFunctionsCode);
+    allowCodePull = codeAnswer.override;
+  }
 
-    localConfig.addDatabase(database);
+  const shouldPullCode = code !== false && allowCodePull === true;
+  const selectedFunctionIds = functionsToCheck.map((f: any) => f.$id);
 
-    const { collections } = await paginate(
-      async () => (await getDatabasesService()).listCollections(databaseId),
-      {},
-      100,
-      "collections",
-    );
+  const pullInstance = await createPullInstance();
+  const functions = await pullInstance.pullFunctions({
+    code: shouldPullCode,
+    withVariables,
+    functionIds: selectedFunctionIds,
+  });
 
-    for (const collection of collections) {
-      totalCollections++;
-      localConfig.addCollection({
-        ...collection,
-        $createdAt: undefined,
-        $updatedAt: undefined,
-      });
-    }
+  for (const func of functions) {
+    const localFunction = localConfig.getFunction(func.$id);
+    func["path"] = localFunction["path"] || func["path"];
+    localConfig.addFunction(func);
   }
-
-  success(
-    `Successfully pulled ${chalk.bold(totalCollections)} collections from ${chalk.bold(totalDatabases)} databases.`,
-  );
 };
 
-const pullTable = async (): Promise<void> => {
-  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.`,
-    );
+const pullSites = async ({
+  code,
+  withVariables,
+}: PullSitesOptions = {}): Promise<void> => {
+  const sitesService = await getSitesService();
+  const fetchResponse = await sitesService.list({
+    queries: [Query.limit(1)],
+  });
+  if (fetchResponse["sites"].length <= 0) {
+    log("No sites found.");
+    success(`Successfully pulled ${chalk.bold(0)} sites.`);
     return;
   }
 
-  let databases: string[] = cliConfig.ids;
-
-  if (databases.length === 0) {
-    if (cliConfig.all) {
-      databases = (
+  const sitesToCheck = cliConfig.all
+    ? (
         await paginate(
-          async () => (await getTablesDBService()).list(),
+          async () => (await getSitesService()).list(),
           {},
           100,
-          "databases",
+          "sites",
         )
-      ).databases.map((database: any) => database.$id);
-    } else {
-      databases = (await inquirer.prompt(questionsPullCollection)).databases;
-    }
+      ).sites
+    : (await inquirer.prompt(questionsPullSites)).sites;
+
+  let allowCodePull: boolean | null = cliConfig.force === true ? true : null;
+  if (code !== false && allowCodePull === null) {
+    const codeAnswer = await inquirer.prompt(questionsPullSitesCode);
+    allowCodePull = codeAnswer.override;
   }
 
-  for (const databaseId of databases) {
-    const database = await tablesDBService.get(databaseId);
+  const shouldPullCode = code !== false && allowCodePull === true;
+  const selectedSiteIds = sitesToCheck.map((s: any) => s.$id);
 
-    totalTablesDBs++;
-    log(`Pulling all tables from ${chalk.bold(database["name"])} database ...`);
+  const pullInstance = await createPullInstance();
+  const sites = await pullInstance.pullSites({
+    code: shouldPullCode,
+    withVariables,
+    siteIds: selectedSiteIds,
+  });
 
-    localConfig.addTablesDB(database);
+  for (const site of sites) {
+    const localSite = localConfig.getSite(site.$id);
+    site["path"] = localSite["path"] || site["path"];
+    localConfig.addSite(site);
+  }
+};
 
-    const { tables } = await paginate(
-      async () => (await getTablesDBService()).listTables(databaseId),
-      {},
-      100,
-      "tables",
-    );
+const pullCollection = async (): Promise<void> => {
+  const pullInstance = await createPullInstance();
+  const { databases, collections } = await pullInstance.pullCollections();
 
-    for (const table of tables) {
-      totalTables++;
-      localConfig.addTable({
-        ...table,
-        $createdAt: undefined,
-        $updatedAt: undefined,
-      });
-    }
+  for (const database of databases) {
+    localConfig.addDatabase(database);
   }
 
-  success(
-    `Successfully pulled ${chalk.bold(totalTables)} tables from ${chalk.bold(totalTablesDBs)} tableDBs.`,
-  );
+  for (const collection of collections) {
+    localConfig.addCollection(collection);
+  }
 };
 
-const pullBucket = async (): Promise<void> => {
-  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 pullTable = async (): Promise<void> => {
+  const pullInstance = await createPullInstance();
+  const { databases, tables } = await pullInstance.pullTables();
+
+  for (const database of databases) {
+    localConfig.addTablesDB(database);
   }
 
-  const { buckets } = await paginate(
-    async () => (await getStorageService()).listBuckets(),
-    {},
-    100,
-    "buckets",
-  );
+  for (const table of tables) {
+    localConfig.addTable(table);
+  }
+};
+
+const pullBucket = async (): Promise<void> => {
+  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 (): Promise<void> => {
-  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 (): Promise<void> => {
-  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;