appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/migrations/dataLoader.js

@@ -1,18 +1,15 @@
 import { AttributeMappingsSchema, CollectionCreateSchema, importDefSchema, } from "appwrite-utils";
 import path from "path";
 import fs from "fs";
-import { convertObjectByAttributeMappings } from "../utils/dataConverters.js";
+import { convertObjectByAttributeMappings } from "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, AdapterFactory, MessageFormatter } from "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
@@ -50,6 +47,14 @@ export class DataLoader {
     userIdSet = new Set();
     userExistsMap = new Map();
     shouldWriteFile = false;
+    _adapter = null;
+    async getAdapter() {
+        if (!this._adapter) {
+            const { adapter } = await AdapterFactory.createFromConfig(this.config);
+            this._adapter = adapter;
+        }
+        return this._adapter;
+    }
     // Constructor to initialize the DataLoader with necessary configurations
     constructor(appwriteFolderPath, importDataActions, database, config, shouldWriteFile) {
         this.appwriteFolderPath = appwriteFolderPath;
@@ -221,7 +226,7 @@ export class DataLoader {
         // Run additional converter functions on the converted item, if any
         return this.importDataActions.runConverterFunctions(convertedItem, attributeMappings);
     }
-    async setupMaps(dbId) {
+    async setupMaps(dbId, specificCollections) {
         // Initialize the users collection in the import map
         this.importMap.set(this.getCollectionKey("users"), {
             data: [],
@@ -236,6 +241,11 @@ export class DataLoader {
             for (let index = 0; index < this.config.collections.length; index++) {
                 const collectionConfig = this.config.collections[index];
                 let collection = CollectionCreateSchema.parse(collectionConfig);
+                // Skip collections not in the specific list if one was provided
+                if (specificCollections && specificCollections.length > 0 &&
+                    !specificCollections.includes(collection.name)) {
+                    continue;
+                }
                 // Check if the collection exists in the database
                 const collectionExists = await checkForCollection(this.database, db.$id, collection);
                 if (!collectionExists) {
@@ -250,11 +260,15 @@ export class DataLoader {
                 collectionConfig.$id = collectionExists.$id;
                 collection.$id = collectionExists.$id;
                 this.config.collections[index] = collectionConfig;
-                // Find or create an import operation for the collection
-                const adapter = new LegacyAdapter(this.database.client);
-                const collectionImportOperation = await findOrCreateOperation(adapter, dbId, "importData", collection.$id);
-                // Store the operation ID in the map
-                this.collectionImportOperations.set(this.getCollectionKey(collection.name), collectionImportOperation.$id);
+                // Find or create an import operation for the collection (non-fatal)
+                try {
+                    const adapter = await this.getAdapter();
+                    const collectionImportOperation = await findOrCreateOperation(adapter, dbId, "importData", collection.$id);
+                    this.collectionImportOperations.set(this.getCollectionKey(collection.name), collectionImportOperation.$id);
+                }
+                catch (error) {
+                    MessageFormatter.warning(`Operations tracking unavailable for ${collection.name}, import will proceed without it`, { prefix: "Import" });
+                }
                 // Initialize the collection in the import map
                 this.importMap.set(this.getCollectionKey(collection.name), {
                     collection: collection,
@@ -302,14 +316,17 @@ export class DataLoader {
         return allUsers;
     }
     // Main method to start the data loading process for a given database ID
-    async start(dbId) {
+    async start(dbId, specificCollections) {
         MessageFormatter.divider();
         MessageFormatter.info(`Starting data setup for database: ${dbId}`, { prefix: "Data" });
         MessageFormatter.divider();
-        await this.setupMaps(dbId);
-        const allUsers = await this.getAllUsers();
-        MessageFormatter.info(`Fetched ${allUsers.length} users, waiting a few seconds to let the program catch up...`, { prefix: "Data" });
-        await new Promise((resolve) => setTimeout(resolve, 5000));
+        // Only fetch users if we're importing users or no specific collections specified
+        const needsUsers = !specificCollections || specificCollections.length === 0 ||
+            specificCollections.some(c => this.getCollectionKey(c) === this.getCollectionKey(this.config.usersCollectionName));
+        if (needsUsers) {
+            const allUsers = await this.getAllUsers();
+            MessageFormatter.info(`Fetched ${allUsers.length} users`, { prefix: "Data" });
+        }
         // Iterate over the configured databases to find the matching one
         for (const db of this.config.databases) {
             if (db.$id !== dbId) {
@@ -321,6 +338,11 @@ export class DataLoader {
             // Iterate over the configured collections to process each
             for (const collectionConfig of this.config.collections) {
                 const collection = collectionConfig;
+                // Skip collections not in the specific list
+                if (specificCollections && specificCollections.length > 0 &&
+                    !specificCollections.includes(collection.name)) {
+                    continue;
+                }
                 // Determine if this is the users collection
                 let isUsersCollection = this.getCollectionKey(this.config.usersCollectionName) ===
                     this.getCollectionKey(collection.name);
@@ -754,7 +776,7 @@ export class DataLoader {
             this.oldIdToNewIdPerCollectionMap
                 .set(this.getCollectionKey(collection.name), oldIdToNewIdMap)
                 .get(this.getCollectionKey(collection.name));
-        const adapter = new LegacyAdapter(this.database.client);
+        const adapter = await this.getAdapter();
         if (!operationId) {
             const collectionImportOperation = await findOrCreateOperation(adapter, db.$id, "importData", collection.$id);
             // Store the operation ID in the map
@@ -763,7 +785,7 @@ export class DataLoader {
         }
         if (operationId) {
             await updateOperation(adapter, db.$id, operationId, {
-                status: "ready",
+                status: "in_progress",
                 total: rawData.length,
             });
         }
@@ -907,7 +929,7 @@ export class DataLoader {
         // Load the raw data based on the import definition
         const rawData = this.loadData(importDef);
         let operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
-        const adapter = new LegacyAdapter(this.database.client);
+        const adapter = await this.getAdapter();
         if (!operationId) {
             const collectionImportOperation = await findOrCreateOperation(adapter, db.$id, "importData", collection.$id);
             // Store the operation ID in the map
@@ -916,7 +938,7 @@ export class DataLoader {
         }
         if (operationId) {
             await updateOperation(adapter, db.$id, operationId, {
-                status: "ready",
+                status: "in_progress",
                 total: rawData.length,
             });
         }

package/dist/migrations/importController.d.ts

@@ -15,6 +15,8 @@ export declare class ImportController {
     private hasImportedUsers;
     private postImportActionsQueue;
     private databasesToRun;
+    private _adapter;
+    private getAdapter;
     constructor(config: AppwriteConfig, database: Databases, storage: Storage, appwriteFolderPath: string, importDataActions: ImportDataActions, setupOptions: SetupOptions, databasesToRun?: Models.Database[]);
     run(specificCollections?: string[]): Promise<void>;
     updateOthersToFinalData(updatedDb: Models.Database, targetDb: Models.Database): Promise<void>;

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 "appwrite-utils-helpers";
 import { resolveAndUpdateRelationships } from "./relationships.js";
 import { UsersController } from "../users/methods.js";
-import { logger } from "../shared/logging.js";
+import { logger, AdapterFactory } from "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 "appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
 export class ImportController {
     config;
@@ -22,6 +21,14 @@ export class ImportController {
     hasImportedUsers = false;
     postImportActionsQueue = [];
     databasesToRun;
+    _adapter = null;
+    async getAdapter() {
+        if (!this._adapter) {
+            const { adapter } = await AdapterFactory.createFromConfig(this.config);
+            this._adapter = adapter;
+        }
+        return this._adapter;
+    }
     constructor(config, database, storage, appwriteFolderPath, importDataActions, setupOptions, databasesToRun) {
         this.config = config;
         this.database = database;
@@ -50,8 +57,8 @@ export class ImportController {
             if (!databaseRan) {
                 databaseRan = db;
                 dataLoader = new DataLoader(this.appwriteFolderPath, this.importDataActions, this.database, this.config, this.setupOptions.shouldWriteFile);
-                await dataLoader.setupMaps(db.$id);
-                await dataLoader.start(db.$id);
+                await dataLoader.setupMaps(db.$id, specificCollections);
+                await dataLoader.start(db.$id, specificCollections);
                 await this.importCollections(db, dataLoader, specificCollections);
                 await resolveAndUpdateRelationships(db.$id, this.database, this.config);
                 await this.executePostImportActions(db.$id, dataLoader, specificCollections);
@@ -166,16 +173,19 @@ export class ImportController {
                         MessageFormatter.success("Finished importing users", { prefix: "Import" });
                     }
                 }
-                if (!importOperationId) {
-                    // Skip further processing if no import operation is found
-                    continue;
-                }
                 let importOperation = null;
-                importOperation = await this.database.getDocument("migrations", "currentOperations", importOperationId);
-                const adapter = new LegacyAdapter(this.database.client);
-                await updateOperation(adapter, db.$id, importOperation.$id, {
-                    status: "in_progress",
-                });
+                if (importOperationId) {
+                    try {
+                        importOperation = await this.database.getDocument("migrations", "currentOperations", importOperationId);
+                        const adapter = await this.getAdapter();
+                        await updateOperation(adapter, db.$id, importOperation.$id, {
+                            status: "in_progress",
+                        });
+                    }
+                    catch {
+                        importOperation = null;
+                    }
+                }
                 const collectionData = dataLoader.importMap.get(dataLoader.getCollectionKey(collection.name));
                 MessageFormatter.processing(`Processing collection: ${collection.name}...`, { prefix: "Import" });
                 if (!collectionData) {
@@ -213,18 +223,23 @@ export class ImportController {
                     await Promise.all(batchPromises);
                     MessageFormatter.success(`Completed batch ${i + 1} of ${dataSplit.length}`, { prefix: "Import" });
                     if (importOperation) {
-                        const adapter = new LegacyAdapter(this.database.client);
-                        await updateOperation(adapter, db.$id, importOperation.$id, {
-                            progress: processedItems,
-                        });
+                        try {
+                            const opAdapter = await this.getAdapter();
+                            await updateOperation(opAdapter, db.$id, importOperation.$id, {
+                                progress: processedItems,
+                            });
+                        }
+                        catch { /* operations tracking is non-fatal */ }
                     }
                 }
-                // After all batches are processed, update the operation status to completed
                 if (importOperation) {
-                    const adapter = new LegacyAdapter(this.database.client);
-                    await updateOperation(adapter, db.$id, importOperation.$id, {
-                        status: "completed",
-                    });
+                    try {
+                        const opAdapter = await this.getAdapter();
+                        await updateOperation(opAdapter, db.$id, importOperation.$id, {
+                            status: "completed",
+                        });
+                    }
+                    catch { /* operations tracking is non-fatal */ }
                 }
             }
         }

package/dist/migrations/importDataActions.js

@@ -1,11 +1,11 @@
 import {} from "node-appwrite";
 import { validationRules, } from "appwrite-utils";
 import { converterFunctions } from "appwrite-utils";
-import { convertObjectBySchema } from "../utils/dataConverters.js";
+import { convertObjectBySchema } from "appwrite-utils-helpers";
 import {} from "appwrite-utils";
 import { afterImportActions } from "./afterImportActions.js";
-import { logger } from "../shared/logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { logger } from "appwrite-utils-helpers";
+import { tryAwaitWithRetry } from "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 "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 "appwrite-utils-helpers";
+import { logger } from '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 'appwrite-utils-helpers';
 import { RateLimitManager } from "./RateLimitManager.js";
 /**
  * Service responsible for file handling during import.

package/dist/migrations/services/ImportOrchestrator.d.ts

@@ -26,6 +26,8 @@ export declare class ImportOrchestrator {
     private collectionImportOperations;
     private hasImportedUsers;
     private batchLimit;
+    private _adapter;
+    private getAdapter;
     constructor(config: AppwriteConfig, database: Databases, storage: Storage, appwriteFolderPath: string, importDataActions: ImportDataActions, setupOptions: SetupOptions, databasesToRun?: Models.Database[], rateLimitConfig?: Partial<RateLimitConfig>);
     /**
      * Main entry point for the import process.

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 'appwrite-utils-helpers';
+import { MessageFormatter } from 'appwrite-utils-helpers';
 import { ProgressManager } from "../../shared/progressManager.js";
-import { tryAwaitWithRetry } from "../../utils/index.js";
+import { tryAwaitWithRetry } from "appwrite-utils-helpers";
 import { updateOperation, findOrCreateOperation } from "../../shared/migrationHelpers.js";
-import { LegacyAdapter } from "../../adapters/LegacyAdapter.js";
+import { AdapterFactory } from 'appwrite-utils-helpers';
 import { resolveAndUpdateRelationships } from "../relationships.js";
 // Enhanced rate limiting configuration - now managed by RateLimitManager
 /**
@@ -42,6 +42,14 @@ export class ImportOrchestrator {
     collectionImportOperations = new Map();
     hasImportedUsers = false;
     batchLimit = 50; // Preserve existing batch size
+    _adapter = null;
+    async getAdapter() {
+        if (!this._adapter) {
+            const { adapter } = await AdapterFactory.createFromConfig(this.config);
+            this._adapter = adapter;
+        }
+        return this._adapter;
+    }
     constructor(config, database, storage, appwriteFolderPath, importDataActions, setupOptions, databasesToRun, rateLimitConfig) {
         this.config = config;
         this.database = database;
@@ -147,7 +155,7 @@ export class ImportOrchestrator {
                 collection.$id = existingCollection.$id;
                 this.config.collections[index] = collectionConfig;
                 // Find or create an import operation for the collection
-                const adapter = new LegacyAdapter(this.database.client);
+                const adapter = await this.getAdapter();
                 const collectionImportOperation = await findOrCreateOperation(adapter, dbId, "importData", collection.$id);
                 this.collectionImportOperations.set(this.getCollectionKey(collection.name), collectionImportOperation.$id);
                 // Initialize the collection in the import map
@@ -353,7 +361,7 @@ export class ImportOrchestrator {
         }
         logger.info(`Importing collection: ${collection.name} (${collectionData.data.length} items)`);
         const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
-        const adapter = new LegacyAdapter(this.database.client);
+        const adapter = await this.getAdapter();
         if (operationId) {
             await updateOperation(adapter, db.$id, operationId, { status: "in_progress" });
         }
@@ -461,7 +469,7 @@ export class ImportOrchestrator {
         const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
         if (operationId) {
             const updateData = total ? { status, total } : { status };
-            const adapter = new LegacyAdapter(this.database.client);
+            const adapter = await this.getAdapter();
             await updateOperation(adapter, db.$id, operationId, updateData);
         }
     }

package/dist/migrations/services/RateLimitManager.js

@@ -1,5 +1,5 @@
 import pLimit from "p-limit";
-import { logger } from "../../shared/logging.js";
+import { logger } from '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 '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 '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 '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 "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>;