@njdamstra/appwrite-utils-cli 1.8.9

package/dist/collections/methods.js

@@ -0,0 +1,682 @@
+import { Databases, ID, Permission, Query, } from "node-appwrite";
+import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
+import { nameToIdMapping, processQueue, queuedOperations, clearProcessingState, isCollectionProcessed, markCollectionProcessed } from "../shared/operationQueue.js";
+import { logger } from "../shared/logging.js";
+// 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 { diffTableColumns, isIndexEqualToIndex, diffColumnsDetailed, executeColumnOperations } from "./tableOperations.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 {
+        MessageFormatter.progress(`Checking for collection with name: ${collection.name}`, { prefix: "Collections" });
+        const response = await tryAwaitWithRetry(async () => isLegacyDatabases(db) ?
+            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);
+        if (items && items.length > 0) {
+            MessageFormatter.info(`Collection found: ${items[0].$id}`, { prefix: "Collections" });
+            // 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" });
+            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) => {
+    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) ?
+            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) ?
+            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);
+        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;
+        }
+        else {
+            MessageFormatter.warning(`Collection not found by name: ${collectionName}`, { prefix: "Collections" });
+            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
+        const rels = (attributes || []).filter((a) => a.type === 'relationship');
+        if (rels.length > 0) {
+            for (const attr of rels) {
+                const relNameOrId = attr.relatedCollection;
+                if (!relNameOrId)
+                    continue;
+                let relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
+                if (!nameToIdMapping.has(relNameOrId)) {
+                    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);
+                        }
+                    }
+                    catch { }
+                }
+                if (relId && typeof relId === 'string')
+                    attr.relatedCollection = relId;
+            }
+            const tableInfo2 = await adapter.getTable({ databaseId, tableId });
+            const existingCols2 = tableInfo2.data?.columns || tableInfo2.data?.attributes || [];
+            const { toCreate: relCreate, toUpdate: relUpdate, unchanged: relUnchanged } = diffTableColumns(existingCols2, rels);
+            // Relationship plan with icons
+            {
+                const parts = [];
+                if (relCreate.length)
+                    parts.push(`➕  ${relCreate.length} (${relCreate.map((a) => a.key).join(', ')})`);
+                if (relUpdate.length)
+                    parts.push(`🔧  ${relUpdate.length} (${relUpdate.map((a) => a.key).join(', ')})`);
+                if (relUnchanged.length)
+                    parts.push(`⏭️  ${relUnchanged.length}`);
+                MessageFormatter.info(`Plan → ${parts.join('  |  ') || 'no changes'}`, { prefix: 'Relationships' });
+            }
+            for (const attr of relUpdate) {
+                try {
+                    await updateAttr(tableId, attr);
+                }
+                catch (e) {
+                    MessageFormatter.error(`Failed to update relationship ${attr.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' });
+                }
+            }
+            for (const attr of relCreate) {
+                try {
+                    await createAttr(tableId, attr);
+                }
+                catch (e) {
+                    MessageFormatter.error(`Failed to create relationship ${attr.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Attributes' });
+                }
+            }
+        }
+        // Wait for all attributes to become available before creating indexes
+        const allAttrKeys = [
+            ...nonRel.map((a) => a.key),
+            ...rels.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' });
+                }
+            }
+        }
+        // Prefer local config indexes, but fall back to collection's own indexes if no local config exists (TablesDB path)
+        const localTableConfig = config.collections?.find(c => c.name === collectionData.name || c.$id === collectionData.$id);
+        const idxs = (localTableConfig?.indexes ?? indexes ?? []);
+        // Compare with existing indexes and create/update accordingly with status checks
+        try {
+            const existingIdxRes = await adapter.listIndexes({ databaseId, tableId });
+            const existingIdx = existingIdxRes.data || existingIdxRes.indexes || [];
+            MessageFormatter.debug(`Existing index keys: ${existingIdx.map((i) => i.key).join(', ')}`, undefined, { prefix: 'Indexes' });
+            // Show a concise plan with icons before executing
+            const idxPlanPlus = [];
+            const idxPlanPlusMinus = [];
+            const idxPlanSkip = [];
+            for (const idx of idxs) {
+                const found = existingIdx.find((i) => i.key === idx.key);
+                if (found) {
+                    if (isIndexEqualToIndex(found, idx))
+                        idxPlanSkip.push(idx.key);
+                    else
+                        idxPlanPlusMinus.push(idx.key);
+                }
+                else
+                    idxPlanPlus.push(idx.key);
+            }
+            const planParts = [];
+            if (idxPlanPlus.length)
+                planParts.push(`➕  ${idxPlanPlus.length} (${idxPlanPlus.join(', ')})`);
+            if (idxPlanPlusMinus.length)
+                planParts.push(`🔧  ${idxPlanPlusMinus.length} (${idxPlanPlusMinus.join(', ')})`);
+            if (idxPlanSkip.length)
+                planParts.push(`⏭️  ${idxPlanSkip.length}`);
+            MessageFormatter.info(`Plan → ${planParts.join('  |  ') || 'no changes'}`, { prefix: 'Indexes' });
+            const created = [];
+            const updated = [];
+            const skipped = [];
+            for (const idx of idxs) {
+                const found = existingIdx.find((i) => i.key === idx.key);
+                if (found) {
+                    if (isIndexEqualToIndex(found, idx)) {
+                        MessageFormatter.info(`Index ${idx.key} unchanged`, { prefix: 'Indexes' });
+                        skipped.push(idx.key);
+                    }
+                    else {
+                        try {
+                            await adapter.deleteIndex({ databaseId, tableId, key: idx.key });
+                            await delay(100);
+                        }
+                        catch { }
+                        try {
+                            await adapter.createIndex({ databaseId, tableId, key: idx.key, type: idx.type, attributes: idx.attributes, orders: idx.orders || [] });
+                            updated.push(idx.key);
+                        }
+                        catch (e) {
+                            const msg = (e?.message || '').toString().toLowerCase();
+                            if (msg.includes('already exists')) {
+                                MessageFormatter.info(`Index ${idx.key} already exists after delete attempt, skipping`, { prefix: 'Indexes' });
+                                skipped.push(idx.key);
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                    }
+                }
+                else {
+                    try {
+                        await adapter.createIndex({ databaseId, tableId, key: idx.key, type: idx.type, attributes: idx.attributes, orders: idx.orders || [] });
+                        created.push(idx.key);
+                    }
+                    catch (e) {
+                        const msg = (e?.message || '').toString().toLowerCase();
+                        if (msg.includes('already exists')) {
+                            MessageFormatter.info(`Index ${idx.key} already exists (create), skipping`, { prefix: 'Indexes' });
+                            skipped.push(idx.key);
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                // Wait for index availability
+                const maxWait = 60000;
+                const start = Date.now();
+                let lastStatus = '';
+                while (Date.now() - start < maxWait) {
+                    try {
+                        const li = await adapter.listIndexes({ databaseId, tableId });
+                        const list = li.data || li.indexes || [];
+                        const cur = list.find((i) => i.key === idx.key);
+                        if (cur) {
+                            if (cur.status === 'available')
+                                break;
+                            if (cur.status === 'failed' || cur.status === 'stuck') {
+                                throw new Error(cur.error || `Index ${idx.key} failed`);
+                            }
+                            lastStatus = cur.status;
+                        }
+                        await delay(2000);
+                    }
+                    catch {
+                        await delay(2000);
+                    }
+                }
+                await delay(150);
+            }
+            MessageFormatter.info(`Summary → ➕  ${created.length}  |  🔧  ${updated.length}  |  ⏭️  ${skipped.length}`, { prefix: 'Indexes' });
+        }
+        catch (e) {
+            MessageFormatter.error(`Failed to list/create indexes`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Indexes' });
+        }
+        // Deletions for indexes: remove remote indexes not declared in YAML/config
+        try {
+            const desiredIndexKeys = new Set((indexes || []).map((i) => i.key));
+            const idxRes = await adapter.listIndexes({ databaseId, tableId });
+            const existingIdx = idxRes.data || idxRes.indexes || [];
+            const extraIdx = existingIdx
+                .filter((i) => i?.key && !desiredIndexKeys.has(i.key))
+                .map((i) => i.key);
+            if (extraIdx.length > 0) {
+                MessageFormatter.info(`Plan → 🗑️  ${extraIdx.length} indexes (${extraIdx.join(', ')})`, { prefix: 'Indexes' });
+                const deleted = [];
+                const errors = [];
+                for (const key of extraIdx) {
+                    try {
+                        await adapter.deleteIndex({ databaseId, tableId, key });
+                        // Optionally wait for index to disappear
+                        const start = Date.now();
+                        const maxWait = 30000;
+                        while (Date.now() - start < maxWait) {
+                            try {
+                                const li = await adapter.listIndexes({ databaseId, tableId });
+                                const list = li.data || li.indexes || [];
+                                if (!list.find((ix) => ix.key === key))
+                                    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} indexes: ${deleted.join(', ')}`, { prefix: 'Indexes' });
+                }
+                if (errors.length) {
+                    MessageFormatter.error(`${errors.length} index deletions failed`, undefined, { prefix: 'Indexes' });
+                    errors.forEach(er => MessageFormatter.error(`  ${er.key}: ${er.error}`, undefined, { prefix: 'Indexes' }));
+                }
+            }
+            else {
+                MessageFormatter.info(`Plan → 🗑️  0 indexes`, { prefix: 'Indexes' });
+            }
+        }
+        catch (e) {
+            MessageFormatter.warning(`Could not evaluate index deletions: ${e?.message || e}`, { prefix: 'Indexes' });
+        }
+        // Deletions: remove columns/attributes that are present remotely but not in desired config
+        try {
+            const desiredKeys = new Set((attributes || []).map((a) => a.key));
+            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))
+                .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 : [];
+                                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" });
+            }
+        }
+    }
+};
+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;
+};