appwrite-utils-cli 1.8.5 → 1.8.6

package/dist/collections/methods.js

@@ -235,6 +235,11 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
             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(', ')})`);
@@ -244,6 +249,7 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 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);
@@ -458,6 +464,121 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
         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 to prevent re-processing
         markCollectionProcessed(tableId, collectionData.name);
     }

package/dist/utilsController.js

@@ -619,6 +619,15 @@ export class UtilsController {
             MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
             return;
         }
+        // Always reload config from disk so pushes use current local YAML/Ts definitions
+        try {
+            await this.reloadConfig();
+            MessageFormatter.info("Reloaded config from disk for push", { prefix: "Controller" });
+        }
+        catch (e) {
+            // Non-fatal; continue with existing config
+            MessageFormatter.warning("Could not reload config; continuing with current in-memory config", { prefix: "Controller" });
+        }
         MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
         // Convert database selections to Models.Database format
         const selectedDatabases = [];
@@ -665,7 +674,8 @@ export class UtilsController {
                 // Check if this collection was selected for THIS database
                 if (dbSelection.tableIds.includes(collectionId)) {
                     collectionsForDatabase.push(collection);
-                    MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId}`, { prefix: "Controller" });
+                    const source = collection._isFromTablesDir ? 'tables/' : 'collections/';
+                    MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId} [source: ${source}]`, { prefix: "Controller" });
                 }
             }
             databaseCollectionsMap.set(dbSelection.databaseId, collectionsForDatabase);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.8.5",
+  "version": "1.8.6",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/collections/methods.ts

@@ -319,11 +319,18 @@ export const createOrUpdateCollectionsViaAdapter = async (
       const minus = plan.toRecreate.map((r: any) => (r.newAttribute as any).key);
       const skip = plan.unchanged;
 
+      // Compute deletions (remote extras not present locally)
+      const desiredKeysForDelete = new Set((attributes || []).map((a: any) => a.key));
+      const extraRemoteKeys = (existingCols || [])
+        .map((c: any) => c?.key)
+        .filter((k: any): k is string => !!k && !desiredKeysForDelete.has(k));
+
       const parts: string[] = [];
       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
@@ -510,10 +517,117 @@ export const createOrUpdateCollectionsViaAdapter = async (
     } catch (e) {
       MessageFormatter.error(`Failed to list/create indexes`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Indexes' });
     }
-
-    // Mark this table as fully processed to prevent re-processing
-    markCollectionProcessed(tableId, collectionData.name);
-  }
+
+    // Deletions for indexes: remove remote indexes not declared in YAML/config
+    try {
+      const desiredIndexKeys = new Set((indexes || []).map((i: any) => i.key));
+      const idxRes = await adapter.listIndexes({ databaseId, tableId });
+      const existingIdx: any[] = (idxRes as any).data || (idxRes as any).indexes || [];
+      const extraIdx = existingIdx
+        .filter((i: any) => i?.key && !desiredIndexKeys.has(i.key))
+        .map((i: any) => i.key as string);
+      if (extraIdx.length > 0) {
+        MessageFormatter.info(`Plan → 🗑️  ${extraIdx.length} indexes (${extraIdx.join(', ')})`, { prefix: 'Indexes' });
+        const deleted: string[] = [];
+        const errors: Array<{ key: string; error: string }> = [];
+        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: any[] = (li as any).data || (li as any).indexes || [];
+                if (!list.find((ix: any) => ix.key === key)) break;
+              } catch {}
+              await delay(1000);
+            }
+            deleted.push(key);
+          } catch (e: any) {
+            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 as Error)?.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: any) => a.key));
+      const tableInfo3 = await adapter.getTable({ databaseId, tableId });
+      const existingCols3: any[] = (tableInfo3 as any).data?.columns || (tableInfo3 as any).data?.attributes || [];
+      const toDelete = existingCols3
+        .filter((col: any) => col?.key && !desiredKeys.has(col.key))
+        .map((col: any) => col.key as string);
+
+      if (toDelete.length > 0) {
+        MessageFormatter.info(`Plan → 🗑️  ${toDelete.length} (${toDelete.join(', ')})`, { prefix: 'Attributes' });
+        const deleted: string[] = [];
+        const errors: Array<{ key: string; error: string }> = [];
+        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: any[] = (idxRes as any).data || (idxRes as any).indexes || [];
+              for (const idx of ilist) {
+                const attrs: string[] = 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 as any).data?.columns || (tinfo as any).data?.attributes || [];
+                const found = cols.find((c: any) => c.key === key);
+                if (!found) break;
+                if (found.status && found.status !== 'deleting') break;
+              } catch {}
+              await delay(1000);
+            }
+            deleted.push(key);
+          } catch (e: any) {
+            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 as Error)?.message || e}`, { prefix: 'Attributes' });
+    }
+
+    // Mark this table as fully processed to prevent re-processing
+    markCollectionProcessed(tableId, collectionData.name);
+  }
 
   // Process queued relationships once mapping likely populated
   if (relQueue.length > 0) {

package/src/utilsController.ts

@@ -848,15 +848,24 @@ export class UtilsController {
     MessageFormatter.success("Selective pull completed successfully! Remote config pulled to local.", { prefix: "Controller" });
   }
 
-  async selectivePush(
-    databaseSelections: DatabaseSelection[],
-    bucketSelections: BucketSelection[]
-  ): Promise<void> {
-    await this.init();
-    if (!this.database) {
-      MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
-      return;
-    }
+  async selectivePush(
+    databaseSelections: DatabaseSelection[],
+    bucketSelections: BucketSelection[]
+  ): Promise<void> {
+    await this.init();
+    if (!this.database) {
+      MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+      return;
+    }
+
+    // Always reload config from disk so pushes use current local YAML/Ts definitions
+    try {
+      await this.reloadConfig();
+      MessageFormatter.info("Reloaded config from disk for push", { prefix: "Controller" });
+    } catch (e) {
+      // Non-fatal; continue with existing config
+      MessageFormatter.warning("Could not reload config; continuing with current in-memory config", { prefix: "Controller" });
+    }
 
     MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
 
@@ -900,7 +909,7 @@ export class UtilsController {
     const databaseCollectionsMap = new Map<string, any[]>();
 
     // Get all collections/tables from config (they're at the root level, not nested in databases)
-    const allCollections = this.config?.collections || this.config?.tables || [];
+    const allCollections = this.config?.collections || this.config?.tables || [];
 
     // Create database-specific collection mapping to preserve relationships
     for (const dbSelection of databaseSelections) {
@@ -908,16 +917,17 @@ export class UtilsController {
 
       MessageFormatter.info(`Processing collections for database: ${dbSelection.databaseId}`, { prefix: "Controller" });
 
-      // Filter collections that were selected for THIS specific database
-      for (const collection of allCollections) {
-        const collectionId = collection.$id || (collection as any).id;
-
-        // Check if this collection was selected for THIS database
-        if (dbSelection.tableIds.includes(collectionId)) {
-          collectionsForDatabase.push(collection);
-          MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId}`, { prefix: "Controller" });
-        }
-      }
+      // Filter collections that were selected for THIS specific database
+      for (const collection of allCollections) {
+        const collectionId = collection.$id || (collection as any).id;
+
+        // Check if this collection was selected for THIS database
+        if (dbSelection.tableIds.includes(collectionId)) {
+          collectionsForDatabase.push(collection);
+          const source = (collection as any)._isFromTablesDir ? 'tables/' : 'collections/';
+          MessageFormatter.info(`  - Selected collection: ${collection.name || collectionId} for database ${dbSelection.databaseId} [source: ${source}]`, { prefix: "Controller" });
+        }
+      }
 
       databaseCollectionsMap.set(dbSelection.databaseId, collectionsForDatabase);
       MessageFormatter.info(`Database ${dbSelection.databaseId}: ${collectionsForDatabase.length} collections selected`, { prefix: "Controller" });