chirag-appwrite-cli 0.2.1 → 0.3.0

package/lib/commands/pull.ts

@@ -1,4 +1,5 @@
 import fs from "fs";
+import path from "path";
 import chalk from "chalk";
 import { Command } from "commander";
 import inquirer from "inquirer";
@@ -40,6 +41,7 @@ import { createSettingsObject } from "../utils.js";
 import { ProjectNotInitializedError } from "./errors.js";
 import type { SettingsType, FunctionType, SiteType } from "./config.js";
 import { downloadDeploymentCode } from "./utils/deployment.js";
+import { getConfirmation } from "./utils/change-approval.js";
 
 export interface PullOptions {
   all?: boolean;
@@ -177,7 +179,7 @@ export class Pull {
       updatedConfig.tables = tables;
     }
 
-    if (!skipDeprecated && (shouldPullAll || options.collections)) {
+    if (options.collections || (shouldPullAll && !skipDeprecated)) {
       const { databases, collections } = await this.pullCollections();
       updatedConfig.databases = databases;
       updatedConfig.collections = collections;
@@ -227,104 +229,96 @@ export class Pull {
   ): Promise<FunctionType[]> {
     this.log("Fetching functions ...");
 
-    const originalCwd = process.cwd();
-    process.chdir(this.configDirectoryPath);
+    const functionsService = new Functions(this.projectClient);
+    let functions: Models.Function[];
 
-    try {
-      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 (fetchResponse["functions"].length <= 0) {
-          this.log("No functions found.");
-          this.success(`Successfully pulled ${chalk.bold(0)} functions.`);
-          return [];
-        }
+    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)],
+      });
 
-        const { functions: allFunctions } = await paginate(
-          async () => new Functions(this.projectClient).list(),
-          {},
-          100,
-          "functions",
-        );
-        functions = allFunctions;
+      if (fetchResponse["functions"].length <= 0) {
+        this.log("No functions found.");
+        this.success(`Successfully pulled ${chalk.bold(0)} functions.`);
+        return [];
       }
 
-      const result: FunctionType[] = [];
-
-      for (const func of functions) {
-        this.log(`Pulling function ${chalk.bold(func.name)} ...`);
-
-        const funcPath = `functions/${func.name}`;
-        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(funcPath)) {
-          fs.mkdirSync(funcPath, { recursive: true });
-        }
-
-        if (options.code !== false) {
-          await downloadDeploymentCode({
-            resourceId: func["$id"],
-            resourcePath: funcPath,
-            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,
-          });
-        }
+      const { functions: allFunctions } = await paginate(
+        async () => new Functions(this.projectClient).list(),
+        {},
+        100,
+        "functions",
+      );
+      functions = allFunctions;
+    }
+
+    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) {
-        this.warn("Source code download skipped.");
+      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,
+        });
       }
+    }
 
-      this.success(
-        `Successfully pulled ${chalk.bold(result.length)} functions.`,
-      );
-      return result;
-    } finally {
-      process.chdir(originalCwd);
+    if (options.code === false) {
+      this.warn("Source code download skipped.");
     }
+
+    this.success(`Successfully pulled ${chalk.bold(result.length)} functions.`);
+    return result;
   }
 
   /**
@@ -333,102 +327,96 @@ export class Pull {
   public async pullSites(options: PullSitesOptions = {}): Promise<SiteType[]> {
     this.log("Fetching sites ...");
 
-    const originalCwd = process.cwd();
-    process.chdir(this.configDirectoryPath);
-
-    try {
-      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)],
-        });
+    const sitesService = new Sites(this.projectClient);
+    let sites: Models.Site[];
 
-        if (fetchResponse["sites"].length <= 0) {
-          this.log("No sites found.");
-          this.success(`Successfully pulled ${chalk.bold(0)} sites.`);
-          return [];
-        }
+    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)],
+      });
 
-        const { sites: fetchedSites } = await paginate(
-          async () => new Sites(this.projectClient).list(),
-          {},
-          100,
-          "sites",
-        );
-        sites = fetchedSites;
+      if (fetchResponse["sites"].length <= 0) {
+        this.log("No sites found.");
+        this.success(`Successfully pulled ${chalk.bold(0)} sites.`);
+        return [];
       }
 
-      const result: SiteType[] = [];
-
-      for (const site of sites) {
-        this.log(`Pulling site ${chalk.bold(site.name)} ...`);
-
-        const sitePath = `sites/${site.name}`;
-        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(sitePath)) {
-          fs.mkdirSync(sitePath, { recursive: true });
-        }
-
-        if (options.code !== false) {
-          await downloadDeploymentCode({
-            resourceId: site["$id"],
-            resourcePath: sitePath,
-            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 { sites: fetchedSites } = await paginate(
+        async () => new Sites(this.projectClient).list(),
+        {},
+        100,
+        "sites",
+      );
+      sites = fetchedSites;
+    }
+
+    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 });
       }
 
-      if (options.code === false) {
-        this.warn("Source code download skipped.");
+      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,
+        });
       }
+    }
 
-      this.success(`Successfully pulled ${chalk.bold(result.length)} sites.`);
-      return result;
-    } finally {
-      process.chdir(originalCwd);
+    if (options.code === false) {
+      this.warn("Source code download skipped.");
     }
+
+    this.success(`Successfully pulled ${chalk.bold(result.length)} sites.`);
+    return result;
   }
 
   /**
@@ -817,53 +805,117 @@ const pullCollection = async (): Promise<void> => {
   const pullInstance = await createPullInstance();
   const { databases, collections } = await pullInstance.pullCollections();
 
-  for (const database of databases) {
-    localConfig.addDatabase(database);
-  }
+  const localCollections = localConfig.getCollections();
+  const remoteCollectionIds = new Set(collections.map((c: any) => c.$id));
+  const collectionsToRemove = localCollections.filter(
+    (c: any) => !remoteCollectionIds.has(c.$id),
+  );
 
-  for (const collection of collections) {
-    localConfig.addCollection(collection);
+  if (collectionsToRemove.length > 0) {
+    warn(
+      `The following collections exist locally but not remotely and will be removed: ${collectionsToRemove.map((c: any) => c.name || c.$id).join(", ")}`,
+    );
+    if ((await getConfirmation()) !== true) {
+      log("Pull cancelled.");
+      return;
+    }
   }
+
+  localConfig.set("databases", databases);
+  localConfig.set("collections", collections);
 };
 
 const pullTable = async (): Promise<void> => {
   const pullInstance = await createPullInstance();
   const { databases, tables } = await pullInstance.pullTables();
 
-  for (const database of databases) {
-    localConfig.addTablesDB(database);
-  }
+  const localTables = localConfig.getTables();
+  const remoteTableIds = new Set(tables.map((t: any) => t.$id));
+  const tablesToRemove = localTables.filter(
+    (t: any) => !remoteTableIds.has(t.$id),
+  );
 
-  for (const table of tables) {
-    localConfig.addTable(table);
+  if (tablesToRemove.length > 0) {
+    warn(
+      `The following tables exist locally but not remotely and will be removed: ${tablesToRemove.map((t: any) => t.name || t.$id).join(", ")}`,
+    );
+    if ((await getConfirmation()) !== true) {
+      log("Pull cancelled.");
+      return;
+    }
   }
+
+  localConfig.set("tablesDB", databases);
+  localConfig.set("tables", tables);
 };
 
 const pullBucket = async (): Promise<void> => {
   const pullInstance = await createPullInstance();
   const buckets = await pullInstance.pullBuckets();
 
-  for (const bucket of buckets) {
-    localConfig.addBucket(bucket);
+  const localBuckets = localConfig.getBuckets();
+  const remoteBucketIds = new Set(buckets.map((b: any) => b.$id));
+  const bucketsToRemove = localBuckets.filter(
+    (b: any) => !remoteBucketIds.has(b.$id),
+  );
+
+  if (bucketsToRemove.length > 0) {
+    warn(
+      `The following buckets exist locally but not remotely and will be removed: ${bucketsToRemove.map((b: any) => b.name || b.$id).join(", ")}`,
+    );
+    if ((await getConfirmation()) !== true) {
+      log("Pull cancelled.");
+      return;
+    }
   }
+
+  localConfig.set("buckets", buckets);
 };
 
 const pullTeam = async (): Promise<void> => {
   const pullInstance = await createPullInstance();
   const teams = await pullInstance.pullTeams();
 
-  for (const team of teams) {
-    localConfig.addTeam(team);
+  const localTeams = localConfig.getTeams();
+  const remoteTeamIds = new Set(teams.map((t: any) => t.$id));
+  const teamsToRemove = localTeams.filter(
+    (t: any) => !remoteTeamIds.has(t.$id),
+  );
+
+  if (teamsToRemove.length > 0) {
+    warn(
+      `The following teams exist locally but not remotely and will be removed: ${teamsToRemove.map((t: any) => t.name || t.$id).join(", ")}`,
+    );
+    if ((await getConfirmation()) !== true) {
+      log("Pull cancelled.");
+      return;
+    }
   }
+
+  localConfig.set("teams", teams);
 };
 
 const pullMessagingTopic = async (): Promise<void> => {
   const pullInstance = await createPullInstance();
   const topics = await pullInstance.pullMessagingTopics();
 
-  for (const topic of topics) {
-    localConfig.addMessagingTopic(topic);
+  const localTopics = localConfig.getMessagingTopics();
+  const remoteTopicIds = new Set(topics.map((t: any) => t.$id));
+  const topicsToRemove = localTopics.filter(
+    (t: any) => !remoteTopicIds.has(t.$id),
+  );
+
+  if (topicsToRemove.length > 0) {
+    warn(
+      `The following topics exist locally but not remotely and will be removed: ${topicsToRemove.map((t: any) => t.name || t.$id).join(", ")}`,
+    );
+    if ((await getConfirmation()) !== true) {
+      log("Pull cancelled.");
+      return;
+    }
   }
+
+  localConfig.set("topics", topics);
 };
 
 /** Commander.js exports */