appwrite-utils-cli 1.4.1 → 1.5.0

package/dist/utilsController.js

@@ -7,12 +7,14 @@ import { ImportController } from "./migrations/importController.js";
 import { ImportDataActions } from "./migrations/importDataActions.js";
 import { setupMigrationDatabase, ensureDatabasesExist, wipeOtherDatabases, ensureCollectionsExist, } from "./databases/setup.js";
 import { createOrUpdateCollections, wipeDatabase, generateSchemas, fetchAllCollections, wipeCollection, } from "./collections/methods.js";
+import { wipeAllTables, wipeTableRows } from "./collections/methods.js";
 import { backupDatabase, ensureDatabaseConfigBucketsExist, initOrGetBackupStorage, wipeDocumentStorage, } from "./storage/methods.js";
 import path from "path";
 import { converterFunctions, validationRules, } from "appwrite-utils";
 import { afterImportActions } from "./migrations/afterImportActions.js";
 import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote, } from "./migrations/transfer.js";
 import { getClient } from "./utils/getClientFromConfig.js";
+import { getAdapterFromConfig } from "./utils/getClientFromConfig.js";
 import { fetchAllDatabases } from "./databases/methods.js";
 import { listFunctions, updateFunctionSpecifications, } from "./functions/methods.js";
 import chalk from "chalk";
@@ -291,9 +293,20 @@ export class UtilsController {
     }
     async wipeDatabase(database, wipeBucket = false) {
         await this.init();
-        if (!this.database)
+        if (!this.database || !this.config)
             throw new Error("Database not initialized");
-        await wipeDatabase(this.database, database.$id);
+        try {
+            const { adapter, apiMode } = await getAdapterFromConfig(this.config);
+            if (apiMode === 'tablesdb') {
+                await wipeAllTables(adapter, database.$id);
+            }
+            else {
+                await wipeDatabase(this.database, database.$id);
+            }
+        }
+        catch {
+            await wipeDatabase(this.database, database.$id);
+        }
         if (wipeBucket) {
             await this.wipeBucketFromDatabase(database);
         }
@@ -323,9 +336,20 @@ export class UtilsController {
     }
     async wipeCollection(database, collection) {
         await this.init();
-        if (!this.database)
+        if (!this.database || !this.config)
             throw new Error("Database not initialized");
-        await wipeCollection(this.database, database.$id, collection.$id);
+        try {
+            const { adapter, apiMode } = await getAdapterFromConfig(this.config);
+            if (apiMode === 'tablesdb') {
+                await wipeTableRows(adapter, database.$id, collection.$id);
+            }
+            else {
+                await wipeCollection(this.database, database.$id, collection.$id);
+            }
+        }
+        catch {
+            await wipeCollection(this.database, database.$id, collection.$id);
+        }
     }
     async wipeDocumentStorage(bucketId) {
         await this.init();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/adapters/TablesDBAdapter.ts

@@ -246,12 +246,13 @@ export class TablesDBAdapter extends BaseAdapter {
   }
   
   // Attribute Operations
-  async createAttribute(params: CreateAttributeParams): Promise<ApiResponse> {
-    try {
-      // TablesDB may have different method names for attribute operations
-      const result = await this.tablesDB.createAttribute(params);
-      return { data: result };
-    } catch (error) {
+  async createAttribute(params: CreateAttributeParams): Promise<ApiResponse> {
+    try {
+      // Prefer createColumn if available, fallback to createAttribute
+      const fn = this.tablesDB.createColumn || this.tablesDB.createAttribute;
+      const result = await fn.call(this.tablesDB, params);
+      return { data: result };
+    } catch (error) {
       throw new AdapterError(
         `Failed to create attribute: ${error instanceof Error ? error.message : 'Unknown error'}`,
         'CREATE_ATTRIBUTE_FAILED',
@@ -260,11 +261,12 @@ export class TablesDBAdapter extends BaseAdapter {
     }
   }
   
-  async updateAttribute(params: UpdateAttributeParams): Promise<ApiResponse> {
-    try {
-      const result = await this.tablesDB.updateAttribute(params);
-      return { data: result };
-    } catch (error) {
+  async updateAttribute(params: UpdateAttributeParams): Promise<ApiResponse> {
+    try {
+      const fn = this.tablesDB.updateColumn || this.tablesDB.updateAttribute;
+      const result = await fn.call(this.tablesDB, params);
+      return { data: result };
+    } catch (error) {
       throw new AdapterError(
         `Failed to update attribute: ${error instanceof Error ? error.message : 'Unknown error'}`,
         'UPDATE_ATTRIBUTE_FAILED',
@@ -273,11 +275,12 @@ export class TablesDBAdapter extends BaseAdapter {
     }
   }
   
-  async deleteAttribute(params: DeleteAttributeParams): Promise<ApiResponse> {
-    try {
-      const result = await this.tablesDB.deleteAttribute(params);
-      return { data: result };
-    } catch (error) {
+  async deleteAttribute(params: DeleteAttributeParams): Promise<ApiResponse> {
+    try {
+      const fn = this.tablesDB.deleteColumn || this.tablesDB.deleteAttribute;
+      const result = await fn.call(this.tablesDB, params);
+      return { data: result };
+    } catch (error) {
       throw new AdapterError(
         `Failed to delete attribute: ${error instanceof Error ? error.message : 'Unknown error'}`,
         'DELETE_ATTRIBUTE_FAILED',
@@ -426,4 +429,4 @@ export class TablesDBAdapter extends BaseAdapter {
       );
     }
   }
-}
+}

package/src/collections/attributes.ts

@@ -287,14 +287,14 @@ const attributesSame = (
 /**
  * Enhanced attribute creation with proper status monitoring and retry logic
  */
-export const createOrUpdateAttributeWithStatusCheck = async (
-  db: Databases,
-  dbId: string,
-  collection: Models.Collection,
-  attribute: Attribute,
-  retryCount: number = 0,
-  maxRetries: number = 5
-): Promise<boolean> => {
+export const createOrUpdateAttributeWithStatusCheck = async (
+  db: Databases,
+  dbId: string,
+  collection: Models.Collection,
+  attribute: Attribute,
+  retryCount: number = 0,
+  maxRetries: number = 5
+): Promise<boolean> => {
   console.log(
     chalk.blue(
       `Creating/updating attribute '${attribute.key}' (attempt ${
@@ -303,20 +303,31 @@ export const createOrUpdateAttributeWithStatusCheck = async (
     )
   );
 
-  try {
-    // First, try to create/update the attribute using existing logic
-    await createOrUpdateAttribute(db, dbId, collection, attribute);
-
-    // Now wait for the attribute to become available
-    const success = await waitForAttributeAvailable(
-      db,
-      dbId,
-      collection.$id,
-      attribute.key,
-      60000, // 1 minute timeout
-      retryCount,
-      maxRetries
-    );
+  try {
+    // First, try to create/update the attribute using existing logic
+    const result = await createOrUpdateAttribute(db, dbId, collection, attribute);
+
+    // If the attribute was queued (relationship dependency unresolved),
+    // skip status polling and retry logic — the queue will handle it later.
+    if (result === "queued") {
+      console.log(
+        chalk.yellow(
+          `⏭️  Deferred relationship attribute '${attribute.key}' — queued for later once dependencies are available`
+        )
+      );
+      return true;
+    }
+
+    // Now wait for the attribute to become available
+    const success = await waitForAttributeAvailable(
+      db,
+      dbId,
+      collection.$id,
+      attribute.key,
+      60000, // 1 minute timeout
+      retryCount,
+      maxRetries
+    );
 
     if (success) {
       return true;
@@ -440,12 +451,12 @@ export const createOrUpdateAttributeWithStatusCheck = async (
   }
 };
 
-export const createOrUpdateAttribute = async (
-  db: Databases,
-  dbId: string,
-  collection: Models.Collection,
-  attribute: Attribute
-): Promise<void> => {
+export const createOrUpdateAttribute = async (
+  db: Databases,
+  dbId: string,
+  collection: Models.Collection,
+  attribute: Attribute
+): Promise<"queued" | "processed"> => {
   let action = "create";
   let foundAttribute: Attribute | undefined;
   const updateEnabled = true;
@@ -460,13 +471,13 @@ export const createOrUpdateAttribute = async (
     foundAttribute = undefined;
   }
 
-  if (
-    foundAttribute &&
-    attributesSame(foundAttribute, attribute) &&
-    updateEnabled
-  ) {
-    // No need to do anything, they are the same
-    return;
+  if (
+    foundAttribute &&
+    attributesSame(foundAttribute, attribute) &&
+    updateEnabled
+  ) {
+    // No need to do anything, they are the same
+    return "processed";
   } else if (
     foundAttribute &&
     !attributesSame(foundAttribute, attribute) &&
@@ -484,71 +495,82 @@ export const createOrUpdateAttribute = async (
     !updateEnabled &&
     foundAttribute &&
     !attributesSame(foundAttribute, attribute)
-  ) {
-    await db.deleteAttribute(dbId, collection.$id, attribute.key);
-    console.log(
-      `Deleted attribute: ${attribute.key} to recreate it because they diff (update disabled temporarily)`
-    );
-    return;
-  }
+  ) {
+    await db.deleteAttribute(dbId, collection.$id, attribute.key);
+    console.log(
+      `Deleted attribute: ${attribute.key} to recreate it because they diff (update disabled temporarily)`
+    );
+    return "processed";
+  }
 
   // console.log(`${action}-ing attribute: ${finalAttribute.key}`);
 
   // Relationship attribute logic with adjustments
   let collectionFoundViaRelatedCollection: Models.Collection | undefined;
   let relatedCollectionId: string | undefined;
-  if (
-    finalAttribute.type === "relationship" &&
-    finalAttribute.relatedCollection
-  ) {
-    if (nameToIdMapping.has(finalAttribute.relatedCollection)) {
-      relatedCollectionId = nameToIdMapping.get(
-        finalAttribute.relatedCollection
-      );
-      try {
-        collectionFoundViaRelatedCollection = await db.getCollection(
-          dbId,
-          relatedCollectionId!
-        );
-      } catch (e) {
-        // console.log(
-        //   `Collection not found: ${finalAttribute.relatedCollection} when nameToIdMapping was set`
-        // );
-        collectionFoundViaRelatedCollection = undefined;
-      }
-    } else {
-      const collectionsPulled = await db.listCollections(dbId, [
-        Query.equal("name", finalAttribute.relatedCollection),
-      ]);
-      if (collectionsPulled.total > 0) {
-        collectionFoundViaRelatedCollection = collectionsPulled.collections[0];
-        relatedCollectionId = collectionFoundViaRelatedCollection.$id;
-        nameToIdMapping.set(
-          finalAttribute.relatedCollection,
-          relatedCollectionId
-        );
-      }
-    }
-    // ONLY queue relationship attributes that have actual unresolved dependencies
-    if (!(relatedCollectionId && collectionFoundViaRelatedCollection)) {
-      console.log(
-        chalk.yellow(
-          `⏳ Queueing relationship attribute '${finalAttribute.key}' - related collection '${finalAttribute.relatedCollection}' not found yet`
-        )
-      );
-      enqueueOperation({
-        type: "attribute",
-        collectionId: collection.$id,
-        collection: collection,
-        attribute,
-        dependencies: [finalAttribute.relatedCollection],
-      });
-      return;
-    }
-  }
-  finalAttribute = parseAttribute(finalAttribute);
-  // console.log(`Final Attribute: ${JSON.stringify(finalAttribute)}`);
-  switch (finalAttribute.type) {
+  if (
+    finalAttribute.type === "relationship" &&
+    finalAttribute.relatedCollection
+  ) {
+    // First try treating relatedCollection as an ID directly
+    try {
+      const byIdCollection = await db.getCollection(dbId, finalAttribute.relatedCollection);
+      collectionFoundViaRelatedCollection = byIdCollection;
+      relatedCollectionId = byIdCollection.$id;
+      // Cache by name for subsequent lookups
+      nameToIdMapping.set(byIdCollection.name, byIdCollection.$id);
+    } catch (_) {
+      // Not an ID or not found — fall back to name-based resolution below
+    }
+
+    if (!collectionFoundViaRelatedCollection && nameToIdMapping.has(finalAttribute.relatedCollection)) {
+      relatedCollectionId = nameToIdMapping.get(
+        finalAttribute.relatedCollection
+      );
+      try {
+        collectionFoundViaRelatedCollection = await db.getCollection(
+          dbId,
+          relatedCollectionId!
+        );
+      } catch (e) {
+        // console.log(
+        //   `Collection not found: ${finalAttribute.relatedCollection} when nameToIdMapping was set`
+        // );
+        collectionFoundViaRelatedCollection = undefined;
+      }
+    } else if (!collectionFoundViaRelatedCollection) {
+      const collectionsPulled = await db.listCollections(dbId, [
+        Query.equal("name", finalAttribute.relatedCollection),
+      ]);
+      if (collectionsPulled.total > 0) {
+        collectionFoundViaRelatedCollection = collectionsPulled.collections[0];
+        relatedCollectionId = collectionFoundViaRelatedCollection.$id;
+        nameToIdMapping.set(
+          finalAttribute.relatedCollection,
+          relatedCollectionId
+        );
+      }
+    }
+    // ONLY queue relationship attributes that have actual unresolved dependencies
+    if (!(relatedCollectionId && collectionFoundViaRelatedCollection)) {
+      console.log(
+        chalk.yellow(
+          `⏳ Queueing relationship attribute '${finalAttribute.key}' - related collection '${finalAttribute.relatedCollection}' not found yet`
+        )
+      );
+      enqueueOperation({
+        type: "attribute",
+        collectionId: collection.$id,
+        collection: collection,
+        attribute,
+        dependencies: [finalAttribute.relatedCollection],
+      });
+      return "queued";
+    }
+  }
+  finalAttribute = parseAttribute(finalAttribute);
+  // console.log(`Final Attribute: ${JSON.stringify(finalAttribute)}`);
+  switch (finalAttribute.type) {
     case "string":
       if (action === "create") {
         await tryAwaitWithRetry(
@@ -910,11 +932,12 @@ export const createOrUpdateAttribute = async (
         );
       }
       break;
-    default:
-      console.error("Invalid attribute type");
-      break;
-  }
-};
+    default:
+      console.error("Invalid attribute type");
+      break;
+  }
+  return "processed";
+};
 
 /**
  * Enhanced collection attribute creation with proper status monitoring

package/src/collections/indexes.ts

@@ -1,5 +1,6 @@
-import { indexSchema, type Index } from "appwrite-utils";
-import { Databases, IndexType, Query, type Models } from "node-appwrite";
+import { indexSchema, type Index } from "appwrite-utils";
+import { Databases, IndexType, Query, type Models } from "node-appwrite";
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
 import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import chalk from "chalk";
 
@@ -18,15 +19,15 @@ interface IndexWithStatus {
 /**
  * Wait for index to become available, with retry logic for stuck indexes and exponential backoff
  */
-const waitForIndexAvailable = async (
-  db: Databases,
-  dbId: string,
-  collectionId: string,
-  indexKey: string,
-  maxWaitTime: number = 60000, // 1 minute
-  retryCount: number = 0,
-  maxRetries: number = 5
-): Promise<boolean> => {
+const waitForIndexAvailable = async (
+  db: Databases | DatabaseAdapter,
+  dbId: string,
+  collectionId: string,
+  indexKey: string,
+  maxWaitTime: number = 60000, // 1 minute
+  retryCount: number = 0,
+  maxRetries: number = 5
+): Promise<boolean> => {
   const startTime = Date.now();
   let checkInterval = 2000; // Start with 2 seconds
   
@@ -41,22 +42,29 @@ const waitForIndexAvailable = async (
   
   while (Date.now() - startTime < maxWaitTime) {
     try {
-      const indexList = await db.listIndexes(dbId, collectionId);
-      const index = indexList.indexes.find(
-        (idx: any) => idx.key === indexKey
-      ) as IndexWithStatus | undefined;
+      const indexList = await (db instanceof Databases
+        ? db.listIndexes(dbId, collectionId)
+        : (db as DatabaseAdapter).listIndexes({ databaseId: dbId, tableId: collectionId }));
+      const indexes: any[] = (db instanceof Databases)
+        ? (indexList as any).indexes
+        : ((indexList as any).data || (indexList as any).indexes || []);
+      const index = indexes.find((idx: any) => idx.key === indexKey) as IndexWithStatus | undefined;
       
       if (!index) {
         console.log(chalk.red(`Index '${indexKey}' not found`));
         return false;
       }
       
-      console.log(chalk.gray(`Index '${indexKey}' status: ${index.status}`));
+      if (db instanceof Databases) {
+        console.log(chalk.gray(`Index '${indexKey}' status: ${(index as any).status}`));
+      } else {
+        console.log(chalk.gray(`Index '${indexKey}' detected (TablesDB)`));
+      }
       
       switch (index.status) {
-        case 'available':
-          console.log(chalk.green(`✅ Index '${indexKey}' is now available`));
-          return true;
+        case 'available':
+          console.log(chalk.green(`✅ Index '${indexKey}' is now available`));
+          return true;
           
         case 'failed':
           console.log(chalk.red(`❌ Index '${indexKey}' failed: ${index.error}`));
@@ -66,9 +74,9 @@ const waitForIndexAvailable = async (
           console.log(chalk.yellow(`⚠️ Index '${indexKey}' is stuck, will retry...`));
           return false;
           
-        case 'processing':
-          // Continue waiting
-          break;
+        case 'processing':
+          // Continue waiting
+          break;
           
         case 'deleting':
           console.log(chalk.yellow(`Index '${indexKey}' is being deleted`));
@@ -79,12 +87,12 @@ const waitForIndexAvailable = async (
           break;
       }
       
-      await delay(checkInterval);
-    } catch (error) {
-      console.log(chalk.red(`Error checking index status: ${error}`));
-      return false;
-    }
-  }
+      await delay(checkInterval);
+    } catch (error) {
+      console.log(chalk.red(`Error checking index status: ${error}`));
+      return false;
+    }
+  }
   
   // Timeout reached
   console.log(chalk.yellow(`⏰ Timeout waiting for index '${indexKey}' (${maxWaitTime}ms)`));