Authenticate Users

final anonCredentials = Credentials.anonymous();
await app.logIn(anonCredentials);

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    val anonymousCredentials = Credentials.anonymous()
    val user = app.login(anonymousCredentials)
}

auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
auto user = app.login(realm::App::credentials::anonymous()).get();

var user = await app.LogInAsync(Credentials.Anonymous());

final anonUser = await app.logIn(Credentials.anonymous());
final otherAnonUser =
    await app.logIn(Credentials.anonymous(reuseCredentials: false));

// Create an anonymous credential
const credentials = Realm.Credentials.anonymous();
const user = await app.logIn(credentials);

// Logs in with an anonymous user
val anonUser = app.login(Credentials.anonymous())
// Logs in with a new, different anonymous user
val otherAnonUser =
    app.login(Credentials.anonymous(reuseExisting = false))

let anonymousCredentials = Credentials.anonymous
app.login(credentials: anonymousCredentials) { (result) in
    switch result {
    case .failure(let error):
        print("Login failed: \(error.localizedDescription)")
    case .success(let user):
        print("Successfully logged in as user \(user)")
        // Now logged in, do something with user
        // Remember to dispatch to main if you are doing anything on the UI thread
    }
}

// Create an anonymous credential
const credentials = Realm.Credentials.anonymous();
const user = await app.logIn(credentials);

auto user = app.login(realm::App::credentials::username_password(
                          userEmail, userPassword))
                .get();

var user = await app.LogInAsync(
    Credentials.EmailPassword("caleb@mongodb.com", "MySekritPwd"));

final emailPwCredentials =
    Credentials.emailPassword("lisa@example.com", "myStr0ngPassw0rd");
await app.logIn(emailPwCredentials);

// Create an email/password credential
const credentials = Realm.Credentials.emailPassword(
  "someone@example.com",
  "Pa55w0rd!"
);
const user = await app.logIn(credentials);

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    val emailPasswordCredentials = Credentials.emailPassword(email, password)
    val user = app.login(emailPasswordCredentials)
}

let email = "skroob@example.com"
let password = "12345"
app.login(credentials: Credentials.emailPassword(email: email, password: password)) { (result) in
    switch result {
    case .failure(let error):
        print("Login failed: \(error.localizedDescription)")
    case .success(let user):
        print("Successfully logged in as user \(user)")
        // Now logged in, do something with user
        // Remember to dispatch to main if you are doing anything on the UI thread
    }
}

// Create an email/password credential
const credentials = Realm.Credentials.emailPassword(
  "someone@example.com",
  "Pa55w0rd!"
);
const user = await app.logIn(credentials);

auto token = "<jwt>";
auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
auto user = app.login(realm::App::credentials::custom(token)).get();

var user =
    await app.LogInAsync(Credentials.JWT(jwt_token));

final token = await authenticateWithExternalSystem();
final jwtCredentials = Credentials.jwt(token);
final currentUser = await app.logIn(jwtCredentials);

// Create a custom jwt credential
const jwt = await authenticateWithExternalSystem();
const credentials = Realm.Credentials.jwt(jwt);
const user = await app.logIn(credentials);

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    // Registration is handled by the JWT provider
    val jwtCredentials = Credentials.jwt(jwtToken)
    val user = app.login(jwtCredentials)
}

let credentials = Credentials.jwt(token: "<jwt>")
app.login(credentials: credentials) { (result) in
    switch result {
    case .failure(let error):
        print("Login failed: \(error.localizedDescription)")
    case .success(let user):
        print("Successfully logged in as user \(user)")
        // Now logged in, do something with user
        // Remember to dispatch to main if you are doing anything on the UI thread
    }
}

// Create a custom jwt credential.
const jwt = await authenticateWithExternalSystem();
const credentials = Realm.Credentials.jwt(jwt);
const user = await app.logIn(credentials);

auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
auto user = app.login(realm::App::credentials::api_key(API_KEY)).get();

var user = await app.LogInAsync(Credentials.ApiKey(apiKey));

final apiKeyCredentials = Credentials.apiKey(myApiKey);
final apiKeyUser = await app.logIn(apiKeyCredentials);

// Get the API key from the local environment
const apiKey = process.env?.appServicesApiKey;
if (!apiKey) {
  throw new Error("Could not find a Server API Key.");
}
// Create an api key credential
const credentials = Realm.Credentials.apiKey(apiKey);
const user = await app.logIn(credentials);

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    val user = app.login(Credentials.apiKey(key))
}

let credentials = Credentials.userAPIKey("<api-key>")
app.login(credentials: credentials) { (result) in
    switch result {
    case .failure(let error):
        print("Login failed: \(error.localizedDescription)")
    case .success(let user):
        print("Successfully logged in as user \(user)")
        // Now logged in, do something with user
        // Remember to dispatch to main if you are doing anything on the UI thread
    }
}

// Get the API key from the local environment.
const apiKey = process.env?.appServicesApiKey;
if (!apiKey) {
  throw new Error("Could not find a Server API Key.");
}
// Create an api key credential.
const credentials = Realm.Credentials.apiKey(apiKey);
const user = await app.logIn(credentials);

auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
/* Custom function authentication takes a string parameters argument.
The parameter details vary depending on how you define your custom
authentication function. */
std::string params = "{\"username\": \"bob\"}";
auto user = app.login(realm::App::credentials::function(params)).get();

var functionParameters = new
{
    username = "caleb",
    password = "MySekritPwd",
    IQ = 42,
    hasPets = true
};
var user =
    await app.LogInAsync(Credentials.Function(functionParameters));

final credentials = {
  "username": "someUsername",
};
// payload must be a JSON-encoded string
final payload = jsonEncode(credentials);
final customCredentials = Credentials.function(payload);
final currentUser = await app.logIn(customCredentials);

// Create a custom function credential
const credentials = Realm.Credentials.function({
  username: "ilovemongodb",
});
const user = await app.logIn(credentials);

// Create custom arguments for your Atlas Function
val customCredentials = Credentials.customFunction(
    payload = mapOf("username" to "bob")
)
val user = app.login(customCredentials)

let params: Document = ["username": "bob"]
app.login(credentials: Credentials.function(payload: params)) { (result) in
    switch result {
    case .failure(let error):
        print("Login failed: \(error.localizedDescription)")
    case .success(let user):
        print("Successfully logged in as user \(user)")
        // Now logged in, do something with user
        // Remember to dispatch to main if you are doing anything on the UI thread
    }
}

// Create a custom function credential.
const credentials = Realm.Credentials.function({
  username: "ilovemongodb",
});
const user = await app.logIn(credentials);

auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
// The user's server auth code you got from Google
auto myAuthCode = "auth_code_from_google";
auto user =
    app.login(realm::App::credentials::google_auth_code(myAuthCode)).get();

final googleAuthCodeCredentials = Credentials.googleAuthCode(authCode);
final currentUser = await app.logIn(googleAuthCodeCredentials);

auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
// The user's OpenID Connect id_token you got from the Google OAuth response
auto myIdToken = "open_id_connect_id_token_from_google";
auto user =
    app.login(realm::App::credentials::google_id_token(myIdToken)).get();

var user =
    await app.LogInAsync(Credentials.Google(googleAuthCode, GoogleCredentialType.AuthCode));

final googleIdTokenCredentials = Credentials.googleIdToken(idToken);
final currentUser = await app.logIn(googleIdTokenCredentials);

// Get Google token and use it to sign into Realm
oauth2Client.getToken(authCodeFromQueryString, async function (
  error,
  token
) {
  if (error) return errorHandler(error);
  try {
    const credential = Realm.Credentials.google({
      idToken: token.id_token,
    });
    const user = await realmApp.logIn(credential);
    console.log("signed in as Realm user", user.id);
  } catch (error) {
    errorHandler(error);
  }
});

fun loginWithGoogle() {
    val gso = GoogleSignInOptions
        .Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
        .requestIdToken("YOUR WEB APPLICATION CLIENT ID FOR GOOGLE AUTH")
        .build()
    val googleSignInClient = GoogleSignIn.getClient(activity, gso)
    val signInIntent: Intent = googleSignInClient.signInIntent
    val resultLauncher: ActivityResultLauncher<Intent> =
        // Note: this activity MUST inherit from ComponentActivity or AppCompatActivity to use this API
        registerForActivityResult(ActivityResultContracts.StartActivityForResult())
        { result ->
            val task: Task<GoogleSignInAccount> =
                GoogleSignIn.getSignedInAccountFromIntent(result.data)
            handleSignInResult(task)
        }
    resultLauncher.launch(signInIntent)
}
fun handleSignInResult(completedTask: Task<GoogleSignInAccount>) {
    try {
        if (completedTask.isSuccessful) {
            val account: GoogleSignInAccount? = completedTask.getResult(ApiException::class.java)
            val token: String = account?.idToken!!
            val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
            runBlocking {
                val user = app.login(Credentials.google(token, GoogleAuthType.ID_TOKEN))
            }
        } else {
            Log.e("AUTH", "Google Auth failed: ${completedTask.exception}")
        }
    } catch (e: ApiException) {
        Log.e("AUTH", "Failed to authenticate using Google OAuth: " + e.message);
    }
}

func sign(_ signIn: GIDSignIn!, didSignInFor googleUser: GIDGoogleUser!, withError error: Error!) {
    if let error = error {
      print("\(error.localizedDescription)")
        return
    }
    // Get the ID token for the authenticated user so you can pass it to Realm
    let idToken = googleUser.authentication.idToken!
    let credentials = Credentials.googleId(token: idToken)
    app.login(credentials: credentials) { result in
        DispatchQueue.main.async {
            switch result {
            case .failure(let error):
                print("Failed to log in to MongoDB Realm: \(error)")
            case .success(let user):
                print("Successfully logged in to MongoDB Realm using Google OAuth.")
                // Now logged in, do something with user
                // Remember to dispatch to main if you are doing anything on the UI thread
            }
        }
    }
}

func sign(_ signIn: GIDSignIn!, didSignInFor googleUser: GIDGoogleUser!, withError error: Error!) {
    if let error = error {
      print("\(error.localizedDescription)")
        return
    }
    // Upon first successful sign-in, forward serverAuthCode credentials to MongoDB Realm.
    // Upon subsequent sign-ins, this returns nil.
    let credentials = Credentials.google(serverAuthCode: googleUser.serverAuthCode!)
    app.login(credentials: credentials) { result in
        DispatchQueue.main.async {
            switch result {
            case .failure(let error):
                print("Failed to log in to MongoDB Realm: \(error)")
            case .success(let user):
                print("Successfully logged in to MongoDB Realm using Google OAuth.")
                // Now logged in, do something with user
                // Remember to dispatch to main if you are doing anything on the UI thread
            }
        }
    }
}

// The documentation does not currently have this code example in TypeScript.
// Please refer to the other languages or related pages for example code.

auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
auto accessToken = "<token>";
auto user = app.login(realm::App::credentials::facebook(accessToken)).get();

var user =
    await app.LogInAsync(Credentials.Facebook(facebookToken));

final facebookCredentials = Credentials.facebook(accessToken);
final currentUser = await app.logIn(facebookCredentials);

// Get the access token from the Facebook SDK
const { accessToken } = FB.getAuthResponse();
// Define credentials with the access token from the Facebook SDK
const credentials = Realm.Credentials.facebook(accessToken);
// Log the user in to your app
await app.logIn(credentials);

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
FacebookSdk.setApplicationId(YOUR_FACEBOOK_SDK_APP_ID)
FacebookSdk.sdkInitialize(activity)
val callbackManager = CallbackManager.Factory.create()
LoginManager.getInstance().registerCallback(
    callbackManager,
    object : FacebookCallback<LoginResult> {
        override fun onSuccess(loginResult: LoginResult) {
            // Signed in successfully, forward credentials to MongoDB Realm.
            val accessToken = loginResult.accessToken
            runBlocking {
                val user = app.login(Credentials.facebook(accessToken.token))
            }
        }
        override fun onCancel() {
            Log.v("AUTH", "Cancelled Facebook login")
        }
        override fun onError(exception: FacebookException) {
            Log.e("AUTH", "Failed to authenticate with Facebook: ${exception.message}")
        }
    })

// This example demonstrates login logic for FBSDK version 13.x. If you're using
// a different version of FBSDK, you'll need to adapt this example for your version.
let loginManager = LoginManager()
loginManager.logIn(permissions: [ .email ]) { loginResult in
    switch loginResult {
    case .success(let grantedPermissions, let declinedPermissions, let accessToken):
        let credentials = Credentials.facebook(accessToken: accessToken!.tokenString)
        app.login(credentials: credentials) { result in
            DispatchQueue.main.async {
                switch result {
                case .failure(let error):
                    print("Failed to log in to MongoDB Realm: \(error)")
                case .success(let user):
                    print("Successfully logged in to MongoDB Realm using Facebook OAuth.")
                    // Now logged in, do something with user
                    // Remember to dispatch to main if you are doing anything on the UI thread
                }
            }
        }
    case .failed(let error):
        print("Facebook login failed: \(error)")
    case .cancelled:
        print("The user cancelled the login flow.")
    }
}

// The documentation does not currently have this code example in TypeScript.
// Please refer to the other languages or related pages for example code.

auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
auto idToken = "<token>";
auto user = app.login(realm::App::credentials::apple(idToken)).get();

var user =
    await app.LogInAsync(Credentials.Apple(appleToken));

final appleCredentials = Credentials.apple(idToken);
final currentUser = await app.logIn(appleCredentials);

// Get the ID token from the Apple SDK
const { id_token } = await AppleID.auth.signIn();
// Define credentials with the ID token from the Apple SDK
const credentials = Realm.Credentials.apple(id_token);
// Log the user in to your app
const user = await app.logIn(credentials);

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    // Registration is handled by Apple
    val appleCredentials = Credentials.apple(idToken)
    val user = app.login(appleCredentials)
}

// Fetch IDToken via the Apple SDK
let credentials = Credentials.apple(idToken: "<token>")
app.login(credentials: credentials) { (result) in
    switch result {
    case .failure(let error):
        print("Login failed: \(error.localizedDescription)")
    case .success(let user):
        print("Successfully logged in as user \(user)")
        // Now logged in, do something with user
        // Remember to dispatch to main if you are doing anything on the UI thread
    }
}

// The documentation does not currently have this code example in TypeScript.
// Please refer to the other languages or related pages for example code.

// The documentation does not currently have this code example in C++.
// Please refer to the other languages or related pages for example code.

// The documentation does not currently have this code example in C#.
// Please refer to the other languages or related pages for example code.

// The documentation does not currently have this code example in Dart.
// Please refer to the other languages or related pages for example code.

// The documentation does not currently have this code example in JavaScript.
// Please refer to the other languages or related pages for example code.

// You can only open a synced realm offline if there is a cached user credential. If
// there is no app.currentUser, you must log them in, which requires a network connection.
if (app.currentUser == null) {
    app.login(Credentials.emailPassword(email, password))
}
// If the app.currentUser isn't null, you can use the cached credential to open the synced
// realm even if the user is offline.
val user = app.currentUser!!
val realm = Realm.open(config)
// Query the realm we opened, and see that it contains data
val offlineToads: RealmResults<Toad> = realm.query<Toad>().find()
Log.v("After opening a realm offline, offlineToads.size is ${offlineToads.size}")
realm.close()

// Log the user into the backend app.
// The first time you login, the user must have a network connection.
func getUser() async throws -> User {
    // Check for an existing user.
    // If the user is offline but credentials are
    // cached, this returns the existing user.
    if let user = app.currentUser {
        return user
    } else {
        // If the device has no cached user
        // credentials, log them in.
        let app = App(id: YOUR_APP_SERVICES_APP_ID)
        let loggedInUser = try await app.login(credentials: Credentials.anonymous)
        return loggedInUser
    }
}
let user = try await getUser()
var configuration = user.configuration(partitionValue: "Some Partition Value")
// Open a Realm with this configuration.
// If you do not require the app to download updates
// before opening the realm, the realm just opens, even if
// offline.
let realm = try await Realm(configuration: configuration)
print("Successfully opened realm: \(realm)")

// The documentation does not currently have this code example in TypeScript.
// Please refer to the other languages or related pages for example code.