Feat: Fügt eine 1:n Beziehung zwischen RecurringTransaction und Transaction hinzu

lib/Entities/recurring_transaction.g.dart

@@ -18,8 +18,16 @@ const RecurringTransactionSchema = CollectionSchema(
   name: r'RecurringTransaction',
   id: 969840479390105118,
   properties: {
-    r'amount': PropertySchema(id: 0, name: r'amount', type: IsarType.double),
-    r'name': PropertySchema(id: 1, name: r'name', type: IsarType.string),
+    r'amount': PropertySchema(
+      id: 0,
+      name: r'amount',
+      type: IsarType.double,
+    ),
+    r'name': PropertySchema(
+      id: 1,
+      name: r'name',
+      type: IsarType.string,
+    ),
     r'startDate': PropertySchema(
       id: 2,
       name: r'startDate',
@@ -30,7 +38,7 @@ const RecurringTransactionSchema = CollectionSchema(
       name: r'timeFrame',
       type: IsarType.byte,
       enumMap: _RecurringTransactiontimeFrameEnumValueMap,
-    ),
+    )
   },
   estimateSize: _recurringTransactionEstimateSize,
   serialize: _recurringTransactionSerialize,
@@ -38,7 +46,15 @@ const RecurringTransactionSchema = CollectionSchema(
   deserializeProp: _recurringTransactionDeserializeProp,
   idName: r'id',
   indexes: {},
-  links: {},
+  links: {
+    r'transactions': LinkSchema(
+      id: 459560147514286496,
+      name: r'transactions',
+      target: r'Transaction',
+      single: false,
+      linkName: r'recurringTransaction',
+    )
+  },
   embeddedSchemas: {},
   getId: _recurringTransactionGetId,
   getLinks: _recurringTransactionGetLinks,
@@ -79,10 +95,8 @@ RecurringTransaction _recurringTransactionDeserialize(
   object.id = id;
   object.name = reader.readString(offsets[1]);
   object.startDate = reader.readDateTimeOrNull(offsets[2]);
-  object.timeFrame =
-      _RecurringTransactiontimeFrameValueEnumMap[reader.readByteOrNull(
-        offsets[3],
-      )] ??
+  object.timeFrame = _RecurringTransactiontimeFrameValueEnumMap[
+  reader.readByteOrNull(offsets[3])] ??
       TimeFrameEnum.daily;
   return object;
 }
@@ -101,11 +115,9 @@ P _recurringTransactionDeserializeProp<P>(
     case 2:
       return (reader.readDateTimeOrNull(offset)) as P;
     case 3:
-      return (_RecurringTransactiontimeFrameValueEnumMap[reader.readByteOrNull(
-                offset,
-              )] ??
-              TimeFrameEnum.daily)
-          as P;
+      return (_RecurringTransactiontimeFrameValueEnumMap[
+      reader.readByteOrNull(offset)] ??
+          TimeFrameEnum.daily) as P;
     default:
       throw IsarError('Unknown property with id $propertyId');
   }
@@ -129,17 +141,15 @@ Id _recurringTransactionGetId(RecurringTransaction object) {
 }
 
 List<IsarLinkBase<dynamic>> _recurringTransactionGetLinks(
-  RecurringTransaction object,
-) {
-  return [];
+    RecurringTransaction object) {
+  return [object.transactions];
 }
 
-void _recurringTransactionAttach(
-  IsarCollection<dynamic> col,
-  Id id,
-  RecurringTransaction object,
-) {
+void _recurringTransactionAttach(IsarCollection<dynamic> col, Id id,
+    RecurringTransaction object) {
   object.id = id;
+  object.transactions
+      .attach(col, col.isar.collection<Transaction>(), r'transactions', id);
 }
 
 extension RecurringTransactionQueryWhereSort
@@ -157,7 +167,10 @@ extension RecurringTransactionQueryWhere
   QueryBuilder<RecurringTransaction, RecurringTransaction, QAfterWhereClause>
   idEqualTo(Id id) {
     return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(IdWhereClause.between(lower: id, upper: id));
+      return query.addWhereClause(IdWhereClause.between(
+        lower: id,
+        upper: id,
+      ));
     });
   }
 
@@ -210,92 +223,70 @@ extension RecurringTransactionQueryWhere
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(
-        IdWhereClause.between(
-          lower: lowerId,
-          includeLower: includeLower,
-          upper: upperId,
-          includeUpper: includeUpper,
-        ),
-      );
+      return query.addWhereClause(IdWhereClause.between(
+        lower: lowerId,
+        includeLower: includeLower,
+        upper: upperId,
+        includeUpper: includeUpper,
+      ));
     });
   }
 }
 
-extension RecurringTransactionQueryFilter
-    on
-        QueryBuilder<
-          RecurringTransaction,
-          RecurringTransaction,
-          QFilterCondition
-        > {
-  QueryBuilder<
+extension RecurringTransactionQueryFilter on QueryBuilder<RecurringTransaction,
     RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  amountEqualTo(double value, {double epsilon = Query.epsilon}) {
+    QFilterCondition> {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> amountEqualTo(double value, {
+    double epsilon = Query.epsilon,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(
-          property: r'amount',
-          value: value,
-          epsilon: epsilon,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'amount',
+        value: value,
+        epsilon: epsilon,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  amountGreaterThan(
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> amountGreaterThan(
     double value, {
     bool include = false,
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'amount',
-          value: value,
-          epsilon: epsilon,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'amount',
+        value: value,
+        epsilon: epsilon,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  amountLessThan(
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> amountLessThan(
     double value, {
     bool include = false,
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'amount',
-          value: value,
-          epsilon: epsilon,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'amount',
+        value: value,
+        epsilon: epsilon,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  amountBetween(
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> amountBetween(
     double lower,
     double upper, {
     bool includeLower = true,
@@ -303,157 +294,126 @@ extension RecurringTransactionQueryFilter
     double epsilon = Query.epsilon,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.between(
-          property: r'amount',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-          epsilon: epsilon,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'amount',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+        epsilon: epsilon,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  idEqualTo(Id value) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> idEqualTo(Id value) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'id', value: value),
-      );
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'id',
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  idGreaterThan(Id value, {bool include = false}) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> idGreaterThan(Id value, {
+    bool include = false,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'id',
-          value: value,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'id',
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  idLessThan(Id value, {bool include = false}) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> idLessThan(Id value, {
+    bool include = false,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'id',
-          value: value,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'id',
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  idBetween(
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> idBetween(
     Id lower,
     Id upper, {
     bool includeLower = true,
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.between(
-          property: r'id',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'id',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  nameEqualTo(String value, {bool caseSensitive = true}) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> nameEqualTo(String value, {
+    bool caseSensitive = true,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'name',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  nameGreaterThan(
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> nameGreaterThan(
     String value, {
     bool include = false,
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'name',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  nameLessThan(
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> nameLessThan(
     String value, {
     bool include = false,
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'name',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  nameBetween(
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> nameBetween(
     String lower,
     String upper, {
     bool includeLower = true,
@@ -461,297 +421,302 @@ extension RecurringTransactionQueryFilter
     bool caseSensitive = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.between(
-          property: r'name',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-          caseSensitive: caseSensitive,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'name',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+        caseSensitive: caseSensitive,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  nameStartsWith(String value, {bool caseSensitive = true}) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> nameStartsWith(String value, {
+    bool caseSensitive = true,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.startsWith(
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.startsWith(
+        property: r'name',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  nameEndsWith(String value, {bool caseSensitive = true}) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> nameEndsWith(String value, {
+    bool caseSensitive = true,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.endsWith(
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.endsWith(
+        property: r'name',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition>
   nameContains(String value, {bool caseSensitive = true}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.contains(
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.contains(
+        property: r'name',
+        value: value,
+        caseSensitive: caseSensitive,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition>
   nameMatches(String pattern, {bool caseSensitive = true}) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.matches(
-          property: r'name',
-          wildcard: pattern,
-          caseSensitive: caseSensitive,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.matches(
+        property: r'name',
+        wildcard: pattern,
+        caseSensitive: caseSensitive,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  nameIsEmpty() {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> nameIsEmpty() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'name', value: ''),
-      );
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'name',
+        value: '',
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  nameIsNotEmpty() {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> nameIsNotEmpty() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(property: r'name', value: ''),
-      );
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        property: r'name',
+        value: '',
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  startDateIsNull() {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> startDateIsNull() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        const FilterCondition.isNull(property: r'startDate'),
-      );
+      return query.addFilterCondition(const FilterCondition.isNull(
+        property: r'startDate',
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  startDateIsNotNull() {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> startDateIsNotNull() {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        const FilterCondition.isNotNull(property: r'startDate'),
-      );
+      return query.addFilterCondition(const FilterCondition.isNotNull(
+        property: r'startDate',
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  startDateEqualTo(DateTime? value) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> startDateEqualTo(DateTime? value) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'startDate', value: value),
-      );
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'startDate',
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  startDateGreaterThan(DateTime? value, {bool include = false}) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> startDateGreaterThan(DateTime? value, {
+    bool include = false,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'startDate',
-          value: value,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'startDate',
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  startDateLessThan(DateTime? value, {bool include = false}) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> startDateLessThan(DateTime? value, {
+    bool include = false,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'startDate',
-          value: value,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'startDate',
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  startDateBetween(
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> startDateBetween(
     DateTime? lower,
     DateTime? upper, {
     bool includeLower = true,
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.between(
-          property: r'startDate',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'startDate',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  timeFrameEqualTo(TimeFrameEnum value) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> timeFrameEqualTo(TimeFrameEnum value) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'timeFrame', value: value),
-      );
+      return query.addFilterCondition(FilterCondition.equalTo(
+        property: r'timeFrame',
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  timeFrameGreaterThan(TimeFrameEnum value, {bool include = false}) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> timeFrameGreaterThan(TimeFrameEnum value, {
+    bool include = false,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'timeFrame',
-          value: value,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.greaterThan(
+        include: include,
+        property: r'timeFrame',
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  timeFrameLessThan(TimeFrameEnum value, {bool include = false}) {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> timeFrameLessThan(TimeFrameEnum value, {
+    bool include = false,
+  }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'timeFrame',
-          value: value,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.lessThan(
+        include: include,
+        property: r'timeFrame',
+        value: value,
+      ));
     });
   }
 
-  QueryBuilder<
-    RecurringTransaction,
-    RecurringTransaction,
-    QAfterFilterCondition
-  >
-  timeFrameBetween(
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> timeFrameBetween(
     TimeFrameEnum lower,
     TimeFrameEnum upper, {
     bool includeLower = true,
     bool includeUpper = true,
   }) {
     return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.between(
-          property: r'timeFrame',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-        ),
-      );
+      return query.addFilterCondition(FilterCondition.between(
+        property: r'timeFrame',
+        lower: lower,
+        includeLower: includeLower,
+        upper: upper,
+        includeUpper: includeUpper,
+      ));
     });
   }
 }
 
-extension RecurringTransactionQueryObject
-    on
-        QueryBuilder<
-          RecurringTransaction,
-          RecurringTransaction,
-          QFilterCondition
-        > {}
+extension RecurringTransactionQueryObject on QueryBuilder<RecurringTransaction,
+    RecurringTransaction,
+    QFilterCondition> {}
 
-extension RecurringTransactionQueryLinks
-    on
-        QueryBuilder<
-          RecurringTransaction,
-          RecurringTransaction,
-          QFilterCondition
-        > {}
+extension RecurringTransactionQueryLinks on QueryBuilder<RecurringTransaction,
+    RecurringTransaction,
+    QFilterCondition> {
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactions(FilterQuery<Transaction> q) {
+    return QueryBuilder.apply(this, (query) {
+      return query.link(q, r'transactions');
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsLengthEqualTo(int length) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', length, true, length, true);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', 0, true, 0, true);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', 0, false, 999999, true);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsLengthLessThan(int length, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', 0, true, length, include);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsLengthGreaterThan(int length, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(r'transactions', length, include, 999999, true);
+    });
+  }
+
+  QueryBuilder<RecurringTransaction,
+      RecurringTransaction,
+      QAfterFilterCondition> transactionsLengthBetween(int lower,
+      int upper, {
+        bool includeLower = true,
+        bool includeUpper = true,
+      }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.linkLength(
+          r'transactions', lower, includeLower, upper, includeUpper);
+    });
+  }
+}
 
 extension RecurringTransactionQuerySortBy
     on QueryBuilder<RecurringTransaction, RecurringTransaction, QSortBy> {
@@ -916,13 +881,10 @@ extension RecurringTransactionQueryWhereDistinct
   }
 }
 
-extension RecurringTransactionQueryProperty
-    on
-        QueryBuilder<
-          RecurringTransaction,
-          RecurringTransaction,
-          QQueryProperty
-        > {
+extension RecurringTransactionQueryProperty on QueryBuilder<
+    RecurringTransaction,
+    RecurringTransaction,
+    QQueryProperty> {
   QueryBuilder<RecurringTransaction, int, QQueryOperations> idProperty() {
     return QueryBuilder.apply(this, (query) {
       return query.addPropertyName(r'id');