support calling custom reset password functions

CHANGELOG.md

@@ -8,15 +8,22 @@ 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))
+* Support EmailPassword calling custom reset password functions. ([#482](https://github.com/realm/realm-dart/pull/482))
 
 ### 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,69 @@ 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);
+ }
+
+ /// Calls the reset password function, configured on the server.
+ Future<void> callResetPasswordFunction(String email, String password, String functionArgsAsJSON) {
+ return realmCore.emailPasswordCallResetPasswordFunction(application, email, password, functionArgsAsJSON);
+ }
+}

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,