appwrite-utils-cli 1.7.9 → 1.8.2

package/dist/collections/methods.js

@@ -2,13 +2,14 @@ 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";
-import { createUpdateCollectionAttributesWithStatusCheck } from "./attributes.js";
-import { createOrUpdateIndexesWithStatusCheck } from "./indexes.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
@@ -122,130 +123,9 @@ export const generateSchemas = async (config, appwriteFolderPath) => {
 export const createOrUpdateCollections = async (database, databaseId, config, deletedCollections, selectedCollections = []) => {
     // Clear processing state at the start of a new operation
     clearProcessingState();
-    // If API mode is tablesdb, route to adapter-based implementation
-    try {
-        const { adapter, apiMode } = await getAdapterFromConfig(config);
-        if (apiMode === 'tablesdb') {
-            await createOrUpdateCollectionsViaAdapter(adapter, databaseId, config, deletedCollections, selectedCollections);
-            return;
-        }
-    }
-    catch {
-        // Fallback to legacy path below
-    }
-    const collectionsToProcess = selectedCollections.length > 0 ? selectedCollections : config.collections;
-    if (!collectionsToProcess) {
-        return;
-    }
-    const usedIds = new Set();
-    MessageFormatter.info(`Processing ${collectionsToProcess.length} collections with intelligent state management`, { prefix: "Collections" });
-    for (const collection of collectionsToProcess) {
-        const { attributes, indexes, ...collectionData } = collection;
-        // Check if this collection has already been processed in this session
-        if (collectionData.$id && isCollectionProcessed(collectionData.$id)) {
-            MessageFormatter.info(`Collection '${collectionData.name}' already processed, skipping`, { prefix: "Collections" });
-            continue;
-        }
-        // Prepare permissions for the collection
-        const permissions = [];
-        if (collection.$permissions && collection.$permissions.length > 0) {
-            for (const permission of collection.$permissions) {
-                if (typeof permission === "string") {
-                    permissions.push(permission);
-                }
-                else {
-                    switch (permission.permission) {
-                        case "read":
-                            permissions.push(Permission.read(permission.target));
-                            break;
-                        case "create":
-                            permissions.push(Permission.create(permission.target));
-                            break;
-                        case "update":
-                            permissions.push(Permission.update(permission.target));
-                            break;
-                        case "delete":
-                            permissions.push(Permission.delete(permission.target));
-                            break;
-                        case "write":
-                            permissions.push(Permission.write(permission.target));
-                            break;
-                        default:
-                            MessageFormatter.warning(`Unknown permission: ${permission.permission}`, { prefix: "Collections" });
-                            break;
-                    }
-                }
-            }
-        }
-        // Check if the collection already exists by name
-        let collectionsFound = await tryAwaitWithRetry(async () => await database.listCollections(databaseId, [
-            Query.equal("name", collectionData.name),
-        ]));
-        let collectionToUse = collectionsFound.total > 0 ? collectionsFound.collections[0] : null;
-        // Determine the correct ID for the collection
-        let collectionId;
-        if (!collectionToUse) {
-            MessageFormatter.info(`Creating collection: ${collectionData.name}`, { prefix: "Collections" });
-            let foundColl = deletedCollections?.find((coll) => coll.collectionName.toLowerCase().trim().replace(" ", "") ===
-                collectionData.name.toLowerCase().trim().replace(" ", ""));
-            if (collectionData.$id) {
-                collectionId = collectionData.$id;
-            }
-            else if (foundColl && !usedIds.has(foundColl.collectionId)) {
-                collectionId = foundColl.collectionId;
-            }
-            else {
-                collectionId = ID.unique();
-            }
-            usedIds.add(collectionId);
-            // Create the collection with the determined ID
-            try {
-                collectionToUse = await tryAwaitWithRetry(async () => await database.createCollection(databaseId, collectionId, collectionData.name, permissions, collectionData.documentSecurity ?? false, collectionData.enabled ?? true));
-                collectionData.$id = collectionToUse.$id;
-                nameToIdMapping.set(collectionData.name, collectionToUse.$id);
-            }
-            catch (error) {
-                MessageFormatter.error(`Failed to create collection ${collectionData.name} with ID ${collectionId}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Collections" });
-                continue;
-            }
-        }
-        else {
-            MessageFormatter.info(`Collection ${collectionData.name} exists, updating it`, { prefix: "Collections" });
-            await tryAwaitWithRetry(async () => await database.updateCollection(databaseId, collectionToUse.$id, collectionData.name, permissions, collectionData.documentSecurity ?? false, collectionData.enabled ?? true));
-            // Cache the existing collection ID
-            nameToIdMapping.set(collectionData.name, collectionToUse.$id);
-        }
-        // Add delay after creating/updating collection
-        await delay(250);
-        // Update attributes and indexes for the collection
-        MessageFormatter.progress("Creating Attributes", { prefix: "Collections" });
-        await createUpdateCollectionAttributesWithStatusCheck(database, databaseId, collectionToUse, 
-        // @ts-expect-error
-        attributes);
-        // Add delay after creating attributes
-        await delay(250);
-        // Prefer local config indexes, but fall back to collection's own indexes if no local config exists
-        const localCollectionConfig = config.collections?.find(c => c.name === collectionData.name || c.$id === collectionData.$id);
-        const indexesToUse = localCollectionConfig?.indexes ?? indexes ?? [];
-        MessageFormatter.progress("Creating Indexes", { prefix: "Collections" });
-        await createOrUpdateIndexesWithStatusCheck(databaseId, database, collectionToUse.$id, collectionToUse, indexesToUse);
-        // Delete indexes that exist on server but not in local config
-        const { deleteObsoleteIndexes } = await import('../shared/indexManager.js');
-        await deleteObsoleteIndexes(database, databaseId, collectionToUse, { indexes: indexesToUse }, { verbose: true });
-        // Mark this collection as fully processed to prevent re-processing
-        markCollectionProcessed(collectionToUse.$id, collectionData.name);
-        // Add delay after creating indexes
-        await delay(250);
-    }
-    // Process any remaining relationship attributes in the queue
-    // This surgical approach only processes specific attributes, not entire collections
-    if (queuedOperations.length > 0) {
-        MessageFormatter.info(`🔧 Processing ${queuedOperations.length} queued relationship attributes (surgical approach)`, { prefix: "Collections" });
-        await processQueue(database, databaseId);
-    }
-    else {
-        MessageFormatter.info("✅ No queued relationship attributes to process", { prefix: "Collections" });
-    }
+    // 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 = []) => {
@@ -254,29 +134,15 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
         return;
     const usedIds = new Set();
     MessageFormatter.info(`Processing ${collectionsToProcess.length} tables via adapter with intelligent state management`, { prefix: "Tables" });
-    // Helper: create attributes through adapter
+    // Helpers for attribute operations through adapter
     const createAttr = async (tableId, attr) => {
-        const base = {
-            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,
-            encrypt: attr.encrypted,
-            relatedCollection: attr.relatedCollection,
-            relationType: attr.relationType,
-            twoWay: attr.twoWay,
-            twoWayKey: attr.twoWayKey,
-            onDelete: attr.onDelete,
-            side: attr.side,
-        };
-        await adapter.createAttribute(base);
+        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
@@ -357,37 +223,92 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
         }
         // Add small delay after table create/update
         await delay(250);
-        // Create attributes: non-relationship first
+        // Create/Update attributes: non-relationship first using enhanced planning
         const nonRel = (attributes || []).filter((a) => a.type !== 'relationship');
-        for (const attr of nonRel) {
-            await createAttr(tableId, attr);
+        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;
+            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}`);
+            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
+        // Relationship attributes — resolve relatedCollection to ID, then diff and create/update
         const rels = (attributes || []).filter((a) => a.type === 'relationship');
-        for (const attr of rels) {
-            const relNameOrId = attr.relatedCollection;
-            if (!relNameOrId)
-                continue;
-            let relId = nameToIdMapping.get(relNameOrId) || relNameOrId;
-            // If looks like a name (not ULID) and not in cache, try query by name
-            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);
+        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 { }
                 }
-                catch { }
+                if (relId && typeof relId === 'string')
+                    attr.relatedCollection = relId;
             }
-            if (relId && typeof relId === 'string') {
-                attr.relatedCollection = relId;
-                await createAttr(tableId, attr);
+            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' });
             }
-            else {
-                // Defer if unresolved
-                relQueue.push({ tableId, attr: attr });
+            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
@@ -403,7 +324,7 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
                 while (Date.now() - startTime < maxWait) {
                     try {
                         const tableData = await adapter.getTable({ databaseId, tableId });
-                        const attrs = tableData.attributes || [];
+                        const attrs = tableData.data?.columns || tableData.data?.attributes || [];
                         const attr = attrs.find((a) => a.key === attrKey);
                         if (attr) {
                             if (attr.status === 'available') {
@@ -431,21 +352,111 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
         // 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 ?? []);
-        for (const idx of idxs) {
-            try {
-                await adapter.createIndex({
-                    databaseId,
-                    tableId,
-                    key: idx.key,
-                    type: idx.type,
-                    attributes: idx.attributes,
-                    orders: idx.orders || []
-                });
-                await delay(150);
+        // 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);
             }
-            catch (e) {
-                MessageFormatter.error(`Failed to create index ${idx.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Indexes' });
+            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' });
         }
         // Mark this table as fully processed to prevent re-processing
         markCollectionProcessed(tableId, collectionData.name);

package/dist/collections/tableOperations.d.ts

@@ -0,0 +1,86 @@
+import type { Attribute } from "appwrite-utils";
+interface ColumnPropertyChange {
+    property: string;
+    oldValue: any;
+    newValue: any;
+    requiresRecreate: boolean;
+}
+interface ColumnOperationPlan {
+    toCreate: Attribute[];
+    toUpdate: Array<{
+        attribute: Attribute;
+        changes: ColumnPropertyChange[];
+    }>;
+    toRecreate: Array<{
+        oldAttribute: any;
+        newAttribute: Attribute;
+    }>;
+    toDelete: Array<{
+        attribute: any;
+    }>;
+    unchanged: string[];
+}
+type ComparableColumn = {
+    key: string;
+    type: string;
+    required?: boolean;
+    array?: boolean;
+    default?: any;
+    size?: number;
+    min?: number;
+    max?: number;
+    elements?: string[];
+    encrypt?: boolean;
+    relatedCollection?: string;
+    relationType?: string;
+    twoWay?: boolean;
+    twoWayKey?: string;
+    onDelete?: string;
+    side?: string;
+};
+export declare function normalizeAttributeToComparable(attr: Attribute): ComparableColumn;
+export declare function normalizeColumnToComparable(col: any): ComparableColumn;
+export declare function isColumnEqualToColumn(a: any, b: any): boolean;
+export declare function isIndexEqualToIndex(a: any, b: any): boolean;
+/**
+ * Enhanced version of columns diff with detailed change analysis
+ * Order: desired first, then existing (matches internal usage here)
+ */
+export declare function diffColumnsDetailed(desiredAttributes: Attribute[], existingColumns: any[]): ColumnOperationPlan;
+/**
+ * Returns true if there is any difference between existing columns and desired attributes
+ */
+export declare function areTableColumnsDiff(existingColumns: any[], desired: Attribute[]): boolean;
+export declare function diffTableColumns(existingColumns: any[], desired: Attribute[]): {
+    toCreate: Attribute[];
+    toUpdate: Attribute[];
+    unchanged: string[];
+};
+/**
+ * Execute the column operation plan using the adapter
+ */
+export declare function executeColumnOperations(adapter: any, databaseId: string, tableId: string, plan: ColumnOperationPlan): Promise<{
+    success: string[];
+    errors: Array<{
+        column: string;
+        error: string;
+    }>;
+}>;
+/**
+ * Integration function for methods.ts - processes columns using enhanced logic
+ */
+export declare function processTableColumns(adapter: any, databaseId: string, tableId: string, desiredAttributes: Attribute[], existingColumns?: any[]): Promise<{
+    totalProcessed: number;
+    success: string[];
+    errors: Array<{
+        column: string;
+        error: string;
+    }>;
+    summary: {
+        created: number;
+        updated: number;
+        recreated: number;
+        unchanged: number;
+    };
+}>;
+export {};