classDefinition function

Class classDefinition(
  1. GraphQLScanResult model,
  2. NameNode nameNode, {
  3. required bool toJson,
  4. required bool toMap,
  5. required bool fromJson,
  6. required bool isInput,
  7. bool isData = false,
  8. Iterable<String> subTypes = const {},
  9. required bool isJoinRecord,
  10. Iterable<String> interfaces = const [],
  11. Iterable<String> extraMixins = const [],
  12. required Iterable<FieldDefinition> fields,
  13. required List<DirectiveNode> directives,
  14. bool isAbstract = false,
  15. ClassSnippetGenerator? extraGenerator,
})

Implementation

Class classDefinition(
  GraphQLScanResult model,
  NameNode nameNode, {
  required bool toJson,
  required bool toMap,
  required bool fromJson,
  required bool isInput,
  bool isData = false,
  Iterable<String> subTypes = const {},
  required bool isJoinRecord,
  Iterable<String> interfaces = const [],
  Iterable<String> extraMixins = const [],
  required Iterable<FieldDefinition> fields,
  required List<DirectiveNode> directives,
  bool isAbstract = false,
  ClassSnippetGenerator? extraGenerator,
}) {
  String name = nameNode.value;
  String? mixin = model.getMixin(name);
  final match = nameRegex.firstMatch(nameNode.value);
  final suffix = (match?.group(1) ?? '') + (isInput ? 'Input' : '');
  var rootName = nameNode.value.replaceAll(nameRegex, '');
  var sourceFields = fields.where((s) => !s.name.endsWith('Connection'));

  if (name.endsWith('Where')) {
    sourceFields = sourceFields.where((element) => element.name == 'id');
  }

  var c = Class(
    (classDef) {
      final isJoinInterface = directives.hasDirective('relationshipProperties');
      if (isJoinInterface) {
        isAbstract = false;
        isJoinRecord = true;
        classDef..implements.add(refer("JoinRecordData"));
      }

      final annotatedMixins =
          isInput ? directives.mixinInputNames : directives.mixinNames;
      final annotatedInterfaces =
          isInput ? directives.interfaceInputNames : directives.interfaceNames;
      var ifaces = <String>{
        for (var extra in model.getExtraInterfaces(rootName))
          '${extra.toDartType(withNullability: false)}${suffix}',
        ...annotatedInterfaces,
        for (var iface in interfaces)
          if (!iface.contains("Mixin")) iface,
      };

      var mixins = <String>{
        ...annotatedMixins,
        if (mixin.isNotNullOrBlank) mixin!,
        for (var iface in interfaces)
          if (iface.contains("Mixin")) iface,
      };

      classDef
        ..name = name
        ..abstract = isAbstract
        ..mixins.addAll([
          if (!isAbstract)
            for (var mixin in mixins) refer(mixin),
        ])
        ..implements.addAll([
          if (isData && !isAbstract)
            refer('${name}Data')
          else ...[
            for (var interface in ifaces) refer(interface),
          ]
        ]);

      if (subTypes.isNotEmpty) {
        buildBaseClass(
          classDef,
          toJson: toJson,
          toMap: toMap,
          isInput: isInput,
          subTypes: subTypes.toSet(),
          sourceFields: sourceFields,
        );
        return;
      } else if (isAbstract) {
        buildAbstractClass(
          classDef,
          toJson: toJson,
          toMap: toMap,
          sourceFields: sourceFields,
          isData: isData,
        );
        return;
      }

      if (!isJoinRecord) {
        classDef..implements.add(refer('MBaseModel'));
      }

      if (isInput) {
        buildInputClass(
          classDef,
          directives: directives,
          sourceFields: sourceFields,
          allFields: fields,
        );
      } else if (!isInput) {
        buildNonInputClass(
          classDef,
          sourceFields: sourceFields,
          name: name,
          directives: directives,
          isEntity: !isJoinRecord,
        );
      }

      extraGenerator?.call(classDef, nameNode.value, fields, isAbstract);
    },
  );

  return c;
}