Client reset

CHANGELOG.md

@@ -47,6 +47,7 @@
  * Expose `User.apiKeys` client - this client can be used to create, fetch, and delete API keys.
  * Expose `Credentials.apiKey` that enable authentication with API keys.
 * Exposed `User.accessToken` and `User.refreshToken` - these tokens can be used to authenticate against the server when calling HTTP API outside of the Dart/Flutter SDK. For example, if you want to use the GraphQL. (PR [#919](https://github.com/realm/realm-dart/pull/919))
+* Set `recoverOrDiscard` mode as default resync mode for `FlexibleSyncConfiguration`. In this mode Realm attempts to recover unsynced local changes and if that fails, then the changes are discarded.(PR [#925](https://github.com/realm/realm-dart/pull/925))
 
 ### Fixed
 * Previously removeAt did not truncate length. ([#883](https://github.com/realm/realm-dart/issues/883))

lib/src/configuration.dart

@@ -162,7 +162,7 @@ abstract class Configuration implements Finalizable {
  String? fifoFilesFallbackPath,
  String? path,
  SyncErrorHandler syncErrorHandler = defaultSyncErrorHandler,
- SyncClientResetErrorHandler syncClientResetErrorHandler = const ManualSyncClientResetHandler(_defaultSyncClientResetHandler),
+ SyncClientResetErrorHandler syncClientResetErrorHandler = const RecoverOrDiscardSyncClientResetHandler(_defaultSyncClientResetHandler),
  }) =>
  FlexibleSyncConfiguration._(
  user,
@@ -286,7 +286,7 @@ class FlexibleSyncConfiguration extends Configuration {
  super.fifoFilesFallbackPath,
  super.path,
  this.syncErrorHandler = defaultSyncErrorHandler,
- this.syncClientResetErrorHandler = const ManualSyncClientResetHandler(_defaultSyncClientResetHandler),
+ this.syncClientResetErrorHandler = const RecoverOrDiscardSyncClientResetHandler(_defaultSyncClientResetHandler),
  }) : super._();
 
  @override
@@ -369,8 +369,12 @@ class RealmSchema extends Iterable<SchemaObject> {
 
 /// The signature of a callback that will be invoked if a client reset error occurs for this [Realm].
 ///
-/// Currently, Flexible Sync supports only the [ManualSyncClientResetHandler].
-class SyncClientResetErrorHandler {
+/// A Client Resync is triggered if the device and server cannot agree
+/// on a common shared history for the Realm file,
+/// thus making it impossible for the device to upload or receive any changes.
+/// This can happen if the server is rolled back or restored from backup.
+/// {@category Sync}
+abstract class SyncClientResetErrorHandler {
  /// The callback that handles the [SyncClientResetError].
  final void Function(SyncClientResetError code) callback;
 
@@ -379,4 +383,69 @@ class SyncClientResetErrorHandler {
 }
 
 /// A client reset strategy where the user needs to fully take care of a client reset.
-typedef ManualSyncClientResetHandler = SyncClientResetErrorHandler;
+///
+/// If you set [ManualSyncClientResetHandler] callback as `syncClientResetErrorHandler` argument of [Configuration.flexibleSync],
+/// that will enable full control of moving unsynced changes to synced realm.
+/// {@category Sync}
+class ManualSyncClientResetHandler extends SyncClientResetErrorHandler {
+ const ManualSyncClientResetHandler(super.callback);
+}
+
+/// A client reset strategy where all the not yet synchronized data is automatically
+/// discarded and a fresh copy of the synchronized Realm is obtained.
+///
+/// If you set [DiscardLocalSyncClientResetHandler] callback as `syncClientResetErrorHandler` argument of [Configuration.flexibleSync],
+/// the local Realm will be discarded and replaced with the server side Realm.
+/// All local changes will be lost.
+/// {@category Sync}
+class DiscardLocalSyncClientResetHandler extends SyncClientResetErrorHandler {
+ const DiscardLocalSyncClientResetHandler(super.callback);
+}
+
+///A client reset strategy that attempts to automatically recover any unsynchronized changes.
+///
+/// If you set [RecoverSyncClientResetHandler] callback as `syncClientResetErrorHandler` argument of [Configuration.flexibleSync],
+/// Realm will compare the local Realm with the Realm on the server and automatically transfer
+/// any changes from the local Realm that makes sense to the Realm provided by the server.
+/// {@category Sync}
+class RecoverSyncClientResetHandler extends SyncClientResetErrorHandler {
+ const RecoverSyncClientResetHandler(super.callback);
+}
+
+/// A client reset strategy that attempts to automatically recover any unsynchronized changes.
+/// If that fails, this handler fallsback to the discard unsynced changes strategy.
+///
+/// If you set [RecoverOrDiscardSyncClientResetHandler] callback as `syncClientResetErrorHandler` argument of [Configuration.flexibleSync],
+/// Realm will compare the local Realm with the Realm on the server and automatically transfer
+/// any changes from the local Realm that makes sense to the Realm provided by the server.
+/// If that fails, the local changes will be discarded.
+/// This is the default mode for fully synchronized Realms.
+/// {@category Sync}
+class RecoverOrDiscardSyncClientResetHandler extends SyncClientResetErrorHandler {
+ const RecoverOrDiscardSyncClientResetHandler(super.callback);
+
+}
+
+/// @nodoc
+extension SyncClientResetErrorHandlerInternal on SyncClientResetErrorHandler {
+ ClientResyncModeInternal get clientResyncMode {
+ if (this is ManualSyncClientResetHandler) {
+ return ClientResyncModeInternal.manual;
+ } else if (this is DiscardLocalSyncClientResetHandler) {
+ return ClientResyncModeInternal.discardLocal;
+ } else if (this is RecoverSyncClientResetHandler) {
+ return ClientResyncModeInternal.recover;
+ } else {
+ return ClientResyncModeInternal.recoverOrDiscard;
+ }
+ }
+}
+
+/// Enum describing what should happen in case of a Client Resync.
+/// @nodoc
+enum ClientResyncModeInternal {
+ manual,
+ discardLocal,
+ recover,
+ recoverOrDiscard,
+}

lib/src/native/realm_core.dart

@@ -211,13 +211,14 @@ class _RealmCore {
  final syncConfigPtr = _realmLib.invokeGetPointer(() => _realmLib.realm_flx_sync_config_new(config.user.handle._pointer));
  try {
  _realmLib.realm_sync_config_set_session_stop_policy(syncConfigPtr, config.sessionStopPolicy.index);
-
+ _realmLib.realm_sync_config_set_resync_mode(syncConfigPtr, config.syncClientResetErrorHandler.clientResyncMode.index);
  final errorHandlerCallback =
  Pointer.fromFunction<Void Function(Handle, Pointer<realm_sync_session_t>, realm_sync_error_t)>(_syncErrorHandlerCallback);
  final errorHandlerUserdata = _realmLib.realm_dart_userdata_async_new(config, errorHandlerCallback.cast(), scheduler.handle._pointer);
  _realmLib.realm_sync_config_set_error_handler(syncConfigPtr, _realmLib.addresses.realm_dart_sync_error_handler_callback, errorHandlerUserdata.cast(),
  _realmLib.addresses.realm_dart_userdata_async_free);
 
+
  _realmLib.realm_config_set_sync_config(configPtr, syncConfigPtr);
  } finally {
  _realmLib.realm_release(syncConfigPtr.cast());

lib/src/realm_class.dart

@@ -72,7 +72,11 @@ export "configuration.dart"
  SchemaObject,
  ShouldCompactCallback,
  SyncErrorHandler,
- SyncClientResetErrorHandler;
+ SyncClientResetErrorHandler,
+ ManualSyncClientResetHandler,
+ DiscardLocalSyncClientResetHandler,
+ RecoverSyncClientResetHandler,
+ RecoverOrDiscardSyncClientResetHandler;
 
 export 'credentials.dart' show Credentials, AuthProviderType, EmailPasswordAuthProvider;
 export 'list.dart' show RealmList, RealmListOfObject, RealmListChanges;

test/configuration_test.dart

@@ -22,6 +22,7 @@ import 'dart:math';
 import 'package:test/test.dart' hide test, throws;
 import 'package:path/path.dart' as path;
 import '../lib/realm.dart';
+import '../lib/src/configuration.dart' show SyncClientResetErrorHandlerInternal, ClientResyncModeInternal;
 import 'test.dart';
 
 Future<void> main([List<String>? args]) async {
@@ -530,4 +531,42 @@ Future<void> main([List<String>? args]) async {
  final disconnectedRealm = Realm(disconnectedSyncConfig);
  expect(disconnectedRealm.find<Task>(oid), isNotNull);
  });
+
+ baasTest("Configuration.flexibleSync set recoverOrDiscard as a default resync mode", (appConfiguration) async {
+ final app = App(appConfiguration);
+ final credentials = Credentials.anonymous();
+ final user = await app.logIn(credentials);
+ expect(
+ Configuration.flexibleSync(
+ user,
+ [Task.schema, Schedule.schema],
+ syncClientResetErrorHandler: ManualSyncClientResetHandler((syncError) {}),
+ ).syncClientResetErrorHandler.clientResyncMode,
+ ClientResyncModeInternal.manual);
+ expect(
+ Configuration.flexibleSync(
+ user,
+ [Task.schema, Schedule.schema],
+ syncClientResetErrorHandler: DiscardLocalSyncClientResetHandler((syncError) {}),
+ ).syncClientResetErrorHandler.clientResyncMode,
+ ClientResyncModeInternal.discardLocal);
+ expect(
+ Configuration.flexibleSync(
+ user,
+ [Task.schema, Schedule.schema],
+ syncClientResetErrorHandler: RecoverSyncClientResetHandler((syncError) {}),
+ ).syncClientResetErrorHandler.clientResyncMode,
+ ClientResyncModeInternal.recover);
+
+ expect(
+ Configuration.flexibleSync(
+ user,
+ [Task.schema, Schedule.schema],
+ syncClientResetErrorHandler: RecoverOrDiscardSyncClientResetHandler((syncError) {}),
+ ).syncClientResetErrorHandler.clientResyncMode,
+ ClientResyncModeInternal.recoverOrDiscard);
+
+ expect(Configuration.flexibleSync(user, [Task.schema, Schedule.schema]).syncClientResetErrorHandler.clientResyncMode,
+ ClientResyncModeInternal.recoverOrDiscard);
+ });
 }