Support RealmValue (aka mixed)

CHANGELOG.md

@@ -12,6 +12,7 @@
 * Add List.move extension method that moves an element from one index to another. Delegates to ManagedRealmList.move for managed lists. This allows notifications to correctly report moves, as opposed to reporting moves as deletes + inserts. ([#1037](https://github.com/realm/realm-dart/issues/1037))
 * Support setting `shouldDeleteIfMigrationNeeded` when creating a `Configuration.local`. ([#1049](https://github.com/realm/realm-dart/issues/1049))
 * Add `unknown` error code to all SyncErrors: `SyncSessionErrorCode.unknown`, `SyncConnectionErrorCode.unknown`, `SyncClientErrorCode.unknown`, `GeneralSyncErrorCode.unknown`. Use `unknown` error code instead of throwing a RealmError. ([#1052](https://github.com/realm/realm-dart/pull/1052))
+* Add support for `RealmValue` data type. This new type can represent any valid Realm data type, including objects. Lists of `RealmValue` are also supported, but `RealmValue` itself cannot contain collections. Please note that a property of type `RealmValue` cannot be nullable, but can contain null, represented by the value `RealmValue.nullValue()`. ([#1051](https://github.com/realm/realm-dart/pull/1051))
 
 ### Fixed
 * Support mapping into `SyncSessionErrorCode` for "Compensating write" with error code 231. ([#1022](https://github.com/realm/realm-dart/pull/1022))

common/lib/src/realm_types.dart

@@ -17,7 +17,6 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 import 'dart:ffi';
-import 'dart:typed_data';
 import 'package:objectid/objectid.dart';
 import 'package:sane_uuid/uuid.dart';
 
@@ -46,7 +45,7 @@ enum RealmPropertyType {
  _3, // ignore: unused_field, constant_identifier_names
  binary,
  _5, // ignore: unused_field, constant_identifier_names
- mixed,
+ mixed(Mapping<RealmValue>(indexable: true)),
  _7, // ignore: unused_field, constant_identifier_names
  timestamp(Mapping<DateTime>(indexable: true)),
  float,
@@ -104,35 +103,87 @@ class RealmStateError extends StateError implements RealmError {
 class Decimal128 {} // TODO Support decimal128 datatype https://github.com/realm/realm-dart/issues/725
 
 /// @nodoc
-class RealmObjectBaseMarker {}
+abstract class RealmObjectMarker {}
 
-/// @nodoc
-class RealmObjectMarker extends RealmObjectBaseMarker {}
-
-/// @nodoc
-class EmbeddedObjectMarker extends RealmObjectBaseMarker {}
-
-// Union type
-/// @nodoc
-class RealmAny {
- final dynamic value;
+/// A type that can represent any valid realm data type, except collections and embedded objects.
+///
+/// You can use [RealmValue] to declare fields on realm models, in which case it must be non-nullable,
+/// but it can wrap a null-value. List of [RealmValue] (`List<RealmValue>`) are also legal.
+///
+/// [RealmValue] fields can be [Indexed]
+///
+/// ```dart
+/// @RealmModel()
+/// class _AnythingGoes {
+/// @Indexed()
+/// late RealmValue any;
+/// late List<RealmValue> manyAny;
+/// }
+///
+/// void main() {
+/// final realm = Realm(Configuration.local([AnythingGoes.schema]));
+/// realm.write(() {
+/// final something = realm.add(AnythingGoes(any: RealmValue.string('text')));
+/// something.manyAny.addAll([
+/// null,
+/// true,
+/// 'text',
+/// 42,
+/// 3.14,
+/// ].map(RealmValue.from));
+/// });
+/// }
+/// ```
+class RealmValue {
+ final Object? value;
+ Type get type => value.runtimeType;
  T as<T>() => value as T; // better for code completion
 
  // This is private, so user cannot accidentally construct an invalid instance
- const RealmAny._(this.value);
-
- const RealmAny.bool(bool b) : this._(b);
- const RealmAny.string(String text) : this._(text);
- const RealmAny.int(int i) : this._(i);
- const RealmAny.float(Float f) : this._(f);
- const RealmAny.double(double d) : this._(d);
- const RealmAny.uint8List(Uint8List data) : this._(data);
+ const RealmValue._(this.value);
+
+ const RealmValue.nullValue() : this._(null);
+ const RealmValue.bool(bool b) : this._(b);
+ const RealmValue.string(String text) : this._(text);
+ const RealmValue.int(int i) : this._(i);
+ const RealmValue.double(double d) : this._(d);
  // TODO: RealmObjectMarker introduced to avoid dependency inversion. It would be better if we could use RealmObject directly. https://github.com/realm/realm-dart/issues/701
- const RealmAny.realmObject(RealmObjectBaseMarker o) : this._(o);
- const RealmAny.dateTime(DateTime timestamp) : this._(timestamp);
- const RealmAny.objectId(ObjectId id) : this._(id);
- const RealmAny.decimal128(Decimal128 decimal) : this._(decimal);
- const RealmAny.uuid(Uuid uuid) : this._(uuid);
+ const RealmValue.realmObject(RealmObjectMarker o) : this._(o);
+ const RealmValue.dateTime(DateTime timestamp) : this._(timestamp);
+ const RealmValue.objectId(ObjectId id) : this._(id);
+ // const RealmValue.decimal128(Decimal128 decimal) : this._(decimal); // not supported yet
+ const RealmValue.uuid(Uuid uuid) : this._(uuid);
+
+ /// Will throw [ArgumentError]
+ factory RealmValue.from(Object? o) {
+ if (o == null ||
+ o is bool ||
+ o is String ||
+ o is int ||
+ o is Float ||
+ o is double ||
+ o is RealmObjectMarker ||
+ o is DateTime ||
+ o is ObjectId ||
+ // o is Decimal128 || // not supported yet
+ o is Uuid) {
+ return RealmValue._(o);
+ } else {
+ throw ArgumentError.value(o, 'o', 'Unsupported type');
+ }
+ }
+
+ @override
+ operator ==(Object? other) {
+ if (other is RealmValue) {
+ return value == other.value;
+ } else {
+ return value == other;
+ }
+ }
+
+ @override
+ int get hashCode => value.hashCode;
 }
 
 /// The category of a [SyncError].

generator/lib/src/dart_type_ex.dart

@@ -30,7 +30,7 @@ import 'type_checkers.dart';
 extension DartTypeEx on DartType {
  bool isExactly<T>() => TypeChecker.fromRuntime(T).isExactlyType(this);
 
- bool get isRealmAny => const TypeChecker.fromRuntime(RealmAny).isAssignableFromType(this);
+ bool get isRealmValue => const TypeChecker.fromRuntime(RealmValue).isAssignableFromType(this);
  bool get isRealmCollection => realmCollectionType != RealmCollectionType.none;
  bool get isRealmModel => element2 != null ? realmModelChecker.annotationsOfExact(element2!).isNotEmpty : false;
 
@@ -108,7 +108,7 @@ extension DartTypeEx on DartType {
  if (isDartCoreBool) return RealmPropertyType.bool;
  if (isDartCoreString) return RealmPropertyType.string;
  if (isExactly<Uint8List>()) return RealmPropertyType.binary;
- if (isRealmAny) return RealmPropertyType.mixed;
+ if (isRealmValue) return RealmPropertyType.mixed;
  if (isExactly<DateTime>()) return RealmPropertyType.timestamp;
  if (isExactly<Float>()) return RealmPropertyType.float;
  if (isDartCoreNum || isDartCoreDouble) return RealmPropertyType.double;

generator/lib/src/field_element_ex.dart

@@ -84,7 +84,6 @@ extension FieldElementEx on FieldElement {
  // Check for as-of-yet unsupported type
  if (type.isDartCoreSet || //
  type.isDartCoreMap ||
- type.isRealmAny ||
  type.isExactly<Decimal128>()) {
  throw RealmInvalidGenerationSourceError(
  'Field type not supported yet',
@@ -134,12 +133,12 @@ extension FieldElementEx on FieldElement {
 
  // Validate indexes
  if ((((primaryKey ?? indexed) != null) && !(type.realmType?.mapping.indexable ?? false)) || //
- (primaryKey != null && type.isDartCoreBool)) {
+ (primaryKey != null && (type.isDartCoreBool || type.isExactly<RealmValue>()))) {
  final file = span!.file;
  final annotation = (primaryKey ?? indexed)!.annotation;
  final listOfValidTypes = RealmPropertyType.values //
  .map((t) => t.mapping)
- .where((m) => m.indexable && (m.type != bool || primaryKey == null))
+ .where((m) => m.indexable && ((m.type != bool && m.type != RealmValue) || primaryKey == null))
  .map((m) => m.type);
 
  throw RealmInvalidGenerationSourceError(
@@ -262,6 +261,17 @@ extension FieldElementEx on FieldElement {
  );
  }
  }
+
+ // Validate mixed (RealmValue)
+ else if (realmType == RealmPropertyType.mixed && type.isNullable) {
+ throw RealmInvalidGenerationSourceError(
+ 'RealmValue fields cannot be nullable',
+ primarySpan: typeSpan(file),
+ primaryLabel: '$modelTypeName is nullable',
+ todo: 'Change type to ${modelType.asNonNullable}',
+ element: this,
+ );
+ }
  }
 
  return RealmFieldInfo(

generator/lib/src/realm_field_info.dart

@@ -46,9 +46,10 @@ class RealmFieldInfo {
  bool get isRealmCollection => type.isRealmCollection;
  bool get isLate => fieldElement.isLate;
  bool get hasDefaultValue => fieldElement.hasInitializer;
- bool get optional => type.basicType.isNullable;
+ bool get optional => type.basicType.isNullable || realmType == RealmPropertyType.mixed;
  bool get isRequired => !(hasDefaultValue || optional);
  bool get isRealmBacklink => realmType == RealmPropertyType.linkingObjects;
+ bool get isMixed => realmType == RealmPropertyType.mixed;
  bool get isComputed => isRealmBacklink; // only computed, so far
 
  String get name => fieldElement.name;

generator/lib/src/realm_model_info.dart

@@ -48,10 +48,13 @@ class RealmModelInfo {
  yield* required.map((f) => '${f.mappedTypeName} ${f.name},');
 
  final notRequired = allSettable.where((f) => !f.isRequired && !f.isPrimaryKey);
- final collections = fields.where((f) => f.type.isRealmCollection).toList();
+ final collections = fields.where((f) => f.isRealmCollection).toList();
  if (notRequired.isNotEmpty || collections.isNotEmpty) {
  yield '{';
- yield* notRequired.map((f) => '${f.mappedTypeName} ${f.name}${f.hasDefaultValue ? ' = ${f.fieldElement.initializerExpression}' : ''},');
+ yield* notRequired.map(
+ (f) =>
+ '${f.mappedTypeName} ${f.name}${f.hasDefaultValue ? ' = ${f.fieldElement.initializerExpression}' : (f.isMixed ? ' = const RealmValue.nullValue()' : '')},',
+ );
  yield* collections.map((c) => 'Iterable<${c.type.basicMappedName}> ${c.name} = const [],');
  yield '}';
  }

generator/test/error_test_data/not_an_indexable_type.expected

@@ -1,5 +1,5 @@
 Realm only supports the @Indexed() annotation on fields of type
-int, bool, String, DateTime, ObjectId, Uuid
+int, bool, String, RealmValue, DateTime, ObjectId, Uuid
 as well as their nullable versions
 
 in: asset:pkg/test/error_test_data/not_an_indexable_type.dart:8:8

generator/test/error_test_data/nullable_realm_value.dart

@@ -0,0 +1,8 @@
+import 'package:realm_common/realm_common.dart';
+
+//part 'nullable_list.g.dart';
+
+@RealmModel()
+class _Bad {
+ RealmValue? wrong;
+}

generator/test/error_test_data/nullable_realm_value.expected

@@ -0,0 +1,12 @@
+RealmValue fields cannot be nullable
+
+in: asset:pkg/test/error_test_data/nullable_realm_value.dart:7:3
+ ╷
+5 │ @RealmModel()
+6 │ class _Bad {
+ │ ━━━━ in realm model for 'Bad'
+7 │ RealmValue? wrong;
+ │ ^^^^^^^^^^^ RealmValue? is nullable
+ ╵
+Change type to RealmValue
+

generator/test/good_test_data/all_types.dart

@@ -17,7 +17,6 @@ class _Bar {
  @Indexed()
  late bool aBool, another; // both are indexed!
  var data = Uint8List(16);
- // late RealmAny any; // not supported yet
  @MapTo('tidspunkt')
  @Indexed()
  var timestamp = DateTime.now();
@@ -39,6 +38,9 @@ class _Bar {
 
  @Backlink(#bar)
  late Iterable<_Foo> foos;
+
+ late RealmValue any;
+ late List<RealmValue> manyAny;
 }
 
 @RealmModel()

generator/test/good_test_data/all_types.expected

@@ -56,14 +56,16 @@ class Bar extends _Bar with RealmEntity, RealmObjectBase, RealmObject {
  String name,
  bool aBool,
  bool another,
- ObjectId objectId, 
+ ObjectId objectId,
  Uuid uuid, {
  Uint8List data = Uint8List(16),
  DateTime timestamp = DateTime.now(),
  double aDouble = 0.0,
  Foo? foo,
  String? anOptionalString,
+ RealmValue any = const RealmValue.nullValue(),
  Iterable<int> list = const [],
+ Iterable<RealmValue> manyAny = const [],
  }) {
  if (!_defaultsSet) {
  _defaultsSet = RealmObjectBase.setDefaults<Bar>({
@@ -82,7 +84,10 @@ class Bar extends _Bar with RealmEntity, RealmObjectBase, RealmObject {
  RealmObjectBase.set(this, 'objectId', objectId);
  RealmObjectBase.set(this, 'uuid', uuid);
  RealmObjectBase.set(this, 'anOptionalString', anOptionalString);
+ RealmObjectBase.set(this, 'any', any);
  RealmObjectBase.set<RealmList<int>>(this, 'list', RealmList<int>(list));
+ RealmObjectBase.set<RealmList<RealmValue>>(
+ this, 'manyAny', RealmList<RealmValue>(manyAny));
  }
 
  Bar._();
@@ -132,8 +137,7 @@ class Bar extends _Bar with RealmEntity, RealmObjectBase, RealmObject {
  set objectId(ObjectId value) => RealmObjectBase.set(this, 'objectId', value);
 
  @override
- Uuid get uuid =>
- RealmObjectBase.get<Uuid>(this, 'uuid') as Uuid;
+ Uuid get uuid => RealmObjectBase.get<Uuid>(this, 'uuid') as Uuid;
  @override
  set uuid(Uuid value) => RealmObjectBase.set(this, 'uuid', value);
 
@@ -150,11 +154,24 @@ class Bar extends _Bar with RealmEntity, RealmObjectBase, RealmObject {
  set anOptionalString(String? value) =>
  RealmObjectBase.set(this, 'anOptionalString', value);
 
+ @override
+ RealmValue get any =>
+ RealmObjectBase.get<RealmValue>(this, 'any') as RealmValue;
+ @override
+ set any(RealmValue value) => RealmObjectBase.set(this, 'any', value);
+
+ @override
+ RealmList<RealmValue> get manyAny =>
+ RealmObjectBase.get<RealmValue>(this, 'manyAny') as RealmList<RealmValue>;
+ @override
+ set manyAny(covariant RealmList<RealmValue> value) =>
+ throw RealmUnsupportedSetError();
+
  @override
  RealmResults<Foo> get foos =>
  RealmObjectBase.get<Foo>(this, 'foos') as RealmResults<Foo>;
  @override
- set foos(covariant RealmResults<Foo> value) => 
+ set foos(covariant RealmResults<Foo> value) =>
  throw RealmUnsupportedSetError();
 
  @override
@@ -184,6 +201,9 @@ class Bar extends _Bar with RealmEntity, RealmObjectBase, RealmObject {
  collectionType: RealmCollectionType.list),
  SchemaProperty('anOptionalString', RealmPropertyType.string,
  optional: true, indexed: true),
+ SchemaProperty('any', RealmPropertyType.mixed, optional: true),
+ SchemaProperty('manyAny', RealmPropertyType.mixed,
+ optional: true, collectionType: RealmCollectionType.list),
  SchemaProperty('foos', RealmPropertyType.linkingObjects,
  linkOriginProperty: 'bar',
  collectionType: RealmCollectionType.list,
@@ -263,4 +283,3 @@ class PrimitiveTypes extends _PrimitiveTypes
  ]);
  }
 }
-

lib/src/list.dart

@@ -111,12 +111,23 @@ class ManagedRealmList<T extends Object?> with RealmEntity, ListMixin<T> impleme
  }
 
  try {
- final value = realmCore.listGetElementAt(this, index);
-
+ var value = realmCore.listGetElementAt(this, index);
  if (value is RealmObjectHandle) {
- return realm.createObject(T, value, _metadata!) as T;
+ late RealmObjectMetadata targetMetadata;
+ late Type type;
+ if (T == RealmValue) {
+ final tuple = realm.metadata.getByClassKey(realmCore.getClassKey(value));
+ type = tuple.item1;
+ targetMetadata = tuple.item2;
+ } else {
+ targetMetadata = _metadata!;
+ type = T;
+ }
+ value = realm.createObject(type, value, targetMetadata);
+ }
+ if (T == RealmValue) {
+ value = RealmValue.from(value);
  }
-
  return value as T;
  } on Exception catch (e) {
  throw RealmException("Error getting value at index $index. Error: $e");
@@ -277,6 +288,10 @@ extension RealmListInternal<T extends Object?> on RealmList<T> {
  return;
  }
 
+ if (value is RealmValue) {
+ value = value.value;
+ }
+
  if (value is RealmObject && !value.isManaged) {
  realm.add<RealmObject>(value, update: update);
  }