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

package/lib/commands/utils/change-approval.ts

@@ -0,0 +1,186 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { cliConfig, success, warn, log, drawTable } from "../../parser.js";
+import { whitelistKeys } from "../../config.js";
+import {
+  questionPushChanges,
+  questionPushChangesConfirmation,
+} from "../../questions.js";
+
+/**
+ * Check if a value is considered empty
+ */
+export const isEmpty = (value: any): boolean =>
+  value === null ||
+  value === undefined ||
+  (typeof value === "string" && value.trim().length === 0) ||
+  (Array.isArray(value) && value.length === 0);
+
+/**
+ * Prompt user for confirmation to proceed with push
+ */
+export const getConfirmation = async (): Promise<boolean> => {
+  if (cliConfig.force) {
+    return true;
+  }
+
+  async function fixConfirmation(): Promise<string> {
+    const answers = await inquirer.prompt(questionPushChangesConfirmation);
+    if (answers.changes !== "YES" && answers.changes !== "NO") {
+      return await fixConfirmation();
+    }
+
+    return answers.changes;
+  }
+
+  let answers = await inquirer.prompt(questionPushChanges);
+
+  if (answers.changes !== "YES" && answers.changes !== "NO") {
+    answers.changes = await fixConfirmation();
+  }
+
+  if (answers.changes === "YES") {
+    return true;
+  }
+
+  warn("Skipping push action. Changes were not applied.");
+  return false;
+};
+
+/**
+ * Compare two objects and return their differences
+ */
+interface ObjectChange {
+  group: string;
+  setting: string;
+  remote: string;
+  local: string;
+}
+
+type ComparableValue = boolean | number | string | any[] | undefined;
+
+export const getObjectChanges = <T extends Record<string, any>>(
+  remote: T,
+  local: T,
+  index: keyof T,
+  what: string,
+): ObjectChange[] => {
+  const changes: ObjectChange[] = [];
+
+  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 as Record<string, ComparableValue>;
+    const localObj = localNested as Record<string, ComparableValue>;
+
+    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);
+      } else {
+        valuesEqual = status === localValue;
+      }
+
+      if (!valuesEqual) {
+        changes.push({
+          group: what,
+          setting: service,
+          remote: chalk.red(String(status ?? "")),
+          local: chalk.green(String(localValue ?? "")),
+        });
+      }
+    }
+  }
+
+  return changes;
+};
+
+/**
+ * Approve changes before pushing resources
+ * Compares local resources with remote resources and prompts user for confirmation
+ */
+export const approveChanges = async (
+  resource: any[],
+  resourceGetFunction: Function,
+  keys: Set<string>,
+  resourceName: string,
+  resourcePlural: string,
+  skipKeys: string[] = [],
+  secondId: string = "",
+  secondResourceName: string = "",
+): Promise<boolean> => {
+  log("Checking for changes ...");
+  const changes: any[] = [];
+
+  await Promise.all(
+    resource.map(async (localResource) => {
+      try {
+        const options: Record<string, any> = {
+          [resourceName]: localResource["$id"],
+        };
+
+        if (secondId !== "" && secondResourceName !== "") {
+          options[secondResourceName] = localResource[secondId];
+        }
+
+        const remoteResource = await resourceGetFunction(options);
+
+        for (let [key, value] of Object.entries(
+          whitelistKeys(remoteResource, keys),
+        )) {
+          if (skipKeys.includes(key)) {
+            continue;
+          }
+
+          if (isEmpty(value) && isEmpty(localResource[key])) {
+            continue;
+          }
+
+          if (Array.isArray(value) && Array.isArray(localResource[key])) {
+            if (JSON.stringify(value) !== JSON.stringify(localResource[key])) {
+              changes.push({
+                id: localResource["$id"],
+                key,
+                remote: chalk.red((value as string[]).join("\n")),
+                local: chalk.green(localResource[key].join("\n")),
+              });
+            }
+          } else if (value !== localResource[key]) {
+            changes.push({
+              id: localResource["$id"],
+              key,
+              remote: chalk.red(value),
+              local: chalk.green(localResource[key]),
+            });
+          }
+        }
+      } catch (e: any) {
+        if (Number(e.code) !== 404) {
+          throw e;
+        }
+      }
+    }),
+  );
+
+  if (changes.length === 0) {
+    return true;
+  }
+
+  drawTable(changes);
+  if ((await getConfirmation()) === true) {
+    return true;
+  }
+
+  success(`Successfully pushed 0 ${resourcePlural}.`);
+  return false;
+};

package/lib/commands/utils/database-sync.ts

@@ -0,0 +1,180 @@
+import chalk from "chalk";
+import { localConfig } from "../../config.js";
+import { log, success, error, drawTable } from "../../parser.js";
+import { paginate } from "../../paginate.js";
+import { getTablesDBService } from "../../services.js";
+import { getConfirmation } from "./change-approval.js";
+
+export interface TablesDBChangesResult {
+  applied: boolean;
+  resyncNeeded: boolean;
+}
+
+/**
+ * Check for and apply changes to tablesDB (databases)
+ * Handles creation, update, and deletion of databases
+ */
+export const checkAndApplyTablesDBChanges =
+  async (): Promise<TablesDBChangesResult> => {
+    log("Checking for tablesDB changes ...");
+
+    const localTablesDBs = localConfig.getTablesDBs();
+    const { databases: remoteTablesDBs } = await paginate(
+      async (args: any) => {
+        const tablesDBService = await getTablesDBService();
+        return await tablesDBService.list(args.queries || []);
+      },
+      {},
+      100,
+      "databases",
+    );
+
+    if (localTablesDBs.length === 0 && remoteTablesDBs.length === 0) {
+      return { applied: false, resyncNeeded: false };
+    }
+
+    const changes: any[] = [];
+    const toCreate: any[] = [];
+    const toUpdate: any[] = [];
+    const toDelete: any[] = [];
+
+    // Check for deletions - remote DBs that aren't in local config
+    for (const remoteDB of remoteTablesDBs) {
+      const localDB = localTablesDBs.find((db: any) => db.$id === remoteDB.$id);
+      if (!localDB) {
+        toDelete.push(remoteDB);
+        changes.push({
+          id: remoteDB.$id,
+          action: chalk.red("deleting"),
+          key: "Database",
+          remote: remoteDB.name,
+          local: "(deleted locally)",
+        });
+      }
+    }
+
+    // Check for additions and updates
+    for (const localDB of localTablesDBs) {
+      const remoteDB = remoteTablesDBs.find(
+        (db: any) => db.$id === localDB.$id,
+      );
+
+      if (!remoteDB) {
+        toCreate.push(localDB);
+        changes.push({
+          id: localDB.$id,
+          action: chalk.green("creating"),
+          key: "Database",
+          remote: "(does not exist)",
+          local: localDB.name,
+        });
+      } else {
+        let hasChanges = false;
+
+        if (remoteDB.name !== localDB.name) {
+          hasChanges = true;
+          changes.push({
+            id: localDB.$id,
+            action: chalk.yellow("updating"),
+            key: "Name",
+            remote: remoteDB.name,
+            local: localDB.name,
+          });
+        }
+
+        if (remoteDB.enabled !== localDB.enabled) {
+          hasChanges = true;
+          changes.push({
+            id: localDB.$id,
+            action: chalk.yellow("updating"),
+            key: "Enabled",
+            remote: remoteDB.enabled,
+            local: localDB.enabled,
+          });
+        }
+
+        if (hasChanges) {
+          toUpdate.push(localDB);
+        }
+      }
+    }
+
+    if (changes.length === 0) {
+      return { applied: false, resyncNeeded: false };
+    }
+
+    log("Found changes in tablesDB resource:");
+    drawTable(changes);
+
+    if (toDelete.length > 0) {
+      console.log(
+        `${chalk.red("------------------------------------------------------------------")}`,
+      );
+      console.log(
+        `${chalk.red("| WARNING: Database deletion will also delete all related tables |")}`,
+      );
+      console.log(
+        `${chalk.red("------------------------------------------------------------------")}`,
+      );
+      console.log();
+    }
+
+    if ((await getConfirmation()) !== true) {
+      return { applied: false, resyncNeeded: false };
+    }
+
+    // Apply deletions first
+    let needsResync = false;
+    for (const db of toDelete) {
+      try {
+        log(`Deleting database ${db.name} ( ${db.$id} ) ...`);
+        const tablesDBService = await getTablesDBService();
+        await tablesDBService.delete(db.$id);
+        success(`Deleted ${db.name} ( ${db.$id} )`);
+        needsResync = true;
+      } catch (e: any) {
+        error(
+          `Failed to delete database ${db.name} ( ${db.$id} ): ${e.message}`,
+        );
+        throw new Error(
+          `Database sync failed during deletion of ${db.$id}. Some changes may have been applied.`,
+        );
+      }
+    }
+
+    // Apply creations
+    for (const db of toCreate) {
+      try {
+        log(`Creating database ${db.name} ( ${db.$id} ) ...`);
+        const tablesDBService = await getTablesDBService();
+        await tablesDBService.create(db.$id, db.name, db.enabled);
+        success(`Created ${db.name} ( ${db.$id} )`);
+      } catch (e: any) {
+        error(
+          `Failed to create database ${db.name} ( ${db.$id} ): ${e.message}`,
+        );
+        throw new Error(
+          `Database sync failed during creation of ${db.$id}. Some changes may have been applied.`,
+        );
+      }
+    }
+
+    // Apply updates
+    for (const db of toUpdate) {
+      try {
+        log(`Updating database ${db.name} ( ${db.$id} ) ...`);
+        const tablesDBService = await getTablesDBService();
+        await tablesDBService.update(db.$id, db.name, db.enabled);
+        success(`Updated ${db.name} ( ${db.$id} )`);
+      } catch (e: any) {
+        error(
+          `Failed to update database ${db.name} ( ${db.$id} ): ${e.message}`,
+        );
+        throw new Error(
+          `Database sync failed during update of ${db.$id}. Some changes may have been applied.`,
+        );
+      }
+    }
+
+    return { applied: true, resyncNeeded: needsResync };
+  };

package/lib/commands/utils/deployment.ts

@@ -0,0 +1,184 @@
+import fs from "fs";
+import path from "path";
+import tar from "tar";
+import { Client, AppwriteException } from "@appwrite.io/console";
+import { error } from "../../parser.js";
+
+const POLL_DEBOUNCE = 2000; // Milliseconds
+
+/**
+ * Package a directory into a tar.gz File object for deployment
+ * @private - Only used internally by pushDeployment
+ */
+async function packageDirectory(dirPath: string): Promise<File> {
+  const tempFile = `${dirPath.replace(/[^a-zA-Z0-9]/g, "_")}-${Date.now()}.tar.gz`;
+
+  await tar.create(
+    {
+      gzip: true,
+      file: tempFile,
+      cwd: dirPath,
+    },
+    ["."],
+  );
+
+  const buffer = fs.readFileSync(tempFile);
+  fs.unlinkSync(tempFile);
+
+  return new File([buffer], path.basename(tempFile), {
+    type: "application/gzip",
+  });
+}
+
+/**
+ * Download and extract deployment code for a resource
+ */
+export async function downloadDeploymentCode(params: {
+  resourceId: string;
+  resourcePath: string;
+  holdingVars: { key: string; value: string }[];
+  withVariables?: boolean;
+  listDeployments: () => Promise<any>;
+  getDownloadUrl: (deploymentId: string) => string;
+  projectClient: Client;
+}): Promise<void> {
+  const {
+    resourceId,
+    resourcePath,
+    holdingVars,
+    withVariables,
+    listDeployments,
+    getDownloadUrl,
+    projectClient,
+  } = params;
+
+  let deploymentId: string | null = null;
+  try {
+    const deployments = await listDeployments();
+    if (deployments["total"] > 0) {
+      deploymentId = deployments["deployments"][0]["$id"];
+    }
+  } catch (e: unknown) {
+    if (e instanceof AppwriteException) {
+      error(e.message);
+      return;
+    } else {
+      throw e;
+    }
+  }
+
+  if (deploymentId === null) {
+    return;
+  }
+
+  const compressedFileName = path.resolve(
+    path.dirname(resourcePath),
+    `${resourceId}-${+new Date()}.tar.gz`,
+  );
+  const downloadUrl = getDownloadUrl(deploymentId);
+
+  const downloadBuffer = await projectClient.call(
+    "get",
+    new URL(downloadUrl),
+    {},
+    {},
+    "arrayBuffer",
+  );
+
+  try {
+    fs.writeFileSync(compressedFileName, Buffer.from(downloadBuffer as any));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Failed to write deployment archive to "${compressedFileName}": ${message}`,
+    );
+  }
+
+  tar.extract({
+    sync: true,
+    cwd: resourcePath,
+    file: compressedFileName,
+    strict: false,
+  });
+
+  fs.rmSync(compressedFileName);
+
+  if (withVariables) {
+    const envFileLocation = `${resourcePath}/.env`;
+    try {
+      fs.rmSync(envFileLocation);
+    } catch {}
+
+    fs.writeFileSync(
+      envFileLocation,
+      holdingVars.map((r) => `${r.key}=${r.value}\n`).join(""),
+    );
+  }
+}
+
+export interface PushDeploymentParams {
+  resourcePath: string;
+  createDeployment: (codeFile: File) => Promise<any>;
+  getDeployment?: (deploymentId: string) => Promise<any>;
+  pollForStatus?: boolean;
+  onStatusUpdate?: (status: string) => void;
+}
+
+export interface PushDeploymentResult {
+  deployment: any;
+  wasPolled: boolean;
+  finalStatus?: string;
+}
+
+/**
+ * Push a deployment for a resource (function or site)
+ * Handles packaging, creating the deployment, and optionally polling for status
+ */
+export async function pushDeployment(
+  params: PushDeploymentParams,
+): Promise<PushDeploymentResult> {
+  const {
+    resourcePath,
+    createDeployment,
+    getDeployment,
+    pollForStatus = false,
+    onStatusUpdate,
+  } = params;
+
+  // Package the directory
+  const codeFile = await packageDirectory(resourcePath);
+
+  // Create the deployment
+  let deployment = await createDeployment(codeFile);
+
+  // Poll for deployment status if requested
+  let finalStatus: string | undefined;
+  let wasPolled = false;
+
+  if (pollForStatus && getDeployment) {
+    wasPolled = true;
+    const deploymentId = deployment["$id"];
+
+    while (true) {
+      deployment = await getDeployment(deploymentId);
+      const status = deployment["status"];
+
+      if (onStatusUpdate) {
+        onStatusUpdate(status);
+      }
+
+      if (status === "ready" || status === "failed") {
+        finalStatus = status;
+        break;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, POLL_DEBOUNCE * 1.5));
+    }
+  }
+
+  return {
+    deployment,
+    wasPolled,
+    finalStatus,
+  };
+}