@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.0

package/dist/migrations/comprehensiveTransfer.js

@@ -1,10 +1,9 @@
 import { converterFunctions, tryAwaitWithRetry, parseAttribute, objectNeedsUpdate, } from "@njdamstra/appwrite-utils";
 import { Client, Databases, Storage, Users, Functions, Teams, Query, AppwriteException, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter, getClient } from "@njdamstra/appwrite-utils-helpers";
 import { processQueue, queuedOperations } from "../shared/operationQueue.js";
 import { ProgressManager } from "../shared/progressManager.js";
-import { getClient } from "../utils/getClientFromConfig.js";
 import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote, } from "./transfer.js";
 import { deployLocalFunction } from "../functions/deployments.js";
 import { listFunctions, downloadLatestFunctionDeployment, } from "../functions/methods.js";
@@ -12,8 +11,7 @@ import pLimit from "p-limit";
 import chalk from "chalk";
 import { join } from "node:path";
 import fs from "node:fs";
-import { getAdapter } from "../utils/getClientFromConfig.js";
-import { mapToCreateAttributeParams } from "../shared/attributeMapper.js";
+import { getAdapter, mapToCreateAttributeParams } from "@njdamstra/appwrite-utils-helpers";
 export class ComprehensiveTransfer {
     options;
     sourceClient;
@@ -714,7 +712,7 @@ export class ComprehensiveTransfer {
                         specification: func.specification,
                         dirPath: functionPath,
                     };
-                    await deployLocalFunction(this.targetClient, func.name, functionConfig);
+                    await deployLocalFunction(this.targetClient, func.name, functionConfig, undefined, this.tempDir);
                     this.results.functions.transferred++;
                     MessageFormatter.success(`Function ${func.name} transferred successfully`, { prefix: "Transfer" });
                 }

package/dist/migrations/dataLoader.js

@@ -1,18 +1,15 @@
 import { AttributeMappingsSchema, CollectionCreateSchema, importDefSchema, } from "@njdamstra/appwrite-utils";
 import path from "path";
 import fs from "fs";
-import { convertObjectByAttributeMappings } from "../utils/dataConverters.js";
+import { convertObjectByAttributeMappings } from "@njdamstra/appwrite-utils-helpers";
 import { z } from "zod";
 import { checkForCollection } from "../collections/methods.js";
 import { ID, Users } from "node-appwrite";
-import { logger } from "../shared/logging.js";
+import { logger, LegacyAdapter, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import { findOrCreateOperation, updateOperation } from "../shared/migrationHelpers.js";
 import { AuthUserCreateSchema } from "../schemas/authUser.js";
-import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
 import { UsersController } from "../users/methods.js";
-import { finalizeByAttributeMap } from "../utils/helperFunctions.js";
 import { isEmpty } from "es-toolkit/compat";
-import { MessageFormatter } from "../shared/messageFormatter.js";
 // Define a schema for the structure of collection import data using Zod for validation
 export const CollectionImportDataSchema = z.object({
     // Optional collection creation schema

package/dist/migrations/importController.js

@@ -1,14 +1,13 @@
 import { AppwriteException, ID, Query, } from "node-appwrite";
-import { areCollectionNamesSame, tryAwaitWithRetry } from "../utils/index.js";
+import { areCollectionNamesSame, tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { resolveAndUpdateRelationships } from "./relationships.js";
 import { UsersController } from "../users/methods.js";
-import { logger } from "../shared/logging.js";
+import { logger, LegacyAdapter } from "@njdamstra/appwrite-utils-helpers";
 import { updateOperation } from "../shared/migrationHelpers.js";
-import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
 import { BatchSchema, OperationCreateSchema, OperationSchema, } from "../storage/schemas.js";
 import { DataLoader } from "./dataLoader.js";
 import { transferDatabaseLocalToLocal, transferStorageLocalToLocal, } from "./transfer.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
 export class ImportController {
     config;

package/dist/migrations/importDataActions.js

@@ -1,11 +1,11 @@
 import {} from "node-appwrite";
 import { validationRules, } from "@njdamstra/appwrite-utils";
 import { converterFunctions } from "@njdamstra/appwrite-utils";
-import { convertObjectBySchema } from "../utils/dataConverters.js";
+import { convertObjectBySchema } from "@njdamstra/appwrite-utils-helpers";
 import {} from "@njdamstra/appwrite-utils";
 import { afterImportActions } from "./afterImportActions.js";
-import { logger } from "../shared/logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { logger } from "@njdamstra/appwrite-utils-helpers";
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 export class ImportDataActions {
     db;
     storage;

package/dist/migrations/relationships.js

@@ -1,7 +1,6 @@
 import { Databases, Query } from "node-appwrite";
 import { fetchAllCollections } from "../collections/methods.js";
-import { logger } from "../shared/logging.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { logger, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Finds collections that have defined relationship attributes.
  */

package/dist/migrations/services/DataTransformationService.js

@@ -1,5 +1,5 @@
-import { convertObjectByAttributeMappings } from "../../utils/dataConverters.js";
-import { logger } from "../../shared/logging.js";
+import { convertObjectByAttributeMappings } from "@njdamstra/appwrite-utils-helpers";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Service responsible for data transformation during import.
  * Extracted from DataLoader to provide focused, testable transformation logic.

package/dist/migrations/services/FileHandlerService.js

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 import { RateLimitManager } from "./RateLimitManager.js";
 /**
  * Service responsible for file handling during import.

package/dist/migrations/services/ImportOrchestrator.js

@@ -8,12 +8,12 @@ import { UserMappingService } from "./UserMappingService.js";
 import { ValidationService } from "./ValidationService.js";
 import { RelationshipResolver } from "./RelationshipResolver.js";
 import { UsersController } from "../../users/methods.js";
-import { logger } from "../../shared/logging.js";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 import { ProgressManager } from "../../shared/progressManager.js";
-import { tryAwaitWithRetry } from "../../utils/index.js";
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { updateOperation, findOrCreateOperation } from "../../shared/migrationHelpers.js";
-import { LegacyAdapter } from "../../adapters/LegacyAdapter.js";
+import { LegacyAdapter } from '@njdamstra/appwrite-utils-helpers';
 import { resolveAndUpdateRelationships } from "../relationships.js";
 // Enhanced rate limiting configuration - now managed by RateLimitManager
 /**

package/dist/migrations/services/RateLimitManager.js

@@ -1,5 +1,5 @@
 import pLimit from "p-limit";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Manages rate limiting across the import system.
  * Provides configurable p-limit instances for different operation types.

package/dist/migrations/services/RelationshipResolver.js

@@ -1,4 +1,4 @@
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 import { isEmpty } from "es-toolkit/compat";
 /**
  * Service responsible for resolving relationships and ID mappings during import.

package/dist/migrations/services/UserMappingService.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ID } from "node-appwrite";
 import { AuthUserCreateSchema } from "../../schemas/authUser.js";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Service responsible for user mapping and deduplication during import.
  * Preserves all existing sophisticated user handling logic from DataLoader.

package/dist/migrations/services/ValidationService.js

@@ -1,4 +1,4 @@
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 import fs from "fs";
 import path from "path";
 /**

package/dist/migrations/transfer.d.ts

@@ -1,4 +1,5 @@
 import { Databases, Storage, Users, type Models } from "node-appwrite";
+import { type DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 export interface TransferOptions {
     fromDb: Models.Database | undefined;
     targetDb: Models.Database | undefined;
@@ -14,13 +15,16 @@ export interface TransferOptions {
 export declare const transferStorageLocalToLocal: (storage: Storage, fromBucketId: string, toBucketId: string) => Promise<void>;
 export declare const transferStorageLocalToRemote: (localStorage: Storage, endpoint: string, projectId: string, apiKey: string, fromBucketId: string, toBucketId: string) => Promise<void>;
 /**
- * Transfers all collections and documents from one local database to another local database.
+ * Transfers all tables/collections and documents from one local database to another local database.
+ * Uses the DatabaseAdapter for unified TablesDB / legacy support.
  *
- * @param {Databases} localDb - The local database instance.
+ * @param {Databases} localDb - The local database instance (kept for signature compat).
  * @param {string} fromDbId - The ID of the source database.
  * @param {string} targetDbId - The ID of the target database.
+ * @param {string[]} collectionIds - Optional filter: specific table/collection IDs to transfer. undefined = all, empty array = none.
+ * @param {DatabaseAdapter} adapter - The database adapter (TablesDB or Legacy).
  * @return {Promise<void>} A promise that resolves when the transfer is complete.
  */
-export declare const transferDatabaseLocalToLocal: (localDb: Databases, fromDbId: string, targetDbId: string) => Promise<void>;
-export declare const transferDatabaseLocalToRemote: (localDb: Databases, endpoint: string, projectId: string, apiKey: string, fromDbId: string, toDbId: string) => Promise<void>;
+export declare const transferDatabaseLocalToLocal: (localDb: Databases, fromDbId: string, targetDbId: string, collectionIds?: string[], adapter?: DatabaseAdapter) => Promise<void>;
+export declare const transferDatabaseLocalToRemote: (localDb: Databases, endpoint: string, projectId: string, apiKey: string, fromDbId: string, toDbId: string, collectionIds?: string[]) => Promise<void>;
 export declare const transferUsersLocalToRemote: (localUsers: Users, endpoint: string, projectId: string, apiKey: string) => Promise<void>;

package/dist/migrations/transfer.js

@@ -1,17 +1,16 @@
 import { converterFunctions, tryAwaitWithRetry } from "@njdamstra/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 { getAppwriteClient } from "@njdamstra/appwrite-utils-helpers";
 // Legacy attribute helpers retained only for local-to-local flows if needed
 import { parseAttribute } from "@njdamstra/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 { MessageFormatter, mapToCreateAttributeParams } from "@njdamstra/appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
-import { getClient, getAdapter } from "../utils/getClientFromConfig.js";
+import { getClient, getAdapter } from "@njdamstra/appwrite-utils-helpers";
 import { diffTableColumns } from "../collections/tableOperations.js";
-import { mapToCreateAttributeParams } from "../shared/attributeMapper.js";
+import { LegacyAdapter } from "@njdamstra/appwrite-utils-helpers";
 export const transferStorageLocalToLocal = async (storage, fromBucketId, toBucketId) => {
     MessageFormatter.info(`Transferring files from ${fromBucketId} to ${toBucketId}`, { prefix: "Transfer" });
     let lastFileId;
@@ -130,51 +129,96 @@ export const transferStorageLocalToRemote = async (localStorage, endpoint, proje
 // Document transfer functions moved to collections/methods.ts with enhanced UX
 // Remote document transfer functions moved to collections/methods.ts with enhanced UX
 /**
- * Transfers all collections and documents from one local database to another local database.
+ * Transfers all tables/collections and documents from one local database to another local database.
+ * Uses the DatabaseAdapter for unified TablesDB / legacy support.
  *
- * @param {Databases} localDb - The local database instance.
+ * @param {Databases} localDb - The local database instance (kept for signature compat).
  * @param {string} fromDbId - The ID of the source database.
  * @param {string} targetDbId - The ID of the target database.
+ * @param {string[]} collectionIds - Optional filter: specific table/collection IDs to transfer. undefined = all, empty array = none.
+ * @param {DatabaseAdapter} adapter - The database adapter (TablesDB or Legacy).
  * @return {Promise<void>} A promise that resolves when the transfer is complete.
  */
-export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId) => {
-    MessageFormatter.info(`Starting database transfer from ${fromDbId} to ${targetDbId}`, { prefix: "Transfer" });
-    // Get all collections from source database
-    const sourceCollections = await fetchAllCollections(fromDbId, localDb);
-    MessageFormatter.info(`Found ${sourceCollections.length} collections in source database`, { prefix: "Transfer" });
-    // Process each collection
-    for (const collection of sourceCollections) {
-        MessageFormatter.processing(`Processing collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
+export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId, collectionIds, adapter) => {
+    // If no adapter provided, fall back to creating a LegacyAdapter from the Databases client
+    const dbAdapter = adapter || new LegacyAdapter(localDb.client);
+    MessageFormatter.info(`Starting database transfer from ${fromDbId} to ${targetDbId} (mode: ${dbAdapter.getApiMode()})`, { prefix: "Transfer" });
+    // Get all tables/collections from source database via adapter
+    const sourceListRes = await dbAdapter.listTables({ databaseId: fromDbId, queries: [Query.limit(500)] });
+    let sourceTables = sourceListRes.tables || sourceListRes.collections || sourceListRes.data || [];
+    // Filter by collectionIds if provided (match by $id or by name)
+    if (collectionIds !== undefined) {
+        if (collectionIds.length === 0) {
+            MessageFormatter.info("No tables/collections selected for transfer, skipping.", { prefix: "Transfer" });
+            return;
+        }
+        const idSet = new Set(collectionIds);
+        sourceTables = sourceTables.filter((c) => idSet.has(c.$id) || idSet.has(c.name));
+    }
+    MessageFormatter.info(`Found ${sourceTables.length} tables/collections in source database`, { prefix: "Transfer" });
+    // Process each table/collection
+    for (const table of sourceTables) {
+        MessageFormatter.processing(`Processing table: ${table.name} (${table.$id})`, { prefix: "Transfer" });
         try {
-            // Create or update collection in target
-            let targetCollection;
-            const existingCollection = await tryAwaitWithRetry(async () => localDb.listCollections(targetDbId, [
-                Query.equal("$id", collection.$id),
-            ]));
-            if (existingCollection.collections.length > 0) {
-                targetCollection = existingCollection.collections[0];
-                MessageFormatter.info(`Collection ${collection.name} exists in target database`, { prefix: "Transfer" });
-                // Update collection if needed
-                if (targetCollection.name !== collection.name ||
-                    targetCollection.$permissions !== collection.$permissions ||
-                    targetCollection.documentSecurity !== collection.documentSecurity ||
-                    targetCollection.enabled !== collection.enabled) {
-                    targetCollection = await tryAwaitWithRetry(async () => localDb.updateCollection(targetDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
-                    MessageFormatter.success(`Collection ${collection.name} updated`, { prefix: "Transfer" });
+            // Check if table exists in target via adapter
+            let targetTableId = table.$id;
+            let targetTableData;
+            try {
+                const existingRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: table.$id });
+                targetTableData = existingRes.data || (existingRes.tables && existingRes.tables[0]);
+                if (targetTableData) {
+                    MessageFormatter.info(`Table ${table.name} exists in target database`, { prefix: "Transfer" });
+                    // Update table if needed
+                    const securityField = table.rowSecurity ?? table.documentSecurity ?? false;
+                    const targetSecurity = targetTableData.rowSecurity ?? targetTableData.documentSecurity ?? false;
+                    if (targetTableData.name !== table.name ||
+                        JSON.stringify(targetTableData.$permissions) !== JSON.stringify(table.$permissions) ||
+                        targetSecurity !== securityField ||
+                        targetTableData.enabled !== table.enabled) {
+                        await tryAwaitWithRetry(async () => dbAdapter.updateTable({
+                            databaseId: targetDbId,
+                            id: table.$id,
+                            name: table.name,
+                            permissions: table.$permissions,
+                            documentSecurity: table.documentSecurity,
+                            rowSecurity: table.rowSecurity,
+                            enabled: table.enabled,
+                        }));
+                        MessageFormatter.success(`Table ${table.name} updated`, { prefix: "Transfer" });
+                    }
                 }
             }
-            else {
-                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));
+            catch {
+                // Table does not exist in target, create it
+                targetTableData = null;
             }
-            // 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));
+            if (!targetTableData) {
+                MessageFormatter.progress(`Creating table ${table.name} in target database...`, { prefix: "Transfer" });
+                const createRes = await tryAwaitWithRetry(async () => dbAdapter.createTable({
+                    databaseId: targetDbId,
+                    id: table.$id,
+                    name: table.name,
+                    permissions: table.$permissions,
+                    documentSecurity: table.documentSecurity,
+                    rowSecurity: table.rowSecurity,
+                    enabled: table.enabled,
+                }));
+                targetTableData = createRes.data || (createRes.tables && createRes.tables[0]);
+            }
+            // Create attributes via adapter
+            MessageFormatter.info(`Creating attributes for ${table.name} via adapter...`, { prefix: 'Transfer' });
+            // Fetch existing attributes in target to skip already-created ones
+            const targetTableRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: targetTableId });
+            const targetInfo = targetTableRes.data || (targetTableRes.tables && targetTableRes.tables[0]);
+            const existingAttrs = targetInfo?.attributes || targetInfo?.columns || [];
+            const existingKeys = new Set(existingAttrs.map((a) => a.key || a.$id));
+            const uniformAttrs = (table.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);
+                if (existingKeys.has(attr.key))
+                    continue;
+                const params = mapToCreateAttributeParams(attr, { databaseId: targetDbId, tableId: targetTableId });
+                await dbAdapter.createAttribute(params);
                 await new Promise((r) => setTimeout(r, 150));
             }
             // Wait for attributes to become available
@@ -184,8 +228,9 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
                 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 tableRes = await dbAdapter.getTable({ databaseId: targetDbId, tableId: targetTableId });
+                        const tInfo = tableRes.data || (tableRes.tables && tableRes.tables[0]);
+                        const attrs = tInfo?.attributes || tInfo?.columns || [];
                         const found = attrs.find((a) => a.key === attr.key);
                         if (found) {
                             if (found.status === 'available')
@@ -208,16 +253,18 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
             // 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);
+                if (existingKeys.has(attr.key))
+                    continue;
+                const params = mapToCreateAttributeParams(attr, { databaseId: targetDbId, tableId: targetTableId });
+                await dbAdapter.createAttribute(params);
                 await new Promise((r) => setTimeout(r, 150));
             }
             // Handle indexes via adapter (create or update)
-            for (const idx of collection.indexes) {
+            for (const idx of (table.indexes || [])) {
                 try {
-                    await localAdapter.createIndex({
+                    await dbAdapter.createIndex({
                         databaseId: targetDbId,
-                        tableId: targetCollection.$id,
+                        tableId: targetTableId,
                         key: idx.key,
                         type: idx.type,
                         attributes: idx.attributes,
@@ -229,10 +276,10 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
                 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({
+                        await dbAdapter.deleteIndex({ databaseId: targetDbId, tableId: targetTableId, key: idx.key });
+                        await dbAdapter.createIndex({
                             databaseId: targetDbId,
-                            tableId: targetCollection.$id,
+                            tableId: targetTableId,
                             key: idx.key,
                             type: idx.type,
                             attributes: idx.attributes,
@@ -246,20 +293,24 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
                     }
                 }
             }
-            // Transfer documents
-            const { transferDocumentsBetweenDbsLocalToLocal } = await import("../collections/methods.js");
-            await transferDocumentsBetweenDbsLocalToLocal(localDb, fromDbId, targetDbId, collection.$id, targetCollection.$id);
+            // Transfer documents/rows via adapter
+            const { transferDocumentsBetweenDbsLocalToLocal } = await import("../collections/transferOperations.js");
+            await transferDocumentsBetweenDbsLocalToLocal(dbAdapter, fromDbId, targetDbId, table.$id, targetTableId);
         }
         catch (error) {
-            MessageFormatter.error(`Error processing collection ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            MessageFormatter.error(`Error processing table ${table.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
         }
     }
 };
-export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId) => {
+export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId, apiKey, fromDbId, toDbId, collectionIds) => {
     const client = getAppwriteClient(endpoint, projectId, apiKey);
     const remoteDb = new Databases(client);
     // Get all collections from source database
-    const sourceCollections = await fetchAllCollections(fromDbId, localDb);
+    let sourceCollections = await fetchAllCollections(fromDbId, localDb);
+    if (collectionIds && collectionIds.length > 0) {
+        const idSet = new Set(collectionIds);
+        sourceCollections = sourceCollections.filter((c) => idSet.has(c.$id));
+    }
     MessageFormatter.info(`Found ${sourceCollections.length} collections in source database`, { prefix: "Transfer" });
     // Process each collection
     for (const collection of sourceCollections) {

package/dist/migrations/yaml/YamlImportConfigLoader.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import path from "path";
 import fs from "fs";
 import yaml from "js-yaml";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 // YAML Import Configuration Schema
 export const YamlImportConfigSchema = z.object({
     source: z.object({

package/dist/migrations/yaml/YamlImportIntegration.js

@@ -1,7 +1,7 @@
 import { YamlImportConfigLoader } from "./YamlImportConfigLoader.js";
 import { createImportSchemas, createImportExamples } from "./generateImportSchemas.js";
-import { logger } from "../../shared/logging.js";
-import { normalizeYamlData, usesTableTerminology, convertTerminology } from "../../utils/yamlConverter.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { normalizeYamlData, usesTableTerminology, convertTerminology } from "@njdamstra/appwrite-utils-helpers";
 import path from "path";
 import fs from "fs";
 import yaml from "js-yaml";

package/dist/migrations/yaml/generateImportSchemas.js

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { logger } from "../../shared/logging.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Generates JSON Schema for YAML import configurations.
  * Provides IntelliSense support for YAML files in IDEs.

package/dist/setupCommands.d.ts

@@ -1,4 +1,4 @@
-import { type ApiMode } from "./utils/versionDetection.js";
+import { type ApiMode } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Terminology configuration for API mode-specific naming
  */

package/dist/setupCommands.js

@@ -1,12 +1,11 @@
 import { mkdirSync, writeFileSync, existsSync } from "node:fs";
 import path from "node:path";
 import { ulid } from "ulidx";
-import { MessageFormatter } from "./shared/messageFormatter.js";
-import { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from "./utils/versionDetection.js";
-import { loadAppwriteProjectConfig, findAppwriteProjectConfig, isTablesDBProject } from "./utils/projectConfig.js";
-import { findYamlConfig, generateYamlConfigTemplate } from "./config/yamlConfig.js";
-import { loadYamlConfig } from "./config/yamlConfig.js";
-import { hasSessionAuth } from "./utils/sessionAuth.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
+import { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from "@njdamstra/appwrite-utils-helpers";
+import { loadAppwriteProjectConfig, findAppwriteProjectConfig, isTablesDBProject } from "@njdamstra/appwrite-utils-helpers";
+import { findYamlConfig, generateYamlConfigTemplate, loadYamlConfig } from "@njdamstra/appwrite-utils-helpers";
+import { hasSessionAuth } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Get terminology configuration based on API mode
  */

package/dist/setupController.js

@@ -2,7 +2,7 @@ import { setupDirsFiles } from "./utils/setupFiles.js";
 import { loadConfig } from "./utils/loadConfigs.js";
 import path from "path";
 import fs from "fs";
-import { MessageFormatter } from "./shared/messageFormatter.js";
+import { MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 export class SetupController {
     currentDir;
     config = null;

package/dist/shared/backupTracking.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 import { type BackupMetadata } from "./backupMetadataSchema.js";
 /**
  * Creates the backup tracking table in the specified database

package/dist/shared/backupTracking.js

@@ -1,5 +1,5 @@
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { Query, ID } from "node-appwrite";
 import { BACKUP_TABLE_ID, BACKUP_TABLE_NAME, BackupMetadataSchema } from "./backupMetadataSchema.js";
 /**

package/dist/shared/confirmationDialogs.js

@@ -1,6 +1,6 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
-import { MessageFormatter } from "./messageFormatter.js";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 export class ConfirmationDialogs {
     /**
      * Shows a confirmation dialog for destructive operations

package/dist/shared/migrationHelpers.d.ts

@@ -1,6 +1,6 @@
 import { type Databases } from "node-appwrite";
 import { z } from "zod";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 /**
  * Object that contains the context for an action that needs to be executed after import
  * Used in the afterImportActionsDefinitions

package/dist/shared/migrationHelpers.js

@@ -2,10 +2,10 @@ import { ID, Query } from "node-appwrite";
 import { BatchSchema, OperationSchema } from "../storage/schemas.js";
 import { AttributeMappingsSchema } from "@njdamstra/appwrite-utils";
 import { z } from "zod";
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { findOrCreateOperation as findOrCreateOp, updateOperation as updateOp, getOperation as getOp } from "./operationsTable.js";
-import { MessageFormatter } from "./messageFormatter.js";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 /**
  * Object that contains the context for an action that needs to be executed after import
  * Used in the afterImportActionsDefinitions

package/dist/shared/operationQueue.d.ts

@@ -1,6 +1,6 @@
 import { type Databases, type Models } from "node-appwrite";
 import type { Attribute } from "@njdamstra/appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 export interface QueuedOperation {
     type: "attribute";
     collectionId?: string;

package/dist/shared/operationQueue.js

@@ -1,9 +1,8 @@
 import { Query } from "node-appwrite";
 import { createOrUpdateAttributeWithStatusCheck } from "../collections/attributes.js";
 import { fetchAndCacheCollectionByName } from "../collections/methods.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-import { logger } from "../shared/logging.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
+import { logger, MessageFormatter } from "@njdamstra/appwrite-utils-helpers";
 // Global state management
 export const queuedOperations = [];
 export const nameToIdMapping = new Map();

package/dist/shared/operationsTable.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 import { type OperationRecord } from "./operationsTableSchema.js";
 /**
  * Creates the operations tracking table in the specified database

package/dist/shared/operationsTable.js

@@ -1,5 +1,5 @@
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { logger } from '@njdamstra/appwrite-utils-helpers';
+import { tryAwaitWithRetry } from "@njdamstra/appwrite-utils-helpers";
 import { Query, ID } from "node-appwrite";
 import { OPERATIONS_TABLE_ID, OPERATIONS_TABLE_NAME, OperationRecordSchema, } from "./operationsTableSchema.js";
 /**

package/dist/shared/progressManager.js

@@ -1,6 +1,6 @@
 import cliProgress from "cli-progress";
 import chalk from "chalk";
-import { MessageFormatter } from "./messageFormatter.js";
+import { MessageFormatter } from '@njdamstra/appwrite-utils-helpers';
 export class ProgressManager {
     static instances = new Map();
     bar;