appwrite-utils-cli 1.7.9 → 1.8.2

package/dist/collections/tableOperations.js

@@ -0,0 +1,434 @@
+import { mapToCreateAttributeParams, mapToUpdateAttributeParams } from "../shared/attributeMapper.js";
+import { Decimal } from "decimal.js";
+const EXTREME_BOUND = new Decimal('1e12');
+// Property configuration for different column types
+const MUTABLE_PROPERTIES = {
+    string: ["required", "default", "size", "array"],
+    integer: ["required", "default", "min", "max", "array"],
+    float: ["required", "default", "min", "max", "array"],
+    double: ["required", "default", "min", "max", "array"],
+    boolean: ["required", "default", "array"],
+    datetime: ["required", "default", "array"],
+    email: ["required", "default", "array"],
+    ip: ["required", "default", "array"],
+    url: ["required", "default", "array"],
+    enum: ["required", "default", "elements", "array"],
+    relationship: ["required", "default"],
+};
+const IMMUTABLE_PROPERTIES = {
+    string: ["encrypt", "key"],
+    integer: ["encrypt", "key"],
+    float: ["encrypt", "key"],
+    double: ["encrypt", "key"],
+    boolean: ["key"],
+    datetime: ["key"],
+    email: ["key"],
+    ip: ["key"],
+    url: ["key"],
+    enum: ["key"],
+    relationship: ["key", "relatedCollection", "relationType", "twoWay", "twoWayKey", "onDelete"],
+};
+const TYPE_CHANGE_REQUIRES_RECREATE = [
+    "string",
+    "integer",
+    "float",
+    "double",
+    "boolean",
+    "datetime",
+    "email",
+    "ip",
+    "url",
+    "enum",
+    "relationship",
+];
+function normDefault(val) {
+    // Treat undefined and null as equal unset default
+    return val === undefined ? null : val;
+}
+function toNumber(n) {
+    if (n === null || n === undefined)
+        return undefined;
+    const num = Number(n);
+    return Number.isFinite(num) ? num : undefined;
+}
+export function normalizeAttributeToComparable(attr) {
+    const t = String(attr.type || '').toLowerCase();
+    const base = {
+        key: attr.key,
+        type: t,
+        required: !!attr.required,
+        array: !!attr.array,
+        default: normDefault(attr.xdefault),
+    };
+    if (t === 'string') {
+        base.size = attr.size ?? 255;
+        base.encrypt = !!(attr.encrypted ?? attr.encrypt);
+    }
+    if (t === 'integer' || t === 'float' || t === 'double') {
+        const min = toNumber(attr.min);
+        const max = toNumber(attr.max);
+        if (min !== undefined && max !== undefined) {
+            base.min = Math.min(min, max);
+            base.max = Math.max(min, max);
+        }
+        else {
+            base.min = min;
+            base.max = max;
+        }
+    }
+    if (t === 'enum') {
+        base.elements = Array.isArray(attr.elements) ? attr.elements.slice().sort() : [];
+    }
+    if (t === 'relationship') {
+        base.relatedCollection = attr.relatedCollection;
+        base.relationType = attr.relationType;
+        base.twoWay = !!attr.twoWay;
+        base.twoWayKey = attr.twoWayKey;
+        base.onDelete = attr.onDelete;
+        base.side = attr.side;
+    }
+    return base;
+}
+export function normalizeColumnToComparable(col) {
+    // Detect enum surfaced as string+elements from server and normalize to enum for comparison
+    let t = String((col?.type ?? col?.columnType ?? '')).toLowerCase();
+    const hasElements = Array.isArray(col?.elements) && col.elements.length > 0;
+    if (t === 'string' && hasElements)
+        t = 'enum';
+    const base = {
+        key: col?.key,
+        type: t,
+        required: !!col?.required,
+        array: !!col?.array,
+        default: normDefault(col?.default ?? col?.xdefault),
+    };
+    if (t === 'string') {
+        base.size = typeof col?.size === 'number' ? col.size : undefined;
+        base.encrypt = !!col?.encrypt;
+    }
+    if (t === 'integer' || t === 'float' || t === 'double') {
+        // Preserve raw min/max without forcing extremes; compare with Decimal in shallowEqual
+        const rawMin = col?.min;
+        const rawMax = col?.max;
+        base.min = rawMin;
+        base.max = rawMax;
+    }
+    if (t === 'enum') {
+        base.elements = Array.isArray(col?.elements) ? col.elements.slice().sort() : [];
+    }
+    if (t === 'relationship') {
+        base.relatedCollection = col?.relatedTableId || col?.relatedCollection;
+        base.relationType = col?.relationType || col?.typeName;
+        base.twoWay = !!col?.twoWay;
+        base.twoWayKey = col?.twoWayKey;
+        base.onDelete = col?.onDelete;
+        base.side = col?.side;
+    }
+    return base;
+}
+function shallowEqual(a, b) {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const k of keys) {
+        const va = a[k];
+        const vb = b[k];
+        if (Array.isArray(va) && Array.isArray(vb)) {
+            if (va.length !== vb.length)
+                return false;
+            for (let i = 0; i < va.length; i++)
+                if (va[i] !== vb[i])
+                    return false;
+        }
+        else if (k === 'min' || k === 'max') {
+            // Compare numeric bounds with Decimal to avoid precision issues
+            if (va == null && vb == null)
+                continue;
+            if (va == null || vb == null) {
+                // Treat extreme bounds on one side as equivalent to undefined (unbounded)
+                const present = va == null ? vb : va;
+                try {
+                    const dp = new Decimal(String(present));
+                    if (dp.abs().greaterThanOrEqualTo(EXTREME_BOUND))
+                        continue; // equal
+                }
+                catch { }
+                return false;
+            }
+            try {
+                const da = new Decimal(String(va));
+                const db = new Decimal(String(vb));
+                if (!da.equals(db))
+                    return false;
+            }
+            catch {
+                if (va !== vb)
+                    return false;
+            }
+        }
+        else if (va !== vb) {
+            // Treat null and undefined as equal for defaults
+            if (!(va == null && vb == null))
+                return false;
+        }
+    }
+    return true;
+}
+export function isColumnEqualToColumn(a, b) {
+    const na = normalizeColumnToComparable(a);
+    const nb = normalizeColumnToComparable(b);
+    return shallowEqual(na, nb);
+}
+export function isIndexEqualToIndex(a, b) {
+    if (!a || !b)
+        return false;
+    if (a.key !== b.key)
+        return false;
+    if (String(a.type).toLowerCase() !== String(b.type).toLowerCase())
+        return false;
+    // Compare attributes as sets (order-insensitive)
+    const attrsA = Array.isArray(a.attributes) ? [...a.attributes].sort() : [];
+    const attrsB = Array.isArray(b.attributes) ? [...b.attributes].sort() : [];
+    if (attrsA.length !== attrsB.length)
+        return false;
+    for (let i = 0; i < attrsA.length; i++)
+        if (attrsA[i] !== attrsB[i])
+            return false;
+    // Orders are only considered if BOTH have orders defined
+    const hasOrdersA = Array.isArray(a.orders) && a.orders.length > 0;
+    const hasOrdersB = Array.isArray(b.orders) && b.orders.length > 0;
+    if (hasOrdersA && hasOrdersB) {
+        const ordersA = [...a.orders].sort();
+        const ordersB = [...b.orders].sort();
+        if (ordersA.length !== ordersB.length)
+            return false;
+        for (let i = 0; i < ordersA.length; i++)
+            if (ordersA[i] !== ordersB[i])
+                return false;
+    }
+    // If only one side has orders, treat as equal (orders unspecified by user)
+    return true;
+}
+/**
+ * Compare individual properties between old and new columns
+ */
+function compareColumnProperties(oldColumn, newAttribute, columnType) {
+    const changes = [];
+    const t = String(columnType || newAttribute.type || '').toLowerCase();
+    const mutableProps = MUTABLE_PROPERTIES[t] || [];
+    const immutableProps = IMMUTABLE_PROPERTIES[t] || [];
+    const getNewVal = (prop) => {
+        const na = newAttribute;
+        if (prop === 'default')
+            return na.xdefault;
+        if (prop === 'encrypt')
+            return na.encrypted ?? na.encrypt;
+        return na[prop];
+    };
+    const getOldVal = (prop) => {
+        if (prop === 'default')
+            return oldColumn?.default ?? oldColumn?.xdefault;
+        return oldColumn?.[prop];
+    };
+    for (const prop of mutableProps) {
+        const oldValue = getOldVal(prop);
+        let newValue = getNewVal(prop);
+        // Special-case: enum elements empty/missing should not trigger updates
+        if (t === 'enum' && prop === 'elements') {
+            if (!Array.isArray(newValue) || newValue.length === 0)
+                newValue = oldValue;
+        }
+        if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+            if (oldValue.length !== newValue.length || oldValue.some((v, i) => v !== newValue[i])) {
+                changes.push({ property: prop, oldValue, newValue, requiresRecreate: false });
+            }
+        }
+        else if (oldValue !== newValue) {
+            changes.push({ property: prop, oldValue, newValue, requiresRecreate: false });
+        }
+    }
+    for (const prop of immutableProps) {
+        const oldValue = getOldVal(prop);
+        const newValue = getNewVal(prop);
+        if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+            if (oldValue.length !== newValue.length || oldValue.some((v, i) => v !== newValue[i])) {
+                changes.push({ property: prop, oldValue, newValue, requiresRecreate: true });
+            }
+        }
+        else if (oldValue !== newValue) {
+            changes.push({ property: prop, oldValue, newValue, requiresRecreate: true });
+        }
+    }
+    // Type change requires recreate (normalize string+elements to enum on old side)
+    const oldTypeRaw = String(oldColumn?.type || oldColumn?.columnType || '').toLowerCase();
+    const oldHasElements = Array.isArray(oldColumn?.elements) && oldColumn.elements.length > 0;
+    const oldType = oldTypeRaw === 'string' && oldHasElements ? 'enum' : oldTypeRaw;
+    if (oldType && t && oldType !== t && TYPE_CHANGE_REQUIRES_RECREATE.includes(oldType)) {
+        changes.push({ property: 'type', oldValue: oldType, newValue: t, requiresRecreate: true });
+    }
+    return changes;
+}
+/**
+ * Analyze what changes are needed for a specific column
+ */
+function analyzeColumnChanges(oldColumn, newAttribute) {
+    const columnType = String(newAttribute.type || 'string').toLowerCase();
+    const columnKey = newAttribute.key;
+    // Use normalized comparison to reduce false positives then property-wise details
+    const normalizedOld = normalizeColumnToComparable(oldColumn);
+    const normalizedNew = normalizeAttributeToComparable(newAttribute);
+    const hasAnyDiff = !shallowEqual(normalizedOld, normalizedNew);
+    const changes = hasAnyDiff ? compareColumnProperties(oldColumn, newAttribute, columnType) : [];
+    const requiresRecreate = changes.some((c) => c.requiresRecreate);
+    const mutableChanges = {};
+    const immutableChanges = {};
+    for (const c of changes) {
+        if (c.requiresRecreate)
+            immutableChanges[c.property] = { old: c.oldValue, new: c.newValue };
+        else
+            mutableChanges[c.property] = { old: c.oldValue, new: c.newValue };
+    }
+    return {
+        columnKey,
+        columnType,
+        hasChanges: changes.length > 0,
+        requiresRecreate,
+        changes,
+        mutableChanges,
+        immutableChanges,
+    };
+}
+/**
+ * Enhanced version of columns diff with detailed change analysis
+ * Order: desired first, then existing (matches internal usage here)
+ */
+export function diffColumnsDetailed(desiredAttributes, existingColumns) {
+    const byKey = new Map((existingColumns || []).map((col) => [col?.key, col]));
+    const toCreate = [];
+    const toUpdate = [];
+    const toRecreate = [];
+    const unchanged = [];
+    for (const attr of desiredAttributes || []) {
+        const key = attr?.key;
+        const existing = key ? byKey.get(key) : undefined;
+        if (!existing) {
+            toCreate.push(attr);
+            continue;
+        }
+        const analysis = analyzeColumnChanges(existing, attr);
+        if (!analysis.hasChanges)
+            unchanged.push(analysis.columnKey);
+        else if (analysis.requiresRecreate)
+            toRecreate.push({ oldAttribute: existing, newAttribute: attr });
+        else
+            toUpdate.push({ attribute: attr, changes: analysis.changes });
+    }
+    // Note: we keep toDelete empty for now (conservative behavior)
+    return { toCreate, toUpdate, toRecreate, toDelete: [], unchanged };
+}
+/**
+ * Returns true if there is any difference between existing columns and desired attributes
+ */
+export function areTableColumnsDiff(existingColumns, desired) {
+    const byKey = new Map();
+    for (const c of existingColumns || []) {
+        if (c?.key)
+            byKey.set(c.key, c);
+    }
+    for (const attr of desired || []) {
+        const desiredNorm = normalizeAttributeToComparable(attr);
+        const existing = byKey.get(desiredNorm.key);
+        if (!existing)
+            return true;
+        const existingNorm = normalizeColumnToComparable(existing);
+        if (!shallowEqual(desiredNorm, existingNorm))
+            return true;
+    }
+    // Extra columns on remote also constitute a diff
+    const desiredKeys = new Set((desired || []).map((a) => a.key));
+    for (const k of byKey.keys())
+        if (!desiredKeys.has(k))
+            return true;
+    return false;
+}
+export function diffTableColumns(existingColumns, desired) {
+    // Use detailed plan but return legacy structure for compatibility
+    const plan = diffColumnsDetailed(desired, existingColumns);
+    const toUpdate = [
+        ...plan.toUpdate.map((u) => u.attribute),
+        ...plan.toRecreate.map((r) => r.newAttribute),
+    ];
+    return { toCreate: plan.toCreate, toUpdate, unchanged: plan.unchanged };
+}
+/**
+ * Execute the column operation plan using the adapter
+ */
+export async function executeColumnOperations(adapter, databaseId, tableId, plan) {
+    if (!databaseId || !tableId)
+        throw new Error('Database ID and Table ID are required for column operations');
+    if (!adapter || typeof adapter.createAttribute !== 'function')
+        throw new Error('Valid adapter is required for column operations');
+    const results = { success: [], errors: [] };
+    const exec = async (fn, key, op) => {
+        try {
+            await fn();
+            results.success.push(`${op}: ${key}`);
+        }
+        catch (e) {
+            results.errors.push({ column: key, error: `${op} failed: ${e?.message || String(e)}` });
+        }
+    };
+    for (const attr of plan.toCreate) {
+        const params = mapToCreateAttributeParams(attr, { databaseId, tableId });
+        await exec(() => adapter.createAttribute(params), attr.key, 'CREATE');
+    }
+    for (const { attribute } of plan.toUpdate) {
+        const params = mapToUpdateAttributeParams(attribute, { databaseId, tableId });
+        await exec(() => adapter.updateAttribute(params), attribute.key, 'UPDATE');
+    }
+    for (const { oldAttribute, newAttribute } of plan.toRecreate) {
+        await exec(() => adapter.deleteAttribute({ databaseId, tableId, key: oldAttribute.key }), oldAttribute.key, 'DELETE (for recreate)');
+        // Wait until the attribute is actually removed (or no longer 'deleting') before recreating
+        try {
+            const start = Date.now();
+            const maxWaitMs = 60000; // 60s
+            while (Date.now() - start < maxWaitMs) {
+                try {
+                    const tableRes = await adapter.getTable({ databaseId, tableId });
+                    const cols = (tableRes?.data?.columns || tableRes?.data?.attributes || []);
+                    const found = cols.find((c) => c.key === oldAttribute.key);
+                    if (!found)
+                        break; // fully removed
+                    if (found.status && found.status !== 'deleting')
+                        break; // no longer deleting (failed/stuck) -> stop waiting
+                }
+                catch { }
+                await new Promise((r) => setTimeout(r, 1500));
+            }
+        }
+        catch { }
+        const params = mapToCreateAttributeParams(newAttribute, { databaseId, tableId });
+        await exec(() => adapter.createAttribute(params), newAttribute.key, 'CREATE (after recreate)');
+    }
+    return results;
+}
+/**
+ * Integration function for methods.ts - processes columns using enhanced logic
+ */
+export async function processTableColumns(adapter, databaseId, tableId, desiredAttributes, existingColumns = []) {
+    if (!existingColumns || existingColumns.length === 0) {
+        const tableInfo = await adapter.getTable({ databaseId, tableId });
+        existingColumns = (tableInfo?.data?.columns || tableInfo?.data?.attributes || []);
+    }
+    const plan = diffColumnsDetailed(desiredAttributes, existingColumns);
+    const results = await executeColumnOperations(adapter, databaseId, tableId, plan);
+    return {
+        totalProcessed: plan.toCreate.length + plan.toUpdate.length + plan.toRecreate.length,
+        success: results.success,
+        errors: results.errors,
+        summary: {
+            created: plan.toCreate.length,
+            updated: plan.toUpdate.length,
+            recreated: plan.toRecreate.length,
+            unchanged: plan.unchanged.length,
+        },
+    };
+}

package/dist/collections/transferOperations.d.ts

@@ -1,7 +1,8 @@
 import { Databases } from "node-appwrite";
+import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
 /**
  * Transfers all documents from one collection to another in a different database
  * within the same Appwrite Project
  */
-export declare const transferDocumentsBetweenDbsLocalToLocal: (db: Databases, fromDbId: string, toDbId: string, fromCollId: string, toCollId: string) => Promise<void>;
-export declare const transferDocumentsBetweenDbsLocalToRemote: (localDb: Databases, endpoint: string, projectId: string, apiKey: string, fromDbId: string, toDbId: string, fromCollId: string, toCollId: string) => Promise<void>;
+export declare const transferDocumentsBetweenDbsLocalToLocal: (db: Databases | DatabaseAdapter, fromDbId: string, toDbId: string, fromCollId: string, toCollId: string) => Promise<void>;
+export declare const transferDocumentsBetweenDbsLocalToRemote: (localDb: Databases | DatabaseAdapter, endpoint: string, projectId: string, apiKey: string, fromDbId: string, toDbId: string, fromCollId: string, toCollId: string) => Promise<void>;

package/dist/collections/transferOperations.js

@@ -2,12 +2,62 @@ import { Client, Databases, ID, Query, } from "node-appwrite";
 import { tryAwaitWithRetry, delay, calculateExponentialBackoff } from "../utils/helperFunctions.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { chunk } from "es-toolkit";
+import { isLegacyDatabases } from "../utils/typeGuards.js";
+import { getAdapter } from "../utils/getClientFromConfig.js";
 /**
  * Transfers all documents from one collection to another in a different database
  * within the same Appwrite Project
  */
 export const transferDocumentsBetweenDbsLocalToLocal = async (db, fromDbId, toDbId, fromCollId, toCollId) => {
-    let fromCollDocs = await tryAwaitWithRetry(async () => db.listDocuments(fromDbId, fromCollId, [Query.limit(50)]));
+    // Use adapter path when available for bulk operations
+    if (!isLegacyDatabases(db)) {
+        const adapter = db;
+        const pageSize = 1000;
+        let lastId;
+        let totalTransferred = 0;
+        while (true) {
+            const queries = [Query.limit(pageSize)];
+            if (lastId)
+                queries.push(Query.cursorAfter(lastId));
+            const result = await adapter.listRows({ databaseId: fromDbId, tableId: fromCollId, queries });
+            const rows = result.rows || result.documents || [];
+            if (!rows.length)
+                break;
+            // Prepare rows: strip system fields, keep $id and $permissions
+            const prepared = rows.map((doc) => {
+                const data = { ...doc };
+                delete data.$databaseId;
+                delete data.$collectionId;
+                delete data.$createdAt;
+                delete data.$updatedAt;
+                return data; // keep $id and $permissions for upsert
+            });
+            // Prefer bulk upsert, then bulk create, then individual
+            if (typeof adapter.bulkUpsertRows === 'function' && adapter.supportsBulkOperations()) {
+                await adapter.bulkUpsertRows({ databaseId: toDbId, tableId: toCollId, rows: prepared });
+            }
+            else if (typeof adapter.bulkCreateRows === 'function' && adapter.supportsBulkOperations()) {
+                await adapter.bulkCreateRows({ databaseId: toDbId, tableId: toCollId, rows: prepared });
+            }
+            else {
+                for (const row of prepared) {
+                    const id = row.$id || ID.unique();
+                    const permissions = row.$permissions || [];
+                    const { $id, $permissions, ...data } = row;
+                    await adapter.createRow({ databaseId: toDbId, tableId: toCollId, id, data, permissions });
+                }
+            }
+            totalTransferred += rows.length;
+            if (rows.length < pageSize)
+                break;
+            lastId = rows[rows.length - 1].$id;
+        }
+        MessageFormatter.success(`Transferred ${totalTransferred} rows from ${fromDbId}/${fromCollId} to ${toDbId}/${toCollId}`, { prefix: "Transfer" });
+        return;
+    }
+    // Legacy path (Databases) – keep existing behavior
+    const legacyDb = db;
+    let fromCollDocs = await tryAwaitWithRetry(async () => legacyDb.listDocuments(fromDbId, fromCollId, [Query.limit(50)]));
     let totalDocumentsTransferred = 0;
     if (fromCollDocs.documents.length === 0) {
         MessageFormatter.info(`No documents found in collection ${fromCollId}`, { prefix: "Transfer" });
@@ -24,7 +74,7 @@ export const transferDocumentsBetweenDbsLocalToLocal = async (db, fromDbId, toDb
             delete toCreateObject.$updatedAt;
             delete toCreateObject.$id;
             delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => await db.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
+            return tryAwaitWithRetry(async () => await legacyDb.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
         });
         await Promise.all(batchedPromises);
         totalDocumentsTransferred += fromCollDocs.documents.length;
@@ -40,12 +90,12 @@ export const transferDocumentsBetweenDbsLocalToLocal = async (db, fromDbId, toDb
             delete toCreateObject.$updatedAt;
             delete toCreateObject.$id;
             delete toCreateObject.$permissions;
-            return tryAwaitWithRetry(async () => db.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
+            return tryAwaitWithRetry(async () => legacyDb.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
         });
         await Promise.all(batchedPromises);
         totalDocumentsTransferred += fromCollDocs.documents.length;
         while (fromCollDocs.documents.length === 50) {
-            fromCollDocs = await tryAwaitWithRetry(async () => await db.listDocuments(fromDbId, fromCollId, [
+            fromCollDocs = await tryAwaitWithRetry(async () => await legacyDb.listDocuments(fromDbId, fromCollId, [
                 Query.limit(50),
                 Query.cursorAfter(fromCollDocs.documents[fromCollDocs.documents.length - 1].$id),
             ]));
@@ -59,7 +109,7 @@ export const transferDocumentsBetweenDbsLocalToLocal = async (db, fromDbId, toDb
                 delete toCreateObject.$updatedAt;
                 delete toCreateObject.$id;
                 delete toCreateObject.$permissions;
-                return tryAwaitWithRetry(async () => await db.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
+                return tryAwaitWithRetry(async () => await legacyDb.createDocument(toDbId, toCollId, doc.$id, toCreateObject, doc.$permissions));
             });
             await Promise.all(batchedPromises);
             totalDocumentsTransferred += fromCollDocs.documents.length;
@@ -282,11 +332,9 @@ const transferDocumentBatchWithRetry = async (db, client, dbId, collectionId, do
 };
 export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId, fromCollId, toCollId) => {
     MessageFormatter.info(`Starting enhanced document transfer from ${fromCollId} to ${toCollId}...`, { prefix: "Transfer" });
-    const client = new Client()
-        .setEndpoint(endpoint)
-        .setProject(projectId)
-        .setKey(apiKey);
-    const remoteDb = new Databases(client);
+    // Prefer adapter for remote to enable bulk operations
+    const { adapter: remoteAdapter, client } = await getAdapter(endpoint, projectId, apiKey, 'auto');
+    const remoteDb = new Databases(client); // Legacy fallback for HTTP/individual
     let totalDocumentsProcessed = 0;
     let totalSuccessful = 0;
     let totalFailed = 0;
@@ -298,13 +346,46 @@ export const transferDocumentsBetweenDbsLocalToRemote = async (localDb, endpoint
         if (lastDocumentId) {
             queries.push(Query.cursorAfter(lastDocumentId));
         }
-        const fromCollDocs = await tryAwaitWithRetry(async () => localDb.listDocuments(fromDbId, fromCollId, queries));
+        const fromCollDocs = await tryAwaitWithRetry(async () => {
+            if (isLegacyDatabases(localDb)) {
+                return localDb.listDocuments(fromDbId, fromCollId, queries);
+            }
+            else {
+                const res = await localDb.listRows({ databaseId: fromDbId, tableId: fromCollId, queries });
+                const rows = res.rows || res.documents || [];
+                return { documents: rows };
+            }
+        });
         if (fromCollDocs.documents.length === 0) {
             hasMoreDocuments = false;
             break;
         }
         MessageFormatter.progress(`Fetched ${fromCollDocs.documents.length} documents, processing for transfer...`, { prefix: "Transfer" });
-        const { successful, failed } = await transferDocumentBatchWithRetry(remoteDb, client, toDbId, toCollId, fromCollDocs.documents);
+        // Prefer remote adapter bulk upsert if available
+        const prepared = fromCollDocs.documents.map((doc) => {
+            const data = { ...doc };
+            delete data.$databaseId;
+            delete data.$collectionId;
+            delete data.$createdAt;
+            delete data.$updatedAt;
+            return data; // Keep $id and $permissions for upsert
+        });
+        let successful = 0;
+        let failed = 0;
+        if (typeof remoteAdapter.bulkUpsertRows === 'function' && remoteAdapter.supportsBulkOperations()) {
+            try {
+                await remoteAdapter.bulkUpsertRows({ databaseId: toDbId, tableId: toCollId, rows: prepared });
+                successful = prepared.length;
+            }
+            catch (e) {
+                MessageFormatter.warning('Remote adapter bulk upsert failed, falling back to HTTP/individual', { prefix: 'Transfer' });
+            }
+        }
+        if (successful === 0) {
+            const res = await transferDocumentBatchWithRetry(remoteDb, client, toDbId, toCollId, fromCollDocs.documents);
+            successful = res.successful;
+            failed = res.failed;
+        }
         totalDocumentsProcessed += fromCollDocs.documents.length;
         totalSuccessful += successful;
         totalFailed += failed;