From f8e04d19a75c508bd3e9002da6aa4b3c3c94d4ec Mon Sep 17 00:00:00 2001 From: gmpassos Date: Wed, 14 Jan 2026 19:38:16 -0300 Subject: [PATCH 1/4] v1.9.20 - `ConditionSQLEncoder`: - `keyToSQL`: added check to throw `ConditionEncodingError` if `keys` is empty. - Refactored `keyFieldReferenceToSQL` to recursively resolve multi-level key references by walking keys and resolving intermediate tables and relationships. - Added helper methods `_resolveReferenceField` and `_resolveFinalField` to modularize reference resolution logic. - `DBSQLAdapter`: - Introduced `_JoinEntry` typedef to represent SQL JOIN fragments with explicit alias dependencies (`defs` and `refs`). - Added local extension methods on `List<_JoinEntry>` to perform dependency-aware sorting of JOINs ensuring referenced aliases are resolved before use. - Refactored JOIN construction logic in SQL query building to: - Collect JOINs as `_JoinEntry` with defined and referenced aliases. - Sort JOINs by alias dependencies before concatenation. - Log a warning if not all JOIN references could be resolved. - This improves correctness and ordering of JOIN clauses in generated SQL. - Dependencies: - Updated `async_extension` from ^1.2.17 to ^1.2.18. - Updated `build_runner` from ^2.10.4 to ^2.10.5. --- CHANGELOG.md | 20 +++ lib/src/bones_api_base.dart | 2 +- lib/src/bones_api_condition_sql.dart | 240 +++++++++++++-------------- lib/src/bones_api_entity_db_sql.dart | 113 ++++++++++++- pubspec.yaml | 6 +- 5 files changed, 249 insertions(+), 132 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 586ab8b..c72da31 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,23 @@ +## 1.9.20 + +- `ConditionSQLEncoder`: + - `keyToSQL`: added check to throw `ConditionEncodingError` if `keys` is empty. + - Refactored `keyFieldReferenceToSQL` to recursively resolve multi-level key references by walking keys and resolving intermediate tables and relationships. + - Added helper methods `_resolveReferenceField` and `_resolveFinalField` to modularize reference resolution logic. + +- `DBSQLAdapter`: + - Introduced `_JoinEntry` typedef to represent SQL JOIN fragments with explicit alias dependencies (`defs` and `refs`). + - Added local extension methods on `List<_JoinEntry>` to perform dependency-aware sorting of JOINs ensuring referenced aliases are resolved before use. + - Refactored JOIN construction logic in SQL query building to: + - Collect JOINs as `_JoinEntry` with defined and referenced aliases. + - Sort JOINs by alias dependencies before concatenation. + - Log a warning if not all JOIN references could be resolved. + - This improves correctness and ordering of JOIN clauses in generated SQL. + +- Dependencies: + - Updated `async_extension` from ^1.2.17 to ^1.2.18. + - Updated `build_runner` from ^2.10.4 to ^2.10.5. + ## 1.9.19 - Dependency updates: diff --git a/lib/src/bones_api_base.dart b/lib/src/bones_api_base.dart index 2f1ad96..571cbf7 100644 --- a/lib/src/bones_api_base.dart +++ b/lib/src/bones_api_base.dart @@ -48,7 +48,7 @@ typedef APILogger = /// Bones API Library class. class BonesAPI { // ignore: constant_identifier_names - static const String VERSION = '1.9.19'; + static const String VERSION = '1.9.20'; static bool _boot = false; diff --git a/lib/src/bones_api_condition_sql.dart b/lib/src/bones_api_condition_sql.dart index 06c666c..e6d85a8 100644 --- a/lib/src/bones_api_condition_sql.dart +++ b/lib/src/bones_api_condition_sql.dart @@ -292,6 +292,9 @@ class ConditionSQLEncoder extends ConditionEncoder { EncodingContext context, ) { var keys = c.keys; + if (keys.isEmpty) { + throw ConditionEncodingError('keys empty: $c'); + } if (keys.first is! ConditionKeyField) { throw ConditionEncodingError('Root Key should be a field key: $c'); @@ -299,10 +302,10 @@ class ConditionSQLEncoder extends ConditionEncoder { if (keys.length == 1) { return keyFieldToSQL(c, context); - } else if (keys.length == 2) { + } + // keys.length >= 2 + else { return keyFieldReferenceToSQL(c, context); - } else { - throw ConditionEncodingError('keys > 2: $c'); } } @@ -405,150 +408,133 @@ class ConditionSQLEncoder extends ConditionEncoder { }); } - FutureOr> keyFieldReferenceToSQL( - KeyCondition c, - EncodingContext context, - ) { - var schemeProvider = this.schemeProvider; - var tableName = context.tableNameOrEntityName; + FutureOr _resolveReferenceField({ + required SchemeProvider schemeProvider, + required EncodingContext context, + required KeyCondition c, + required TableScheme sourceScheme, + required String sourceTable, + required ConditionKeyField key, + }) { + final fieldRef = sourceScheme.getFieldReferencedTable(key.name); - if (schemeProvider == null) { - throw ConditionEncodingError( - 'No SchemeProvider> tableName: $tableName > $this', - ); + // Normal reference field, pointing to another entity table: + if (fieldRef != null) { + context.addFieldReference(fieldRef, c); + context.resolveEntityAlias(fieldRef.targetTable); + return fieldRef.targetTable; } - var keys = c.keys; - var key0 = keys.first as ConditionKeyField; - - var tableSchemeRet = schemeProvider.getTableScheme(tableName); - - return tableSchemeRet.resolveMapped((tableScheme) { - if (tableScheme == null) { - var errorMsg = "Can't find `TableScheme` for entity/table: $tableName"; - _log.severe(errorMsg); - throw StateError(errorMsg); - } - - var fieldName = key0.name; - var fieldRef = tableScheme.getFieldReferencedTable(fieldName); - - if (fieldRef != null) { - context.addFieldReference(fieldRef, c); - - var entityAlias = context.resolveEntityAlias(fieldRef.targetTable); - - var key1 = keys[1]; - - if (key1 is ConditionKeyField) { - var targetTableSchemeRet = schemeProvider.getTableScheme( - fieldRef.targetTable, - ); + return schemeProvider + .getFieldType(key.name, tableName: sourceTable) + .resolveMapped((fieldType) { + if (fieldType == null) { + throw ConditionEncodingError('No field type for ${key.name}'); + } - return targetTableSchemeRet.resolveMapped((targetTableScheme) { - if (targetTableScheme == null) { - var errorMsg = - "Can't find `TableScheme` for target table: $fieldRef"; - _log.severe(errorMsg); - throw StateError(errorMsg); + return schemeProvider.getTableForType(fieldType).resolveMapped(( + targetTable, + ) { + if (targetTable == null) { + throw ConditionEncodingError('No table for type $fieldType'); } - var q = sqlElementQuote; - var targetFieldName = targetTableScheme.resolveTableFieldName( - key1.name, + final rel = sourceScheme.getTableRelationshipReference( + sourceTable: sourceTable, + sourceField: key.name, + targetTable: targetTable, ); - var targetFieldType = - targetTableScheme.fieldsTypes[targetFieldName]!; - return MapEntry( - targetFieldType, - '$q$entityAlias$q.$q$targetFieldName$q', - ); - }); - } else { - throw ConditionEncodingError('Key: $c'); - } - } - var retFieldType = schemeProvider.getFieldType( - fieldName, - entityName: context.entityName, - tableName: context.tableName, - ); + if (rel == null) { + throw ConditionEncodingError( + 'No relationship table for: `$sourceTable` -> `$targetTable`', + ); + } - return retFieldType.resolveMapped((refFieldType) { - if (refFieldType == null) { - throw ConditionEncodingError( - 'No field type for key[0]> keys: $key0 $keys ; entityName: ${context.entityName} ; tableName: ${context.tableName} > $this ; tableScheme: $tableScheme', - ); - } + context.addRelationshipTable(targetTable, rel, c); + context.resolveEntityAlias(rel.targetTable); - var retTableNameRef = schemeProvider.getTableForType(refFieldType); + return rel.targetTable; + }); + }); + } - return retTableNameRef.resolveMapped((tableNameRef) { - if (tableNameRef == null) { - throw ConditionEncodingError( - 'No referenced table or relationship table for key[0]> keys: $key0 $keys ; tableName: $tableName ; fieldType: $refFieldType> $this ; tableScheme: $tableScheme', - ); - } + FutureOr> _resolveFinalField({ + required SchemeProvider schemeProvider, + required EncodingContext context, + required String targetTable, + required ConditionKeyField key, + }) { + return schemeProvider.getTableScheme(targetTable).resolveMapped((scheme) { + if (scheme == null) { + throw StateError("Can't find TableScheme for $targetTable"); + } - var relationship = tableScheme.getTableRelationshipReference( - sourceTable: tableName, - sourceField: fieldName, - targetTable: tableNameRef, - ); + final fieldName = scheme.resolveTableFieldName(key.name); + if (fieldName == null) { + throw StateError( + "Can't find field `${key.name}` on table `${scheme.name}`", + ); + } - if (relationship == null) { - throw ConditionEncodingError( - 'No relationship table with target table $tableNameRef> keys: $key0 $keys ; tableName: $tableName ; fieldType: $refFieldType> $this ; tableScheme: $tableScheme', - ); - } + final alias = context.resolveEntityAlias(targetTable); + final type = scheme.fieldsTypes[fieldName]!; + final q = sqlElementQuote; - context.addRelationshipTable(tableNameRef, relationship, c); + return MapEntry(type, '$q$alias$q.$q$fieldName$q'); + }); + } - var targetAlias = context.resolveEntityAlias( - relationship.targetTable, - ); + FutureOr> keyFieldReferenceToSQL( + KeyCondition c, + EncodingContext context, + ) { + final rootTable = context.tableNameOrEntityName; - var key1 = keys[1]; + final schemeProvider = this.schemeProvider; + if (schemeProvider == null) { + throw ConditionEncodingError( + 'No SchemeProvider> tableName: $rootTable > $this', + ); + } - if (key1 is ConditionKeyField) { - var targetTableSchemeRet = schemeProvider.getTableScheme( - relationship.targetTable, - ); + final keys = c.keys.cast(); + if (keys.isEmpty) { + throw ConditionEncodingError('Empty key path: $c'); + } - return targetTableSchemeRet.resolveMapped((targetTableScheme) { - if (targetTableScheme == null) { - var errorMsg = - "Can't find `TableScheme` for target table: $fieldRef"; - _log.severe(errorMsg); - throw StateError(errorMsg); - } - - var q = sqlElementQuote; - var targetFieldName = targetTableScheme.resolveTableFieldName( - key1.name, - ); + FutureOr> walkKeys({ + required int index, + required String sourceTable, + }) { + if (index == keys.length - 1) { + return _resolveFinalField( + schemeProvider: schemeProvider, + context: context, + targetTable: sourceTable, + key: keys[index], + ); + } - if (targetFieldName == null) { - var errorMsg = - "Can't find field `${key1.name}` for target `${targetTableScheme.name}`. relationship: $relationship"; - _log.severe(errorMsg); - throw StateError(errorMsg); - } - - var targetFieldType = - targetTableScheme.fieldsTypes[targetFieldName]!; - return MapEntry( - targetFieldType, - '$q$targetAlias$q.$q$targetFieldName$q', - ); - }); - } else { - throw ConditionEncodingError('Key: $c'); - } - }); + return schemeProvider.getTableScheme(sourceTable).resolveMapped((scheme) { + if (scheme == null) { + throw StateError("Can't find `TableScheme` for table: $sourceTable"); + } + + return _resolveReferenceField( + schemeProvider: schemeProvider, + context: context, + c: c, + sourceScheme: scheme, + sourceTable: sourceTable, + key: keys[index], + ).resolveMapped( + (nextTable) => walkKeys(index: index + 1, sourceTable: nextTable), + ); }); - }); + } + + return walkKeys(index: 0, sourceTable: rootTable); } static List _valueToList(Object value) { diff --git a/lib/src/bones_api_entity_db_sql.dart b/lib/src/bones_api_entity_db_sql.dart index ff16f1f..24b3c6e 100644 --- a/lib/src/bones_api_entity_db_sql.dart +++ b/lib/src/bones_api_entity_db_sql.dart @@ -27,6 +27,78 @@ export 'bones_api_entity_db.dart' show DBAdapterCapabilityConnectivity; final _log = logging.Logger('SQLAdapter')..registerAsDbLogger(); +/// Represents a SQL JOIN fragment with explicit alias dependencies. +/// +/// - [defs]: Aliases **defined** (introduced) by this JOIN. +/// - [refs]: Aliases **referenced** by this JOIN (typically in the ON clause). +/// - [join]: The rendered JOIN SQL snippet. +typedef _JoinEntry = ({List defs, List refs, String join}); + +extension on _JoinEntry { + bool refsResolved(Set resolved) => refs.every(resolved.contains); +} + +extension on List<_JoinEntry> { + /// Sorts JOIN entries so that alias dependency order is respected. + /// + /// Ensures that every JOIN appears **after** all aliases it references + /// are already available, producing a valid SQL JOIN sequence whenever + /// possible. + /// + /// - [initialAliases] are aliases already defined by the FROM clause. + /// + /// This performs a dependency-aware (topological) sort: + /// - Iteratively selects JOINs whose [refs] are fully resolved + /// - Appends them in a valid order + /// - Accumulates newly defined aliases from [defs] + /// + /// If unresolved or circular dependencies are detected, the remaining + /// JOINs are appended in their original order and the method returns + /// `false`. + /// + /// Returns `true` if all JOIN dependencies were fully resolved and + /// ordered correctly, or `false` if a best-effort fallback order was used. + bool sortJoins(Set initialAliases) { + final List<_JoinEntry> joins = this; + // No ordering needed for zero or one JOIN. + if (joins.length <= 1) { + var resolved = joins.first.refsResolved(initialAliases); + return resolved; + } + + // Aliases currently available for reference. + final resolved = {...initialAliases}; + // JOINs not yet placed in the final order. + final pending = List<_JoinEntry>.from(joins); + + // Clear and rebuild the list in dependency-safe order. + joins.clear(); + + while (pending.isNotEmpty) { + // Find a JOIN whose referenced aliases are all resolved. + final index = pending.indexWhere((j) => j.refsResolved(resolved)); + + // No JOIN can be resolved → missing alias or circular dependency. + if (index == -1) { + // Append remaining JOINs as-is, preserving input order. + joins.addAll(pending); + // Not fully resolved; fallback ordering was applied. + return false; + } + + // Move the resolvable JOIN to the final list. + final resolvedJoin = pending.removeAt(index); + joins.add(resolvedJoin); + + // Register aliases defined by this JOIN. + resolved.addAll(resolvedJoin.defs); + } + + // Fully resolved dependency order. + return true; + } +} + /// [SQL] wrapper interface. abstract class SQLWrapper { /// The amount of [SQL]s. @@ -2511,7 +2583,7 @@ abstract class DBSQLAdapter extends DBRelationalAdapter limit: limit, ); } else { - var join = StringBuffer(); + var joins = <_JoinEntry>[]; for (var e in encodedSQL.referencedTablesFields.entries) { var refTable = e.key; @@ -2521,6 +2593,8 @@ abstract class DBSQLAdapter extends DBRelationalAdapter (ref) => encodedSQL.isInnerFieldReference(ref), ); + var join = StringBuffer(); + if (innerRef) { join.write('INNER JOIN '); } else { @@ -2529,6 +2603,9 @@ abstract class DBSQLAdapter extends DBRelationalAdapter join.write('$q$refTable$q as $q$refTableAlias$q ON '); + var defAliases = [refTableAlias]; + var refAliases = []; + for (var fieldRef in e.value) { var sourceTableAlias = _conditionSQLGenerator.resolveEntityAlias( encodedSQL, @@ -2539,6 +2616,9 @@ abstract class DBSQLAdapter extends DBRelationalAdapter fieldRef.targetTable, ); + refAliases.add(sourceTableAlias); + refAliases.add(targetTableAlias); + join.write(q); join.write(sourceTableAlias); join.write(q); @@ -2556,7 +2636,16 @@ abstract class DBSQLAdapter extends DBRelationalAdapter join.write(q); join.write(fieldRef.targetField); join.write(q); + join.write(' '); } + + refAliases.removeAll(defAliases); + + joins.add(( + defs: defAliases, + refs: refAliases, + join: join.toString(), + )); } for (var e in encodedSQL.relationshipTables.entries) { @@ -2579,6 +2668,8 @@ abstract class DBSQLAdapter extends DBRelationalAdapter var innerRel = encodedSQL.isInnerRelationshipTable(relationship); + var join = StringBuffer(); + if (innerRel) { join.write('INNER JOIN '); } else { @@ -2650,10 +2741,30 @@ abstract class DBSQLAdapter extends DBRelationalAdapter join.write(q); join.write(') '); + + joins.add(( + defs: [relTableAlias, targetTableAlias], + refs: [tableAlias], + join: join.toString(), + )); } + var allJoinRefsResolved = joins.sortJoins({tableAlias}); + + var join = joins.map((e) => e.join).join(' '); + var from = 'FROM $q$table$q as $q$tableAlias$q $join WHERE $conditionSQL'; + + if (!allJoinRefsResolved) { + _log.warning( + "Not all JOIN references where resolved while building SQL>\n" + "$from\n" + "$joins\n" + "$matcher", + ); + } + var sqlQuery = sqlBuilder(from, encodedSQL); return SQL( diff --git a/pubspec.yaml b/pubspec.yaml index 0d5286f..7d6832d 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -1,6 +1,6 @@ name: bones_api description: Bones_API - A powerful API backend framework for Dart. It comes with a built-in HTTP Server, route handler, entity handler, SQL translator, and DB adapters. -version: 1.9.19 +version: 1.9.20 homepage: https://github.com/Colossus-Services/bones_api environment: @@ -10,7 +10,7 @@ executables: bones_api: dependencies: - async_extension: ^1.2.17 + async_extension: ^1.2.18 async_events: ^1.3.0 reflection_factory: ^2.7.3 statistics: ^1.2.1 @@ -55,7 +55,7 @@ dependencies: dev_dependencies: lints: ^5.1.1 - build_runner: ^2.10.4 + build_runner: ^2.10.5 build_verify: ^3.1.1 test: ^1.29.0 pubspec: ^2.3.0 From 9205158a0c8c886a1d847b0e1d0247fc273f9fad Mon Sep 17 00:00:00 2001 From: gmpassos Date: Wed, 14 Jan 2026 21:26:55 -0300 Subject: [PATCH 2/4] Add order, campaign, bonus, and item entity handlers and Multi-level Query tests. --- test/bones_api_entity_db_tests_base.dart | 80 + test/bones_api_test_entities_orders.dart | 343 +++ ...api_test_entities_orders.reflection.g.dart | 2221 +++++++++++++++++ 3 files changed, 2644 insertions(+) create mode 100644 test/bones_api_test_entities_orders.dart create mode 100644 test/bones_api_test_entities_orders.reflection.g.dart diff --git a/test/bones_api_entity_db_tests_base.dart b/test/bones_api_entity_db_tests_base.dart index 597b0f4..40c7135 100644 --- a/test/bones_api_entity_db_tests_base.dart +++ b/test/bones_api_entity_db_tests_base.dart @@ -9,6 +9,7 @@ import 'package:statistics/statistics.dart'; import 'package:test/test.dart'; import 'bones_api_test_entities.dart'; +import 'bones_api_test_entities_orders.dart'; final _log = logging.Logger('bones_api_test_adapter'); @@ -30,18 +31,32 @@ class TestEntityRepositoryProvider extends DBSQLEntityRepositoryProvider { final EntityHandler userInfoEntityHandler; final EntityHandler userEntityHandler; + final EntityHandler campaignEntityHandler; + final EntityHandler bonusEntityHandler; + final EntityHandler itemEntityHandler; + final EntityHandler orderEntityHandler; + late final StoreAPIRepository storeAPIRepository; late final AddressAPIRepository addressAPIRepository; late final RoleAPIRepository roleAPIRepository; late final UserInfoAPIRepository userInfoAPIRepository; late final UserAPIRepository userAPIRepository; + late final CampaignAPIRepository campaignAPIRepository; + late final BonusAPIRepository bonusAPIRepository; + late final ItemAPIRepository itemAPIRepository; + late final OrderAPIRepository orderAPIRepository; + TestEntityRepositoryProvider( this.storeEntityHandler, this.addressEntityHandler, this.roleEntityHandler, this.userInfoEntityHandler, this.userEntityHandler, + this.campaignEntityHandler, + this.bonusEntityHandler, + this.itemEntityHandler, + this.orderEntityHandler, this.sqlAdapterCreator, this.dbPort, this.dbConfig, @@ -75,6 +90,15 @@ class TestEntityRepositoryProvider extends DBSQLEntityRepositoryProvider { userInfoEntityHandler, ), DBSQLEntityRepository(adapter, 'user', userEntityHandler), + // Order-related tables + DBSQLEntityRepository( + adapter, + 'campaign', + campaignEntityHandler, + ), + DBSQLEntityRepository(adapter, 'bonus', bonusEntityHandler), + DBSQLEntityRepository(adapter, 'item', itemEntityHandler), + DBSQLEntityRepository(adapter, 'order', orderEntityHandler), ].asUnmodifiableListView(); } @@ -85,6 +109,11 @@ class TestEntityRepositoryProvider extends DBSQLEntityRepositoryProvider { roleAPIRepository = RoleAPIRepository(this), userInfoAPIRepository = UserInfoAPIRepository(this), userAPIRepository = UserAPIRepository(this), + // Order related repositories + campaignAPIRepository = CampaignAPIRepository(this), + bonusAPIRepository = BonusAPIRepository(this), + itemAPIRepository = ItemAPIRepository(this), + orderAPIRepository = OrderAPIRepository(this), ]; } @@ -142,6 +171,10 @@ TestEntityRepositoryProvider createEntityRepositoryProvider( Role$reflection().entityHandler, UserInfo$reflection().entityHandler, User$reflection().entityHandler, + Campaign$reflection().entityHandler, + Bonus$reflection().entityHandler, + Item$reflection().entityHandler, + Order$reflection().entityHandler, sqlAdapterCreator, dbPort, dbConfig, @@ -152,6 +185,10 @@ TestEntityRepositoryProvider createEntityRepositoryProvider( roleEntityHandler..inspectObject(Role.empty()), userInfoEntityHandler..inspectObject(UserInfo.empty()), userEntityHandler..inspectObject(User.empty()), + campaignEntityHandler..inspectObject(Campaign.empty()), + bonusEntityHandler..inspectObject(Bonus.empty()), + itemEntityHandler..inspectObject(Item.empty()), + orderEntityHandler..inspectObject(Order.empty()), sqlAdapterCreator, dbPort, dbConfig, @@ -2163,6 +2200,49 @@ Future runAdapterTests( } }); + test('Multi-level Query: Order.items.bonus.campaign query', () async { + ////////// + + { + final campaignRepo = entityRepositoryProvider.campaignAPIRepository; + final bonusRepo = entityRepositoryProvider.bonusAPIRepository; + final itemRepo = entityRepositoryProvider.itemAPIRepository; + final orderRepo = entityRepositoryProvider.orderAPIRepository; + + // Create campaign + var campaign = Campaign('Summer Promo'); + var campaignId = await campaignRepo.store(campaign); + expect(campaignId, isNotNull); + + // Create bonus referencing the campaign (by id) + var bonus = Bonus(campaign: campaignId); + var bonusId = await bonusRepo.store(bonus); + expect(bonusId, isNotNull); + + // Create item referencing the bonus (by id) + var item = Item('Widget', bonus: bonusId); + var itemId = await itemRepo.store(item); + expect(itemId, isNotNull); + + // Create order containing the item + var order = Order('ORD-CHAIN-001', items: [item]); + var orderId = await orderRepo.store(order); + expect(orderId, isNotNull); + + // Negative case: order without the referenced campaign + var otherOrder = Order('ORD-CHAIN-002', items: []); + await orderRepo.store(otherOrder); + + // Query orders by campaign id using multi-level chain + var results = + (await orderRepo.selectByCampaignId(campaignId)).toList(); + var numbers = results.map((o) => o.orderNumber).toList(); + + expect(numbers, contains('ORD-CHAIN-001')); + expect(numbers, isNot(contains('ORD-CHAIN-002'))); + } + }); + test('populate', () async { var result = await entityRepositoryProvider.storeAllFromJson({ 'user': [ diff --git a/test/bones_api_test_entities_orders.dart b/test/bones_api_test_entities_orders.dart new file mode 100644 index 0000000..4e7d590 --- /dev/null +++ b/test/bones_api_test_entities_orders.dart @@ -0,0 +1,343 @@ +import 'package:bones_api/bones_api.dart'; + +part 'bones_api_test_entities_orders.reflection.g.dart'; + +final campaignEntityHandler = GenericEntityHandler( + instantiatorDefault: Campaign.empty, + instantiatorFromMap: Campaign.fromMap, + type: Campaign, + typeName: 'Campaign', +); + +final bonusEntityHandler = GenericEntityHandler( + instantiatorDefault: Bonus.empty, + instantiatorFromMap: Bonus.fromMap, + type: Bonus, + typeName: 'Bonus', +); + +final itemEntityHandler = GenericEntityHandler( + instantiatorDefault: Item.empty, + instantiatorFromMap: Item.fromMap, + type: Item, + typeName: 'Item', +); + +final orderEntityHandler = GenericEntityHandler( + instantiatorDefault: Order.empty, + instantiatorFromMap: Order.fromMap, + type: Order, + typeName: 'Order', +); + +class CampaignAPIRepository extends APIRepository { + CampaignAPIRepository(EntityRepositoryProvider provider) + : super(provider: provider); +} + +class BonusAPIRepository extends APIRepository { + BonusAPIRepository(EntityRepositoryProvider provider) + : super(provider: provider); +} + +class ItemAPIRepository extends APIRepository { + ItemAPIRepository(EntityRepositoryProvider provider) + : super(provider: provider); +} + +class OrderAPIRepository extends APIRepository { + OrderAPIRepository(EntityRepositoryProvider provider) + : super(provider: provider); + + // convenience: select orders that reference campaign id via chain items.bonus.campaign + FutureOr> selectByCampaignId(int campaignId) { + return selectByQuery( + ' items.bonus.campaign == ? ', + parameters: [campaignId], + ); + } +} + +@EnableReflection() +class Campaign extends Entity { + int? id; + String name; + + Campaign(this.name, {this.id}); + Campaign.empty() : this(''); + + static FutureOr fromMap(Map map) => + Campaign(map.getAsString('name')!, id: map['id']); + + @override + String get idFieldName => 'id'; + + @JsonField.hidden() + @override + List get fieldsNames => const ['id', 'name']; + + @override + V? getField(String key) { + switch (key) { + case 'id': + return id as V?; + case 'name': + return name as V?; + default: + return null; + } + } + + @override + TypeInfo? getFieldType(String key) { + switch (key) { + case 'id': + return TypeInfo.tInt; + case 'name': + return TypeInfo.tString; + default: + return null; + } + } + + @override + void setField(String key, V? value) { + switch (key) { + case 'id': + id = value as int?; + break; + case 'name': + name = value as String; + break; + default: + return; + } + } + + @override + Map toJson() => {if (id != null) 'id': id, 'name': name}; +} + +@EnableReflection() +class Bonus extends Entity { + int? id; + // campaign is a reference to Campaign (one-to-one) + EntityReference campaign; + + Bonus({Object? campaign, this.id}) + : campaign = EntityReference.from(campaign); + + Bonus.empty() : this(); + + static FutureOr fromMap(Map map) => + Bonus(campaign: map['campaign'], id: map['id']); + + @override + String get idFieldName => 'id'; + + @JsonField.hidden() + @override + List get fieldsNames => const ['id', 'campaign']; + + @override + V? getField(String key) { + switch (key) { + case 'id': + return id as V?; + case 'campaign': + return campaign as V?; + default: + return null; + } + } + + @override + TypeInfo? getFieldType(String key) { + switch (key) { + case 'id': + return TypeInfo.tInt; + case 'campaign': + return TypeInfo>.fromType(EntityReference, [ + TypeInfo.fromType(Campaign), + ]); + default: + return null; + } + } + + @override + void setField(String key, V? value) { + switch (key) { + case 'id': + id = value as int?; + break; + case 'campaign': + campaign = EntityReference.from(value); + break; + default: + return; + } + } + + @override + Map toJson() => { + if (id != null) 'id': id, + 'campaign': campaign.toJson(), + }; +} + +@EnableReflection() +class Item extends Entity { + int? id; + String name; + // bonus is a reference to Bonus (nullable) + EntityReference bonus; + + Item(this.name, {Object? bonus, this.id}) + : bonus = EntityReference.from(bonus); + + Item.empty() : this('', bonus: null); + + static FutureOr fromMap(Map map) => + Item(map.getAsString('name')!, bonus: map['bonus'], id: map['id']); + + @override + String get idFieldName => 'id'; + + @JsonField.hidden() + @override + List get fieldsNames => const ['id', 'name', 'bonus']; + + @override + V? getField(String key) { + switch (key) { + case 'id': + return id as V?; + case 'name': + return name as V?; + case 'bonus': + return bonus as V?; + default: + return null; + } + } + + @override + TypeInfo? getFieldType(String key) { + switch (key) { + case 'id': + return TypeInfo.tInt; + case 'name': + return TypeInfo.tString; + case 'bonus': + return TypeInfo>.fromType(EntityReference, [ + TypeInfo.fromType(Bonus), + ]); + default: + return null; + } + } + + @override + void setField(String key, V? value) { + switch (key) { + case 'id': + id = value as int?; + break; + case 'name': + name = value as String; + break; + case 'bonus': + bonus = EntityReference.from(value); + break; + default: + return; + } + } + + @override + Map toJson() => { + if (id != null) 'id': id, + 'name': name, + 'bonus': bonus.toJson(), + }; +} + +@EnableReflection() +class Order extends Entity { + int? id; + String orderNumber; + + // items is an embedded list of Item objects (similar style to Address.stores) + List items; + + Order(this.orderNumber, {List? items, this.id}) + : items = items ?? []; + + Order.empty() : this(''); + + static FutureOr fromMap(Map map) => Order( + map.getAsString('orderNumber')!, + items: map.getAsList('items', def: [])!, + id: map['id'], + ); + + @override + String get idFieldName => 'id'; + + @JsonField.hidden() + @override + List get fieldsNames => const ['id', 'orderNumber', 'items']; + + @override + V? getField(String key) { + switch (key) { + case 'id': + return id as V?; + case 'orderNumber': + return orderNumber as V?; + case 'items': + return items as V?; + default: + return null; + } + } + + @override + TypeInfo? getFieldType(String key) { + switch (key) { + case 'id': + return TypeInfo.tInt; + case 'orderNumber': + return TypeInfo.tString; + case 'items': + return TypeInfo>(List, [TypeInfo(Item)]); + default: + return null; + } + } + + @override + void setField(String key, V? value) { + switch (key) { + case 'id': + id = value as int?; + break; + case 'orderNumber': + orderNumber = value as String; + break; + case 'items': + items = value as List; + break; + default: + return; + } + } + + @override + Map toJson() => { + if (id != null) 'id': id, + 'orderNumber': orderNumber, + 'items': items.map((e) => e.toJson()).toList(), + }; +} diff --git a/test/bones_api_test_entities_orders.reflection.g.dart b/test/bones_api_test_entities_orders.reflection.g.dart new file mode 100644 index 0000000..6c3b06c --- /dev/null +++ b/test/bones_api_test_entities_orders.reflection.g.dart @@ -0,0 +1,2221 @@ +// +// GENERATED CODE - DO NOT MODIFY BY HAND! +// BUILDER: reflection_factory/2.7.3 +// BUILD COMMAND: dart run build_runner build +// + +// coverage:ignore-file +// ignore_for_file: unused_element +// ignore_for_file: no_leading_underscores_for_local_identifiers +// ignore_for_file: camel_case_types +// ignore_for_file: camel_case_extensions +// ignore_for_file: deprecated_member_use +// ignore_for_file: deprecated_member_use_from_same_package +// ignore_for_file: unnecessary_const +// ignore_for_file: unnecessary_cast +// ignore_for_file: unnecessary_type_check + +part of 'bones_api_test_entities_orders.dart'; + +typedef __TR = TypeReflection; +typedef __TI = TypeInfo; +typedef __PR = ParameterReflection; + +mixin __ReflectionMixin { + static final Version _version = Version.parse('2.7.3'); + + Version get reflectionFactoryVersion => _version; + + List siblingsReflection() => _siblingsReflection(); +} + +Symbol? _getSymbol(String? key) { + if (key == null) return null; + + switch (key) { + case r"bonus": + return const Symbol(r"bonus"); + case r"campaign": + return const Symbol(r"campaign"); + case r"id": + return const Symbol(r"id"); + case r"items": + return const Symbol(r"items"); + default: + return null; + } +} + +// ignore: non_constant_identifier_names +Bonus Bonus$fromJson(Map map) => + Bonus$reflection.staticInstance.fromJson(map); +// ignore: non_constant_identifier_names +Bonus Bonus$fromJsonEncoded(String jsonEncoded) => + Bonus$reflection.staticInstance.fromJsonEncoded(jsonEncoded); +// ignore: non_constant_identifier_names +Campaign Campaign$fromJson(Map map) => + Campaign$reflection.staticInstance.fromJson(map); +// ignore: non_constant_identifier_names +Campaign Campaign$fromJsonEncoded(String jsonEncoded) => + Campaign$reflection.staticInstance.fromJsonEncoded(jsonEncoded); +// ignore: non_constant_identifier_names +Item Item$fromJson(Map map) => + Item$reflection.staticInstance.fromJson(map); +// ignore: non_constant_identifier_names +Item Item$fromJsonEncoded(String jsonEncoded) => + Item$reflection.staticInstance.fromJsonEncoded(jsonEncoded); +// ignore: non_constant_identifier_names +Order Order$fromJson(Map map) => + Order$reflection.staticInstance.fromJson(map); +// ignore: non_constant_identifier_names +Order Order$fromJsonEncoded(String jsonEncoded) => + Order$reflection.staticInstance.fromJsonEncoded(jsonEncoded); + +class Bonus$reflection extends ClassReflection with __ReflectionMixin { + static final Expando _objectReflections = Expando(); + + factory Bonus$reflection([Bonus? object]) { + if (object == null) return staticInstance; + return _objectReflections[object] ??= Bonus$reflection._(object); + } + + Bonus$reflection._([Bonus? object]) : super(Bonus, r'Bonus', object); + + static bool _registered = false; + @override + void register() { + if (!_registered) { + _registered = true; + super.register(); + _registerSiblingsReflection(); + } + } + + @override + Version get languageVersion => Version.parse('3.7.0'); + + @override + Bonus$reflection withObject([Bonus? obj]) => + Bonus$reflection(obj)..setupInternalsWith(this); + + static Bonus$reflection? _withoutObjectInstance; + @override + Bonus$reflection withoutObjectInstance() => staticInstance; + + @override + Symbol? getSymbol(String? key) => _getSymbol(key); + + static Bonus$reflection get staticInstance => + _withoutObjectInstance ??= Bonus$reflection._(); + + @override + Bonus$reflection getStaticInstance() => staticInstance; + + static bool _boot = false; + static void boot() { + if (_boot) return; + _boot = true; + Bonus$reflection.staticInstance; + } + + @override + bool get hasDefaultConstructor => true; + @override + Bonus? createInstanceWithDefaultConstructor() => Bonus(); + + @override + bool get hasEmptyConstructor => true; + @override + Bonus? createInstanceWithEmptyConstructor() => Bonus.empty(); + @override + bool get hasNoRequiredArgsConstructor => true; + @override + Bonus? createInstanceWithNoRequiredArgsConstructor() => Bonus.empty(); + + static const List _constructorsNames = const ['', 'empty']; + + @override + List get constructorsNames => _constructorsNames; + + static final Map> _constructors = {}; + + @override + ConstructorReflection? constructor(String constructorName) { + var c = _constructors[constructorName]; + if (c != null) return c; + c = _constructorImpl(constructorName); + if (c == null) return null; + _constructors[constructorName] = c; + return c; + } + + ConstructorReflection? _constructorImpl(String constructorName) { + var lc = constructorName.trim().toLowerCase(); + + switch (lc) { + case '': + return ConstructorReflection( + this, + Bonus, + '', + () => Bonus.new, + null, + null, + const { + 'campaign': __PR(__TR.tObject, 'campaign', true, false), + 'id': __PR(__TR.tInt, 'id', true, false), + }, + null, + ); + case 'empty': + return ConstructorReflection( + this, + Bonus, + 'empty', + () => Bonus.empty, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _classAnnotations = []; + + @override + List get classAnnotations => _classAnnotations; + + static const List _supperTypes = const [Entity]; + + @override + List get supperTypes => _supperTypes; + + @override + bool get hasMethodToJson => true; + + @override + Object? callMethodToJson([Bonus? obj]) { + obj ??= object; + return obj?.toJson(); + } + + static const List _fieldsNames = const [ + 'campaign', + 'fieldsNames', + 'id', + 'idFieldName', + ]; + + @override + List get fieldsNames => _fieldsNames; + + static final Map> _fieldsNoObject = + {}; + + final Map> _fieldsObject = {}; + + @override + FieldReflection? field(String fieldName, [Bonus? obj]) { + if (obj == null) { + if (object != null) { + return _fieldObjectImpl(fieldName); + } else { + return _fieldNoObjectImpl(fieldName); + } + } else if (identical(obj, object)) { + return _fieldObjectImpl(fieldName); + } + return _fieldNoObjectImpl(fieldName)?.withObject(obj); + } + + FieldReflection? _fieldNoObjectImpl(String fieldName) { + final f = _fieldsNoObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + final f2 = _fieldImpl(fieldName, null); + if (f2 == null) return null; + _fieldsNoObject[fieldName] = f2; + return f2 as FieldReflection; + } + + FieldReflection? _fieldObjectImpl(String fieldName) { + final f = _fieldsObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + var f2 = _fieldNoObjectImpl(fieldName); + if (f2 == null) return null; + f2 = f2.withObject(object!); + _fieldsObject[fieldName] = f2; + return f2; + } + + FieldReflection? _fieldImpl(String fieldName, Bonus? obj) { + obj ??= object; + + var lc = fieldName.trim().toLowerCase(); + + switch (lc) { + case 'id': + return FieldReflection( + this, + Bonus, + __TR.tInt, + 'id', + true, + (o) => () => o!.id, + (o) => (v) => o!.id = v, + obj, + false, + ); + case 'campaign': + return FieldReflection>( + this, + Bonus, + const __TR>(EntityReference, <__TR>[ + __TR(Campaign), + ]), + 'campaign', + false, + (o) => () => o!.campaign, + (o) => (v) => o!.campaign = v, + obj, + false, + ); + case 'idfieldname': + return FieldReflection( + this, + Bonus, + __TR.tString, + 'idFieldName', + false, + (o) => () => o!.idFieldName, + null, + obj, + false, + const [override], + ); + case 'fieldsnames': + return FieldReflection>( + this, + Bonus, + __TR.tListString, + 'fieldsNames', + false, + (o) => () => o!.fieldsNames, + null, + obj, + false, + const [JsonField.hidden(), override], + ); + default: + return null; + } + } + + @override + Map getFieldsValues( + Bonus? obj, { + bool withHashCode = false, + }) { + obj ??= object; + return { + 'id': obj?.id, + 'campaign': obj?.campaign, + 'idFieldName': obj?.idFieldName, + 'fieldsNames': obj?.fieldsNames, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + @override + Map getJsonFieldsVisibleValues( + Bonus? obj, { + bool withHashCode = false, + }) { + obj ??= object; + return { + 'id': obj?.id, + 'campaign': obj?.campaign, + 'idFieldName': obj?.idFieldName, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + static const List _staticFieldsNames = const []; + + @override + List get staticFieldsNames => _staticFieldsNames; + + @override + StaticFieldReflection? staticField(String fieldName) => null; + + static const List _methodsNames = const [ + 'getField', + 'getFieldEntityAnnotations', + 'getFieldType', + 'getID', + 'setField', + 'setID', + 'toJson', + 'toJsonEncoded', + ]; + + @override + List get methodsNames => _methodsNames; + + static final Map> _methodsNoObject = + {}; + + final Map> _methodsObject = {}; + + @override + MethodReflection? method(String methodName, [Bonus? obj]) { + if (obj == null) { + if (object != null) { + return _methodObjectImpl(methodName); + } else { + return _methodNoObjectImpl(methodName); + } + } else if (identical(obj, object)) { + return _methodObjectImpl(methodName); + } + return _methodNoObjectImpl(methodName)?.withObject(obj); + } + + MethodReflection? _methodNoObjectImpl(String methodName) { + final m = _methodsNoObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + final m2 = _methodImpl(methodName, null); + if (m2 == null) return null; + _methodsNoObject[methodName] = m2; + return m2 as MethodReflection; + } + + MethodReflection? _methodObjectImpl(String methodName) { + final m = _methodsObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + var m2 = _methodNoObjectImpl(methodName); + if (m2 == null) return null; + m2 = m2.withObject(object!); + _methodsObject[methodName] = m2; + return m2; + } + + MethodReflection? _methodImpl(String methodName, Bonus? obj) { + obj ??= object; + + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'getfield': + return MethodReflection( + this, + Bonus, + 'getField', + __TR.tDynamic, + true, + (o) => o!.getField, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'getfieldtype': + return MethodReflection?>( + this, + Bonus, + 'getFieldType', + const __TR>(TypeInfo, <__TR>[__TR.tDynamic]), + true, + (o) => o!.getFieldType, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'setfield': + return MethodReflection( + this, + Bonus, + 'setField', + __TR.tVoid, + false, + (o) => o!.setField, + obj, + const <__PR>[ + __PR(__TR.tString, 'key', false, true), + __PR(__TR.tDynamic, 'value', true, true), + ], + null, + null, + const [override], + ); + case 'tojson': + return MethodReflection>( + this, + Bonus, + 'toJson', + __TR.tMapStringDynamic, + false, + (o) => o!.toJson, + obj, + null, + null, + null, + const [override], + ); + case 'getid': + return MethodReflection( + this, + Entity, + 'getID', + __TR.tDynamic, + true, + (o) => o!.getID, + obj, + null, + null, + null, + null, + ); + case 'setid': + return MethodReflection( + this, + Entity, + 'setID', + __TR.tVoid, + false, + (o) => o!.setID, + obj, + const <__PR>[__PR(__TR.tDynamic, 'id', false, true)], + null, + null, + null, + ); + case 'getfieldentityannotations': + return MethodReflection?>( + this, + Entity, + 'getFieldEntityAnnotations', + const __TR>(List, <__TR>[ + __TR(EntityAnnotation), + ]), + true, + (o) => o!.getFieldEntityAnnotations, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + null, + ); + case 'tojsonencoded': + return MethodReflection( + this, + Entity, + 'toJsonEncoded', + __TR.tString, + false, + (o) => o!.toJsonEncoded, + obj, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _staticMethodsNames = const ['fromMap']; + + @override + List get staticMethodsNames => _staticMethodsNames; + + static final Map> + _staticMethods = {}; + + @override + StaticMethodReflection? staticMethod(String methodName) { + var m = _staticMethods[methodName]; + if (m != null) { + return m as StaticMethodReflection; + } + m = _staticMethodImpl(methodName); + if (m == null) return null; + _staticMethods[methodName] = m; + return m as StaticMethodReflection; + } + + StaticMethodReflection? _staticMethodImpl(String methodName) { + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'frommap': + return StaticMethodReflection>( + this, + Bonus, + 'fromMap', + const __TR>(FutureOr, <__TR>[__TR(Bonus)]), + false, + () => Bonus.fromMap, + const <__PR>[__PR(__TR.tMapStringDynamic, 'map', false, true)], + null, + null, + null, + ); + default: + return null; + } + } +} + +class Campaign$reflection extends ClassReflection + with __ReflectionMixin { + static final Expando _objectReflections = Expando(); + + factory Campaign$reflection([Campaign? object]) { + if (object == null) return staticInstance; + return _objectReflections[object] ??= Campaign$reflection._(object); + } + + Campaign$reflection._([Campaign? object]) + : super(Campaign, r'Campaign', object); + + static bool _registered = false; + @override + void register() { + if (!_registered) { + _registered = true; + super.register(); + _registerSiblingsReflection(); + } + } + + @override + Version get languageVersion => Version.parse('3.7.0'); + + @override + Campaign$reflection withObject([Campaign? obj]) => + Campaign$reflection(obj)..setupInternalsWith(this); + + static Campaign$reflection? _withoutObjectInstance; + @override + Campaign$reflection withoutObjectInstance() => staticInstance; + + @override + Symbol? getSymbol(String? key) => _getSymbol(key); + + static Campaign$reflection get staticInstance => + _withoutObjectInstance ??= Campaign$reflection._(); + + @override + Campaign$reflection getStaticInstance() => staticInstance; + + static bool _boot = false; + static void boot() { + if (_boot) return; + _boot = true; + Campaign$reflection.staticInstance; + } + + @override + bool get hasDefaultConstructor => false; + @override + Campaign? createInstanceWithDefaultConstructor() => null; + + @override + bool get hasEmptyConstructor => true; + @override + Campaign? createInstanceWithEmptyConstructor() => Campaign.empty(); + @override + bool get hasNoRequiredArgsConstructor => true; + @override + Campaign? createInstanceWithNoRequiredArgsConstructor() => Campaign.empty(); + + static const List _constructorsNames = const ['', 'empty']; + + @override + List get constructorsNames => _constructorsNames; + + static final Map> _constructors = {}; + + @override + ConstructorReflection? constructor(String constructorName) { + var c = _constructors[constructorName]; + if (c != null) return c; + c = _constructorImpl(constructorName); + if (c == null) return null; + _constructors[constructorName] = c; + return c; + } + + ConstructorReflection? _constructorImpl(String constructorName) { + var lc = constructorName.trim().toLowerCase(); + + switch (lc) { + case '': + return ConstructorReflection( + this, + Campaign, + '', + () => Campaign.new, + const <__PR>[__PR(__TR.tString, 'name', false, true)], + null, + const {'id': __PR(__TR.tInt, 'id', true, false)}, + null, + ); + case 'empty': + return ConstructorReflection( + this, + Campaign, + 'empty', + () => Campaign.empty, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _classAnnotations = []; + + @override + List get classAnnotations => _classAnnotations; + + static const List _supperTypes = const [Entity]; + + @override + List get supperTypes => _supperTypes; + + @override + bool get hasMethodToJson => true; + + @override + Object? callMethodToJson([Campaign? obj]) { + obj ??= object; + return obj?.toJson(); + } + + static const List _fieldsNames = const [ + 'fieldsNames', + 'id', + 'idFieldName', + 'name', + ]; + + @override + List get fieldsNames => _fieldsNames; + + static final Map> _fieldsNoObject = + {}; + + final Map> _fieldsObject = {}; + + @override + FieldReflection? field(String fieldName, [Campaign? obj]) { + if (obj == null) { + if (object != null) { + return _fieldObjectImpl(fieldName); + } else { + return _fieldNoObjectImpl(fieldName); + } + } else if (identical(obj, object)) { + return _fieldObjectImpl(fieldName); + } + return _fieldNoObjectImpl(fieldName)?.withObject(obj); + } + + FieldReflection? _fieldNoObjectImpl(String fieldName) { + final f = _fieldsNoObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + final f2 = _fieldImpl(fieldName, null); + if (f2 == null) return null; + _fieldsNoObject[fieldName] = f2; + return f2 as FieldReflection; + } + + FieldReflection? _fieldObjectImpl(String fieldName) { + final f = _fieldsObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + var f2 = _fieldNoObjectImpl(fieldName); + if (f2 == null) return null; + f2 = f2.withObject(object!); + _fieldsObject[fieldName] = f2; + return f2; + } + + FieldReflection? _fieldImpl( + String fieldName, + Campaign? obj, + ) { + obj ??= object; + + var lc = fieldName.trim().toLowerCase(); + + switch (lc) { + case 'id': + return FieldReflection( + this, + Campaign, + __TR.tInt, + 'id', + true, + (o) => () => o!.id, + (o) => (v) => o!.id = v, + obj, + false, + ); + case 'name': + return FieldReflection( + this, + Campaign, + __TR.tString, + 'name', + false, + (o) => () => o!.name, + (o) => (v) => o!.name = v, + obj, + false, + ); + case 'idfieldname': + return FieldReflection( + this, + Campaign, + __TR.tString, + 'idFieldName', + false, + (o) => () => o!.idFieldName, + null, + obj, + false, + const [override], + ); + case 'fieldsnames': + return FieldReflection>( + this, + Campaign, + __TR.tListString, + 'fieldsNames', + false, + (o) => () => o!.fieldsNames, + null, + obj, + false, + const [JsonField.hidden(), override], + ); + default: + return null; + } + } + + @override + Map getFieldsValues( + Campaign? obj, { + bool withHashCode = false, + }) { + obj ??= object; + return { + 'id': obj?.id, + 'name': obj?.name, + 'idFieldName': obj?.idFieldName, + 'fieldsNames': obj?.fieldsNames, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + @override + Map getJsonFieldsVisibleValues( + Campaign? obj, { + bool withHashCode = false, + }) { + obj ??= object; + return { + 'id': obj?.id, + 'name': obj?.name, + 'idFieldName': obj?.idFieldName, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + static const List _staticFieldsNames = const []; + + @override + List get staticFieldsNames => _staticFieldsNames; + + @override + StaticFieldReflection? staticField(String fieldName) => null; + + static const List _methodsNames = const [ + 'getField', + 'getFieldEntityAnnotations', + 'getFieldType', + 'getID', + 'setField', + 'setID', + 'toJson', + 'toJsonEncoded', + ]; + + @override + List get methodsNames => _methodsNames; + + static final Map> + _methodsNoObject = {}; + + final Map> _methodsObject = {}; + + @override + MethodReflection? method(String methodName, [Campaign? obj]) { + if (obj == null) { + if (object != null) { + return _methodObjectImpl(methodName); + } else { + return _methodNoObjectImpl(methodName); + } + } else if (identical(obj, object)) { + return _methodObjectImpl(methodName); + } + return _methodNoObjectImpl(methodName)?.withObject(obj); + } + + MethodReflection? _methodNoObjectImpl(String methodName) { + final m = _methodsNoObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + final m2 = _methodImpl(methodName, null); + if (m2 == null) return null; + _methodsNoObject[methodName] = m2; + return m2 as MethodReflection; + } + + MethodReflection? _methodObjectImpl(String methodName) { + final m = _methodsObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + var m2 = _methodNoObjectImpl(methodName); + if (m2 == null) return null; + m2 = m2.withObject(object!); + _methodsObject[methodName] = m2; + return m2; + } + + MethodReflection? _methodImpl( + String methodName, + Campaign? obj, + ) { + obj ??= object; + + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'getfield': + return MethodReflection( + this, + Campaign, + 'getField', + __TR.tDynamic, + true, + (o) => o!.getField, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'getfieldtype': + return MethodReflection?>( + this, + Campaign, + 'getFieldType', + const __TR>(TypeInfo, <__TR>[__TR.tDynamic]), + true, + (o) => o!.getFieldType, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'setfield': + return MethodReflection( + this, + Campaign, + 'setField', + __TR.tVoid, + false, + (o) => o!.setField, + obj, + const <__PR>[ + __PR(__TR.tString, 'key', false, true), + __PR(__TR.tDynamic, 'value', true, true), + ], + null, + null, + const [override], + ); + case 'tojson': + return MethodReflection>( + this, + Campaign, + 'toJson', + __TR.tMapStringDynamic, + false, + (o) => o!.toJson, + obj, + null, + null, + null, + const [override], + ); + case 'getid': + return MethodReflection( + this, + Entity, + 'getID', + __TR.tDynamic, + true, + (o) => o!.getID, + obj, + null, + null, + null, + null, + ); + case 'setid': + return MethodReflection( + this, + Entity, + 'setID', + __TR.tVoid, + false, + (o) => o!.setID, + obj, + const <__PR>[__PR(__TR.tDynamic, 'id', false, true)], + null, + null, + null, + ); + case 'getfieldentityannotations': + return MethodReflection?>( + this, + Entity, + 'getFieldEntityAnnotations', + const __TR>(List, <__TR>[ + __TR(EntityAnnotation), + ]), + true, + (o) => o!.getFieldEntityAnnotations, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + null, + ); + case 'tojsonencoded': + return MethodReflection( + this, + Entity, + 'toJsonEncoded', + __TR.tString, + false, + (o) => o!.toJsonEncoded, + obj, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _staticMethodsNames = const ['fromMap']; + + @override + List get staticMethodsNames => _staticMethodsNames; + + static final Map> + _staticMethods = {}; + + @override + StaticMethodReflection? staticMethod(String methodName) { + var m = _staticMethods[methodName]; + if (m != null) { + return m as StaticMethodReflection; + } + m = _staticMethodImpl(methodName); + if (m == null) return null; + _staticMethods[methodName] = m; + return m as StaticMethodReflection; + } + + StaticMethodReflection? _staticMethodImpl( + String methodName, + ) { + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'frommap': + return StaticMethodReflection>( + this, + Campaign, + 'fromMap', + const __TR>(FutureOr, <__TR>[ + __TR(Campaign), + ]), + false, + () => Campaign.fromMap, + const <__PR>[__PR(__TR.tMapStringDynamic, 'map', false, true)], + null, + null, + null, + ); + default: + return null; + } + } +} + +class Item$reflection extends ClassReflection with __ReflectionMixin { + static final Expando _objectReflections = Expando(); + + factory Item$reflection([Item? object]) { + if (object == null) return staticInstance; + return _objectReflections[object] ??= Item$reflection._(object); + } + + Item$reflection._([Item? object]) : super(Item, r'Item', object); + + static bool _registered = false; + @override + void register() { + if (!_registered) { + _registered = true; + super.register(); + _registerSiblingsReflection(); + } + } + + @override + Version get languageVersion => Version.parse('3.7.0'); + + @override + Item$reflection withObject([Item? obj]) => + Item$reflection(obj)..setupInternalsWith(this); + + static Item$reflection? _withoutObjectInstance; + @override + Item$reflection withoutObjectInstance() => staticInstance; + + @override + Symbol? getSymbol(String? key) => _getSymbol(key); + + static Item$reflection get staticInstance => + _withoutObjectInstance ??= Item$reflection._(); + + @override + Item$reflection getStaticInstance() => staticInstance; + + static bool _boot = false; + static void boot() { + if (_boot) return; + _boot = true; + Item$reflection.staticInstance; + } + + @override + bool get hasDefaultConstructor => false; + @override + Item? createInstanceWithDefaultConstructor() => null; + + @override + bool get hasEmptyConstructor => true; + @override + Item? createInstanceWithEmptyConstructor() => Item.empty(); + @override + bool get hasNoRequiredArgsConstructor => true; + @override + Item? createInstanceWithNoRequiredArgsConstructor() => Item.empty(); + + static const List _constructorsNames = const ['', 'empty']; + + @override + List get constructorsNames => _constructorsNames; + + static final Map> _constructors = {}; + + @override + ConstructorReflection? constructor(String constructorName) { + var c = _constructors[constructorName]; + if (c != null) return c; + c = _constructorImpl(constructorName); + if (c == null) return null; + _constructors[constructorName] = c; + return c; + } + + ConstructorReflection? _constructorImpl(String constructorName) { + var lc = constructorName.trim().toLowerCase(); + + switch (lc) { + case '': + return ConstructorReflection( + this, + Item, + '', + () => Item.new, + const <__PR>[__PR(__TR.tString, 'name', false, true)], + null, + const { + 'bonus': __PR(__TR.tObject, 'bonus', true, false), + 'id': __PR(__TR.tInt, 'id', true, false), + }, + null, + ); + case 'empty': + return ConstructorReflection( + this, + Item, + 'empty', + () => Item.empty, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _classAnnotations = []; + + @override + List get classAnnotations => _classAnnotations; + + static const List _supperTypes = const [Entity]; + + @override + List get supperTypes => _supperTypes; + + @override + bool get hasMethodToJson => true; + + @override + Object? callMethodToJson([Item? obj]) { + obj ??= object; + return obj?.toJson(); + } + + static const List _fieldsNames = const [ + 'bonus', + 'fieldsNames', + 'id', + 'idFieldName', + 'name', + ]; + + @override + List get fieldsNames => _fieldsNames; + + static final Map> _fieldsNoObject = {}; + + final Map> _fieldsObject = {}; + + @override + FieldReflection? field(String fieldName, [Item? obj]) { + if (obj == null) { + if (object != null) { + return _fieldObjectImpl(fieldName); + } else { + return _fieldNoObjectImpl(fieldName); + } + } else if (identical(obj, object)) { + return _fieldObjectImpl(fieldName); + } + return _fieldNoObjectImpl(fieldName)?.withObject(obj); + } + + FieldReflection? _fieldNoObjectImpl(String fieldName) { + final f = _fieldsNoObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + final f2 = _fieldImpl(fieldName, null); + if (f2 == null) return null; + _fieldsNoObject[fieldName] = f2; + return f2 as FieldReflection; + } + + FieldReflection? _fieldObjectImpl(String fieldName) { + final f = _fieldsObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + var f2 = _fieldNoObjectImpl(fieldName); + if (f2 == null) return null; + f2 = f2.withObject(object!); + _fieldsObject[fieldName] = f2; + return f2; + } + + FieldReflection? _fieldImpl(String fieldName, Item? obj) { + obj ??= object; + + var lc = fieldName.trim().toLowerCase(); + + switch (lc) { + case 'id': + return FieldReflection( + this, + Item, + __TR.tInt, + 'id', + true, + (o) => () => o!.id, + (o) => (v) => o!.id = v, + obj, + false, + ); + case 'name': + return FieldReflection( + this, + Item, + __TR.tString, + 'name', + false, + (o) => () => o!.name, + (o) => (v) => o!.name = v, + obj, + false, + ); + case 'bonus': + return FieldReflection>( + this, + Item, + const __TR>(EntityReference, <__TR>[ + __TR(Bonus), + ]), + 'bonus', + false, + (o) => () => o!.bonus, + (o) => (v) => o!.bonus = v, + obj, + false, + ); + case 'idfieldname': + return FieldReflection( + this, + Item, + __TR.tString, + 'idFieldName', + false, + (o) => () => o!.idFieldName, + null, + obj, + false, + const [override], + ); + case 'fieldsnames': + return FieldReflection>( + this, + Item, + __TR.tListString, + 'fieldsNames', + false, + (o) => () => o!.fieldsNames, + null, + obj, + false, + const [JsonField.hidden(), override], + ); + default: + return null; + } + } + + @override + Map getFieldsValues(Item? obj, {bool withHashCode = false}) { + obj ??= object; + return { + 'id': obj?.id, + 'name': obj?.name, + 'bonus': obj?.bonus, + 'idFieldName': obj?.idFieldName, + 'fieldsNames': obj?.fieldsNames, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + @override + Map getJsonFieldsVisibleValues( + Item? obj, { + bool withHashCode = false, + }) { + obj ??= object; + return { + 'id': obj?.id, + 'name': obj?.name, + 'bonus': obj?.bonus, + 'idFieldName': obj?.idFieldName, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + static const List _staticFieldsNames = const []; + + @override + List get staticFieldsNames => _staticFieldsNames; + + @override + StaticFieldReflection? staticField(String fieldName) => null; + + static const List _methodsNames = const [ + 'getField', + 'getFieldEntityAnnotations', + 'getFieldType', + 'getID', + 'setField', + 'setID', + 'toJson', + 'toJsonEncoded', + ]; + + @override + List get methodsNames => _methodsNames; + + static final Map> _methodsNoObject = + {}; + + final Map> _methodsObject = {}; + + @override + MethodReflection? method(String methodName, [Item? obj]) { + if (obj == null) { + if (object != null) { + return _methodObjectImpl(methodName); + } else { + return _methodNoObjectImpl(methodName); + } + } else if (identical(obj, object)) { + return _methodObjectImpl(methodName); + } + return _methodNoObjectImpl(methodName)?.withObject(obj); + } + + MethodReflection? _methodNoObjectImpl(String methodName) { + final m = _methodsNoObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + final m2 = _methodImpl(methodName, null); + if (m2 == null) return null; + _methodsNoObject[methodName] = m2; + return m2 as MethodReflection; + } + + MethodReflection? _methodObjectImpl(String methodName) { + final m = _methodsObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + var m2 = _methodNoObjectImpl(methodName); + if (m2 == null) return null; + m2 = m2.withObject(object!); + _methodsObject[methodName] = m2; + return m2; + } + + MethodReflection? _methodImpl(String methodName, Item? obj) { + obj ??= object; + + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'getfield': + return MethodReflection( + this, + Item, + 'getField', + __TR.tDynamic, + true, + (o) => o!.getField, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'getfieldtype': + return MethodReflection?>( + this, + Item, + 'getFieldType', + const __TR>(TypeInfo, <__TR>[__TR.tDynamic]), + true, + (o) => o!.getFieldType, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'setfield': + return MethodReflection( + this, + Item, + 'setField', + __TR.tVoid, + false, + (o) => o!.setField, + obj, + const <__PR>[ + __PR(__TR.tString, 'key', false, true), + __PR(__TR.tDynamic, 'value', true, true), + ], + null, + null, + const [override], + ); + case 'tojson': + return MethodReflection>( + this, + Item, + 'toJson', + __TR.tMapStringDynamic, + false, + (o) => o!.toJson, + obj, + null, + null, + null, + const [override], + ); + case 'getid': + return MethodReflection( + this, + Entity, + 'getID', + __TR.tDynamic, + true, + (o) => o!.getID, + obj, + null, + null, + null, + null, + ); + case 'setid': + return MethodReflection( + this, + Entity, + 'setID', + __TR.tVoid, + false, + (o) => o!.setID, + obj, + const <__PR>[__PR(__TR.tDynamic, 'id', false, true)], + null, + null, + null, + ); + case 'getfieldentityannotations': + return MethodReflection?>( + this, + Entity, + 'getFieldEntityAnnotations', + const __TR>(List, <__TR>[ + __TR(EntityAnnotation), + ]), + true, + (o) => o!.getFieldEntityAnnotations, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + null, + ); + case 'tojsonencoded': + return MethodReflection( + this, + Entity, + 'toJsonEncoded', + __TR.tString, + false, + (o) => o!.toJsonEncoded, + obj, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _staticMethodsNames = const ['fromMap']; + + @override + List get staticMethodsNames => _staticMethodsNames; + + static final Map> + _staticMethods = {}; + + @override + StaticMethodReflection? staticMethod(String methodName) { + var m = _staticMethods[methodName]; + if (m != null) { + return m as StaticMethodReflection; + } + m = _staticMethodImpl(methodName); + if (m == null) return null; + _staticMethods[methodName] = m; + return m as StaticMethodReflection; + } + + StaticMethodReflection? _staticMethodImpl(String methodName) { + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'frommap': + return StaticMethodReflection>( + this, + Item, + 'fromMap', + const __TR>(FutureOr, <__TR>[__TR(Item)]), + false, + () => Item.fromMap, + const <__PR>[__PR(__TR.tMapStringDynamic, 'map', false, true)], + null, + null, + null, + ); + default: + return null; + } + } +} + +class Order$reflection extends ClassReflection with __ReflectionMixin { + static final Expando _objectReflections = Expando(); + + factory Order$reflection([Order? object]) { + if (object == null) return staticInstance; + return _objectReflections[object] ??= Order$reflection._(object); + } + + Order$reflection._([Order? object]) : super(Order, r'Order', object); + + static bool _registered = false; + @override + void register() { + if (!_registered) { + _registered = true; + super.register(); + _registerSiblingsReflection(); + } + } + + @override + Version get languageVersion => Version.parse('3.7.0'); + + @override + Order$reflection withObject([Order? obj]) => + Order$reflection(obj)..setupInternalsWith(this); + + static Order$reflection? _withoutObjectInstance; + @override + Order$reflection withoutObjectInstance() => staticInstance; + + @override + Symbol? getSymbol(String? key) => _getSymbol(key); + + static Order$reflection get staticInstance => + _withoutObjectInstance ??= Order$reflection._(); + + @override + Order$reflection getStaticInstance() => staticInstance; + + static bool _boot = false; + static void boot() { + if (_boot) return; + _boot = true; + Order$reflection.staticInstance; + } + + @override + bool get hasDefaultConstructor => false; + @override + Order? createInstanceWithDefaultConstructor() => null; + + @override + bool get hasEmptyConstructor => true; + @override + Order? createInstanceWithEmptyConstructor() => Order.empty(); + @override + bool get hasNoRequiredArgsConstructor => true; + @override + Order? createInstanceWithNoRequiredArgsConstructor() => Order.empty(); + + static const List _constructorsNames = const ['', 'empty']; + + @override + List get constructorsNames => _constructorsNames; + + static final Map> _constructors = {}; + + @override + ConstructorReflection? constructor(String constructorName) { + var c = _constructors[constructorName]; + if (c != null) return c; + c = _constructorImpl(constructorName); + if (c == null) return null; + _constructors[constructorName] = c; + return c; + } + + ConstructorReflection? _constructorImpl(String constructorName) { + var lc = constructorName.trim().toLowerCase(); + + switch (lc) { + case '': + return ConstructorReflection( + this, + Order, + '', + () => Order.new, + const <__PR>[__PR(__TR.tString, 'orderNumber', false, true)], + null, + const { + 'id': __PR(__TR.tInt, 'id', true, false), + 'items': __PR( + __TR>(List, <__TR>[__TR(Item)]), + 'items', + true, + false, + ), + }, + null, + ); + case 'empty': + return ConstructorReflection( + this, + Order, + 'empty', + () => Order.empty, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _classAnnotations = []; + + @override + List get classAnnotations => _classAnnotations; + + static const List _supperTypes = const [Entity]; + + @override + List get supperTypes => _supperTypes; + + @override + bool get hasMethodToJson => true; + + @override + Object? callMethodToJson([Order? obj]) { + obj ??= object; + return obj?.toJson(); + } + + static const List _fieldsNames = const [ + 'fieldsNames', + 'id', + 'idFieldName', + 'items', + 'orderNumber', + ]; + + @override + List get fieldsNames => _fieldsNames; + + static final Map> _fieldsNoObject = + {}; + + final Map> _fieldsObject = {}; + + @override + FieldReflection? field(String fieldName, [Order? obj]) { + if (obj == null) { + if (object != null) { + return _fieldObjectImpl(fieldName); + } else { + return _fieldNoObjectImpl(fieldName); + } + } else if (identical(obj, object)) { + return _fieldObjectImpl(fieldName); + } + return _fieldNoObjectImpl(fieldName)?.withObject(obj); + } + + FieldReflection? _fieldNoObjectImpl(String fieldName) { + final f = _fieldsNoObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + final f2 = _fieldImpl(fieldName, null); + if (f2 == null) return null; + _fieldsNoObject[fieldName] = f2; + return f2 as FieldReflection; + } + + FieldReflection? _fieldObjectImpl(String fieldName) { + final f = _fieldsObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + var f2 = _fieldNoObjectImpl(fieldName); + if (f2 == null) return null; + f2 = f2.withObject(object!); + _fieldsObject[fieldName] = f2; + return f2; + } + + FieldReflection? _fieldImpl(String fieldName, Order? obj) { + obj ??= object; + + var lc = fieldName.trim().toLowerCase(); + + switch (lc) { + case 'id': + return FieldReflection( + this, + Order, + __TR.tInt, + 'id', + true, + (o) => () => o!.id, + (o) => (v) => o!.id = v, + obj, + false, + ); + case 'ordernumber': + return FieldReflection( + this, + Order, + __TR.tString, + 'orderNumber', + false, + (o) => () => o!.orderNumber, + (o) => (v) => o!.orderNumber = v, + obj, + false, + ); + case 'items': + return FieldReflection>( + this, + Order, + const __TR>(List, <__TR>[__TR(Item)]), + 'items', + false, + (o) => () => o!.items, + (o) => (v) => o!.items = v, + obj, + false, + ); + case 'idfieldname': + return FieldReflection( + this, + Order, + __TR.tString, + 'idFieldName', + false, + (o) => () => o!.idFieldName, + null, + obj, + false, + const [override], + ); + case 'fieldsnames': + return FieldReflection>( + this, + Order, + __TR.tListString, + 'fieldsNames', + false, + (o) => () => o!.fieldsNames, + null, + obj, + false, + const [JsonField.hidden(), override], + ); + default: + return null; + } + } + + @override + Map getFieldsValues( + Order? obj, { + bool withHashCode = false, + }) { + obj ??= object; + return { + 'id': obj?.id, + 'orderNumber': obj?.orderNumber, + 'items': obj?.items, + 'idFieldName': obj?.idFieldName, + 'fieldsNames': obj?.fieldsNames, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + @override + Map getJsonFieldsVisibleValues( + Order? obj, { + bool withHashCode = false, + }) { + obj ??= object; + return { + 'id': obj?.id, + 'orderNumber': obj?.orderNumber, + 'items': obj?.items, + 'idFieldName': obj?.idFieldName, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + static const List _staticFieldsNames = const []; + + @override + List get staticFieldsNames => _staticFieldsNames; + + @override + StaticFieldReflection? staticField(String fieldName) => null; + + static const List _methodsNames = const [ + 'getField', + 'getFieldEntityAnnotations', + 'getFieldType', + 'getID', + 'setField', + 'setID', + 'toJson', + 'toJsonEncoded', + ]; + + @override + List get methodsNames => _methodsNames; + + static final Map> _methodsNoObject = + {}; + + final Map> _methodsObject = {}; + + @override + MethodReflection? method(String methodName, [Order? obj]) { + if (obj == null) { + if (object != null) { + return _methodObjectImpl(methodName); + } else { + return _methodNoObjectImpl(methodName); + } + } else if (identical(obj, object)) { + return _methodObjectImpl(methodName); + } + return _methodNoObjectImpl(methodName)?.withObject(obj); + } + + MethodReflection? _methodNoObjectImpl(String methodName) { + final m = _methodsNoObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + final m2 = _methodImpl(methodName, null); + if (m2 == null) return null; + _methodsNoObject[methodName] = m2; + return m2 as MethodReflection; + } + + MethodReflection? _methodObjectImpl(String methodName) { + final m = _methodsObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + var m2 = _methodNoObjectImpl(methodName); + if (m2 == null) return null; + m2 = m2.withObject(object!); + _methodsObject[methodName] = m2; + return m2; + } + + MethodReflection? _methodImpl(String methodName, Order? obj) { + obj ??= object; + + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'getfield': + return MethodReflection( + this, + Order, + 'getField', + __TR.tDynamic, + true, + (o) => o!.getField, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'getfieldtype': + return MethodReflection?>( + this, + Order, + 'getFieldType', + const __TR>(TypeInfo, <__TR>[__TR.tDynamic]), + true, + (o) => o!.getFieldType, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'setfield': + return MethodReflection( + this, + Order, + 'setField', + __TR.tVoid, + false, + (o) => o!.setField, + obj, + const <__PR>[ + __PR(__TR.tString, 'key', false, true), + __PR(__TR.tDynamic, 'value', true, true), + ], + null, + null, + const [override], + ); + case 'tojson': + return MethodReflection>( + this, + Order, + 'toJson', + __TR.tMapStringDynamic, + false, + (o) => o!.toJson, + obj, + null, + null, + null, + const [override], + ); + case 'getid': + return MethodReflection( + this, + Entity, + 'getID', + __TR.tDynamic, + true, + (o) => o!.getID, + obj, + null, + null, + null, + null, + ); + case 'setid': + return MethodReflection( + this, + Entity, + 'setID', + __TR.tVoid, + false, + (o) => o!.setID, + obj, + const <__PR>[__PR(__TR.tDynamic, 'id', false, true)], + null, + null, + null, + ); + case 'getfieldentityannotations': + return MethodReflection?>( + this, + Entity, + 'getFieldEntityAnnotations', + const __TR>(List, <__TR>[ + __TR(EntityAnnotation), + ]), + true, + (o) => o!.getFieldEntityAnnotations, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + null, + ); + case 'tojsonencoded': + return MethodReflection( + this, + Entity, + 'toJsonEncoded', + __TR.tString, + false, + (o) => o!.toJsonEncoded, + obj, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _staticMethodsNames = const ['fromMap']; + + @override + List get staticMethodsNames => _staticMethodsNames; + + static final Map> + _staticMethods = {}; + + @override + StaticMethodReflection? staticMethod(String methodName) { + var m = _staticMethods[methodName]; + if (m != null) { + return m as StaticMethodReflection; + } + m = _staticMethodImpl(methodName); + if (m == null) return null; + _staticMethods[methodName] = m; + return m as StaticMethodReflection; + } + + StaticMethodReflection? _staticMethodImpl(String methodName) { + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'frommap': + return StaticMethodReflection>( + this, + Order, + 'fromMap', + const __TR>(FutureOr, <__TR>[__TR(Order)]), + false, + () => Order.fromMap, + const <__PR>[__PR(__TR.tMapStringDynamic, 'map', false, true)], + null, + null, + null, + ); + default: + return null; + } + } +} + +extension Bonus$reflectionExtension on Bonus { + /// Returns a [ClassReflection] for type [Bonus]. (Generated by [ReflectionFactory]) + ClassReflection get reflection => Bonus$reflection(this); + + /// Returns a JSON [Map] for type [Bonus]. (Generated by [ReflectionFactory]) + Map? toJsonMap({bool duplicatedEntitiesAsID = false}) => + reflection.toJsonMap(duplicatedEntitiesAsID: duplicatedEntitiesAsID); + + /// Returns a JSON for type [Bonus] using the class fields. (Generated by [ReflectionFactory]) + Object? toJsonFromFields({bool duplicatedEntitiesAsID = false}) => reflection + .toJsonFromFields(duplicatedEntitiesAsID: duplicatedEntitiesAsID); +} + +extension Campaign$reflectionExtension on Campaign { + /// Returns a [ClassReflection] for type [Campaign]. (Generated by [ReflectionFactory]) + ClassReflection get reflection => Campaign$reflection(this); + + /// Returns a JSON [Map] for type [Campaign]. (Generated by [ReflectionFactory]) + Map? toJsonMap({bool duplicatedEntitiesAsID = false}) => + reflection.toJsonMap(duplicatedEntitiesAsID: duplicatedEntitiesAsID); + + /// Returns a JSON for type [Campaign] using the class fields. (Generated by [ReflectionFactory]) + Object? toJsonFromFields({bool duplicatedEntitiesAsID = false}) => reflection + .toJsonFromFields(duplicatedEntitiesAsID: duplicatedEntitiesAsID); +} + +extension Item$reflectionExtension on Item { + /// Returns a [ClassReflection] for type [Item]. (Generated by [ReflectionFactory]) + ClassReflection get reflection => Item$reflection(this); + + /// Returns a JSON [Map] for type [Item]. (Generated by [ReflectionFactory]) + Map? toJsonMap({bool duplicatedEntitiesAsID = false}) => + reflection.toJsonMap(duplicatedEntitiesAsID: duplicatedEntitiesAsID); + + /// Returns a JSON for type [Item] using the class fields. (Generated by [ReflectionFactory]) + Object? toJsonFromFields({bool duplicatedEntitiesAsID = false}) => reflection + .toJsonFromFields(duplicatedEntitiesAsID: duplicatedEntitiesAsID); +} + +extension Order$reflectionExtension on Order { + /// Returns a [ClassReflection] for type [Order]. (Generated by [ReflectionFactory]) + ClassReflection get reflection => Order$reflection(this); + + /// Returns a JSON [Map] for type [Order]. (Generated by [ReflectionFactory]) + Map? toJsonMap({bool duplicatedEntitiesAsID = false}) => + reflection.toJsonMap(duplicatedEntitiesAsID: duplicatedEntitiesAsID); + + /// Returns a JSON for type [Order] using the class fields. (Generated by [ReflectionFactory]) + Object? toJsonFromFields({bool duplicatedEntitiesAsID = false}) => reflection + .toJsonFromFields(duplicatedEntitiesAsID: duplicatedEntitiesAsID); +} + +List _listSiblingsReflection() => [ + Bonus$reflection(), + Campaign$reflection(), + Item$reflection(), + Order$reflection(), +]; + +List? _siblingsReflectionList; +List _siblingsReflection() => + _siblingsReflectionList ??= List.unmodifiable( + _listSiblingsReflection(), + ); + +bool _registerSiblingsReflectionCalled = false; +void _registerSiblingsReflection() { + if (_registerSiblingsReflectionCalled) return; + _registerSiblingsReflectionCalled = true; + var length = _listSiblingsReflection().length; + assert(length > 0); +} From 45154dc19ca7640f7a5747e4ab449c6637bfcf02 Mon Sep 17 00:00:00 2001 From: gmpassos Date: Wed, 14 Jan 2026 21:58:06 -0300 Subject: [PATCH 3/4] Add CampaignConfig entity and Multi-level Query: Order.items.bonus.campaign.config.open --- test/bones_api_entity_db_tests_base.dart | 75 +++ test/bones_api_test_entities_orders.dart | 99 ++- ...api_test_entities_orders.reflection.g.dart | 586 +++++++++++++++++- 3 files changed, 754 insertions(+), 6 deletions(-) diff --git a/test/bones_api_entity_db_tests_base.dart b/test/bones_api_entity_db_tests_base.dart index 40c7135..88cad4c 100644 --- a/test/bones_api_entity_db_tests_base.dart +++ b/test/bones_api_entity_db_tests_base.dart @@ -31,6 +31,7 @@ class TestEntityRepositoryProvider extends DBSQLEntityRepositoryProvider { final EntityHandler userInfoEntityHandler; final EntityHandler userEntityHandler; + final EntityHandler campaignConfigEntityHandler; final EntityHandler campaignEntityHandler; final EntityHandler bonusEntityHandler; final EntityHandler itemEntityHandler; @@ -42,6 +43,7 @@ class TestEntityRepositoryProvider extends DBSQLEntityRepositoryProvider { late final UserInfoAPIRepository userInfoAPIRepository; late final UserAPIRepository userAPIRepository; + late final CampaignConfigAPIRepository campaignConfigAPIRepository; late final CampaignAPIRepository campaignAPIRepository; late final BonusAPIRepository bonusAPIRepository; late final ItemAPIRepository itemAPIRepository; @@ -53,6 +55,7 @@ class TestEntityRepositoryProvider extends DBSQLEntityRepositoryProvider { this.roleEntityHandler, this.userInfoEntityHandler, this.userEntityHandler, + this.campaignConfigEntityHandler, this.campaignEntityHandler, this.bonusEntityHandler, this.itemEntityHandler, @@ -91,6 +94,11 @@ class TestEntityRepositoryProvider extends DBSQLEntityRepositoryProvider { ), DBSQLEntityRepository(adapter, 'user', userEntityHandler), // Order-related tables + DBSQLEntityRepository( + adapter, + 'campaign_config', + campaignConfigEntityHandler, + ), DBSQLEntityRepository( adapter, 'campaign', @@ -110,6 +118,7 @@ class TestEntityRepositoryProvider extends DBSQLEntityRepositoryProvider { userInfoAPIRepository = UserInfoAPIRepository(this), userAPIRepository = UserAPIRepository(this), // Order related repositories + campaignConfigAPIRepository = CampaignConfigAPIRepository(this), campaignAPIRepository = CampaignAPIRepository(this), bonusAPIRepository = BonusAPIRepository(this), itemAPIRepository = ItemAPIRepository(this), @@ -171,6 +180,7 @@ TestEntityRepositoryProvider createEntityRepositoryProvider( Role$reflection().entityHandler, UserInfo$reflection().entityHandler, User$reflection().entityHandler, + CampaignConfig$reflection().entityHandler, Campaign$reflection().entityHandler, Bonus$reflection().entityHandler, Item$reflection().entityHandler, @@ -185,6 +195,7 @@ TestEntityRepositoryProvider createEntityRepositoryProvider( roleEntityHandler..inspectObject(Role.empty()), userInfoEntityHandler..inspectObject(UserInfo.empty()), userEntityHandler..inspectObject(User.empty()), + campaignConfigEntityHandler..inspectObject(CampaignConfig.empty()), campaignEntityHandler..inspectObject(Campaign.empty()), bonusEntityHandler..inspectObject(Bonus.empty()), itemEntityHandler..inspectObject(Item.empty()), @@ -2243,6 +2254,70 @@ Future runAdapterTests( } }); + test( + 'Multi-level Query: Order.items.bonus.campaign.config.open == true', + () async { + { + final campaignRepo = entityRepositoryProvider.campaignAPIRepository; + final campaignConfigRepo = + entityRepositoryProvider.campaignConfigAPIRepository; + final bonusRepo = entityRepositoryProvider.bonusAPIRepository; + final itemRepo = entityRepositoryProvider.itemAPIRepository; + final orderRepo = entityRepositoryProvider.orderAPIRepository; + + // Create two campaign configs + var cfgOpen = CampaignConfig(open: true); + var cfgClosed = CampaignConfig(open: false); + var cfgOpenId = await campaignConfigRepo.store(cfgOpen); + var cfgClosedId = await campaignConfigRepo.store(cfgClosed); + expect(cfgOpenId, isNotNull); + expect(cfgClosedId, isNotNull); + + // Create campaigns referencing configs + var campaignOpen = Campaign('Promo Open', config: cfgOpenId); + var campaignClosed = Campaign('Promo Closed', config: cfgClosedId); + var campaignOpenId = await campaignRepo.store(campaignOpen); + var campaignClosedId = await campaignRepo.store(campaignClosed); + expect(campaignOpenId, isNotNull); + expect(campaignClosedId, isNotNull); + + // Create bonuses referencing campaigns + var bonusOpen = Bonus(campaign: campaignOpenId); + var bonusClosed = Bonus(campaign: campaignClosedId); + var bonusOpenId = await bonusRepo.store(bonusOpen); + var bonusClosedId = await bonusRepo.store(bonusClosed); + expect(bonusOpenId, isNotNull); + expect(bonusClosedId, isNotNull); + + // Create items referencing bonuses + var itemOpen = Item('WidgetA', bonus: bonusOpenId); + var itemClosed = Item('WidgetB', bonus: bonusClosedId); + var itemOpenId = await itemRepo.store(itemOpen); + var itemClosedId = await itemRepo.store(itemClosed); + expect(itemOpenId, isNotNull); + expect(itemClosedId, isNotNull); + + // Create orders + var orderOpen = Order('ORD-CONFIG-001', items: [itemOpen]); + var orderClosed = Order('ORD-CONFIG-002', items: [itemClosed]); + var orderOpenId = await orderRepo.store(orderOpen); + var orderClosedId = await orderRepo.store(orderClosed); + expect(orderOpenId, isNotNull); + expect(orderClosedId, isNotNull); + + // Query orders where items.bonus.campaign.config.open == true + var results = + (await orderRepo.selectByQuery( + ' items.bonus.campaign.config.open == ? ', + parameters: [true], + )).toList(); + + var numbers = results.map((o) => o.orderNumber).toList(); + expect(numbers, contains('ORD-CONFIG-001')); + expect(numbers, isNot(contains('ORD-CONFIG-002'))); + } + }, + ); test('populate', () async { var result = await entityRepositoryProvider.storeAllFromJson({ 'user': [ diff --git a/test/bones_api_test_entities_orders.dart b/test/bones_api_test_entities_orders.dart index 4e7d590..3604a8b 100644 --- a/test/bones_api_test_entities_orders.dart +++ b/test/bones_api_test_entities_orders.dart @@ -9,6 +9,13 @@ final campaignEntityHandler = GenericEntityHandler( typeName: 'Campaign', ); +final campaignConfigEntityHandler = GenericEntityHandler( + instantiatorDefault: CampaignConfig.empty, + instantiatorFromMap: CampaignConfig.fromMap, + type: CampaignConfig, + typeName: 'CampaignConfig', +); + final bonusEntityHandler = GenericEntityHandler( instantiatorDefault: Bonus.empty, instantiatorFromMap: Bonus.fromMap, @@ -30,6 +37,11 @@ final orderEntityHandler = GenericEntityHandler( typeName: 'Order', ); +class CampaignConfigAPIRepository extends APIRepository { + CampaignConfigAPIRepository(EntityRepositoryProvider provider) + : super(provider: provider); +} + class CampaignAPIRepository extends APIRepository { CampaignAPIRepository(EntityRepositoryProvider provider) : super(provider: provider); @@ -58,23 +70,86 @@ class OrderAPIRepository extends APIRepository { } } +@EnableReflection() +class CampaignConfig extends Entity { + int? id; + bool open; + + CampaignConfig({this.open = false, this.id}); + CampaignConfig.empty() : this(open: false); + + static FutureOr fromMap(Map map) => + CampaignConfig(open: map['open'] == true, id: map['id']); + + @override + String get idFieldName => 'id'; + + @JsonField.hidden() + @override + List get fieldsNames => const ['id', 'open']; + + @override + V? getField(String key) { + switch (key) { + case 'id': + return id as V?; + case 'open': + return open as V?; + default: + return null; + } + } + + @override + TypeInfo? getFieldType(String key) { + switch (key) { + case 'id': + return TypeInfo.tInt; + case 'open': + return TypeInfo.tBool; + default: + return null; + } + } + + @override + void setField(String key, V? value) { + switch (key) { + case 'id': + id = value as int?; + break; + case 'open': + open = value as bool; + break; + default: + return; + } + } + + @override + Map toJson() => {if (id != null) 'id': id, 'open': open}; +} + @EnableReflection() class Campaign extends Entity { int? id; String name; + EntityReference config; + + Campaign(this.name, {Object? config, this.id}) + : config = EntityReference.from(config); - Campaign(this.name, {this.id}); - Campaign.empty() : this(''); + Campaign.empty() : this('', config: null); static FutureOr fromMap(Map map) => - Campaign(map.getAsString('name')!, id: map['id']); + Campaign(map.getAsString('name')!, config: map['config'], id: map['id']); @override String get idFieldName => 'id'; @JsonField.hidden() @override - List get fieldsNames => const ['id', 'name']; + List get fieldsNames => const ['id', 'name', 'config']; @override V? getField(String key) { @@ -83,6 +158,8 @@ class Campaign extends Entity { return id as V?; case 'name': return name as V?; + case 'config': + return config as V?; default: return null; } @@ -95,6 +172,11 @@ class Campaign extends Entity { return TypeInfo.tInt; case 'name': return TypeInfo.tString; + case 'config': + return TypeInfo>.fromType( + EntityReference, + [TypeInfo.fromType(CampaignConfig)], + ); default: return null; } @@ -109,13 +191,20 @@ class Campaign extends Entity { case 'name': name = value as String; break; + case 'config': + config = EntityReference.from(value); + break; default: return; } } @override - Map toJson() => {if (id != null) 'id': id, 'name': name}; + Map toJson() => { + if (id != null) 'id': id, + 'name': name, + 'config': config.toJson(), + }; } @EnableReflection() diff --git a/test/bones_api_test_entities_orders.reflection.g.dart b/test/bones_api_test_entities_orders.reflection.g.dart index 6c3b06c..d1ef343 100644 --- a/test/bones_api_test_entities_orders.reflection.g.dart +++ b/test/bones_api_test_entities_orders.reflection.g.dart @@ -37,10 +37,14 @@ Symbol? _getSymbol(String? key) { return const Symbol(r"bonus"); case r"campaign": return const Symbol(r"campaign"); + case r"config": + return const Symbol(r"config"); case r"id": return const Symbol(r"id"); case r"items": return const Symbol(r"items"); + case r"open": + return const Symbol(r"open"); default: return null; } @@ -59,6 +63,12 @@ Campaign Campaign$fromJson(Map map) => Campaign Campaign$fromJsonEncoded(String jsonEncoded) => Campaign$reflection.staticInstance.fromJsonEncoded(jsonEncoded); // ignore: non_constant_identifier_names +CampaignConfig CampaignConfig$fromJson(Map map) => + CampaignConfig$reflection.staticInstance.fromJson(map); +// ignore: non_constant_identifier_names +CampaignConfig CampaignConfig$fromJsonEncoded(String jsonEncoded) => + CampaignConfig$reflection.staticInstance.fromJsonEncoded(jsonEncoded); +// ignore: non_constant_identifier_names Item Item$fromJson(Map map) => Item$reflection.staticInstance.fromJson(map); // ignore: non_constant_identifier_names @@ -673,7 +683,10 @@ class Campaign$reflection extends ClassReflection () => Campaign.new, const <__PR>[__PR(__TR.tString, 'name', false, true)], null, - const {'id': __PR(__TR.tInt, 'id', true, false)}, + const { + 'config': __PR(__TR.tObject, 'config', true, false), + 'id': __PR(__TR.tInt, 'id', true, false), + }, null, ); case 'empty': @@ -712,6 +725,7 @@ class Campaign$reflection extends ClassReflection } static const List _fieldsNames = const [ + 'config', 'fieldsNames', 'id', 'idFieldName', @@ -796,6 +810,20 @@ class Campaign$reflection extends ClassReflection obj, false, ); + case 'config': + return FieldReflection>( + this, + Campaign, + const __TR>(EntityReference, <__TR>[ + __TR(CampaignConfig), + ]), + 'config', + false, + (o) => () => o!.config, + (o) => (v) => o!.config = v, + obj, + false, + ); case 'idfieldname': return FieldReflection( this, @@ -836,6 +864,7 @@ class Campaign$reflection extends ClassReflection return { 'id': obj?.id, 'name': obj?.name, + 'config': obj?.config, 'idFieldName': obj?.idFieldName, 'fieldsNames': obj?.fieldsNames, if (withHashCode) 'hashCode': obj?.hashCode, @@ -851,6 +880,7 @@ class Campaign$reflection extends ClassReflection return { 'id': obj?.id, 'name': obj?.name, + 'config': obj?.config, 'idFieldName': obj?.idFieldName, if (withHashCode) 'hashCode': obj?.hashCode, }; @@ -1098,6 +1128,545 @@ class Campaign$reflection extends ClassReflection } } +class CampaignConfig$reflection extends ClassReflection + with __ReflectionMixin { + static final Expando _objectReflections = + Expando(); + + factory CampaignConfig$reflection([CampaignConfig? object]) { + if (object == null) return staticInstance; + return _objectReflections[object] ??= CampaignConfig$reflection._(object); + } + + CampaignConfig$reflection._([CampaignConfig? object]) + : super(CampaignConfig, r'CampaignConfig', object); + + static bool _registered = false; + @override + void register() { + if (!_registered) { + _registered = true; + super.register(); + _registerSiblingsReflection(); + } + } + + @override + Version get languageVersion => Version.parse('3.7.0'); + + @override + CampaignConfig$reflection withObject([CampaignConfig? obj]) => + CampaignConfig$reflection(obj)..setupInternalsWith(this); + + static CampaignConfig$reflection? _withoutObjectInstance; + @override + CampaignConfig$reflection withoutObjectInstance() => staticInstance; + + @override + Symbol? getSymbol(String? key) => _getSymbol(key); + + static CampaignConfig$reflection get staticInstance => + _withoutObjectInstance ??= CampaignConfig$reflection._(); + + @override + CampaignConfig$reflection getStaticInstance() => staticInstance; + + static bool _boot = false; + static void boot() { + if (_boot) return; + _boot = true; + CampaignConfig$reflection.staticInstance; + } + + @override + bool get hasDefaultConstructor => true; + @override + CampaignConfig? createInstanceWithDefaultConstructor() => CampaignConfig(); + + @override + bool get hasEmptyConstructor => true; + @override + CampaignConfig? createInstanceWithEmptyConstructor() => + CampaignConfig.empty(); + @override + bool get hasNoRequiredArgsConstructor => true; + @override + CampaignConfig? createInstanceWithNoRequiredArgsConstructor() => + CampaignConfig.empty(); + + static const List _constructorsNames = const ['', 'empty']; + + @override + List get constructorsNames => _constructorsNames; + + static final Map> + _constructors = {}; + + @override + ConstructorReflection? constructor(String constructorName) { + var c = _constructors[constructorName]; + if (c != null) return c; + c = _constructorImpl(constructorName); + if (c == null) return null; + _constructors[constructorName] = c; + return c; + } + + ConstructorReflection? _constructorImpl( + String constructorName, + ) { + var lc = constructorName.trim().toLowerCase(); + + switch (lc) { + case '': + return ConstructorReflection( + this, + CampaignConfig, + '', + () => CampaignConfig.new, + null, + null, + const { + 'id': __PR(__TR.tInt, 'id', true, false), + 'open': __PR(__TR.tBool, 'open', false, false, false), + }, + null, + ); + case 'empty': + return ConstructorReflection( + this, + CampaignConfig, + 'empty', + () => CampaignConfig.empty, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _classAnnotations = []; + + @override + List get classAnnotations => _classAnnotations; + + static const List _supperTypes = const [Entity]; + + @override + List get supperTypes => _supperTypes; + + @override + bool get hasMethodToJson => true; + + @override + Object? callMethodToJson([CampaignConfig? obj]) { + obj ??= object; + return obj?.toJson(); + } + + static const List _fieldsNames = const [ + 'fieldsNames', + 'id', + 'idFieldName', + 'open', + ]; + + @override + List get fieldsNames => _fieldsNames; + + static final Map> + _fieldsNoObject = {}; + + final Map> _fieldsObject = + {}; + + @override + FieldReflection? field( + String fieldName, [ + CampaignConfig? obj, + ]) { + if (obj == null) { + if (object != null) { + return _fieldObjectImpl(fieldName); + } else { + return _fieldNoObjectImpl(fieldName); + } + } else if (identical(obj, object)) { + return _fieldObjectImpl(fieldName); + } + return _fieldNoObjectImpl(fieldName)?.withObject(obj); + } + + FieldReflection? _fieldNoObjectImpl(String fieldName) { + final f = _fieldsNoObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + final f2 = _fieldImpl(fieldName, null); + if (f2 == null) return null; + _fieldsNoObject[fieldName] = f2; + return f2 as FieldReflection; + } + + FieldReflection? _fieldObjectImpl(String fieldName) { + final f = _fieldsObject[fieldName]; + if (f != null) { + return f as FieldReflection; + } + var f2 = _fieldNoObjectImpl(fieldName); + if (f2 == null) return null; + f2 = f2.withObject(object!); + _fieldsObject[fieldName] = f2; + return f2; + } + + FieldReflection? _fieldImpl( + String fieldName, + CampaignConfig? obj, + ) { + obj ??= object; + + var lc = fieldName.trim().toLowerCase(); + + switch (lc) { + case 'id': + return FieldReflection( + this, + CampaignConfig, + __TR.tInt, + 'id', + true, + (o) => () => o!.id, + (o) => (v) => o!.id = v, + obj, + false, + ); + case 'open': + return FieldReflection( + this, + CampaignConfig, + __TR.tBool, + 'open', + false, + (o) => () => o!.open, + (o) => (v) => o!.open = v, + obj, + false, + ); + case 'idfieldname': + return FieldReflection( + this, + CampaignConfig, + __TR.tString, + 'idFieldName', + false, + (o) => () => o!.idFieldName, + null, + obj, + false, + const [override], + ); + case 'fieldsnames': + return FieldReflection>( + this, + CampaignConfig, + __TR.tListString, + 'fieldsNames', + false, + (o) => () => o!.fieldsNames, + null, + obj, + false, + const [JsonField.hidden(), override], + ); + default: + return null; + } + } + + @override + Map getFieldsValues( + CampaignConfig? obj, { + bool withHashCode = false, + }) { + obj ??= object; + return { + 'id': obj?.id, + 'open': obj?.open, + 'idFieldName': obj?.idFieldName, + 'fieldsNames': obj?.fieldsNames, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + @override + Map getJsonFieldsVisibleValues( + CampaignConfig? obj, { + bool withHashCode = false, + }) { + obj ??= object; + return { + 'id': obj?.id, + 'open': obj?.open, + 'idFieldName': obj?.idFieldName, + if (withHashCode) 'hashCode': obj?.hashCode, + }; + } + + static const List _staticFieldsNames = const []; + + @override + List get staticFieldsNames => _staticFieldsNames; + + @override + StaticFieldReflection? staticField(String fieldName) => + null; + + static const List _methodsNames = const [ + 'getField', + 'getFieldEntityAnnotations', + 'getFieldType', + 'getID', + 'setField', + 'setID', + 'toJson', + 'toJsonEncoded', + ]; + + @override + List get methodsNames => _methodsNames; + + static final Map> + _methodsNoObject = {}; + + final Map> _methodsObject = + {}; + + @override + MethodReflection? method( + String methodName, [ + CampaignConfig? obj, + ]) { + if (obj == null) { + if (object != null) { + return _methodObjectImpl(methodName); + } else { + return _methodNoObjectImpl(methodName); + } + } else if (identical(obj, object)) { + return _methodObjectImpl(methodName); + } + return _methodNoObjectImpl(methodName)?.withObject(obj); + } + + MethodReflection? _methodNoObjectImpl( + String methodName, + ) { + final m = _methodsNoObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + final m2 = _methodImpl(methodName, null); + if (m2 == null) return null; + _methodsNoObject[methodName] = m2; + return m2 as MethodReflection; + } + + MethodReflection? _methodObjectImpl(String methodName) { + final m = _methodsObject[methodName]; + if (m != null) { + return m as MethodReflection; + } + var m2 = _methodNoObjectImpl(methodName); + if (m2 == null) return null; + m2 = m2.withObject(object!); + _methodsObject[methodName] = m2; + return m2; + } + + MethodReflection? _methodImpl( + String methodName, + CampaignConfig? obj, + ) { + obj ??= object; + + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'getfield': + return MethodReflection( + this, + CampaignConfig, + 'getField', + __TR.tDynamic, + true, + (o) => o!.getField, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'getfieldtype': + return MethodReflection?>( + this, + CampaignConfig, + 'getFieldType', + const __TR>(TypeInfo, <__TR>[__TR.tDynamic]), + true, + (o) => o!.getFieldType, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + const [override], + ); + case 'setfield': + return MethodReflection( + this, + CampaignConfig, + 'setField', + __TR.tVoid, + false, + (o) => o!.setField, + obj, + const <__PR>[ + __PR(__TR.tString, 'key', false, true), + __PR(__TR.tDynamic, 'value', true, true), + ], + null, + null, + const [override], + ); + case 'tojson': + return MethodReflection>( + this, + CampaignConfig, + 'toJson', + __TR.tMapStringDynamic, + false, + (o) => o!.toJson, + obj, + null, + null, + null, + const [override], + ); + case 'getid': + return MethodReflection( + this, + Entity, + 'getID', + __TR.tDynamic, + true, + (o) => o!.getID, + obj, + null, + null, + null, + null, + ); + case 'setid': + return MethodReflection( + this, + Entity, + 'setID', + __TR.tVoid, + false, + (o) => o!.setID, + obj, + const <__PR>[__PR(__TR.tDynamic, 'id', false, true)], + null, + null, + null, + ); + case 'getfieldentityannotations': + return MethodReflection?>( + this, + Entity, + 'getFieldEntityAnnotations', + const __TR>(List, <__TR>[ + __TR(EntityAnnotation), + ]), + true, + (o) => o!.getFieldEntityAnnotations, + obj, + const <__PR>[__PR(__TR.tString, 'key', false, true)], + null, + null, + null, + ); + case 'tojsonencoded': + return MethodReflection( + this, + Entity, + 'toJsonEncoded', + __TR.tString, + false, + (o) => o!.toJsonEncoded, + obj, + null, + null, + null, + null, + ); + default: + return null; + } + } + + static const List _staticMethodsNames = const ['fromMap']; + + @override + List get staticMethodsNames => _staticMethodsNames; + + static final Map> + _staticMethods = {}; + + @override + StaticMethodReflection? staticMethod( + String methodName, + ) { + var m = _staticMethods[methodName]; + if (m != null) { + return m as StaticMethodReflection; + } + m = _staticMethodImpl(methodName); + if (m == null) return null; + _staticMethods[methodName] = m; + return m as StaticMethodReflection; + } + + StaticMethodReflection? _staticMethodImpl( + String methodName, + ) { + var lc = methodName.trim().toLowerCase(); + + switch (lc) { + case 'frommap': + return StaticMethodReflection>( + this, + CampaignConfig, + 'fromMap', + const __TR>(FutureOr, <__TR>[ + __TR(CampaignConfig), + ]), + false, + () => CampaignConfig.fromMap, + const <__PR>[__PR(__TR.tMapStringDynamic, 'map', false, true)], + null, + null, + null, + ); + default: + return null; + } + } +} + class Item$reflection extends ClassReflection with __ReflectionMixin { static final Expando _objectReflections = Expando(); @@ -2173,6 +2742,20 @@ extension Campaign$reflectionExtension on Campaign { .toJsonFromFields(duplicatedEntitiesAsID: duplicatedEntitiesAsID); } +extension CampaignConfig$reflectionExtension on CampaignConfig { + /// Returns a [ClassReflection] for type [CampaignConfig]. (Generated by [ReflectionFactory]) + ClassReflection get reflection => + CampaignConfig$reflection(this); + + /// Returns a JSON [Map] for type [CampaignConfig]. (Generated by [ReflectionFactory]) + Map? toJsonMap({bool duplicatedEntitiesAsID = false}) => + reflection.toJsonMap(duplicatedEntitiesAsID: duplicatedEntitiesAsID); + + /// Returns a JSON for type [CampaignConfig] using the class fields. (Generated by [ReflectionFactory]) + Object? toJsonFromFields({bool duplicatedEntitiesAsID = false}) => reflection + .toJsonFromFields(duplicatedEntitiesAsID: duplicatedEntitiesAsID); +} + extension Item$reflectionExtension on Item { /// Returns a [ClassReflection] for type [Item]. (Generated by [ReflectionFactory]) ClassReflection get reflection => Item$reflection(this); @@ -2202,6 +2785,7 @@ extension Order$reflectionExtension on Order { List _listSiblingsReflection() => [ Bonus$reflection(), Campaign$reflection(), + CampaignConfig$reflection(), Item$reflection(), Order$reflection(), ]; From 3b1c3eb1792eb2eb326471efb605e06e695d2efd Mon Sep 17 00:00:00 2001 From: gmpassos Date: Wed, 14 Jan 2026 21:59:06 -0300 Subject: [PATCH 4/4] clean code --- test/bones_api_entity_db_tests_base.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/bones_api_entity_db_tests_base.dart b/test/bones_api_entity_db_tests_base.dart index 88cad4c..8600fc9 100644 --- a/test/bones_api_entity_db_tests_base.dart +++ b/test/bones_api_entity_db_tests_base.dart @@ -2211,7 +2211,7 @@ Future runAdapterTests( } }); - test('Multi-level Query: Order.items.bonus.campaign query', () async { + test('Multi-level Query: Order.items.bonus.campaign == ?', () async { ////////// {