Emailpassword send reset password email

CHANGELOG.md

@@ -8,15 +8,21 @@ x.x.x Release notes (yyyy-MM-dd)
 
 ### Enhancements
 * Added a property `Configuration.disableFormatUpgrade`. When set to `true`, opening a Realm with an older file format will throw an exception to avoid automatically upgrading it. ([#310](https://github.com/realm/realm-dart/pull/310))
-* Support result value from write transaction callbacks. ([#294](https://github.com/realm/realm-dart/pull/294/))
+* Support result value from write transaction callbacks. ([#294](https://github.com/realm/realm-dart/pull/294))
 * Added a property `Realm.isInTransaction` that indicates whether the Realm instance has an open write transaction associated with it.
-* Support anonymous application credentials. ([#443](https://github.com/realm/realm-dart/pull/443/))
+* Support anonymous application credentials. ([#443](https://github.com/realm/realm-dart/pull/443))
 * Added a property `Configuration.initialDataCallback`. This is a callback executed when a Realm file is first created and allows you to populate some initial data necessary for your application. ([#298](https://github.com/realm/realm-dart/issues/298))
-* Support application configuration. ([#306](https://github.com/realm/realm-dart/pull/306/))
-* Support application class. ([#446](https://github.com/realm/realm-dart/pull/446/))
+* Support application configuration. ([#306](https://github.com/realm/realm-dart/pull/306))
+* Support application class. ([#446](https://github.com/realm/realm-dart/pull/446))
 * Support should realm compact on open callback `Configuration.shouldCompactCallback` as option when configuring a Realm to determine if it should be compacted before being returned.  ([#466](https://github.com/realm/realm-dart/pull/466/))
 * Support ObjectId type. ([#468](https://github.com/realm/realm-dart/pull/468))
 * Support Uuid type. ([#470](https://github.com/realm/realm-dart/pull/470))
+* Support application login. ([#469](https://github.com/realm/realm-dart/pull/469))
+* Support EmailPassword register user. ([#452](https://github.com/realm/realm-dart/pull/452))
+* Support EmailPassword confirm user. ([#478](https://github.com/realm/realm-dart/pull/478))
+* Support EmailPassword resend user confirmation email. ([#479](https://github.com/realm/realm-dart/pull/479))
+* Support EmailPassword complete reset password. ([#480](https://github.com/realm/realm-dart/pull/480))
+* Support EmailPassword reset password. ([#481](https://github.com/realm/realm-dart/pull/481))
 
 ### Fixed
 * Fixed an issue that would result in the wrong transaction being rolled back if you start a write transaction inside a write transaction. ([#442](https://github.com/realm/realm-dart/issues/442))

lib/src/application.dart

@@ -19,9 +19,12 @@
 import 'dart:io';
 import 'package:meta/meta.dart';
 import 'native/realm_core.dart';
+import 'credentials.dart';
+import 'user.dart';
 import 'configuration.dart';
 
 /// Specify if and how to persists user objects.
+/// {@category Application}
 enum MetadataPersistenceMode {
   /// Persist [User] objects, but do not encrypt them.
   plaintext,
@@ -36,6 +39,7 @@ enum MetadataPersistenceMode {
 @immutable
 
 /// A class exposing configuration options for an [Application]
+/// {@category Application}
 class ApplicationConfiguration {
   /// The [appId] is the unique id that identifies the Realm application.
   final String appId;
@@ -108,13 +112,23 @@ class ApplicationConfiguration {
 /// The [Application]] can be used to
 /// * Register uses and perform various user-related operations through authentication providers
 /// * Synchronize data between the local device and a remote Realm App with Synchronized Realms
+/// {@category Application}
 class Application {
   final AppHandle _handle;
   final ApplicationConfiguration configuration;
 
-  Application(this.configuration) : _handle = realmCore.getApp(configuration);
+  /// Create an app with a particular [AppConfiguration]
+  Application(this.configuration) : 
+    _handle = realmCore.getApp(configuration);
+
+  /// Logs in a user with the given credentials.
+  Future<User> logIn(Credentials credentials) async {
+    var userHandle = await realmCore.logIn(this, credentials);
+    return UserInternal.create(userHandle);
+  }
 }
 
+/// @nodoc
 extension ApplicationInternal on Application {
   AppHandle get handle => _handle;
 }

lib/src/credentials.dart

@@ -15,16 +15,18 @@
 // limitations under the License.
 //
 ////////////////////////////////////////////////////////////////////////////////
+
 import 'native/realm_core.dart';
+import 'application.dart';
 
 /// An enum containing all authentication providers. These have to be enabled manually for the application before they can be used.
 /// [Authentication Providers Docs](https://docs.mongodb.com/realm/authentication/providers/)
 /// {@category Application}
-enum AuthProvider {
-  /// Mechanism for authenticating without credentials.
+enum AuthProviderType {
+  /// For authenticating without credentials.
   anonymous,
 
-  /// Mechanism for authenticating with an email and a password.
+  /// For authenticating with an email and a password.
   emailPassword,
 }
 
@@ -33,24 +35,64 @@ enum AuthProvider {
 class Credentials {
   late final RealmAppCredentialsHandle _handle;
 
-  final AuthProvider provider;
+  final AuthProviderType provider;
 
   /// Returns a [Credentials] object that can be used to authenticate an anonymous user.
   /// [Anonymous Authentication Docs](https://docs.mongodb.com/realm/authentication/anonymous)
   Credentials.anonymous()
       : _handle = realmCore.createAppCredentialsAnonymous(),
-        provider = AuthProvider.anonymous;
+        provider = AuthProviderType.anonymous;
 
   /// Returns a [Credentials] object that can be used to authenticate a user with their email and password.
   /// A user can login with email and password only after they have registered their account and verified their
   /// email.
   /// [Email/Password Authentication Docs](https://docs.mongodb.com/realm/authentication/email-password)
   Credentials.emailPassword(String email, String password)
       : _handle = realmCore.createAppCredentialsEmailPassword(email, password),
-        provider = AuthProvider.emailPassword;
+        provider = AuthProviderType.emailPassword;
 }
 
 /// @nodoc
 extension CredentialsInternal on Credentials {
   RealmAppCredentialsHandle get handle => _handle;
 }
+
+/// A class, encapsulating functionality for users, logged in with [Credentials.emailPassword()].
+/// It is always scoped to a particular app.
+/// {@category Application}
+class EmailPasswordAuthProvider {
+  final Application application;
+
+  /// Create a new EmailPasswordAuthProvider for the [application]
+  EmailPasswordAuthProvider(this.application);
+
+  /// Registers a new user with the given email and password.
+  /// The [email] to register with. This will be the user's username and, if user confirmation is enabled, this will be the address for
+  /// the confirmation email.
+  /// The [password] to associate with the email. The password must be between 6 and 128 characters long.
+  ///
+  /// Successful completion indicates that the user has been created on the server and can now be logged in with [Credentials.emailPassword()].
+  Future<void> registerUser(String email, String password) {
+    return realmCore.emailPasswordRegisterUser(application, email, password);
+  }
+
+  /// Confirms a user with the given token and token id. These are typically included in the registration email.
+  Future<void> confirmUser(String token, String tokenId) {
+    return realmCore.emailPasswordConfirmUser(application, token, tokenId);
+  }
+
+  /// Resends the confirmation email for a user to the given email.
+  Future<void> resendUserConfirmation(String email) {
+    return realmCore.emailPasswordResendUserConfirmation(application, email);
+  }
+
+  /// Completes the reset password procedure by providing the desired new password.
+  Future<void> completeResetPassword(String password, String token, String tokenId) {
+    return realmCore.emailPasswordCompleteResetPassword(application, password, token, tokenId);
+  }
+
+  /// Sends a password reset email.
+  Future<void> resetPassword(String email) {
+    return realmCore.emailPasswordResetPassword(application, email);
+  }
+}

lib/src/native/realm_bindings.dart

@@ -7449,34 +7449,76 @@ class RealmLibrary {
   late final _realm_delete_finalizable = _realm_delete_finalizablePtr
       .asFunction<void Function(Dart_FinalizableHandle, Object)>();
 
-  ffi.Pointer<ffi.Void> object_to_gc_handle(
+  ffi.Pointer<ffi.Void> object_to_weak_handle(
     Object handle,
   ) {
-    return _object_to_gc_handle(
+    return _object_to_weak_handle(
       handle,
     );
   }
 
-  late final _object_to_gc_handlePtr =
+  late final _object_to_weak_handlePtr =
       _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(ffi.Handle)>>(
-          'object_to_gc_handle');
-  late final _object_to_gc_handle = _object_to_gc_handlePtr
+          'object_to_weak_handle');
+  late final _object_to_weak_handle = _object_to_weak_handlePtr
       .asFunction<ffi.Pointer<ffi.Void> Function(Object)>();
 
-  Object gc_handle_to_object(
+  Object weak_handle_to_object(
     ffi.Pointer<ffi.Void> handle,
   ) {
-    return _gc_handle_to_object(
+    return _weak_handle_to_object(
       handle,
     );
   }
 
-  late final _gc_handle_to_objectPtr =
+  late final _weak_handle_to_objectPtr =
       _lookup<ffi.NativeFunction<ffi.Handle Function(ffi.Pointer<ffi.Void>)>>(
-          'gc_handle_to_object');
-  late final _gc_handle_to_object = _gc_handle_to_objectPtr
+          'weak_handle_to_object');
+  late final _weak_handle_to_object = _weak_handle_to_objectPtr
       .asFunction<Object Function(ffi.Pointer<ffi.Void>)>();
 
+  ffi.Pointer<ffi.Void> object_to_persistent_handle(
+    Object handle,
+  ) {
+    return _object_to_persistent_handle(
+      handle,
+    );
+  }
+
+  late final _object_to_persistent_handlePtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(ffi.Handle)>>(
+          'object_to_persistent_handle');
+  late final _object_to_persistent_handle = _object_to_persistent_handlePtr
+      .asFunction<ffi.Pointer<ffi.Void> Function(Object)>();
+
+  Object persistent_handle_to_object(
+    ffi.Pointer<ffi.Void> handle,
+  ) {
+    return _persistent_handle_to_object(
+      handle,
+    );
+  }
+
+  late final _persistent_handle_to_objectPtr =
+      _lookup<ffi.NativeFunction<ffi.Handle Function(ffi.Pointer<ffi.Void>)>>(
+          'persistent_handle_to_object');
+  late final _persistent_handle_to_object = _persistent_handle_to_objectPtr
+      .asFunction<Object Function(ffi.Pointer<ffi.Void>)>();
+
+  void delete_persistent_handle(
+    ffi.Pointer<ffi.Void> handle,
+  ) {
+    return _delete_persistent_handle(
+      handle,
+    );
+  }
+
+  late final _delete_persistent_handlePtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'delete_persistent_handle');
+  late final _delete_persistent_handle = _delete_persistent_handlePtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
   ffi.Pointer<realm_scheduler_t> realm_dart_create_scheduler(
     int isolateId,
     int port,