RDART-1010: Allow configuration of generator per realm model class

CHANGELOG.md

@@ -1,7 +1,25 @@
 ## vNext (TBD)
 
 ### Enhancements
-* None
+* Allow configuration of generator per model class. Currently support specifying the constructor style to use. 
+  ```dart
+  const config = GeneratorConfig(ctorStyle: CtorStyle.allNamed);
+  const realmModel = RealmModel.using(baseType: ObjectType.realmObject, generatorConfig: config);
+
+  @realmModel
+  class _Person {
+    late String name;
+    int age = 42;
+  }
+  ```
+  will generate a constructor like:
+  ```dart
+  Person({
+    required String name,
+    int age = 42,
+  }) { ... }
+  ```
+  (Issue [#292](https://github.com/realm/realm-dart/issues/292))
 
 ### Fixed
 * None

packages/realm_common/lib/src/realm_common_base.dart

@@ -20,10 +20,9 @@ enum ObjectType {
   /// to query or modify it.
   asymmetricObject('AsymmetricObject', 2);
 
-  const ObjectType([this._className = 'Unknown', this._flags = -1]);
+  const ObjectType(this._className, this._flags);
 
   final String _className;
-
   final int _flags;
 }
 
@@ -33,15 +32,49 @@ extension ObjectTypeInternal on ObjectType {
   String get className => _className;
 }
 
+/// An enum controlling the constructor type generated for a [RealmModel].
+enum CtorStyle {
+  /// Generate a constructor with only optional parameters named.
+  /// All required parameters will be positional.
+  /// This is the default, unless overridden in the build config.
+  onlyOptionalNamed,
+
+  /// Generate a constructor with all parameters named.
+  allNamed,
+}
+
+/// Class used to define the desired constructor behavior for a [RealmModel].
+///
+/// {@category Annotations}
+class GeneratorConfig {
+  /// The style to use for the generated constructor
+  final CtorStyle ctorStyle;
+
+  const GeneratorConfig({this.ctorStyle = CtorStyle.onlyOptionalNamed});
+}
+
 /// Annotation class used to define `Realm` data model classes and their properties
 ///
 /// {@category Annotations}
 class RealmModel {
-  /// The base type of the object
-  final ObjectType type;
-
-  /// Creates a new instance of [RealmModel] specifying the desired base type.
-  const RealmModel([this.type = ObjectType.realmObject]);
+  /// The base type of the generated object class
+  final ObjectType baseType;
+
+  /// The generator configuration to use for this model
+  final GeneratorConfig generatorConfig;
+
+  // NOTE: To avoid a breaking change, we keep this old constructor and add a new one
+  /// Creates a new instance of [RealmModel] optionally specifying the [baseType].
+  const RealmModel([
+    ObjectType baseType = ObjectType.realmObject,
+  ]) : this.using(baseType: baseType);
+
+  /// Creates a new instance of [RealmModel] optionally specifying the [baseType]
+  /// and [generatorConfig].
+  const RealmModel.using({
+    this.baseType = ObjectType.realmObject,
+    this.generatorConfig = const GeneratorConfig(),
+  });
 }
 
 /// MapTo annotation for class level and class member level.

packages/realm_common/lib/src/realm_types.dart

@@ -85,18 +85,12 @@ enum RealmCollectionType {
   _3, // ignore: unused_field, constant_identifier_names
   map;
 
-  String get plural {
-    switch (this) {
-      case RealmCollectionType.list:
-        return "lists";
-      case RealmCollectionType.set:
-        return "sets";
-      case RealmCollectionType.map:
-        return "maps";
-      default:
-        return "none";
-    }
-  }
+  String get plural => switch (this) {
+      RealmCollectionType.list => 'lists',
+      RealmCollectionType.set => 'sets',
+      RealmCollectionType.map => 'maps',
+      _ => 'none'
+    };
 }
 
 /// A base class of all Realm errors.

packages/realm_generator/lib/src/class_element_ex.dart

@@ -202,7 +202,19 @@ extension ClassElementEx on ClassElement {
         }
       }
 
-      return RealmModelInfo(name, modelName, realmName, mappedFields, objectType);
+      // Get the generator configuration
+      final index = realmModelInfo?.value.getField('generatorConfig')?.getField('ctorStyle')?.getField('index')?.toIntValue();
+      final ctorStyle = index != null ? CtorStyle.values[index] : CtorStyle.onlyOptionalNamed;
+      final config = GeneratorConfig(ctorStyle: ctorStyle);
+
+      return RealmModelInfo(
+        name,
+        modelName,
+        realmName,
+        mappedFields,
+        objectType,
+        config,
+      );
     } on InvalidGenerationSourceError catch (_) {
       rethrow;
     } catch (e, s) {

packages/realm_generator/lib/src/dart_type_ex.dart

@@ -24,7 +24,7 @@ extension DartTypeEx on DartType {
     if (element == null) return null;
     final realmModelAnnotation = realmModelChecker.firstAnnotationOfExact(element!);
     if (realmModelAnnotation == null) return null; // not a RealmModel
-    final index = realmModelAnnotation.getField('type')!.getField('index')!.toIntValue()!;
+    final index = realmModelAnnotation.getField('baseType')!.getField('index')!.toIntValue()!;
     return ObjectType.values[index];
   }
 

packages/realm_generator/lib/src/realm_model_info.dart

@@ -11,14 +11,26 @@ extension<T> on Iterable<T> {
   Iterable<T> except(bool Function(T) test) => where((e) => !test(e));
 }
 
+extension on String {
+  String nonPrivate() => startsWith('_') ? substring(1) : this;
+}
+
 class RealmModelInfo {
   final String name;
   final String modelName;
   final String realmName;
   final List<RealmFieldInfo> fields;
   final ObjectType baseType;
+  final GeneratorConfig config;
 
-  const RealmModelInfo(this.name, this.modelName, this.realmName, this.fields, this.baseType);
+  const RealmModelInfo(
+    this.name,
+    this.modelName,
+    this.realmName,
+    this.fields,
+    this.baseType,
+    this.config,
+  );
 
   Iterable<String> toCode() sync* {
     yield 'class $name extends $modelName with RealmEntity, RealmObjectBase, ${baseType.className} {';
@@ -32,26 +44,29 @@ class RealmModelInfo {
         yield '';
       }
 
-      bool requiredCondition(RealmFieldInfo f) => f.isRequired || f.isPrimaryKey;
-      final required = allSettable.where(requiredCondition);
-      final notRequired = allSettable.except(requiredCondition);
+      bool required(RealmFieldInfo f) => f.isRequired || f.isPrimaryKey;
+      bool usePositional(RealmFieldInfo f) => config.ctorStyle == CtorStyle.allNamed ? false : required(f);
+      String paramName(RealmFieldInfo f) => usePositional(f) ? f.name : f.name.nonPrivate();
+      final positional = allSettable.where(usePositional);
+      final named = allSettable.except(usePositional);
 
       // Constructor
       yield '$name(';
       {
-        yield* required.map((f) => '${f.mappedTypeName} ${f.name},');
-        if (notRequired.isNotEmpty) {
+        yield* positional.map((f) => '${f.mappedTypeName} ${paramName(f)},');
+        if (named.isNotEmpty) {
           yield '{';
-          yield* notRequired.map((f) {
-            if (f.isRealmCollection) {
-              final collectionPrefix = f.type.isDartCoreList
-                  ? 'Iterable<'
-                  : f.type.isDartCoreSet
-                      ? 'Set<'
-                      : 'Map<String, ';
-              return '$collectionPrefix${f.type.basicMappedName}> ${f.name}${f.initializer},';
-            }
-            return '${f.mappedTypeName} ${f.name}${f.initializer},';
+          yield* named.map((f) {
+            final requiredPrefix = required(f) ? 'required ' : '';
+            final param = paramName(f);
+            final collectionPrefix = switch (f) {
+              _ when f.isDartCoreList => 'Iterable<',
+              _ when f.isDartCoreSet => 'Set<',
+              _ when f.isDartCoreMap => 'Map<String,',
+              _ => '',
+            };
+            final typePrefix = f.isRealmCollection ? '$collectionPrefix${f.type.basicMappedName}>' : f.mappedTypeName;
+            return '$requiredPrefix$typePrefix $param${f.initializer},';
           });
           yield '}';
         }
@@ -67,13 +82,14 @@ class RealmModelInfo {
         }
 
         yield* allSettable.map((f) {
+          final param = paramName(f);
           if (f.type.isUint8List && f.hasDefaultValue) {
-            return "RealmObjectBase.set(this, '${f.realmName}', ${f.name} ?? ${f.fieldElement.initializerExpression});";
+            return "RealmObjectBase.set(this, '${f.realmName}', $param ?? ${f.fieldElement.initializerExpression});";
           }
           if (f.isRealmCollection) {
-            return "RealmObjectBase.set<${f.mappedTypeName}>(this, '${f.realmName}', ${f.mappedTypeName}(${f.name}));";
+            return "RealmObjectBase.set<${f.mappedTypeName}>(this, '${f.realmName}', ${f.mappedTypeName}($param));";
           }
-          return "RealmObjectBase.set(this, '${f.realmName}', ${f.name});";
+          return "RealmObjectBase.set(this, '${f.realmName}', $param);";
         });
       }
       yield '}';
@@ -129,8 +145,8 @@ class RealmModelInfo {
           }
           yield '} => $name(';
           {
-            yield* required.map((f) => 'fromEJson(${f.name}),');
-            yield* notRequired.map((f) => '${f.name}: fromEJson(${f.name}),');
+            yield* positional.map((f) => 'fromEJson(${f.name}),');
+            yield* named.map((f) => '${f.name}: fromEJson(${f.name}),');
           }
           yield '),';
           yield '_ => raiseInvalidEJson(ejson),';

packages/realm_generator/test/good_test_data/all_named_ctor.dart

@@ -0,0 +1,12 @@
+import 'package:realm_common/realm_common.dart';
+
+part 'all_named_ctor.realm.dart';
+
+const config = GeneratorConfig(ctorStyle: CtorStyle.allNamed);
+const realmModel = RealmModel.using(baseType: ObjectType.realmObject, generatorConfig: config);
+
+@realmModel
+class _Person {
+  late String name;
+  int age = 42;
+}

packages/realm_generator/test/good_test_data/all_named_ctor.expected

@@ -0,0 +1,82 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'all_named_ctor.dart';
+
+// **************************************************************************
+// RealmObjectGenerator
+// **************************************************************************
+
+// ignore_for_file: type=lint
+class Person extends _Person with RealmEntity, RealmObjectBase, RealmObject {
+  static var _defaultsSet = false;
+
+  Person({
+    required String name,
+    int age = 42,
+  }) {
+    if (!_defaultsSet) {
+      _defaultsSet = RealmObjectBase.setDefaults<Person>({
+        'age': 42,
+      });
+    }
+    RealmObjectBase.set(this, 'name', name);
+    RealmObjectBase.set(this, 'age', age);
+  }
+
+  Person._();
+
+  @override
+  String get name => RealmObjectBase.get<String>(this, 'name') as String;
+  @override
+  set name(String value) => RealmObjectBase.set(this, 'name', value);
+
+  @override
+  int get age => RealmObjectBase.get<int>(this, 'age') as int;
+  @override
+  set age(int value) => RealmObjectBase.set(this, 'age', value);
+
+  @override
+  Stream<RealmObjectChanges<Person>> get changes =>
+      RealmObjectBase.getChanges<Person>(this);
+
+  @override
+  Stream<RealmObjectChanges<Person>> changesFor([List<String>? keyPaths]) =>
+      RealmObjectBase.getChangesFor<Person>(this, keyPaths);
+
+  @override
+  Person freeze() => RealmObjectBase.freezeObject<Person>(this);
+
+  EJsonValue toEJson() {
+    return <String, dynamic>{
+      'name': name.toEJson(),
+      'age': age.toEJson(),
+    };
+  }
+
+  static EJsonValue _toEJson(Person value) => value.toEJson();
+  static Person _fromEJson(EJsonValue ejson) {
+    return switch (ejson) {
+      {
+        'name': EJsonValue name,
+        'age': EJsonValue age,
+      } =>
+        Person(
+          name: fromEJson(name),
+          age: fromEJson(age),
+        ),
+      _ => raiseInvalidEJson(ejson),
+    };
+  }
+
+  static final schema = () {
+    RealmObjectBase.registerFactory(Person._);
+    register(_toEJson, _fromEJson);
+    return SchemaObject(ObjectType.realmObject, Person, 'Person', [
+      SchemaProperty('name', RealmPropertyType.string),
+      SchemaProperty('age', RealmPropertyType.int),
+    ]);
+  }();
+
+  @override
+  SchemaObject get objectSchema => RealmObjectBase.getSchema(this) ?? schema;
+}

packages/realm_generator/test/good_test_data/all_named_ctor.realm.dart

@@ -0,0 +1,2 @@
+
+part of 'all_named_ctor.dart';

packages/realm_generator/test/good_test_data/private_fields.expected

@@ -13,15 +13,15 @@ class WithPrivateFields extends _WithPrivateFields
 
   WithPrivateFields(
     String _plain, {
-    int _withDefault = 0,
+    int withDefault = 0,
   }) {
     if (!_defaultsSet) {
       _defaultsSet = RealmObjectBase.setDefaults<WithPrivateFields>({
         '_withDefault': 0,
       });
     }
     RealmObjectBase.set(this, '_plain', _plain);
-    RealmObjectBase.set(this, '_withDefault', _withDefault);
+    RealmObjectBase.set(this, '_withDefault', withDefault);
   }
 
   WithPrivateFields._();