appwrite-utils-cli 1.11.0 → 1.12.0

package/dist/collections/methods.js

@@ -0,0 +1,605 @@
+import { Databases, ID, Permission, Query, } from "node-appwrite";
+import { getAdapterFromConfig } from "appwrite-utils-helpers";
+import { nameToIdMapping, processQueue, queuedOperations, clearProcessingState, isCollectionProcessed, markCollectionProcessed, enqueueOperation } from "../shared/operationQueue.js";
+import { logger, SchemaGenerator } from "appwrite-utils-helpers";
+// Legacy attribute/index helpers removed in favor of unified adapter path
+import { isNull, isUndefined, isNil, isPlainObject, isString, } from "es-toolkit";
+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
+export { wipeDatabase, wipeCollection, wipeAllTables, wipeTableRows, } from "./wipeOperations.js";
+// Re-export transfer operations
+export { transferDocumentsBetweenDbsLocalToLocal, transferDocumentsBetweenDbsLocalToRemote, } from "./transferOperations.js";
+export const documentExists = async (db, dbId, targetCollectionId, toCreateObject) => {
+    const collection = await (isLegacyDatabases(db) ?
+        db.getCollection(dbId, targetCollectionId) :
+        db.getTable({ databaseId: dbId, tableId: targetCollectionId }));
+    const attributes = collection.attributes;
+    let arrayTypeAttributes = attributes
+        .filter((attribute) => attribute.array === true)
+        .map((attribute) => attribute.key);
+    const isJsonString = (str) => {
+        try {
+            const json = JSON.parse(str);
+            return typeof json === "object" && json !== null;
+        }
+        catch (e) {
+            return false;
+        }
+    };
+    // Convert object to entries and filter
+    const validEntries = Object.entries(toCreateObject).filter(([key, value]) => !arrayTypeAttributes.includes(key) &&
+        !key.startsWith("$") &&
+        !isNull(value) &&
+        !isUndefined(value) &&
+        !isNil(value) &&
+        !isPlainObject(value) &&
+        !Array.isArray(value) &&
+        !(isString(value) && isJsonString(value)) &&
+        (isString(value) ? value.length < 4096 && value.length > 0 : true));
+    // Map and filter valid entries
+    const validMappedEntries = validEntries
+        .map(([key, value]) => [
+        key,
+        isString(value) || typeof value === "number" || typeof value === "boolean"
+            ? value
+            : null,
+    ])
+        .filter(([key, value]) => !isNull(value) && isString(key))
+        .slice(0, 25);
+    // 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 (isLegacyDatabases(db) ?
+        db.listDocuments(dbId, targetCollectionId, validQueryParams) :
+        db.listRows({ databaseId: dbId, tableId: targetCollectionId, queries: validQueryParams }));
+    const items = isLegacyDatabases(db) ? result.documents : (result.rows || result.documents);
+    return items?.[0] || null;
+};
+export const checkForCollection = async (db, dbId, collection) => {
+    try {
+        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 = isLegacy ? response.collections : (response.tables || response.collections);
+        if (items && items.length > 0) {
+            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 ${entityType.toLowerCase()} found with name: ${collection.name}`, { prefix: entityType + "s" });
+            return null;
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        MessageFormatter.error(`Error checking for collection: ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Collections" });
+        logger.error('Collection check failed', {
+            collectionName: collection.name,
+            dbId,
+            error: errorMessage,
+            operation: 'checkForCollection'
+        });
+        return null;
+    }
+};
+// 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(`${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 ${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 = isLegacy ? collectionsPulled.collections : (collectionsPulled.tables || collectionsPulled.collections);
+        if ((collectionsPulled.total || items?.length) > 0) {
+            const collection = items[0];
+            MessageFormatter.info(`${entityType} found: ${collection.$id}`, { prefix: entityType + "s" });
+            nameToIdMapping.set(collectionName, collection.$id);
+            return collection;
+        }
+        else {
+            MessageFormatter.warning(`${entityType} not found by name: ${collectionName}`, { prefix: entityType + "s" });
+            return undefined;
+        }
+    }
+};
+export const generateSchemas = async (config, appwriteFolderPath) => {
+    const schemaGenerator = new SchemaGenerator(config, appwriteFolderPath);
+    await schemaGenerator.generateSchemas();
+};
+export const createOrUpdateCollections = async (database, databaseId, config, deletedCollections, selectedCollections = []) => {
+    // Clear processing state at the start of a new operation
+    clearProcessingState();
+    // Always use adapter path (LegacyAdapter translates when pre-1.8)
+    const { adapter } = await getAdapterFromConfig(config);
+    await createOrUpdateCollectionsViaAdapter(adapter, databaseId, config, deletedCollections, selectedCollections);
+};
+// New: Adapter-based implementation for TablesDB with state management
+export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, config, deletedCollections, selectedCollections = []) => {
+    const collectionsToProcess = selectedCollections.length > 0 ? selectedCollections : (config.collections || []);
+    if (!collectionsToProcess || collectionsToProcess.length === 0)
+        return;
+    const usedIds = new Set();
+    MessageFormatter.info(`Processing ${collectionsToProcess.length} tables via adapter with intelligent state management`, { prefix: "Tables" });
+    // Helpers for attribute operations through adapter
+    const createAttr = async (tableId, attr) => {
+        const params = mapToCreateAttributeParams(attr, { databaseId, tableId });
+        await adapter.createAttribute(params);
+        await delay(150);
+    };
+    const updateAttr = async (tableId, attr) => {
+        const params = mapToUpdateAttributeParams(attr, { databaseId, tableId });
+        await adapter.updateAttribute(params);
+        await delay(150);
+    };
+    // Local queue for unresolved relationships
+    const relQueue = [];
+    for (const collection of collectionsToProcess) {
+        const { attributes, indexes, ...collectionData } = collection;
+        // Check if this table has already been processed in this session (per database)
+        if (collectionData.$id && isCollectionProcessed(collectionData.$id, databaseId)) {
+            MessageFormatter.info(`Table '${collectionData.name}' already processed, skipping`, { prefix: "Tables" });
+            continue;
+        }
+        // Prepare permissions as strings (reuse Permission helper)
+        const permissions = [];
+        if (collection.$permissions && collection.$permissions.length > 0) {
+            for (const p of collection.$permissions) {
+                if (typeof p === 'string')
+                    permissions.push(p);
+                else {
+                    switch (p.permission) {
+                        case 'read':
+                            permissions.push(Permission.read(p.target));
+                            break;
+                        case 'create':
+                            permissions.push(Permission.create(p.target));
+                            break;
+                        case 'update':
+                            permissions.push(Permission.update(p.target));
+                            break;
+                        case 'delete':
+                            permissions.push(Permission.delete(p.target));
+                            break;
+                        case 'write':
+                            permissions.push(Permission.write(p.target));
+                            break;
+                        default: break;
+                    }
+                }
+            }
+        }
+        // Find existing table — prefer lookup by ID (if provided), then by name
+        let table;
+        let tableId;
+        // 1) Try by explicit $id first (handles rename scenarios)
+        if (collectionData.$id) {
+            try {
+                const byId = await adapter.getTable({ databaseId, tableId: collectionData.$id });
+                table = byId.data || byId.tables?.[0];
+                if (table?.$id) {
+                    MessageFormatter.info(`Found existing table by ID: ${table.$id}`, { prefix: 'Tables' });
+                }
+            }
+            catch {
+                // Not found by ID; fall back to name lookup
+            }
+        }
+        // 2) If not found by ID, try by name
+        if (!table) {
+            const list = await adapter.listTables({ databaseId, queries: [Query.equal('name', collectionData.name)] });
+            const items = list.tables || [];
+            table = items[0];
+            if (table?.$id) {
+                // If local has $id that differs from remote, prefer remote (IDs are immutable)
+                if (collectionData.$id && collectionData.$id !== table.$id) {
+                    MessageFormatter.warning(`Config $id '${collectionData.$id}' differs from existing table ID '${table.$id}'. Using existing table.`, { prefix: 'Tables' });
+                }
+            }
+        }
+        if (!table) {
+            // Determine ID (prefer provided $id or re-use deleted one)
+            let foundColl = deletedCollections?.find((coll) => coll.collectionName.toLowerCase().trim().replace(" ", "") === collectionData.name.toLowerCase().trim().replace(" ", ""));
+            if (collectionData.$id)
+                tableId = collectionData.$id;
+            else if (foundColl && !usedIds.has(foundColl.collectionId))
+                tableId = foundColl.collectionId;
+            else
+                tableId = ID.unique();
+            usedIds.add(tableId);
+            const res = await adapter.createTable({
+                databaseId,
+                id: tableId,
+                name: collectionData.name,
+                permissions,
+                documentSecurity: !!collectionData.documentSecurity,
+                enabled: collectionData.enabled !== false
+            });
+            table = res.data || res;
+            nameToIdMapping.set(collectionData.name, tableId);
+        }
+        else {
+            tableId = table.$id;
+            await adapter.updateTable({
+                databaseId,
+                id: tableId,
+                name: collectionData.name,
+                permissions,
+                documentSecurity: !!collectionData.documentSecurity,
+                enabled: collectionData.enabled !== false
+            });
+            // Cache the existing table ID
+            nameToIdMapping.set(collectionData.name, tableId);
+        }
+        // Add small delay after table create/update
+        await delay(250);
+        // Create/Update attributes: non-relationship first using enhanced planning
+        const nonRel = (attributes || []).filter((a) => a.type !== 'relationship');
+        if (nonRel.length > 0) {
+            // Fetch existing columns once
+            const tableInfo = await adapter.getTable({ databaseId, tableId });
+            const existingCols = tableInfo.data?.columns || tableInfo.data?.attributes || [];
+            // Plan with icons
+            const plan = diffColumnsDetailed(nonRel, existingCols);
+            const plus = plan.toCreate.map((a) => a.key);
+            const plusminus = plan.toUpdate.map((u) => u.attribute.key);
+            const minus = plan.toRecreate.map((r) => r.newAttribute.key);
+            const skip = plan.unchanged;
+            // Compute deletions (remote extras not present locally)
+            const desiredKeysForDelete = new Set((attributes || []).map((a) => a.key));
+            const extraRemoteKeys = (existingCols || [])
+                .map((c) => c?.key)
+                .filter((k) => !!k && !desiredKeysForDelete.has(k));
+            const parts = [];
+            if (plus.length)
+                parts.push(`➕  ${plus.length} (${plus.join(', ')})`);
+            if (plusminus.length)
+                parts.push(`🔧  ${plusminus.length} (${plusminus.join(', ')})`);
+            if (minus.length)
+                parts.push(`♻️  ${minus.length} (${minus.join(', ')})`);
+            if (skip.length)
+                parts.push(`⏭️  ${skip.length}`);
+            parts.push(`🗑️  ${extraRemoteKeys.length}${extraRemoteKeys.length ? ` (${extraRemoteKeys.join(', ')})` : ''}`);
+            MessageFormatter.info(`Plan → ${parts.join('  |  ') || 'no changes'}`, { prefix: 'Attributes' });
+            // Execute
+            const colResults = await executeColumnOperations(adapter, databaseId, tableId, plan);
+            if (colResults.success.length > 0) {
+                MessageFormatter.success(`Processed ${colResults.success.length} ops`, { prefix: 'Attributes' });
+            }
+            if (colResults.errors.length > 0) {
+                MessageFormatter.error(`${colResults.errors.length} attribute operations failed:`, undefined, { prefix: 'Attributes' });
+                for (const err of colResults.errors) {
+                    MessageFormatter.error(`  ${err.column}: ${err.error}`, undefined, { prefix: 'Attributes' });
+                }
+            }
+            MessageFormatter.info(`Summary → ➕  ${plan.toCreate.length}  |  🔧  ${plan.toUpdate.length}  |  ♻️  ${plan.toRecreate.length}  |  ⏭️  ${plan.unchanged.length}`, { prefix: 'Attributes' });
+        }
+        // Relationship attributes — resolve relatedCollection to ID, then diff and create/update with recreate support
+        const relsAll = (attributes || []).filter((a) => a.type === 'relationship');
+        if (relsAll.length > 0) {
+            const relsResolved = [];
+            const relsDeferred = [];
+            // Resolve related collections (names -> IDs) using cache or lookup.
+            // If not resolvable yet (target table created later in the same push), queue for later.
+            for (const attr of relsAll) {
+                const relNameOrId = attr.relatedCollection;
+                if (!relNameOrId)
+                    continue;
+                let relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
+                let resolved = false;
+                if (nameToIdMapping.has(relNameOrId)) {
+                    resolved = true;
+                }
+                else {
+                    // Try resolve by name
+                    try {
+                        const relList = await adapter.listTables({ databaseId, queries: [Query.equal('name', relNameOrId)] });
+                        const relItems = relList.tables || [];
+                        if (relItems[0]?.$id) {
+                            relId = relItems[0].$id;
+                            nameToIdMapping.set(relNameOrId, relId);
+                            resolved = true;
+                        }
+                    }
+                    catch { }
+                    // If the relNameOrId looks like an ID but isn't resolved yet, attempt a direct get
+                    if (!resolved && relNameOrId && relNameOrId.length >= 10) {
+                        try {
+                            const probe = await adapter.getTable({ databaseId, tableId: relNameOrId });
+                            if (probe.data?.$id) {
+                                nameToIdMapping.set(relNameOrId, relNameOrId);
+                                relId = relNameOrId;
+                                resolved = true;
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                if (resolved && relId && typeof relId === 'string') {
+                    attr.relatedCollection = relId;
+                    relsResolved.push(attr);
+                }
+                else {
+                    // Defer until related table exists; queue a surgical operation
+                    enqueueOperation({
+                        type: 'attribute',
+                        collectionId: tableId,
+                        attribute: attr,
+                        dependencies: [relNameOrId]
+                    });
+                    relsDeferred.push(attr);
+                }
+            }
+            // Compute a detailed plan for immediately resolvable relationships
+            const tableInfo2 = await adapter.getTable({ databaseId, tableId });
+            const existingCols2 = tableInfo2.data?.columns || tableInfo2.data?.attributes || [];
+            const relPlan = diffColumnsDetailed(relsResolved, existingCols2);
+            // Relationship plan with icons (includes recreates)
+            {
+                const parts = [];
+                if (relPlan.toCreate.length)
+                    parts.push(`➕  ${relPlan.toCreate.length} (${relPlan.toCreate.map((a) => a.key).join(', ')})`);
+                if (relPlan.toUpdate.length)
+                    parts.push(`🔧  ${relPlan.toUpdate.length} (${relPlan.toUpdate.map((u) => u.attribute?.key ?? u.key).join(', ')})`);
+                if (relPlan.toRecreate.length)
+                    parts.push(`♻️  ${relPlan.toRecreate.length} (${relPlan.toRecreate.map((r) => r.newAttribute?.key ?? r?.key).join(', ')})`);
+                if (relPlan.unchanged.length)
+                    parts.push(`⏭️  ${relPlan.unchanged.length}`);
+                MessageFormatter.info(`Plan → ${parts.join('  |  ') || 'no changes'}`, { prefix: 'Relationships' });
+            }
+            // Execute plan using the same operation executor to properly handle deletes/recreates
+            const relResults = await executeColumnOperations(adapter, databaseId, tableId, relPlan);
+            if (relResults.success.length > 0) {
+                const totalRelationships = relPlan.toCreate.length + relPlan.toUpdate.length + relPlan.toRecreate.length + relPlan.unchanged.length;
+                const activeRelationships = relPlan.toCreate.length + relPlan.toUpdate.length + relPlan.toRecreate.length;
+                if (relResults.success.length !== activeRelationships) {
+                    // Show both counts when they differ (usually due to recreations)
+                    MessageFormatter.success(`Processed ${relResults.success.length} operations for ${activeRelationships} relationship${activeRelationships === 1 ? '' : 's'}`, { prefix: 'Relationships' });
+                }
+                else {
+                    MessageFormatter.success(`Processed ${relResults.success.length} relationship${relResults.success.length === 1 ? '' : 's'}`, { prefix: 'Relationships' });
+                }
+            }
+            if (relResults.errors.length > 0) {
+                MessageFormatter.error(`${relResults.errors.length} relationship operations failed:`, undefined, { prefix: 'Relationships' });
+                for (const err of relResults.errors) {
+                    MessageFormatter.error(`  ${err.column}: ${err.error}`, undefined, { prefix: 'Relationships' });
+                }
+            }
+            if (relsDeferred.length > 0) {
+                MessageFormatter.info(`Deferred ${relsDeferred.length} relationship(s) until related tables become available`, { prefix: 'Relationships' });
+            }
+        }
+        // Wait for all attributes to become available before creating indexes
+        const allAttrKeys = [
+            ...nonRel.map((a) => a.key),
+            ...relsAll.filter((a) => a.relatedCollection).map((a) => a.key)
+        ];
+        if (allAttrKeys.length > 0) {
+            for (const attrKey of allAttrKeys) {
+                const maxWait = 60000; // 60 seconds
+                const startTime = Date.now();
+                let lastStatus = '';
+                while (Date.now() - startTime < maxWait) {
+                    try {
+                        const tableData = await adapter.getTable({ databaseId, tableId });
+                        const attrs = tableData.data?.columns || tableData.data?.attributes || [];
+                        const attr = attrs.find((a) => a.key === attrKey);
+                        if (attr) {
+                            if (attr.status === 'available') {
+                                break; // Attribute is ready
+                            }
+                            if (attr.status === 'failed' || attr.status === 'stuck') {
+                                throw new Error(`Attribute ${attrKey} failed to create: ${attr.error || 'unknown error'}`);
+                            }
+                            // Still processing, continue waiting
+                            lastStatus = attr.status;
+                        }
+                        await delay(2000); // Check every 2 seconds
+                    }
+                    catch (e) {
+                        // If we can't check status, assume it's processing and continue
+                        await delay(2000);
+                    }
+                }
+                // Timeout check
+                if (Date.now() - startTime >= maxWait) {
+                    MessageFormatter.warning(`Attribute ${attrKey} did not become available within ${maxWait / 1000}s (last status: ${lastStatus}). Proceeding anyway.`, { prefix: 'Attributes' });
+                }
+            }
+        }
+        // Index management: create/update indexes using clean adapter-based system
+        const localTableConfig = config.collections?.find(c => c.name === collectionData.name || c.$id === collectionData.$id);
+        const idxs = (localTableConfig?.indexes ?? indexes ?? []);
+        // Create/update indexes with proper planning and execution
+        await createOrUpdateIndexesViaAdapter(adapter, databaseId, tableId, idxs, indexes);
+        // Handle obsolete index deletions
+        const desiredIndexKeys = new Set((indexes || []).map((i) => i.key));
+        await deleteObsoleteIndexesViaAdapter(adapter, databaseId, tableId, desiredIndexKeys);
+        // 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) => {
+                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' });
+                const deleted = [];
+                const errors = [];
+                for (const key of toDelete) {
+                    try {
+                        // Drop any indexes that reference this attribute to avoid server errors
+                        try {
+                            const idxRes = await adapter.listIndexes({ databaseId, tableId });
+                            const ilist = idxRes.data || idxRes.indexes || [];
+                            for (const idx of ilist) {
+                                const attrs = Array.isArray(idx.attributes)
+                                    ? idx.attributes
+                                    : (Array.isArray(idx.columns) ? idx.columns : []);
+                                if (attrs.includes(key)) {
+                                    MessageFormatter.info(`🗑️  Deleting index '${idx.key}' referencing '${key}'`, { prefix: 'Indexes' });
+                                    await adapter.deleteIndex({ databaseId, tableId, key: idx.key });
+                                    await delay(500);
+                                }
+                            }
+                        }
+                        catch { }
+                        await adapter.deleteAttribute({ databaseId, tableId, key });
+                        // Wait briefly for deletion to settle
+                        const start = Date.now();
+                        const maxWaitMs = 60000;
+                        while (Date.now() - start < maxWaitMs) {
+                            try {
+                                const tinfo = await adapter.getTable({ databaseId, tableId });
+                                const cols = tinfo.data?.columns || tinfo.data?.attributes || [];
+                                const found = cols.find((c) => c.key === key);
+                                if (!found)
+                                    break;
+                                if (found.status && found.status !== 'deleting')
+                                    break;
+                            }
+                            catch { }
+                            await delay(1000);
+                        }
+                        deleted.push(key);
+                    }
+                    catch (e) {
+                        errors.push({ key, error: e?.message || String(e) });
+                    }
+                }
+                if (deleted.length) {
+                    MessageFormatter.success(`Deleted ${deleted.length} attributes: ${deleted.join(', ')}`, { prefix: 'Attributes' });
+                }
+                if (errors.length) {
+                    MessageFormatter.error(`${errors.length} deletions failed`, undefined, { prefix: 'Attributes' });
+                    errors.forEach(er => MessageFormatter.error(`  ${er.key}: ${er.error}`, undefined, { prefix: 'Attributes' }));
+                }
+            }
+            else {
+                MessageFormatter.info(`Plan → 🗑️  0`, { prefix: 'Attributes' });
+            }
+        }
+        catch (e) {
+            MessageFormatter.warning(`Could not evaluate deletions: ${e?.message || e}`, { prefix: 'Attributes' });
+        }
+        // Mark this table as fully processed for this database to prevent re-processing in the same DB only
+        markCollectionProcessed(tableId, collectionData.name, databaseId);
+    }
+    // Process queued relationships once mapping likely populated
+    if (relQueue.length > 0) {
+        MessageFormatter.info(`🔧 Processing ${relQueue.length} queued relationship attributes for tables`, { prefix: "Tables" });
+        for (const { tableId, attr } of relQueue) {
+            const relNameOrId = attr.relatedCollection;
+            if (!relNameOrId)
+                continue;
+            const relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
+            if (relId) {
+                attr.relatedCollection = relId;
+                try {
+                    await adapter.createAttribute({
+                        databaseId,
+                        tableId,
+                        key: attr.key,
+                        type: attr.type,
+                        size: attr.size,
+                        required: !!attr.required,
+                        default: attr.xdefault,
+                        array: !!attr.array,
+                        min: attr.min,
+                        max: attr.max,
+                        elements: attr.elements,
+                        relatedCollection: relId,
+                        relationType: attr.relationType,
+                        twoWay: attr.twoWay,
+                        twoWayKey: attr.twoWayKey,
+                        onDelete: attr.onDelete,
+                        side: attr.side
+                    });
+                    await delay(150);
+                    MessageFormatter.info(`✅ Successfully processed queued relationship: ${attr.key}`, { prefix: "Tables" });
+                }
+                catch (e) {
+                    MessageFormatter.error(`Failed queued relationship ${attr.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' });
+                }
+            }
+            else {
+                MessageFormatter.warning(`Could not resolve relationship ${attr.key} -> ${relNameOrId}`, { prefix: "Tables" });
+            }
+        }
+    }
+    // Process any remaining queued operations to complete relationship sync
+    try {
+        MessageFormatter.info(`🔄 Processing final operation queue for database ${databaseId}`, { prefix: "Tables" });
+        await processQueue(adapter, databaseId);
+        MessageFormatter.info(`✅ Operation queue processing completed`, { prefix: "Tables" });
+    }
+    catch (error) {
+        MessageFormatter.error(`Failed to process operation queue`, error instanceof Error ? error : new Error(String(error)), { prefix: 'Tables' });
+    }
+};
+export const generateMockData = async (database, databaseId, configCollections) => {
+    for (const { collection, mockFunction } of configCollections) {
+        if (mockFunction) {
+            MessageFormatter.progress(`Generating mock data for collection: ${collection.name}`, { prefix: "Mock Data" });
+            const mockData = mockFunction();
+            for (const data of mockData) {
+                await database.createDocument(databaseId, collection.$id, ID.unique(), data);
+            }
+        }
+    }
+};
+export const fetchAllCollections = async (dbId, database) => {
+    MessageFormatter.progress(`Fetching all collections for database ID: ${dbId}`, { prefix: "Collections" });
+    let collections = [];
+    let moreCollections = true;
+    let lastCollectionId;
+    while (moreCollections) {
+        const queries = [Query.limit(500)];
+        if (lastCollectionId) {
+            queries.push(Query.cursorAfter(lastCollectionId));
+        }
+        const response = await tryAwaitWithRetry(async () => await database.listCollections(dbId, queries));
+        collections = collections.concat(response.collections);
+        moreCollections = response.collections.length === 500;
+        if (moreCollections) {
+            lastCollectionId =
+                response.collections[response.collections.length - 1].$id;
+        }
+    }
+    MessageFormatter.success(`Fetched a total of ${collections.length} collections`, { prefix: "Collections" });
+    return collections;
+};