appwrite-utils-cli 0.0.286 → 0.9.2

package/dist/interactiveCLI.js

@@ -0,0 +1,555 @@
+import inquirer from "inquirer";
+import { UtilsController } from "./utilsController.js";
+import { createEmptyCollection, setupDirsFiles } from "./utils/setupFiles.js";
+import { fetchAllDatabases } from "./databases/methods.js";
+import { fetchAllCollections } from "./collections/methods.js";
+import { listBuckets, createBucket } from "./storage/methods.js";
+import { Databases, Storage, Client, Compression, } from "node-appwrite";
+import { getClient } from "./utils/getClientFromConfig.js";
+import { ulid } from "ulidx";
+var CHOICES;
+(function (CHOICES) {
+    CHOICES["CREATE_COLLECTION_CONFIG"] = "Create collection config file";
+    CHOICES["SETUP_DIRS_FILES"] = "Setup directories and files";
+    CHOICES["SETUP_DIRS_FILES_WITH_EXAMPLE_DATA"] = "Setup directories and files with example data";
+    CHOICES["SYNC_DB"] = "Push local config to Appwrite";
+    CHOICES["SYNCHRONIZE_CONFIGURATIONS"] = "Synchronize configurations";
+    CHOICES["TRANSFER_DATA"] = "Transfer data";
+    CHOICES["BACKUP_DATABASE"] = "Backup database";
+    CHOICES["WIPE_DATABASE"] = "Wipe database";
+    CHOICES["GENERATE_SCHEMAS"] = "Generate schemas";
+    CHOICES["IMPORT_DATA"] = "Import data";
+    CHOICES["EXIT"] = "Exit";
+})(CHOICES || (CHOICES = {}));
+export class InteractiveCLI {
+    controller;
+    constructor(currentDir, utilsController) {
+        if (utilsController) {
+            this.controller = utilsController;
+        }
+        else if (currentDir) {
+            this.controller = new UtilsController(currentDir);
+        }
+        else {
+            throw new Error("Current directory or utils controller is required");
+        }
+    }
+    async run() {
+        console.log("Welcome to Appwrite Utils CLI Tool by Zach Handley");
+        console.log("For more information, visit https://github.com/zachhandley/appwrite-utils");
+        await this.controller.init();
+        while (true) {
+            const { action } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "action",
+                    message: "What would you like to do?",
+                    choices: Object.values(CHOICES),
+                },
+            ]);
+            switch (action) {
+                case CHOICES.CREATE_COLLECTION_CONFIG:
+                    await this.createCollectionConfig();
+                    break;
+                case CHOICES.SETUP_DIRS_FILES:
+                    await setupDirsFiles(false);
+                    break;
+                case CHOICES.SETUP_DIRS_FILES_WITH_EXAMPLE_DATA:
+                    await setupDirsFiles(true);
+                    break;
+                case CHOICES.SYNCHRONIZE_CONFIGURATIONS:
+                    await this.synchronizeConfigurations();
+                    break;
+                case CHOICES.SYNC_DB:
+                    await this.syncDb();
+                    break;
+                case CHOICES.TRANSFER_DATA:
+                    await this.transferData();
+                    break;
+                case CHOICES.BACKUP_DATABASE:
+                    await this.backupDatabase();
+                    break;
+                case CHOICES.WIPE_DATABASE:
+                    await this.wipeDatabase();
+                    break;
+                case CHOICES.GENERATE_SCHEMAS:
+                    await this.generateSchemas();
+                    break;
+                case CHOICES.IMPORT_DATA:
+                    await this.importData();
+                    break;
+                case CHOICES.EXIT:
+                    console.log("Exiting...");
+                    return;
+            }
+        }
+    }
+    async selectDatabases(databases, message, multiSelect = true) {
+        const choices = databases.map((db) => ({ name: db.name, value: db }));
+        if (multiSelect) {
+            choices.unshift({ name: "Select All", value: "ALL" });
+            choices.push({ name: "Clear Selection", value: "CLEAR" });
+        }
+        const { selectedDatabases } = await inquirer.prompt([
+            {
+                type: multiSelect ? "checkbox" : "list",
+                name: "selectedDatabases",
+                message,
+                choices,
+                loop: false,
+                pageSize: 10,
+            },
+        ]);
+        if (multiSelect) {
+            if (selectedDatabases.includes("ALL")) {
+                return databases;
+            }
+            else if (selectedDatabases.includes("CLEAR")) {
+                return [];
+            }
+        }
+        return selectedDatabases.filter((db) => typeof db !== "string");
+    }
+    async selectCollections(database, databasesClient, message, multiSelect = true) {
+        const collections = await fetchAllCollections(database.$id, databasesClient);
+        const choices = collections.map((collection) => ({
+            name: collection.name,
+            value: collection,
+        }));
+        if (multiSelect) {
+            choices.unshift({ name: "Select All", value: "ALL" });
+            choices.push({ name: "Clear Selection", value: "CLEAR" });
+        }
+        const { selectedCollections } = await inquirer.prompt([
+            {
+                type: multiSelect ? "checkbox" : "list",
+                name: "selectedCollections",
+                message,
+                choices,
+                loop: false,
+                pageSize: 10,
+            },
+        ]);
+        if (multiSelect) {
+            if (selectedCollections.includes("ALL")) {
+                return collections;
+            }
+            else if (selectedCollections.includes("CLEAR")) {
+                return [];
+            }
+        }
+        return selectedCollections.filter((collection) => typeof collection !== "string");
+    }
+    async selectBuckets(buckets, message, multiSelect = true) {
+        const choices = buckets.map((bucket) => ({
+            name: bucket.name,
+            value: bucket.$id,
+        }));
+        if (multiSelect) {
+            choices.unshift({ name: "Select All", value: "ALL" });
+            choices.push({ name: "Clear Selection", value: "CLEAR" });
+        }
+        const { selectedBuckets } = await inquirer.prompt([
+            {
+                type: multiSelect ? "checkbox" : "list",
+                name: "selectedBuckets",
+                message,
+                choices,
+                loop: false,
+                pageSize: 10,
+            },
+        ]);
+        if (multiSelect) {
+            if (selectedBuckets.includes("ALL")) {
+                return buckets;
+            }
+            else if (selectedBuckets.includes("CLEAR")) {
+                return [];
+            }
+        }
+        return selectedBuckets.map((id) => buckets.find((bucket) => bucket.$id === id));
+    }
+    async createCollectionConfig() {
+        const { collectionName } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "collectionName",
+                message: "Enter the name of the collection:",
+                validate: (input) => input.trim() !== "" || "Collection name cannot be empty.",
+            },
+        ]);
+        console.log(`Creating collection config file for '${collectionName}'...`);
+        createEmptyCollection(collectionName);
+    }
+    async configureBuckets(config, databases) {
+        const { storage } = this.controller;
+        if (!storage) {
+            throw new Error("Storage is not initialized. Is the config file correct and created?");
+        }
+        const allBuckets = await listBuckets(storage);
+        // If there are no buckets, ask to create one for each database
+        if (allBuckets.total === 0) {
+            for (const database of databases ?? config.databases) {
+                const { wantCreateBucket } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "wantCreateBucket",
+                        message: `There are no buckets. Do you want to create a bucket for the database "${database.name}"?`,
+                        default: true,
+                    },
+                ]);
+                if (wantCreateBucket) {
+                    const createdBucket = await this.createNewBucket(storage, database.name);
+                    database.bucket = {
+                        ...createdBucket,
+                        compression: createdBucket.compression,
+                    };
+                }
+            }
+            return config;
+        }
+        // Configure global buckets
+        let globalBuckets = [];
+        if (allBuckets.total > 0) {
+            globalBuckets = await this.selectBuckets(allBuckets.buckets, "Select global buckets (buckets that are not associated with any specific database):", true);
+            config.buckets = globalBuckets.map((bucket) => ({
+                $id: bucket.$id,
+                name: bucket.name,
+                enabled: bucket.enabled,
+                maximumFileSize: bucket.maximumFileSize,
+                allowedFileExtensions: bucket.allowedFileExtensions,
+                compression: bucket.compression,
+                encryption: bucket.encryption,
+                antivirus: bucket.antivirus,
+            }));
+        }
+        else {
+            config.buckets = [];
+        }
+        // Configure database-specific buckets
+        for (const database of config.databases) {
+            const { assignBucket } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "assignBucket",
+                    message: `Do you want to assign or create a bucket for the database "${database.name}"?`,
+                    default: false,
+                },
+            ]);
+            if (assignBucket) {
+                const { action } = await inquirer.prompt([
+                    {
+                        type: "list",
+                        name: "action",
+                        message: `Choose an action for the database "${database.name}":`,
+                        choices: [
+                            { name: "Assign existing bucket", value: "assign" },
+                            { name: "Create new bucket", value: "create" },
+                        ],
+                    },
+                ]);
+                if (action === "assign") {
+                    const [selectedBucket] = await this.selectBuckets(allBuckets.buckets.filter((b) => !globalBuckets.some((gb) => gb.$id === b.$id)), `Select a bucket for the database "${database.name}":`, false);
+                    if (selectedBucket) {
+                        database.bucket = {
+                            $id: selectedBucket.$id,
+                            name: selectedBucket.name,
+                            enabled: selectedBucket.enabled,
+                            maximumFileSize: selectedBucket.maximumFileSize,
+                            allowedFileExtensions: selectedBucket.allowedFileExtensions,
+                            compression: selectedBucket.compression,
+                            encryption: selectedBucket.encryption,
+                            antivirus: selectedBucket.antivirus,
+                        };
+                    }
+                }
+                else if (action === "create") {
+                    const createdBucket = await this.createNewBucket(storage, database.name);
+                    database.bucket = {
+                        ...createdBucket,
+                        compression: createdBucket.compression,
+                    };
+                }
+            }
+        }
+        return config;
+    }
+    async createNewBucket(storage, databaseName) {
+        const { bucketName, bucketEnabled, bucketMaximumFileSize, bucketAllowedFileExtensions, bucketFileSecurity, bucketCompression, bucketCompressionType, bucketEncryption, bucketAntivirus, bucketId, } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "bucketName",
+                message: `Enter the name of the bucket for database "${databaseName}":`,
+                default: `${databaseName}-bucket`,
+            },
+            {
+                type: "confirm",
+                name: "bucketEnabled",
+                message: "Is the bucket enabled?",
+                default: true,
+            },
+            {
+                type: "confirm",
+                name: "bucketFileSecurity",
+                message: "Do you want to enable file security for the bucket?",
+                default: false,
+            },
+            {
+                type: "number",
+                name: "bucketMaximumFileSize",
+                message: "Enter the maximum file size for the bucket (MB):",
+                default: 1000000,
+            },
+            {
+                type: "input",
+                name: "bucketAllowedFileExtensions",
+                message: "Enter the allowed file extensions for the bucket (comma separated):",
+                default: "",
+            },
+            {
+                type: "confirm",
+                name: "bucketCompression",
+                message: "Do you want to enable compression for the bucket?",
+                default: false,
+            },
+            {
+                type: "list",
+                name: "bucketCompressionType",
+                message: "Select the compression type for the bucket:",
+                choices: Object.values(Compression),
+                default: Compression.None,
+                when: (answers) => answers.bucketCompression,
+            },
+            {
+                type: "confirm",
+                name: "bucketEncryption",
+                message: "Do you want to enable encryption for the bucket?",
+                default: false,
+            },
+            {
+                type: "confirm",
+                name: "bucketAntivirus",
+                message: "Do you want to enable antivirus for the bucket?",
+                default: false,
+            },
+            {
+                type: "input",
+                name: "bucketId",
+                message: "Enter the ID of the bucket (or empty for auto-generation):",
+            },
+        ]);
+        return await createBucket(storage, {
+            name: bucketName,
+            $permissions: [],
+            enabled: bucketEnabled,
+            fileSecurity: bucketFileSecurity,
+            maximumFileSize: bucketMaximumFileSize * 1024 * 1024,
+            allowedFileExtensions: bucketAllowedFileExtensions.length > 0
+                ? bucketAllowedFileExtensions?.split(",")
+                : [],
+            compression: bucketCompressionType,
+            encryption: bucketEncryption,
+            antivirus: bucketAntivirus,
+        }, bucketId.length > 0 ? bucketId : ulid());
+    }
+    async syncDb() {
+        await this.controller.syncDb();
+    }
+    async synchronizeConfigurations() {
+        if (!this.controller.database) {
+            throw new Error("Database is not initialized. Is the config file correct and created?");
+        }
+        const databases = await fetchAllDatabases(this.controller.database);
+        const selectedDatabases = await this.selectDatabases(databases, "Select databases to synchronize (or select none to synchronize all):");
+        console.log("Configuring storage buckets...");
+        const updatedConfig = await this.configureBuckets(this.controller.config, selectedDatabases);
+        console.log("Synchronizing configurations...");
+        await this.controller.synchronizeConfigurations(selectedDatabases, updatedConfig);
+    }
+    async backupDatabase() {
+        if (!this.controller.database) {
+            throw new Error("Database is not initialized, is the config file correct & created?");
+        }
+        const databases = await fetchAllDatabases(this.controller.database);
+        const selectedDatabases = await this.selectDatabases(databases, "Select databases to backup (or select none to backup all):");
+        for (const db of selectedDatabases) {
+            console.log(`Backing up database: ${db.name}`);
+            await this.controller.backupDatabase(db);
+        }
+    }
+    async wipeDatabase() {
+        if (!this.controller.database || !this.controller.storage) {
+            throw new Error("Database or Storage is not initialized, is the config file correct & created?");
+        }
+        const databases = await fetchAllDatabases(this.controller.database);
+        const storage = await listBuckets(this.controller.storage);
+        const selectedDatabases = await this.selectDatabases(databases, "Select databases to wipe (or select none to skip database wipe):");
+        const { selectedStorage } = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "selectedStorage",
+                message: "Select storage buckets to wipe (or select none to skip storage wipe):",
+                choices: storage.buckets.map((s) => ({ name: s.name, value: s.$id })),
+            },
+        ]);
+        const { wipeUsers } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "wipeUsers",
+                message: "Do you want to wipe users as well?",
+                default: false,
+            },
+        ]);
+        const { confirm } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "Are you sure you want to wipe the selected items? This action cannot be undone.",
+                default: false,
+            },
+        ]);
+        if (confirm) {
+            console.log("Wiping selected items...");
+            for (const db of selectedDatabases) {
+                await this.controller.wipeDatabase(db);
+            }
+            for (const bucketId of selectedStorage) {
+                await this.controller.wipeDocumentStorage(bucketId);
+            }
+            if (wipeUsers) {
+                await this.controller.wipeUsers();
+            }
+        }
+        else {
+            console.log("Wipe operation cancelled.");
+        }
+    }
+    async generateSchemas() {
+        console.log("Generating schemas...");
+        await this.controller.generateSchemas();
+    }
+    async importData() {
+        if (!this.controller.database) {
+            throw new Error("Database is not initialized, is the config file correct & created?");
+        }
+        const databases = await fetchAllDatabases(this.controller.database);
+        const selectedDatabases = await this.selectDatabases(databases, "Select the database(s) to import data into:");
+        let selectedCollections = [];
+        for (const db of selectedDatabases) {
+            const dbCollections = await this.selectCollections(db, this.controller.database, `Select collections to import data into for database ${db.name} (or select none to import into all):`, true);
+            selectedCollections = [...selectedCollections, ...dbCollections];
+        }
+        const { shouldWriteFile } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "shouldWriteFile",
+                message: "Do you want to write the imported data to a file?",
+                default: false,
+            },
+        ]);
+        const { checkDuplicates } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "checkDuplicates",
+                message: "Do you want to check for duplicates during import?",
+                default: true,
+            },
+        ]);
+        console.log("Importing data...");
+        await this.controller.importData({
+            databases: selectedDatabases,
+            collections: selectedCollections.length > 0
+                ? selectedCollections.map((c) => c.$id)
+                : undefined,
+            shouldWriteFile,
+            checkDuplicates,
+        });
+    }
+    async transferData() {
+        if (!this.controller.database) {
+            throw new Error("Database is not initialized, is the config file correct & created?");
+        }
+        const { isRemote } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "isRemote",
+                message: "Is this a remote transfer?",
+                default: false,
+            },
+        ]);
+        let sourceClient = this.controller.database;
+        let targetClient;
+        let sourceDatabases;
+        let targetDatabases;
+        let remoteOptions;
+        if (isRemote) {
+            remoteOptions = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "transferEndpoint",
+                    message: "Enter the remote endpoint:",
+                },
+                {
+                    type: "input",
+                    name: "transferProject",
+                    message: "Enter the remote project ID:",
+                },
+                {
+                    type: "input",
+                    name: "transferKey",
+                    message: "Enter the remote API key:",
+                },
+            ]);
+            const remoteClient = getClient(remoteOptions.transferEndpoint, remoteOptions.transferProject, remoteOptions.transferKey);
+            targetClient = new Databases(remoteClient);
+            sourceDatabases = await fetchAllDatabases(sourceClient);
+            targetDatabases = await fetchAllDatabases(targetClient);
+        }
+        else {
+            targetClient = sourceClient;
+            sourceDatabases = targetDatabases = await fetchAllDatabases(sourceClient);
+        }
+        const [fromDb] = await this.selectDatabases(sourceDatabases, "Select the source database:", false);
+        const [targetDb] = await this.selectDatabases(targetDatabases.filter((db) => db.$id !== fromDb.$id), "Select the target database:", false);
+        const selectedCollections = await this.selectCollections(fromDb, sourceClient, "Select collections to transfer (or select none to transfer all):");
+        const { transferStorage } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "transferStorage",
+                message: "Do you want to transfer storage as well?",
+                default: false,
+            },
+        ]);
+        let sourceBucket, targetBucket;
+        if (transferStorage) {
+            const sourceStorage = new Storage(this.controller.appwriteServer);
+            const targetStorage = isRemote
+                ? new Storage(getClient(remoteOptions.transferEndpoint, remoteOptions.transferProject, remoteOptions.transferKey))
+                : sourceStorage;
+            const sourceBuckets = await listBuckets(sourceStorage);
+            const targetBuckets = isRemote
+                ? await listBuckets(targetStorage)
+                : sourceBuckets;
+            [sourceBucket] = await this.selectBuckets(sourceBuckets.buckets, "Select the source bucket:", false);
+            [targetBucket] = await this.selectBuckets(targetBuckets.buckets, "Select the target bucket:", false);
+        }
+        let transferOptions = {
+            fromDb,
+            targetDb,
+            isRemote,
+            collections: selectedCollections.length > 0
+                ? selectedCollections.map((c) => c.$id)
+                : undefined,
+            sourceBucket,
+            targetBucket,
+        };
+        if (isRemote && remoteOptions) {
+            transferOptions = {
+                ...transferOptions,
+                ...remoteOptions,
+            };
+        }
+        console.log("Transferring data...");
+        await this.controller.transferData(transferOptions);
+    }
+}