appwrite-cli 13.0.0 → 13.1.0-rc.1

package/lib/commands/push.ts

@@ -17,7 +17,12 @@ import {
   KeysCollection,
   KeysTable,
 } from "../config.js";
-import { ConfigSchema, type SettingsType, type ConfigType } from "./config.js";
+import {
+  ConfigSchema,
+  type SettingsType,
+  type ConfigType,
+  type CollectionType,
+} from "./config.js";
 import { parseWithBetterErrors } from "./utils/error-formatter.js";
 import { createSettingsObject } from "../utils.js";
 import { Spinner, SPINNER_DOTS } from "../spinner.js";
@@ -127,6 +132,20 @@ interface PushTableOptions {
   skipConfirmation?: boolean;
 }
 
+interface PushCollectionInput extends CollectionType {
+  databaseName?: string;
+}
+
+interface PushCollectionState extends PushCollectionInput {
+  remoteVersion?: {
+    name: string;
+    attributes: object[];
+    indexes: object[];
+  };
+  isExisted?: boolean;
+  isNewlyCreated?: boolean;
+}
+
 export class Push {
   private projectClient: Client;
   private consoleClient: Client;
@@ -1414,26 +1433,26 @@ export class Push {
     for (let table of tables) {
       let columns = table.columns;
       let indexes = table.indexes;
+      let hadChanges = false;
 
       if (table.isExisted) {
-        columns = await attributes.attributesToCreate(
+        const columnsResult = await attributes.attributesToCreate(
           table.remoteVersion.columns,
           table.columns,
           table as Collection,
         );
-        indexes = await attributes.attributesToCreate(
+        const indexesResult = await attributes.attributesToCreate(
           table.remoteVersion.indexes,
           table.indexes,
           table as Collection,
           true,
         );
 
-        if (
-          Array.isArray(columns) &&
-          columns.length <= 0 &&
-          Array.isArray(indexes) &&
-          indexes.length <= 0
-        ) {
+        columns = columnsResult.attributes;
+        indexes = indexesResult.attributes;
+        hadChanges = columnsResult.hasChanges || indexesResult.hasChanges;
+
+        if (!hadChanges && columns.length <= 0 && indexes.length <= 0) {
           continue;
         }
       }
@@ -1466,25 +1485,28 @@ export class Push {
   }
 
   public async pushCollections(
-    collections: any[],
+    collections: PushCollectionInput[],
     options: { skipConfirmation?: boolean } = {},
   ): Promise<{
     successfullyPushed: number;
-    errors: any[];
+    errors: Error[];
   }> {
     const { skipConfirmation = false } = options;
     const pools = new Pools(POLL_DEFAULT_VALUE);
-    const attributes = new Attributes(pools, skipConfirmation);
+    const attributesHelper = new Attributes(pools, skipConfirmation);
 
-    const errors: any[] = [];
+    const errors: Error[] = [];
+
+    // Cast to state type since we'll be adding state properties
+    const collectionsWithState = collections as PushCollectionState[];
 
     const databases = Array.from(
-      new Set(collections.map((collection: any) => collection["databaseId"])),
+      new Set(collectionsWithState.map((collection) => collection.databaseId)),
     );
 
     // Parallel db actions
     await Promise.all(
-      databases.map(async (databaseId: any) => {
+      databases.map(async (databaseId) => {
         const databasesService = await getDatabasesService(this.projectClient);
         try {
           const database = await databasesService.get(databaseId);
@@ -1492,7 +1514,7 @@ export class Push {
           // Note: We can't get the local database name here since we don't have access to localConfig
           // This will need to be handled by the caller if needed
           const localDatabaseName =
-            collections.find((c: any) => c.databaseId === databaseId)
+            collectionsWithState.find((c) => c.databaseId === databaseId)
               ?.databaseName ?? databaseId;
 
           if (database.name !== localDatabaseName) {
@@ -1500,12 +1522,12 @@ export class Push {
 
             this.success(`Updated ${localDatabaseName} ( ${databaseId} ) name`);
           }
-        } catch (err: any) {
-          if (Number(err.code) === 404) {
+        } catch (err: unknown) {
+          if (err instanceof AppwriteException && Number(err.code) === 404) {
             this.log(`Database ${databaseId} not found. Creating it now ...`);
 
             const localDatabaseName =
-              collections.find((c: any) => c.databaseId === databaseId)
+              collectionsWithState.find((c) => c.databaseId === databaseId)
                 ?.databaseName ?? databaseId;
 
             await databasesService.create(databaseId, localDatabaseName);
@@ -1518,32 +1540,32 @@ export class Push {
 
     // Parallel collection actions
     await Promise.all(
-      collections.map(async (collection: any) => {
+      collectionsWithState.map(async (collection) => {
         try {
           const databasesService = await getDatabasesService(
             this.projectClient,
           );
           const remoteCollection = await databasesService.getCollection(
-            collection["databaseId"],
-            collection["$id"],
+            collection.databaseId,
+            collection.$id,
           );
 
           if (remoteCollection.name !== collection.name) {
-            await databasesService.updateCollection(
-              collection["databaseId"],
-              collection["$id"],
-              collection.name,
-            );
+            await databasesService.updateCollection({
+              databaseId: collection.databaseId,
+              collectionId: collection.$id,
+              name: collection.name,
+            });
 
             this.success(
-              `Updated ${collection.name} ( ${collection["$id"]} ) name`,
+              `Updated ${collection.name} ( ${collection.$id} ) name`,
             );
           }
           collection.remoteVersion = remoteCollection;
 
           collection.isExisted = true;
-        } catch (e: any) {
-          if (Number(e.code) === 404) {
+        } catch (e: unknown) {
+          if (e instanceof AppwriteException && Number(e.code) === 404) {
             this.log(
               `Collection ${collection.name} does not exist in the project. Creating ... `,
             );
@@ -1551,14 +1573,19 @@ export class Push {
               this.projectClient,
             );
             await databasesService.createCollection({
-              databaseId: collection["databaseId"],
-              collectionId: collection["$id"],
+              databaseId: collection.databaseId,
+              collectionId: collection.$id,
               name: collection.name,
               documentSecurity: collection.documentSecurity,
-              permissions: collection["$permissions"],
+              permissions: collection.$permissions,
+              attributes: collection.attributes,
+              indexes: collection.indexes,
             });
+            collection.isNewlyCreated = true;
           } else {
-            errors.push(e);
+            if (e instanceof Error) {
+              errors.push(e);
+            }
             throw e;
           }
         }
@@ -1567,56 +1594,72 @@ export class Push {
 
     let numberOfCollections = 0;
     // Serialize attribute actions
-    for (let collection of collections) {
-      let collectionAttributes = collection.attributes;
-      let indexes = collection.indexes;
-
-      if (collection.isExisted) {
-        collectionAttributes = await attributes.attributesToCreate(
-          collection.remoteVersion.attributes,
-          collection.attributes,
-          collection as Collection,
+    for (const collection of collectionsWithState) {
+      // Skip newly created collections - their attributes and indexes were already created
+      if (collection.isNewlyCreated) {
+        numberOfCollections++;
+        this.success(
+          `Successfully pushed ${collection.name} ( ${collection.$id} )`,
         );
-        indexes = await attributes.attributesToCreate(
-          collection.remoteVersion.indexes,
-          collection.indexes,
+        continue;
+      }
+
+      if (!collection.isExisted) {
+        continue;
+      }
+
+      const collectionAttributesResult =
+        await attributesHelper.attributesToCreate(
+          collection.remoteVersion!.attributes,
+          collection.attributes ?? [],
           collection as Collection,
-          true,
         );
+      const indexesResult = await attributesHelper.attributesToCreate(
+        collection.remoteVersion!.indexes,
+        collection.indexes ?? [],
+        collection as Collection,
+        true,
+      );
 
-        if (
-          Array.isArray(collectionAttributes) &&
-          collectionAttributes.length <= 0 &&
-          Array.isArray(indexes) &&
-          indexes.length <= 0
-        ) {
-          continue;
-        }
+      const collectionAttributes = collectionAttributesResult.attributes;
+      const indexes = indexesResult.attributes;
+
+      if (
+        collectionAttributes.length <= 0 &&
+        indexes.length <= 0 &&
+        !collectionAttributesResult.hasChanges &&
+        !indexesResult.hasChanges
+      ) {
+        continue;
       }
 
       this.log(
-        `Pushing collection ${collection.name} ( ${collection["databaseId"]} - ${collection["$id"]} ) attributes`,
+        `Pushing collection ${collection.name} ( ${collection.databaseId} - ${collection.$id} ) attributes`,
       );
 
       try {
-        await attributes.createAttributes(
+        await attributesHelper.createAttributes(
           collectionAttributes,
           collection as Collection,
         );
       } catch (e) {
-        errors.push(e);
+        if (e instanceof Error) {
+          errors.push(e);
+        }
         throw e;
       }
 
       try {
-        await attributes.createIndexes(indexes, collection as Collection);
+        await attributesHelper.createIndexes(indexes, collection as Collection);
       } catch (e) {
-        errors.push(e);
+        if (e instanceof Error) {
+          errors.push(e);
+        }
         throw e;
       }
       numberOfCollections++;
       this.success(
-        `Successfully pushed ${collection.name} ( ${collection["$id"]} )`,
+        `Successfully pushed ${collection.name} ( ${collection.$id} )`,
       );
     }
 
@@ -2193,7 +2236,7 @@ const pushTable = async ({
   const { successfullyPushed, errors } = result;
 
   if (successfullyPushed === 0) {
-    error("No tables were pushed.");
+    warn("No tables were pushed.");
   } else {
     success(`Successfully pushed ${successfullyPushed} tables.`);
   }

package/lib/commands/schema.ts

@@ -7,7 +7,7 @@ import { parseWithBetterErrors } from "./utils/error-formatter.js";
 import JSONbig from "json-bigint";
 import * as fs from "fs";
 import * as path from "path";
-import { Db } from "./db.js";
+import { TypeScriptDatabasesGenerator } from "./generators/typescript/databases.js";
 
 const JSONBig = JSONbig({ useNativeBigInt: true });
 
@@ -17,7 +17,7 @@ export class Schema {
 
   private pullCommandSilent: Pull;
 
-  public db: Db;
+  public db: TypeScriptDatabasesGenerator;
 
   constructor({
     projectClient,
@@ -31,7 +31,7 @@ export class Schema {
 
     this.pullCommandSilent = new Pull(projectClient, consoleClient, true);
 
-    this.db = new Db();
+    this.db = new TypeScriptDatabasesGenerator();
   }
 
   /**

package/lib/commands/services/projects.ts

@@ -42,7 +42,7 @@ export const projects = new Command("projects")
 projects
   .command(`list`)
   .description(`Get a list of all projects. You can use the query params to filter your results. `)
-  .option(`--queries [queries...]`, `Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: name, teamId`)
+  .option(`--queries [queries...]`, `Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: name, teamId, labels, search`)
   .option(`--search <search>`, `Search term to filter your list results. Max length: 256 chars.`)
   .option(
     `--total [value]`,
@@ -429,6 +429,18 @@ projects
     ),
   );
 
+projects
+  .command(`update-labels`)
+  .description(`Update the project labels by its unique ID. Labels can be used to easily filter projects in an organization.`)
+  .requiredOption(`--project-id <project-id>`, `Project unique ID.`)
+  .requiredOption(`--labels [labels...]`, `Array of project labels. Replaces the previous labels. Maximum of 1000 labels are allowed, each up to 36 alphanumeric characters long.`)
+  .action(
+    actionRunner(
+      async ({ projectId, labels }) =>
+        parse(await (await getProjectsClient()).updateLabels(projectId, labels)),
+    ),
+  );
+
 projects
   .command(`update-o-auth-2`)
   .description(`Update the OAuth2 provider configurations. Use this endpoint to set up or update the OAuth2 provider credentials or enable/disable providers. `)

package/lib/commands/services/storage.ts

@@ -71,7 +71,7 @@ storage
   )
   .option(`--maximum-file-size <maximum-file-size>`, `Maximum file size allowed in bytes. Maximum allowed value is 30MB.`, parseInteger)
   .option(`--allowed-file-extensions [allowed-file-extensions...]`, `Allowed file extensions. Maximum of 100 extensions are allowed, each 64 characters long.`)
-  .option(`--compression <compression>`, `Compression algorithm choosen for compression. Can be one of none,  [gzip](https://en.wikipedia.org/wiki/Gzip), or [zstd](https://en.wikipedia.org/wiki/Zstd), For file size above 20MB compression is skipped even if it's enabled`)
+  .option(`--compression <compression>`, `Compression algorithm chosen for compression. Can be one of none,  [gzip](https://en.wikipedia.org/wiki/Gzip), or [zstd](https://en.wikipedia.org/wiki/Zstd), For file size above 20MB compression is skipped even if it's enabled`)
   .option(
     `--encryption [value]`,
     `Is encryption enabled? For file size above 20MB encryption is skipped even if it's enabled`,
@@ -128,7 +128,7 @@ storage
   )
   .option(`--maximum-file-size <maximum-file-size>`, `Maximum file size allowed in bytes. Maximum allowed value is 30MB.`, parseInteger)
   .option(`--allowed-file-extensions [allowed-file-extensions...]`, `Allowed file extensions. Maximum of 100 extensions are allowed, each 64 characters long.`)
-  .option(`--compression <compression>`, `Compression algorithm choosen for compression. Can be one of none, [gzip](https://en.wikipedia.org/wiki/Gzip), or [zstd](https://en.wikipedia.org/wiki/Zstd), For file size above 20MB compression is skipped even if it's enabled`)
+  .option(`--compression <compression>`, `Compression algorithm chosen for compression. Can be one of none, [gzip](https://en.wikipedia.org/wiki/Gzip), or [zstd](https://en.wikipedia.org/wiki/Zstd), For file size above 20MB compression is skipped even if it's enabled`)
   .option(
     `--encryption [value]`,
     `Is encryption enabled? For file size above 20MB encryption is skipped even if it's enabled`,

package/lib/commands/utils/attributes.ts

@@ -480,40 +480,59 @@ export class Attributes {
     );
   };
 
+  /**
+   * Check if attribute is a child-side relationship
+   * Child-side relationships are auto-generated by Appwrite and should be skipped
+   */
+  private isChildSideRelationship = (attribute: any): boolean =>
+    attribute.type === "relationship" && attribute.side === "child";
+
   /**
    * Filter deleted and recreated attributes,
-   * return list of attributes to create
+   * return list of attributes to create and whether any changes were made
    */
   public attributesToCreate = async (
     remoteAttributes: any[],
     localAttributes: any[],
     collection: Collection,
     isIndex: boolean = false,
-  ): Promise<any[]> => {
-    const deleting = remoteAttributes
+  ): Promise<{ attributes: any[]; hasChanges: boolean }> => {
+    // Filter out child-side relationships from both local and remote attributes for comparison
+    // Child-side relationships are auto-generated by Appwrite when creating two-way relationships
+    // from the parent side, so we should not compare or try to create them directly
+    const filteredLocalAttributes = localAttributes.filter(
+      (attr) => !this.isChildSideRelationship(attr),
+    );
+    let filteredRemoteAttributes = remoteAttributes.filter(
+      (attr) => !this.isChildSideRelationship(attr),
+    );
+
+    const deleting = filteredRemoteAttributes
       .filter(
-        (attribute) => !this.attributesContains(attribute, localAttributes),
+        (attribute) =>
+          !this.attributesContains(attribute, filteredLocalAttributes),
       )
       .map((attr) => this.generateChangesObject(attr, collection, false));
-    const adding = localAttributes
+    const adding = filteredLocalAttributes
       .filter(
-        (attribute) => !this.attributesContains(attribute, remoteAttributes),
+        (attribute) =>
+          !this.attributesContains(attribute, filteredRemoteAttributes),
       )
       .map((attr) => this.generateChangesObject(attr, collection, true));
-    const conflicts = remoteAttributes
+    const conflicts = filteredRemoteAttributes
       .map((attribute) =>
         this.checkAttributeChanges(
           attribute,
-          this.attributesContains(attribute, localAttributes),
+          this.attributesContains(attribute, filteredLocalAttributes),
           collection,
         ),
       )
       .filter((attribute) => attribute !== undefined) as AttributeChange[];
-    const changes = remoteAttributes
+    const changes = filteredRemoteAttributes
       .map((attribute) =>
         this.checkAttributeChanges(
           attribute,
-          this.attributesContains(attribute, localAttributes),
+          this.attributesContains(attribute, filteredLocalAttributes),
           collection,
           false,
         ),
@@ -527,7 +546,7 @@ export class Attributes {
     let changedAttributes: any[] = [];
     const changing = [...deleting, ...adding, ...conflicts, ...changes];
     if (changing.length === 0) {
-      return changedAttributes;
+      return { attributes: changedAttributes, hasChanges: false };
     }
 
     log(
@@ -573,7 +592,7 @@ export class Attributes {
       }
 
       if ((await this.getConfirmation()) !== true) {
-        return changedAttributes;
+        return { attributes: changedAttributes, hasChanges: false };
       }
     }
 
@@ -584,7 +603,7 @@ export class Attributes {
           this.deleteAttribute(collection, changed, isIndex),
         ),
       );
-      remoteAttributes = remoteAttributes.filter(
+      filteredRemoteAttributes = filteredRemoteAttributes.filter(
         (attribute) => !this.attributesContains(attribute, changedAttributes),
       );
     }
@@ -631,9 +650,11 @@ export class Attributes {
       }
     }
 
-    return localAttributes.filter(
-      (attribute) => !this.attributesContains(attribute, remoteAttributes),
+    const newAttributes = filteredLocalAttributes.filter(
+      (attribute) =>
+        !this.attributesContains(attribute, filteredRemoteAttributes),
     );
+    return { attributes: newAttributes, hasChanges: true };
   };
 
   public createIndexes = async (
@@ -664,13 +685,17 @@ export class Attributes {
       throw new Error("Index creation timed out.");
     }
 
-    success(`Created ${indexes.length} indexes`);
+    if (indexes.length > 0) {
+      success(`Created ${indexes.length} indexes`);
+    }
   };
 
   public createAttributes = async (
     attributes: any[],
     collection: Collection,
   ): Promise<void> => {
+    log(`Creating attributes ...`);
+
     for (let attribute of attributes) {
       if (attribute.side !== "child") {
         await this.createAttribute(
@@ -694,13 +719,17 @@ export class Attributes {
     }
 
     const createdCount = attributes.filter((a) => a.side !== "child").length;
-    success(`Created ${createdCount} attributes`);
+    if (createdCount > 0) {
+      success(`Created ${createdCount} attributes`);
+    }
   };
 
   public createColumns = async (
     columns: any[],
     table: Collection,
   ): Promise<void> => {
+    log(`Creating columns ...`);
+
     for (let column of columns) {
       if (column.side !== "child") {
         await this.createAttribute(table["databaseId"], table["$id"], column);
@@ -720,6 +749,8 @@ export class Attributes {
     }
 
     const createdCount = columns.filter((c) => c.side !== "child").length;
-    success(`Created ${createdCount} columns`);
+    if (createdCount > 0) {
+      success(`Created ${createdCount} columns`);
+    }
   };
 }

package/lib/commands/utils/pools.ts

@@ -14,14 +14,6 @@ export class Pools {
     }
   }
 
-  public setPollMaxDebounces(value: number): void {
-    this.pollMaxDebounces = value;
-  }
-
-  public getPollMaxDebounces(): number {
-    return this.pollMaxDebounces;
-  }
-
   public wipeAttributes = async (
     databaseId: string,
     collectionId: string,
@@ -226,65 +218,6 @@ export class Pools {
     );
   };
 
-  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,