appwrite-cli 13.6.0 → 14.0.0

package/lib/commands/generate.ts

@@ -25,6 +25,8 @@ export interface GenerateCommandOptions {
   output: string;
   language?: string;
   server?: ServerSideOverride;
+  appwriteImportSource?: string;
+  importExtension?: string;
 }
 
 const generateAction = async (
@@ -77,17 +79,18 @@ const generateAction = async (
       } else {
         log(`Detected language: ${detectedLanguage} (${detection.reason})`);
       }
-    } catch (err: any) {
+    } catch (err) {
       const supported = getSupportedLanguages().join(", ");
+      const message = err instanceof Error ? err.message : String(err);
       error(
-        `${err.message}\nUse --language to specify the target language. Supported: ${supported}`,
+        `${message}\nUse --language to specify the target language. Supported: ${supported}`,
       );
       process.exit(1);
     }
   }
 
-  if (typeof (generator as any).setServerSideOverride === "function") {
-    (generator as any).setServerSideOverride(serverSideOverride);
+  if (typeof generator.setServerSideOverride === "function") {
+    generator.setServerSideOverride(serverSideOverride);
   }
 
   const config: ConfigType = {
@@ -113,7 +116,10 @@ const generateAction = async (
   );
 
   try {
-    const result = await generator.generate(config);
+    const result = await generator.generate(config, {
+      appwriteImportSource: options.appwriteImportSource,
+      importExtension: options.importExtension,
+    });
     await generator.writeFiles(absoluteOutputDir, result);
 
     const generatedFiles = generator.getGeneratedFilePaths(result);
@@ -130,7 +136,7 @@ const generateAction = async (
       const firstEntity = entities?.[0];
       const dbId = firstEntity?.databaseId ?? "databaseId";
       const tableName = firstEntity?.name ?? "tableName";
-      const importExt = detectImportExtension();
+      const importExt = options.importExtension ?? detectImportExtension();
 
       console.log("");
       log(`Import the generated SDK in your project:`);
@@ -149,8 +155,9 @@ const generateAction = async (
         `  await mydb.use(${JSON.stringify(tableName)}).create({ ... });`,
       );
     }
-  } catch (err: any) {
-    error(`Failed to generate SDK: ${err.message}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    error(`Failed to generate SDK: ${message}`);
     process.exit(1);
   }
 };
@@ -173,6 +180,14 @@ export const generate = new Command("generate")
     "Override server-side generation (auto|true|false)",
     "auto",
   )
+  .option(
+    "--appwrite-import-source <source>",
+    "Override Appwrite import source in generated files (e.g. node-appwrite, appwrite, @appwrite.io/console). Auto-detected from package.json/deno.json if not provided.",
+  )
+  .option(
+    "--import-extension <ext>",
+    'Override import file extension in generated files (.js for ESM, empty string for CJS). Auto-detected from package.json "type" field if not provided.',
+  )
   .addHelpText(
     "after",
     `

package/lib/commands/generators/base.ts

@@ -26,6 +26,24 @@ export interface GenerateResult {
   constantsContent: string;
 }
 
+/**
+ * Options for overriding auto-detected generation settings.
+ */
+export interface GenerateOptions {
+  /**
+   * Override the Appwrite import source used in generated files.
+   * Auto-detected from package.json/deno.json if not provided.
+   * Examples: "node-appwrite", "appwrite", "@appwrite.io/console"
+   */
+  appwriteImportSource?: string;
+  /**
+   * Override the import file extension used in generated files.
+   * Auto-detected from package.json "type" field / deno.json if not provided.
+   * Use ".js" for ESM projects or "" for CJS/unknown projects.
+   */
+  importExtension?: string;
+}
+
 /**
  * Base interface for all language-specific database generators.
  * Implement this interface to add support for new languages.
@@ -44,12 +62,16 @@ export interface IDatabasesGenerator {
   /**
    * Generate the SDK files from the configuration.
    * @param config - The project configuration containing tables/collections
+   * @param options - Optional overrides for auto-detected settings (e.g. import source, extension)
    * @returns Promise resolving to named file contents:
    * `dbContent` (`databases.ts`), `typesContent` (`types.ts`),
    * `indexContent` (`index.ts`), and `constantsContent` (`constants.ts`).
    * Import your generated SDK from `index.ts` (or `index.js` after transpilation).
    */
-  generate(config: ConfigType): Promise<GenerateResult>;
+  generate(
+    config: ConfigType,
+    options?: GenerateOptions,
+  ): Promise<GenerateResult>;
 
   /**
    * Write the generated files to disk.
@@ -64,6 +86,12 @@ export interface IDatabasesGenerator {
    * @param result - The generation result
    */
   getGeneratedFilePaths(result: GenerateResult): string[];
+
+  /**
+   * Optional method to override server-side generation behavior.
+   * @param override - The override value
+   */
+  setServerSideOverride?(override: "auto" | "true" | "false"): void;
 }
 
 /**
@@ -74,7 +102,10 @@ export abstract class BaseDatabasesGenerator implements IDatabasesGenerator {
   abstract readonly language: SupportedLanguage;
   abstract readonly fileExtension: string;
 
-  abstract generate(config: ConfigType): Promise<GenerateResult>;
+  abstract generate(
+    config: ConfigType,
+    options?: GenerateOptions,
+  ): Promise<GenerateResult>;
 
   async writeFiles(outputDir: string, result: GenerateResult): Promise<void> {
     const sdkDir = path.join(outputDir, SDK_TITLE_LOWER);

package/lib/commands/generators/index.ts

@@ -9,6 +9,7 @@ export {
   IDatabasesGenerator,
   SupportedLanguage,
   GenerateResult,
+  GenerateOptions,
 } from "./base.js";
 export {
   LanguageDetector,

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

@@ -6,6 +6,7 @@ import { TypeScript } from "../../../type-generation/languages/typescript.js";
 import { SDK_TITLE, EXECUTABLE_NAME } from "../../../constants.js";
 import {
   BaseDatabasesGenerator,
+  GenerateOptions,
   GenerateResult,
   SupportedLanguage,
 } from "../base.js";
@@ -240,7 +241,7 @@ export type DatabaseHandle<D extends DatabaseId> = {
   use: <T extends keyof DatabaseTableMap[D] & string>(tableId: T) => DatabaseTableMap[D][T];
 ${
   supportsServerSide
-    ? `  create: (tableId: string, name: string, options?: { permissions?: ${PERMISSION_CALLBACK_INLINE}; rowSecurity?: boolean; enabled?: boolean; columns?: any[]; indexes?: any[] }) => Promise<Models.Table>;
+    ? `  create: (tableId: string, name: string, options?: { permissions?: ${PERMISSION_CALLBACK_INLINE}; rowSecurity?: boolean; enabled?: boolean; columns?: object[]; indexes?: object[] }) => Promise<Models.Table>;
   update: <T extends keyof DatabaseTableMap[D] & string>(tableId: T, options?: { name?: string; permissions?: ${PERMISSION_CALLBACK_INLINE}; rowSecurity?: boolean; enabled?: boolean }) => Promise<Models.Table>;
   delete: <T extends keyof DatabaseTableMap[D] & string>(tableId: T) => Promise<void>;`
     : ""
@@ -259,14 +260,13 @@ ${
 };`;
   }
 
-  private generateTypesFile(config: ConfigType): string {
+  private generateTypesFile(config: ConfigType, appwriteDep: string): string {
     const entities = config.tables?.length ? config.tables : config.collections;
 
     if (!entities || entities.length === 0) {
       return "// No tables or collections found in configuration\n";
     }
 
-    const appwriteDep = getAppwriteDependency();
     const enums = this.generateEnums(entities);
     const types = entities
       .map((entity: Entity) => this.generateTableType(entity, entities))
@@ -330,26 +330,26 @@ ${
     if (!supportsBulk) return "";
 
     return `
-    createMany: (rows: any[], options?: { transactionId?: string }) =>
+    createMany: (rows: object[], options?: { transactionId?: string }) =>
       tablesDB.createRows({
         databaseId,
         tableId,
         rows,
         transactionId: options?.transactionId,
       }),
-    updateMany: (data: any, options?: { queries?: (q: any) => string[]; transactionId?: string }) =>
+    updateMany: (data: object, options?: { queries?: (q: QueryBuilder<T>) => string[]; transactionId?: string }) =>
       tablesDB.updateRows({
         databaseId,
         tableId,
         data,
-        queries: options?.queries?.(createQueryBuilder()),
+        queries: options?.queries?.(createQueryBuilder<T>()),
         transactionId: options?.transactionId,
       }),
-    deleteMany: (options?: { queries?: (q: any) => string[]; transactionId?: string }) =>
+    deleteMany: (options?: { queries?: (q: QueryBuilder<T>) => string[]; transactionId?: string }) =>
       tablesDB.deleteRows({
         databaseId,
         tableId,
-        queries: options?.queries?.(createQueryBuilder()),
+        queries: options?.queries?.(createQueryBuilder<T>()),
         transactionId: options?.transactionId,
       }),`;
   }
@@ -364,13 +364,17 @@ ${
     return `
         // Remove bulk methods for tables with relationships
         if (!hasBulkMethods(databaseId, tableId)) {
-          delete (api as any).createMany;
-          delete (api as any).updateMany;
-          delete (api as any).deleteMany;
+          delete (api as Record<string, unknown>).createMany;
+          delete (api as Record<string, unknown>).updateMany;
+          delete (api as Record<string, unknown>).deleteMany;
         }`;
   }
 
-  private generateDatabasesFile(config: ConfigType, importExt: string): string {
+  private generateDatabasesFile(
+    config: ConfigType,
+    importExt: string,
+    appwriteDep: string,
+  ): string {
     const entities = config.tables?.length ? config.tables : config.collections;
 
     if (!entities || entities.length === 0) {
@@ -378,7 +382,6 @@ ${
     }
 
     const entitiesByDb = this.groupEntitiesByDb(entities);
-    const appwriteDep = getAppwriteDependency();
     const supportsServerSide = supportsServerSideMethods(
       appwriteDep,
       this.serverSideOverride,
@@ -405,8 +408,10 @@ ${
     });
   }
 
-  private generateConstantsFile(config: ConfigType): string {
-    const appwriteDep = getAppwriteDependency();
+  private generateConstantsFile(
+    config: ConfigType,
+    appwriteDep: string,
+  ): string {
     const supportsServerSide = supportsServerSideMethods(
       appwriteDep,
       this.serverSideOverride,
@@ -420,12 +425,17 @@ ${
     });
   }
 
-  async generate(config: ConfigType): Promise<GenerateResult> {
+  async generate(
+    config: ConfigType,
+    options?: GenerateOptions,
+  ): Promise<GenerateResult> {
     if (!config.projectId) {
       throw new Error("Project ID is required in configuration");
     }
 
-    const importExt = detectImportExtension();
+    const appwriteDep =
+      options?.appwriteImportSource ?? getAppwriteDependency();
+    const importExt = options?.importExtension ?? detectImportExtension();
 
     const hasEntities =
       (config.tables && config.tables.length > 0) ||
@@ -439,15 +449,15 @@ ${
         dbContent: "// No tables or collections found in configuration\n",
         typesContent: "// No tables or collections found in configuration\n",
         indexContent: this.generateIndexFile(importExt),
-        constantsContent: this.generateConstantsFile(config),
+        constantsContent: this.generateConstantsFile(config, appwriteDep),
       };
     }
 
     return {
-      dbContent: this.generateDatabasesFile(config, importExt),
-      typesContent: this.generateTypesFile(config),
+      dbContent: this.generateDatabasesFile(config, importExt, appwriteDep),
+      typesContent: this.generateTypesFile(config, appwriteDep),
       indexContent: this.generateIndexFile(importExt),
-      constantsContent: this.generateConstantsFile(config),
+      constantsContent: this.generateConstantsFile(config, appwriteDep),
     };
   }
 }

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

@@ -1,5 +1,5 @@
 import { Client, TablesDB, ID, Query, type Models, Permission, Role } from '{{appwriteDep}}';
-import type { DatabaseHandle, DatabaseId, DatabaseTableMap, DatabaseTables, QueryBuilder, PermissionBuilder, RoleBuilder, RoleString } from './types{{importExt}}';
+import type { DatabaseHandle, DatabaseId, DatabaseTableMap, DatabaseTables, QueryBuilder, QueryValue, PermissionBuilder, RoleBuilder, RoleString } from './types{{importExt}}';
 {{#if supportsServerSide}}
 import { PROJECT_ID, ENDPOINT, API_KEY } from './constants{{importExt}}';
 {{else}}
@@ -7,19 +7,19 @@ import { PROJECT_ID, ENDPOINT } from './constants{{importExt}}';
 {{/if}}
 
 const createQueryBuilder = <T>(): QueryBuilder<T> => ({
-  equal: (field, value) => Query.equal(String(field), value as any),
-  notEqual: (field, value) => Query.notEqual(String(field), value as any),
-  lessThan: (field, value) => Query.lessThan(String(field), value as any),
-  lessThanEqual: (field, value) => Query.lessThanEqual(String(field), value as any),
-  greaterThan: (field, value) => Query.greaterThan(String(field), value as any),
-  greaterThanEqual: (field, value) => Query.greaterThanEqual(String(field), value as any),
-  contains: (field, value) => Query.contains(String(field), value as any),
+  equal: (field, value) => Query.equal(String(field), value as QueryValue),
+  notEqual: (field, value) => Query.notEqual(String(field), value as QueryValue),
+  lessThan: (field, value) => Query.lessThan(String(field), value as QueryValue),
+  lessThanEqual: (field, value) => Query.lessThanEqual(String(field), value as QueryValue),
+  greaterThan: (field, value) => Query.greaterThan(String(field), value as QueryValue),
+  greaterThanEqual: (field, value) => Query.greaterThanEqual(String(field), value as QueryValue),
+  contains: (field, value) => Query.contains(String(field), value as string | QueryValue[]),
   search: (field, value) => Query.search(String(field), value),
   isNull: (field) => Query.isNull(String(field)),
   isNotNull: (field) => Query.isNotNull(String(field)),
   startsWith: (field, value) => Query.startsWith(String(field), value),
   endsWith: (field, value) => Query.endsWith(String(field), value),
-  between: (field, start, end) => Query.between(String(field), start as any, end as any),
+  between: (field, start, end) => Query.between(String(field), start as string | number, end as string | number),
   select: (fields) => Query.select(fields.map(String)),
   orderAsc: (field) => Query.orderAsc(String(field)),
   orderDesc: (field) => Query.orderDesc(String(field)),
@@ -62,12 +62,12 @@ function createTableApi<T extends Models.Row>(
   tableId: string,
 ) {
   return {
-    create: (data: any, options?: { rowId?: string; permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; transactionId?: string }) =>
+    create: (data: Omit<T, keyof Models.Row>, options?: { rowId?: string; permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; transactionId?: string }) =>
       tablesDB.createRow<T>({
         databaseId,
         tableId,
         rowId: options?.rowId ?? ID.unique(),
-        data,
+        data: data as T extends Models.DefaultRow ? Partial<Models.Row> & Record<string, unknown> : Partial<Models.Row> & Omit<T, keyof Models.Row>,
         permissions: resolvePermissions(options?.permissions),
         transactionId: options?.transactionId,
       }),
@@ -77,12 +77,12 @@ function createTableApi<T extends Models.Row>(
         tableId,
         rowId: id,
       }),
-    update: (id: string, data: any, options?: { permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; transactionId?: string }) =>
+    update: (id: string, data: Partial<Omit<T, keyof Models.Row>>, options?: { permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; transactionId?: string }) =>
       tablesDB.updateRow<T>({
         databaseId,
         tableId,
         rowId: id,
-        data,
+        data: data as T extends Models.DefaultRow ? Partial<Models.Row> & Record<string, unknown> : Partial<Models.Row> & Partial<Omit<T, keyof Models.Row>>,
         ...(options?.permissions ? { permissions: resolvePermissions(options.permissions) } : {}),
         transactionId: options?.transactionId,
       }),
@@ -94,7 +94,7 @@ function createTableApi<T extends Models.Row>(
         transactionId: options?.transactionId,
       });
     },
-    list: (options?: { queries?: (q: any) => string[] }) =>
+    list: (options?: { queries?: (q: QueryBuilder<T>) => string[] }) =>
       tablesDB.listRows<T>({
         databaseId,
         tableId,
@@ -129,7 +129,7 @@ function createDatabaseHandle<D extends DatabaseId>(
       return tableApiCache.get(tableId) as DatabaseTableMap[D][T];
     },
 {{#if supportsServerSide}}
-    create: (tableId: string, name: string, options?: { permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; rowSecurity?: boolean; enabled?: boolean; columns?: any[]; indexes?: any[] }) =>
+    create: (tableId: string, name: string, options?: { permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; rowSecurity?: boolean; enabled?: boolean; columns?: object[]; indexes?: object[] }) =>
       tablesDB.createTable({
         databaseId,
         tableId,
@@ -148,7 +148,7 @@ function createDatabaseHandle<D extends DatabaseId>(
       return tablesDB.updateTable({
         databaseId,
         tableId: resolvedTableId,
-        name: options?.name ?? tableId, // TODO: remove this fallback once fixed in other SDKs
+        name: options?.name,
         permissions: resolvePermissions(options?.permissions),
         rowSecurity: options?.rowSecurity,
         enabled: options?.enabled,

package/lib/commands/generic.ts

@@ -28,9 +28,14 @@ import ClientLegacy from "../client.js";
 
 const DEFAULT_ENDPOINT = "https://cloud.appwrite.io/v1";
 
-const isMfaRequiredError = (err: any): boolean =>
-  err?.type === "user_more_factors_required" ||
-  err?.response === "user_more_factors_required";
+interface AppwriteError {
+  type?: string;
+  response?: string;
+}
+
+const isMfaRequiredError = (err: unknown): err is AppwriteError =>
+  (err as AppwriteError)?.type === "user_more_factors_required" ||
+  (err as AppwriteError)?.response === "user_more_factors_required";
 
 const createLegacyConsoleClient = (endpoint: string): ClientLegacy => {
   const legacyClient = new ClientLegacy();
@@ -52,7 +57,7 @@ const completeMfaLogin = async ({
   legacyClient: ClientLegacy;
   mfa?: string;
   code?: string;
-}): Promise<any> => {
+}): Promise<unknown> => {
   let accountClient = new Account(client);
 
   const savedCookie = globalConfig.getCookie();
@@ -92,11 +97,11 @@ const completeMfaLogin = async ({
 
 const deleteServerSession = async (sessionId: string): Promise<boolean> => {
   try {
-    let client = await sdkForConsole();
-    let accountClient = new Account(client);
+    const client = await sdkForConsole();
+    const accountClient = new Account(client);
     await accountClient.deleteSession(sessionId);
     return true;
-  } catch (e) {
+  } catch (_e) {
     return false;
   }
 };
@@ -206,7 +211,7 @@ export const loginCommand = async ({
 
     try {
       await accountClient.get();
-    } catch (err: any) {
+    } catch (err) {
       if (!isMfaRequiredError(err)) {
         throw err;
       }
@@ -234,7 +239,7 @@ export const loginCommand = async ({
   // Use legacy client for login to extract cookies from response
   const legacyClient = createLegacyConsoleClient(configEndpoint);
 
-  let client = await sdkForConsole(false);
+  const client = await sdkForConsole(false);
   let accountClient = new Account(client);
 
   let account;
@@ -261,7 +266,7 @@ export const loginCommand = async ({
 
     accountClient = new Account(client);
     account = await accountClient.get();
-  } catch (err: any) {
+  } catch (err) {
     if (isMfaRequiredError(err)) {
       account = await completeMfaLogin({
         client,
@@ -301,8 +306,8 @@ export const whoami = new Command("whoami")
         return;
       }
 
-      let client = await sdkForConsole(false);
-      let accountClient = new Account(client);
+      const client = await sdkForConsole(false);
+      const accountClient = new Account(client);
 
       let account;
 
@@ -501,7 +506,7 @@ export const client = new Command("client")
                 : cookieValue || "********";
             maskedCookie = `${cookieName}=...${tail}`;
           }
-          let config = {
+          const config = {
             endpoint: globalConfig.getEndpoint(),
             key: maskedKey,
             cookie: maskedCookie,
@@ -515,17 +520,17 @@ export const client = new Command("client")
         if (endpoint !== undefined) {
           try {
             const id = ID.unique();
-            let url = new URL(endpoint);
+            const url = new URL(endpoint);
             if (url.protocol !== "http:" && url.protocol !== "https:") {
               throw new Error();
             }
 
-            let clientInstance = new Client().setEndpoint(endpoint);
+            const clientInstance = new Client().setEndpoint(endpoint);
             clientInstance.setProject("console");
             if (selfSigned || globalConfig.getSelfSigned()) {
               clientInstance.setSelfSigned(true);
             }
-            let response = (await clientInstance.call(
+            const response = (await clientInstance.call(
               "GET",
               new URL(endpoint + "/health/version"),
             )) as { version?: string };