appwrite-cli 10.2.1 → 10.2.3

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Change Log
 
+## 10.2.3
+
+* Fix `init tables` command not working
+* Improve tablesDB resource syncing during `push tables` command
+
+## 10.2.2
+
+* Fix `logout` command showing duplicate sessions
+* Fix `logout` command showing a blank email even when logged out
+* Add syncing of `tablesDB` resource during `push tables` command
+
 ## 10.2.1
 
 * Add transaction support for Databases and TablesDB

package/README.md

@@ -29,7 +29,7 @@ Once the installation is complete, you can verify the install using
 
 ```sh
 $ appwrite -v
-10.2.1
+10.2.3
 ```
 
 ### Install using prebuilt binaries
@@ -60,7 +60,7 @@ $ scoop install https://raw.githubusercontent.com/appwrite/sdk-for-cli/master/sc
 Once the installation completes, you can verify your install using
 ```
 $ appwrite -v
-10.2.1
+10.2.3
 ```
 
 ## Getting Started 

package/install.ps1

@@ -13,8 +13,8 @@
 # You can use "View source" of this page to see the full script.
 
 # REPO
-$GITHUB_x64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/10.2.1/appwrite-cli-win-x64.exe"
-$GITHUB_arm64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/10.2.1/appwrite-cli-win-arm64.exe"
+$GITHUB_x64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/10.2.3/appwrite-cli-win-x64.exe"
+$GITHUB_arm64_URL = "https://github.com/appwrite/sdk-for-cli/releases/download/10.2.3/appwrite-cli-win-arm64.exe"
 
 $APPWRITE_BINARY_NAME = "appwrite.exe"
 

package/install.sh

@@ -97,7 +97,7 @@ printSuccess() {
 downloadBinary() {
     echo "[2/4] Downloading executable for $OS ($ARCH) ..."
 
-    GITHUB_LATEST_VERSION="10.2.1"
+    GITHUB_LATEST_VERSION="10.2.3"
     GITHUB_FILE="appwrite-cli-${OS}-${ARCH}"
     GITHUB_URL="https://github.com/$GITHUB_REPOSITORY_NAME/releases/download/$GITHUB_LATEST_VERSION/$GITHUB_FILE"
 

package/lib/client.js

@@ -16,8 +16,8 @@ class Client {
       'x-sdk-name': 'Command Line',
       'x-sdk-platform': 'console',
       'x-sdk-language': 'cli',
-      'x-sdk-version': '10.2.1',
-      'user-agent' : `AppwriteCLI/10.2.1 (${os.type()} ${os.version()}; ${os.arch()})`,
+      'x-sdk-version': '10.2.3',
+      'user-agent' : `AppwriteCLI/10.2.3 (${os.type()} ${os.version()}; ${os.arch()})`,
       'X-Appwrite-Response-Format' : '1.8.0',
     };
   }

package/lib/commands/generic.js

@@ -171,12 +171,11 @@ const deleteSession = async (accountId) => {
             parseOutput: false,
             sdk: client
         })
-
-        globalConfig.removeSession(accountId);
     } catch (e) {
         error('Unable to log out, removing locally saved session information')
+    } finally {
+        globalConfig.removeSession(accountId);
     }
-    globalConfig.removeSession(accountId);
 }
 
 const logout = new Command("logout")
@@ -194,6 +193,7 @@ const logout = new Command("logout")
         }
         if (sessions.length === 1) {
             await deleteSession(current);
+            globalConfig.setCurrentSession('');
             success("Logging out");
 
             return;
@@ -215,6 +215,8 @@ const logout = new Command("logout")
             globalConfig.setCurrentSession(accountId);
 
             success(`Current account is ${accountId}`);
+        } else if (remainingSessions.length === 0) {
+            globalConfig.setCurrentSession('');
         }
 
         success("Logging out");

package/lib/commands/init.js

@@ -19,6 +19,7 @@ const {
     questionsCreateBucket,
     questionsCreateMessagingTopic,
     questionsCreateCollection,
+    questionsCreateTable,
     questionsInitProject,
     questionsInitProjectAutopull,
     questionsInitResources,
@@ -34,10 +35,11 @@ const initResources = async () => {
     const actions = {
         function: initFunction,
         site: initSite,
-        collection: initCollection,
+        table: initTable,
         bucket: initBucket,
         team: initTeam,
-        message: initTopic
+        message: initTopic,
+        collection: initCollection
     }
 
     const answers = await inquirer.prompt(questionsInitResources[0]);
@@ -160,6 +162,40 @@ const initTeam = async () => {
     log("Next you can use 'appwrite push team' to deploy the changes.");
 };
 
+const initTable = async () => {
+    const answers = await inquirer.prompt(questionsCreateTable)
+    const newDatabase = (answers.method ?? '').toLowerCase() !== 'existing';
+
+    if (!newDatabase) {
+        answers.databaseId = answers.database;
+        answers.databaseName = localConfig.getTablesDB(answers.database).name;
+    }
+
+    const databaseId = answers.databaseId === 'unique()' ? ID.unique() : answers.databaseId;
+
+    if (newDatabase || !localConfig.getTablesDB(answers.databaseId)) {
+        localConfig.addTablesDB({
+            $id: databaseId,
+            name: answers.databaseName,
+            enabled: true
+        });
+    }
+
+    localConfig.addTable({
+        $id: answers.id === 'unique()' ? ID.unique() : answers.id,
+        $permissions: [],
+        databaseId: databaseId,
+        name: answers.table,
+        enabled: true,
+        rowSecurity: answers.rowSecurity.toLowerCase() === 'yes',
+        columns: [],
+        indexes: [],
+    });
+
+    success("Initialing table");
+    log("Next you can use 'appwrite push table' to deploy the changes.");
+};
+
 const initCollection = async () => {
     const answers = await inquirer.prompt(questionsCreateCollection)
     const newDatabase = (answers.method ?? '').toLowerCase() !== 'existing';
@@ -557,6 +593,12 @@ init
     .description("Init a new Appwrite collection")
     .action(actionRunner(initCollection));
 
+init
+    .command("table")
+    .alias("tables")
+    .description("Init a new Appwrite table")
+    .action(actionRunner(initTable));
+
 init
     .command("topic")
     .alias("topics")

package/lib/commands/push.js

@@ -55,7 +55,10 @@ const {
     tablesDBUpdate,
     tablesDBCreateTable,
     tablesDBGetTable,
-    tablesDBUpdateTable
+    tablesDBUpdateTable,
+    tablesDBList,
+    tablesDBDelete,
+    tablesDBListTables
 } = require("./tables-db");
 const {
     storageGetBucket, storageUpdateBucket, storageCreateBucket
@@ -834,14 +837,16 @@ const attributesToCreate = async (remoteAttributes, localAttributes, collection,
 
     if (!cliConfig.force) {
         if (deleting.length > 0 && !isIndex) {
-            console.log(`${chalk.red('-------------------------------------------------------')}`);
+            console.log(`${chalk.red('------------------------------------------------------')}`);
             console.log(`${chalk.red('| WARNING: Attribute deletion may cause loss of data |')}`);
-            console.log(`${chalk.red('-------------------------------------------------------')}`);
+            console.log(`${chalk.red('------------------------------------------------------')}`);
+            console.log();
         }
         if (conflicts.length > 0 && !isIndex) {
-            console.log(`${chalk.red('---------------------------------------------------------')}`);
+            console.log(`${chalk.red('--------------------------------------------------------')}`);
             console.log(`${chalk.red('| WARNING: Attribute recreation may cause loss of data |')}`);
-            console.log(`${chalk.red('---------------------------------------------------------')}`);
+            console.log(`${chalk.red('--------------------------------------------------------')}`);
+            console.log();
         }
 
         if ((await getConfirmation()) !== true) {
@@ -1700,6 +1705,158 @@ const pushFunction = async ({ functionId, async, code, withVariables } = { retur
     }
 }
 
+const checkAndApplyTablesDBChanges = async () => {
+    log('Checking for tablesDB changes ...');
+    
+    const localTablesDBs = localConfig.getTablesDBs();
+    const { databases: remoteTablesDBs } = await paginate(tablesDBList, { parseOutput: false }, 100, 'databases');
+    
+    if (localTablesDBs.length === 0 && remoteTablesDBs.length === 0) {
+        return { applied: false, resyncNeeded: false };
+    }
+    
+    const changes = [];
+    const toCreate = [];
+    const toUpdate = [];
+    const toDelete = [];
+
+    // Check for deletions - remote DBs that aren't in local config
+    for (const remoteDB of remoteTablesDBs) {
+        const localDB = localTablesDBs.find(db => db.$id === remoteDB.$id);
+        if (!localDB) {
+            toDelete.push(remoteDB);
+            changes.push({
+                id: remoteDB.$id,
+                action: chalk.red('deleting'),
+                key: 'Database',
+                remote: remoteDB.name,
+                local: '(deleted locally)'
+            });
+        }
+    }
+
+    // Check for additions and updates
+    for (const localDB of localTablesDBs) {
+        const remoteDB = remoteTablesDBs.find(db => db.$id === localDB.$id);
+        
+        if (!remoteDB) {
+            toCreate.push(localDB);
+            changes.push({
+                id: localDB.$id,
+                action: chalk.green('creating'),
+                key: 'Database',
+                remote: '(does not exist)',
+                local: localDB.name
+            });
+        } else {
+            let hasChanges = false;
+            
+            if (remoteDB.name !== localDB.name) {
+                hasChanges = true;
+                changes.push({
+                    id: localDB.$id,
+                    action: chalk.yellow('updating'),
+                    key: 'Name',
+                    remote: remoteDB.name,
+                    local: localDB.name
+                });
+            }
+            
+            if (remoteDB.enabled !== localDB.enabled) {
+                hasChanges = true;
+                changes.push({
+                    id: localDB.$id,
+                    action: chalk.yellow('updating'),
+                    key: 'Enabled',
+                    remote: remoteDB.enabled,
+                    local: localDB.enabled
+                });
+            }
+            
+            if (hasChanges) {
+                toUpdate.push(localDB);
+            }
+        }
+    }
+
+    if (changes.length === 0) {
+        console.log('No changes found in tablesDB resource');
+        console.log();
+        return { applied: false, resyncNeeded: false };
+    }
+
+    log('Found changes in tablesDB resource:');
+    drawTable(changes);
+
+    if (toDelete.length > 0) {
+        console.log(`${chalk.red('------------------------------------------------------------------')}`);
+        console.log(`${chalk.red('| WARNING: Database deletion will also delete all related tables |')}`);
+        console.log(`${chalk.red('------------------------------------------------------------------')}`);
+        console.log();
+    }
+
+    if ((await getConfirmation()) !== true) {
+        return { applied: false, resyncNeeded: false };
+    }
+
+    // Apply deletions first
+    let needsResync = false;
+    for (const db of toDelete) {
+        try {
+            log(`Deleting database ${db.name} ( ${db.$id} ) ...`);
+            await tablesDBDelete({
+                databaseId: db.$id,
+                parseOutput: false
+            });
+            success(`Deleted ${db.name} ( ${db.$id} )`);
+            needsResync = true;
+        } catch (e) {
+            error(`Failed to delete database ${db.name} ( ${db.$id} ): ${e.message}`);
+            throw new Error(`Database sync failed during deletion of ${db.$id}. Some changes may have been applied.`);
+        }
+    }
+
+    // Apply creations
+    for (const db of toCreate) {
+        try {
+            log(`Creating database ${db.name} ( ${db.$id} ) ...`);
+            await tablesDBCreate({
+                databaseId: db.$id,
+                name: db.name,
+                enabled: db.enabled,
+                parseOutput: false
+            });
+            success(`Created ${db.name} ( ${db.$id} )`);
+        } catch (e) {
+            error(`Failed to create database ${db.name} ( ${db.$id} ): ${e.message}`);
+            throw new Error(`Database sync failed during creation of ${db.$id}. Some changes may have been applied.`);
+        }
+    }
+
+    // Apply updates
+    for (const db of toUpdate) {
+        try {
+            log(`Updating database ${db.name} ( ${db.$id} ) ...`);
+            await tablesDBUpdate({
+                databaseId: db.$id,
+                name: db.name,
+                enabled: db.enabled,
+                parseOutput: false
+            });
+            success(`Updated ${db.name} ( ${db.$id} )`);
+        } catch (e) {
+            error(`Failed to update database ${db.name} ( ${db.$id} ): ${e.message}`);
+            throw new Error(`Database sync failed during update of ${db.$id}. Some changes may have been applied.`);
+        }
+    }
+
+    if (toDelete.length === 0){
+        console.log();
+    }
+
+    return { applied: true, resyncNeeded: needsResync };
+};
+
 const pushTable = async ({ returnOnZero, attempts } = { returnOnZero: false }) => {
     const tables = [];
 
@@ -1707,6 +1864,26 @@ const pushTable = async ({ returnOnZero, attempts } = { returnOnZero: false }) =
         pollMaxDebounces = attempts;
     }
 
+    const { applied: tablesDBApplied, resyncNeeded } = await checkAndApplyTablesDBChanges();
+    if (resyncNeeded) {
+        log('Resyncing configuration due to tablesDB deletions ...');
+
+        const remoteTablesDBs = (await paginate(tablesDBList, { parseOutput: false }, 100, 'databases')).databases;
+        const localTablesDBs = localConfig.getTablesDBs();
+
+        const remoteDatabaseIds = new Set(remoteTablesDBs.map(db => db.$id));
+        const localTables = localConfig.getTables();
+        const validTables = localTables.filter(table => remoteDatabaseIds.has(table.databaseId));
+
+        localConfig.set('tables', validTables);
+
+        const validTablesDBs = localTablesDBs.filter(db => remoteDatabaseIds.has(db.$id));
+        localConfig.set('tablesDB', validTablesDBs);
+
+        success('Configuration resynced successfully.');
+        console.log();
+    }
+
     if (cliConfig.all) {
         checkDeployConditions(localConfig);
         tables.push(...localConfig.getTables());
@@ -1730,39 +1907,6 @@ const pushTable = async ({ returnOnZero, attempts } = { returnOnZero: false }) =
         return;
     }
 
-    const databases = Array.from(new Set(tables.map(table => table['databaseId'])));
-
-    // Parallel tablesDB actions
-    await Promise.all(databases.map(async (databaseId) => {
-        const localDatabase = localConfig.getTablesDB(databaseId);
-
-        try {
-            const database = await tablesDBGet({
-                databaseId: databaseId,
-                parseOutput: false,
-            });
-
-            if (database.name !== (localDatabase.name ?? databaseId)) {
-                await tablesDBUpdate({
-                    databaseId: databaseId,
-                    name: localDatabase.name ?? databaseId,
-                    parseOutput: false
-                })
-
-                success(`Updated ${localDatabase.name} ( ${databaseId} ) name`);
-            }
-        } catch (err) {
-            log(`Database ${databaseId} not found. Creating it now ...`);
-
-            await tablesDBCreate({
-                databaseId: databaseId,
-                name: localDatabase.name ?? databaseId,
-                parseOutput: false,
-            });
-        }
-    }));
-
-
     if (!(await approveChanges(tables, tablesDBGetTable, KeysTable, 'tableId', 'tables', ['columns', 'indexes'], 'databaseId', 'databaseId'))) {
         return;
     }

package/lib/config.js

@@ -681,15 +681,25 @@ class Global extends Config {
 
     getSessions() {
         const sessions = Object.keys(this.data).filter((key) => !Global.IGNORE_ATTRIBUTES.includes(key))
+        const current = this.getCurrentSession();
 
-        return sessions.map((session) => {
-
-            return {
-                id: session,
-                endpoint: this.data[session][Global.PREFERENCE_ENDPOINT],
-                email: this.data[session][Global.PREFERENCE_EMAIL]
+        const sessionMap = new Map();
+        
+        sessions.forEach((sessionId) => {
+            const email = this.data[sessionId][Global.PREFERENCE_EMAIL];
+            const endpoint = this.data[sessionId][Global.PREFERENCE_ENDPOINT];
+            const key = `${email}|${endpoint}`;
+
+            if (sessionId === current || !sessionMap.has(key)) {
+                sessionMap.set(key, {
+                    id: sessionId,
+                    endpoint: this.data[sessionId][Global.PREFERENCE_ENDPOINT],
+                    email: this.data[sessionId][Global.PREFERENCE_EMAIL]
+                });
             }
-        })
+        });
+
+        return Array.from(sessionMap.values());
     }
 
     addSession(session, data) {

package/lib/parser.js

@@ -122,7 +122,7 @@ const parseError = (err) => {
             } catch {
             }
 
-            const version = '10.2.1';
+            const version = '10.2.3';
             const stepsToReproduce = `Running \`appwrite ${cliConfig.reportData.data.args.join(' ')}\``;
             const yourEnvironment = `CLI version: ${version}\nOperation System: ${os.type()}\nAppwrite version: ${appwriteVersion}\nIs Cloud: ${isCloud()}`;
 

package/lib/questions.js

@@ -496,7 +496,73 @@ const questionsCreateCollection = [
     {
         type: "list",
         name: "documentSecurity",
-        message: "Enable Document-Security for configuring permissions for individual documents",
+        message: "Enable document security for configuring permissions for individual documents",
+        choices: ["No", "Yes"]
+    }
+];
+
+const questionsCreateTable = [
+    {
+        type: "list",
+        name: "method",
+        message: "What database would you like to use for your table?",
+        choices: ["New", "Existing"],
+        when: async () => {
+            return localConfig.getTablesDBs().length !== 0;
+        }
+    },
+    {
+        type: "search-list",
+        name: "database",
+        message: "Choose the table database",
+        choices: async () => {
+            const databases = localConfig.getTablesDBs();
+
+            let choices = databases.map((database, idx) => {
+                return {
+                    name: `${database.name} (${database.$id})`,
+                    value: database.$id
+                }
+            })
+
+            if (choices.length === 0) {
+                throw new Error("No databases found. Please create one in project console.")
+            }
+
+            return choices;
+        },
+        when: (answers) => (answers.method ?? '').toLowerCase() === 'existing'
+    },
+    {
+        type: "input",
+        name: "databaseName",
+        message: "What would you like to name your database?",
+        default: "My Awesome Database",
+        when: (answers) => (answers.method ?? '').toLowerCase() !== 'existing'
+    },
+    {
+        type: "input",
+        name: "databaseId",
+        message: "What ID would you like to have for your database?",
+        default: "unique()",
+        when: (answers) => (answers.method ?? '').toLowerCase() !== 'existing'
+    },
+    {
+        type: "input",
+        name: "table",
+        message: "What would you like to name your table?",
+        default: "My Awesome Table"
+    },
+    {
+        type: "input",
+        name: "id",
+        message: "What ID would you like to have for your table?",
+        default: "unique()"
+    },
+    {
+        type: "list",
+        name: "rowSecurity",
+        message: "Enable row security for configuring permissions for individual rows",
         choices: ["No", "Yes"]
     }
 ];
@@ -1001,6 +1067,7 @@ module.exports = {
     questionsCreateFunctionSelectTemplate,
     questionsCreateBucket,
     questionsCreateCollection,
+    questionsCreateTable,
     questionsCreateMessagingTopic,
     questionsPullFunctions,
     questionsPullFunctionsCode,

package/package.json

@@ -2,7 +2,7 @@
   "name": "appwrite-cli",
   "homepage": "https://appwrite.io/support",
   "description": "Appwrite is an open-source self-hosted backend server that abstract and simplify complex and repetitive development tasks behind a very simple REST API",
-  "version": "10.2.1",
+  "version": "10.2.3",
   "license": "BSD-3-Clause",
   "main": "index.js",
   "bin": {

package/scoop/appwrite.config.json

@@ -1,12 +1,12 @@
 {
 	"$schema": "https://raw.githubusercontent.com/ScoopInstaller/Scoop/master/schema.json",
-	"version": "10.2.1",
+	"version": "10.2.3",
 	"description": "The Appwrite CLI is a command-line application that allows you to interact with Appwrite and perform server-side tasks using your terminal.",
 	"homepage": "https://github.com/appwrite/sdk-for-cli",
 	"license": "BSD-3-Clause",
 	"architecture": {
 		"64bit": {
-			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/10.2.1/appwrite-cli-win-x64.exe",
+			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/10.2.3/appwrite-cli-win-x64.exe",
 			"bin": [
 				[
 					"appwrite-cli-win-x64.exe",
@@ -15,7 +15,7 @@
 			]
 		},
 		"arm64": {
-			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/10.2.1/appwrite-cli-win-arm64.exe",
+			"url": "https://github.com/appwrite/sdk-for-cli/releases/download/10.2.3/appwrite-cli-win-arm64.exe",
 			"bin": [
 				[
 					"appwrite-cli-win-arm64.exe",