appwrite-utils-cli 1.7.9 → 1.8.2

package/dist/migrations/transfer.js

@@ -2,14 +2,16 @@ import { converterFunctions, tryAwaitWithRetry } from "appwrite-utils";
 import { Client, Databases, IndexType, Query, Storage, Users, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
 import { getAppwriteClient } from "../utils/helperFunctions.js";
-import { createOrUpdateAttribute, createUpdateCollectionAttributes, createUpdateCollectionAttributesWithStatusCheck, } from "../collections/attributes.js";
+// Legacy attribute helpers retained only for local-to-local flows if needed
 import { parseAttribute } from "appwrite-utils";
 import chalk from "chalk";
 import { fetchAllCollections } from "../collections/methods.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
+import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
 import { ProgressManager } from "../shared/progressManager.js";
-import { createOrUpdateIndex, createOrUpdateIndexes, createOrUpdateIndexesWithStatusCheck, } from "../collections/indexes.js";
-import { getClient } from "../utils/getClientFromConfig.js";
+import { getClient, getAdapter } from "../utils/getClientFromConfig.js";
+import { diffTableColumns } from "../collections/tableOperations.js";
+import { mapToCreateAttributeParams } from "../shared/attributeMapper.js";
 export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucketId) => {
     MessageFormatter.info(`Transferring files from ${fromBucketId} to ${toBucketId}`, { prefix: "Transfer" });
     let lastFileId;
@@ -165,26 +167,83 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
                 MessageFormatter.progress(`Creating collection ${collection.name} in target database...`, { prefix: "Transfer" });
                 targetCollection = await tryAwaitWithRetry(async () => localDb.createCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
             }
-            // Handle attributes with enhanced status checking
-            MessageFormatter.info(`Creating attributes for collection ${collection.name} with enhanced monitoring...`, { prefix: "Transfer" });
-            const allAttributes = collection.attributes.map((attr) => parseAttribute(attr));
-            const attributeSuccess = await createUpdateCollectionAttributesWithStatusCheck(localDb, targetDbId, targetCollection, allAttributes);
-            if (!attributeSuccess) {
-                MessageFormatter.error(`Failed to create all attributes for collection ${collection.name}, skipping to next collection`, undefined, { prefix: "Transfer" });
-                continue;
+            // Create attributes via local adapter (wrap the existing client)
+            const localAdapter = new LegacyAdapter(localDb.client);
+            MessageFormatter.info(`Creating attributes for ${collection.name} via adapter...`, { prefix: 'Transfer' });
+            const uniformAttrs = collection.attributes.map((attr) => parseAttribute(attr));
+            const nonRel = uniformAttrs.filter((a) => a.type !== 'relationship');
+            for (const attr of nonRel) {
+                const params = mapToCreateAttributeParams(attr, { databaseId: targetDbId, tableId: targetCollection.$id });
+                await localAdapter.createAttribute(params);
+                await new Promise((r) => setTimeout(r, 150));
             }
-            MessageFormatter.success(`All attributes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
-            // Handle indexes
-            const existingIndexes = await tryAwaitWithRetry(async () => await localDb.listIndexes(targetDbId, targetCollection.$id));
-            for (const index of collection.indexes) {
-                const existingIndex = existingIndexes.indexes.find((idx) => idx.key === index.key);
-                if (!existingIndex) {
-                    await tryAwaitWithRetry(async () => createOrUpdateIndex(targetDbId, localDb, targetCollection.$id, index));
-                    MessageFormatter.success(`Index ${index.key} created`, { prefix: "Transfer" });
+            // Wait for attributes to become available
+            for (const attr of nonRel) {
+                const maxWait = 60000;
+                const start = Date.now();
+                let lastStatus = '';
+                while (Date.now() - start < maxWait) {
+                    try {
+                        const tableRes = await localAdapter.getTable({ databaseId: targetDbId, tableId: targetCollection.$id });
+                        const attrs = tableRes.attributes || tableRes.columns || [];
+                        const found = attrs.find((a) => a.key === attr.key);
+                        if (found) {
+                            if (found.status === 'available')
+                                break;
+                            if (found.status === 'failed' || found.status === 'stuck') {
+                                throw new Error(found.error || `Attribute ${attr.key} failed`);
+                            }
+                            lastStatus = found.status;
+                        }
+                        await new Promise((r) => setTimeout(r, 2000));
+                    }
+                    catch {
+                        await new Promise((r) => setTimeout(r, 2000));
+                    }
                 }
-                else {
-                    MessageFormatter.info(`Index ${index.key} exists, checking for updates...`, { prefix: "Transfer" });
-                    await tryAwaitWithRetry(async () => createOrUpdateIndex(targetDbId, localDb, targetCollection.$id, index));
+                if (Date.now() - start >= maxWait) {
+                    MessageFormatter.warning(`Attribute ${attr.key} did not become available within 60s (last: ${lastStatus})`, { prefix: 'Transfer' });
+                }
+            }
+            // Relationship attributes
+            const rels = uniformAttrs.filter((a) => a.type === 'relationship');
+            for (const attr of rels) {
+                const params = mapToCreateAttributeParams(attr, { databaseId: targetDbId, tableId: targetCollection.$id });
+                await localAdapter.createAttribute(params);
+                await new Promise((r) => setTimeout(r, 150));
+            }
+            // Handle indexes via adapter (create or update)
+            for (const idx of collection.indexes) {
+                try {
+                    await localAdapter.createIndex({
+                        databaseId: targetDbId,
+                        tableId: targetCollection.$id,
+                        key: idx.key,
+                        type: idx.type,
+                        attributes: idx.attributes,
+                        orders: idx.orders || []
+                    });
+                    await new Promise((r) => setTimeout(r, 150));
+                    MessageFormatter.success(`Index ${idx.key} created`, { prefix: 'Transfer' });
+                }
+                catch (e) {
+                    // Try update path by deleting and recreating if necessary
+                    try {
+                        await localAdapter.deleteIndex({ databaseId: targetDbId, tableId: targetCollection.$id, key: idx.key });
+                        await localAdapter.createIndex({
+                            databaseId: targetDbId,
+                            tableId: targetCollection.$id,
+                            key: idx.key,
+                            type: idx.type,
+                            attributes: idx.attributes,
+                            orders: idx.orders || []
+                        });
+                        await new Promise((r) => setTimeout(r, 150));
+                        MessageFormatter.info(`Index ${idx.key} recreated`, { prefix: 'Transfer' });
+                    }
+                    catch (e2) {
+                        MessageFormatter.error(`Failed to ensure index ${idx.key}`, e2 instanceof Error ? e2 : new Error(String(e2)), { prefix: 'Transfer' });
+                    }
                 }
             }
             // Transfer documents
@@ -225,26 +284,89 @@ export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId
                 MessageFormatter.progress(`Creating collection ${collection.name} in remote database...`, { prefix: "Transfer" });
                 targetCollection = await tryAwaitWithRetry(async () => remoteDb.createCollection(toDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
             }
-            // Handle attributes with enhanced status checking
-            MessageFormatter.info(`Creating attributes for collection ${collection.name} with enhanced monitoring...`, { prefix: "Transfer" });
-            const attributesToCreate = collection.attributes.map((attr) => parseAttribute(attr));
-            const attributesSuccess = await createUpdateCollectionAttributesWithStatusCheck(remoteDb, toDbId, targetCollection, attributesToCreate);
-            if (!attributesSuccess) {
-                MessageFormatter.warning(`Failed to create some attributes for collection ${collection.name}`, { prefix: "Transfer" });
-                // Continue with the transfer even if some attributes failed
+            // Create/Update attributes via adapter (prefer adapter for remote)
+            const { adapter: remoteAdapter } = await getAdapter(endpoint, projectId, apiKey, 'auto');
+            MessageFormatter.info(`Creating attributes for ${collection.name} via adapter...`, { prefix: 'Transfer' });
+            const uniformAttrs = collection.attributes.map((attr) => parseAttribute(attr));
+            const nonRel = uniformAttrs.filter((a) => a.type !== 'relationship');
+            if (nonRel.length > 0) {
+                const tableInfo = await remoteAdapter.getTable({ databaseId: toDbId, tableId: collection.$id });
+                const existingCols = tableInfo.columns || tableInfo.attributes || [];
+                const { toCreate, toUpdate } = diffTableColumns(existingCols, nonRel);
+                for (const a of toUpdate) {
+                    const p = mapToCreateAttributeParams(a, { databaseId: toDbId, tableId: collection.$id });
+                    await remoteAdapter.updateAttribute(p);
+                    await new Promise((r) => setTimeout(r, 150));
+                }
+                for (const a of toCreate) {
+                    const p = mapToCreateAttributeParams(a, { databaseId: toDbId, tableId: collection.$id });
+                    await remoteAdapter.createAttribute(p);
+                    await new Promise((r) => setTimeout(r, 150));
+                }
             }
-            else {
-                MessageFormatter.success(`All attributes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
+            // Wait for non-relationship attributes to become available
+            for (const attr of nonRel) {
+                const maxWait = 60000;
+                const start = Date.now();
+                let lastStatus = '';
+                while (Date.now() - start < maxWait) {
+                    try {
+                        const tableRes = await remoteAdapter.getTable({ databaseId: toDbId, tableId: collection.$id });
+                        const attrs = tableRes.attributes || tableRes.columns || [];
+                        const found = attrs.find((a) => a.key === attr.key);
+                        if (found) {
+                            if (found.status === 'available')
+                                break;
+                            if (found.status === 'failed' || found.status === 'stuck') {
+                                throw new Error(found.error || `Attribute ${attr.key} failed`);
+                            }
+                            lastStatus = found.status;
+                        }
+                        await new Promise((r) => setTimeout(r, 2000));
+                    }
+                    catch {
+                        await new Promise((r) => setTimeout(r, 2000));
+                    }
+                }
+                if (Date.now() - start >= maxWait) {
+                    MessageFormatter.warning(`Attribute ${attr.key} did not become available within 60s (last: ${lastStatus})`, { prefix: 'Transfer' });
+                }
+            }
+            // Relationship attributes
+            const rels = uniformAttrs.filter((a) => a.type === 'relationship');
+            if (rels.length > 0) {
+                const tableInfo2 = await remoteAdapter.getTable({ databaseId: toDbId, tableId: collection.$id });
+                const existingCols2 = tableInfo2.columns || tableInfo2.attributes || [];
+                const { toCreate: rCreate, toUpdate: rUpdate } = diffTableColumns(existingCols2, rels);
+                for (const a of rUpdate) {
+                    const p = mapToCreateAttributeParams(a, { databaseId: toDbId, tableId: collection.$id });
+                    await remoteAdapter.updateAttribute(p);
+                    await new Promise((r) => setTimeout(r, 150));
+                }
+                for (const a of rCreate) {
+                    const p = mapToCreateAttributeParams(a, { databaseId: toDbId, tableId: collection.$id });
+                    await remoteAdapter.createAttribute(p);
+                    await new Promise((r) => setTimeout(r, 150));
+                }
             }
             // Handle indexes with enhanced status checking
             MessageFormatter.info(`Creating indexes for collection ${collection.name} with enhanced monitoring...`, { prefix: "Transfer" });
-            const indexesSuccess = await createOrUpdateIndexesWithStatusCheck(toDbId, remoteDb, targetCollection.$id, targetCollection, collection.indexes);
-            if (!indexesSuccess) {
-                MessageFormatter.warning(`Failed to create some indexes for collection ${collection.name}`, { prefix: "Transfer" });
-                // Continue with the transfer even if some indexes failed
-            }
-            else {
-                MessageFormatter.success(`All indexes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
+            // Create indexes via adapter
+            for (const idx of collection.indexes || []) {
+                try {
+                    await remoteAdapter.createIndex({
+                        databaseId: toDbId,
+                        tableId: collection.$id,
+                        key: idx.key,
+                        type: idx.type,
+                        attributes: idx.attributes,
+                        orders: idx.orders || []
+                    });
+                    await new Promise((r) => setTimeout(r, 150));
+                }
+                catch (e) {
+                    MessageFormatter.error(`Failed to create index ${idx.key}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Transfer' });
+                }
             }
             // Transfer documents
             const { transferDocumentsBetweenDbsLocalToRemote } = await import("../collections/methods.js");

package/dist/shared/attributeMapper.d.ts

@@ -0,0 +1,20 @@
+import type { CreateAttributeParams, UpdateAttributeParams } from "../adapters/DatabaseAdapter.js";
+import type { Attribute } from "appwrite-utils";
+/**
+ * Map a schema Attribute into DatabaseAdapter CreateAttributeParams
+ * Only includes fields valid for the specific type to satisfy TS unions.
+ * Also normalizes min/max ordering for numeric types to avoid server errors.
+ */
+export declare function mapToCreateAttributeParams(attr: Attribute, base: {
+    databaseId: string;
+    tableId: string;
+}): CreateAttributeParams;
+/**
+ * Map a schema Attribute into DatabaseAdapter UpdateAttributeParams
+ * Omits fields that are not explicitly provided, and guards enum updates
+ * so we never send an empty elements array (preserve existing on server).
+ */
+export declare function mapToUpdateAttributeParams(attr: Attribute, base: {
+    databaseId: string;
+    tableId: string;
+}): UpdateAttributeParams;

package/dist/shared/attributeMapper.js

@@ -0,0 +1,203 @@
+function ensureNumber(n) {
+    if (n === null || n === undefined)
+        return undefined;
+    const num = Number(n);
+    return Number.isFinite(num) ? num : undefined;
+}
+/**
+ * Map a schema Attribute into DatabaseAdapter CreateAttributeParams
+ * Only includes fields valid for the specific type to satisfy TS unions.
+ * Also normalizes min/max ordering for numeric types to avoid server errors.
+ */
+export function mapToCreateAttributeParams(attr, base) {
+    const type = String(attr.type || "").toLowerCase();
+    const required = !!attr.required;
+    const array = !!attr.array;
+    const xdefault = attr.xdefault;
+    const encrypt = attr.encrypted ?? attr.encrypt;
+    // Numeric helpers
+    const rawMin = ensureNumber(attr.min);
+    const rawMax = ensureNumber(attr.max);
+    let min = rawMin;
+    let max = rawMax;
+    if (min !== undefined && max !== undefined && min >= max) {
+        // Swap to satisfy server-side validation
+        const tmp = min;
+        min = Math.min(min, max);
+        max = Math.max(tmp, max);
+        if (min === max) {
+            // If still equal, unset max to avoid error
+            max = undefined;
+        }
+    }
+    switch (type) {
+        case "string":
+            return {
+                databaseId: base.databaseId,
+                tableId: base.tableId,
+                key: attr.key,
+                type,
+                size: attr.size ?? 255,
+                required,
+                default: xdefault,
+                array,
+                encrypt: !!encrypt,
+            };
+        case "integer":
+            return {
+                databaseId: base.databaseId,
+                tableId: base.tableId,
+                key: attr.key,
+                type,
+                required,
+                default: xdefault,
+                array,
+                min,
+                max,
+            };
+        case "double":
+        case "float":
+            return {
+                databaseId: base.databaseId,
+                tableId: base.tableId,
+                key: attr.key,
+                type,
+                required,
+                default: xdefault,
+                array,
+                min,
+                max,
+            };
+        case "boolean":
+            return {
+                databaseId: base.databaseId,
+                tableId: base.tableId,
+                key: attr.key,
+                type,
+                required,
+                default: xdefault,
+                array,
+            };
+        case "datetime":
+        case "email":
+        case "ip":
+        case "url":
+            return {
+                databaseId: base.databaseId,
+                tableId: base.tableId,
+                key: attr.key,
+                type,
+                required,
+                default: xdefault,
+                array,
+            };
+        case "enum":
+            {
+                const elements = attr.elements;
+                if (!Array.isArray(elements) || elements.length === 0) {
+                    // Creating an enum without elements is invalid – fail fast with clear messaging
+                    throw new Error(`Enum attribute '${attr.key}' requires a non-empty 'elements' array for creation`);
+                }
+            }
+            return {
+                databaseId: base.databaseId,
+                tableId: base.tableId,
+                key: attr.key,
+                type,
+                required,
+                default: xdefault,
+                array,
+                elements: attr.elements,
+            };
+        case "relationship": {
+            // Relationship attributes require related collection and metadata
+            return {
+                databaseId: base.databaseId,
+                tableId: base.tableId,
+                key: attr.key,
+                type,
+                relatedCollection: attr.relatedCollection,
+                relationType: attr.relationType,
+                twoWay: attr.twoWay,
+                twoWayKey: attr.twoWayKey,
+                onDelete: attr.onDelete,
+                side: attr.side,
+            };
+        }
+        default:
+            return {
+                databaseId: base.databaseId,
+                tableId: base.tableId,
+                key: attr.key,
+                type,
+                required,
+            };
+    }
+}
+/**
+ * Map a schema Attribute into DatabaseAdapter UpdateAttributeParams
+ * Omits fields that are not explicitly provided, and guards enum updates
+ * so we never send an empty elements array (preserve existing on server).
+ */
+export function mapToUpdateAttributeParams(attr, base) {
+    const type = String(attr.type || "").toLowerCase();
+    const params = {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+    };
+    const setIfDefined = (key, value) => {
+        if (value !== undefined)
+            params[key] = value;
+    };
+    // Common fields
+    setIfDefined("type", type);
+    setIfDefined("required", attr.required);
+    // Only send default if explicitly provided and not on required
+    if (!attr.required && attr.xdefault !== undefined) {
+        setIfDefined("default", attr.xdefault);
+    }
+    setIfDefined("array", attr.array);
+    // encrypt only applies to string types
+    if (type === "string")
+        setIfDefined("encrypt", attr.encrypted ?? attr.encrypt);
+    // Numeric normalization
+    const toNum = (n) => (n === null || n === undefined ? undefined : (Number(n)));
+    let min = toNum(attr.min);
+    let max = toNum(attr.max);
+    if (min !== undefined && max !== undefined && min >= max) {
+        const tmp = min;
+        min = Math.min(min, max);
+        max = Math.max(tmp, max);
+        if (min === max)
+            max = undefined;
+    }
+    switch (type) {
+        case "string":
+            setIfDefined("size", attr.size);
+            break;
+        case "integer":
+        case "float":
+        case "double":
+            setIfDefined("min", min);
+            setIfDefined("max", max);
+            break;
+        case "enum": {
+            const elements = attr.elements;
+            if (Array.isArray(elements) && elements.length > 0) {
+                // Only include when non-empty; otherwise preserve existing on server
+                setIfDefined("elements", elements);
+            }
+            break;
+        }
+        case "relationship": {
+            setIfDefined("relatedCollection", attr.relatedCollection);
+            setIfDefined("relationType", attr.relationType);
+            setIfDefined("twoWay", attr.twoWay);
+            setIfDefined("twoWayKey", attr.twoWayKey);
+            setIfDefined("onDelete", attr.onDelete);
+            break;
+        }
+    }
+    return params;
+}

package/dist/shared/selectionDialogs.js

@@ -145,7 +145,8 @@ export class SelectionDialogs {
                 name,
                 value: database.$id,
                 short: database.name,
-                checked: defaultSelected.includes(database.$id) || (!allowNewOnly && isConfigured)
+                // Do not preselect anything unless explicitly provided
+                checked: defaultSelected.includes(database.$id)
             });
         });
         if (choices.length === 0) {
@@ -205,7 +206,8 @@ export class SelectionDialogs {
                 name,
                 value: table.$id,
                 short: table.name,
-                checked: defaultSelected.includes(table.$id) || (!allowNewOnly && isConfigured)
+                // Do not preselect anything unless explicitly provided
+                checked: defaultSelected.includes(table.$id)
             });
         });
         if (choices.length === 0) {
@@ -288,7 +290,8 @@ export class SelectionDialogs {
                             name: `  ${name}`,
                             value: bucket.$id,
                             short: bucket.name,
-                            checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
+                            // Do not preselect anything unless explicitly provided
+                            checked: defaultSelected.includes(bucket.$id)
                         });
                     });
                 }
@@ -327,7 +330,8 @@ export class SelectionDialogs {
                     name,
                     value: bucket.$id,
                     short: bucket.name,
-                    checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
+                    // Do not preselect anything unless explicitly provided
+                    checked: defaultSelected.includes(bucket.$id)
                 });
             });
         }