Custom Map Types

Custom Map Types

Author: TimWhiting

json_serializable/lib/src/type_helpers/json_helper.dart

@@ -11,10 +11,13 @@ import 'package:source_gen/source_gen.dart';
 import 'package:source_helper/source_helper.dart';
 
 import '../default_container.dart';
+import '../shared_checkers.dart';
 import '../type_helper.dart';
+import '../unsupported_type_error.dart';
 import '../utils.dart';
 import 'config_types.dart';
 import 'generic_factory_helper.dart';
+import 'to_from_string.dart';
 
 const _helperLambdaParam = 'value';
 
@@ -49,11 +52,13 @@ class JsonHelper extends TypeHelper<TypeHelperContextWithConfig> {
 
       toJsonArgs.addAll(
         _helperParams(
+          context,
           context.serialize,
           _encodeHelper,
           interfaceType,
           toJson.parameters.where((element) => element.isRequiredPositional),
           toJson,
+          isSerializing: true,
         ),
       );
     }
@@ -109,11 +114,13 @@ class JsonHelper extends TypeHelper<TypeHelperContextWithConfig> {
       final args = [
         output,
         ..._helperParams(
+          context,
           context.deserialize,
           _decodeHelper,
           targetType,
           positionalParams.skip(1),
           fromJsonCtor,
+          isSerializing: false,
         ),
       ];
 
@@ -137,13 +144,16 @@ class JsonHelper extends TypeHelper<TypeHelperContextWithConfig> {
 }
 
 List<String> _helperParams(
+  TypeHelperContextWithConfig context,
   Object? Function(DartType, String) execute,
-  TypeParameterType Function(ParameterElement, Element) paramMapper,
+  TypeParameterTypeWithKeyHelper Function(ParameterElement, Element)
+      paramMapper,
   InterfaceType type,
   Iterable<ParameterElement> positionalParams,
-  Element targetElement,
-) {
-  final rest = <TypeParameterType>[];
+  Element targetElement, {
+  required bool isSerializing,
+}) {
+  final rest = <TypeParameterTypeWithKeyHelper>[];
   for (var param in positionalParams) {
     rest.add(paramMapper(param, targetElement));
   }
@@ -152,18 +162,26 @@ List<String> _helperParams(
 
   for (var helperArg in rest) {
     final typeParamIndex =
-        type.element.typeParameters.indexOf(helperArg.element);
+        type.element.typeParameters.indexOf(helperArg.type.element);
 
     // TODO: throw here if `typeParamIndex` is -1 ?
     final typeArg = type.typeArguments[typeParamIndex];
     final body = execute(typeArg, _helperLambdaParam);
-    args.add('($_helperLambdaParam) => $body');
+    if (helperArg.isJsonKey) {
+      const keyHelper = MapKeyHelper();
+      final newBody = isSerializing
+          ? keyHelper.serialize(typeArg, '', context)
+          : keyHelper.deserialize(typeArg, '', context, false);
+      args.add('($_helperLambdaParam) => $newBody');
+    } else {
+      args.add('($_helperLambdaParam) => $body');
+    }
   }
 
   return args;
 }
 
-TypeParameterType _decodeHelper(
+TypeParameterTypeWithKeyHelper _decodeHelper(
   ParameterElement param,
   Element targetElement,
 ) {
@@ -178,8 +196,11 @@ TypeParameterType _decodeHelper(
       final funcParamType = type.normalParameterTypes.single;
 
       if ((funcParamType.isDartCoreObject && funcParamType.isNullableType) ||
-          funcParamType.isDynamic) {
-        return funcReturnType as TypeParameterType;
+          funcParamType.isDynamic ||
+          funcParamType.isDartCoreString) {
+        return TypeParameterTypeWithKeyHelper(
+            funcReturnType as TypeParameterType,
+            funcParamType.isDartCoreString);
       }
     }
   }
@@ -194,20 +215,30 @@ TypeParameterType _decodeHelper(
   );
 }
 
-TypeParameterType _encodeHelper(
+class TypeParameterTypeWithKeyHelper {
+  final TypeParameterType type;
+  final bool isJsonKey;
+
+  TypeParameterTypeWithKeyHelper(this.type, this.isJsonKey);
+}
+
+TypeParameterTypeWithKeyHelper _encodeHelper(
   ParameterElement param,
   Element targetElement,
 ) {
   final type = param.type;
 
   if (type is FunctionType &&
-      (type.returnType.isDartCoreObject || type.returnType.isDynamic) &&
+      (type.returnType.isDartCoreObject ||
+          type.returnType.isDynamic ||
+          type.returnType.isDartCoreString) &&
       type.normalParameterTypes.length == 1) {
     final funcParamType = type.normalParameterTypes.single;
 
     if (param.name == toJsonForName(funcParamType.element!.name!)) {
       if (funcParamType is TypeParameterType) {
-        return funcParamType;
+        return TypeParameterTypeWithKeyHelper(
+            funcParamType, type.returnType.isDartCoreString);
       }
     }
   }
@@ -290,3 +321,118 @@ ClassConfig? _annotation(ClassConfig config, InterfaceType source) {
 MethodElement? _toJsonMethod(DartType type) => type.typeImplementations
     .map((dt) => dt is InterfaceType ? dt.getMethod('toJson') : null)
     .firstWhereOrNull((me) => me != null);
+
+class MapKeyHelper extends TypeHelper<TypeHelperContextWithConfig> {
+  const MapKeyHelper();
+
+  @override
+  String? serialize(
+    DartType targetType,
+    String expression,
+    TypeHelperContextWithConfig context,
+  ) {
+    final keyType = targetType;
+
+    _checkSafeKeyType(expression, keyType);
+
+    final subKeyValue =
+        _forType(keyType)?.serialize(keyType, _helperLambdaParam, false) ??
+            context.serialize(keyType, _helperLambdaParam);
+
+    if (_helperLambdaParam == subKeyValue) {
+      return expression;
+    }
+
+    return '$subKeyValue';
+  }
+
+  @override
+  String? deserialize(
+    DartType targetType,
+    String expression,
+    TypeHelperContextWithConfig context,
+    bool defaultProvided,
+  ) {
+    final keyArg = targetType;
+
+    _checkSafeKeyType(expression, keyArg);
+
+    final isKeyStringable = _isKeyStringable(keyArg);
+    if (!isKeyStringable) {
+      throw UnsupportedTypeError(
+        keyArg,
+        expression,
+        'Map keys must be one of: ${_allowedTypeNames.join(', ')}.',
+      );
+    }
+
+    String keyUsage;
+    if (keyArg.isEnum) {
+      keyUsage = context.deserialize(keyArg, _helperLambdaParam).toString();
+    } else if (context.config.anyMap &&
+        !(keyArg.isDartCoreObject || keyArg.isDynamic)) {
+      keyUsage = '$_helperLambdaParam as String';
+    } else if (context.config.anyMap &&
+        keyArg.isDartCoreObject &&
+        !keyArg.isNullableType) {
+      keyUsage = '$_helperLambdaParam as Object';
+    } else {
+      keyUsage = '$_helperLambdaParam as String';
+    }
+
+    final toFromString = _forType(keyArg);
+    if (toFromString != null) {
+      keyUsage = toFromString.deserialize(keyArg, keyUsage, false, true)!;
+    }
+
+    return keyUsage;
+  }
+}
+
+final _intString = ToFromStringHelper('int.parse', 'toString()', 'int');
+
+/// [ToFromStringHelper] instances representing non-String types that can
+/// be used as [Map] keys.
+final _instances = [
+  bigIntString,
+  dateTimeString,
+  _intString,
+  uriString,
+];
+
+ToFromStringHelper? _forType(DartType type) =>
+    _instances.singleWhereOrNull((i) => i.matches(type));
+
+/// Returns `true` if [keyType] can be automatically converted to/from String –
+/// and is therefor usable as a key in a [Map].
+bool _isKeyStringable(DartType keyType) =>
+    keyType.isEnum || _instances.any((inst) => inst.matches(keyType));
+
+void _checkSafeKeyType(String expression, DartType keyArg) {
+  // We're not going to handle converting key types at the moment
+  // So the only safe types for key are dynamic/Object/String/enum
+  if (keyArg.isDynamic ||
+      (!keyArg.isNullableType &&
+          (keyArg.isDartCoreObject ||
+              coreStringTypeChecker.isExactlyType(keyArg) ||
+              _isKeyStringable(keyArg)))) {
+    return;
+  }
+
+  throw UnsupportedTypeError(
+    keyArg,
+    expression,
+    'Map keys must be one of: ${_allowedTypeNames.join(', ')}.',
+  );
+}
+
+/// The names of types that can be used as [Map] keys.
+///
+/// Used in [_checkSafeKeyType] to provide a helpful error with unsupported
+/// types.
+Iterable<String> get _allowedTypeNames => const [
+      'Object',
+      'dynamic',
+      'enum',
+      'String',
+    ].followedBy(_instances.map((i) => i.coreTypeName));

json_serializable/test/generic_files/generic_argument_factories.dart

@@ -50,3 +50,33 @@ class ConcreteClass {
 
   Map<String, dynamic> toJson() => _$ConcreteClassToJson(this);
 }
+
+class CustomMap<K, V> {
+  final Map<K, V> map;
+
+  CustomMap(this.map);
+
+  factory CustomMap.fromJson(
+    Map<String, dynamic> json,
+    K Function(String?) fromJsonK,
+    V Function(Object?) fromJsonV,
+  ) =>
+      CustomMap(json.map<K, V>(
+          (key, value) => MapEntry(fromJsonK(key), fromJsonV(value))));
+
+  Map<String?, dynamic> toJson(
+          String? Function(K) toJsonK, Object? Function(V) toJsonV) =>
+      map.map((key, value) => MapEntry(toJsonK(key), toJsonV(value)));
+}
+
+@JsonSerializable()
+class UseOfCustomMap {
+  final CustomMap<int, String> map;
+
+  UseOfCustomMap(this.map);
+
+  factory UseOfCustomMap.fromJson(Map<String, dynamic> json) =>
+      _$UseOfCustomMapFromJson(json);
+
+  Map<String, dynamic> toJson() => _$UseOfCustomMapToJson(this);
+}