chirag-appwrite-cli 0.1.0

package/lib/commands/generic.js

@@ -0,0 +1,328 @@
+const inquirer = require("inquirer");
+const { Command } = require("commander");
+const Client = require("../client");
+const { sdkForConsole } = require("../sdks");
+const { globalConfig, localConfig } = require("../config");
+const { actionRunner, success, parseBool, commandDescriptions, error, parse, hint, log, drawTable, cliConfig } = require("../parser");
+const ID = require("../id");
+const { questionsLogin, questionsLogout, questionsListFactors, questionsMfaChallenge } = require("../questions");
+const { accountUpdateMfaChallenge, accountCreateMfaChallenge, accountGet, accountCreateEmailPasswordSession, accountDeleteSession } = require("./account");
+
+const DEFAULT_ENDPOINT = 'https://cloud.appwrite.io/v1';
+
+const loginCommand = async ({ email, password, endpoint, mfa, code }) => {
+    const oldCurrent = globalConfig.getCurrentSession();
+
+    const configEndpoint = (endpoint ?? globalConfig.getEndpoint()) || DEFAULT_ENDPOINT;
+
+    if (globalConfig.getCurrentSession() !== '') {
+        log('You are currently signed in as ' + globalConfig.getEmail());
+
+        if (globalConfig.getSessions().length === 1) {
+            hint('You can sign in and manage multiple accounts with Appwrite CLI');
+        }
+    }
+
+    const answers = email && password ? { email, password } : await inquirer.prompt(questionsLogin);
+
+    if (!answers.method) {
+        answers.method = 'login';
+    }
+
+    if (answers.method === 'select') {
+        const accountId = answers.accountId;
+
+        if (!globalConfig.getSessionIds().includes(accountId)) {
+            throw Error('Session ID not found');
+        }
+
+        globalConfig.setCurrentSession(accountId);
+        success(`Current account is ${accountId}`);
+
+        return;
+    }
+
+    const id = ID.unique();
+
+    globalConfig.addSession(id, {});
+    globalConfig.setCurrentSession(id);
+    globalConfig.setEndpoint(configEndpoint);
+    globalConfig.setEmail(answers.email);
+
+    let client = await sdkForConsole(false);
+
+    let account;
+
+    try {
+        await accountCreateEmailPasswordSession({
+            email: answers.email,
+            password: answers.password,
+            parseOutput: false,
+            sdk: client
+        })
+
+        client.setCookie(globalConfig.getCookie());
+
+        account = await accountGet({
+            sdk: client,
+            parseOutput: false
+        });
+    } catch (error) {
+        if (error.response === 'user_more_factors_required') {
+            const { factor } = mfa ? { factor: mfa } : await inquirer.prompt(questionsListFactors);
+
+            const challenge = await accountCreateMfaChallenge({
+                factor,
+                parseOutput: false,
+                sdk: client
+            });
+
+            const { otp } = code ? { otp: code } : await inquirer.prompt(questionsMfaChallenge);
+
+            await accountUpdateMfaChallenge({
+                challengeId: challenge.$id,
+                otp,
+                parseOutput: false,
+                sdk: client
+            });
+
+            account = await accountGet({
+                sdk: client,
+                parseOutput: false
+            });
+        } else {
+            globalConfig.removeSession(id);
+            globalConfig.setCurrentSession(oldCurrent);
+            if (endpoint !== DEFAULT_ENDPOINT && error.response === 'user_invalid_credentials') {
+                log('Use the --endpoint option for self-hosted instances')
+            }
+            throw error;
+        }
+    }
+
+    success("Successfully signed in as " + account.email);
+    hint("Next you can create or link to your project using 'appwrite init project'");
+};
+
+const whoami = new Command("whoami")
+    .description(commandDescriptions['whoami'])
+    .action(actionRunner(async () => {
+        if (globalConfig.getEndpoint() === '' || globalConfig.getCookie() === '') {
+            error("No user is signed in. To sign in, run 'appwrite login'");
+            return;
+        }
+
+        let client = await sdkForConsole(false);
+
+        let account;
+
+        try {
+            account = await accountGet({
+                sdk: client,
+                parseOutput: false
+            });
+        } catch (_) {
+            error("No user is signed in. To sign in, run 'appwrite login'");
+            return;
+        }
+
+        const data = [
+            {
+                'ID': account.$id,
+                'Name': account.name,
+                'Email': account.email,
+                'MFA enabled': account.mfa ? 'Yes' : 'No',
+                'Endpoint': globalConfig.getEndpoint()
+            }
+        ];
+
+        if (cliConfig.json) {
+            console.log(data);
+            return;
+        }
+
+        drawTable(data)
+    }));
+
+const register = new Command("register")
+    .description(commandDescriptions['register'])
+    .action(actionRunner(async () => {
+        log('Visit https://cloud.appwrite.io/register to create an account')
+    }));
+
+const login = new Command("login")
+    .description(commandDescriptions['login'])
+    .option(`--email [email]`, `User email`)
+    .option(`--password [password]`, `User password`)
+    .option(`--endpoint [endpoint]`, `Appwrite endpoint for self hosted instances`)
+    .option(`--mfa [factor]`, `Multi-factor authentication login factor: totp, email, phone or recoveryCode`)
+    .option(`--code [code]`, `Multi-factor code`)
+    .configureHelp({
+        helpWidth: process.stdout.columns || 80
+    })
+    .action(actionRunner(loginCommand));
+
+const deleteSession = async (accountId) => {
+    try {
+        let client = await sdkForConsole();
+
+        await accountDeleteSession({
+            sessionId: 'current',
+            parseOutput: false,
+            sdk: client
+        })
+
+        globalConfig.removeSession(accountId);
+    } catch (e) {
+        error('Unable to log out, removing locally saved session information')
+    }
+    globalConfig.removeSession(accountId);
+}
+
+const logout = new Command("logout")
+    .description(commandDescriptions['logout'])
+    .configureHelp({
+        helpWidth: process.stdout.columns || 80
+    })
+    .action(actionRunner(async () => {
+        const sessions = globalConfig.getSessions();
+        const current = globalConfig.getCurrentSession();
+
+        if (current === '' || !sessions.length) {
+            log('No active sessions found.');
+            return;
+        }
+        if (sessions.length === 1) {
+            await deleteSession(current);
+            success("Logging out");
+
+            return;
+        }
+
+        const answers = await inquirer.prompt(questionsLogout);
+
+        if (answers.accounts) {
+            for (let accountId of answers.accounts) {
+                globalConfig.setCurrentSession(accountId);
+                await deleteSession(accountId);
+            }
+        }
+
+        const remainingSessions = globalConfig.getSessions();
+
+        if (remainingSessions.length > 0 && remainingSessions.filter(session => session.id === current).length !== 1) {
+            const accountId = remainingSessions [0].id;
+            globalConfig.setCurrentSession(accountId);
+
+            success(`Current account is ${accountId}`);
+        }
+
+        success("Logging out");
+    }));
+
+const client = new Command("client")
+    .description(commandDescriptions['client'])
+    .configureHelp({
+        helpWidth: process.stdout.columns || 80
+    })
+    .option("-ss, --self-signed <value>", "Configure the CLI to use a self-signed certificate ( true or false )", parseBool)
+    .option("-e, --endpoint <endpoint>", "Set your Appwrite server endpoint")
+    .option("-p, --project-id <project-id>", "Set your Appwrite project ID")
+    .option("-k, --key <key>", "Set your Appwrite server's API key")
+    .option("-d, --debug", "Print CLI debug information")
+    .option("-r, --reset", "Reset the CLI configuration")
+    .action(actionRunner(async ({ selfSigned, endpoint, projectId, key, debug, reset }, command) => {
+        if (selfSigned == undefined && endpoint == undefined && projectId == undefined && key == undefined && debug == undefined && reset == undefined) {
+            command.help()
+        }
+
+        if (debug) {
+            let config = {
+                endpoint: globalConfig.getEndpoint(),
+                key: globalConfig.getKey(),
+                cookie: globalConfig.getCookie(),
+                selfSigned: globalConfig.getSelfSigned(),
+                project: localConfig.getProject()
+            }
+            parse(config)
+        }
+
+        if (endpoint !== undefined) {
+            try {
+                const id = ID.unique();
+                let url = new URL(endpoint);
+                if (url.protocol !== "http:" && url.protocol !== "https:") {
+                    throw new Error();
+                }
+
+                let client = new Client().setEndpoint(endpoint);
+                client.setProject('console');
+                if (selfSigned || globalConfig.getSelfSigned()) {
+                    client.setSelfSigned(true);
+                }
+                let response = await client.call('GET', '/health/version');
+                if (!response.version) {
+                    throw new Error();
+                }
+                globalConfig.setCurrentSession(id);
+                globalConfig.addSession(id, {});
+                globalConfig.setEndpoint(endpoint);
+            } catch (_) {
+                throw new Error("Invalid endpoint or your Appwrite server is not running as expected.");
+            }
+        }
+
+        if (key !== undefined) {
+            globalConfig.setKey(key)
+        }
+
+        if (projectId !== undefined) {
+            localConfig.setProject(projectId, '');
+        }
+
+        if (selfSigned == true || selfSigned == false) {
+            globalConfig.setSelfSigned(selfSigned);
+        }
+
+        if (reset !== undefined) {
+            const sessions = globalConfig.getSessions();
+
+            for (let accountId of sessions.map(session => session.id)) {
+                globalConfig.setCurrentSession(accountId);
+                await deleteSession(accountId);
+            }
+        }
+
+        success("Setting client")
+    }));
+
+const migrate = async () => {
+    if (!globalConfig.has('endpoint') || !globalConfig.has('cookie')) {
+        return;
+    }
+
+    const endpoint = globalConfig.get('endpoint');
+    const cookie = globalConfig.get('cookie');
+
+    const id = ID.unique();
+    const data = {
+        endpoint,
+        cookie,
+        email: 'legacy'
+    };
+
+    globalConfig.addSession(id, data);
+    globalConfig.setCurrentSession(id);
+    globalConfig.delete('endpoint');
+    globalConfig.delete('cookie');
+
+}
+module.exports = {
+        loginCommand,
+    whoami,
+    register,
+    login,
+    logout,
+        migrate,
+    client
+};

package/lib/commands/graphql.js

@@ -0,0 +1,128 @@
+const fs = require('fs');
+const pathLib = require('path');
+const tar = require("tar");
+const ignore = require("ignore");
+const { promisify } = require('util');
+const libClient = require('../client.js');
+const { getAllFiles, showConsoleLink } = require('../utils.js');
+const { Command } = require('commander');
+const { sdkForProject, sdkForConsole } = require('../sdks')
+const { parse, actionRunner, parseInteger, parseBool, commandDescriptions, success, log } = require('../parser')
+const { localConfig, globalConfig } = require("../config");
+const { File } = require('undici');
+const { ReadableStream } = require('stream/web');
+
+/**
+ * @param {fs.ReadStream} readStream
+ * @returns {ReadableStream}
+ */
+function convertReadStreamToReadableStream(readStream) {
+  return new ReadableStream({
+    start(controller) {
+      readStream.on("data", (chunk) => {
+        controller.enqueue(chunk);
+      });
+      readStream.on("end", () => {
+        controller.close();
+      });
+      readStream.on("error", (err) => {
+        controller.error(err);
+      });
+    },
+    cancel() {
+      readStream.destroy();
+    },
+  });
+}
+
+const graphql = new Command("graphql").description(commandDescriptions['graphql'] ?? '').configureHelp({
+    helpWidth: process.stdout.columns || 80
+})
+
+/**
+ * @typedef {Object} GraphqlQueryRequestParams
+ * @property {object} query The query or queries to execute.
+ * @property {boolean} overrideForCli
+ * @property {boolean} parseOutput
+ * @property {libClient | undefined} sdk
+ */
+
+/**
+ * @param {GraphqlQueryRequestParams} params
+ */
+const graphqlQuery = async ({query,parseOutput = true, overrideForCli = false, sdk = undefined}) => {
+    let client = !sdk ? await sdkForProject() :
+    sdk;
+    let apiPath = '/graphql';
+    let payload = {};
+    if (typeof query !== 'undefined') {
+        payload['query'] = JSON.parse(query);
+    }
+
+    let response = undefined;
+
+    response = await client.call('post', apiPath, {
+        'x-sdk-graphql': 'true',
+        'content-type': 'application/json',
+    }, payload);
+
+    if (parseOutput) {
+        parse(response)
+    }
+
+    return response;
+
+}
+
+/**
+ * @typedef {Object} GraphqlMutationRequestParams
+ * @property {object} query The query or queries to execute.
+ * @property {boolean} overrideForCli
+ * @property {boolean} parseOutput
+ * @property {libClient | undefined} sdk
+ */
+
+/**
+ * @param {GraphqlMutationRequestParams} params
+ */
+const graphqlMutation = async ({query,parseOutput = true, overrideForCli = false, sdk = undefined}) => {
+    let client = !sdk ? await sdkForProject() :
+    sdk;
+    let apiPath = '/graphql/mutation';
+    let payload = {};
+    if (typeof query !== 'undefined') {
+        payload['query'] = JSON.parse(query);
+    }
+
+    let response = undefined;
+
+    response = await client.call('post', apiPath, {
+        'x-sdk-graphql': 'true',
+        'content-type': 'application/json',
+    }, payload);
+
+    if (parseOutput) {
+        parse(response)
+    }
+
+    return response;
+
+}
+
+graphql
+    .command(`query`)
+    .description(`Execute a GraphQL mutation.`)
+    .requiredOption(`--query <query>`, `The query or queries to execute.`)
+    .action(actionRunner(graphqlQuery))
+
+graphql
+    .command(`mutation`)
+    .description(`Execute a GraphQL mutation.`)
+    .requiredOption(`--query <query>`, `The query or queries to execute.`)
+    .action(actionRunner(graphqlMutation))
+
+module.exports = {
+    graphql,
+    graphqlQuery,
+    graphqlMutation
+};