appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/cli/commands/schemaCommands.js

@@ -1,8 +1,8 @@
 import inquirer from "inquirer";
 import path from "path";
 import chalk from "chalk";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
-import { SchemaGenerator } from "../../shared/schemaGenerator.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
+import { SchemaGenerator } from 'appwrite-utils-helpers';
 import { setupDirsFiles } from "../../utils/setupFiles.js";
 import { fetchAllDatabases } from "../../databases/methods.js";
 export const schemaCommands = {
@@ -112,7 +112,7 @@ export const schemaCommands = {
             },
         ]);
         try {
-            const { ConstantsGenerator } = await import("../../utils/constantsGenerator.js");
+            const { ConstantsGenerator } = await import("appwrite-utils-helpers");
             const generator = new ConstantsGenerator(cli.controller.config);
             const include = {
                 databases: includeWhat.includes('databases'),

package/dist/cli/commands/storageCommands.js

@@ -1,10 +1,9 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { Storage, Permission, Role, Compression } from "node-appwrite";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
 import { listBuckets, createBucket as createBucketApi, deleteBucket as deleteBucketApi } from "../../storage/methods.js";
-import { writeYamlConfig } from "../../config/yamlConfig.js";
-import { ConfigManager } from "../../config/ConfigManager.js";
+import { writeYamlConfig, ConfigManager } from "appwrite-utils-helpers";
 export const storageCommands = {
     async createBucket(cli) {
         const storage = cli.controller.storage;

package/dist/cli/commands/transferCommands.js

@@ -1,9 +1,9 @@
 import inquirer from "inquirer";
 import { Databases, Storage } from "node-appwrite";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
 import { fetchAllDatabases } from "../../databases/methods.js";
 import { listBuckets } from "../../storage/methods.js";
-import { getClient } from "../../utils/getClientFromConfig.js";
+import { getClient } from "appwrite-utils-helpers";
 import { ComprehensiveTransfer } from "../../migrations/comprehensiveTransfer.js";
 export const transferCommands = {
     async transferData(cli) {
@@ -91,9 +91,7 @@ export const transferCommands = {
             fromDb,
             targetDb,
             isRemote,
-            collections: selectedCollections.length > 0
-                ? selectedCollections.map((c) => c.$id)
-                : undefined,
+            collections: selectedCollections.map((c) => c.$id),
             sourceBucket,
             targetBucket,
         };

package/dist/collections/{attributes.d.ts → columns.d.ts}

@@ -1,6 +1,6 @@
 import { type Databases, type Models } from "node-appwrite";
 import { type Attribute } from "appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "appwrite-utils-helpers";
 /**
  * Enhanced attribute creation with proper status monitoring and retry logic
  */

package/dist/collections/{attributes.js → columns.js}

@@ -1,17 +1,19 @@
 import { Query } from "node-appwrite";
 import { attributeSchema, parseAttribute, } from "appwrite-utils";
 import { nameToIdMapping, enqueueOperation, markAttributeProcessed, isAttributeProcessed, } from "../shared/operationQueue.js";
-import { delay, tryAwaitWithRetry, calculateExponentialBackoff, } from "../utils/helperFunctions.js";
+import { delay, tryAwaitWithRetry, calculateExponentialBackoff, } from "appwrite-utils-helpers";
 import chalk from "chalk";
 import { Decimal } from "decimal.js";
-import { logger } from "../shared/logging.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { isDatabaseAdapter } from "../utils/typeGuards.js";
+import { logger, MessageFormatter, isDatabaseAdapter } from "appwrite-utils-helpers";
 // Extreme values that Appwrite may return, which should be treated as undefined
 const EXTREME_MIN_INTEGER = -9223372036854776000;
 const EXTREME_MAX_INTEGER = 9223372036854776000;
 const EXTREME_MIN_FLOAT = -1.7976931348623157e308;
 const EXTREME_MAX_FLOAT = 1.7976931348623157e308;
+/** Get columns/attributes array, preferring modern 'columns' over legacy 'attributes' */
+function getColumns(obj) {
+    return obj.columns || obj.attributes || [];
+}
 /**
  * Type guard to check if an attribute has min/max properties
  */
@@ -560,7 +562,7 @@ retryCount = 0, maxRetries = 5) => {
             const collection = isDatabaseAdapter(db)
                 ? (await db.getTable({ databaseId: dbId, tableId: collectionId })).data
                 : await db.getCollection(dbId, collectionId);
-            const attribute = collection.attributes.find((attr) => attr.key === attributeKey);
+            const attribute = getColumns(collection).find((attr) => attr.key === attributeKey);
             if (!attribute) {
                 MessageFormatter.error(`Attribute '${attributeKey}' not found`);
                 return false;
@@ -933,7 +935,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
     const updateEnabled = true;
     let finalAttribute = attribute;
     try {
-        const collectionAttr = collection.attributes.find((attr) => attr.key === attribute.key);
+        const collectionAttr = getColumns(collection).find((attr) => attr.key === attribute.key);
         foundAttribute = parseAttribute(collectionAttr);
     }
     catch (error) {
@@ -955,7 +957,11 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
                 await db.deleteAttribute(dbId, collection.$id, attribute.key);
             }
             // Remove from local collection metadata so downstream logic treats it as new
-            collection.attributes = collection.attributes.filter((attr) => attr.key !== attribute.key);
+            const filtered = getColumns(collection).filter((attr) => attr.key !== attribute.key);
+            if ('columns' in collection)
+                collection.columns = filtered;
+            if ('attributes' in collection)
+                collection.attributes = filtered;
             foundAttribute = undefined;
         }
         catch (deleteError) {
@@ -1128,7 +1134,7 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
  * Enhanced collection attribute creation with proper status monitoring
  */
 export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId, collection, attributes) => {
-    const existingAttributes = collection.attributes.map((attr) => parseAttribute(attr)) || [];
+    const existingAttributes = getColumns(collection).map((attr) => parseAttribute(attr)) || [];
     const attributesToRemove = existingAttributes.filter((attr) => !attributes.some((a) => a.key === attr.key));
     const indexesToRemove = collection.indexes.filter((index) => attributesToRemove.some((attr) => index.attributes.includes(attr.key)));
     // Handle attribute removal first
@@ -1275,7 +1281,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
 };
 export const createUpdateCollectionAttributes = async (db, dbId, collection, attributes) => {
     MessageFormatter.info(chalk.green(`Creating/Updating attributes for collection: ${collection.name}`));
-    const existingAttributes = collection.attributes.map((attr) => parseAttribute(attr)) || [];
+    const existingAttributes = getColumns(collection).map((attr) => parseAttribute(attr)) || [];
     const attributesToRemove = existingAttributes.filter((attr) => !attributes.some((a) => a.key === attr.key));
     const indexesToRemove = collection.indexes.filter((index) => attributesToRemove.some((attr) => index.attributes.includes(attr.key)));
     if (attributesToRemove.length > 0) {

package/dist/collections/indexes.js

@@ -1,8 +1,6 @@
 import { indexSchema } from "appwrite-utils";
 import { Databases, IndexType, Query } from "node-appwrite";
-import { delay, tryAwaitWithRetry, calculateExponentialBackoff } from "../utils/helperFunctions.js";
-import { isLegacyDatabases } from "../utils/typeGuards.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { delay, tryAwaitWithRetry, calculateExponentialBackoff, isLegacyDatabases, MessageFormatter } from "appwrite-utils-helpers";
 // System attributes that are always available for indexing in Appwrite
 const SYSTEM_ATTRIBUTES = ['$id', '$createdAt', '$updatedAt', '$permissions'];
 /**

package/dist/collections/methods.d.ts

@@ -1,6 +1,6 @@
 import { Databases, type Models } from "node-appwrite";
 import type { AppwriteConfig, CollectionCreate } from "appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "appwrite-utils-helpers";
 export { wipeDatabase, wipeCollection, wipeAllTables, wipeTableRows, } from "./wipeOperations.js";
 export { transferDocumentsBetweenDbsLocalToLocal, transferDocumentsBetweenDbsLocalToRemote, } from "./transferOperations.js";
 export declare const documentExists: (db: Databases | DatabaseAdapter, dbId: string, targetCollectionId: string, toCreateObject: any) => Promise<Models.Document | null>;

package/dist/collections/methods.js

@@ -1,14 +1,12 @@
 import { Databases, ID, Permission, Query, } from "node-appwrite";
-import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
+import { getAdapterFromConfig } from "appwrite-utils-helpers";
 import { nameToIdMapping, processQueue, queuedOperations, clearProcessingState, isCollectionProcessed, markCollectionProcessed, enqueueOperation } from "../shared/operationQueue.js";
-import { logger } from "../shared/logging.js";
+import { logger, SchemaGenerator } from "appwrite-utils-helpers";
 // Legacy attribute/index helpers removed in favor of unified adapter path
-import { SchemaGenerator } from "../shared/schemaGenerator.js";
 import { isNull, isUndefined, isNil, isPlainObject, isString, } from "es-toolkit";
-import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { isLegacyDatabases } from "../utils/typeGuards.js";
-import { mapToCreateAttributeParams, mapToUpdateAttributeParams } from "../shared/attributeMapper.js";
+import { delay, tryAwaitWithRetry } from "appwrite-utils-helpers";
+import { MessageFormatter, mapToCreateAttributeParams, mapToUpdateAttributeParams } from "appwrite-utils-helpers";
+import { isLegacyDatabases } from "appwrite-utils-helpers";
 import { diffTableColumns, isIndexEqualToIndex, diffColumnsDetailed, executeColumnOperations } from "./tableOperations.js";
 import { createOrUpdateIndexesViaAdapter, deleteObsoleteIndexesViaAdapter } from "../tables/indexManager.js";
 // Re-export wipe operations
@@ -63,18 +61,20 @@ export const documentExists = async (db, dbId, targetCollectionId, toCreateObjec
 };
 export const checkForCollection = async (db, dbId, collection) => {
     try {
-        MessageFormatter.progress(`Checking for collection with name: ${collection.name}`, { prefix: "Collections" });
-        const response = await tryAwaitWithRetry(async () => isLegacyDatabases(db) ?
+        const isLegacy = isLegacyDatabases(db);
+        const entityType = isLegacy ? "Collection" : "Table";
+        MessageFormatter.progress(`Checking for ${entityType.toLowerCase()} with name: ${collection.name}`, { prefix: entityType + "s" });
+        const response = await tryAwaitWithRetry(async () => isLegacy ?
             await db.listCollections(dbId, [Query.equal("name", collection.name)]) :
             await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collection.name)] }));
-        const items = isLegacyDatabases(db) ? response.collections : (response.tables || response.collections);
+        const items = isLegacy ? response.collections : (response.tables || response.collections);
         if (items && items.length > 0) {
-            MessageFormatter.info(`Collection found: ${items[0].$id}`, { prefix: "Collections" });
+            MessageFormatter.info(`${entityType} found: ${items[0].$id}`, { prefix: entityType + "s" });
             // Return remote collection for update operations (don't merge local config over it)
             return items[0];
         }
         else {
-            MessageFormatter.info(`No collection found with name: ${collection.name}`, { prefix: "Collections" });
+            MessageFormatter.info(`No ${entityType.toLowerCase()} found with name: ${collection.name}`, { prefix: entityType + "s" });
             return null;
         }
     }
@@ -92,27 +92,29 @@ export const checkForCollection = async (db, dbId, collection) => {
 };
 // Helper function to fetch and cache collection by name
 export const fetchAndCacheCollectionByName = async (db, dbId, collectionName) => {
+    const isLegacy = isLegacyDatabases(db);
+    const entityType = isLegacy ? "Collection" : "Table";
     if (nameToIdMapping.has(collectionName)) {
         const collectionId = nameToIdMapping.get(collectionName);
-        MessageFormatter.debug(`Collection found in cache: ${collectionId}`, undefined, { prefix: "Collections" });
-        return await tryAwaitWithRetry(async () => isLegacyDatabases(db) ?
+        MessageFormatter.debug(`${entityType} found in cache: ${collectionId}`, undefined, { prefix: entityType + "s" });
+        return await tryAwaitWithRetry(async () => isLegacy ?
             await db.getCollection(dbId, collectionId) :
             await db.getTable({ databaseId: dbId, tableId: collectionId }));
     }
     else {
-        MessageFormatter.progress(`Fetching collection by name: ${collectionName}`, { prefix: "Collections" });
-        const collectionsPulled = await tryAwaitWithRetry(async () => isLegacyDatabases(db) ?
+        MessageFormatter.progress(`Fetching ${entityType.toLowerCase()} by name: ${collectionName}`, { prefix: entityType + "s" });
+        const collectionsPulled = await tryAwaitWithRetry(async () => isLegacy ?
             await db.listCollections(dbId, [Query.equal("name", collectionName)]) :
             await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collectionName)] }));
-        const items = isLegacyDatabases(db) ? collectionsPulled.collections : (collectionsPulled.tables || collectionsPulled.collections);
+        const items = isLegacy ? collectionsPulled.collections : (collectionsPulled.tables || collectionsPulled.collections);
         if ((collectionsPulled.total || items?.length) > 0) {
             const collection = items[0];
-            MessageFormatter.info(`Collection found: ${collection.$id}`, { prefix: "Collections" });
+            MessageFormatter.info(`${entityType} found: ${collection.$id}`, { prefix: entityType + "s" });
             nameToIdMapping.set(collectionName, collection.$id);
             return collection;
         }
         else {
-            MessageFormatter.warning(`Collection not found by name: ${collectionName}`, { prefix: "Collections" });
+            MessageFormatter.warning(`${entityType} not found by name: ${collectionName}`, { prefix: entityType + "s" });
             return undefined;
         }
     }
@@ -433,10 +435,26 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
         // Deletions: remove columns/attributes that are present remotely but not in desired config
         try {
             const desiredKeys = new Set((attributes || []).map((a) => a.key));
+            // Also track case-insensitive keys to avoid double-deletion of renames (handled as recreates)
+            const desiredKeysLower = new Set((attributes || []).map((a) => a.key?.toLowerCase()));
             const tableInfo3 = await adapter.getTable({ databaseId, tableId });
             const existingCols3 = tableInfo3.data?.columns || tableInfo3.data?.attributes || [];
             const toDelete = existingCols3
-                .filter((col) => col?.key && !desiredKeys.has(col.key))
+                .filter((col) => {
+                if (!col?.key)
+                    return false;
+                // Exact match - keep it
+                if (desiredKeys.has(col.key))
+                    return false;
+                // Case-insensitive match (rename scenario) - already handled as recreate, don't delete again
+                if (desiredKeysLower.has(col.key?.toLowerCase()))
+                    return false;
+                // Don't delete child-side relationship attributes - they're auto-managed by Appwrite
+                // for two-way relationships and deleting them would break the parent relationship
+                if (col.type === 'relationship' && col.side === 'child')
+                    return false;
+                return true;
+            })
                 .map((col) => col.key);
             if (toDelete.length > 0) {
                 MessageFormatter.info(`Plan → 🗑️  ${toDelete.length} (${toDelete.join(', ')})`, { prefix: 'Attributes' });

package/dist/collections/tableOperations.d.ts

@@ -45,6 +45,7 @@ export declare function isIndexEqualToIndex(a: any, b: any): boolean;
 /**
  * Enhanced version of columns diff with detailed change analysis
  * Order: desired first, then existing (matches internal usage here)
+ * Handles case-insensitive key matches as renames (recreates)
  */
 export declare function diffColumnsDetailed(desiredAttributes: Attribute[], existingColumns: any[]): ColumnOperationPlan;
 /**

package/dist/collections/tableOperations.js

@@ -1,4 +1,4 @@
-import { mapToCreateAttributeParams, mapToUpdateAttributeParams } from "../shared/attributeMapper.js";
+import { mapToCreateAttributeParams, mapToUpdateAttributeParams } from "appwrite-utils-helpers";
 import { Decimal } from "decimal.js";
 const EXTREME_BOUND = new Decimal('1e12');
 // Property configuration for different column types
@@ -312,29 +312,48 @@ function analyzeColumnChanges(oldColumn, newAttribute) {
 /**
  * Enhanced version of columns diff with detailed change analysis
  * Order: desired first, then existing (matches internal usage here)
+ * Handles case-insensitive key matches as renames (recreates)
  */
 export function diffColumnsDetailed(desiredAttributes, existingColumns) {
+    // Exact key lookup (case-sensitive)
     const byKey = new Map((existingColumns || []).map((col) => [col?.key, col]));
+    // Case-insensitive key lookup for detecting renames
+    const byKeyLower = new Map((existingColumns || []).map((col) => [col?.key?.toLowerCase(), col]));
     const toCreate = [];
     const toUpdate = [];
     const toRecreate = [];
     const unchanged = [];
+    const handledExistingKeys = new Set(); // Track which existing columns we've handled
     for (const attr of desiredAttributes || []) {
         const key = attr?.key;
-        const existing = key ? byKey.get(key) : undefined;
-        if (!existing) {
-            toCreate.push(attr);
+        if (!key)
+            continue;
+        // First try exact match
+        const exactMatch = byKey.get(key);
+        if (exactMatch) {
+            handledExistingKeys.add(key);
+            const analysis = analyzeColumnChanges(exactMatch, attr);
+            if (!analysis.hasChanges)
+                unchanged.push(analysis.columnKey);
+            else if (analysis.requiresRecreate)
+                toRecreate.push({ oldAttribute: exactMatch, newAttribute: attr });
+            else
+                toUpdate.push({ attribute: attr, changes: analysis.changes });
             continue;
         }
-        const analysis = analyzeColumnChanges(existing, attr);
-        if (!analysis.hasChanges)
-            unchanged.push(analysis.columnKey);
-        else if (analysis.requiresRecreate)
-            toRecreate.push({ oldAttribute: existing, newAttribute: attr });
-        else
-            toUpdate.push({ attribute: attr, changes: analysis.changes });
+        // Check for case-insensitive match (rename scenario like oAuthAccounts -> oauthAccounts)
+        const caseInsensitiveMatch = byKeyLower.get(key.toLowerCase());
+        if (caseInsensitiveMatch && caseInsensitiveMatch.key !== key) {
+            // This is a rename - treat as recreate (delete old, create new)
+            handledExistingKeys.add(caseInsensitiveMatch.key);
+            toRecreate.push({ oldAttribute: caseInsensitiveMatch, newAttribute: attr });
+            continue;
+        }
+        // No match - it's a new attribute
+        toCreate.push(attr);
     }
     // Note: we keep toDelete empty for now (conservative behavior)
+    // Deletions are handled separately in methods.ts
     return { toCreate, toUpdate, toRecreate, toDelete: [], unchanged };
 }
 /**

package/dist/collections/transferOperations.d.ts

@@ -1,5 +1,5 @@
 import { Databases } from "node-appwrite";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "appwrite-utils-helpers";
 /**
  * Transfers all documents from one collection to another in a different database
  * within the same Appwrite Project

package/dist/collections/transferOperations.js

@@ -1,9 +1,8 @@
 import { Client, Databases, ID, Query, } from "node-appwrite";
-import { tryAwaitWithRetry, delay, calculateExponentialBackoff } from "../utils/helperFunctions.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { tryAwaitWithRetry, delay, calculateExponentialBackoff, MessageFormatter } from "appwrite-utils-helpers";
 import { chunk } from "es-toolkit";
-import { isLegacyDatabases } from "../utils/typeGuards.js";
-import { getAdapter } from "../utils/getClientFromConfig.js";
+import { isLegacyDatabases } from "appwrite-utils-helpers";
+import { getAdapter } from "appwrite-utils-helpers";
 /**
  * Transfers all documents from one collection to another in a different database
  * within the same Appwrite Project

package/dist/collections/wipeOperations.d.ts

@@ -1,5 +1,5 @@
 import { Databases } from "node-appwrite";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "appwrite-utils-helpers";
 export declare const wipeDatabase: (database: Databases, databaseId: string) => Promise<{
     collectionId: string;
     collectionName: string;
@@ -10,7 +10,8 @@ export declare const wipeAllTables: (adapter: DatabaseAdapter, databaseId: strin
     tableName: string;
 }[]>;
 /**
- * Optimized deletion of all rows from a table using direct bulk deletion
- * Uses Query.limit() to delete rows without fetching IDs first
+ * Optimized deletion of all rows from a table.
+ * Uses bulk deletion when possible, but falls back to individual row deletion
+ * for tables with relationship columns (bulk delete not supported for those).
  */
 export declare const wipeTableRows: (adapter: DatabaseAdapter, databaseId: string, tableId: string) => Promise<void>;

package/dist/collections/wipeOperations.js

@@ -1,9 +1,8 @@
 import { Databases, Query, } from "node-appwrite";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { tryAwaitWithRetry } from "appwrite-utils-helpers";
+import { MessageFormatter, isRetryableError, isCriticalError } from "appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
-import { isRetryableError, isCriticalError } from "../shared/errorUtils.js";
-import { delay } from "../utils/helperFunctions.js";
+import { delay } from "appwrite-utils-helpers";
 import { chunk } from "es-toolkit";
 import pLimit from "p-limit";
 import { fetchAllCollections } from "./methods.js";
@@ -167,52 +166,126 @@ export const wipeAllTables = async (adapter, databaseId) => {
     return deleted;
 };
 /**
- * Optimized deletion of all rows from a table using direct bulk deletion
- * Uses Query.limit() to delete rows without fetching IDs first
+ * Optimized deletion of all rows from a table.
+ * Uses bulk deletion when possible, but falls back to individual row deletion
+ * for tables with relationship columns (bulk delete not supported for those).
  */
 export const wipeTableRows = async (adapter, databaseId, tableId) => {
     try {
-        // 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
+        // Check if the table has relationship columns — bulk delete is not supported for those
+        const tableInfo = await adapter.getTable({ databaseId, tableId });
+        const columns = tableInfo.data?.columns || [];
+        const hasRelationships = columns.some((col) => col.type === "relationship");
+        const DELETE_BATCH_SIZE = 250;
         let totalDeleted = 0;
         let hasMoreRows = true;
-        MessageFormatter.info("Starting optimized table row deletion...", { prefix: "Wipe" });
-        const progress = ProgressManager.create(`delete-${tableId}`, 1, // Start with 1, will update as we discover more
-        { title: "Deleting table rows" });
-        while (hasMoreRows) {
-            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) {
+        const progress = ProgressManager.create(`delete-${tableId}`, 1, { title: "Deleting table rows" });
+        if (hasRelationships) {
+            // ── Relationship table: fetch rows then delete individually ──
+            MessageFormatter.info("Table has relationship columns — using individual row deletion (bulk delete not supported)", { prefix: "Wipe" });
+            const FETCH_BATCH_SIZE = 1000;
+            const MAX_CONCURRENT_DELETES = 25;
+            const limit = pLimit(MAX_CONCURRENT_DELETES);
+            // Pipeline: prefetch the first batch, then overlap fetch+delete
+            let pendingRows = [];
+            let totalDiscovered = 0;
+            // Fetch helper — always fetches from the top since we're deleting everything
+            const fetchBatch = async () => {
+                const queries = [Query.limit(FETCH_BATCH_SIZE)];
+                const response = await tryAwaitWithRetry(async () => adapter.listRows({ databaseId, tableId, queries }));
+                return response.rows || response.data || [];
+            };
+            // Kick off the first fetch
+            let nextFetchPromise = fetchBatch();
+            while (hasMoreRows) {
+                // Await the prefetched batch
+                const rows = nextFetchPromise ? await nextFetchPromise : [];
+                nextFetchPromise = null;
+                if (rows.length === 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
+                totalDiscovered += rows.length;
+                const isLastBatch = rows.length < FETCH_BATCH_SIZE;
+                if (!isLastBatch) {
+                    progress.setTotal(totalDiscovered + 1000);
+                }
+                else {
+                    progress.setTotal(totalDiscovered);
+                }
+                MessageFormatter.progress(`Fetched ${rows.length} rows (${totalDiscovered} discovered, ${totalDeleted} deleted so far)`, { prefix: "Wipe" });
+                // Start deleting this batch — and prefetch the next one concurrently
+                // (only prefetch if we expect more rows)
+                if (!isLastBatch) {
+                    // Wait a moment before prefetching so the first few deletes free up API capacity
+                    nextFetchPromise = delay(200).then(() => fetchBatch());
+                }
+                // Delete each row with concurrency limit
+                const deletePromises = rows.map((row) => limit(async () => {
+                    try {
+                        await tryAwaitWithRetry(async () => adapter.deleteRow({ databaseId, tableId, id: row.$id }));
+                        totalDeleted++;
+                        progress.update(totalDeleted);
+                    }
+                    catch (error) {
+                        const errorMessage = error.message || String(error);
+                        if (errorMessage.includes("could not be found")) {
+                            totalDeleted++;
+                            progress.update(totalDeleted);
+                        }
+                        else if (isCriticalError(errorMessage)) {
+                            MessageFormatter.error(`Critical error deleting row ${row.$id}: ${errorMessage}`, error, { prefix: "Wipe" });
+                            throw error;
+                        }
+                        else {
+                            MessageFormatter.error(`Failed to delete row ${row.$id}: ${errorMessage}`, error, { prefix: "Wipe" });
+                            totalDeleted++;
+                            progress.update(totalDeleted);
+                        }
+                    }
+                }));
+                await Promise.all(deletePromises);
+                if (isLastBatch) {
+                    hasMoreRows = false;
+                }
                 await delay(10);
             }
-            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 {
+            // ── No relationships: use fast bulk deletion ──
+            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");
+            }
+            MessageFormatter.info("Starting optimized table row deletion...", { prefix: "Wipe" });
+            while (hasMoreRows) {
+                try {
+                    const result = await tryAwaitWithRetry(async () => adapter.bulkDeleteRows({
+                        databaseId,
+                        tableId,
+                        rowIds: [],
+                        batchSize: DELETE_BATCH_SIZE
+                    }));
+                    const deletedCount = result.total || 0;
+                    if (deletedCount === 0) {
+                        hasMoreRows = false;
+                        break;
+                    }
+                    totalDeleted += deletedCount;
+                    progress.setTotal(totalDeleted + 100);
+                    progress.update(totalDeleted);
+                    MessageFormatter.progress(`Deleted ${deletedCount} rows (${totalDeleted} total so far)`, { prefix: "Wipe" });
+                    await delay(10);
                 }
-                else {
-                    MessageFormatter.error(`Error during deletion batch: ${errorMessage}`, error, { prefix: "Wipe" });
-                    // Continue trying with next batch
+                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" });
+                    }
                 }
             }
         }

package/dist/databases/methods.js

@@ -1,7 +1,7 @@
 import { Databases, Query } from "node-appwrite";
-import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { delay, tryAwaitWithRetry } from "appwrite-utils-helpers";
 import { fetchAllCollections } from "../collections/methods.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter } from "appwrite-utils-helpers";
 export const fetchAllDatabases = async (database) => {
     const databases = await tryAwaitWithRetry(async () => await database.list([Query.limit(25)]));
     const allDatabases = databases.databases;

package/dist/databases/setup.js

@@ -1,8 +1,8 @@
 import { Databases, Query } from "node-appwrite";
-import { tryAwaitWithRetry } from "../utils/index.js";
+import { tryAwaitWithRetry } from "appwrite-utils-helpers";
 import {} from "appwrite-utils";
 import { ulid } from "ulidx";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter } from "appwrite-utils-helpers";
 export const ensureDatabasesExist = async (config, databasesToEnsure) => {
     if (!config.appwriteClient) {
         throw new Error("Appwrite client is not initialized in the config");

package/dist/examples/yamlTerminologyExample.js

@@ -7,8 +7,8 @@
  * 3. Validate terminology consistency
  * 4. Migrate between formats
  */
-import { collectionToYaml, generateYamlTemplate, generateExampleYamls, convertTerminology, normalizeYamlData, usesTableTerminology } from "../utils/yamlConverter.js";
-import { createYamlLoader } from "../utils/yamlLoader.js";
+import { collectionToYaml, generateYamlTemplate, generateExampleYamls, convertTerminology, normalizeYamlData, usesTableTerminology } from "appwrite-utils-helpers";
+import { createYamlLoader } from "appwrite-utils-helpers";
 import { YamlImportIntegration } from "../migrations/yaml/YamlImportIntegration.js";
 import { createImportSchemas } from "../migrations/yaml/generateImportSchemas.js";
 import { CollectionCreateSchema } from "appwrite-utils";

package/dist/functions/deployments.d.ts

@@ -1,4 +1,4 @@
 import { Client, type Models } from "node-appwrite";
 import { type AppwriteFunction } from "appwrite-utils";
 export declare const deployFunction: (client: Client, functionId: string, codePath: string, activate?: boolean, entrypoint?: string, commands?: string, ignored?: string[]) => Promise<Models.Deployment>;
-export declare const deployLocalFunction: (client: Client, functionName: string, functionConfig: AppwriteFunction, functionPath?: string) => Promise<Models.Deployment>;
+export declare const deployLocalFunction: (client: Client, functionName: string, functionConfig: AppwriteFunction, functionPath?: string, configDirPath?: string) => Promise<Models.Deployment>;