appwrite-utils-cli 1.5.2 → 1.6.0

package/dist/migrations/services/ImportOrchestrator.js

@@ -13,6 +13,7 @@ import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { ProgressManager } from "../../shared/progressManager.js";
 import { tryAwaitWithRetry } from "../../utils/index.js";
 import { updateOperation, findOrCreateOperation } from "../../shared/migrationHelpers.js";
+import { LegacyAdapter } from "../../adapters/LegacyAdapter.js";
 import { resolveAndUpdateRelationships } from "../relationships.js";
 // Enhanced rate limiting configuration - now managed by RateLimitManager
 /**
@@ -71,9 +72,6 @@ export class ImportOrchestrator {
         }
         let processedDatabase;
         for (const db of databasesToProcess) {
-            if (!this.config.useMigrations && db.name.toLowerCase().trim().replace(" ", "") === "migrations") {
-                continue;
-            }
             MessageFormatter.banner(`Starting import data for database: ${db.name}`, "Database Import");
             if (!processedDatabase) {
                 processedDatabase = db;
@@ -149,10 +147,9 @@ export class ImportOrchestrator {
                 collection.$id = existingCollection.$id;
                 this.config.collections[index] = collectionConfig;
                 // Find or create an import operation for the collection
-                if (this.config.useMigrations) {
-                    const collectionImportOperation = await findOrCreateOperation(this.database, collection.$id, "importData");
-                    this.collectionImportOperations.set(this.getCollectionKey(collection.name), collectionImportOperation.$id);
-                }
+                const adapter = new LegacyAdapter(this.database);
+                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
                 this.importMap.set(this.getCollectionKey(collection.name), {
                     collection: collection,
@@ -230,7 +227,7 @@ export class ImportOrchestrator {
         const rawData = this.loadDataFromFile(importDef);
         if (rawData.length === 0)
             return;
-        await this.updateOperationStatus(collection, "ready", rawData.length);
+        await this.updateOperationStatus(db, collection, "ready", rawData.length);
         const collectionData = this.importMap.get(this.getCollectionKey(collection.name));
         if (!collectionData) {
             logger.error(`No collection data found for ${collection.name}`);
@@ -284,7 +281,7 @@ export class ImportOrchestrator {
         const rawData = this.loadDataFromFile(importDef);
         if (rawData.length === 0)
             return;
-        await this.updateOperationStatus(collection, "ready", rawData.length);
+        await this.updateOperationStatus(db, collection, "ready", rawData.length);
         const collectionData = this.importMap.get(this.getCollectionKey(collection.name));
         if (!collectionData)
             return;
@@ -356,8 +353,9 @@ export class ImportOrchestrator {
         }
         logger.info(`Importing collection: ${collection.name} (${collectionData.data.length} items)`);
         const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
-        if (operationId && this.config.useMigrations) {
-            await updateOperation(this.database, operationId, { status: "in_progress" }, this.config.useMigrations);
+        const adapter = new LegacyAdapter(this.database);
+        if (operationId) {
+            await updateOperation(adapter, db.$id, operationId, { status: "in_progress" });
         }
         // Create batches for processing
         const batches = this.createBatches(collectionData.data, this.batchLimit);
@@ -373,13 +371,13 @@ export class ImportOrchestrator {
             processedItems += successCount;
             logger.info(`Batch ${i + 1} completed: ${successCount}/${batch.length} items imported`);
             // Update operation progress
-            if (operationId && this.config.useMigrations) {
-                await updateOperation(this.database, operationId, { progress: processedItems }, this.config.useMigrations);
+            if (operationId) {
+                await updateOperation(adapter, db.$id, operationId, { progress: processedItems });
             }
         }
         // Mark operation as completed
-        if (operationId && this.config.useMigrations) {
-            await updateOperation(this.database, operationId, { status: "completed" }, this.config.useMigrations);
+        if (operationId) {
+            await updateOperation(adapter, db.$id, operationId, { status: "completed" });
         }
         logger.info(`Completed importing collection: ${collection.name} (${processedItems} items)`);
     }
@@ -459,13 +457,12 @@ export class ImportOrchestrator {
             return null;
         }
     }
-    async updateOperationStatus(collection, status, total) {
-        if (!this.config.useMigrations)
-            return;
+    async updateOperationStatus(db, collection, status, total) {
         const operationId = this.collectionImportOperations.get(this.getCollectionKey(collection.name));
         if (operationId) {
             const updateData = total ? { status, total } : { status };
-            await updateOperation(this.database, operationId, updateData, this.config.useMigrations);
+            const adapter = new LegacyAdapter(this.database);
+            await updateOperation(adapter, db.$id, operationId, updateData);
         }
     }
     async importUsersCollection() {

package/dist/migrations/transfer.js

@@ -136,13 +136,13 @@ export const transferStorageLocalToRemote = async (localStorage, endpoint, proje
  * @return {Promise<void>} A promise that resolves when the transfer is complete.
  */
 export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId) => {
-    console.log(chalk.blue(`Starting database transfer from ${fromDbId} to ${targetDbId}`));
+    MessageFormatter.info(`Starting database transfer from ${fromDbId} to ${targetDbId}`, { prefix: "Transfer" });
     // Get all collections from source database
     const sourceCollections = await fetchAllCollections(fromDbId, localDb);
-    console.log(chalk.blue(`Found ${sourceCollections.length} collections in source database`));
+    MessageFormatter.info(`Found ${sourceCollections.length} collections in source database`, { prefix: "Transfer" });
     // Process each collection
     for (const collection of sourceCollections) {
-        console.log(chalk.yellow(`Processing collection: ${collection.name} (${collection.$id})`));
+        MessageFormatter.processing(`Processing collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
         try {
             // Create or update collection in target
             let targetCollection;
@@ -151,39 +151,39 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
             ]));
             if (existingCollection.collections.length > 0) {
                 targetCollection = existingCollection.collections[0];
-                console.log(chalk.green(`Collection ${collection.name} exists in target database`));
+                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));
-                    console.log(chalk.green(`Collection ${collection.name} updated`));
+                    MessageFormatter.success(`Collection ${collection.name} updated`, { prefix: "Transfer" });
                 }
             }
             else {
-                console.log(chalk.yellow(`Creating collection ${collection.name} in target database...`));
+                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
-            console.log(chalk.blue(`Creating attributes for collection ${collection.name} with enhanced monitoring...`));
+            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) {
-                console.log(chalk.red(`❌ Failed to create all attributes for collection ${collection.name}, skipping to next collection`));
+                MessageFormatter.error(`Failed to create all attributes for collection ${collection.name}, skipping to next collection`, undefined, { prefix: "Transfer" });
                 continue;
             }
-            console.log(chalk.green(`✅ All attributes created successfully for collection ${collection.name}`));
+            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));
-                    console.log(chalk.green(`Index ${index.key} created`));
+                    MessageFormatter.success(`Index ${index.key} created`, { prefix: "Transfer" });
                 }
                 else {
-                    console.log(chalk.blue(`Index ${index.key} exists, checking for updates...`));
+                    MessageFormatter.info(`Index ${index.key} exists, checking for updates...`, { prefix: "Transfer" });
                     await tryAwaitWithRetry(async () => createOrUpdateIndex(targetDbId, localDb, targetCollection.$id, index));
                 }
             }
@@ -192,7 +192,7 @@ export const transferDatabaseLocalToLocal = async (localDb, fromDbId, targetDbId
             await transferDocumentsBetweenDbsLocalToLocal(localDb, fromDbId, targetDbId, collection.$id, targetCollection.$id);
         }
         catch (error) {
-            console.error(chalk.red(`Error processing collection ${collection.name}:`), error);
+            MessageFormatter.error(`Error processing collection ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
         }
     }
 };
@@ -201,62 +201,62 @@ export const transferDatabaseLocalToRemote = async (localDb, endpoint, projectId
     const remoteDb = new Databases(client);
     // Get all collections from source database
     const sourceCollections = await fetchAllCollections(fromDbId, localDb);
-    console.log(chalk.blue(`Found ${sourceCollections.length} collections in source database`));
+    MessageFormatter.info(`Found ${sourceCollections.length} collections in source database`, { prefix: "Transfer" });
     // Process each collection
     for (const collection of sourceCollections) {
-        console.log(chalk.yellow(`Processing collection: ${collection.name} (${collection.$id})`));
+        MessageFormatter.processing(`Processing collection: ${collection.name} (${collection.$id})`, { prefix: "Transfer" });
         try {
             // Create or update collection in target
             let targetCollection;
             const existingCollection = await tryAwaitWithRetry(async () => remoteDb.listCollections(toDbId, [Query.equal("$id", collection.$id)]));
             if (existingCollection.collections.length > 0) {
                 targetCollection = existingCollection.collections[0];
-                console.log(chalk.green(`Collection ${collection.name} exists in remote database`));
+                MessageFormatter.info(`Collection ${collection.name} exists in remote 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 () => remoteDb.updateCollection(toDbId, collection.$id, collection.name, collection.$permissions, collection.documentSecurity, collection.enabled));
-                    console.log(chalk.green(`Collection ${collection.name} updated`));
+                    MessageFormatter.success(`Collection ${collection.name} updated`, { prefix: "Transfer" });
                 }
             }
             else {
-                console.log(chalk.yellow(`Creating collection ${collection.name} in remote database...`));
+                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
-            console.log(chalk.blue(`Creating attributes for collection ${collection.name} with enhanced monitoring...`));
+            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) {
-                console.log(chalk.red(`Failed to create some attributes for collection ${collection.name}`));
+                MessageFormatter.warning(`Failed to create some attributes for collection ${collection.name}`, { prefix: "Transfer" });
                 // Continue with the transfer even if some attributes failed
             }
             else {
-                console.log(chalk.green(`All attributes created successfully for collection ${collection.name}`));
+                MessageFormatter.success(`All attributes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
             }
             // Handle indexes with enhanced status checking
-            console.log(chalk.blue(`Creating indexes for collection ${collection.name} with enhanced monitoring...`));
+            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) {
-                console.log(chalk.red(`Failed to create some indexes for collection ${collection.name}`));
+                MessageFormatter.warning(`Failed to create some indexes for collection ${collection.name}`, { prefix: "Transfer" });
                 // Continue with the transfer even if some indexes failed
             }
             else {
-                console.log(chalk.green(`All indexes created successfully for collection ${collection.name}`));
+                MessageFormatter.success(`All indexes created successfully for collection ${collection.name}`, { prefix: "Transfer" });
             }
             // Transfer documents
             const { transferDocumentsBetweenDbsLocalToRemote } = await import("../collections/methods.js");
             await transferDocumentsBetweenDbsLocalToRemote(localDb, endpoint, projectId, apiKey, fromDbId, toDbId, collection.$id, targetCollection.$id);
         }
         catch (error) {
-            console.error(chalk.red(`Error processing collection ${collection.name}:`), error);
+            MessageFormatter.error(`Error processing collection ${collection.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
         }
     }
 };
 export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId, apiKey) => {
-    console.log(chalk.blue("Starting user transfer to remote instance..."));
+    MessageFormatter.info("Starting user transfer to remote instance...", { prefix: "Transfer" });
     const client = getClient(endpoint, projectId, apiKey);
     const remoteUsers = new Users(client);
     let totalTransferred = 0;
@@ -278,18 +278,18 @@ export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId
                     remoteUser = await tryAwaitWithRetry(async () => remoteUsers.get(user.$id));
                     // If user exists, update only the differences
                     if (remoteUser) {
-                        console.log(chalk.blue(`User ${user.$id} exists, checking for updates...`));
+                        MessageFormatter.info(`User ${user.$id} exists, checking for updates...`, { prefix: "Transfer" });
                         let hasUpdates = false;
                         // Update name if different
                         if (remoteUser.name !== user.name) {
                             await tryAwaitWithRetry(async () => remoteUsers.updateName(user.$id, user.name));
-                            console.log(chalk.green(`Updated name for user ${user.$id}`));
+                            MessageFormatter.success(`Updated name for user ${user.$id}`, { prefix: "Transfer" });
                             hasUpdates = true;
                         }
                         // Update email if different
                         if (remoteUser.email !== user.email) {
                             await tryAwaitWithRetry(async () => remoteUsers.updateEmail(user.$id, user.email));
-                            console.log(chalk.green(`Updated email for user ${user.$id}`));
+                            MessageFormatter.success(`Updated email for user ${user.$id}`, { prefix: "Transfer" });
                             hasUpdates = true;
                         }
                         // Update phone if different
@@ -300,45 +300,45 @@ export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId
                             if (normalizedLocalPhone) {
                                 await tryAwaitWithRetry(async () => remoteUsers.updatePhone(user.$id, normalizedLocalPhone));
                             }
-                            console.log(chalk.green(`Updated phone for user ${user.$id}`));
+                            MessageFormatter.success(`Updated phone for user ${user.$id}`, { prefix: "Transfer" });
                             hasUpdates = true;
                         }
                         // Update preferences if different
                         if (JSON.stringify(remoteUser.prefs) !== JSON.stringify(user.prefs)) {
                             await tryAwaitWithRetry(async () => remoteUsers.updatePrefs(user.$id, user.prefs));
-                            console.log(chalk.green(`Updated preferences for user ${user.$id}`));
+                            MessageFormatter.success(`Updated preferences for user ${user.$id}`, { prefix: "Transfer" });
                             hasUpdates = true;
                         }
                         // Update labels if different
                         if (JSON.stringify(remoteUser.labels) !== JSON.stringify(user.labels)) {
                             await tryAwaitWithRetry(async () => remoteUsers.updateLabels(user.$id, user.labels));
-                            console.log(chalk.green(`Updated labels for user ${user.$id}`));
+                            MessageFormatter.success(`Updated labels for user ${user.$id}`, { prefix: "Transfer" });
                             hasUpdates = true;
                         }
                         // Update email verification if different
                         if (remoteUser.emailVerification !== user.emailVerification) {
                             await tryAwaitWithRetry(async () => remoteUsers.updateEmailVerification(user.$id, user.emailVerification));
-                            console.log(chalk.green(`Updated email verification for user ${user.$id}`));
+                            MessageFormatter.success(`Updated email verification for user ${user.$id}`, { prefix: "Transfer" });
                             hasUpdates = true;
                         }
                         // Update phone verification if different
                         if (remoteUser.phoneVerification !== user.phoneVerification) {
                             await tryAwaitWithRetry(async () => remoteUsers.updatePhoneVerification(user.$id, user.phoneVerification));
-                            console.log(chalk.green(`Updated phone verification for user ${user.$id}`));
+                            MessageFormatter.success(`Updated phone verification for user ${user.$id}`, { prefix: "Transfer" });
                             hasUpdates = true;
                         }
                         // Update status if different
                         if (remoteUser.status !== user.status) {
                             await tryAwaitWithRetry(async () => remoteUsers.updateStatus(user.$id, user.status));
-                            console.log(chalk.green(`Updated status for user ${user.$id}`));
+                            MessageFormatter.success(`Updated status for user ${user.$id}`, { prefix: "Transfer" });
                             hasUpdates = true;
                         }
                         if (!hasUpdates) {
-                            console.log(chalk.yellow(`User ${user.$id} is already up to date, skipping...`));
+                            MessageFormatter.info(`User ${user.$id} is already up to date, skipping...`, { prefix: "Transfer" });
                         }
                         else {
                             totalTransferred++;
-                            console.log(chalk.green(`Updated user ${user.$id}`));
+                            MessageFormatter.success(`Updated user ${user.$id}`, { prefix: "Transfer" });
                         }
                         continue;
                     }
@@ -381,7 +381,7 @@ export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId
                                 // Warn if using default values due to missing hash options
                                 if (!hashOptions.salt ||
                                     typeof hashOptions.costCpu !== "number") {
-                                    console.log(chalk.yellow(`User ${user.$id}: Using default Scrypt parameters due to missing hashOptions`));
+                                    MessageFormatter.warning(`User ${user.$id}: Using default Scrypt parameters due to missing hashOptions`, { prefix: "Transfer" });
                                 }
                                 await tryAwaitWithRetry(async () => remoteUsers.createScryptUser(user.$id, user.email, hashedPassword, salt, costCpu, costMemory, costParallel, length, user.name));
                                 break;
@@ -398,7 +398,7 @@ export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId
                                 if (!hashOptions.salt ||
                                     !hashOptions.saltSeparator ||
                                     !hashOptions.signerKey) {
-                                    console.log(chalk.yellow(`User ${user.$id}: Missing critical Scrypt Modified parameters in hashOptions`));
+                                    MessageFormatter.warning(`User ${user.$id}: Missing critical Scrypt Modified parameters in hashOptions`, { prefix: "Transfer" });
                                 }
                                 await tryAwaitWithRetry(async () => remoteUsers.createScryptModifiedUser(user.$id, user.email, hashedPassword, modSalt, saltSeparator, signerKey, user.name));
                                 break;
@@ -428,17 +428,17 @@ export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId
                                 await tryAwaitWithRetry(async () => remoteUsers.createPHPassUser(user.$id, user.email, hashedPassword, user.name));
                                 break;
                             default:
-                                console.log(chalk.yellow(`Unknown hash type '${hashType}' for user ${user.$id}, falling back to Argon2`));
+                                MessageFormatter.warning(`Unknown hash type '${hashType}' for user ${user.$id}, falling back to Argon2`, { prefix: "Transfer" });
                                 await tryAwaitWithRetry(async () => remoteUsers.createArgon2User(user.$id, user.email, hashedPassword, user.name));
                                 break;
                         }
-                        console.log(chalk.green(`User ${user.$id} created with preserved ${hashType} password`));
+                        MessageFormatter.success(`User ${user.$id} created with preserved ${hashType} password`, { prefix: "Transfer" });
                     }
                     catch (error) {
-                        console.log(chalk.yellow(`Failed to create user ${user.$id} with ${hashType} hash, trying with temporary password`));
+                        MessageFormatter.warning(`Failed to create user ${user.$id} with ${hashType} hash, trying with temporary password`, { prefix: "Transfer" });
                         // Fallback to creating user with temporary password
                         await tryAwaitWithRetry(async () => remoteUsers.create(user.$id, user.email, phone, `changeMe${user.email}`, user.name));
-                        console.log(chalk.yellow(`User ${user.$id} created with temporary password - password reset required`));
+                        MessageFormatter.warning(`User ${user.$id} created with temporary password - password reset required`, { prefix: "Transfer" });
                     }
                 }
                 else {
@@ -446,7 +446,7 @@ export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId
                     const tempPassword = user.password || `changeMe${user.email}`;
                     await tryAwaitWithRetry(async () => remoteUsers.create(user.$id, user.email, phone, tempPassword, user.name));
                     if (!user.password) {
-                        console.log(chalk.yellow(`User ${user.$id} created with temporary password - password reset required`));
+                        MessageFormatter.warning(`User ${user.$id} created with temporary password - password reset required`, { prefix: "Transfer" });
                     }
                 }
                 // Update phone, labels, and other attributes for newly created users
@@ -471,10 +471,10 @@ export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId
                     await tryAwaitWithRetry(async () => remoteUsers.updateStatus(user.$id, false));
                 }
                 totalTransferred++;
-                console.log(chalk.green(`Transferred user ${user.$id}`));
+                MessageFormatter.success(`Transferred user ${user.$id}`, { prefix: "Transfer" });
             }
             catch (error) {
-                console.error(chalk.red(`Failed to transfer user ${user.$id}:`), error);
+                MessageFormatter.error(`Failed to transfer user ${user.$id}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
             }
         }
         if (usersList.users.length < 100) {
@@ -482,5 +482,5 @@ export const transferUsersLocalToRemote = async (localUsers, endpoint, projectId
         }
         lastId = usersList.users[usersList.users.length - 1].$id;
     }
-    console.log(chalk.green(`Successfully transferred ${totalTransferred} users`));
+    MessageFormatter.success(`Successfully transferred ${totalTransferred} users`, { prefix: "Transfer" });
 };

package/dist/migrations/yaml/YamlImportConfigLoader.d.ts

@@ -91,12 +91,14 @@ export declare class YamlImportConfigLoader {
     /**
      * Generates a template YAML import configuration.
      * Useful for getting started with YAML-based imports.
+     * Supports both collection and table terminology.
      *
      * @param collectionName - Name of the collection
      * @param sourceFile - Source data file name
+     * @param useTableTerminology - Whether to use table terminology
      * @returns YAML configuration template
      */
-    generateTemplate(collectionName: string, sourceFile: string): string;
+    generateTemplate(collectionName: string, sourceFile: string, useTableTerminology?: boolean): string;
     /**
      * Creates the import directory structure if it doesn't exist.
      * Sets up the recommended directory layout for YAML import configurations.

package/dist/migrations/yaml/YamlImportConfigLoader.js

@@ -185,12 +185,15 @@ export class YamlImportConfigLoader {
     /**
      * Generates a template YAML import configuration.
      * Useful for getting started with YAML-based imports.
+     * Supports both collection and table terminology.
      *
      * @param collectionName - Name of the collection
      * @param sourceFile - Source data file name
+     * @param useTableTerminology - Whether to use table terminology
      * @returns YAML configuration template
      */
-    generateTemplate(collectionName, sourceFile) {
+    generateTemplate(collectionName, sourceFile, useTableTerminology = false) {
+        const entityType = useTableTerminology ? 'table' : 'collection';
         const template = {
             source: {
                 file: `importData/${sourceFile}`,
@@ -198,7 +201,7 @@ export class YamlImportConfigLoader {
                 type: "json"
             },
             target: {
-                collection: collectionName,
+                [entityType]: collectionName,
                 type: "create",
                 primaryKey: "id",
                 createUsers: false
@@ -240,7 +243,7 @@ export class YamlImportConfigLoader {
                     {
                         sourceField: "user_id",
                         targetField: "userId",
-                        targetCollection: "Users"
+                        [useTableTerminology ? 'targetTable' : 'targetCollection']: "Users"
                     }
                 ]
             },

package/dist/migrations/yaml/YamlImportIntegration.d.ts

@@ -43,19 +43,23 @@ export declare class YamlImportIntegration {
     /**
      * Generates a YAML import configuration from an existing ImportDef.
      * Useful for migrating TypeScript configurations to YAML.
+     * Supports both collection and table terminology.
      *
      * @param importDef - Existing ImportDef to convert
      * @param collectionName - Name of the collection
+     * @param useTableTerminology - Whether to use table terminology
      * @returns YAML configuration string
      */
-    convertImportDefToYaml(importDef: ImportDef, collectionName: string): string;
+    convertImportDefToYaml(importDef: ImportDef, collectionName: string, useTableTerminology?: boolean): string;
     /**
      * Exports existing TypeScript import configurations to YAML files.
      * Helps migrate from TypeScript to YAML-based configurations.
+     * Supports both collection and table terminology.
      *
      * @param collections - Collections with existing import definitions
+     * @param useTableTerminology - Whether to use table terminology
      */
-    exportToYaml(collections: CollectionCreate[]): Promise<void>;
+    exportToYaml(collections: CollectionCreate[], useTableTerminology?: boolean): Promise<void>;
     /**
      * Gets statistics about YAML import configurations.
      */
@@ -71,12 +75,14 @@ export declare class YamlImportIntegration {
     }>;
     /**
      * Creates a new YAML import configuration from a template.
+     * Supports both collection and table terminology.
      *
      * @param collectionName - Name of the collection
      * @param sourceFile - Source data file name
+     * @param useTableTerminology - Whether to use table terminology
      * @param outputPath - Output file path (optional)
      */
-    createFromTemplate(collectionName: string, sourceFile: string, outputPath?: string): Promise<string>;
+    createFromTemplate(collectionName: string, sourceFile: string, useTableTerminology?: boolean, outputPath?: string): Promise<string>;
     /**
      * Checks if YAML import system is properly set up.
      */

package/dist/migrations/yaml/YamlImportIntegration.js

@@ -1,6 +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 path from "path";
 import fs from "fs";
 /**
@@ -171,12 +172,14 @@ export class YamlImportIntegration {
     /**
      * Generates a YAML import configuration from an existing ImportDef.
      * Useful for migrating TypeScript configurations to YAML.
+     * Supports both collection and table terminology.
      *
      * @param importDef - Existing ImportDef to convert
      * @param collectionName - Name of the collection
+     * @param useTableTerminology - Whether to use table terminology
      * @returns YAML configuration string
      */
-    convertImportDefToYaml(importDef, collectionName) {
+    convertImportDefToYaml(importDef, collectionName, useTableTerminology = false) {
         const yamlConfig = {
             source: {
                 file: importDef.filePath,
@@ -228,15 +231,18 @@ export class YamlImportIntegration {
             lineWidth: 120,
             sortKeys: false,
         });
-        return `# yaml-language-server: $schema=../.yaml_schemas/import-config.schema.json\n# Import Configuration for ${collectionName}\n\n${yamlContent}`;
+        const entityType = useTableTerminology ? 'Table' : 'Collection';
+        return `# yaml-language-server: $schema=../.yaml_schemas/import-config.schema.json\n# Import Configuration for ${entityType}: ${collectionName}\n\n${yamlContent}`;
     }
     /**
      * Exports existing TypeScript import configurations to YAML files.
      * Helps migrate from TypeScript to YAML-based configurations.
+     * Supports both collection and table terminology.
      *
      * @param collections - Collections with existing import definitions
+     * @param useTableTerminology - Whether to use table terminology
      */
-    async exportToYaml(collections) {
+    async exportToYaml(collections, useTableTerminology = false) {
         const exportDir = path.join(this.appwriteFolderPath, "import", "exported");
         if (!fs.existsSync(exportDir)) {
             fs.mkdirSync(exportDir, { recursive: true });
@@ -248,10 +254,11 @@ export class YamlImportIntegration {
             }
             for (let i = 0; i < collection.importDefs.length; i++) {
                 const importDef = collection.importDefs[i];
-                const yamlContent = this.convertImportDefToYaml(importDef, collection.name);
+                const yamlContent = this.convertImportDefToYaml(importDef, collection.name, useTableTerminology);
+                const entityType = useTableTerminology ? 'table' : 'collection';
                 const filename = collection.importDefs.length > 1
-                    ? `${collection.name}-${i + 1}.yaml`
-                    : `${collection.name}.yaml`;
+                    ? `${collection.name}-${entityType}-${i + 1}.yaml`
+                    : `${collection.name}-${entityType}.yaml`;
                 const filePath = path.join(exportDir, filename);
                 fs.writeFileSync(filePath, yamlContent);
                 exportedCount++;
@@ -290,18 +297,22 @@ export class YamlImportIntegration {
     }
     /**
      * Creates a new YAML import configuration from a template.
+     * Supports both collection and table terminology.
      *
      * @param collectionName - Name of the collection
      * @param sourceFile - Source data file name
+     * @param useTableTerminology - Whether to use table terminology
      * @param outputPath - Output file path (optional)
      */
-    async createFromTemplate(collectionName, sourceFile, outputPath) {
-        const template = this.configLoader.generateTemplate(collectionName, sourceFile);
-        const fileName = outputPath || `${collectionName.toLowerCase()}-import.yaml`;
+    async createFromTemplate(collectionName, sourceFile, useTableTerminology = false, outputPath) {
+        const template = this.configLoader.generateTemplate(collectionName, sourceFile, useTableTerminology);
+        const entityType = useTableTerminology ? 'table' : 'collection';
+        const fileName = outputPath || `${collectionName.toLowerCase()}-${entityType}-import.yaml`;
         const fullPath = path.join(this.appwriteFolderPath, "import", fileName);
-        // Add schema reference to template
+        // Add schema reference to template with entity type comment
         const schemaHeader = "# yaml-language-server: $schema=../.yaml_schemas/import-config.schema.json\n";
-        const templateWithSchema = schemaHeader + template;
+        const entityComment = `# Import Configuration for ${useTableTerminology ? 'Table' : 'Collection'}: ${collectionName}\n`;
+        const templateWithSchema = schemaHeader + entityComment + template;
         fs.writeFileSync(fullPath, templateWithSchema);
         logger.info(`Created YAML import configuration: ${fullPath}`);
         return fullPath;

package/dist/migrations/yaml/generateImportSchemas.d.ts

@@ -4,7 +4,20 @@
  */
 export declare function generateImportConfigSchema(): any;
 /**
- * Creates all necessary schema files for YAML import configurations.
+ * Generates JSON Schema for collection definitions (legacy Databases API)
+ */
+export declare function generateCollectionSchema(): any;
+/**
+ * Generates JSON Schema for table definitions (new TablesDB API)
+ */
+export declare function generateTableSchema(): any;
+/**
+ * Generates JSON Schema for main Appwrite configuration (YAML format)
+ * Matches the structure of YamlConfigSchema from yamlConfig.ts
+ */
+export declare function generateAppwriteConfigSchema(): any;
+/**
+ * Creates all necessary schema files for YAML configurations.
  *
  * @param appwriteFolderPath - Path to the .appwrite directory
  */