appwrite-utils-cli 1.7.6 → 1.7.7

package/dist/adapters/DatabaseAdapter.d.ts

@@ -72,6 +72,7 @@ export interface BulkDeleteRowsParams {
     databaseId: string;
     tableId: string;
     rowIds: string[];
+    batchSize?: number;
 }
 export interface CreateIndexParams {
     databaseId: string;

package/dist/adapters/LegacyAdapter.js

@@ -7,6 +7,7 @@
  * older Appwrite instances.
  */
 import { Query } from "node-appwrite";
+import { chunk } from "es-toolkit";
 import { BaseAdapter, AdapterError, UnsupportedOperationError } from './DatabaseAdapter.js';
 /**
  * LegacyAdapter - Translates TablesDB calls to legacy Databases API
@@ -310,13 +311,24 @@ export class LegacyAdapter extends BaseAdapter {
     }
     async bulkDeleteRows(params) {
         try {
-            // Try to use deleteDocuments with queries first (more efficient)
-            const queries = params.rowIds.map(id => Query.equal('$id', id));
+            let queries;
+            // Wipe mode: use Query.limit for deleting without fetching
+            if (params.rowIds.length === 0) {
+                const batchSize = params.batchSize || 250;
+                queries = [Query.limit(batchSize)];
+            }
+            // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
+            // (max 100 IDs per Query.equal, and queries must be < 4096 chars total)
+            else {
+                const ID_BATCH_SIZE = 85; // Safe batch size for Query.equal
+                const idBatches = chunk(params.rowIds, ID_BATCH_SIZE);
+                queries = idBatches.map(batch => Query.equal('$id', batch));
+            }
             const result = await this.databases.deleteDocuments(params.databaseId, params.tableId, // Maps tableId to collectionId
             queries);
             return {
                 data: result,
-                total: params.rowIds.length
+                total: params.rowIds.length || result.total || 0
             };
         }
         catch (error) {

package/dist/adapters/TablesDBAdapter.js

@@ -6,6 +6,7 @@
  * and returns Models.Row instead of Models.Document.
  */
 import { Query } from "node-appwrite";
+import { chunk } from "es-toolkit";
 import { BaseAdapter, AdapterError } from './DatabaseAdapter.js';
 /**
  * TablesDBAdapter implementation for native TablesDB API
@@ -270,8 +271,19 @@ export class TablesDBAdapter extends BaseAdapter {
     }
     async bulkDeleteRows(params) {
         try {
-            // Convert rowIds to queries for the deleteRows API
-            const queries = params.rowIds.map(id => Query.equal('$id', id));
+            let queries;
+            // Wipe mode: use Query.limit for deleting without fetching
+            if (params.rowIds.length === 0) {
+                const batchSize = params.batchSize || 250;
+                queries = [Query.limit(batchSize)];
+            }
+            // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
+            // (max 100 IDs per Query.equal, and queries must be < 4096 chars total)
+            else {
+                const ID_BATCH_SIZE = 85; // Safe batch size for Query.equal
+                const idBatches = chunk(params.rowIds, ID_BATCH_SIZE);
+                queries = idBatches.map(batch => Query.equal('$id', batch));
+            }
             const result = await this.tablesDB.deleteRows({
                 databaseId: params.databaseId,
                 tableId: params.tableId,
@@ -279,7 +291,7 @@ export class TablesDBAdapter extends BaseAdapter {
             });
             return {
                 data: result,
-                total: params.rowIds.length
+                total: params.rowIds.length || result.total || 0
             };
         }
         catch (error) {

package/dist/collections/wipeOperations.d.ts

@@ -10,7 +10,7 @@ export declare const wipeAllTables: (adapter: DatabaseAdapter, databaseId: strin
     tableName: string;
 }[]>;
 /**
- * Optimized streaming deletion of all rows from a table
- * Uses bulk deletion when available, falls back to optimized individual deletion
+ * Optimized deletion of all rows from a table using direct bulk deletion
+ * Uses Query.limit() to delete rows without fetching IDs first
  */
 export declare const wipeTableRows: (adapter: DatabaseAdapter, databaseId: string, tableId: string) => Promise<void>;

package/dist/collections/wipeOperations.js

@@ -2,7 +2,7 @@ import { Databases, Query, } from "node-appwrite";
 import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
-import { isRetryableError, isBulkNotSupportedError, isCriticalError } from "../shared/errorUtils.js";
+import { isRetryableError, isCriticalError } from "../shared/errorUtils.js";
 import { delay } from "../utils/helperFunctions.js";
 import { chunk } from "es-toolkit";
 import pLimit from "p-limit";
@@ -167,82 +167,54 @@ export const wipeAllTables = async (adapter, databaseId) => {
     return deleted;
 };
 /**
- * Optimized streaming deletion of all rows from a table
- * Uses bulk deletion when available, falls back to optimized individual deletion
+ * Optimized deletion of all rows from a table using direct bulk deletion
+ * Uses Query.limit() to delete rows without fetching IDs first
  */
 export const wipeTableRows = async (adapter, databaseId, tableId) => {
     try {
-        // Configuration for optimized deletion
-        const FETCH_BATCH_SIZE = 1000; // How many to fetch per query
-        const BULK_DELETE_BATCH_SIZE = 500; // How many to bulk delete at once
-        const INDIVIDUAL_DELETE_BATCH_SIZE = 200; // For fallback individual deletion
-        const MAX_CONCURRENT_OPERATIONS = 10; // Concurrent bulk/individual operations
+        // Check if bulk deletion is available
+        if (!adapter.bulkDeleteRows) {
+            MessageFormatter.error("Bulk deletion not available for this adapter - wipe operation not supported", new Error("bulkDeleteRows not available"), { prefix: "Wipe" });
+            throw new Error("Bulk deletion required for wipe operations");
+        }
+        const DELETE_BATCH_SIZE = 250; // How many rows to delete per batch
         let totalDeleted = 0;
-        let cursor;
         let hasMoreRows = true;
         MessageFormatter.info("Starting optimized table row deletion...", { prefix: "Wipe" });
-        // Create progress tracker (we'll update the total as we discover more rows)
-        const progress = ProgressManager.create(`delete-${tableId}`, 1, // Start with 1, will update as we go
+        const progress = ProgressManager.create(`delete-${tableId}`, 1, // Start with 1, will update as we discover more
         { title: "Deleting table rows" });
         while (hasMoreRows) {
-            // Fetch next batch of rows
-            const queries = [Query.limit(FETCH_BATCH_SIZE)];
-            if (cursor) {
-                queries.push(Query.cursorAfter(cursor));
-            }
-            const response = await adapter.listRows({ databaseId, tableId, queries });
-            const rows = response.rows || [];
-            if (rows.length === 0) {
-                hasMoreRows = false;
-                break;
-            }
-            // Update progress total as we discover more rows
-            if (rows.length === FETCH_BATCH_SIZE) {
-                // There might be more rows, update progress total
-                progress.setTotal(totalDeleted + rows.length + 1000); // Estimate more
-            }
-            MessageFormatter.progress(`Processing batch: ${rows.length} rows (${totalDeleted + rows.length} total so far)`, { prefix: "Wipe" });
-            // Try to use bulk deletion first, fall back to individual deletion
-            const rowIds = rows.map((row) => row.$id);
-            // 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;
+            try {
+                // Delete next batch using Query.limit() - no fetching needed!
+                const result = await tryAwaitWithRetry(async () => adapter.bulkDeleteRows({
+                    databaseId,
+                    tableId,
+                    rowIds: [], // Empty array signals we want to use Query.limit instead
+                    batchSize: DELETE_BATCH_SIZE
+                }));
+                const deletedCount = result.total || 0;
+                if (deletedCount === 0) {
+                    hasMoreRows = false;
+                    break;
                 }
-            }
-            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;
+                progress.setTotal(totalDeleted + 100); // Estimate more rows exist
+                progress.update(totalDeleted);
+                MessageFormatter.progress(`Deleted ${deletedCount} rows (${totalDeleted} total so far)`, { prefix: "Wipe" });
+                // Small delay between batches to be respectful to the API
+                await delay(10);
             }
-            // Set up cursor for next iteration
-            if (rows.length < FETCH_BATCH_SIZE) {
-                hasMoreRows = false;
-            }
-            else {
-                cursor = rows[rows.length - 1].$id;
+            catch (error) {
+                const errorMessage = error.message || String(error);
+                if (isCriticalError(errorMessage)) {
+                    MessageFormatter.error(`Critical error during bulk deletion: ${errorMessage}`, error, { prefix: "Wipe" });
+                    throw error;
+                }
+                else {
+                    MessageFormatter.error(`Error during deletion batch: ${errorMessage}`, error, { prefix: "Wipe" });
+                    // Continue trying with next batch
+                }
             }
-            // Small delay between fetch cycles to be respectful to the API
-            await delay(10);
         }
         // Update final progress total
         progress.setTotal(totalDeleted);
@@ -259,77 +231,3 @@ export const wipeTableRows = async (adapter, databaseId, tableId) => {
         throw error;
     }
 };
-/**
- * Helper function to attempt bulk deletion of row IDs
- */
-async function tryBulkDeletion(adapter, databaseId, tableId, rowIds, batchSize, maxConcurrent) {
-    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) {
-            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, databaseId, tableId, rows, batchSize, maxConcurrent, progress, baseDeleted) {
-    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, 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;
-}

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

package/src/adapters/DatabaseAdapter.ts

@@ -86,7 +86,8 @@ export interface BulkUpsertRowsParams {
 export interface BulkDeleteRowsParams {
   databaseId: string;
   tableId: string;
-  rowIds: string[];
+  rowIds: string[]; // Empty array = wipe mode (use Query.limit), otherwise specific IDs to delete
+  batchSize?: number; // Optional batch size for wipe mode (default 250)
 }
 
 // Index operation parameters  

package/src/adapters/LegacyAdapter.ts

@@ -7,32 +7,33 @@
  * older Appwrite instances.
  */
 
-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';
+import { Query } from "node-appwrite";
+import { chunk } from "es-toolkit";
+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
@@ -587,62 +588,74 @@ export class LegacyAdapter extends BaseAdapter {
     throw new UnsupportedOperationError('bulkUpsertRows', 'legacy');
   }
   
-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
-        );
-      }
-    }
-  }
+async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
+    try {
+      let queries: string[];
+
+      // Wipe mode: use Query.limit for deleting without fetching
+      if (params.rowIds.length === 0) {
+        const batchSize = params.batchSize || 250;
+        queries = [Query.limit(batchSize)];
+      }
+      // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
+      // (max 100 IDs per Query.equal, and queries must be < 4096 chars total)
+      else {
+        const ID_BATCH_SIZE = 85; // Safe batch size for Query.equal
+        const idBatches = chunk(params.rowIds, ID_BATCH_SIZE);
+        queries = idBatches.map(batch => Query.equal('$id', batch));
+      }
+
+      const result = await this.databases.deleteDocuments(
+        params.databaseId,
+        params.tableId, // Maps tableId to collectionId
+        queries
+      );
+
+      return {
+        data: result,
+        total: params.rowIds.length || (result as any).total || 0
+      };
+    } 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,32 +6,33 @@
  * and returns Models.Row instead of Models.Document.
  */
 
-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';
+import { Query } from "node-appwrite";
+import { chunk } from "es-toolkit";
+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
@@ -514,27 +515,41 @@ export class TablesDBAdapter extends BaseAdapter {
     }
   }
   
-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
-      );
-    }
-  }
+async bulkDeleteRows(params: BulkDeleteRowsParams): Promise<ApiResponse> {
+    try {
+      let queries: string[];
+
+      // Wipe mode: use Query.limit for deleting without fetching
+      if (params.rowIds.length === 0) {
+        const batchSize = params.batchSize || 250;
+        queries = [Query.limit(batchSize)];
+      }
+      // Specific IDs mode: chunk into batches of 80-90 to stay within Appwrite limits
+      // (max 100 IDs per Query.equal, and queries must be < 4096 chars total)
+      else {
+        const ID_BATCH_SIZE = 85; // Safe batch size for Query.equal
+        const idBatches = chunk(params.rowIds, ID_BATCH_SIZE);
+        queries = idBatches.map(batch => Query.equal('$id', batch));
+      }
+
+      const result = await this.tablesDB.deleteRows({
+        databaseId: params.databaseId,
+        tableId: params.tableId,
+        queries: queries
+      });
+
+      return {
+        data: result,
+        total: params.rowIds.length || (result as any).total || 0
+      };
+    } 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

@@ -7,7 +7,7 @@ import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
 import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
-import { isRetryableError, isBulkNotSupportedError, isCriticalError } from "../shared/errorUtils.js";
+import { isRetryableError, isCriticalError } from "../shared/errorUtils.js";
 import { delay } from "../utils/helperFunctions.js";
 import { chunk } from "es-toolkit";
 import pLimit from "p-limit";
@@ -239,8 +239,8 @@ export const wipeAllTables = async (
 };
 
 /**
- * Optimized streaming deletion of all rows from a table
- * Uses bulk deletion when available, falls back to optimized individual deletion
+ * Optimized deletion of all rows from a table using direct bulk deletion
+ * Uses Query.limit() to delete rows without fetching IDs first
  */
 export const wipeTableRows = async (
   adapter: DatabaseAdapter,
@@ -248,123 +248,78 @@ export const wipeTableRows = async (
   tableId: string
 ): Promise<void> => {
   try {
-    // Configuration for optimized deletion
-    const FETCH_BATCH_SIZE = 1000; // How many to fetch per query
-    const BULK_DELETE_BATCH_SIZE = 500; // How many to bulk delete at once
-    const INDIVIDUAL_DELETE_BATCH_SIZE = 200; // For fallback individual deletion
-    const MAX_CONCURRENT_OPERATIONS = 10; // Concurrent bulk/individual operations
+    // Check if bulk deletion is available
+    if (!adapter.bulkDeleteRows) {
+      MessageFormatter.error(
+        "Bulk deletion not available for this adapter - wipe operation not supported",
+        new Error("bulkDeleteRows not available"),
+        { prefix: "Wipe" }
+      );
+      throw new Error("Bulk deletion required for wipe operations");
+    }
 
+    const DELETE_BATCH_SIZE = 250; // How many rows to delete per batch
     let totalDeleted = 0;
-    let cursor: string | undefined;
     let hasMoreRows = true;
 
     MessageFormatter.info("Starting optimized table row deletion...", { prefix: "Wipe" });
 
-    // Create progress tracker (we'll update the total as we discover more rows)
     const progress = ProgressManager.create(
       `delete-${tableId}`,
-      1, // Start with 1, will update as we go
+      1, // Start with 1, will update as we discover more
       { title: "Deleting table rows" }
     );
 
     while (hasMoreRows) {
-      // Fetch next batch of rows
-      const queries = [Query.limit(FETCH_BATCH_SIZE)];
-      if (cursor) {
-        queries.push(Query.cursorAfter(cursor));
+      try {
+        // Delete next batch using Query.limit() - no fetching needed!
+        const result = await tryAwaitWithRetry(async () =>
+          adapter.bulkDeleteRows!({
+            databaseId,
+            tableId,
+            rowIds: [], // Empty array signals we want to use Query.limit instead
+            batchSize: DELETE_BATCH_SIZE
+          })
+        );
+
+        const deletedCount = (result as any).total || 0;
+
+        if (deletedCount === 0) {
+          hasMoreRows = false;
+          break;
+        }
+
+        totalDeleted += deletedCount;
+        progress.setTotal(totalDeleted + 100); // Estimate more rows exist
+        progress.update(totalDeleted);
+
+        MessageFormatter.progress(
+          `Deleted ${deletedCount} rows (${totalDeleted} total so far)`,
+          { prefix: "Wipe" }
+        );
+
+        // Small delay between batches to be respectful to the API
+        await delay(10);
+
+      } catch (error: any) {
+        const errorMessage = error.message || String(error);
+
+        if (isCriticalError(errorMessage)) {
+          MessageFormatter.error(
+            `Critical error during bulk deletion: ${errorMessage}`,
+            error,
+            { prefix: "Wipe" }
+          );
+          throw error;
+        } else {
+          MessageFormatter.error(
+            `Error during deletion batch: ${errorMessage}`,
+            error,
+            { prefix: "Wipe" }
+          );
+          // Continue trying with next batch
+        }
       }
-
-      const response = await adapter.listRows({ databaseId, tableId, queries });
-      const rows: any[] = (response as any).rows || [];
-
-      if (rows.length === 0) {
-        hasMoreRows = false;
-        break;
-      }
-
-      // Update progress total as we discover more rows
-      if (rows.length === FETCH_BATCH_SIZE) {
-        // There might be more rows, update progress total
-        progress.setTotal(totalDeleted + rows.length + 1000); // Estimate more
-      }
-
-      MessageFormatter.progress(
-        `Processing batch: ${rows.length} rows (${totalDeleted + rows.length} total so far)`,
-        { prefix: "Wipe" }
-      );
-
-      // 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)
-          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) {
-        hasMoreRows = false;
-      } else {
-        cursor = rows[rows.length - 1].$id;
-      }
-
-      // Small delay between fetch cycles to be respectful to the API
-      await delay(10);
     }
 
     // Update final progress total
@@ -389,120 +344,3 @@ export const wipeTableRows = async (
     throw error;
   }
 };
-
-/**
- * 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<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<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;
-}