appwrite-cli 0.17.1 → 0.18.3

package/lib/commands/deploy.js

@@ -6,34 +6,37 @@ const { questionsDeployFunctions, questionsGetEntrypoint, questionsDeployCollect
 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
@@ -44,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
@@ -63,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
@@ -94,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
@@ -125,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.map((func) => JSONbig.parse(func))
+    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']} )`)
 
@@ -230,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,
@@ -244,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,
@@ -253,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,
@@ -262,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,
@@ -272,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,
@@ -284,7 +312,8 @@ const createAttribute = async (collectionId, attribute) => {
 
             }
         case 'integer':
-            return await databaseCreateIntegerAttribute({
+            return await databasesCreateIntegerAttribute({
+                databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
@@ -295,7 +324,8 @@ const createAttribute = async (collectionId, attribute) => {
                 parseOutput: false
             })
         case 'double':
-            return databaseCreateFloatAttribute({
+            return databasesCreateFloatAttribute({
+                databaseId,
                 collectionId,
                 key: attribute.key,
                 required: attribute.required,
@@ -306,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,
@@ -317,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.map((collection) => JSONbig.parse(collection));
+
+    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,
             })
@@ -340,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.");
             }
@@ -393,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,
@@ -404,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.");
             }
@@ -413,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,
@@ -424,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.");
                 }
@@ -437,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,
@@ -448,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.");
                 }
@@ -466,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

@@ -264,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;
@@ -576,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))
 
@@ -630,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))
 
@@ -680,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

@@ -5,7 +5,7 @@ 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'])
@@ -14,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,

package/lib/commands/init.js

@@ -6,22 +6,16 @@ const inquirer = require("inquirer");
 const { teamsCreate } = require("./teams");
 const { projectsCreate } = require("./projects");
 const { functionsCreate } = require("./functions");
-const { databaseListCollections } = require("./database");
+const { databasesListCollections, databasesList } = require("./databases");
 const { sdkForConsole } = require("../sdks");
 const { localConfig } = require("../config");
-const { questionsInitProject, questionsInitFunction } = require("../questions");
+const { questionsInitProject, questionsInitFunction, questionsInitCollection } = require("../questions");
 const { success, log, actionRunner, commandDescriptions } = require("../parser");
 
 const init = new Command("init")
   .description(commandDescriptions['init'])
-  .option("--all", "Flag to initialize projects and collection")
-  .action(actionRunner(async ({ all }, command) => {
-    if (all == undefined) {
-      command.help()
-    }
-
-    await initProject();
-    await initCollection()
+  .action(actionRunner(async (_options, command) => {
+    command.help();
   }));
 
 const initProject = async () => {
@@ -40,7 +34,7 @@ const initProject = async () => {
 
     let teamId = response['$id'];
     response = await projectsCreate({
-      projectId: 'unique()',
+      projectId: answers.id,
       name: answers.project,
       teamId,
       parseOutput: false
@@ -54,6 +48,7 @@ const initProject = async () => {
 }
 
 const initFunction = async () => {
+  // TODO: Add CI/CD support (ID, name, runtime)
   let answers = await inquirer.prompt(questionsInitFunction)
 
   if (fs.existsSync(path.join(process.cwd(), 'functions', answers.name))) {
@@ -65,7 +60,7 @@ const initFunction = async () => {
   }
 
   let response = await functionsCreate({
-    functionId: 'unique()',
+    functionId: answers.id,
     name: answers.name,
     runtime: answers.runtime.id,
     parseOutput: false
@@ -110,20 +105,41 @@ const initFunction = async () => {
   success();
 }
 
-const initCollection = async () => {
-  // TODO: Pagination?
-  let response = await databaseListCollections({
-    limit: 100,
-    parseOutput: false
-  })
+const initCollection = async ({ all, databaseId } = {}) => {
+  const databaseIds = [];
+
+  if(databaseId) {
+    databaseIds.push(databaseId);
+  } else if(all) {
+      let allDatabases = await databasesList({
+        parseOutput: false
+      })
 
-  let collections = response.collections;
-  log(`Found ${collections.length} collections`);
+      databaseIds.push(...allDatabases.databases.map((d) => d.$id));
+  }
+
+  if(databaseIds.length <= 0) {
+      let answers = await inquirer.prompt(questionsInitCollection)
+      if (!answers.databases) process.exit(1)
+      databaseIds.push(...answers.databases);
+  }
 
-  collections.forEach(async collection => {
-    log(`Fetching ${collection.name} ...`);
-    localConfig.addCollection(collection);
-  });
+  for(const databaseId of databaseIds) {
+    // TODO: Pagination?
+    let response = await databasesListCollections({
+      databaseId,
+      limit: 100,
+      parseOutput: false
+    })
+
+    let collections = response.collections;
+    log(`Found ${collections.length} collections`);
+
+    collections.forEach(async collection => {
+      log(`Fetching ${collection.name} ...`);
+      localConfig.addCollection(collection);
+    });
+  }
 
   success();
 }
@@ -141,6 +157,8 @@ init
 init
   .command("collection")
   .description("Initialise your Appwrite collections")
+  .option(`--databaseId <databaseId>`, `Database ID`)
+  .option(`--all`, `Flag to initialize all databases`)
   .action(actionRunner(initCollection))
 
 module.exports = {