appwrite-utils-cli 1.3.5 → 1.4.1

package/dist/adapters/TablesDBAdapter.js

@@ -0,0 +1,302 @@
+/**
+ * TablesDBAdapter - Native TablesDB API Implementation
+ *
+ * This adapter provides direct access to the new Appwrite TablesDB API
+ * without any translation layer. It uses object notation parameters
+ * and returns Models.Row instead of Models.Document.
+ */
+import { BaseAdapter, AdapterError } from './DatabaseAdapter.js';
+/**
+ * TablesDBAdapter implementation for native TablesDB API
+ */
+export class TablesDBAdapter extends BaseAdapter {
+    tablesDB;
+    constructor(client) {
+        super(client, 'tablesdb');
+        // Assuming TablesDB service is available on the client
+        this.tablesDB = client.tablesDB || client;
+    }
+    // Row (Document) Operations
+    async listRows(params) {
+        try {
+            const result = await this.tablesDB.listRows(params);
+            return {
+                data: result.rows,
+                rows: result.rows,
+                total: result.total
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to list rows: ${error instanceof Error ? error.message : 'Unknown error'}`, 'LIST_ROWS_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async createRow(params) {
+        try {
+            const result = await this.tablesDB.createRow(params);
+            return {
+                data: result,
+                rows: [result]
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to create row: ${error instanceof Error ? error.message : 'Unknown error'}`, 'CREATE_ROW_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async updateRow(params) {
+        try {
+            const result = await this.tablesDB.updateRow(params);
+            return {
+                data: result,
+                rows: [result]
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to update row: ${error instanceof Error ? error.message : 'Unknown error'}`, 'UPDATE_ROW_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async deleteRow(params) {
+        try {
+            const result = await this.tablesDB.deleteRow(params);
+            return { data: result };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to delete row: ${error instanceof Error ? error.message : 'Unknown error'}`, 'DELETE_ROW_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async getRow(params) {
+        try {
+            const result = await this.tablesDB.getRow(params);
+            return {
+                data: result,
+                rows: [result]
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to get row: ${error instanceof Error ? error.message : 'Unknown error'}`, 'GET_ROW_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    // Table (Collection) Operations
+    async listTables(params) {
+        try {
+            const result = await this.tablesDB.listTables(params);
+            return {
+                data: result.tables,
+                tables: result.tables,
+                total: result.total
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to list tables: ${error instanceof Error ? error.message : 'Unknown error'}`, 'LIST_TABLES_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async createTable(params) {
+        try {
+            const result = await this.tablesDB.createTable(params);
+            return {
+                data: result,
+                tables: [result]
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to create table: ${error instanceof Error ? error.message : 'Unknown error'}`, 'CREATE_TABLE_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async updateTable(params) {
+        try {
+            const result = await this.tablesDB.updateTable(params);
+            return {
+                data: result,
+                tables: [result]
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to update table: ${error instanceof Error ? error.message : 'Unknown error'}`, 'UPDATE_TABLE_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async deleteTable(params) {
+        try {
+            const result = await this.tablesDB.deleteTable(params);
+            return { data: result };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to delete table: ${error instanceof Error ? error.message : 'Unknown error'}`, 'DELETE_TABLE_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async getTable(params) {
+        try {
+            const result = await this.tablesDB.getTable(params);
+            return {
+                data: result,
+                tables: [result]
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to get table: ${error instanceof Error ? error.message : 'Unknown error'}`, 'GET_TABLE_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    // Index Operations
+    async listIndexes(params) {
+        try {
+            const result = await this.tablesDB.listIndexes(params);
+            return {
+                data: result.indexes,
+                total: result.total
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to list indexes: ${error instanceof Error ? error.message : 'Unknown error'}`, 'LIST_INDEXES_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async createIndex(params) {
+        try {
+            const result = await this.tablesDB.createIndex(params);
+            return { data: result };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to create index: ${error instanceof Error ? error.message : 'Unknown error'}`, 'CREATE_INDEX_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async deleteIndex(params) {
+        try {
+            const result = await this.tablesDB.deleteIndex(params);
+            return { data: result };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to delete index: ${error instanceof Error ? error.message : 'Unknown error'}`, 'DELETE_INDEX_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    // Attribute Operations
+    async createAttribute(params) {
+        try {
+            // TablesDB may have different method names for attribute operations
+            const result = await this.tablesDB.createAttribute(params);
+            return { data: result };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to create attribute: ${error instanceof Error ? error.message : 'Unknown error'}`, 'CREATE_ATTRIBUTE_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async updateAttribute(params) {
+        try {
+            const result = await this.tablesDB.updateAttribute(params);
+            return { data: result };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to update attribute: ${error instanceof Error ? error.message : 'Unknown error'}`, 'UPDATE_ATTRIBUTE_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async deleteAttribute(params) {
+        try {
+            const result = await this.tablesDB.deleteAttribute(params);
+            return { data: result };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to delete attribute: ${error instanceof Error ? error.message : 'Unknown error'}`, 'DELETE_ATTRIBUTE_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    // Bulk Operations (Native TablesDB Support)
+    async bulkCreateRows(params) {
+        try {
+            const result = await this.tablesDB.bulkCreateRows(params);
+            return {
+                data: result.rows,
+                rows: result.rows,
+                total: result.rows?.length || 0
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to bulk create rows: ${error instanceof Error ? error.message : 'Unknown error'}`, 'BULK_CREATE_ROWS_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async bulkUpsertRows(params) {
+        try {
+            const result = await this.tablesDB.bulkUpsertRows(params);
+            return {
+                data: result.rows,
+                rows: result.rows,
+                total: result.rows?.length || 0
+            };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to bulk upsert rows: ${error instanceof Error ? error.message : 'Unknown error'}`, 'BULK_UPSERT_ROWS_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    async bulkDeleteRows(params) {
+        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);
+        }
+    }
+    // Metadata and Capabilities
+    getMetadata() {
+        return {
+            apiMode: 'tablesdb',
+            terminology: {
+                container: 'table',
+                item: 'row',
+                service: 'TablesDB'
+            },
+            capabilities: {
+                bulkOperations: true,
+                advancedQueries: true,
+                realtime: true,
+                transactions: true // TablesDB may support transactions
+            }
+        };
+    }
+    supportsBulkOperations() {
+        return true; // TablesDB natively supports bulk operations
+    }
+    // Advanced TablesDB Features
+    /**
+     * Execute a transaction (if supported by TablesDB)
+     */
+    async executeTransaction(operations) {
+        if (!this.tablesDB.transaction) {
+            throw new AdapterError('Transactions are not supported in this TablesDB version', 'TRANSACTIONS_NOT_SUPPORTED');
+        }
+        try {
+            const result = await this.tablesDB.transaction(operations);
+            return { data: result };
+        }
+        catch (error) {
+            throw new AdapterError(`Transaction failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 'TRANSACTION_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Subscribe to real-time updates (if supported)
+     */
+    subscribeToTable(params, callback) {
+        if (!this.tablesDB.subscribe) {
+            throw new AdapterError('Real-time subscriptions are not supported', 'REALTIME_NOT_SUPPORTED');
+        }
+        try {
+            return this.tablesDB.subscribe(`databases.${params.databaseId}.tables.${params.tableId}.rows`, callback);
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to subscribe to table: ${error instanceof Error ? error.message : 'Unknown error'}`, 'SUBSCRIPTION_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get table statistics (if available in TablesDB)
+     */
+    async getTableStats(params) {
+        try {
+            if (!this.tablesDB.getTableStats) {
+                // Fallback to basic table info
+                return this.getTable(params);
+            }
+            const result = await this.tablesDB.getTableStats(params);
+            return { data: result };
+        }
+        catch (error) {
+            throw new AdapterError(`Failed to get table stats: ${error instanceof Error ? error.message : 'Unknown error'}`, 'GET_TABLE_STATS_FAILED', error instanceof Error ? error : undefined);
+        }
+    }
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Adapters Module - Unified Database API for Appwrite
+ *
+ * This module exports all adapter classes and utilities for working with
+ * both legacy Appwrite (collections/documents) and TablesDB (tables/rows) APIs.
+ */
+export { AdapterFactory, type AdapterFactoryConfig, type AdapterFactoryResult } from './AdapterFactory.js';
+export { 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, BaseAdapter } from './DatabaseAdapter.js';
+export { TablesDBAdapter } from './TablesDBAdapter.js';
+export { LegacyAdapter } from './LegacyAdapter.js';
+export { createDatabaseAdapter, getApiCapabilities } from './AdapterFactory.js';

package/dist/adapters/index.js

@@ -0,0 +1,12 @@
+/**
+ * Adapters Module - Unified Database API for Appwrite
+ *
+ * This module exports all adapter classes and utilities for working with
+ * both legacy Appwrite (collections/documents) and TablesDB (tables/rows) APIs.
+ */
+export { AdapterFactory } from './AdapterFactory.js';
+export { BaseAdapter } from './DatabaseAdapter.js';
+export { TablesDBAdapter } from './TablesDBAdapter.js';
+export { LegacyAdapter } from './LegacyAdapter.js';
+// Convenience exports
+export { createDatabaseAdapter, getApiCapabilities } from './AdapterFactory.js';

package/dist/collections/attributes.js

@@ -29,19 +29,19 @@ retryCount = 0, maxRetries = 5) => {
             }
             console.log(chalk.gray(`Attribute '${attributeKey}' status: ${attribute.status}`));
             switch (attribute.status) {
-                case 'available':
+                case "available":
                     console.log(chalk.green(`✅ Attribute '${attributeKey}' is now available`));
                     return true;
-                case 'failed':
+                case "failed":
                     console.log(chalk.red(`❌ Attribute '${attributeKey}' failed: ${attribute.error}`));
                     return false;
-                case 'stuck':
+                case "stuck":
                     console.log(chalk.yellow(`⚠️ Attribute '${attributeKey}' is stuck, will retry...`));
                     return false;
-                case 'processing':
+                case "processing":
                     // Continue waiting
                     break;
-                case 'deleting':
+                case "deleting":
                     console.log(chalk.yellow(`Attribute '${attributeKey}' is being deleted`));
                     break;
                 default:
@@ -254,7 +254,8 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
     // Relationship attribute logic with adjustments
     let collectionFoundViaRelatedCollection;
     let relatedCollectionId;
-    if (finalAttribute.type === "relationship") {
+    if (finalAttribute.type === "relationship" &&
+        finalAttribute.relatedCollection) {
         if (nameToIdMapping.has(finalAttribute.relatedCollection)) {
             relatedCollectionId = nameToIdMapping.get(finalAttribute.relatedCollection);
             try {
@@ -277,9 +278,9 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
                 nameToIdMapping.set(finalAttribute.relatedCollection, relatedCollectionId);
             }
         }
-        // Only queue relationship attributes that have dependencies
-        if (finalAttribute.type === "relationship" && !(relatedCollectionId && collectionFoundViaRelatedCollection)) {
-            // console.log(`Enqueueing operation for attribute: ${finalAttribute.key}`);
+        // ONLY queue relationship attributes that have actual unresolved dependencies
+        if (!(relatedCollectionId && collectionFoundViaRelatedCollection)) {
+            console.log(chalk.yellow(`⏳ Queueing relationship attribute '${finalAttribute.key}' - related collection '${finalAttribute.relatedCollection}' not found yet`));
             enqueueOperation({
                 type: "attribute",
                 collectionId: collection.$id,
@@ -302,35 +303,49 @@ export const createOrUpdateAttribute = async (db, dbId, collection, attribute) =
             else {
                 await tryAwaitWithRetry(async () => await db.updateStringAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
                     ? finalAttribute.xdefault
-                    : null));
+                    : null, finalAttribute.size));
             }
             break;
         case "integer":
             if (action === "create") {
                 if (finalAttribute.min &&
                     BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
-                    delete finalAttribute.min;
+                    finalAttribute.min = undefined;
                 }
                 if (finalAttribute.max &&
                     BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
-                    delete finalAttribute.max;
+                    finalAttribute.max = undefined;
                 }
-                await tryAwaitWithRetry(async () => await db.createIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min !== undefined ? finalAttribute.min : -2147483647, finalAttribute.max !== undefined ? finalAttribute.max : 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                const minValue = finalAttribute.min !== undefined && finalAttribute.min !== null
+                    ? parseInt(finalAttribute.min)
+                    : -9007199254740991;
+                const maxValue = finalAttribute.max !== undefined && finalAttribute.max !== null
+                    ? parseInt(finalAttribute.max)
+                    : 9007199254740991;
+                console.log(`DEBUG: Creating integer attribute '${finalAttribute.key}' with min=${minValue}, max=${maxValue}, minType=${typeof minValue}, maxType=${typeof maxValue}`);
+                await tryAwaitWithRetry(async () => await db.createIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, minValue, maxValue, finalAttribute.xdefault !== undefined && !finalAttribute.required
                     ? finalAttribute.xdefault
                     : null, finalAttribute.array || false));
             }
             else {
                 if (finalAttribute.min &&
                     BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
-                    delete finalAttribute.min;
+                    finalAttribute.min = undefined;
                 }
                 if (finalAttribute.max &&
                     BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
-                    delete finalAttribute.max;
+                    finalAttribute.max = undefined;
                 }
-                await tryAwaitWithRetry(async () => await db.updateIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.min !== undefined ? finalAttribute.min : -2147483647, finalAttribute.max !== undefined ? finalAttribute.max : 2147483647, finalAttribute.xdefault !== undefined && !finalAttribute.required
+                const minValue = finalAttribute.min !== undefined && finalAttribute.min !== null
+                    ? parseInt(finalAttribute.min)
+                    : 9007199254740991;
+                const maxValue = finalAttribute.max !== undefined && finalAttribute.max !== null
+                    ? parseInt(finalAttribute.max)
+                    : 9007199254740991;
+                console.log(`DEBUG: Updating integer attribute '${finalAttribute.key}' with min=${minValue}, max=${maxValue}, minType=${typeof minValue}, maxType=${typeof maxValue}`);
+                await tryAwaitWithRetry(async () => await db.updateIntegerAttribute(dbId, collection.$id, finalAttribute.key, finalAttribute.required || false, finalAttribute.xdefault !== undefined && !finalAttribute.required
                     ? finalAttribute.xdefault
-                    : null));
+                    : null, minValue, maxValue));
             }
             break;
         case "double":
@@ -469,15 +484,16 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
     }
     const existingAttributesMap = new Map();
     try {
+        const parsedAttributes = currentCollection.attributes.map((attr) => 
         // @ts-expect-error
-        const parsedAttributes = currentCollection.attributes.map((attr) => parseAttribute(attr));
-        parsedAttributes.forEach(attr => existingAttributesMap.set(attr.key, attr));
+        parseAttribute(attr));
+        parsedAttributes.forEach((attr) => existingAttributesMap.set(attr.key, attr));
     }
     catch (error) {
         console.log(chalk.yellow(`Warning: Could not parse existing attributes: ${error}`));
     }
     // Filter to only attributes that need processing (new or changed)
-    const attributesToProcess = attributes.filter(attribute => {
+    const attributesToProcess = attributes.filter((attribute) => {
         const existing = existingAttributesMap.get(attribute.key);
         if (!existing) {
             console.log(chalk.blue(`➕ New attribute: ${attribute.key}`));
@@ -500,7 +516,8 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
     let remainingAttributes = [...attributesToProcess];
     let overallRetryCount = 0;
     const maxOverallRetries = 3;
-    while (remainingAttributes.length > 0 && overallRetryCount < maxOverallRetries) {
+    while (remainingAttributes.length > 0 &&
+        overallRetryCount < maxOverallRetries) {
         const attributesToProcessThisRound = [...remainingAttributes];
         remainingAttributes = []; // Reset for next iteration
         console.log(chalk.blue(`\n=== Attempt ${overallRetryCount + 1}/${maxOverallRetries} - Processing ${attributesToProcessThisRound.length} attributes ===`));
@@ -544,7 +561,9 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
     }
     // If we get here, some attributes still failed after all retries
     if (attributesToProcess.length > 0) {
-        console.log(chalk.red(`\n❌ Failed to create ${attributesToProcess.length} attributes after ${maxOverallRetries} attempts: ${attributesToProcess.map(a => a.key).join(', ')}`));
+        console.log(chalk.red(`\n❌ Failed to create ${attributesToProcess.length} attributes after ${maxOverallRetries} attempts: ${attributesToProcess
+            .map((a) => a.key)
+            .join(", ")}`));
         console.log(chalk.red(`This may indicate a fundamental issue with the attribute definitions or Appwrite instance`));
         return false;
     }

package/dist/collections/methods.d.ts

@@ -1,8 +1,9 @@
 import { Databases, type Models } from "node-appwrite";
 import type { AppwriteConfig, CollectionCreate } from "appwrite-utils";
-export declare const documentExists: (db: Databases, dbId: string, targetCollectionId: string, toCreateObject: any) => Promise<Models.Document | null>;
-export declare const checkForCollection: (db: Databases, dbId: string, collection: Partial<CollectionCreate>) => Promise<Models.Collection | null>;
-export declare const fetchAndCacheCollectionByName: (db: Databases, dbId: string, collectionName: string) => Promise<Models.Collection | undefined>;
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+export declare const documentExists: (db: Databases | DatabaseAdapter, dbId: string, targetCollectionId: string, toCreateObject: any) => Promise<Models.Document | null>;
+export declare const checkForCollection: (db: Databases | DatabaseAdapter, dbId: string, collection: Partial<CollectionCreate>) => Promise<Models.Collection | null>;
+export declare const fetchAndCacheCollectionByName: (db: Databases | DatabaseAdapter, dbId: string, collectionName: string) => Promise<Models.Collection | undefined>;
 export declare const wipeDatabase: (database: Databases, databaseId: string) => Promise<{
     collectionId: string;
     collectionName: string;

package/dist/collections/methods.js

@@ -1,5 +1,6 @@
 import { Client, Databases, ID, Permission, Query, } from "node-appwrite";
-import { nameToIdMapping, processQueue } from "../shared/operationQueue.js";
+import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
+import { nameToIdMapping, processQueue, queuedOperations } from "../shared/operationQueue.js";
 import { createUpdateCollectionAttributes, createUpdateCollectionAttributesWithStatusCheck } from "./attributes.js";
 import { createOrUpdateIndexes, createOrUpdateIndexesWithStatusCheck } from "./indexes.js";
 import { SchemaGenerator } from "../shared/schemaGenerator.js";
@@ -9,7 +10,9 @@ import { MessageFormatter } from "../shared/messageFormatter.js";
 import { ProgressManager } from "../shared/progressManager.js";
 import chalk from "chalk";
 export const documentExists = async (db, dbId, targetCollectionId, toCreateObject) => {
-    const collection = await db.getCollection(dbId, targetCollectionId);
+    const collection = await (db instanceof Databases ?
+        db.getCollection(dbId, targetCollectionId) :
+        db.getTable({ databaseId: dbId, tableId: targetCollectionId }));
     const attributes = collection.attributes;
     let arrayTypeAttributes = attributes
         .filter((attribute) => attribute.array === true)
@@ -46,16 +49,22 @@ export const documentExists = async (db, dbId, targetCollectionId, toCreateObjec
     // Convert to Query parameters
     const validQueryParams = validMappedEntries.map(([key, value]) => Query.equal(key, value));
     // Execute the query with the validated and prepared parameters
-    const result = await db.listDocuments(dbId, targetCollectionId, validQueryParams);
-    return result.documents[0] || null;
+    const result = await (db instanceof Databases ?
+        db.listDocuments(dbId, targetCollectionId, validQueryParams) :
+        db.listRows({ databaseId: dbId, tableId: targetCollectionId, queries: validQueryParams }));
+    const items = db instanceof Databases ? result.documents : (result.rows || result.documents);
+    return items?.[0] || null;
 };
 export const checkForCollection = async (db, dbId, collection) => {
     try {
         MessageFormatter.progress(`Checking for collection with name: ${collection.name}`, { prefix: "Collections" });
-        const response = await tryAwaitWithRetry(async () => await db.listCollections(dbId, [Query.equal("name", collection.name)]));
-        if (response.collections.length > 0) {
-            MessageFormatter.info(`Collection found: ${response.collections[0].$id}`, { prefix: "Collections" });
-            return { ...collection, ...response.collections[0] };
+        const response = await tryAwaitWithRetry(async () => db instanceof Databases ?
+            await db.listCollections(dbId, [Query.equal("name", collection.name)]) :
+            await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collection.name)] }));
+        const items = db instanceof Databases ? response.collections : (response.tables || response.collections);
+        if (items && items.length > 0) {
+            MessageFormatter.info(`Collection found: ${items[0].$id}`, { prefix: "Collections" });
+            return { ...collection, ...items[0] };
         }
         else {
             MessageFormatter.info(`No collection found with name: ${collection.name}`, { prefix: "Collections" });
@@ -72,13 +81,18 @@ export const fetchAndCacheCollectionByName = async (db, dbId, collectionName) =>
     if (nameToIdMapping.has(collectionName)) {
         const collectionId = nameToIdMapping.get(collectionName);
         MessageFormatter.debug(`Collection found in cache: ${collectionId}`, undefined, { prefix: "Collections" });
-        return await tryAwaitWithRetry(async () => await db.getCollection(dbId, collectionId));
+        return await tryAwaitWithRetry(async () => db instanceof Databases ?
+            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 () => await db.listCollections(dbId, [Query.equal("name", collectionName)]));
-        if (collectionsPulled.total > 0) {
-            const collection = collectionsPulled.collections[0];
+        const collectionsPulled = await tryAwaitWithRetry(async () => db instanceof Databases ?
+            await db.listCollections(dbId, [Query.equal("name", collectionName)]) :
+            await db.listTables({ databaseId: dbId, queries: [Query.equal("name", collectionName)] }));
+        const items = db instanceof Databases ? collectionsPulled.collections : (collectionsPulled.tables || collectionsPulled.collections);
+        if ((collectionsPulled.total || items?.length) > 0) {
+            const collection = items[0];
             MessageFormatter.info(`Collection found: ${collection.$id}`, { prefix: "Collections" });
             nameToIdMapping.set(collectionName, collection.$id);
             return collection;
@@ -281,8 +295,14 @@ export const createOrUpdateCollections = async (database, databaseId, config, de
         // Add delay after creating indexes
         await delay(250);
     }
-    // Process any remaining tasks in the queue
-    await processQueue(database, databaseId);
+    // Process any remaining tasks in the queue (only if there are operations to process)
+    if (queuedOperations.length > 0) {
+        MessageFormatter.info(`Processing ${queuedOperations.length} queued operations (relationship dependencies)`, { prefix: "Collections" });
+        await processQueue(database, databaseId);
+    }
+    else {
+        MessageFormatter.info("No queued operations to process", { prefix: "Collections" });
+    }
 };
 export const generateMockData = async (database, databaseId, configCollections) => {
     for (const { collection, mockFunction } of configCollections) {