appwrite-cli 13.6.0 → 13.6.1

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

@@ -1,4 +1,5 @@
 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";
@@ -10,6 +11,39 @@ export interface TablesDBChangesResult {
   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
@@ -18,29 +52,37 @@ export const checkAndApplyTablesDBChanges =
   async (): Promise<TablesDBChangesResult> => {
     log("Checking for tablesDB changes ...");
 
-    const localTablesDBs = localConfig.getTablesDBs();
-    const { databases: remoteTablesDBs } = await paginate(
-      async (args: any) => {
+    const localTablesDBs: TablesDBResource[] = localConfig.getTablesDBs();
+    const paginatedResult = await paginate(
+      async (args) => {
         const tablesDBService = await getTablesDBService();
-        return await tablesDBService.list(args.queries || []);
+        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: any[] = [];
-    const toCreate: any[] = [];
-    const toUpdate: any[] = [];
-    const toDelete: any[] = [];
+    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: any) => db.$id === remoteDB.$id);
+      const localDB = localTablesDBs.find((db) => db.$id === remoteDB.$id);
       if (!localDB) {
         toDelete.push(remoteDB);
         changes.push({
@@ -55,9 +97,7 @@ export const checkAndApplyTablesDBChanges =
 
     // Check for additions and updates
     for (const localDB of localTablesDBs) {
-      const remoteDB = remoteTablesDBs.find(
-        (db: any) => db.$id === localDB.$id,
-      );
+      const remoteDB = remoteTablesDBs.find((db) => db.$id === localDB.$id);
 
       if (!remoteDB) {
         toCreate.push(localDB);
@@ -132,9 +172,9 @@ export const checkAndApplyTablesDBChanges =
         await tablesDBService.delete(db.$id);
         success(`Deleted ${db.name} ( ${db.$id} )`);
         needsResync = true;
-      } catch (e: any) {
+      } catch (e: unknown) {
         error(
-          `Failed to delete database ${db.name} ( ${db.$id} ): ${e.message}`,
+          `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.`,
@@ -149,9 +189,9 @@ export const checkAndApplyTablesDBChanges =
         const tablesDBService = await getTablesDBService();
         await tablesDBService.create(db.$id, db.name, db.enabled);
         success(`Created ${db.name} ( ${db.$id} )`);
-      } catch (e: any) {
+      } catch (e: unknown) {
         error(
-          `Failed to create database ${db.name} ( ${db.$id} ): ${e.message}`,
+          `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.`,
@@ -166,9 +206,9 @@ export const checkAndApplyTablesDBChanges =
         const tablesDBService = await getTablesDBService();
         await tablesDBService.update(db.$id, db.name, db.enabled);
         success(`Updated ${db.name} ( ${db.$id} )`);
-      } catch (e: any) {
+      } catch (e: unknown) {
         error(
-          `Failed to update database ${db.name} ( ${db.$id} ): ${e.message}`,
+          `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.`,

package/lib/commands/utils/deployment.ts

@@ -6,6 +6,19 @@ 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
  * @private - Only used internally by pushDeployment
@@ -38,7 +51,7 @@ export async function downloadDeploymentCode(params: {
   resourcePath: string;
   holdingVars: { key: string; value: string }[];
   withVariables?: boolean;
-  listDeployments: () => Promise<any>;
+  listDeployments: () => Promise<DeploymentListResult>;
   getDownloadUrl: (deploymentId: string) => string;
   projectClient: Client;
 }): Promise<void> {
@@ -85,8 +98,12 @@ export async function downloadDeploymentCode(params: {
     "arrayBuffer",
   );
 
+  if (!(downloadBuffer instanceof ArrayBuffer)) {
+    throw new Error("Failed to download deployment archive as ArrayBuffer.");
+  }
+
   try {
-    fs.writeFileSync(compressedFileName, Buffer.from(downloadBuffer as any));
+    fs.writeFileSync(compressedFileName, Buffer.from(downloadBuffer));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(
@@ -118,14 +135,14 @@ export async function downloadDeploymentCode(params: {
 
 export interface PushDeploymentParams {
   resourcePath: string;
-  createDeployment: (codeFile: File) => Promise<any>;
-  getDeployment?: (deploymentId: string) => Promise<any>;
+  createDeployment: (codeFile: File) => Promise<DeploymentDetails>;
+  getDeployment?: (deploymentId: string) => Promise<DeploymentDetails>;
   pollForStatus?: boolean;
   onStatusUpdate?: (status: string) => void;
 }
 
 export interface PushDeploymentResult {
-  deployment: any;
+  deployment: DeploymentDetails;
   wasPolled: boolean;
   finalStatus?: string;
 }

package/lib/commands/utils/pools.ts

@@ -39,7 +39,7 @@ export class Pools {
     }
 
     if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
-      let steps = Math.max(1, Math.ceil(Number(total) / this.STEP_SIZE));
+      const steps = Math.max(1, Math.ceil(Number(total) / this.STEP_SIZE));
       if (steps > 1 && iteration === 1) {
         this.pollMaxDebounces *= steps;
 
@@ -78,7 +78,7 @@ export class Pools {
     }
 
     if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
-      let steps = Math.max(1, Math.ceil(Number(total) / this.STEP_SIZE));
+      const steps = Math.max(1, Math.ceil(Number(total) / this.STEP_SIZE));
       if (steps > 1 && iteration === 1) {
         this.pollMaxDebounces *= steps;
 
@@ -106,7 +106,10 @@ export class Pools {
     }
 
     if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
-      let steps = Math.max(1, Math.ceil(attributeKeys.length / this.STEP_SIZE));
+      const steps = Math.max(
+        1,
+        Math.ceil(attributeKeys.length / this.STEP_SIZE),
+      );
       if (steps > 1 && iteration === 1) {
         this.pollMaxDebounces *= steps;
 
@@ -164,7 +167,10 @@ export class Pools {
     }
 
     if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
-      let steps = Math.max(1, Math.ceil(attributeKeys.length / this.STEP_SIZE));
+      const steps = Math.max(
+        1,
+        Math.ceil(attributeKeys.length / this.STEP_SIZE),
+      );
       if (steps > 1 && iteration === 1) {
         this.pollMaxDebounces *= steps;
 
@@ -232,7 +238,7 @@ export class Pools {
     }
 
     if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
-      let steps = Math.max(1, Math.ceil(indexKeys.length / this.STEP_SIZE));
+      const steps = Math.max(1, Math.ceil(indexKeys.length / this.STEP_SIZE));
       if (steps > 1 && iteration === 1) {
         this.pollMaxDebounces *= steps;
 

package/lib/config.ts

@@ -146,7 +146,7 @@ class Config<T extends ConfigData = ConfigData> {
     try {
       const file = fs.readFileSync(this.path).toString();
       this.data = JSONBig.parse(file);
-    } catch (e) {
+    } catch (_e) {
       this.data = {} as T;
     }
   }

package/lib/constants.ts

@@ -1,7 +1,7 @@
 // SDK
 export const SDK_TITLE = 'Appwrite';
 export const SDK_TITLE_LOWER = 'appwrite';
-export const SDK_VERSION = '13.6.0';
+export const SDK_VERSION = '13.6.1';
 export const SDK_NAME = 'Command Line';
 export const SDK_PLATFORM = 'console';
 export const SDK_LANGUAGE = 'cli';

package/lib/emulation/docker.ts

@@ -1,6 +1,7 @@
 import ignoreModule from "ignore";
 const ignore: typeof ignoreModule =
-  (ignoreModule as any).default ?? ignoreModule;
+  (ignoreModule as unknown as { default?: typeof ignoreModule }).default ??
+  ignoreModule;
 import net from "net";
 import chalk from "chalk";
 import childProcess from "child_process";
@@ -256,11 +257,9 @@ export async function dockerStart(
 
   try {
     await waitUntilPortOpen(port);
-  } catch (err: any) {
-    error(
-      "Failed to start function with error: " +
-        (err.message ? err.message : err.toString()),
-    );
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    error(`Failed to start function with error: ${message}`);
     return;
   }
 

package/lib/emulation/utils.ts

@@ -142,14 +142,14 @@ export const JwtManager = {
       await usersClient.get({
         userId,
       });
-      const userResponse: any = await usersClient.createJWT({
+      const userResponse = await usersClient.createJWT({
         userId,
         duration: 60 * 60,
       });
       this.userJwt = userResponse.jwt;
     }
 
-    const functionResponse: any = await projectsClient.createJWT({
+    const functionResponse = await projectsClient.createJWT({
       projectId: localConfig.getProject().projectId!,
       scopes: projectScopes,
       duration: 60 * 60,

package/lib/json.ts

@@ -8,18 +8,25 @@ const MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
 const MAX_INT64 = BigInt("9223372036854775807");
 const MIN_INT64 = BigInt("-9223372036854775808");
 
-function isBigNumber(value: any): boolean {
+interface BigNumberLike {
+  _isBigNumber: boolean;
+  isInteger: () => boolean;
+  toFixed: () => string;
+  toNumber: () => number;
+}
+
+function isBigNumber(value: unknown): value is BigNumberLike {
   return (
     value !== null &&
     typeof value === "object" &&
-    value._isBigNumber === true &&
-    typeof value.isInteger === "function" &&
-    typeof value.toFixed === "function" &&
-    typeof value.toNumber === "function"
+    (value as BigNumberLike)._isBigNumber === true &&
+    typeof (value as BigNumberLike).isInteger === "function" &&
+    typeof (value as BigNumberLike).toFixed === "function" &&
+    typeof (value as BigNumberLike).toNumber === "function"
   );
 }
 
-function reviver(_key: string, value: any): any {
+function reviver(_key: string, value: unknown): unknown {
   if (isBigNumber(value)) {
     if (value.isInteger()) {
       const str = value.toFixed();
@@ -38,6 +45,7 @@ function reviver(_key: string, value: any): any {
 }
 
 export const JSONBig = {
-  parse: (text: string) => JSONbigParser.parse(text, reviver),
+  parse: <T = unknown>(text: string): T =>
+    JSONbigParser.parse(text, reviver) as T,
   stringify: JSONbigSerializer.stringify,
 };

package/lib/paginate.ts

@@ -1,10 +1,12 @@
-interface PaginateArgs {
-  [key: string]: any;
-}
+type PaginateArgs = Record<string, unknown>;
+
+type WrappedPaginateResponse<T, K extends string = string> = Record<K, T[]> & {
+  total: number;
+};
 
 // Overload for when wrapper is empty string - returns array
-export function paginate<T = any>(
-  action: (args: PaginateArgs) => Promise<any>,
+export function paginate<T = unknown>(
+  action: (args: PaginateArgs) => Promise<T[]>,
   args: PaginateArgs,
   limit: number,
   wrapper: "",
@@ -12,22 +14,24 @@ export function paginate<T = any>(
 ): Promise<T[]>;
 
 // Overload for when wrapper is specified - returns object with that key
-export function paginate<T = any, K extends string = string>(
-  action: (args: PaginateArgs) => Promise<any>,
+export function paginate<T = unknown, K extends string = string>(
+  action: (args: PaginateArgs) => Promise<WrappedPaginateResponse<T, K>>,
   args: PaginateArgs,
   limit: number,
   wrapper: K,
   queries?: string[],
-): Promise<Record<K, T[]> & { total: number }>;
+): Promise<WrappedPaginateResponse<T, K>>;
 
 // Implementation
-export async function paginate<T = any>(
-  action: (args: PaginateArgs) => Promise<any>,
+export async function paginate<T = unknown>(
+  action: (
+    args: PaginateArgs,
+  ) => Promise<T[] | WrappedPaginateResponse<T, string>>,
   args: PaginateArgs = {},
   limit: number = 100,
   wrapper: string = "",
   queries: string[] = [],
-): Promise<T[] | (Record<string, T[]> & { total: number })> {
+): Promise<T[] | WrappedPaginateResponse<T, string>> {
   let pageNumber = 0;
   let results: T[] = [];
   let total = 0;
@@ -46,21 +50,27 @@ export async function paginate<T = any>(
     });
 
     if (wrapper === "") {
-      if (response.length === 0) {
+      const listResponse = response as T[];
+
+      if (listResponse.length === 0) {
         break;
       }
-      results = results.concat(response);
+
+      results = results.concat(listResponse);
     } else {
-      if (response[wrapper].length === 0) {
+      const wrappedResponse = response as WrappedPaginateResponse<T, string>;
+      const wrappedResults = wrappedResponse[wrapper] ?? [];
+
+      if (wrappedResults.length === 0) {
         break;
       }
-      results = results.concat(response[wrapper]);
-    }
 
-    total = response.total;
+      results = results.concat(wrappedResults);
+      total = wrappedResponse.total;
 
-    if (results.length >= total) {
-      break;
+      if (results.length >= total) {
+        break;
+      }
     }
 
     pageNumber++;
@@ -73,5 +83,5 @@ export async function paginate<T = any>(
   return {
     [wrapper]: results,
     total,
-  } as Record<string, T[]> & { total: number };
+  } as WrappedPaginateResponse<T, string>;
 }

package/lib/parser.ts

@@ -25,7 +25,36 @@ const cliConfig: CliConfig = {
   reportData: {},
 };
 
-export const parse = (data: Record<string, any>): void => {
+type JsonObject = Record<string, unknown>;
+
+interface ReportDataPayload {
+  data?: {
+    args?: string[];
+  };
+}
+
+const toJsonObject = (value: unknown): JsonObject | null => {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as JsonObject;
+  }
+
+  return null;
+};
+
+const extractReportCommandArgs = (value: unknown): string[] => {
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+
+  const reportData = value as ReportDataPayload;
+  if (!Array.isArray(reportData.data?.args)) {
+    return [];
+  }
+
+  return reportData.data.args;
+};
+
+export const parse = (data: JsonObject): void => {
   if (cliConfig.json) {
     drawJSON(data);
     return;
@@ -46,7 +75,8 @@ export const parse = (data: Record<string, any>): void => {
         console.log(`${chalk.yellow.bold(key)} : ${data[key]}`);
       } else {
         console.log(`${chalk.yellow.bold.underline(key)}`);
-        drawTable([data[key]]);
+        const tableRow = toJsonObject(data[key]) ?? {};
+        drawTable([tableRow]);
       }
     } else {
       console.log(`${chalk.yellow.bold(key)} : ${data[key]}`);
@@ -54,17 +84,13 @@ export const parse = (data: Record<string, any>): void => {
   }
 };
 
-export const drawTable = (
-  data: Array<Record<string, any> | null | undefined>,
-): void => {
+export const drawTable = (data: Array<JsonObject | null | undefined>): void => {
   if (data.length == 0) {
     console.log("[]");
     return;
   }
 
-  const rows = data.map((item) =>
-    item && typeof item === "object" && !Array.isArray(item) ? item : {},
-  );
+  const rows = data.map((item): JsonObject => toJsonObject(item) ?? {});
 
   // Create an object with all the keys in it
   const obj = rows.reduce((res, item) => ({ ...res, ...item }), {});
@@ -106,7 +132,7 @@ export const drawTable = (
   });
 
   normalizedData.forEach((row) => {
-    const rowValues: any[] = [];
+    const rowValues: string[] = [];
     for (const key of columns) {
       if (row[key] == null) {
         rowValues.push("-");
@@ -115,7 +141,7 @@ export const drawTable = (
       } else if (typeof row[key] === "object") {
         rowValues.push(JSON.stringify(row[key]));
       } else {
-        rowValues.push(row[key]);
+        rowValues.push(String(row[key]));
       }
     }
     table.push(rowValues);
@@ -123,13 +149,13 @@ export const drawTable = (
   console.log(table.toString());
 };
 
-export const drawJSON = (data: any): void => {
+export const drawJSON = (data: unknown): void => {
   console.log(JSON.stringify(data, null, 2));
 };
 
 export const parseError = (err: Error): void => {
   if (cliConfig.report) {
-    (async () => {
+    void (async () => {
       let appwriteVersion = "unknown";
       const endpoint = globalConfig.getEndpoint();
 
@@ -145,7 +171,8 @@ export const parseError = (err: Error): void => {
       }
 
       const version = SDK_VERSION;
-      const stepsToReproduce = `Running \`${EXECUTABLE_NAME} ${(cliConfig.reportData as any).data.args.join(" ")}\``;
+      const commandArgs = extractReportCommandArgs(cliConfig.reportData);
+      const stepsToReproduce = `Running \`${EXECUTABLE_NAME} ${commandArgs.join(" ")}\``;
       const yourEnvironment = `CLI version: ${version}\nOperation System: ${os.type()}\nAppwrite version: ${appwriteVersion}\nIs Cloud: ${isCloud()}`;
 
       const stack = "```\n" + (err.stack || err.message) + "\n```";
@@ -188,7 +215,9 @@ export const parseError = (err: Error): void => {
   }
 };
 
-export const actionRunner = <T extends (...args: any[]) => Promise<any>>(
+export const actionRunner = <
+  T extends (...args: unknown[]) => Promise<unknown>,
+>(
   fn: T,
 ): ((...args: Parameters<T>) => Promise<void>) => {
   return (...args: Parameters<T>) => {
@@ -200,7 +229,9 @@ export const actionRunner = <T extends (...args: any[]) => Promise<any>>(
       error(`The '--all' and '--id' flags cannot be used together.`);
       process.exit(1);
     }
-    return fn(...args).catch(parseError);
+    return fn(...args)
+      .then(() => undefined)
+      .catch(parseError);
   };
 };