feat: golang map types unioned with possible 'null' (#18)

* feat: golang map types unioned with possible 'null'

Golang `map[<key>]<value>` can be `null` in json. This change unions
the Record type with `null`.
To revert to the previous behavior, use the mutation 'NotNullMaps'

Author: Emyrk

config/mutations.go

@@ -269,3 +269,39 @@ func (v *nullUnionVisitor) Visit(node bindings.Node) walk.Visitor {
 
 	return v
 }
+
+// NotNullMaps assumes all maps will not be null.
+// Example:
+// GolangType: map[string]string
+// TsType: Record<string,string> | null --> Record<string,string>
+func NotNullMaps(ts *guts.Typescript) {
+	ts.ForEach(func(key string, node bindings.Node) {
+		walk.Walk(&notNullMaps{}, node)
+	})
+}
+
+type notNullMaps struct{}
+
+func (v *notNullMaps) Visit(node bindings.Node) walk.Visitor {
+	if union, ok := node.(*bindings.UnionType); ok && len(union.Types) == 2 {
+		hasNull := slices.ContainsFunc(union.Types, func(t bindings.ExpressionType) bool {
+			_, isNull := t.(*bindings.Null)
+			return isNull
+		})
+
+		var record bindings.ExpressionType
+		index := slices.IndexFunc(union.Types, func(t bindings.ExpressionType) bool {
+			ref, isRef := t.(*bindings.ReferenceType)
+			if !isRef {
+				return false
+			}
+			return ref.Name.Name == "Record"
+		})
+		if hasNull && index != -1 {
+			record = union.Types[index]
+			union.Types = []bindings.ExpressionType{record}
+		}
+	}
+
+	return v
+}

convert.go

@@ -801,7 +801,8 @@ func (ts *Typescript) typescriptType(ty types.Type) (parsedType, error) {
 			return parsedType{}, xerrors.Errorf("simplify generics in map: %w", err)
 		}
 		parsed := parsedType{
-			Value:          RecordReference(keyType.Value, valueType.Value),
+			// Golang `map` can be marshaled to `null` in json.
+			Value:          bindings.Union(RecordReference(keyType.Value, valueType.Value), &bindings.Null{}),
 			TypeParameters: tp,
 			RaisedComments: append(keyType.RaisedComments, valueType.RaisedComments...),
 		}

convert_test.go

@@ -117,3 +117,27 @@ func TestGeneration(t *testing.T) {
 		})
 	}
 }
+
+func TestNotNullMaps(t *testing.T) {
+	gen, err := guts.NewGolangParser()
+	require.NoError(t, err, "new convert")
+
+	dir := filepath.Join(".", "testdata", "maps")
+	err = gen.IncludeGenerate("./" + dir)
+	require.NoErrorf(t, err, "include %q", dir)
+
+	gen.IncludeCustomDeclaration(config.StandardMappings())
+
+	ts, err := gen.ToTypescript()
+	require.NoError(t, err, "to typescript")
+
+	ts.ApplyMutations(
+		config.NotNullMaps,
+	)
+
+	output, err := ts.Serialize()
+	require.NoErrorf(t, err, "generate %q", dir)
+
+	// Not perfect, this asserts if the record is a nullable type.
+	require.Contains(t, output, "SimpleMap: Record<string, string>;", "no nullable Record")
+}

testdata/anyreference/anyreference.ts

@@ -2,7 +2,7 @@
 
 // From anyreference/anyreference.go
 export interface Example {
-    readonly Value: Record<string, string>;
+    readonly Value: Record<string, string> | null;
 }
 
 // From anyreference/anyreference.go

testdata/genericmap/genericmap.go

@@ -17,12 +17,10 @@ type Custom interface {
 	Foo | Buzz
 }
 
-// Not yet supported
-//type FooBuzzMap[R Custom] struct {
-//	Something map[string]R `json:"something"`
-//}
+type FooBuzzMap[R Custom] struct {
+	Something map[string]R `json:"something"`
+}
 
-// Not yet supported
-//type FooBuzzAnonymousUnion[R Foo | Buzz] struct {
-//	Something []R `json:"something"`
-//}
+type FooBuzzAnonymousUnion[R Foo | Buzz] struct {
+	Something []R `json:"something"`
+}

testdata/genericmap/genericmap.ts

@@ -18,3 +18,13 @@ export interface Foo {
 export interface FooBuzz<R extends Custom> {
     readonly something: readonly R[];
 }
+
+// From codersdk/genericmap.go
+export interface FooBuzzAnonymousUnion<R extends Foo | Buzz> {
+    readonly something: readonly R[];
+}
+
+// From codersdk/genericmap.go
+export interface FooBuzzMap<R extends Custom> {
+    readonly something: Record<string, R> | null;
+}

testdata/maps/maps.ts

@@ -2,7 +2,7 @@
 
 // From maps/map.go
 export interface Bar<T extends any> {
-    readonly SimpleMap: Record<string, string>;
-    readonly NumberMap: Record<string, number>;
-    readonly GenericMap: Record<string, T>;
+    readonly SimpleMap: Record<string, string> | null;
+    readonly NumberMap: Record<string, number> | null;
+    readonly GenericMap: Record<string, T> | null;
 }