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

package/lib/commands/utils/pools.ts

@@ -0,0 +1,355 @@
+import { getDatabasesService } from "../../services.js";
+import { paginate } from "../../paginate.js";
+import { log } from "../../parser.js";
+
+export class Pools {
+  private STEP_SIZE = 100; // Resources
+  private POLL_DEBOUNCE = 2000; // Milliseconds
+  private pollMaxDebounces = 30;
+  private POLL_DEFAULT_VALUE = 30;
+
+  constructor(pollMaxDebounces?: number) {
+    if (pollMaxDebounces) {
+      this.pollMaxDebounces = pollMaxDebounces;
+    }
+  }
+
+  public setPollMaxDebounces(value: number): void {
+    this.pollMaxDebounces = value;
+  }
+
+  public getPollMaxDebounces(): number {
+    return this.pollMaxDebounces;
+  }
+
+  public wipeAttributes = async (
+    databaseId: string,
+    collectionId: string,
+    iteration: number = 1,
+  ): Promise<boolean> => {
+    if (iteration > this.pollMaxDebounces) {
+      return false;
+    }
+
+    const databasesService = await getDatabasesService();
+    const response = await databasesService.listAttributes(
+      databaseId,
+      collectionId,
+      [JSON.stringify({ method: "limit", values: [1] })],
+    );
+    const { total } = response;
+
+    if (total === 0) {
+      return true;
+    }
+
+    if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
+      let steps = Math.max(1, Math.ceil(total / this.STEP_SIZE));
+      if (steps > 1 && iteration === 1) {
+        this.pollMaxDebounces *= steps;
+
+        log(
+          "Found a large number of attributes, increasing timeout to " +
+            (this.pollMaxDebounces * this.POLL_DEBOUNCE) / 1000 / 60 +
+            " minutes",
+        );
+      }
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, this.POLL_DEBOUNCE));
+
+    return await this.wipeAttributes(databaseId, collectionId, iteration + 1);
+  };
+
+  public wipeIndexes = async (
+    databaseId: string,
+    collectionId: string,
+    iteration: number = 1,
+  ): Promise<boolean> => {
+    if (iteration > this.pollMaxDebounces) {
+      return false;
+    }
+
+    const databasesService = await getDatabasesService();
+    const response = await databasesService.listIndexes(
+      databaseId,
+      collectionId,
+      [JSON.stringify({ method: "limit", values: [1] })],
+    );
+    const { total } = response;
+
+    if (total === 0) {
+      return true;
+    }
+
+    if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
+      let steps = Math.max(1, Math.ceil(total / this.STEP_SIZE));
+      if (steps > 1 && iteration === 1) {
+        this.pollMaxDebounces *= steps;
+
+        log(
+          "Found a large number of indexes, increasing timeout to " +
+            (this.pollMaxDebounces * this.POLL_DEBOUNCE) / 1000 / 60 +
+            " minutes",
+        );
+      }
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, this.POLL_DEBOUNCE));
+
+    return await this.wipeIndexes(databaseId, collectionId, iteration + 1);
+  };
+
+  public waitForAttributeDeletion = async (
+    databaseId: string,
+    collectionId: string,
+    attributeKeys: any[],
+    iteration: number = 1,
+  ): Promise<boolean> => {
+    if (iteration > this.pollMaxDebounces) {
+      return false;
+    }
+
+    if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
+      let steps = Math.max(1, Math.ceil(attributeKeys.length / this.STEP_SIZE));
+      if (steps > 1 && iteration === 1) {
+        this.pollMaxDebounces *= steps;
+
+        log(
+          "Found a large number of attributes to be deleted. Increasing timeout to " +
+            (this.pollMaxDebounces * this.POLL_DEBOUNCE) / 1000 / 60 +
+            " minutes",
+        );
+      }
+    }
+
+    const { attributes } = await paginate(
+      async (args: any) => {
+        const databasesService = await getDatabasesService();
+        return await databasesService.listAttributes({
+          databaseId: args.databaseId,
+          collectionId: args.collectionId,
+          queries: args.queries || [],
+        });
+      },
+      {
+        databaseId,
+        collectionId,
+      },
+      100,
+      "attributes",
+    );
+
+    const ready = attributeKeys.filter((attribute: any) =>
+      attributes.some((a: any) => a.key === attribute.key),
+    );
+
+    if (ready.length === 0) {
+      return true;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, this.POLL_DEBOUNCE));
+
+    return await this.waitForAttributeDeletion(
+      databaseId,
+      collectionId,
+      attributeKeys,
+      iteration + 1,
+    );
+  };
+
+  public expectAttributes = async (
+    databaseId: string,
+    collectionId: string,
+    attributeKeys: string[],
+    iteration: number = 1,
+  ): Promise<boolean> => {
+    if (iteration > this.pollMaxDebounces) {
+      return false;
+    }
+
+    if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
+      let steps = Math.max(1, Math.ceil(attributeKeys.length / this.STEP_SIZE));
+      if (steps > 1 && iteration === 1) {
+        this.pollMaxDebounces *= steps;
+
+        log(
+          "Creating a large number of attributes, increasing timeout to " +
+            (this.pollMaxDebounces * this.POLL_DEBOUNCE) / 1000 / 60 +
+            " minutes",
+        );
+      }
+    }
+
+    const { attributes } = await paginate(
+      async (args: any) => {
+        const databasesService = await getDatabasesService();
+        return await databasesService.listAttributes(
+          args.databaseId,
+          args.collectionId,
+          args.queries || [],
+        );
+      },
+      {
+        databaseId,
+        collectionId,
+      },
+      100,
+      "attributes",
+    );
+
+    const ready = attributes
+      .filter((attribute: any) => {
+        if (attributeKeys.includes(attribute.key)) {
+          if (["stuck", "failed"].includes(attribute.status)) {
+            throw new Error(`Attribute '${attribute.key}' failed!`);
+          }
+
+          return attribute.status === "available";
+        }
+
+        return false;
+      })
+      .map((attribute: any) => attribute.key);
+
+    if (ready.length === attributeKeys.length) {
+      return true;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, this.POLL_DEBOUNCE));
+
+    return await this.expectAttributes(
+      databaseId,
+      collectionId,
+      attributeKeys,
+      iteration + 1,
+    );
+  };
+
+  public deleteIndexes = async (
+    databaseId: string,
+    collectionId: string,
+    indexesKeys: any[],
+    iteration: number = 1,
+  ): Promise<boolean> => {
+    if (iteration > this.pollMaxDebounces) {
+      return false;
+    }
+
+    if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
+      let steps = Math.max(1, Math.ceil(indexesKeys.length / this.STEP_SIZE));
+      if (steps > 1 && iteration === 1) {
+        this.pollMaxDebounces *= steps;
+
+        log(
+          "Found a large number of indexes to be deleted. Increasing timeout to " +
+            (this.pollMaxDebounces * this.POLL_DEBOUNCE) / 1000 / 60 +
+            " minutes",
+        );
+      }
+    }
+
+    const { indexes } = await paginate(
+      async (args: any) => {
+        const databasesService = await getDatabasesService();
+        return await databasesService.listIndexes(
+          args.databaseId,
+          args.collectionId,
+          args.queries || [],
+        );
+      },
+      {
+        databaseId,
+        collectionId,
+      },
+      100,
+      "indexes",
+    );
+
+    const indexKeySet = new Set(indexes.map((i: any) => i.key));
+    const ready = indexesKeys.filter((index: any) =>
+      indexKeySet.has(index.key),
+    );
+
+    if (ready.length === 0) {
+      return true;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, this.POLL_DEBOUNCE));
+
+    return await this.deleteIndexes(
+      databaseId,
+      collectionId,
+      indexesKeys,
+      iteration + 1,
+    );
+  };
+
+  public expectIndexes = async (
+    databaseId: string,
+    collectionId: string,
+    indexKeys: string[],
+    iteration: number = 1,
+  ): Promise<boolean> => {
+    if (iteration > this.pollMaxDebounces) {
+      return false;
+    }
+
+    if (this.pollMaxDebounces === this.POLL_DEFAULT_VALUE) {
+      let steps = Math.max(1, Math.ceil(indexKeys.length / this.STEP_SIZE));
+      if (steps > 1 && iteration === 1) {
+        this.pollMaxDebounces *= steps;
+
+        log(
+          "Creating a large number of indexes, increasing timeout to " +
+            (this.pollMaxDebounces * this.POLL_DEBOUNCE) / 1000 / 60 +
+            " minutes",
+        );
+      }
+    }
+
+    const { indexes } = await paginate(
+      async (args: any) => {
+        const databasesService = await getDatabasesService();
+        return await databasesService.listIndexes(
+          args.databaseId,
+          args.collectionId,
+          args.queries || [],
+        );
+      },
+      {
+        databaseId,
+        collectionId,
+      },
+      100,
+      "indexes",
+    );
+
+    const ready = indexes
+      .filter((index: any) => {
+        if (indexKeys.includes(index.key)) {
+          if (["stuck", "failed"].includes(index.status)) {
+            throw new Error(`Index '${index.key}' failed!`);
+          }
+
+          return index.status === "available";
+        }
+
+        return false;
+      })
+      .map((index: any) => index.key);
+
+    if (ready.length >= indexKeys.length) {
+      return true;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, this.POLL_DEBOUNCE));
+
+    return await this.expectIndexes(
+      databaseId,
+      collectionId,
+      indexKeys,
+      iteration + 1,
+    );
+  };
+}

package/lib/config.ts

@@ -3,22 +3,26 @@ import fs from "fs";
 import _path from "path";
 import process from "process";
 import JSONbig from "json-bigint";
+import type { Models } from "@appwrite.io/console";
 import type {
-  BucketConfig,
-  CollectionConfig,
+  BucketType,
+  CollectionType,
+  FunctionType,
+  ConfigType,
+  SettingsType,
+  SiteType,
+  TableType,
+  TeamType,
+  TopicType,
+} from "./commands/config.js";
+import type {
+  SessionData,
   ConfigData,
   Entity,
-  FunctionConfig,
   GlobalConfigData,
-  ProjectConfigData,
-  ProjectSettings,
-  RawProjectSettings,
-  SessionData,
-  SiteConfig,
-  TableConfig,
-  TeamConfig,
-  TopicConfig,
 } from "./types.js";
+import { createSettingsObject } from "./utils.js";
+import { SDK_TITLE_LOWER } from "./constants.js";
 
 const JSONBigInt = JSONbig({ storeAsString: false });
 
@@ -302,9 +306,9 @@ class Config<T extends ConfigData = ConfigData> {
   }
 }
 
-class Local extends Config<ProjectConfigData> {
-  static CONFIG_FILE_PATH = "appwrite.config.json";
-  static CONFIG_FILE_PATH_LEGACY = "appwrite.json";
+class Local extends Config<ConfigType> {
+  static CONFIG_FILE_PATH = `${SDK_TITLE_LOWER}.config.json`;
+  static CONFIG_FILE_PATH_LEGACY = `${SDK_TITLE_LOWER}.json`;
   configDirectoryPath = "";
 
   constructor(
@@ -347,21 +351,21 @@ class Local extends Config<ProjectConfigData> {
   }
 
   getEndpoint(): string {
-    return (this.get("endpoint" as keyof ProjectConfigData) as string) || "";
+    return this.get("endpoint") || "";
   }
 
   setEndpoint(endpoint: string): void {
-    this.set("endpoint" as any, endpoint);
+    this.set("endpoint", endpoint);
   }
 
-  getSites(): SiteConfig[] {
+  getSites(): SiteType[] {
     if (!this.has("sites")) {
       return [];
     }
     return this.get("sites") ?? [];
   }
 
-  getSite($id: string): SiteConfig | Record<string, never> {
+  getSite($id: string): SiteType | Record<string, never> {
     if (!this.has("sites")) {
       return {};
     }
@@ -376,7 +380,7 @@ class Local extends Config<ProjectConfigData> {
     return {};
   }
 
-  addSite(props: SiteConfig): void {
+  addSite(props: SiteType): void {
     props = whitelistKeys(props, KeysSite, {
       vars: KeysVars,
     });
@@ -401,14 +405,14 @@ class Local extends Config<ProjectConfigData> {
     this.set("sites", sites);
   }
 
-  getFunctions(): FunctionConfig[] {
+  getFunctions(): FunctionType[] {
     if (!this.has("functions")) {
       return [];
     }
     return this.get("functions") ?? [];
   }
 
-  getFunction($id: string): FunctionConfig | Record<string, never> {
+  getFunction($id: string): FunctionType | Record<string, never> {
     if (!this.has("functions")) {
       return {};
     }
@@ -423,7 +427,7 @@ class Local extends Config<ProjectConfigData> {
     return {};
   }
 
-  addFunction(props: FunctionConfig): void {
+  addFunction(props: FunctionType): void {
     props = whitelistKeys(props, KeysFunction, {
       vars: KeysVars,
     });
@@ -448,14 +452,14 @@ class Local extends Config<ProjectConfigData> {
     this.set("functions", functions);
   }
 
-  getCollections(): CollectionConfig[] {
+  getCollections(): CollectionType[] {
     if (!this.has("collections")) {
       return [];
     }
     return this.get("collections") ?? [];
   }
 
-  getCollection($id: string): CollectionConfig | Record<string, never> {
+  getCollection($id: string): CollectionType | Record<string, never> {
     if (!this.has("collections")) {
       return {};
     }
@@ -470,7 +474,7 @@ class Local extends Config<ProjectConfigData> {
     return {};
   }
 
-  addCollection(props: CollectionConfig): void {
+  addCollection(props: CollectionType): void {
     props = whitelistKeys(props, KeysCollection, {
       attributes: KeysAttributes,
       indexes: KeyIndexes,
@@ -495,14 +499,14 @@ class Local extends Config<ProjectConfigData> {
     this.set("collections", collections);
   }
 
-  getTables(): TableConfig[] {
+  getTables(): TableType[] {
     if (!this.has("tables")) {
       return [];
     }
     return this.get("tables") ?? [];
   }
 
-  getTable($id: string): TableConfig | Record<string, never> {
+  getTable($id: string): TableType | Record<string, never> {
     if (!this.has("tables")) {
       return {};
     }
@@ -517,7 +521,7 @@ class Local extends Config<ProjectConfigData> {
     return {};
   }
 
-  addTable(props: TableConfig): void {
+  addTable(props: TableType): void {
     props = whitelistKeys(props, KeysTable, {
       columns: KeysColumns,
       indexes: KeyIndexesColumns,
@@ -542,14 +546,14 @@ class Local extends Config<ProjectConfigData> {
     this.set("tables", tables);
   }
 
-  getBuckets(): BucketConfig[] {
+  getBuckets(): BucketType[] {
     if (!this.has("buckets")) {
       return [];
     }
     return this.get("buckets") ?? [];
   }
 
-  getBucket($id: string): BucketConfig | Record<string, never> {
+  getBucket($id: string): BucketType | Record<string, never> {
     if (!this.has("buckets")) {
       return {};
     }
@@ -564,7 +568,7 @@ class Local extends Config<ProjectConfigData> {
     return {};
   }
 
-  addBucket(props: BucketConfig): void {
+  addBucket(props: BucketType): void {
     props = whitelistKeys(props, KeysStorage);
 
     if (!this.has("buckets")) {
@@ -583,14 +587,14 @@ class Local extends Config<ProjectConfigData> {
     this.set("buckets", buckets);
   }
 
-  getMessagingTopics(): TopicConfig[] {
+  getMessagingTopics(): TopicType[] {
     if (!this.has("topics")) {
       return [];
     }
     return this.get("topics") ?? [];
   }
 
-  getMessagingTopic($id: string): TopicConfig | Record<string, never> {
+  getMessagingTopic($id: string): TopicType | Record<string, never> {
     if (!this.has("topics")) {
       return {};
     }
@@ -605,7 +609,7 @@ class Local extends Config<ProjectConfigData> {
     return {};
   }
 
-  addMessagingTopic(props: TopicConfig): void {
+  addMessagingTopic(props: TopicType): void {
     props = whitelistKeys(props, KeysTopics);
 
     if (!this.has("topics")) {
@@ -648,14 +652,14 @@ class Local extends Config<ProjectConfigData> {
     this._addDBEntity("databases", props, KeysDatabase);
   }
 
-  getTeams(): TeamConfig[] {
+  getTeams(): TeamType[] {
     if (!this.has("teams")) {
       return [];
     }
     return this.get("teams") ?? [];
   }
 
-  getTeam($id: string): TeamConfig | Record<string, never> {
+  getTeam($id: string): TeamType | Record<string, never> {
     if (!this.has("teams")) {
       return {};
     }
@@ -670,7 +674,7 @@ class Local extends Config<ProjectConfigData> {
     return {};
   }
 
-  addTeam(props: TeamConfig): void {
+  addTeam(props: TeamType): void {
     props = whitelistKeys(props, KeysTeams);
     if (!this.has("teams")) {
       this.set("teams", []);
@@ -691,7 +695,7 @@ class Local extends Config<ProjectConfigData> {
   getProject(): {
     projectId?: string;
     projectName?: string;
-    projectSettings?: ProjectSettings;
+    projectSettings?: SettingsType;
   } {
     if (!this.has("projectId")) {
       return {};
@@ -707,7 +711,7 @@ class Local extends Config<ProjectConfigData> {
   setProject(
     projectId: string,
     projectName: string = "",
-    projectSettings?: RawProjectSettings,
+    project?: Models.Project,
   ): void {
     this.set("projectId", projectId);
 
@@ -715,56 +719,16 @@ class Local extends Config<ProjectConfigData> {
       this.set("projectName", projectName);
     }
 
-    if (projectSettings === undefined) {
+    if (project === undefined) {
       return;
     }
 
-    this.set("settings", this.createSettingsObject(projectSettings));
-  }
-
-  createSettingsObject(projectSettings: RawProjectSettings): ProjectSettings {
-    return {
-      services: {
-        account: projectSettings.serviceStatusForAccount,
-        avatars: projectSettings.serviceStatusForAvatars,
-        databases: projectSettings.serviceStatusForDatabases,
-        locale: projectSettings.serviceStatusForLocale,
-        health: projectSettings.serviceStatusForHealth,
-        storage: projectSettings.serviceStatusForStorage,
-        teams: projectSettings.serviceStatusForTeams,
-        users: projectSettings.serviceStatusForUsers,
-        sites: projectSettings.serviceStatusForSites,
-        functions: projectSettings.serviceStatusForFunctions,
-        graphql: projectSettings.serviceStatusForGraphql,
-        messaging: projectSettings.serviceStatusForMessaging,
-      },
-      auth: {
-        methods: {
-          jwt: projectSettings.authJWT,
-          phone: projectSettings.authPhone,
-          invites: projectSettings.authInvites,
-          anonymous: projectSettings.authAnonymous,
-          "email-otp": projectSettings.authEmailOtp,
-          "magic-url": projectSettings.authUsersAuthMagicURL,
-          "email-password": projectSettings.authEmailPassword,
-        },
-        security: {
-          duration: projectSettings.authDuration,
-          limit: projectSettings.authLimit,
-          sessionsLimit: projectSettings.authSessionsLimit,
-          passwordHistory: projectSettings.authPasswordHistory,
-          passwordDictionary: projectSettings.authPasswordDictionary,
-          personalDataCheck: projectSettings.authPersonalDataCheck,
-          sessionAlerts: projectSettings.authSessionAlerts,
-          mockNumbers: projectSettings.authMockNumbers,
-        },
-      },
-    };
+    this.set("settings", createSettingsObject(project));
   }
 }
 
 class Global extends Config<GlobalConfigData> {
-  static CONFIG_FILE_PATH = ".appwrite/prefs.json";
+  static CONFIG_FILE_PATH = `.${SDK_TITLE_LOWER}/prefs.json`;
 
   static PREFERENCE_CURRENT = "current" as const;
   static PREFERENCE_ENDPOINT = "endpoint" as const;

package/lib/constants.ts

@@ -0,0 +1,22 @@
+// SDK
+export const SDK_TITLE = 'Appwrite';
+export const SDK_TITLE_LOWER = 'appwrite';
+export const SDK_VERSION = '13.0.0-rc.3';
+export const SDK_NAME = 'Command Line';
+export const SDK_PLATFORM = 'console';
+export const SDK_LANGUAGE = 'cli';
+export const SDK_LOGO = "\n    _                            _ _           ___   __   _____\n   \/_\\  _ __  _ ____      ___ __(_) |_ ___    \/ __\\ \/ \/   \\_   \\\n  \/\/_\\\\| '_ \\| '_ \\ \\ \/\\ \/ \/ '__| | __\/ _ \\  \/ \/   \/ \/     \/ \/\\\/\n \/  _  \\ |_) | |_) \\ V  V \/| |  | | ||  __\/ \/ \/___\/ \/___\/\\\/ \/_\n \\_\/ \\_\/ .__\/| .__\/ \\_\/\\_\/ |_|  |_|\\__\\___| \\____\/\\____\/\\____\/\n       |_|   |_|\n\n";
+
+// CLI
+export const EXECUTABLE_NAME = 'appwrite';
+
+// NPM
+export const NPM_PACKAGE_NAME = 'appwrite-cli';
+export const NPM_REGISTRY_URL = `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
+
+// GitHub
+export const GITHUB_REPO = 'appwrite/appwrite-cli';
+export const GITHUB_RELEASES_URL = `https://github.com/${GITHUB_REPO}/releases`;
+
+// API
+export const DEFAULT_ENDPOINT = 'https://cloud.appwrite.io/v1';