appwrite-cli 0.16.0 → 0.18.1

package/lib/commands/deploy.js

@@ -1,38 +1,42 @@
 const inquirer = require("inquirer");
+const JSONbig = require("json-bigint")({ storeAsString: false });
 const { Command } = require("commander");
 const { localConfig } = require("../config");
 const { questionsDeployFunctions, questionsGetEntrypoint, questionsDeployCollections } = require("../questions");
 const { actionRunner, success, log, error, commandDescriptions } = require("../parser");
 const { functionsGet, functionsCreate, functionsUpdate, functionsCreateDeployment, functionsUpdateDeployment } = require('./functions');
 const {
-    databaseCreateBooleanAttribute,
-    databaseGetCollection,
-    databaseCreateCollection,
-    databaseCreateStringAttribute,
-    databaseCreateIntegerAttribute,
-    databaseCreateFloatAttribute,
-    databaseCreateEmailAttribute,
-    databaseCreateIndex,
-    databaseCreateUrlAttribute,
-    databaseCreateIpAttribute,
-    databaseCreateEnumAttribute,
-    databaseDeleteAttribute,
-    databaseListAttributes,
-    databaseListIndexes,
-    databaseDeleteIndex
-} = require("./database");
+    databasesGet,
+    databasesCreate,
+    databasesCreateBooleanAttribute,
+    databasesGetCollection,
+    databasesCreateCollection,
+    databasesCreateStringAttribute,
+    databasesCreateIntegerAttribute,
+    databasesCreateFloatAttribute,
+    databasesCreateEmailAttribute,
+    databasesCreateIndex,
+    databasesCreateUrlAttribute,
+    databasesCreateIpAttribute,
+    databasesCreateEnumAttribute,
+    databasesDeleteAttribute,
+    databasesListAttributes,
+    databasesListIndexes,
+    databasesDeleteIndex
+} = require("./databases");
 
 const POOL_DEBOUNCE = 2000; // in milliseconds
 const POOL_MAX_DEBOUNCES = 30;
 
 const awaitPools = {
-    wipeAttributes: async (collectionId, iteration = 1) => {
+    wipeAttributes: async (databaseId, collectionId, iteration = 1) => {
         if (iteration > POOL_MAX_DEBOUNCES) {
             return false;
         }
 
         // TODO: Pagination?
-        const { attributes: remoteAttributes } = await databaseListAttributes({
+        const { attributes: remoteAttributes } = await databasesListAttributes({
+            databaseId,
             collectionId,
             limit: 100,
             parseOutput: false
@@ -43,15 +47,16 @@ const awaitPools = {
         }
 
         await new Promise(resolve => setTimeout(resolve, POOL_DEBOUNCE));
-        return await awaitPools.wipeAttributes(collectionId, iteration + 1);
+        return await awaitPools.wipeAttributes(databaseId, collectionId, iteration + 1);
     },
-    wipeIndexes: async (collectionId, iteration = 1) => {
+    wipeIndexes: async (databaseId, collectionId, iteration = 1) => {
         if (iteration > POOL_MAX_DEBOUNCES) {
             return false;
         }
 
         // TODO: Pagination?
-        const { indexes: remoteIndexes } = await databaseListIndexes({
+        const { indexes: remoteIndexes } = await databasesListIndexes({
+            databaseId,
             collectionId,
             limit: 100,
             parseOutput: false
@@ -62,15 +67,16 @@ const awaitPools = {
         }
 
         await new Promise(resolve => setTimeout(resolve, POOL_DEBOUNCE));
-        return await awaitPools.wipeIndexes(collectionId, iteration + 1);
+        return await awaitPools.wipeIndexes(databaseId, collectionId, iteration + 1);
     },
-    expectAttributes: async (collectionId, attributeKeys, iteration = 1) => {
+    expectAttributes: async (databaseId, collectionId, attributeKeys, iteration = 1) => {
         if (iteration > POOL_MAX_DEBOUNCES) {
             return false;
         }
 
         // TODO: Pagination?
-        const { attributes: remoteAttributes } = await databaseListAttributes({
+        const { attributes: remoteAttributes } = await databasesListAttributes({
+            databaseId,
             collectionId,
             limit: 100,
             parseOutput: false
@@ -93,15 +99,16 @@ const awaitPools = {
         }
 
         await new Promise(resolve => setTimeout(resolve, POOL_DEBOUNCE));
-        return await awaitPools.expectAttributes(collectionId, attributeKeys, iteration + 1);
+        return await awaitPools.expectAttributes(databaseId, collectionId, attributeKeys, iteration + 1);
     },
-    expectIndexes: async (collectionId, indexKeys, iteration = 1) => {
+    expectIndexes: async (databaseId, collectionId, indexKeys, iteration = 1) => {
         if (iteration > POOL_MAX_DEBOUNCES) {
             return false;
         }
 
         // TODO: Pagination?
-        const { indexes: remoteIndexes } = await databaseListIndexes({
+        const { indexes: remoteIndexes } = await databasesListIndexes({
+            databaseId,
             collectionId,
             limit: 100,
             parseOutput: false
@@ -124,32 +131,49 @@ const awaitPools = {
         }
 
         await new Promise(resolve => setTimeout(resolve, POOL_DEBOUNCE));
-        return await awaitPools.expectIndexes(collectionId, indexKeys, iteration + 1);
+        return await awaitPools.expectIndexes(databaseId, collectionId, indexKeys, iteration + 1);
     },
 }
 
 const deploy = new Command("deploy")
     .description(commandDescriptions['deploy'])
-    .option("--all", "Flag to deploy collections and functions")
-    .action(actionRunner(async ({ all }, command) => {
-        if (all == undefined) {
-            command.help()
-        }
-
-        try {
-            await deployFunction();
-        } catch (e) {
-            error(e.message);
-        }
-        await deployCollection()
+    .action(actionRunner(async (_options, command) => {
+        command.help()
     }));
 
-const deployFunction = async () => {
+const deployFunction = async ({ functionId, all } = {}) => {
     let response = {};
 
-    let answers = await inquirer.prompt(questionsDeployFunctions)
-    let functions = answers.functions
+    const functionIds = [];
+
+    if(functionId) {
+        functionIds.push(functionId);
+    } else if(all) {
+        const functions = localConfig.getFunctions();
+        if (functions.length === 0) {
+            throw new Error("No functions found in the current directory.");
+        }
+        functionIds.push(...functions.map((func, idx) => {
+            return func.$id;
+        }));
+    }
 
+    if(functionIds.length <= 0) {
+        const answers = await inquirer.prompt(questionsDeployFunctions);
+        functionIds.push(...answers.functions);
+    }
+
+    let functions = functionIds.map((id) => {
+      const functions = localConfig.getFunctions();
+      const func = functions.find((f) => f.$id === id);
+
+      if(!func) {
+        throw new Error("Function '" + id + "' not found.")
+      }
+
+      return func;
+    });
+    
     for (let func of functions) {
         log(`Deploying function ${func.name} ( ${func['$id']} )`)
 
@@ -167,7 +191,7 @@ const deployFunction = async () => {
                 functionId: func['$id'],
                 name: func.name,
                 execute: func.execute,
-                vars: response.vars,
+                vars: JSON.stringify(response.vars),
                 events: func.events,
                 schedule: func.schedule,
                 timeout: func.timeout,
@@ -181,7 +205,7 @@ const deployFunction = async () => {
                     name: func.name,
                     runtime: func.runtime,
                     execute: func.execute,
-                    vars: func.vars,
+                    vars: JSON.stringify(func.vars),
                     events: func.events,
                     schedule: func.schedule,
                     timeout: func.timeout,
@@ -229,12 +253,13 @@ const deployFunction = async () => {
     }
 }
 
-const createAttribute = async (collectionId, attribute) => {
+const createAttribute = async (databaseId, collectionId, attribute) => {
     switch (attribute.type) {
         case 'string':
             switch (attribute.format) {
                 case 'email':
-                    return await databaseCreateEmailAttribute({
+                    return await databasesCreateEmailAttribute({
+                        databaseId,
                         collectionId,
                         key: attribute.key,
                         required: attribute.required,
@@ -243,7 +268,8 @@ const createAttribute = async (collectionId, attribute) => {
                         parseOutput: false
                     })
                 case 'url':
-                    return await databaseCreateUrlAttribute({
+                    return await databasesCreateUrlAttribute({
+                        databaseId,
                         collectionId,
                         key: attribute.key,
                         required: attribute.required,
@@ -252,7 +278,8 @@ const createAttribute = async (collectionId, attribute) => {
                         parseOutput: false
                     })
                 case 'ip':
-                    return await databaseCreateIpAttribute({
+                    return await databasesCreateIpAttribute({
+                        databaseId,
                         collectionId,
                         key: attribute.key,
                         required: attribute.required,
@@ -261,7 +288,8 @@ const createAttribute = async (collectionId, attribute) => {
                         parseOutput: false
                     })
                 case 'enum':
-                    return await databaseCreateEnumAttribute({
+                    return await databasesCreateEnumAttribute({
+                        databaseId,
                         collectionId,
                         key: attribute.key,
                         elements: attribute.elements,
@@ -271,7 +299,8 @@ const createAttribute = async (collectionId, attribute) => {
                         parseOutput: false
                     })
                 default:
-                    return await databaseCreateStringAttribute({
+                    return await databasesCreateStringAttribute({
+                        databaseId,
                         collectionId,
                         key: attribute.key,
                         size: attribute.size,
@@ -283,7 +312,8 @@ const createAttribute = async (collectionId, attribute) => {
 
             }
         case 'integer':
-            return await databaseCreateIntegerAttribute({
+            return await databasesCreateIntegerAttribute({
+                databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
@@ -294,7 +324,8 @@ const createAttribute = async (collectionId, attribute) => {
                 parseOutput: false
             })
         case 'double':
-            return databaseCreateFloatAttribute({
+            return databasesCreateFloatAttribute({
+                databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
@@ -305,7 +336,9 @@ const createAttribute = async (collectionId, attribute) => {
                 parseOutput: false
             })
         case 'boolean':
-            return databaseCreateBooleanAttribute({
+            return databasesCreateBooleanAttribute({
+                databaseId,
+                databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
@@ -316,15 +349,55 @@ const createAttribute = async (collectionId, attribute) => {
     }
 }
 
-const deployCollection = async () => {
+const deployCollection = async ({ all } = {}) => {
     let response = {};
-    let answers = await inquirer.prompt(questionsDeployCollections[0])
-    let collections = answers.collections
+
+    let collectionIds = [];
+    const configCollections = localConfig.getCollections();
+
+    if(all) {
+        if (configCollections.length === 0) {
+            throw new Error("No collections found in the current directory. Run `appwrite init collection` to fetch all your collections.");
+        }
+        collectionIds.push(...configCollections.map((c) => c.$id));
+    }
+
+    if(collectionIds.length <= 0) {
+        let answers = await inquirer.prompt(questionsDeployCollections[0])
+        collectionIds.push(...answers.collections);
+    }
+
+    let collections = [];
+
+    for(const collectionId of collectionIds) {
+        const idCollections = configCollections.filter((c) => c.$id === collectionId);
+        collections.push(...idCollections);
+    }
 
     for (let collection of collections) {
         log(`Deploying collection ${collection.name} ( ${collection['$id']} )`)
+
+        let databaseId;
+
+        try {
+            const database = await databasesGet({
+                databaseId: collection.databaseId,
+                parseOutput: false,
+            });
+            databaseId = database.$id;
+        } catch(err) {
+            log(`Database ${collection.databaseId} not found. Creating it now...`);
+            const database = await databasesCreate({
+                databaseId: collection.databaseId,
+                name: collection.databaseId,
+                parseOutput: false,
+            });
+            databaseId = database.$id;
+        }
+
         try {
-            response = await databaseGetCollection({
+            response = await databasesGetCollection({
+                databaseId,
                 collectionId: collection['$id'],
                 parseOutput: false,
             })
@@ -339,51 +412,55 @@ const deployCollection = async () => {
             log(`Updating attributes ... `);
 
             // TODO: Pagination?
-            const { indexes: remoteIndexes } = await databaseListIndexes({
+            const { indexes: remoteIndexes } = await databasesListIndexes({
+                databaseId,
                 collectionId: collection['$id'],
                 limit: 100,
                 parseOutput: false
             });
 
             await Promise.all(remoteIndexes.map(async index => {
-                await databaseDeleteIndex({
+                await databasesDeleteIndex({
+                    databaseId,
                     collectionId: collection['$id'],
                     key: index.key,
                     parseOutput: false
                 });
             }));
 
-            const deleteIndexesPoolStatus = await awaitPools.wipeIndexes(collection['$id']);
+            const deleteIndexesPoolStatus = await awaitPools.wipeIndexes(databaseId, collection['$id']);
             if (!deleteIndexesPoolStatus) {
                 throw new Error("Index deletion did not finish for too long.");
             }
 
             // TODO: Pagination?
-            const { attributes: remoteAttributes } = await databaseListAttributes({
+            const { attributes: remoteAttributes } = await databasesListAttributes({
+                databaseId,
                 collectionId: collection['$id'],
                 limit: 100,
                 parseOutput: false
             });
             
             await Promise.all(remoteAttributes.map(async attribute => {
-                await databaseDeleteAttribute({
+                await databasesDeleteAttribute({
+                    databaseId,
                     collectionId: collection['$id'],
                     key: attribute.key,
                     parseOutput: false
                 });
             }));
 
-            const deleteAttributesPoolStatus = await awaitPools.wipeAttributes(collection['$id']);
+            const deleteAttributesPoolStatus = await awaitPools.wipeAttributes(databaseId, collection['$id']);
             if (!deleteAttributesPoolStatus) {
                 throw new Error("Attribute deletion did not finish for too long.");
             }
 
             await Promise.all(collection.attributes.map(async attribute => {
-                await createAttribute(collection['$id'], attribute);
+                await createAttribute(databaseId, collection['$id'], attribute);
             }));
 
             const attributeKeys = collection.attributes.map(attribute => attribute.key);
-            const createPoolStatus = await awaitPools.expectAttributes(collection['$id'], attributeKeys);
+            const createPoolStatus = await awaitPools.expectAttributes(databaseId, collection['$id'], attributeKeys);
             if (!createPoolStatus) {
                 throw new Error("Attribute creation did not finish for too long.");
             }
@@ -392,7 +469,8 @@ const deployCollection = async () => {
 
             log(`Creating indexes ...`)
             await Promise.all(collection.indexes.map(async index => {
-                await databaseCreateIndex({
+                await databasesCreateIndex({
+                    databaseId,
                     collectionId: collection['$id'],
                     key: index.key,
                     type: index.type,
@@ -403,7 +481,7 @@ const deployCollection = async () => {
             }));
 
             const indexKeys = collection.indexes.map(attribute => attribute.key);
-            const indexPoolStatus = await awaitPools.expectIndexes(collection['$id'], indexKeys);
+            const indexPoolStatus = await awaitPools.expectIndexes(databaseId, collection['$id'], indexKeys);
             if (!indexPoolStatus) {
                 throw new Error("Index creation did not finish for too long.");
             }
@@ -412,7 +490,8 @@ const deployCollection = async () => {
         } catch (e) {
             if (e.code == 404) {
                 log(`Collection ${collection.name} does not exist in the project. Creating ... `);
-                response = await databaseCreateCollection({
+                response = await databasesCreateCollection({
+                    databaseId,
                     collectionId: collection['$id'],
                     name: collection.name,
                     permission: collection.permission,
@@ -423,11 +502,11 @@ const deployCollection = async () => {
 
                 log(`Creating attributes ... `);
                 await Promise.all(collection.attributes.map(async attribute => {
-                    await createAttribute(collection['$id'], attribute);
+                    await createAttribute(databaseId, collection['$id'], attribute);
                 }));
 
                 const attributeKeys = collection.attributes.map(attribute => attribute.key);
-                const attributePoolStatus = await awaitPools.expectAttributes(collection['$id'], attributeKeys);
+                const attributePoolStatus = await awaitPools.expectAttributes(databaseId, collection['$id'], attributeKeys);
                 if (!attributePoolStatus) {
                     throw new Error("Attribute creation did not finish for too long.");
                 }
@@ -436,7 +515,8 @@ const deployCollection = async () => {
 
                 log(`Creating indexes ...`);
                 await Promise.all(collection.indexes.map(async index => {
-                    await databaseCreateIndex({
+                    await databasesCreateIndex({
+                        databaseId,
                         collectionId: collection['$id'],
                         key: index.key,
                         type: index.type,
@@ -447,7 +527,7 @@ const deployCollection = async () => {
                 }));
 
                 const indexKeys = collection.indexes.map(attribute => attribute.key);
-                const indexPoolStatus = await awaitPools.expectIndexes(collection['$id'], indexKeys);
+                const indexPoolStatus = await awaitPools.expectIndexes(databaseId, collection['$id'], indexKeys);
                 if (!indexPoolStatus) {
                     throw new Error("Index creation did not finish for too long.");
                 }
@@ -465,11 +545,14 @@ const deployCollection = async () => {
 deploy
     .command("function")
     .description("Deploy functions in the current directory.")
+    .option(`--functionId <functionId>`, `Function ID`)
+    .option(`--all`, `Flag to deploy all functions`)
     .action(actionRunner(deployFunction));
 
 deploy
     .command("collection")
     .description("Deploy collections in the current project.")
+    .option(`--all`, `Flag to deploy all functions`)
     .action(actionRunner(deployCollection));
 
 module.exports = {

package/lib/commands/functions.js

@@ -1,7 +1,10 @@
 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 } = require('../utils.js');
 const { Command } = require('commander');
 const { sdkForProject, sdkForConsole } = require('../sdks')
 const { parse, actionRunner, parseInteger, parseBool, commandDescriptions, success, log } = require('../parser')
@@ -261,7 +264,7 @@ const functionsListDeployments = async ({ functionId, search, limit, offset, cur
 const functionsCreateDeployment = async ({ functionId, entrypoint, code, activate, parseOutput = true, sdk = undefined, onProgress = () => {}}) => {
     /* @param {string} functionId */
     /* @param {string} entrypoint */
-    /* @param {string} code */
+    /* @param {InputFile} code */
     /* @param {boolean} activate */
 
     let client = !sdk ? await sdkForProject() : sdk;
@@ -277,13 +280,27 @@ const functionsCreateDeployment = async ({ functionId, entrypoint, code, activat
     if (!fs.lstatSync(folderPath).isDirectory())
         throw new Error('The path is not a directory.');
     
+    const ignorer = ignore();
+
+    const func = localConfig.getFunction(functionId);
+
+    if(func.ignore) {
+        ignorer.add(func.ignore);
+        log('Ignoring files using configuration from appwrite.json');
+    } else if(fs.existsSync(pathLib.join(code, '.gitignore'))) {
+        ignorer.add(fs.readFileSync(pathLib.join(code, '.gitignore')).toString());
+        log('Ignoring files in .gitignore');
+    }
+    
+    const files = getAllFiles(code).map((file) => pathLib.relative(code, file)).filter((file) => !ignorer.ignores(file));
+
     await tar
         .create({
             gzip: true,
             sync: true,
             cwd: folderPath,
             file: 'code.tar.gz'
-        }, ['./'])
+        }, files);
     let archivePath = fs.realpathSync('code.tar.gz')
     if (typeof archivePath !== 'undefined') {
         payload['code'] = archivePath;
@@ -559,7 +576,7 @@ functions
     .option(`--limit <limit>`, `Maximum number of functions to return in response. By default will return maximum 25 results. Maximum of 100 results allowed per request.`, parseInteger)
     .option(`--offset <offset>`, `Offset value. The default value is 0. Use this value to manage pagination. [learn more about pagination](https://appwrite.io/docs/pagination)`, parseInteger)
     .option(`--cursor <cursor>`, `ID of the function used as the starting point for the query, excluding the function itself. Should be used for efficient pagination when working with large sets of data. [learn more about pagination](https://appwrite.io/docs/pagination)`)
-    .option(`--cursorDirection <cursorDirection>`, `Direction of the cursor.`)
+    .option(`--cursorDirection <cursorDirection>`, `Direction of the cursor, can be either 'before' or 'after'.`)
     .option(`--orderType <orderType>`, `Order result by ASC or DESC order.`)
     .action(actionRunner(functionsList))
 
@@ -568,10 +585,10 @@ functions
     .description(`Create a new function. You can pass a list of [permissions](/docs/permissions) to allow different project users or team with access to execute the function using the client API.`)
     .requiredOption(`--functionId <functionId>`, `Function ID. Choose your own unique ID or pass the string "unique()" to auto generate it. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.`)
     .requiredOption(`--name <name>`, `Function name. Max length: 128 chars.`)
-    .requiredOption(`--execute <execute...>`, `An array of strings with execution permissions. By default no user is granted with any execute permissions. [learn more about permissions](https://appwrite.io/docs/permissions) and get a full list of available permissions.`)
+    .requiredOption(`--execute <execute...>`, `An array of strings with execution permissions. By default no user is granted with any execute permissions. [learn more about permissions](https://appwrite.io/docs/permissions) and get a full list of available permissions. Maximum of 100 scopes are allowed, each 64 characters long.`)
     .requiredOption(`--runtime <runtime>`, `Execution runtime.`)
     .option(`--vars <vars>`, `Key-value JSON object that will be passed to the function as environment variables.`)
-    .option(`--events <events...>`, `Events list.`)
+    .option(`--events <events...>`, `Events list. Maximum of 100 events are allowed.`)
     .option(`--schedule <schedule>`, `Schedule CRON syntax.`)
     .option(`--timeout <timeout>`, `Function maximum execution time in seconds.`, parseInteger)
     .action(actionRunner(functionsCreate))
@@ -592,9 +609,9 @@ functions
     .description(`Update function by its unique ID.`)
     .requiredOption(`--functionId <functionId>`, `Function ID.`)
     .requiredOption(`--name <name>`, `Function name. Max length: 128 chars.`)
-    .requiredOption(`--execute <execute...>`, `An array of strings with execution permissions. By default no user is granted with any execute permissions. [learn more about permissions](https://appwrite.io/docs/permissions) and get a full list of available permissions.`)
+    .requiredOption(`--execute <execute...>`, `An array of strings with execution permissions. By default no user is granted with any execute permissions. [learn more about permissions](https://appwrite.io/docs/permissions) and get a full list of available permissions. Maximum of 100 scopes are allowed, each 64 characters long.`)
     .option(`--vars <vars>`, `Key-value JSON object that will be passed to the function as environment variables.`)
-    .option(`--events <events...>`, `Events list.`)
+    .option(`--events <events...>`, `Events list. Maximum of 100 events are allowed.`)
     .option(`--schedule <schedule>`, `Schedule CRON syntax.`)
     .option(`--timeout <timeout>`, `Maximum execution time in seconds.`, parseInteger)
     .action(actionRunner(functionsUpdate))
@@ -613,7 +630,7 @@ functions
     .option(`--limit <limit>`, `Maximum number of deployments to return in response. By default will return maximum 25 results. Maximum of 100 results allowed per request.`, parseInteger)
     .option(`--offset <offset>`, `Offset value. The default value is 0. Use this value to manage pagination. [learn more about pagination](https://appwrite.io/docs/pagination)`, parseInteger)
     .option(`--cursor <cursor>`, `ID of the deployment used as the starting point for the query, excluding the deployment itself. Should be used for efficient pagination when working with large sets of data. [learn more about pagination](https://appwrite.io/docs/pagination)`)
-    .option(`--cursorDirection <cursorDirection>`, `Direction of the cursor.`)
+    .option(`--cursorDirection <cursorDirection>`, `Direction of the cursor, can be either 'before' or 'after'.`)
     .option(`--orderType <orderType>`, `Order result by ASC or DESC order.`)
     .action(actionRunner(functionsListDeployments))
 
@@ -663,7 +680,7 @@ functions
     .option(`--offset <offset>`, `Offset value. The default value is 0. Use this value to manage pagination. [learn more about pagination](https://appwrite.io/docs/pagination)`, parseInteger)
     .option(`--search <search>`, `Search term to filter your list results. Max length: 256 chars.`)
     .option(`--cursor <cursor>`, `ID of the execution used as the starting point for the query, excluding the execution itself. Should be used for efficient pagination when working with large sets of data. [learn more about pagination](https://appwrite.io/docs/pagination)`)
-    .option(`--cursorDirection <cursorDirection>`, `Direction of the cursor.`)
+    .option(`--cursorDirection <cursorDirection>`, `Direction of the cursor, can be either 'before' or 'after'.`)
     .action(actionRunner(functionsListExecutions))
 
 functions

package/lib/commands/generic.js

@@ -1,10 +1,11 @@
 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, log, parse } = require("../parser");
 const { questionsLogin } = require("../questions");
-const { accountCreateSession, accountDeleteSession } = require("./account");
+const { accountCreateEmailSession, accountDeleteSession } = require("./account");
 
 const login = new Command("login")
     .description(commandDescriptions['login'])
@@ -13,7 +14,7 @@ const login = new Command("login")
 
         let client = await sdkForConsole(false);
 
-        await accountCreateSession({
+        await accountCreateEmailSession({
             email: answers.email,
             password: answers.password,
             parseOutput: false,
@@ -65,13 +66,19 @@ const client = new Command("client")
         if (endpoint !== undefined) {
             try {
                 let url = new URL(endpoint);
-                if (url.protocol === "http:" || url.protocol === "https:") {
-                    globalConfig.setEndpoint(endpoint);
-                } else {
+                if (url.protocol !== "http:" && url.protocol !== "https:") {
                     throw new Error();
                 }
+                
+                let client = new Client().setEndpoint(endpoint);
+                let response = await client.call('GET', '/health/version');
+                if(!response.version) {
+                    throw new Error();
+                }
+                
+                globalConfig.setEndpoint(endpoint);
             } catch (_) {
-                throw new Error("Invalid endpoint");
+                throw new Error("Invalid endpoint or your Appwrite server is not running as expected.");
             }
         }