appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/migrations/transfer.js

@@ -1,17 +1,16 @@
 import { converterFunctions, tryAwaitWithRetry } from "appwrite-utils";
 import { Client, Databases, IndexType, Query, Storage, Users, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
-import { getAppwriteClient } from "../utils/helperFunctions.js";
+import { getAppwriteClient } from "appwrite-utils-helpers";
 // Legacy attribute helpers retained only for local-to-local flows if needed
 import { parseAttribute } from "appwrite-utils";
 import chalk from "chalk";
 import { fetchAllCollections } from "../collections/methods.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { LegacyAdapter } from "../adapters/LegacyAdapter.js";
+import { MessageFormatter, mapToCreateAttributeParams } from "appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
-import { getClient, getAdapter } from "../utils/getClientFromConfig.js";
+import { getClient, getAdapter } from "appwrite-utils-helpers";
 import { diffTableColumns } from "../collections/tableOperations.js";
-import { mapToCreateAttributeParams } from "../shared/attributeMapper.js";
+import {} from "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,98 @@ 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 (!adapter) {
+        throw new Error("DatabaseAdapter is required for transferDatabaseLocalToLocal");
+    }
+    const dbAdapter = adapter;
+    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 +230,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 +255,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 +278,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 +295,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 'appwrite-utils-helpers';
 // YAML Import Configuration Schema
 export const YamlImportConfigSchema = z.object({
     source: z.object({
@@ -278,57 +278,57 @@ export class YamlImportConfigLoader {
         // Create README file
         const readmePath = path.join(importDir, "README.md");
         if (!fs.existsSync(readmePath)) {
-            const readmeContent = `# Import Configurations
-
-This directory contains YAML-based import configurations for the Appwrite Utils CLI.
-
-## Structure
-
-- \`collections/\` - Collection-specific import configurations
-- \`templates/\` - Template configurations for reference
-- \`*.yaml\` - Individual import configuration files
-
-## Configuration Format
-
-Each YAML file defines:
-- **source**: Data source configuration (file, type, basePath)
-- **target**: Target collection and operation type
-- **mapping**: Field mappings, transformations, and relationships
-- **options**: Import options (batch size, validation, etc.)
-
-## Example
-
-\`\`\`yaml
-source:
-  file: "importData/users.json"
-  basePath: "RECORDS"
-  type: "json"
-
-target:
-  collection: "Users"
-  type: "create"
-  primaryKey: "id"
-  createUsers: true
-
-mapping:
-  attributes:
-    - oldKey: "user_id"
-      targetKey: "userId"
-      converters: ["anyToString"]
-    - oldKey: "profile_image"
-      targetKey: "avatar"
-      fileData:
-        path: "assets/profiles/{user_id}.jpg"
-        name: "{firstName}_{lastName}_avatar"
-
-options:
-  batchSize: 50
-  continueOnError: true
-\`\`\`
-
-## Usage
-
-The CLI will automatically detect and load YAML import configurations during the import process.
+            const readmeContent = `# Import Configurations
+
+This directory contains YAML-based import configurations for the Appwrite Utils CLI.
+
+## Structure
+
+- \`collections/\` - Collection-specific import configurations
+- \`templates/\` - Template configurations for reference
+- \`*.yaml\` - Individual import configuration files
+
+## Configuration Format
+
+Each YAML file defines:
+- **source**: Data source configuration (file, type, basePath)
+- **target**: Target collection and operation type
+- **mapping**: Field mappings, transformations, and relationships
+- **options**: Import options (batch size, validation, etc.)
+
+## Example
+
+\`\`\`yaml
+source:
+  file: "importData/users.json"
+  basePath: "RECORDS"
+  type: "json"
+
+target:
+  collection: "Users"
+  type: "create"
+  primaryKey: "id"
+  createUsers: true
+
+mapping:
+  attributes:
+    - oldKey: "user_id"
+      targetKey: "userId"
+      converters: ["anyToString"]
+    - oldKey: "profile_image"
+      targetKey: "avatar"
+      fileData:
+        path: "assets/profiles/{user_id}.jpg"
+        name: "{firstName}_{lastName}_avatar"
+
+options:
+  batchSize: 50
+  continueOnError: true
+\`\`\`
+
+## Usage
+
+The CLI will automatically detect and load YAML import configurations during the import process.
 `;
             fs.writeFileSync(readmePath, readmeContent);
             logger.info(`Created README: ${readmePath}`);

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 'appwrite-utils-helpers';
+import { normalizeYamlData, usesTableTerminology, convertTerminology } from "appwrite-utils-helpers";
 import path from "path";
 import fs from "fs";
 import yaml from "js-yaml";