appwrite-cli 13.2.0 → 13.3.0

package/lib/commands/generic.ts

@@ -28,13 +28,131 @@ import ClientLegacy from "../client.js";
 
 const DEFAULT_ENDPOINT = "https://cloud.appwrite.io/v1";
 
-interface LoginCommandOptions {
-  email?: string;
-  password?: string;
-  endpoint?: string;
+const isMfaRequiredError = (err: any): boolean =>
+  err?.type === "user_more_factors_required" ||
+  err?.response === "user_more_factors_required";
+
+const createLegacyConsoleClient = (endpoint: string): ClientLegacy => {
+  const legacyClient = new ClientLegacy();
+  legacyClient.setEndpoint(endpoint);
+  legacyClient.setProject("console");
+  if (globalConfig.getSelfSigned()) {
+    legacyClient.setSelfSigned(true);
+  }
+  return legacyClient;
+};
+
+const completeMfaLogin = async ({
+  client,
+  legacyClient,
+  mfa,
+  code,
+}: {
+  client: ConsoleClient;
+  legacyClient: ClientLegacy;
   mfa?: string;
   code?: string;
-}
+}): Promise<any> => {
+  let accountClient = new Account(client);
+
+  const savedCookie = globalConfig.getCookie();
+  if (savedCookie) {
+    legacyClient.setCookie(savedCookie);
+    client.setCookie(savedCookie);
+  }
+
+  const { factor } = mfa
+    ? { factor: mfa }
+    : await inquirer.prompt(questionsListFactors);
+  const challenge = await accountClient.createMfaChallenge(factor);
+
+  const { otp } = code
+    ? { otp: code }
+    : await inquirer.prompt(questionsMFAChallenge);
+  await legacyClient.call(
+    "PUT",
+    "/account/mfa/challenges",
+    {
+      "content-type": "application/json",
+    },
+    {
+      challengeId: challenge.$id,
+      otp,
+    },
+  );
+
+  const updatedCookie = globalConfig.getCookie();
+  if (updatedCookie) {
+    client.setCookie(updatedCookie);
+  }
+
+  accountClient = new Account(client);
+  return accountClient.get();
+};
+
+const deleteServerSession = async (sessionId: string): Promise<boolean> => {
+  try {
+    let client = await sdkForConsole();
+    let accountClient = new Account(client);
+    await accountClient.deleteSession(sessionId);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+const deleteLocalSession = (accountId: string): void => {
+  globalConfig.removeSession(accountId);
+};
+
+const getSessionAccountKey = (sessionId: string): string | undefined => {
+  const session = globalConfig.get(sessionId) as
+    | { email?: string; endpoint?: string }
+    | undefined;
+  if (!session) return undefined;
+  return `${session.email ?? ""}|${session.endpoint ?? ""}`;
+};
+
+/**
+ * Given selected session IDs, determine which sessions should be logged out
+ * from the server (one per unique account) and which should be removed locally (all sessions for those accounts).
+ *
+ * @param selectedSessionIds Array of session IDs to process for logout.
+ * @returns Object containing `serverTargets` (sessions to logout from server)
+ *          and `localTargets` (sessions to remove locally).
+ */
+const planSessionLogout = (
+  selectedSessionIds: string[],
+): { serverTargets: string[]; localTargets: string[] } => {
+  // Map to group all session IDs by their unique account key (email+endpoint)
+  const sessionIdsByAccount = new Map<string, string[]>();
+  for (const sessionId of globalConfig.getSessionIds()) {
+    const key = getSessionAccountKey(sessionId);
+    if (!key) continue; // Skip sessions without proper account key
+
+    // For each account key, gather all associated session IDs
+    const ids = sessionIdsByAccount.get(key) ?? [];
+    ids.push(sessionId);
+    sessionIdsByAccount.set(key, ids);
+  }
+
+  // Map to store one selected session ID per unique account for server logout
+  const selectedByAccount = new Map<string, string>();
+  for (const selectedSessionId of selectedSessionIds) {
+    const key = getSessionAccountKey(selectedSessionId);
+    if (!key || selectedByAccount.has(key)) continue; // Skip if key missing or already considered for this account
+    selectedByAccount.set(key, selectedSessionId);
+  }
+
+  // Sessions to target for server logout: one per unique account
+  const serverTargets = Array.from(selectedByAccount.values());
+  // Sessions to remove locally: all sessions under selected accounts
+  const localTargets = Array.from(selectedByAccount.keys()).flatMap(
+    (accountKey) => sessionIdsByAccount.get(accountKey) ?? [],
+  );
+
+  return { serverTargets, localTargets };
+};
 
 export const loginCommand = async ({
   email,
@@ -42,7 +160,13 @@ export const loginCommand = async ({
   endpoint,
   mfa,
   code,
-}: LoginCommandOptions): Promise<void> => {
+}: {
+  email?: string;
+  password?: string;
+  endpoint?: string;
+  mfa?: string;
+  code?: string;
+}): Promise<void> => {
   const oldCurrent = globalConfig.getCurrentSession();
 
   const configEndpoint =
@@ -73,7 +197,29 @@ export const loginCommand = async ({
     }
 
     globalConfig.setCurrentSession(accountId);
-    success(`Current account is ${accountId}`);
+
+    const client = await sdkForConsole(false);
+    const accountClient = new Account(client);
+    const legacyClient = createLegacyConsoleClient(
+      globalConfig.getEndpoint() || DEFAULT_ENDPOINT,
+    );
+
+    try {
+      await accountClient.get();
+    } catch (err: any) {
+      if (!isMfaRequiredError(err)) {
+        throw err;
+      }
+
+      await completeMfaLogin({
+        client,
+        legacyClient,
+        mfa,
+        code,
+      });
+    }
+
+    success(`Switched to ${globalConfig.getEmail()}`);
 
     return;
   }
@@ -86,12 +232,7 @@ export const loginCommand = async ({
   globalConfig.setEmail(answers.email);
 
   // Use legacy client for login to extract cookies from response
-  const legacyClient = new ClientLegacy();
-  legacyClient.setEndpoint(configEndpoint);
-  legacyClient.setProject("console");
-  if (globalConfig.getSelfSigned()) {
-    legacyClient.setSelfSigned(true);
-  }
+  const legacyClient = createLegacyConsoleClient(configEndpoint);
 
   let client = await sdkForConsole(false);
   let accountClient = new Account(client);
@@ -121,37 +262,13 @@ export const loginCommand = async ({
     accountClient = new Account(client);
     account = await accountClient.get();
   } catch (err: any) {
-    if (
-      err.type === "user_more_factors_required" ||
-      err.response === "user_more_factors_required"
-    ) {
-      const { factor } = mfa
-        ? { factor: mfa }
-        : await inquirer.prompt(questionsListFactors);
-      const challenge = await accountClient.createMfaChallenge(factor);
-
-      const { otp } = code
-        ? { otp: code }
-        : await inquirer.prompt(questionsMFAChallenge);
-      await legacyClient.call(
-        "PUT",
-        "/account/mfa/challenges",
-        {
-          "content-type": "application/json",
-        },
-        {
-          challengeId: challenge.$id,
-          otp: otp,
-        },
-      );
-
-      const savedCookie = globalConfig.getCookie();
-      if (savedCookie) {
-        client.setCookie(savedCookie);
-      }
-
-      accountClient = new Account(client);
-      account = await accountClient.get();
+    if (isMfaRequiredError(err)) {
+      account = await completeMfaLogin({
+        client,
+        legacyClient,
+        mfa,
+        code,
+      });
     } else {
       globalConfig.removeSession(id);
       globalConfig.setCurrentSession(oldCurrent);
@@ -241,19 +358,6 @@ export const login = new Command("login")
   })
   .action(actionRunner(loginCommand));
 
-const deleteSession = async (accountId: string): Promise<void> => {
-  try {
-    let client = await sdkForConsole();
-    let accountClient = new Account(client);
-
-    await accountClient.deleteSession("current");
-  } catch (e) {
-    error("Unable to log out, removing locally saved session information");
-  } finally {
-    globalConfig.removeSession(accountId);
-  }
-};
-
 export const logout = new Command("logout")
   .description(commandDescriptions["logout"])
   .configureHelp({
@@ -263,44 +367,69 @@ export const logout = new Command("logout")
     actionRunner(async () => {
       const sessions = globalConfig.getSessions();
       const current = globalConfig.getCurrentSession();
+      const originalCurrent = current;
 
       if (current === "" || !sessions.length) {
         log("No active sessions found.");
         return;
       }
       if (sessions.length === 1) {
-        await deleteSession(current);
+        // Try to delete from server, then remove locally
+        const serverDeleted = await deleteServerSession(current);
+        // Remove all local sessions with the same email+endpoint
+        const allSessionIds = globalConfig.getSessionIds();
+        for (const sessId of allSessionIds) {
+          deleteLocalSession(sessId);
+        }
         globalConfig.setCurrentSession("");
-        success("Logging out");
+        if (!serverDeleted) {
+          hint("Could not reach server, removed local session data");
+        }
+        success("Logged out successfully");
 
         return;
       }
 
       const answers = await inquirer.prompt(questionsLogout);
 
-      if (answers.accounts) {
-        for (let accountId of answers.accounts) {
-          globalConfig.setCurrentSession(accountId);
-          await deleteSession(accountId);
+      if (answers.accounts?.length) {
+        const { serverTargets, localTargets } = planSessionLogout(
+          answers.accounts as string[],
+        );
+
+        for (const sessionId of serverTargets) {
+          globalConfig.setCurrentSession(sessionId);
+          await deleteServerSession(sessionId);
+        }
+
+        for (const sessionId of localTargets) {
+          deleteLocalSession(sessionId);
         }
       }
 
       const remainingSessions = globalConfig.getSessions();
+      const hasCurrent = remainingSessions.some(
+        (session) => session.id === originalCurrent,
+      );
 
-      if (
-        remainingSessions.length > 0 &&
-        remainingSessions.filter((session: any) => session.id === current)
-          .length !== 1
-      ) {
-        const accountId = remainingSessions[0].id;
-        globalConfig.setCurrentSession(accountId);
-
-        success(`Current account is ${accountId}`);
+      if (remainingSessions.length > 0 && hasCurrent) {
+        globalConfig.setCurrentSession(originalCurrent);
+      } else if (remainingSessions.length > 0) {
+        const nextSession =
+          remainingSessions.find((session) => session.email) ??
+          remainingSessions[0];
+        globalConfig.setCurrentSession(nextSession.id);
+
+        success(
+          nextSession.email
+            ? `Switched to ${nextSession.email}`
+            : `Switched to session at ${nextSession.endpoint}`,
+        );
       } else if (remainingSessions.length === 0) {
         globalConfig.setCurrentSession("");
       }
 
-      success("Logging out");
+      success("Logged out successfully");
     }),
   );
 
@@ -438,10 +567,16 @@ export const client = new Command("client")
         if (reset !== undefined) {
           const sessions = globalConfig.getSessions();
 
-          for (let accountId of sessions.map((session: any) => session.id)) {
-            globalConfig.setCurrentSession(accountId);
-            await deleteSession(accountId);
+          for (const sessionId of sessions.map((session) => session.id)) {
+            globalConfig.setCurrentSession(sessionId);
+            await deleteServerSession(sessionId);
           }
+
+          for (const sessionId of globalConfig.getSessionIds()) {
+            deleteLocalSession(sessionId);
+          }
+
+          globalConfig.setCurrentSession("");
         }
 
         if (!debug) {

package/lib/commands/push.ts

@@ -1100,7 +1100,8 @@ export class Push {
                 this.consoleClient,
               );
               const variables = await consoleService.variables();
-              domain = ID.unique() + "." + variables["_APP_DOMAIN_SITES"];
+              const domains = variables["_APP_DOMAIN_SITES"].split(",");
+              domain = ID.unique() + "." + domains[0].trim();
             } catch (err) {
               this.error("Error fetching console variables.");
               throw err;
@@ -2323,7 +2324,7 @@ const pushCollection = async (): Promise<void> => {
   const { successfullyPushed, errors } = result;
 
   if (successfullyPushed === 0) {
-    error("No collections were pushed.");
+    warn("No collections were pushed.");
   } else {
     success(`Successfully pushed ${successfullyPushed} collections.`);
   }

package/lib/commands/utils/attributes.ts

@@ -250,6 +250,43 @@ export class Attributes {
               encrypt: attribute.encrypt,
             });
         }
+      case "varchar":
+        return databasesService.createVarcharAttribute({
+          databaseId,
+          collectionId,
+          key: attribute.key,
+          size: attribute.size,
+          required: attribute.required,
+          xdefault: attribute.default,
+          array: attribute.array,
+        });
+      case "text":
+        return databasesService.createTextAttribute({
+          databaseId,
+          collectionId,
+          key: attribute.key,
+          required: attribute.required,
+          xdefault: attribute.default,
+          array: attribute.array,
+        });
+      case "mediumtext":
+        return databasesService.createMediumtextAttribute({
+          databaseId,
+          collectionId,
+          key: attribute.key,
+          required: attribute.required,
+          xdefault: attribute.default,
+          array: attribute.array,
+        });
+      case "longtext":
+        return databasesService.createLongtextAttribute({
+          databaseId,
+          collectionId,
+          key: attribute.key,
+          required: attribute.required,
+          xdefault: attribute.default,
+          array: attribute.array,
+        });
       case "integer":
         return databasesService.createIntegerAttribute({
           databaseId,
@@ -382,6 +419,39 @@ export class Attributes {
               xdefault: attribute.default,
             });
         }
+      case "varchar":
+        return databasesService.updateVarcharAttribute({
+          databaseId,
+          collectionId,
+          key: attribute.key,
+          required: attribute.required,
+          xdefault: attribute.default,
+          size: attribute.size,
+        });
+      case "text":
+        return databasesService.updateTextAttribute({
+          databaseId,
+          collectionId,
+          key: attribute.key,
+          required: attribute.required,
+          xdefault: attribute.default,
+        });
+      case "mediumtext":
+        return databasesService.updateMediumtextAttribute({
+          databaseId,
+          collectionId,
+          key: attribute.key,
+          required: attribute.required,
+          xdefault: attribute.default,
+        });
+      case "longtext":
+        return databasesService.updateLongtextAttribute({
+          databaseId,
+          collectionId,
+          key: attribute.key,
+          required: attribute.required,
+          xdefault: attribute.default,
+        });
       case "integer":
         return databasesService.updateIntegerAttribute({
           databaseId,

package/lib/config.ts

@@ -749,15 +749,15 @@ class Global extends Config<GlobalConfigData> {
 
     sessions.forEach((sessionId) => {
       const sessionData = (this.data as any)[sessionId];
-      const email = sessionData[Global.PREFERENCE_EMAIL];
-      const endpoint = sessionData[Global.PREFERENCE_ENDPOINT];
+      const email = sessionData[Global.PREFERENCE_EMAIL] ?? "";
+      const endpoint = sessionData[Global.PREFERENCE_ENDPOINT] ?? "";
       const key = `${email}|${endpoint}`;
 
       if (sessionId === current || !sessionMap.has(key)) {
         sessionMap.set(key, {
           id: sessionId,
-          endpoint: sessionData[Global.PREFERENCE_ENDPOINT],
-          email: sessionData[Global.PREFERENCE_EMAIL],
+          endpoint,
+          email,
         });
       }
     });

package/lib/constants.ts

@@ -1,7 +1,7 @@
 // SDK
 export const SDK_TITLE = 'Appwrite';
 export const SDK_TITLE_LOWER = 'appwrite';
-export const SDK_VERSION = '13.2.0';
+export const SDK_VERSION = '13.3.0';
 export const SDK_NAME = 'Command Line';
 export const SDK_PLATFORM = 'console';
 export const SDK_LANGUAGE = 'cli';

package/lib/questions.ts

@@ -28,6 +28,7 @@ interface Choice {
   value: any;
   disabled?: boolean | string;
   current?: boolean;
+  short?: string;
 }
 
 interface Question {
@@ -752,7 +753,7 @@ export const questionsLogin: Question[] = [
     when: (answers: Answers) => answers.method !== "select",
   },
   {
-    type: "search-list",
+    type: "list",
     name: "accountId",
     message: "Select an account to use",
     choices() {
@@ -772,6 +773,7 @@ export const questionsLogin: Question[] = [
           data.push({
             current: current === session.id,
             value: session.id,
+            short: `${session.email} (${session.endpoint})`,
             name: `${session.email.padEnd(longestEmail)} ${current === session.id ? chalk.green.bold("current") : " ".repeat(6)} ${session.endpoint}`,
           });
         }

package/lib/shared/typescript-type-utils.ts

@@ -37,6 +37,10 @@ export function getTypeScriptType(
 
   switch (attribute.type) {
     case "string":
+    case "text":
+    case "varchar":
+    case "mediumtext":
+    case "longtext":
     case "datetime":
       type = "string";
       if (attribute.format === "enum") {

package/lib/type-generation/attribute.ts

@@ -1,5 +1,9 @@
 export const AttributeType = {
   STRING: "string",
+  TEXT: "text",
+  VARCHAR: "varchar",
+  MEDIUMTEXT: "mediumtext",
+  LONGTEXT: "longtext",
   INTEGER: "integer",
   FLOAT: "double",
   BOOLEAN: "boolean",

package/lib/type-generation/languages/csharp.ts

@@ -10,6 +10,10 @@ export class CSharp extends LanguageMeta {
     let type = "";
     switch (attribute.type) {
       case AttributeType.STRING:
+      case AttributeType.TEXT:
+      case AttributeType.VARCHAR:
+      case AttributeType.MEDIUMTEXT:
+      case AttributeType.LONGTEXT:
       case AttributeType.DATETIME:
         type = "string";
         if (attribute.format === AttributeType.ENUM) {
@@ -126,7 +130,7 @@ public class <%= toPascalCase(collection.name) %>
                 }
             // ARRAY TYPES
             } else if (attribute.array) {
-                if (attribute.type === 'string' || attribute.type === 'datetime' || attribute.type === 'email') {
+                if (['string', 'text', 'varchar', 'mediumtext', 'longtext', 'datetime', 'email'].includes(attribute.type)) {
                     -%>((IEnumerable<object>)map["<%- attribute.key %>"]).Select(x => x?.ToString())<%- attribute.required ? '.Where(x => x != null)' : '' %>.ToList()!<%
                 } else if (attribute.type === 'integer') {
                     -%>((IEnumerable<object>)map["<%- attribute.key %>"]).Select(x => <%- !attribute.required ? 'x == null ? (long?)null : ' : '' %>Convert.ToInt64(x)).ToList()<%
@@ -142,7 +146,7 @@ public class <%= toPascalCase(collection.name) %>
                 -%><%- !attribute.required ? 'map["' + attribute.key + '"] == null ? null : ' : '' %>Convert.ToDouble(map["<%- attribute.key %>"])<%
             } else if (attribute.type === 'boolean') {
                 -%>(<%- getType(attribute, collections, collection.name) %>)map["<%- attribute.key %>"]<%
-            } else if (attribute.type === 'string' || attribute.type === 'datetime' || attribute.type === 'email') {
+            } else if (['string', 'text', 'varchar', 'mediumtext', 'longtext', 'datetime', 'email'].includes(attribute.type)) {
                 -%>map["<%- attribute.key %>"]<%- !attribute.required ? '?' : '' %>.ToString()<%- attribute.required ? '!' : ''%><%
             } else {
                 -%>default<%

package/lib/type-generation/languages/dart.ts

@@ -72,6 +72,10 @@ export class Dart extends LanguageMeta {
     let type = "";
     switch (attribute.type) {
       case AttributeType.STRING:
+      case AttributeType.TEXT:
+      case AttributeType.VARCHAR:
+      case AttributeType.MEDIUMTEXT:
+      case AttributeType.LONGTEXT:
       case AttributeType.DATETIME:
         type = "String";
         if (attribute.format === AttributeType.ENUM) {
@@ -193,7 +197,7 @@ class <%= toPascalCase(collection.name) %> {
   factory <%= toPascalCase(collection.name) %>.fromMap(Map<String, dynamic> map) {
     return <%= toPascalCase(collection.name) %>(<% if (__attrs.length > 0) { %>
 <% for (const [index, attribute] of Object.entries(__attrs)) { -%>
-      <%= strict ? toCamelCase(attribute.key) : attribute.key %>: <% if (attribute.type === '${AttributeType.STRING}' || attribute.type === '${AttributeType.EMAIL}' || attribute.type === '${AttributeType.DATETIME}') { -%>
+      <%= strict ? toCamelCase(attribute.key) : attribute.key %>: <% if (['${AttributeType.STRING}', '${AttributeType.TEXT}', '${AttributeType.VARCHAR}', '${AttributeType.MEDIUMTEXT}', '${AttributeType.LONGTEXT}', '${AttributeType.EMAIL}', '${AttributeType.DATETIME}'].includes(attribute.type)) { -%>
 <% if (attribute.format === '${AttributeType.ENUM}') { -%>
 <% if (attribute.array) { -%>
 (map['<%= attribute.key %>'] as List<dynamic>?)?.map((e) => <%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %>.values.firstWhere((element) => element.value == e)).toList()<% } else { -%>

package/lib/type-generation/languages/java.ts

@@ -10,6 +10,10 @@ export class Java extends LanguageMeta {
     let type = "";
     switch (attribute.type) {
       case AttributeType.STRING:
+      case AttributeType.TEXT:
+      case AttributeType.VARCHAR:
+      case AttributeType.MEDIUMTEXT:
+      case AttributeType.LONGTEXT:
       case AttributeType.DATETIME:
         type = "String";
         if (attribute.format === AttributeType.ENUM) {

package/lib/type-generation/languages/javascript.ts

@@ -8,6 +8,10 @@ export class JavaScript extends LanguageMeta {
     let type = "";
     switch (attribute.type) {
       case AttributeType.STRING:
+      case AttributeType.TEXT:
+      case AttributeType.VARCHAR:
+      case AttributeType.MEDIUMTEXT:
+      case AttributeType.LONGTEXT:
       case AttributeType.DATETIME:
         type = "string";
         if (attribute.format === AttributeType.ENUM) {

package/lib/type-generation/languages/kotlin.ts

@@ -10,6 +10,10 @@ export class Kotlin extends LanguageMeta {
     let type = "";
     switch (attribute.type) {
       case AttributeType.STRING:
+      case AttributeType.TEXT:
+      case AttributeType.VARCHAR:
+      case AttributeType.MEDIUMTEXT:
+      case AttributeType.LONGTEXT:
       case AttributeType.DATETIME:
         type = "String";
         if (attribute.format === AttributeType.ENUM) {

package/lib/type-generation/languages/php.ts

@@ -13,6 +13,10 @@ export class PHP extends LanguageMeta {
     let type = "";
     switch (attribute.type) {
       case AttributeType.STRING:
+      case AttributeType.TEXT:
+      case AttributeType.VARCHAR:
+      case AttributeType.MEDIUMTEXT:
+      case AttributeType.LONGTEXT:
       case AttributeType.DATETIME:
         type = "string";
         if (attribute.format === AttributeType.ENUM) {