appwrite-cli 17.2.1 → 17.3.1

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

@@ -1,193 +0,0 @@
-import chalk from "chalk";
-import inquirer from "inquirer";
-import { AppwriteException } from "@appwrite.io/console";
-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: unknown): 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;
-  }
-
-  const 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 | unknown[] | undefined;
-
-export const getObjectChanges = <T extends Record<string, unknown>>(
-  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: Array<Record<string, unknown>>,
-  resourceGetFunction: (
-    options: Record<string, unknown>,
-  ) => Promise<Record<string, unknown>>,
-  keys: Set<string>,
-  resourceName: string,
-  resourcePlural: string,
-  skipKeys: string[] = [],
-  secondId: string = "",
-  secondResourceName: string = "",
-): Promise<boolean> => {
-  log("Checking for changes ...");
-  const changes: Array<Record<string, unknown>> = [];
-
-  await Promise.all(
-    resource.map(async (localResource) => {
-      try {
-        const options: Record<string, unknown> = {
-          [resourceName]: localResource["$id"],
-        };
-
-        if (secondId !== "" && secondResourceName !== "") {
-          options[secondResourceName] = localResource[secondId];
-        }
-
-        const remoteResource = await resourceGetFunction(options);
-
-        for (const [key, value] of Object.entries(
-          whitelistKeys(remoteResource, keys),
-        )) {
-          if (skipKeys.includes(key)) {
-            continue;
-          }
-
-          if (isEmpty(value) && isEmpty(localResource[key])) {
-            continue;
-          }
-
-          const localValue = localResource[key];
-
-          if (Array.isArray(value) && Array.isArray(localValue)) {
-            if (JSON.stringify(value) !== JSON.stringify(localValue)) {
-              changes.push({
-                id: localResource["$id"],
-                key,
-                remote: chalk.red((value as string[]).join("\n")),
-                local: chalk.green(
-                  localValue.map((entry) => String(entry)).join("\n"),
-                ),
-              });
-            }
-          } else if (value !== localValue) {
-            changes.push({
-              id: localResource["$id"],
-              key,
-              remote: chalk.red(String(value ?? "")),
-              local: chalk.green(String(localValue ?? "")),
-            });
-          }
-        }
-      } catch (e: unknown) {
-        const isNotFound =
-          e instanceof AppwriteException && Number(e.code) === 404;
-        if (!isNotFound) 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

@@ -1,220 +0,0 @@
-import chalk from "chalk";
-import { AppwriteException } from "@appwrite.io/console";
-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;
-}
-
-interface TablesDBResource {
-  $id: string;
-  name: string;
-  enabled: boolean;
-}
-
-const isTablesDBResource = (value: unknown): value is TablesDBResource => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-
-  return (
-    "$id" in value &&
-    typeof value.$id === "string" &&
-    "name" in value &&
-    typeof value.name === "string" &&
-    "enabled" in value &&
-    typeof value.enabled === "boolean"
-  );
-};
-
-const getSyncErrorMessage = (err: unknown): string => {
-  if (err instanceof AppwriteException) {
-    return err.message;
-  }
-
-  if (err instanceof Error) {
-    return err.message;
-  }
-
-  return String(err);
-};
-
-/**
- * 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: TablesDBResource[] = localConfig.getTablesDBs();
-    const paginatedResult = await paginate(
-      async (args) => {
-        const tablesDBService = await getTablesDBService();
-        const queries = Array.isArray(args.queries)
-          ? args.queries.filter(
-              (query): query is string => typeof query === "string",
-            )
-          : [];
-        return await tablesDBService.list(queries);
-      },
-      {},
-      100,
-      "databases",
-    );
-    const remoteTablesDBs = Array.isArray(paginatedResult.databases)
-      ? paginatedResult.databases.filter(isTablesDBResource)
-      : [];
-
-    if (localTablesDBs.length === 0 && remoteTablesDBs.length === 0) {
-      return { applied: false, resyncNeeded: false };
-    }
-
-    const changes: Array<Record<string, unknown>> = [];
-    const toCreate: TablesDBResource[] = [];
-    const toUpdate: TablesDBResource[] = [];
-    const toDelete: TablesDBResource[] = [];
-
-    // Check for deletions - remote DBs that aren't in local config
-    for (const remoteDB of remoteTablesDBs) {
-      const localDB = localTablesDBs.find((db) => 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) => 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: unknown) {
-        error(
-          `Failed to delete database ${db.name} ( ${db.$id} ): ${getSyncErrorMessage(e)}`,
-        );
-        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: unknown) {
-        error(
-          `Failed to create database ${db.name} ( ${db.$id} ): ${getSyncErrorMessage(e)}`,
-        );
-        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: unknown) {
-        error(
-          `Failed to update database ${db.name} ( ${db.$id} ): ${getSyncErrorMessage(e)}`,
-        );
-        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

@@ -1,225 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { create, extract } from "tar";
-import { Client, AppwriteException } from "@appwrite.io/console";
-import { error } from "../../parser.js";
-
-const POLL_DEBOUNCE = 2000; // Milliseconds
-
-interface DeploymentListResult {
-  total: number;
-  deployments: Array<{
-    $id: string;
-  }>;
-}
-
-interface DeploymentDetails {
-  $id: string;
-  status: string;
-  [key: string]: unknown;
-}
-
-/**
- * Package a directory into a tar.gz File object for deployment
- */
-async function packageDirectory(dirPath: string): Promise<File> {
-  const tempFile = path.join(
-    os.tmpdir(),
-    `appwrite-deploy-${Date.now()}.tar.gz`,
-  );
-
-  await create(
-    {
-      gzip: true,
-      file: tempFile,
-      cwd: dirPath,
-    },
-    ["."],
-  );
-
-  try {
-    const buffer = fs.readFileSync(tempFile);
-    return new File([buffer], path.basename(tempFile), {
-      type: "application/gzip",
-    });
-  } finally {
-    if (fs.existsSync(tempFile)) {
-      fs.unlinkSync(tempFile);
-    }
-  }
-}
-
-/**
- * Resolve a file path (file or directory) into a File object for upload.
- * Directories are packaged into a tar.gz archive.
- */
-export async function resolveFileParam(filePath: string): Promise<File> {
-  const resolved = path.resolve(filePath);
-  if (!fs.existsSync(resolved)) {
-    throw new Error(`File or directory not found: ${resolved}`);
-  }
-  const stat = fs.statSync(resolved);
-  if (stat.isDirectory()) {
-    return packageDirectory(resolved);
-  }
-  const buffer = fs.readFileSync(resolved);
-  return new File([buffer], path.basename(resolved));
-}
-
-/**
- * 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<DeploymentListResult>;
-  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",
-  );
-
-  if (!(downloadBuffer instanceof ArrayBuffer)) {
-    throw new Error("Failed to download deployment archive as ArrayBuffer.");
-  }
-
-  try {
-    fs.writeFileSync(compressedFileName, Buffer.from(downloadBuffer));
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(
-      `Failed to write deployment archive to "${compressedFileName}": ${message}`,
-    );
-  }
-
-  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<DeploymentDetails>;
-  getDeployment?: (deploymentId: string) => Promise<DeploymentDetails>;
-  pollForStatus?: boolean;
-  onStatusUpdate?: (status: string) => void;
-}
-
-export interface PushDeploymentResult {
-  deployment: DeploymentDetails;
-  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,
-  };
-}