appwrite-utils-cli 1.7.5 → 1.7.6

package/dist/adapters/LegacyAdapter.js

@@ -6,6 +6,7 @@
  * code can use modern TablesDB patterns while maintaining compatibility with
  * older Appwrite instances.
  */
+import { Query } from "node-appwrite";
 import { BaseAdapter, AdapterError, UnsupportedOperationError } from './DatabaseAdapter.js';
 /**
  * LegacyAdapter - Translates TablesDB calls to legacy Databases API
@@ -308,30 +309,51 @@ export class LegacyAdapter extends BaseAdapter {
         throw new UnsupportedOperationError('bulkUpsertRows', 'legacy');
     }
     async bulkDeleteRows(params) {
-        // Legacy doesn't support bulk operations, fallback to individual deletes
-        const results = [];
-        const errors = [];
-        for (const rowId of params.rowIds) {
-            try {
-                await this.deleteRow({
-                    databaseId: params.databaseId,
-                    tableId: params.tableId,
-                    id: rowId
-                });
-                results.push({ id: rowId, deleted: true });
+        try {
+            // Try to use deleteDocuments with queries first (more efficient)
+            const queries = params.rowIds.map(id => Query.equal('$id', id));
+            const result = await this.databases.deleteDocuments(params.databaseId, params.tableId, // Maps tableId to collectionId
+            queries);
+            return {
+                data: result,
+                total: params.rowIds.length
+            };
+        }
+        catch (error) {
+            // If deleteDocuments with queries fails, fall back to individual deletes
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Check if the error indicates that deleteDocuments with queries is not supported
+            if (errorMessage.includes('not supported') || errorMessage.includes('invalid') || errorMessage.includes('queries')) {
+                // Fall back to individual deletions
+                const results = [];
+                const errors = [];
+                for (const rowId of params.rowIds) {
+                    try {
+                        await this.deleteRow({
+                            databaseId: params.databaseId,
+                            tableId: params.tableId,
+                            id: rowId
+                        });
+                        results.push({ id: rowId, deleted: true });
+                    }
+                    catch (individualError) {
+                        errors.push({
+                            rowId,
+                            error: individualError instanceof Error ? individualError.message : 'Unknown error'
+                        });
+                    }
+                }
+                return {
+                    data: results,
+                    total: results.length,
+                    errors: errors.length > 0 ? errors : undefined
+                };
             }
-            catch (error) {
-                errors.push({
-                    rowId,
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                });
+            else {
+                // Re-throw the original error if it's not a support issue
+                throw new AdapterError(`Failed to bulk delete rows (legacy): ${errorMessage}`, 'BULK_DELETE_ROWS_FAILED', error instanceof Error ? error : undefined);
             }
         }
-        return {
-            data: results,
-            total: results.length,
-            errors: errors.length > 0 ? errors : undefined
-        };
     }
     // Metadata and Capabilities
     getMetadata() {

package/dist/adapters/TablesDBAdapter.js

@@ -5,6 +5,7 @@
  * without any translation layer. It uses object notation parameters
  * and returns Models.Row instead of Models.Document.
  */
+import { Query } from "node-appwrite";
 import { BaseAdapter, AdapterError } from './DatabaseAdapter.js';
 /**
  * TablesDBAdapter implementation for native TablesDB API
@@ -269,7 +270,13 @@ export class TablesDBAdapter extends BaseAdapter {
     }
     async bulkDeleteRows(params) {
         try {
-            const result = await this.tablesDB.bulkDeleteRows(params);
+            // Convert rowIds to queries for the deleteRows API
+            const queries = params.rowIds.map(id => Query.equal('$id', id));
+            const result = await this.tablesDB.deleteRows({
+                databaseId: params.databaseId,
+                tableId: params.tableId,
+                queries: queries
+            });
             return {
                 data: result,
                 total: params.rowIds.length

package/dist/collections/wipeOperations.js

@@ -208,8 +208,8 @@ export const wipeTableRows = async (adapter, databaseId, tableId) => {
             if (adapter.bulkDeleteRows) {
                 try {
                     // Attempt bulk deletion (available in TablesDB)
-                    await tryBulkDeletion(adapter, databaseId, tableId, rowIds, BULK_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS);
-                    totalDeleted += rows.length;
+                    const deletedCount = await tryBulkDeletion(adapter, databaseId, tableId, rowIds, BULK_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS);
+                    totalDeleted += deletedCount;
                     progress.update(totalDeleted);
                 }
                 catch (bulkError) {
@@ -224,15 +224,15 @@ export const wipeTableRows = async (adapter, databaseId, tableId) => {
                     else {
                         MessageFormatter.progress(`Bulk deletion failed (${errorMessage}), falling back to individual deletion for ${rows.length} rows`, { prefix: "Wipe" });
                     }
-                    await tryIndividualDeletion(adapter, databaseId, tableId, rows, INDIVIDUAL_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS, progress, totalDeleted);
-                    totalDeleted += rows.length;
+                    const deletedCount = await tryIndividualDeletion(adapter, databaseId, tableId, rows, INDIVIDUAL_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS, progress, totalDeleted);
+                    totalDeleted += deletedCount;
                 }
             }
             else {
                 // Bulk deletion not available, use optimized individual deletion
                 MessageFormatter.progress(`Using individual deletion for ${rows.length} rows (bulk deletion not available)`, { prefix: "Wipe" });
-                await tryIndividualDeletion(adapter, databaseId, tableId, rows, INDIVIDUAL_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS, progress, totalDeleted);
-                totalDeleted += rows.length;
+                const deletedCount = await tryIndividualDeletion(adapter, databaseId, tableId, rows, INDIVIDUAL_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS, progress, totalDeleted);
+                totalDeleted += deletedCount;
             }
             // Set up cursor for next iteration
             if (rows.length < FETCH_BATCH_SIZE) {
@@ -268,9 +268,11 @@ async function tryBulkDeletion(adapter, databaseId, tableId, rowIds, batchSize,
     }
     const limit = pLimit(maxConcurrent);
     const batches = chunk(rowIds, batchSize);
+    let successfullyDeleted = 0;
     const deletePromises = batches.map((batch) => limit(async () => {
         try {
-            await tryAwaitWithRetry(async () => adapter.bulkDeleteRows({ databaseId, tableId, rowIds: batch }));
+            const result = await tryAwaitWithRetry(async () => adapter.bulkDeleteRows({ databaseId, tableId, rowIds: batch }));
+            successfullyDeleted += batch.length; // Assume success if no error thrown
         }
         catch (error) {
             const errorMessage = error.message || String(error);
@@ -286,6 +288,7 @@ async function tryBulkDeletion(adapter, databaseId, tableId, rowIds, batchSize,
         }
     }));
     await Promise.all(deletePromises);
+    return successfullyDeleted;
 }
 /**
  * Helper function for fallback individual deletion
@@ -294,16 +297,19 @@ async function tryIndividualDeletion(adapter, databaseId, tableId, rows, batchSi
     const limit = pLimit(maxConcurrent);
     const batches = chunk(rows, batchSize);
     let processedInBatch = 0;
+    let successfullyDeleted = 0;
     const deletePromises = batches.map((batch) => limit(async () => {
         const batchDeletePromises = batch.map(async (row) => {
             try {
                 await tryAwaitWithRetry(async () => adapter.deleteRow({ databaseId, tableId, id: row.$id }));
+                successfullyDeleted++;
             }
             catch (error) {
                 const errorMessage = error.message || String(error);
                 // Enhanced error handling for row deletion
                 if (errorMessage.includes("Row with the requested ID could not be found")) {
-                    // Row already deleted, skip silently
+                    // Row already deleted, count as success since it's gone
+                    successfullyDeleted++;
                 }
                 else if (isCriticalError(errorMessage)) {
                     // Critical error, log and rethrow to stop operation
@@ -320,9 +326,10 @@ async function tryIndividualDeletion(adapter, databaseId, tableId, rows, batchSi
                 }
             }
             processedInBatch++;
-            progress.update(baseDeleted + processedInBatch);
+            progress.update(baseDeleted + successfullyDeleted);
         });
         await Promise.all(batchDeletePromises);
     }));
     await Promise.all(deletePromises);
+    return successfullyDeleted;
 }

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.7.5",
+  "version": "1.7.6",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/adapters/LegacyAdapter.ts

@@ -7,31 +7,32 @@
  * older Appwrite instances.
  */
 
-import {
-  BaseAdapter,
-  type CreateRowParams,
-  type UpdateRowParams,
-  type ListRowsParams,
-  type DeleteRowParams,
-  type CreateTableParams,
-  type UpdateTableParams,
-  type ListTablesParams,
-  type DeleteTableParams,
-  type GetTableParams,
-  type BulkCreateRowsParams,
-  type BulkUpsertRowsParams,
-  type BulkDeleteRowsParams,
-  type CreateIndexParams,
-  type ListIndexesParams,
-  type DeleteIndexParams,
-  type CreateAttributeParams,
-  type UpdateAttributeParams,
-  type DeleteAttributeParams,
-  type ApiResponse,
-  type AdapterMetadata,
-  AdapterError,
-  UnsupportedOperationError
-} from './DatabaseAdapter.js';
+import { Query } from "node-appwrite";
+import {
+  BaseAdapter,
+  type CreateRowParams,
+  type UpdateRowParams,
+  type ListRowsParams,
+  type DeleteRowParams,
+  type CreateTableParams,
+  type UpdateTableParams,
+  type ListTablesParams,
+  type DeleteTableParams,
+  type GetTableParams,
+  type BulkCreateRowsParams,
+  type BulkUpsertRowsParams,
+  type BulkDeleteRowsParams,
+  type CreateIndexParams,
+  type ListIndexesParams,
+  type DeleteIndexParams,
+  type CreateAttributeParams,
+  type UpdateAttributeParams,
+  type DeleteAttributeParams,
+  type ApiResponse,
+  type AdapterMetadata,
+  AdapterError,
+  UnsupportedOperationError
+} from './DatabaseAdapter.js';
 
 /**
  * LegacyAdapter - Translates TablesDB calls to legacy Databases API
@@ -586,33 +587,62 @@ export class LegacyAdapter extends BaseAdapter {
     throw new UnsupportedOperationError('bulkUpsertRows', 'legacy');
   }
   
-  async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
-    // Legacy doesn't support bulk operations, fallback to individual deletes
-    const results = [];
-    const errors = [];
-    
-    for (const rowId of params.rowIds) {
-      try {
-        await this.deleteRow({
-          databaseId: params.databaseId,
-          tableId: params.tableId,
-          id: rowId
-        });
-        results.push({ id: rowId, deleted: true });
-      } catch (error) {
-        errors.push({ 
-          rowId, 
-          error: error instanceof Error ? error.message : 'Unknown error' 
-        });
-      }
-    }
-    
-    return {
-      data: results,
-      total: results.length,
-      errors: errors.length > 0 ? errors : undefined
-    };
-  }
+async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
+    try {
+      // Try to use deleteDocuments with queries first (more efficient)
+      const queries = params.rowIds.map(id => Query.equal('$id', id));
+      
+      const result = await this.databases.deleteDocuments(
+        params.databaseId,
+        params.tableId, // Maps tableId to collectionId
+        queries
+      );
+      
+      return {
+        data: result,
+        total: params.rowIds.length
+      };
+    } catch (error) {
+      // If deleteDocuments with queries fails, fall back to individual deletes
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      
+      // Check if the error indicates that deleteDocuments with queries is not supported
+      if (errorMessage.includes('not supported') || errorMessage.includes('invalid') || errorMessage.includes('queries')) {
+        // Fall back to individual deletions
+        const results = [];
+        const errors = [];
+        
+        for (const rowId of params.rowIds) {
+          try {
+            await this.deleteRow({
+              databaseId: params.databaseId,
+              tableId: params.tableId,
+              id: rowId
+            });
+            results.push({ id: rowId, deleted: true });
+          } catch (individualError) {
+            errors.push({ 
+              rowId, 
+              error: individualError instanceof Error ? individualError.message : 'Unknown error' 
+            });
+          }
+        }
+        
+        return {
+          data: results,
+          total: results.length,
+          errors: errors.length > 0 ? errors : undefined
+        };
+      } else {
+        // Re-throw the original error if it's not a support issue
+        throw new AdapterError(
+          `Failed to bulk delete rows (legacy): ${errorMessage}`,
+          'BULK_DELETE_ROWS_FAILED',
+          error instanceof Error ? error : undefined
+        );
+      }
+    }
+  }
   
   // Metadata and Capabilities
   

package/src/adapters/TablesDBAdapter.ts

@@ -6,31 +6,32 @@
  * and returns Models.Row instead of Models.Document.
  */
 
-import {
-  BaseAdapter,
-  type DatabaseAdapter,
-  type CreateRowParams,
-  type UpdateRowParams,
-  type ListRowsParams,
-  type DeleteRowParams,
-  type CreateTableParams,
-  type UpdateTableParams,
-  type ListTablesParams,
-  type DeleteTableParams,
-  type GetTableParams,
-  type BulkCreateRowsParams,
-  type BulkUpsertRowsParams,
-  type BulkDeleteRowsParams,
-  type CreateIndexParams,
-  type ListIndexesParams,
-  type DeleteIndexParams,
-  type CreateAttributeParams,
-  type UpdateAttributeParams,
-  type DeleteAttributeParams,
-  type ApiResponse,
-  type AdapterMetadata,
-  AdapterError
-} from './DatabaseAdapter.js';
+import { Query } from "node-appwrite";
+import {
+  BaseAdapter,
+  type DatabaseAdapter,
+  type CreateRowParams,
+  type UpdateRowParams,
+  type ListRowsParams,
+  type DeleteRowParams,
+  type CreateTableParams,
+  type UpdateTableParams,
+  type ListTablesParams,
+  type DeleteTableParams,
+  type GetTableParams,
+  type BulkCreateRowsParams,
+  type BulkUpsertRowsParams,
+  type BulkDeleteRowsParams,
+  type CreateIndexParams,
+  type ListIndexesParams,
+  type DeleteIndexParams,
+  type CreateAttributeParams,
+  type UpdateAttributeParams,
+  type DeleteAttributeParams,
+  type ApiResponse,
+  type AdapterMetadata,
+  AdapterError
+} from './DatabaseAdapter.js';
 
 /**
  * TablesDBAdapter implementation for native TablesDB API
@@ -513,21 +514,27 @@ export class TablesDBAdapter extends BaseAdapter {
     }
   }
   
-  async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
-    try {
-      const result = await this.tablesDB.bulkDeleteRows(params);
-      return {
-        data: result,
-        total: params.rowIds.length
-      };
-    } catch (error) {
-      throw new AdapterError(
-        `Failed to bulk delete rows: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        'BULK_DELETE_ROWS_FAILED',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
+async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
+    try {
+      // Convert rowIds to queries for the deleteRows API
+      const queries = params.rowIds.map(id => Query.equal('$id', id));
+      const result = await this.tablesDB.deleteRows({
+        databaseId: params.databaseId,
+        tableId: params.tableId,
+        queries: queries
+      });
+      return {
+        data: result,
+        total: params.rowIds.length
+      };
+    } catch (error) {
+      throw new AdapterError(
+        `Failed to bulk delete rows: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        'BULK_DELETE_ROWS_FAILED',
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
   
   // Metadata and Capabilities
   getMetadata(): AdapterMetadata {

package/src/collections/wipeOperations.ts

@@ -296,65 +296,65 @@ export const wipeTableRows = async (
       // Try to use bulk deletion first, fall back to individual deletion
       const rowIds = rows.map((row: any) => row.$id);
 
-      // Check if bulk deletion is available and try it first
-      if (adapter.bulkDeleteRows) {
-        try {
-          // Attempt bulk deletion (available in TablesDB)
-          await tryBulkDeletion(adapter, databaseId, tableId, rowIds, BULK_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS);
-          totalDeleted += rows.length;
-          progress.update(totalDeleted);
-        } catch (bulkError) {
-          // Enhanced error handling: categorize the error and decide on fallback strategy
-          const errorMessage = bulkError instanceof Error ? bulkError.message : String(bulkError);
-
-          if (isRetryableError(errorMessage)) {
-            MessageFormatter.progress(
-              `Bulk deletion encountered retryable error, retrying with individual deletion for ${rows.length} rows`,
-              { prefix: "Wipe" }
-            );
-          } else if (isBulkNotSupportedError(errorMessage)) {
-            MessageFormatter.progress(
-              `Bulk deletion not supported by server, switching to individual deletion for ${rows.length} rows`,
-              { prefix: "Wipe" }
-            );
-          } else {
-            MessageFormatter.progress(
-              `Bulk deletion failed (${errorMessage}), falling back to individual deletion for ${rows.length} rows`,
-              { prefix: "Wipe" }
-            );
-          }
-
-          await tryIndividualDeletion(
-            adapter,
-            databaseId,
-            tableId,
-            rows,
-            INDIVIDUAL_DELETE_BATCH_SIZE,
-            MAX_CONCURRENT_OPERATIONS,
-            progress,
-            totalDeleted
-          );
-          totalDeleted += rows.length;
-        }
-      } else {
-        // Bulk deletion not available, use optimized individual deletion
-        MessageFormatter.progress(
-          `Using individual deletion for ${rows.length} rows (bulk deletion not available)`,
-          { prefix: "Wipe" }
-        );
-
-        await tryIndividualDeletion(
-          adapter,
-          databaseId,
-          tableId,
-          rows,
-          INDIVIDUAL_DELETE_BATCH_SIZE,
-          MAX_CONCURRENT_OPERATIONS,
-          progress,
-          totalDeleted
-        );
-        totalDeleted += rows.length;
-      }
+// Check if bulk deletion is available and try it first
+      if (adapter.bulkDeleteRows) {
+        try {
+          // Attempt bulk deletion (available in TablesDB)
+          const deletedCount = await tryBulkDeletion(adapter, databaseId, tableId, rowIds, BULK_DELETE_BATCH_SIZE, MAX_CONCURRENT_OPERATIONS);
+          totalDeleted += deletedCount;
+          progress.update(totalDeleted);
+        } catch (bulkError) {
+          // Enhanced error handling: categorize the error and decide on fallback strategy
+          const errorMessage = bulkError instanceof Error ? bulkError.message : String(bulkError);
+
+          if (isRetryableError(errorMessage)) {
+            MessageFormatter.progress(
+              `Bulk deletion encountered retryable error, retrying with individual deletion for ${rows.length} rows`,
+              { prefix: "Wipe" }
+            );
+          } else if (isBulkNotSupportedError(errorMessage)) {
+            MessageFormatter.progress(
+              `Bulk deletion not supported by server, switching to individual deletion for ${rows.length} rows`,
+              { prefix: "Wipe" }
+            );
+          } else {
+            MessageFormatter.progress(
+              `Bulk deletion failed (${errorMessage}), falling back to individual deletion for ${rows.length} rows`,
+              { prefix: "Wipe" }
+            );
+          }
+
+          const deletedCount = await tryIndividualDeletion(
+            adapter,
+            databaseId,
+            tableId,
+            rows,
+            INDIVIDUAL_DELETE_BATCH_SIZE,
+            MAX_CONCURRENT_OPERATIONS,
+            progress,
+            totalDeleted
+          );
+          totalDeleted += deletedCount;
+        }
+      } else {
+        // Bulk deletion not available, use optimized individual deletion
+        MessageFormatter.progress(
+          `Using individual deletion for ${rows.length} rows (bulk deletion not available)`,
+          { prefix: "Wipe" }
+        );
+
+        const deletedCount = await tryIndividualDeletion(
+          adapter,
+          databaseId,
+          tableId,
+          rows,
+          INDIVIDUAL_DELETE_BATCH_SIZE,
+          MAX_CONCURRENT_OPERATIONS,
+          progress,
+          totalDeleted
+        );
+        totalDeleted += deletedCount;
+      }
 
       // Set up cursor for next iteration
       if (rows.length < FETCH_BATCH_SIZE) {
@@ -393,109 +393,116 @@ export const wipeTableRows = async (
 /**
  * Helper function to attempt bulk deletion of row IDs
  */
-async function tryBulkDeletion(
-  adapter: DatabaseAdapter,
-  databaseId: string,
-  tableId: string,
-  rowIds: string[],
-  batchSize: number,
-  maxConcurrent: number
-): Promise<void> {
-  if (!adapter.bulkDeleteRows) {
-    throw new Error("Bulk deletion not available on this adapter");
-  }
-
-  const limit = pLimit(maxConcurrent);
-  const batches = chunk(rowIds, batchSize);
-
-  const deletePromises = batches.map((batch) =>
-    limit(async () => {
-      try {
-        await tryAwaitWithRetry(async () =>
-          adapter.bulkDeleteRows!({ databaseId, tableId, rowIds: batch })
-        );
-      } catch (error: any) {
-        const errorMessage = error.message || String(error);
-
-        // Enhanced error handling for bulk deletion
-        if (isCriticalError(errorMessage)) {
-          MessageFormatter.error(
-            `Critical error in bulk deletion batch: ${errorMessage}`,
-            error,
-            { prefix: "Wipe" }
-          );
-          throw error;
-        } else {
-          // For non-critical errors in bulk deletion, re-throw to trigger fallback
-          throw new Error(`Bulk deletion batch failed: ${errorMessage}`);
-        }
-      }
-    })
-  );
-
-  await Promise.all(deletePromises);
-}
+async function tryBulkDeletion(
+  adapter: DatabaseAdapter,
+  databaseId: string,
+  tableId: string,
+  rowIds: string[],
+  batchSize: number,
+  maxConcurrent: number
+): Promise<number> {
+  if (!adapter.bulkDeleteRows) {
+    throw new Error("Bulk deletion not available on this adapter");
+  }
+
+  const limit = pLimit(maxConcurrent);
+  const batches = chunk(rowIds, batchSize);
+  let successfullyDeleted = 0;
+
+  const deletePromises = batches.map((batch) =>
+    limit(async () => {
+      try {
+        const result = await tryAwaitWithRetry(async () =>
+          adapter.bulkDeleteRows!({ databaseId, tableId, rowIds: batch })
+        );
+        successfullyDeleted += batch.length; // Assume success if no error thrown
+      } catch (error: any) {
+        const errorMessage = error.message || String(error);
+
+        // Enhanced error handling for bulk deletion
+        if (isCriticalError(errorMessage)) {
+          MessageFormatter.error(
+            `Critical error in bulk deletion batch: ${errorMessage}`,
+            error,
+            { prefix: "Wipe" }
+          );
+          throw error;
+        } else {
+          // For non-critical errors in bulk deletion, re-throw to trigger fallback
+          throw new Error(`Bulk deletion batch failed: ${errorMessage}`);
+        }
+      }
+    })
+  );
+
+  await Promise.all(deletePromises);
+  return successfullyDeleted;
+}
 
 /**
  * Helper function for fallback individual deletion
  */
-async function tryIndividualDeletion(
-  adapter: DatabaseAdapter,
-  databaseId: string,
-  tableId: string,
-  rows: any[],
-  batchSize: number,
-  maxConcurrent: number,
-  progress: any,
-  baseDeleted: number
-): Promise<void> {
-  const limit = pLimit(maxConcurrent);
-  const batches = chunk(rows, batchSize);
-  let processedInBatch = 0;
-
-  const deletePromises = batches.map((batch) =>
-    limit(async () => {
-      const batchDeletePromises = batch.map(async (row: any) => {
-        try {
-          await tryAwaitWithRetry(async () =>
-            adapter.deleteRow({ databaseId, tableId, id: row.$id })
-          );
-        } catch (error: any) {
-          const errorMessage = error.message || String(error);
-
-          // Enhanced error handling for row deletion
-          if (errorMessage.includes("Row with the requested ID could not be found")) {
-            // Row already deleted, skip silently
-          } else if (isCriticalError(errorMessage)) {
-            // Critical error, log and rethrow to stop operation
-            MessageFormatter.error(
-              `Critical error deleting row ${row.$id}: ${errorMessage}`,
-              error,
-              { prefix: "Wipe" }
-            );
-            throw error;
-          } else if (isRetryableError(errorMessage)) {
-            // Retryable error, will be handled by tryAwaitWithRetry
-            MessageFormatter.progress(
-              `Retryable error for row ${row.$id}, will retry`,
-              { prefix: "Wipe" }
-            );
-          } else {
-            // Other non-critical errors, log but continue
-            MessageFormatter.error(
-              `Failed to delete row ${row.$id}: ${errorMessage}`,
-              error,
-              { prefix: "Wipe" }
-            );
-          }
-        }
-        processedInBatch++;
-        progress.update(baseDeleted + processedInBatch);
-      });
-
-      await Promise.all(batchDeletePromises);
-    })
-  );
-
-  await Promise.all(deletePromises);
-}
+async function tryIndividualDeletion(
+  adapter: DatabaseAdapter,
+  databaseId: string,
+  tableId: string,
+  rows: any[],
+  batchSize: number,
+  maxConcurrent: number,
+  progress: any,
+  baseDeleted: number
+): Promise<number> {
+  const limit = pLimit(maxConcurrent);
+  const batches = chunk(rows, batchSize);
+  let processedInBatch = 0;
+  let successfullyDeleted = 0;
+
+  const deletePromises = batches.map((batch) =>
+    limit(async () => {
+      const batchDeletePromises = batch.map(async (row: any) => {
+        try {
+          await tryAwaitWithRetry(async () =>
+            adapter.deleteRow({ databaseId, tableId, id: row.$id })
+          );
+          successfullyDeleted++;
+        } catch (error: any) {
+          const errorMessage = error.message || String(error);
+
+          // Enhanced error handling for row deletion
+          if (errorMessage.includes("Row with the requested ID could not be found")) {
+            // Row already deleted, count as success since it's gone
+            successfullyDeleted++;
+          } else if (isCriticalError(errorMessage)) {
+            // Critical error, log and rethrow to stop operation
+            MessageFormatter.error(
+              `Critical error deleting row ${row.$id}: ${errorMessage}`,
+              error,
+              { prefix: "Wipe" }
+            );
+            throw error;
+          } else if (isRetryableError(errorMessage)) {
+            // Retryable error, will be handled by tryAwaitWithRetry
+            MessageFormatter.progress(
+              `Retryable error for row ${row.$id}, will retry`,
+              { prefix: "Wipe" }
+            );
+          } else {
+            // Other non-critical errors, log but continue
+            MessageFormatter.error(
+              `Failed to delete row ${row.$id}: ${errorMessage}`,
+              error,
+              { prefix: "Wipe" }
+            );
+          }
+        }
+        processedInBatch++;
+        progress.update(baseDeleted + successfullyDeleted);
+      });
+
+      await Promise.all(batchDeletePromises);
+    })
+  );
+
+  await Promise.all(deletePromises);
+  return successfullyDeleted;
+}