Auto snake case (#377)

This builds on top of #376 by adding a configuration option to
automatically convert all snake_case type and field names to CamelCase.

Author: clinta

docs/CHANGELOG.md

@@ -25,6 +25,7 @@ When releasing a new version:
 ### New features:
 
 - Added `@genqlient(alias)` directive to customize field names without requiring GraphQL aliases (fixes #367)
+- Added `auto_camel_case` config option to automatically convert snake_case to camelCase in both field names and type names
 
 ### Bug fixes:
 

docs/genqlient.yaml

@@ -241,8 +241,7 @@ bindings:
 package_bindings:
 - package: github.com/you/yourpkg/models
 
-# Configuration for genqlient's smart-casing.
-#
+
 # By default genqlient tries to convert GraphQL type names to Go style
 # automatically. Sometimes it doesn't do a great job; this suite of options
 # lets you configure its algorithm as makes sense for your schema.
@@ -254,7 +253,11 @@ package_bindings:
 # - raw: map the GraphQL type exactly; don't try to convert it to Go style.
 #   This is usually best for schemas with casing conflicts, e.g. enums with
 #   values which differ only in casing.
+# - auto_camel_case: automatically convert snake_case to camelCase names before
+#   standard processing. This applies to field names, type names and enum values.
 casing:
+  # The default casing algorithm to use for all GraphQL names (fields, types, etc.).
+  default: auto_camel_case
   # Use the given casing-style (see above) for all GraphQL enum values.
   all_enums: raw
   # Use the given casing-style (see above) for the enum values in the given

generate/config.go

@@ -71,13 +71,14 @@ type PackageBinding struct {
 type CasingAlgorithm string
 
 const (
-	CasingDefault CasingAlgorithm = "default"
-	CasingRaw     CasingAlgorithm = "raw"
+	CasingDefault       CasingAlgorithm = "default"
+	CasingRaw           CasingAlgorithm = "raw"
+	CasingAutoCamelCase CasingAlgorithm = "auto_camel_case"
 )
 
 func (algo CasingAlgorithm) validate() error {
 	switch algo {
-	case CasingDefault, CasingRaw:
+	case CasingDefault, CasingRaw, CasingAutoCamelCase:
 		return nil
 	default:
 		return errorf(nil, "unknown casing algorithm: %s", algo)
@@ -89,11 +90,17 @@ func (algo CasingAlgorithm) validate() error {
 //
 // [genqlient.yaml docs]: https://github.com/Khan/genqlient/blob/main/docs/genqlient.yaml
 type Casing struct {
+	Default  CasingAlgorithm            `yaml:"default"`
 	AllEnums CasingAlgorithm            `yaml:"all_enums"`
 	Enums    map[string]CasingAlgorithm `yaml:"enums"`
 }
 
 func (casing *Casing) validate() error {
+	if casing.Default != "" {
+		if err := casing.Default.validate(); err != nil {
+			return err
+		}
+	}
 	if casing.AllEnums != "" {
 		if err := casing.AllEnums.validate(); err != nil {
 			return err
@@ -107,14 +114,21 @@ func (casing *Casing) validate() error {
 	return nil
 }
 
+func (casing *Casing) getDefault() CasingAlgorithm {
+	if casing.Default != "" {
+		return casing.Default
+	}
+	return CasingDefault
+}
+
 func (casing *Casing) forEnum(graphQLTypeName string) CasingAlgorithm {
 	if specificConfig, ok := casing.Enums[graphQLTypeName]; ok {
 		return specificConfig
 	}
 	if casing.AllEnums != "" {
 		return casing.AllEnums
 	}
-	return CasingDefault
+	return casing.getDefault()
 }
 
 // pathJoin is like filepath.Join but 1) it only takes two argsuments,
@@ -370,3 +384,8 @@ func findCfgInDir(dir string) string {
 	}
 	return ""
 }
+
+// GetDefaultCasingAlgorithm returns the default casing algorithm for the config.
+func (c *Config) GetDefaultCasingAlgorithm() CasingAlgorithm {
+	return c.Casing.getDefault()
+}

generate/convert.go

@@ -171,7 +171,8 @@ func (g *generator) convertArguments(
 			return nil, err
 		}
 
-		goName := upperFirst(arg.Variable)
+		goName := arg.Variable
+		goName = ApplyCasing(goName, g.Config.GetDefaultCasingAlgorithm(), true)
 		// Some of the arguments don't apply here, namely the name-prefix (see
 		// names.go) and the selection-set (we use all the input type's fields,
 		// and so on recursively).  See also the `case ast.InputObject` in
@@ -345,7 +346,7 @@ func (g *generator) convertDefinition(
 			// name-prefix, append the type-name anyway.  This happens when you
 			// assign a type name to an interface type, and we are generating
 			// one of its implementations.
-			name = makeLongTypeName(namePrefix, def.Name)
+			name = makeLongTypeName(namePrefix, def.Name, g.Config.GetDefaultCasingAlgorithm())
 		}
 		// (But the prefix is shared.)
 		namePrefix = newPrefixList(options.TypeName)
@@ -354,11 +355,11 @@ func (g *generator) convertDefinition(
 		// ever possibly generate for this type, so we don't need any of the
 		// qualifiers.  This is especially helpful because the caller is very
 		// likely to need to reference these types in their code.
-		name = upperFirst(def.Name)
+		name = ApplyCasing(def.Name, g.Config.GetDefaultCasingAlgorithm(), true)
 		// (namePrefix is ignored in this case.)
 	} else {
 		// Else, construct a name using the usual algorithm (see names.go).
-		name = makeTypeName(namePrefix, def.Name)
+		name = makeTypeName(namePrefix, def.Name, g.Config.GetDefaultCasingAlgorithm())
 	}
 
 	// If we already generated the type, we can skip it as long as it matches
@@ -433,7 +434,8 @@ func (g *generator) convertDefinition(
 				return nil, err
 			}
 
-			goName := upperFirst(field.Name)
+			goName := field.Name
+			goName = ApplyCasing(goName, g.Config.GetDefaultCasingAlgorithm(), true)
 			// Several of the arguments don't really make sense here:
 			// (note field.Type is necessarily a scalar, input, or enum)
 			//  - namePrefix is ignored for input types and enums (see
@@ -917,12 +919,14 @@ func (g *generator) convertField(
 			field.Position, "undefined field %v", field.Alias)
 	}
 
-	goName := upperFirst(field.Alias)
+	goName := field.Alias
 	if fieldOptions.Alias != "" {
-		goName = upperFirst(fieldOptions.Alias)
+		goName = fieldOptions.Alias
 	}
 
-	namePrefix = nextPrefix(namePrefix, field)
+	goName = ApplyCasing(goName, g.Config.GetDefaultCasingAlgorithm(), true)
+
+	namePrefix = nextPrefix(namePrefix, field, g.Config.GetDefaultCasingAlgorithm())
 
 	fieldGoType, err := g.convertType(
 		namePrefix, field.Definition.Type, field.SelectionSet,

generate/generate_test.go

@@ -244,6 +244,13 @@ func TestGenerateWithConfig(t *testing.T) {
 				StructReferences: true,
 			},
 		},
+		{
+			"AutoCamelCase", "", []string{"SnakeCaseFields.graphql", "SnakeCaseType.graphql"}, &Config{
+				Casing: Casing{
+					Default: CasingAutoCamelCase,
+				},
+			},
+		},
 	}
 
 	sourceFilename := "SimpleQuery.graphql"

generate/names.go

@@ -139,10 +139,10 @@ func joinPrefixList(prefix *prefixList) string {
 // prefix-list, since it ends with a type, not a field (see top-of-file
 // comment), but it's used to construct both the type-names from the input and
 // the next prefix-list.
-func typeNameParts(prefix *prefixList, typeName string) *prefixList {
-	// GraphQL types are conventionally UpperCamelCase, but it's not required;
-	// our names will look best if they are.
-	typeName = upperFirst(typeName)
+func typeNameParts(prefix *prefixList, typeName string, algorithm CasingAlgorithm) *prefixList {
+	// Apply the specified casing algorithm with uppercase first letter
+	typeName = ApplyCasing(typeName, algorithm, true)
+
 	// If the prefix has just one part, that's the operation-name.  There's no
 	// need to add "Query" or "Mutation".  (Zero should never happen.)
 	if prefix == nil || prefix.tail == nil ||
@@ -156,27 +156,28 @@ func typeNameParts(prefix *prefixList, typeName string) *prefixList {
 
 // Given a prefix-list, and a field, compute the next prefix-list, which will
 // be used for that field's selections.
-func nextPrefix(prefix *prefixList, field *ast.Field) *prefixList {
+func nextPrefix(prefix *prefixList, field *ast.Field, algorithm CasingAlgorithm) *prefixList {
 	// Add the type.
-	prefix = typeNameParts(prefix, field.ObjectDefinition.Name)
+	prefix = typeNameParts(prefix, field.ObjectDefinition.Name, algorithm)
 	// Add the field (there's no shortening here, see top-of-file comment).
-	prefix = &prefixList{upperFirst(field.Alias), prefix}
+	fieldAlias := ApplyCasing(field.Alias, algorithm, true)
+	prefix = &prefixList{fieldAlias, prefix}
 	return prefix
 }
 
 // Given a prefix-list, and the GraphQL of the current type, compute the name
 // we should give it in Go.
-func makeTypeName(prefix *prefixList, typeName string) string {
-	return joinPrefixList(typeNameParts(prefix, typeName))
+func makeTypeName(prefix *prefixList, typeName string, algorithm CasingAlgorithm) string {
+	return joinPrefixList(typeNameParts(prefix, typeName, algorithm))
 }
 
 // Like makeTypeName, but append typeName unconditionally.
 //
 // This is used for when you specify a type-name for a field of interface
 // type; we use YourName for the interface, but need to do YourNameImplName for
 // the implementations.
-func makeLongTypeName(prefix *prefixList, typeName string) string {
-	typeName = upperFirst(typeName)
+func makeLongTypeName(prefix *prefixList, typeName string, algorithm CasingAlgorithm) string {
+	typeName = ApplyCasing(typeName, algorithm, true)
 	return joinPrefixList(&prefixList{typeName, prefix})
 }
 
@@ -186,6 +187,8 @@ func (casing *Casing) enumValueName(goTypeName string, enum *ast.Definition, val
 		return goTypeName + goConstName(val.Name)
 	case CasingRaw:
 		return goTypeName + "_" + val.Name
+	case CasingAutoCamelCase:
+		return goTypeName + ApplyCasing(val.Name, algo, true)
 	default:
 		// Should already be caught by validation.
 		panic(fmt.Sprintf("unknown casing algorithm %s", algo))

generate/names_test.go

@@ -60,9 +60,63 @@ func TestTypeNames(t *testing.T) {
 		t.Run(test.expectedTypeName, func(t *testing.T) {
 			prefix := newPrefixList("Operation")
 			for _, field := range test.fields {
-				prefix = nextPrefix(prefix, field)
+				prefix = nextPrefix(prefix, field, CasingDefault)
 			}
-			actualTypeName := makeTypeName(prefix, test.leafTypeName)
+			actualTypeName := makeTypeName(prefix, test.leafTypeName, CasingDefault)
+			if actualTypeName != test.expectedTypeName {
+				t.Errorf("name mismatch:\ngot:  %s\nwant: %s",
+					actualTypeName, test.expectedTypeName)
+			}
+		})
+	}
+}
+
+func TestSnakeToTypeNames(t *testing.T) {
+	// Test specifically for the snake_case conversion in type names
+	tests := []struct {
+		expectedTypeName string
+		fields           []*ast.Field
+		leafTypeName     string
+		autoCamelCase    bool
+	}{{
+		// Without auto_camel_case
+		"ServiceIPsIp_address_listSnake_case_type",
+		[]*ast.Field{fakeField("Query", "ip_address_list")},
+		"snake_case_type",
+		false,
+	}, {
+		// With auto_camel_case
+		"ServiceIPsIpAddressListSnakeCaseType",
+		[]*ast.Field{fakeField("Query", "ip_address_list")},
+		"snake_case_type",
+		true,
+	}, {
+		// With nested snake_case fields
+		"ServiceIPsObjectSnake_case_fieldSnake_case_type",
+		[]*ast.Field{fakeField("Query", "object"), fakeField("Object", "snake_case_field")},
+		"snake_case_type",
+		false,
+	}, {
+		// With nested snake_case fields and auto_camel_case enabled
+		"ServiceIPsObjectSnakeCaseFieldSnakeCaseType",
+		[]*ast.Field{fakeField("Query", "object"), fakeField("Object", "snake_case_field")},
+		"snake_case_type",
+		true,
+	}}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.expectedTypeName, func(t *testing.T) {
+			prefix := newPrefixList("ServiceIPs")
+			algorithm := CasingDefault
+			if test.autoCamelCase {
+				algorithm = CasingAutoCamelCase
+			}
+
+			for _, field := range test.fields {
+				prefix = nextPrefix(prefix, field, algorithm)
+			}
+			actualTypeName := makeTypeName(prefix, test.leafTypeName, algorithm)
 			if actualTypeName != test.expectedTypeName {
 				t.Errorf("name mismatch:\ngot:  %s\nwant: %s",
 					actualTypeName, test.expectedTypeName)
@@ -92,9 +146,9 @@ func TestTypeNameCollisions(t *testing.T) {
 	for i, test := range tests {
 		prefix := newPrefixList("Operation")
 		for _, field := range test.fields {
-			prefix = nextPrefix(prefix, field)
+			prefix = nextPrefix(prefix, field, CasingDefault)
 		}
-		actualTypeName := makeTypeName(prefix, test.leafTypeName)
+		actualTypeName := makeTypeName(prefix, test.leafTypeName, CasingDefault)
 
 		otherIndex, ok := seen[actualTypeName]
 		if ok {

generate/testdata/queries/SnakeCaseFields.graphql

@@ -0,0 +1,6 @@
+query SnakeCaseFields {
+  user {
+    user_id
+    display_name
+  }
+}

generate/testdata/queries/SnakeCaseNested.graphql

@@ -0,0 +1,8 @@
+query SnakeCaseNested {
+  object {
+    snake_case_field {
+      id
+      name
+    }
+  }
+}

generate/testdata/queries/SnakeCaseType.graphql

@@ -0,0 +1,6 @@
+query SnakeCaseType {
+  snake_case_type {
+    id
+    name
+  }
+}