Merge branch 'gh-392-support-getter-annotation' into 'main'

Support annotations on getters

See merge request objectbox/objectbox-dart!69

Author: greenrobot-team

generator/integration-tests/README.md

@@ -18,6 +18,11 @@ Each subdirectory contains a test case, a complete dart package (with some share
     but not removed between test-case runs
 * additionally, there may be `[0-9]-pre.dart` command-line apps, which are executed `dart N-pre.dart` - these may be 
 used to further prepare the environment **before** code generation for the step `N` is issued and `N.dart` test is run
+
+## Development
+
+To enable Dart Analysis, including code auto-complete, temporarily remove the `exclude` for this directory in
+the parent [analysis_options.yaml](../analysis_options.yaml).
 
 ## Troubleshooting
 

generator/integration-tests/getters/.gitignore

@@ -0,0 +1,8 @@
+# start with an empty project, without a objectbox-model.json
+objectbox-model.json
+testdata
+objectbox.*
+# Do not remove native library to allow running with non-globally installed version.
+!objectbox.dll
+!objectbox.lib
+!libobjectbox.*

generator/integration-tests/getters/1.dart

@@ -0,0 +1,41 @@
+import 'dart:io';
+
+import 'package:test/test.dart';
+
+import '../common.dart';
+import '../test_env.dart';
+import 'lib/lib.dart';
+import 'lib/objectbox.g.dart';
+
+void main() {
+  late TestEnv<AnnotatedGetters> env;
+  final jsonModel = readModelJson('lib');
+  final defs = getObjectBoxModel();
+  final model = defs.model;
+
+  setUp(() {
+    env = TestEnv<AnnotatedGetters>(defs);
+  });
+
+  tearDown(() {
+    env.close();
+  });
+
+  commonModelTests(defs, jsonModel);
+
+  test('project must be generated properly', () {
+    expect(TestEnv.dir.existsSync(), true);
+    expect(File('lib/objectbox.g.dart').existsSync(), true);
+    expect(File('lib/objectbox-model.json').existsSync(), true);
+  });
+
+  test('annotations from getters are read', () {
+    // @Property on getter changes type, @Index adds index flag
+    var prop = property(model, 'AnnotatedGetters.prop');
+    expect(prop.type, OBXPropertyType.Int);
+    expect(prop.flags, OBXPropertyFlags.INDEXED);
+    // @Transient on getter ignores property
+    expect(() => property(model, 'AnnotatedGetters.ignored'),
+        throwsA(isStateError));
+  });
+}

generator/integration-tests/getters/lib/lib.dart

@@ -0,0 +1,33 @@
+import 'package:objectbox/objectbox.dart';
+
+import 'objectbox.g.dart';
+
+/// Test annotations on getters are applied to properties when using
+/// getter + setter combos to create synthetic fields.
+@Entity()
+class AnnotatedGetters {
+  int _dummyId = 0;
+
+  // ID via annotation (not using auto-detected name id)
+  @Id()
+  int get customId => _dummyId;
+
+  set customId(int value) {
+    _dummyId = value;
+  }
+
+  int? _dummyProp;
+
+  // Customizing property via annotation
+  @Property(type: PropertyType.int)
+  @Index()
+  int? get prop => _dummyProp;
+
+  set prop(int? value) => _dummyProp = value;
+
+  // Ignore property via annotation
+  @Transient()
+  String? get ignored => "";
+
+  set ignored(String? value) {}
+}

generator/integration-tests/getters/pubspec.yaml

@@ -0,0 +1,21 @@
+name: objectbox_generator_test
+
+environment:
+  sdk: '>=2.18.0 <4.0.0'
+
+dependencies:
+  objectbox: any
+
+dev_dependencies:
+  objectbox_generator: any
+  test: any
+  build_runner: any
+  build_test: any
+  io: any
+  path: any
+
+dependency_overrides:
+  objectbox:
+    path: ../../../objectbox
+  objectbox_generator:
+    path: ../../

generator/lib/src/entity_resolver.dart

@@ -92,7 +92,13 @@ class EntityResolver extends Builder {
 
     // read all suitable annotated properties
     for (var f in classElement.fields) {
-      if (_transientChecker.hasAnnotationOfExact(f)) {
+      // The field might be implicitly defined by a getter, aka it is synthetic
+      // and does not exist in code. So always resolve the actual non-synthetic
+      // element that exists in code (here a getter) as only it will have any
+      // annotations.
+      final annotated = f.nonSynthetic;
+
+      if (_transientChecker.hasAnnotationOfExact(annotated)) {
         log.info("  Skipping property '${f.name}': annotated with @Transient.");
         continue;
       }
@@ -112,15 +118,16 @@ class EntityResolver extends Builder {
       var flags = 0;
       int? propUid;
 
-      _idChecker.runIfMatches(f, (annotation) {
+      // Check for @Id annotation
+      _idChecker.runIfMatches(annotated, (annotation) {
         flags |= OBXPropertyFlags.ID;
         if (annotation.getField('assignable')!.toBoolValue()!) {
           flags |= OBXPropertyFlags.ID_SELF_ASSIGNABLE;
         }
       });
 
       // Get info from @Property annotation
-      _propertyChecker.runIfMatches(f, (annotation) {
+      _propertyChecker.runIfMatches(annotated, (annotation) {
         propUid = annotation.getField('uid')!.toIntValue();
         fieldType = propertyTypeFromAnnotation(annotation.getField('type')!);
         if (!annotation.getField('signed')!.toBoolValue()!) {
@@ -156,7 +163,8 @@ class EntityResolver extends Builder {
             (f.type as ParameterizedType).typeArguments[0].element!.name;
       }
 
-      final backlinkAnnotations = _backlinkChecker.annotationsOfExact(f);
+      final backlinkAnnotations =
+          _backlinkChecker.annotationsOfExact(annotated);
       if (backlinkAnnotations.isNotEmpty) {
         if (!isToManyRel) {
           log.severe(
@@ -196,7 +204,8 @@ class EntityResolver extends Builder {
         }
 
         // Index and unique annotation.
-        processAnnotationIndexUnique(f, fieldType, classElement, prop);
+        processAnnotationIndexUnique(
+            f, annotated, fieldType, classElement, prop);
 
         // for code generation
         prop.dartFieldType =
@@ -339,12 +348,14 @@ class EntityResolver extends Builder {
     idProperty.flags &= ~OBXPropertyFlags.UNSIGNED;
   }
 
-  void processAnnotationIndexUnique(
-      FieldElement f, int? fieldType, Element elementBare, ModelProperty prop) {
+  void processAnnotationIndexUnique(FieldElement f, Element annotatedElement,
+      int? fieldType, Element elementBare, ModelProperty prop) {
     IndexType? indexType;
 
-    final indexAnnotation = _indexChecker.firstAnnotationOfExact(f);
-    final uniqueAnnotation = _uniqueChecker.firstAnnotationOfExact(f);
+    final indexAnnotation =
+        _indexChecker.firstAnnotationOfExact(annotatedElement);
+    final uniqueAnnotation =
+        _uniqueChecker.firstAnnotationOfExact(annotatedElement);
     if (indexAnnotation == null && uniqueAnnotation == null) return;
 
     // Throw if property type does not support any index.

objectbox/CHANGELOG.md

@@ -26,6 +26,20 @@
   // You can now just write:
   Order_.date.betweenMilliseconds(DateTime(2024, 1), DateTime(2024, 2))
   ```
+* When defining a property with a getter and setter instead of a field, support annotating the
+  getter to configure or ignore the property [#392](https://github.com/objectbox/objectbox-dart/issues/392)
+  
+  For example, it is now possible to do this:
+  ```dart
+  @Property(type: PropertyType.date)
+  @Index()
+  DateTime get date => TODO;
+  set date(DateTime value) => TODO;
+  
+  @Transient()
+  int get computedValue => TODO;
+  set computedValue(int value) => TODO;
+  ```
 
 ## 2.4.0 (2023-12-13)