appwrite-cli 13.2.1 → 13.3.1

package/lib/commands/config-validations.ts

@@ -18,7 +18,7 @@ export const validateRequiredDefault = (data: {
 };
 
 /**
- * Validates that string type attributes must have a size defined,
+ * Validates that string/varchar type attributes must have a size defined,
  * unless they have a format (email, url, ip, enum) which defines the size
  */
 export const validateStringSize = (data: {
@@ -26,8 +26,8 @@ export const validateStringSize = (data: {
   size?: number | null;
   format?: string | null;
 }) => {
-  // Skip validation if not a string type
-  if (data.type !== "string") {
+  // Skip validation if not a string-like type that requires size
+  if (data.type !== "string" && data.type !== "varchar") {
     return true;
   }
 

package/lib/commands/config.ts

@@ -194,6 +194,10 @@ const AttributeSchema = z
     key: z.string(),
     type: z.enum([
       "string",
+      "text",
+      "varchar",
+      "mediumtext",
+      "longtext",
       "integer",
       "double",
       "boolean",
@@ -233,7 +237,7 @@ const AttributeSchema = z
     path: ["default"],
   })
   .refine(validateStringSize, {
-    message: "When 'type' is 'string', 'size' must be defined",
+    message: "When 'type' is 'string' or 'varchar', 'size' must be defined",
     path: ["size"],
   });
 
@@ -270,6 +274,10 @@ const ColumnSchema = z
     key: z.string(),
     type: z.enum([
       "string",
+      "text",
+      "varchar",
+      "mediumtext",
+      "longtext",
       "integer",
       "double",
       "boolean",
@@ -310,7 +318,7 @@ const ColumnSchema = z
     path: ["default"],
   })
   .refine(validateStringSize, {
-    message: "When 'type' is 'string', 'size' must be defined",
+    message: "When 'type' is 'string' or 'varchar', 'size' must be defined",
     path: ["size"],
   });
 

package/lib/commands/generate.ts

@@ -17,6 +17,7 @@ import {
   EXECUTABLE_NAME,
   DEFAULT_ENDPOINT,
 } from "../constants.js";
+import { detectImportExtension } from "../shared/typescript-type-utils.js";
 
 type ServerSideOverride = "auto" | "true" | "false";
 
@@ -129,11 +130,12 @@ const generateAction = async (
       const firstEntity = entities?.[0];
       const dbId = firstEntity?.databaseId ?? "databaseId";
       const tableName = firstEntity?.name ?? "tableName";
+      const importExt = detectImportExtension();
 
       console.log("");
       log(`Import the generated SDK in your project:`);
       console.log(
-        `  import { databases } from "./${outputDir}/${SDK_TITLE_LOWER}/index.js";`,
+        `  import { databases } from "./${outputDir}/${SDK_TITLE_LOWER}/index${importExt}";`,
       );
       console.log("");
       log(`Configure your SDK constants:`);
@@ -176,7 +178,7 @@ export const generate = new Command("generate")
     `
 Example:
   Import the generated SDK in your project:
-    import { databases } from "./generated/${SDK_TITLE_LOWER}/index.js";
+    import { databases } from "./generated/${SDK_TITLE_LOWER}/index${detectImportExtension()}";
 
   Configure your SDK constants:
     set values in ./generated/${SDK_TITLE_LOWER}/constants.ts

package/lib/commands/generators/typescript/databases.ts

@@ -13,6 +13,7 @@ import {
   getTypeScriptType,
   getAppwriteDependency,
   supportsServerSideMethods,
+  detectImportExtension,
   TypeAttribute,
   TypeEntity,
 } from "../../../shared/typescript-type-utils.js";
@@ -369,7 +370,7 @@ ${
         }`;
   }
 
-  private generateDatabasesFile(config: ConfigType): string {
+  private generateDatabasesFile(config: ConfigType, importExt: string): string {
     const entities = config.tables?.length ? config.tables : config.collections;
 
     if (!entities || entities.length === 0) {
@@ -386,6 +387,7 @@ ${
     return databasesTemplate({
       appwriteDep,
       supportsServerSide,
+      importExt,
       TABLE_ID_MAP: this.generateTableIdMap(entitiesByDb),
       TABLES_WITH_RELATIONSHIPS:
         this.generateTablesWithRelationships(entitiesByDb),
@@ -395,10 +397,11 @@ ${
     });
   }
 
-  private generateIndexFile(): string {
+  private generateIndexFile(importExt: string): string {
     return indexTemplate({
       sdkTitle: SDK_TITLE,
       executableName: EXECUTABLE_NAME,
+      importExt,
     });
   }
 
@@ -422,6 +425,7 @@ ${
       throw new Error("Project ID is required in configuration");
     }
 
+    const importExt = detectImportExtension();
     const files = new Map<string, string>();
 
     const hasEntities =
@@ -440,14 +444,14 @@ ${
         "types.ts",
         "// No tables or collections found in configuration\n",
       );
-      files.set("index.ts", this.generateIndexFile());
+      files.set("index.ts", this.generateIndexFile(importExt));
       files.set("constants.ts", this.generateConstantsFile(config));
       return { files };
     }
 
     files.set("types.ts", this.generateTypesFile(config));
-    files.set("databases.ts", this.generateDatabasesFile(config));
-    files.set("index.ts", this.generateIndexFile());
+    files.set("databases.ts", this.generateDatabasesFile(config, importExt));
+    files.set("index.ts", this.generateIndexFile(importExt));
     files.set("constants.ts", this.generateConstantsFile(config));
 
     return { files };

package/lib/commands/generators/typescript/templates/databases.ts.hbs

@@ -1,9 +1,9 @@
 import { Client, TablesDB, ID, Query, type Models, Permission, Role } from '{{appwriteDep}}';
-import type { DatabaseHandle, DatabaseId, DatabaseTableMap, DatabaseTables, QueryBuilder, PermissionBuilder, RoleBuilder, RoleString } from './types.js';
+import type { DatabaseHandle, DatabaseId, DatabaseTableMap, DatabaseTables, QueryBuilder, PermissionBuilder, RoleBuilder, RoleString } from './types{{importExt}}';
 {{#if supportsServerSide}}
-import { PROJECT_ID, ENDPOINT, API_KEY } from './constants.js';
+import { PROJECT_ID, ENDPOINT, API_KEY } from './constants{{importExt}}';
 {{else}}
-import { PROJECT_ID, ENDPOINT } from './constants.js';
+import { PROJECT_ID, ENDPOINT } from './constants{{importExt}}';
 {{/if}}
 
 const createQueryBuilder = <T>(): QueryBuilder<T> => ({

package/lib/commands/generators/typescript/templates/index.ts.hbs

@@ -5,5 +5,5 @@
  * Re-run `{{executableName}} generate` to regenerate.
  */
 
-export { databases } from "./databases.js";
-export * from "./types.js";
+export { databases } from "./databases{{importExt}}";
+export * from "./types{{importExt}}";

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

@@ -2324,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.1';
+export const SDK_VERSION = '13.3.1';
 export const SDK_NAME = 'Command Line';
 export const SDK_PLATFORM = 'console';
 export const SDK_LANGUAGE = 'cli';