feat: Isomorphic SDKs

[ChiragAgg5k]

Summary

Implements the isomorphic SDK client/auth factory pattern across the generated SDKs. The branch now covers the Web SDK, Flutter, Apple, Android, server SDK variants, and React Native, while preserving the existing Client() constructor and setter setup path for backwards compatibility.

This consolidates the work from #1481, #1510, and #1511, extends the pattern to Android, and adds matching server-side factory coverage for the generated Node, Dart, Swift, and Kotlin SDKs.

Web SDK

The generated Web SDK now uses one typed generic Client across browser, server, and console output. Static factories describe both runtime and auth capability, and generated services narrow their available methods from the client auth type.

import { Client, Account, TablesDB } from 'appwrite';

const browserClient = Client.from({
  endpoint: 'https://<REGION>.cloud.appwrite.io/v1',
  projectId: '<PROJECT_ID>',
});

const apiKeyClient = Client.fromAPIKey({
  endpoint: 'https://<REGION>.cloud.appwrite.io/v1',
  projectId: '<PROJECT_ID>',
  apiKey: '<API_KEY>',
});

new Account(browserClient);              // OK
new TablesDB(browserClient).createRow;   // OK
new TablesDB(browserClient).createTable; // Type error for browser auth
new TablesDB(apiKeyClient).createTable;  // OK

Available Web factories are from, fromSession, fromDevKey, and fromImpersonation for client auth. Server and console output also expose fromAPIKey, fromCookie, and fromJWT. Console cookie factories force admin mode.

Flutter SDK

The generated Flutter client SDK now exposes a ClientAuth interface returned by factory-created clients. Services and Realtime accept ClientAuth, so construction stays the same while legacy setters are hidden from factory-created clients.

import 'package:appwrite/appwrite.dart';

final ClientAuth client = Client.from(
  endPoint: 'https://<REGION>.cloud.appwrite.io/v1',
  projectId: '<PROJECT_ID>',
  endPointRealtime: 'wss://<REGION>.cloud.appwrite.io/v1',
);

Account(client);      // OK
Realtime(client);     // OK
client.setProject('other'); // Analyzer error

Available Flutter factories are from, fromSession, fromDevKey, and fromImpersonation. Factories validate endpoint schemes, mirror auth values into config, and store lowercase aliases for generated config lookups.

Apple SDK

The generated Apple SDK now exposes a ClientAuth protocol returned by factory-created clients. Generated services and Realtime accept ClientAuth, and services read auth values through getConfig(key:) instead of exposing the raw config dictionary.

let client: ClientAuth = try Client.from(
    endpoint: "https://<REGION>.cloud.appwrite.io/v1",
    projectId: "<PROJECT_ID>",
    endpointRealtime: "wss://<REGION>.cloud.appwrite.io/v1"
)

let sessionClient: ClientAuth = try Client.fromSession(
    endpoint: "https://<REGION>.cloud.appwrite.io/v1",
    projectId: "<PROJECT_ID>",
    session: "<SESSION>"
)

let tables = TablesDB(client)
let realtime = Realtime(client)

Available Apple factories are from, fromSession, fromDevKey, and throwing fromImpersonation. All factories accept optional endpoint, realtime endpoint, locale, self-signed, and compression values. fromImpersonation throws an AppwriteError when callers pass zero or multiple impersonation targets.

Android SDK

The generated Android SDK now exposes concrete Client factories for Android/Kotlin/Java ergonomics. Generated services and Realtime continue to accept Client, while factories apply the same project, auth header, config, endpoint validation, realtime endpoint, locale, and self-signed setup.

import io.appwrite.Client
import io.appwrite.services.Account
import io.appwrite.services.Realtime

val client = Client.from(
    context = context,
    projectId = "<PROJECT_ID>",
    endpoint = "https://<REGION>.cloud.appwrite.io/v1",
    endpointRealtime = "wss://<REGION>.cloud.appwrite.io/v1"
)

Account(client)   // OK
Realtime(client)  // OK

Available Android factories are from, fromSession, fromDevKey, and fromImpersonation. fromImpersonation validates that exactly one of userId, userEmail, or userPhone is provided, and factory auth values are mirrored into client.config with the key aliases used by generated services.

Server SDK Variants

Generated Node, Dart, Swift, and Kotlin server SDKs now expose the same factory family for server auth flows: from, fromSession, fromAPIKey, fromCookie, fromJWT, fromDevKey, and fromImpersonation. React Native exposes the client-safe subset: from, fromSession, fromDevKey, and fromImpersonation.

const { Client, Users } = require('node-appwrite');

const apiKeyClient = Client.fromAPIKey({
  endpoint: 'https://<REGION>.cloud.appwrite.io/v1',
  projectId: '<PROJECT_ID>',
  apiKey: '<API_KEY>',
});

const users = new Users(apiKeyClient);

final apiKeyClient = Client.fromAPIKey(
  endPoint: 'https://<REGION>.cloud.appwrite.io/v1',
  projectId: '<PROJECT_ID>',
  apiKey: '<API_KEY>',
);

let apiKeyClient = try Client.fromAPIKey(
    endpoint: "https://<REGION>.cloud.appwrite.io/v1",
    projectId: "<PROJECT_ID>",
    apiKey: "<API_KEY>"
)

val apiKeyClient = Client.fromAPIKey(
    projectId = "<PROJECT_ID>",
    apiKey = "<API_KEY>",
    endPoint = "https://<REGION>.cloud.appwrite.io/v1"
)

Backwards Compatibility

Existing constructor/setter setup remains supported in all affected SDKs:

const webClient = new Client()
  .setEndpoint('https://<REGION>.cloud.appwrite.io/v1')
  .setProject('<PROJECT_ID>');

final flutterClient = Client()
  ..setEndpoint('https://<REGION>.cloud.appwrite.io/v1')
  ..setProject('<PROJECT_ID>');

let appleClient = Client()
    .setEndpoint("https://<REGION>.cloud.appwrite.io/v1")
    .setProject("<PROJECT_ID>")

val androidClient = Client(context)
    .setEndpoint("https://<REGION>.cloud.appwrite.io/v1")
    .setProject("<PROJECT_ID>")

Legacy setters are marked deprecated where the generated language surface supports that distinction, but remain available from direct Client() instances.

Implementation Notes

• Adds auth capability typing/protocols/interfaces and static factories across Web, Flutter, Apple, Android, Node, Dart, Swift, Kotlin, and React Native templates.
• Standardizes the base factory name as from across SDKs.
• Keeps service construction syntax unchanged across SDKs.
• Hides service .client internals from the public generated service surface where supported by the SDK language.
• Updates Realtime templates to accept factory-created clients where the SDK has a narrowed auth surface.
• Marks legacy setters as deprecated without removing them.
• Generates Web factory base params from spec-backed global headers instead of hardcoded template branches.
• Mirrors factory auth values into headers and config, including lowercase config aliases required by generated service code.
• Validates API and realtime endpoint schemes in factory setup.
• Adds generated SDK build validation coverage for auth factories across the affected language test fixtures.

Validation

Previously run on the consolidated branch:

php example.php web server
php example.php web client
php example.php web console
php example.php flutter client
php example.php apple client
php example.php android client
composer lint-twig
php -l src/SDK/Language/Web.php
php -l src/SDK/Language/Flutter.php
php -l src/SDK/Language/Apple.php
git diff --check origin/master...HEAD
sh ./gradlew :library:compileDebugKotlin # from examples/android

Android compilation succeeded after Gradle fell back from the Kotlin daemon. The daemon failed locally because the installed Java version reports as 25.0.2; the non-daemon compiler completed successfully with existing generated-code warnings.