appwrite-utils-cli 0.0.285 → 0.9.0

package/dist/main.js

@@ -1,67 +1,232 @@
 #!/usr/bin/env node
-import { program } from "commander";
+import yargs from "yargs";
+import {} from "yargs";
+import { hideBin } from "yargs/helpers";
+import { InteractiveCLI } from "./interactiveCLI.js";
 import { UtilsController } from "./utilsController.js";
-// Setup the main CLI program
-program
-    .version("1.0.0")
-    .description("Utility CLI for Appwrite configurations and operations")
-    .option("--endpoint <endpoint>", "Set the Appwrite endpoint", undefined)
-    .option("--project <project>", "Set the Appwrite project ID", undefined)
-    .option("--key <key>", "Set the Appwrite API key", undefined)
-    .option("--backup", "Perform a backup before executing the command", false)
-    .option("--dev", "Run in development environment", false)
-    .option("--prod", "Run in production environment", false)
-    .option("--staging", "Run in staging environment", false)
-    .option("--sync", "Synchronize configurations", false)
-    .option("--wipe", "Wipe databases", false)
-    .option("--wipe-docs", "Wipe documents", false)
-    .option("--wipe-users", "Wipe users", false)
-    .option("--generate", "Generate schemas", false)
-    .option("--import", "Import data", false)
-    .option("--write-data", "Write data to file", false)
-    .option("-h, --help", "Display help for command", false);
-program.on("--help", () => {
-    console.log("");
-    console.log("Examples:");
-    console.log("  $ npx appwrite-utils-cli appwrite-migrate --sync --endpoint https://appwrite.example.com --project 123456 --key 7890");
-    console.log("  $ npx appwrite-utils-cli appwrite-migrate --sync --dev --backup");
-    console.log("  $ npx appwrite-utils-cli appwrite-migrate --wipe --wipe-docs --wipe-users --dev");
-    console.log("  $ npx appwrite-utils-cli appwrite-migrate --generate --import --write-data --dev");
-    console.log("  $ npx appwrite-utils-cli appwrite-migrate --sync --generate --import --write-data --dev --backup");
-    console.log("  $ npx appwrite-utils-cli appwrite-create");
-    console.log("For more information, visit https://github.com/zachhandley/appwrite-utils");
-    console.log("");
-});
-// Parse and handle options
-program.action(async (options) => {
-    const currentUserDir = process.cwd();
-    const controller = new UtilsController(currentUserDir);
-    try {
-        // Convert Commander options to the format expected by UtilsController
-        const setupOptions = {
-            sync: options.sync,
-            runProd: options.prod,
-            runStaging: options.staging,
-            runDev: options.dev,
-            doBackup: options.backup,
-            wipeDatabases: options.wipe,
-            wipeDocumentStorage: options.wipeDocs,
-            wipeUsers: options.wipeUsers,
-            generateSchemas: options.generate,
-            generateMockData: false, // Assuming this needs to be set based on other conditions
-            importData: options.import,
-            checkDuplicates: false, // Assuming this needs to be set based on other conditions
-            shouldWriteFile: options.writeData,
-            endpoint: options.endpoint,
-            project: options.project,
-            key: options.key,
-        };
-        console.log("Running operation...", setupOptions);
-        await controller.run(setupOptions);
-        console.log("Operation completed successfully.");
+import { Databases, Storage } from "node-appwrite";
+import { getClient } from "./utils/getClientFromConfig.js";
+const argv = yargs(hideBin(process.argv))
+    .command("migrate", "Run Appwrite migrations", (yargs) => {
+    return yargs
+        .option("it", {
+        alias: ["interactive", "i"],
+        type: "boolean",
+        description: "Run in interactive mode",
+    })
+        .option("dbIds", {
+        type: "string",
+        description: "Comma-separated list of database IDs to operate on",
+    })
+        .option("collectionIds", {
+        alias: ["collIds"],
+        type: "string",
+        description: "Comma-separated list of collection IDs to operate on",
+    })
+        .option("bucketIds", {
+        type: "string",
+        description: "Comma-separated list of bucket IDs to operate on",
+    })
+        .option("wipe", {
+        choices: ["all", "docs", "users"],
+        description: "Wipe data (all: everything, docs: only documents, users: only user data)",
+    })
+        .option("generate", {
+        type: "boolean",
+        description: "Generate TypeScript schemas from database schemas",
+    })
+        .option("import", {
+        type: "boolean",
+        description: "Import data into your databases",
+    })
+        .option("backup", {
+        type: "boolean",
+        description: "Perform a backup of your databases",
+    })
+        .option("writeData", {
+        type: "boolean",
+        description: "Write converted imported data to file",
+    })
+        .option("push", {
+        type: "boolean",
+        description: "Push your local Appwrite config to your configured Appwrite Project",
+    })
+        .option("sync", {
+        type: "boolean",
+        description: "Synchronize by pulling your Appwrite config from your configured Appwrite Project",
+    })
+        .option("endpoint", {
+        type: "string",
+        description: "Set the Appwrite endpoint",
+    })
+        .option("projectId", {
+        type: "string",
+        description: "Set the Appwrite project ID",
+    })
+        .option("apiKey", {
+        type: "string",
+        description: "Set the Appwrite API key",
+    })
+        .option("transfer", {
+        type: "boolean",
+        description: "Transfer data between databases or collections",
+    })
+        .option("fromDbId", {
+        alias: ["fromDb"],
+        type: "string",
+        description: "Set the source database ID for transfer",
+    })
+        .option("toDbId", {
+        alias: ["toDb"],
+        type: "string",
+        description: "Set the destination database ID for transfer",
+    })
+        .option("fromCollectionId", {
+        alias: ["fromCollId", "fromColl"],
+        type: "string",
+        description: "Set the source collection ID for transfer",
+    })
+        .option("toCollectionId", {
+        alias: ["toCollId", "toColl"],
+        type: "string",
+        description: "Set the destination collection ID for transfer",
+    })
+        .option("fromBucketId", {
+        alias: ["fromBucket"],
+        type: "string",
+        description: "Set the source bucket ID for transfer",
+    })
+        .option("toBucketId", {
+        alias: ["toBucket"],
+        type: "string",
+        description: "Set the destination bucket ID for transfer",
+    })
+        .option("remoteEndpoint", {
+        type: "string",
+        description: "Set the remote Appwrite endpoint for transfers",
+    })
+        .option("remoteProjectId", {
+        type: "string",
+        description: "Set the remote Appwrite project ID for transfers",
+    })
+        .option("remoteApiKey", {
+        type: "string",
+        description: "Set the remote Appwrite API key for transfers",
+    });
+})
+    .help()
+    .parse();
+async function main() {
+    const parsedArgv = (await argv);
+    const controller = new UtilsController(process.cwd());
+    await controller.init();
+    if (parsedArgv.it) {
+        const cli = new InteractiveCLI(process.cwd(), controller);
+        await cli.run();
     }
-    catch (error) {
-        console.error("Error during operation:", error);
+    else {
+        // Handle non-interactive mode with the new options
+        const options = {
+            databases: parsedArgv.dbIds
+                ? await controller.getDatabasesByIds(parsedArgv.dbIds.replace(" ", "").split(","))
+                : undefined,
+            collections: parsedArgv.collectionIds
+                ? parsedArgv.collectionIds.replace(" ", "").split(",")
+                : undefined,
+            doBackup: parsedArgv.backup,
+            wipeDatabase: parsedArgv.wipe === "all" || parsedArgv.wipe === "docs",
+            wipeDocumentStorage: parsedArgv.wipe === "all",
+            wipeUsers: parsedArgv.wipe === "all" || parsedArgv.wipe === "users",
+            generateSchemas: parsedArgv.generate,
+            importData: parsedArgv.import,
+            checkDuplicates: false,
+            shouldWriteFile: parsedArgv.writeData,
+        };
+        if (parsedArgv.push) {
+            await controller.syncDb();
+        }
+        if (options.wipeDatabase ||
+            options.wipeDocumentStorage ||
+            options.wipeUsers) {
+            if (options.wipeDatabase) {
+                for (const db of options.databases || []) {
+                    await controller.wipeDatabase(db);
+                }
+            }
+            if (options.wipeDocumentStorage && parsedArgv.bucketIds) {
+                for (const bucketId of parsedArgv.bucketIds.split(",")) {
+                    await controller.wipeDocumentStorage(bucketId);
+                }
+            }
+            if (options.wipeUsers) {
+                await controller.wipeUsers();
+            }
+        }
+        if (options.doBackup) {
+            for (const db of options.databases || []) {
+                await controller.backupDatabase(db);
+            }
+        }
+        if (options.generateSchemas) {
+            await controller.generateSchemas();
+        }
+        if (options.importData) {
+            await controller.importData(options);
+        }
+        if (parsedArgv.transfer) {
+            const isRemote = !!parsedArgv.remoteEndpoint;
+            const fromDb = await controller.getDatabasesByIds([parsedArgv.fromDbId]);
+            let toDb;
+            let targetDatabases;
+            let targetStorage;
+            if (isRemote) {
+                if (!parsedArgv.remoteEndpoint ||
+                    !parsedArgv.remoteProjectId ||
+                    !parsedArgv.remoteApiKey) {
+                    throw new Error("Remote transfer details are missing");
+                }
+                const remoteClient = getClient(parsedArgv.remoteEndpoint, parsedArgv.remoteProjectId, parsedArgv.remoteApiKey);
+                targetDatabases = new Databases(remoteClient);
+                targetStorage = new Storage(remoteClient);
+                const remoteDbs = await targetDatabases.list();
+                toDb = remoteDbs.databases.find((db) => db.$id === parsedArgv.toDbId);
+            }
+            else {
+                toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))[0];
+            }
+            if (!fromDb[0] || !toDb) {
+                throw new Error("Source or target database not found");
+            }
+            let sourceBucket, targetBucket;
+            if (parsedArgv.fromBucketId) {
+                sourceBucket = await controller.storage?.getBucket(parsedArgv.fromBucketId);
+            }
+            if (parsedArgv.toBucketId) {
+                if (isRemote) {
+                    targetBucket = await targetStorage?.getBucket(parsedArgv.toBucketId);
+                }
+                else {
+                    targetBucket = await controller.storage?.getBucket(parsedArgv.toBucketId);
+                }
+            }
+            const transferOptions = {
+                isRemote,
+                fromDb: fromDb[0],
+                targetDb: toDb,
+                transferEndpoint: parsedArgv.remoteEndpoint,
+                transferProject: parsedArgv.remoteProjectId,
+                transferKey: parsedArgv.remoteApiKey,
+                sourceBucket: sourceBucket,
+                targetBucket: targetBucket,
+            };
+            await controller.transferData(transferOptions);
+        }
+        if (parsedArgv.sync) {
+            await controller.synchronizeConfigurations(options.databases);
+        }
     }
+}
+main().catch((error) => {
+    console.error("An error occurred:", error);
+    process.exit(1);
 });
-program.parse(process.argv);

package/dist/migrations/afterImportActions.js

@@ -1,9 +1,10 @@
-import { Databases, Storage, InputFile, Query, ID, Client, } from "node-appwrite";
+import { Databases, Storage, Query, ID, Client, Compression, } from "node-appwrite";
+import { InputFile } from "node-appwrite/file";
 import path from "path";
 import fs from "fs";
 import os from "os";
 import { logger } from "./logging.js";
-import {} from "appwrite-utils";
+import { tryAwaitWithRetry, } from "appwrite-utils";
 export const getDatabaseFromConfig = (config) => {
     if (!config.appwriteClient) {
         config.appwriteClient = new Client()
@@ -26,7 +27,7 @@ export const afterImportActions = {
     updateCreatedDocument: async (config, dbId, collId, docId, data) => {
         try {
             const db = getDatabaseFromConfig(config);
-            await db.updateDocument(dbId, collId, docId, data);
+            await tryAwaitWithRetry(async () => await db.updateDocument(dbId, collId, docId, data));
         }
         catch (error) {
             console.error("Error updating document: ", error);
@@ -35,11 +36,11 @@ export const afterImportActions = {
     checkAndUpdateFieldInDocument: async (config, dbId, collId, docId, fieldName, oldFieldValue, newFieldValue) => {
         try {
             const db = getDatabaseFromConfig(config);
-            const doc = await db.getDocument(dbId, collId, docId);
+            const doc = await tryAwaitWithRetry(async () => await db.getDocument(dbId, collId, docId));
             if (doc[fieldName] == oldFieldValue) {
-                await db.updateDocument(dbId, collId, docId, {
+                await tryAwaitWithRetry(async () => await db.updateDocument(dbId, collId, docId, {
                     [fieldName]: newFieldValue,
-                });
+                }));
             }
         }
         catch (error) {
@@ -50,10 +51,10 @@ export const afterImportActions = {
         const db = getDatabaseFromConfig(config);
         // Helper function to find a collection ID by name or return the ID if given
         const findCollectionId = async (collectionIdentifier) => {
-            const collectionsPulled = await db.listCollections(dbId, [
+            const collectionsPulled = await tryAwaitWithRetry(async () => await db.listCollections(dbId, [
                 Query.limit(25),
                 Query.equal("name", collectionIdentifier),
-            ]);
+            ]));
             if (collectionsPulled.total > 0) {
                 return collectionsPulled.collections[0].$id;
             }
@@ -71,9 +72,9 @@ export const afterImportActions = {
             const valueToSet = otherDoc[otherFieldName];
             if (valueToSet) {
                 // Update the target document
-                await db.updateDocument(dbId, targetCollectionId, docId, {
+                await tryAwaitWithRetry(async () => await db.updateDocument(dbId, targetCollectionId, docId, {
                     [fieldName]: valueToSet,
-                });
+                }));
             }
             console.log(`Field ${fieldName} updated successfully in document ${docId}.`);
         }
@@ -89,17 +90,17 @@ export const afterImportActions = {
         const db = getDatabaseFromConfig(config);
         // Helper function to find a collection ID by name or return the ID if given
         const findCollectionId = async (collectionIdentifier) => {
-            const collections = await db.listCollections(dbId, [
+            const collections = await tryAwaitWithRetry(async () => await db.listCollections(dbId, [
                 Query.equal("name", collectionIdentifier),
                 Query.limit(1),
-            ]);
+            ]));
             return collections.total > 0
                 ? collections.collections[0].$id
                 : collectionIdentifier;
         };
         // Function to check if the target field is an array
         const isTargetFieldArray = async (collectionId, fieldName) => {
-            const collection = await db.getCollection(dbId, collectionId);
+            const collection = await tryAwaitWithRetry(async () => await db.getCollection(dbId, collectionId));
             const attribute = collection.attributes.find((attr) => attr.key === fieldName);
             // @ts-ignore
             return attribute?.array === true;
@@ -119,7 +120,7 @@ export const afterImportActions = {
                     queries.push(Query.cursorAfter(cursor));
                 }
                 queries.push(Query.limit(docLimit));
-                const response = await db.listDocuments(dbId, otherCollectionId, queries);
+                const response = await tryAwaitWithRetry(async () => await db.listDocuments(dbId, otherCollectionId, queries));
                 const documents = response.documents;
                 if (documents.length === 0 || documents.length < docLimit) {
                     return documents;
@@ -134,7 +135,7 @@ export const afterImportActions = {
                 const updatePayload = targetFieldIsArray
                     ? { [fieldName]: documentIds }
                     : { [fieldName]: documentIds[0] };
-                await db.updateDocument(dbId, targetCollectionId, docId, updatePayload);
+                await tryAwaitWithRetry(async () => await db.updateDocument(dbId, targetCollectionId, docId, updatePayload));
                 console.log(`Field ${fieldName} updated successfully in document ${docId} with ${documentIds.length} document IDs.`);
             }
         }
@@ -145,10 +146,10 @@ export const afterImportActions = {
     setTargetFieldFromOtherCollectionDocumentsByMatchingField: async (config, dbId, collIdOrName, docId, fieldName, otherCollIdOrName, matchingFieldName, matchingFieldValue, targetField) => {
         const db = getDatabaseFromConfig(config);
         const findCollectionId = async (collectionIdentifier) => {
-            const collections = await db.listCollections(dbId, [
+            const collections = await tryAwaitWithRetry(async () => await db.listCollections(dbId, [
                 Query.equal("name", collectionIdentifier),
                 Query.limit(1),
-            ]);
+            ]));
             return collections.total > 0
                 ? collections.collections[0].$id
                 : collectionIdentifier;
@@ -172,7 +173,7 @@ export const afterImportActions = {
                 if (cursor) {
                     queries.push(Query.cursorAfter(cursor));
                 }
-                const response = await db.listDocuments(dbId, otherCollectionId, queries);
+                const response = await tryAwaitWithRetry(async () => await db.listDocuments(dbId, otherCollectionId, queries));
                 const documents = response.documents;
                 if (documents.length === 0 || documents.length < docLimit) {
                     return documents;
@@ -188,7 +189,7 @@ export const afterImportActions = {
                 const updatePayload = targetFieldIsArray
                     ? { [fieldName]: targetFieldValues }
                     : { [fieldName]: targetFieldValues[0] };
-                await db.updateDocument(dbId, targetCollectionId, docId, updatePayload);
+                await tryAwaitWithRetry(async () => await db.updateDocument(dbId, targetCollectionId, docId, updatePayload));
                 console.log(`Field ${fieldName} updated successfully in document ${docId} with values from field ${targetField}.`);
             }
         }
@@ -199,22 +200,20 @@ export const afterImportActions = {
     createOrGetBucket: async (config, bucketName, bucketId, permissions, fileSecurity, enabled, maxFileSize, allowedExtensions, compression, encryption, antivirus) => {
         try {
             const storage = getStorageFromConfig(config);
-            const bucket = await storage.listBuckets([
-                Query.equal("name", bucketName),
-            ]);
+            const bucket = await tryAwaitWithRetry(async () => await storage.listBuckets([Query.equal("name", bucketName)]));
             if (bucket.buckets.length > 0) {
                 return bucket.buckets[0];
             }
             else if (bucketId) {
                 try {
-                    return await storage.getBucket(bucketId);
+                    return await tryAwaitWithRetry(async () => await storage.getBucket(bucketId));
                 }
                 catch (error) {
-                    return await storage.createBucket(bucketId, bucketName, permissions, fileSecurity, enabled, maxFileSize, allowedExtensions, compression, encryption, antivirus);
+                    return await tryAwaitWithRetry(async () => await storage.createBucket(bucketId, bucketName, permissions, fileSecurity, enabled, maxFileSize, allowedExtensions, compression ? Compression.Gzip : undefined, encryption, antivirus));
                 }
             }
             else {
-                return await storage.createBucket(bucketId || ID.unique(), bucketName, permissions, fileSecurity, enabled, maxFileSize, allowedExtensions, compression, encryption, antivirus);
+                return await tryAwaitWithRetry(async () => await storage.createBucket(bucketId || ID.unique(), bucketName, permissions, fileSecurity, enabled, maxFileSize, allowedExtensions, compression ? Compression.Gzip : undefined, encryption, antivirus));
             }
         }
         catch (error) {
@@ -225,12 +224,16 @@ export const afterImportActions = {
         try {
             const db = getDatabaseFromConfig(config);
             const storage = getStorageFromConfig(config);
-            const collection = await db.getCollection(dbId, collId);
+            const collection = await tryAwaitWithRetry(async () => await db.getCollection(dbId, collId));
             const attributes = collection.attributes;
             const attribute = attributes.find((a) => a.key === fieldName);
             // console.log(
             //   `Processing field ${fieldName} in collection ${collId} for document ${docId} in database ${dbId} in bucket ${bucketId} with path ${filePath} and name ${fileName}...`
             // );
+            if (filePath.length === 0 || fileName.length === 0) {
+                console.error(`File path or name is empty for field ${fieldName} in collection ${collId}, skipping...`);
+                return;
+            }
             let isArray = false;
             if (!attribute) {
                 console.log(`Field ${fieldName} not found in collection ${collId}, weird, skipping...`);
@@ -242,7 +245,7 @@ export const afterImportActions = {
             // Define a helper function to check if a value is a URL
             const isUrl = (value) => typeof value === "string" &&
                 (value.startsWith("http://") || value.startsWith("https://"));
-            const doc = await db.getDocument(dbId, collId, docId);
+            const doc = await tryAwaitWithRetry(async () => await db.getDocument(dbId, collId, docId));
             const existingFieldValue = doc[fieldName];
             // Handle the case where the field is an array
             let updateData = isArray ? [] : "";
@@ -255,7 +258,7 @@ export const afterImportActions = {
                 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "appwrite_tmp"));
                 const tempFilePath = path.join(tempDir, fileName);
                 // Download the file using fetch
-                const response = await fetch(filePath);
+                const response = await tryAwaitWithRetry(async () => await fetch(filePath));
                 if (!response.ok)
                     console.error(`Failed to fetch ${filePath}: ${response.statusText} for document ${docId} with field ${fieldName}`);
                 // Use arrayBuffer if buffer is not available
@@ -265,7 +268,7 @@ export const afterImportActions = {
                 // Create InputFile from the downloaded file
                 const inputFile = InputFile.fromPath(tempFilePath, fileName);
                 // Use the full file name (with extension) for creating the file
-                const file = await storage.createFile(bucketId, ID.unique(), inputFile);
+                const file = await tryAwaitWithRetry(async () => await storage.createFile(bucketId, ID.unique(), inputFile));
                 console.log("Created file from URL: ", file.$id);
                 // After uploading, adjust the updateData based on whether the field is an array or not
                 if (isArray) {
@@ -274,15 +277,9 @@ export const afterImportActions = {
                 else {
                     updateData = file.$id; // Set the new file ID
                 }
-                await db.updateDocument(dbId, collId, doc.$id, {
+                await tryAwaitWithRetry(async () => await db.updateDocument(dbId, collId, doc.$id, {
                     [fieldName]: updateData,
-                });
-                // console.log(
-                //   "Updating document with file: ",
-                //   doc.$id,
-                //   `${fieldName}: `,
-                //   updateData
-                // );
+                }));
                 // If the file was downloaded, delete it after uploading
                 fs.unlinkSync(tempFilePath);
             }
@@ -295,16 +292,16 @@ export const afterImportActions = {
                 }
                 const pathToFile = path.join(filePath, fileFullName);
                 const inputFile = InputFile.fromPath(pathToFile, fileName);
-                const file = await storage.createFile(bucketId, ID.unique(), inputFile);
+                const file = await tryAwaitWithRetry(async () => await storage.createFile(bucketId, ID.unique(), inputFile));
                 if (isArray) {
                     updateData = [...updateData, file.$id]; // Append the new file ID
                 }
                 else {
                     updateData = file.$id; // Set the new file ID
                 }
-                await db.updateDocument(dbId, collId, doc.$id, {
+                tryAwaitWithRetry(async () => await db.updateDocument(dbId, collId, doc.$id, {
                     [fieldName]: updateData,
-                });
+                }));
                 console.log("Created file from path: ", file.$id);
             }
         }