fix: use camelCase for google.api.http path parameters and fix double path-prefix

Three fixes for google.api.http OpenAPI generation:

1. Path parameters now use camelCase (JSON names) by default instead of
   snake_case proto field names. E.g., {account_id} becomes {accountId}.
   Respects the with-proto-names option to keep snake_case when needed.

2. Fix double path-prefix application for additional_bindings. The prefix
   was applied both in httpRuleToPathMap and in the central addPathItem
   handler, causing paths like /api/node/api/node/....

3. Fix nested path params (e.g., source_public_id.value) not tracking the
   top-level field, which caused the parent field to not be excluded from
   the request body when body: "*" was used.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: george-oakling

internal/converter/converter_test.go

@@ -35,6 +35,7 @@ var scenarios = []Scenario{
 	{Name: "with_specification_extensions", Options: "base=testdata/with_specification_extensions/base.yaml,trim-unused-types"},
 	{Name: "additional_bindings"},
 	{Name: "path_params"},
+	{Name: "additional_bindings_prefix", Options: "path-prefix=/api/v1"},
 	{Name: "with_override", Options: "override=testdata/with_override/override.yaml"},
 	{Name: "with_service_filters", Options: "services=**.User*"},
 	{Name: "with_google_error_detail", Options: "with-google-error-detail"},

internal/converter/googleapi/paths.go

@@ -112,6 +112,7 @@ func httpRuleToPathMap(opts options.Options, md protoreflect.MethodDescriptor, r
 	}
 
 	fieldNamesInPath := map[string]struct{}{}
+	paramRenames := map[string]string{} // maps proto path param name to display name (camelCase by default)
 	var pathParams []*v3.Parameter
 	var deferredParams []*v3.Parameter
 	for _, param := range partsToParameter(tokens) {
@@ -125,9 +126,27 @@ func httpRuleToPathMap(opts options.Options, md protoreflect.MethodDescriptor, r
 			// query/param or request body
 			fieldNamesInPath[string(field.FullName())] = struct{}{}
 			fieldNamesInPath[strings.Join(jsonPath, ".")] = struct{}{} // sometimes JSON field names are used
+
+			// For nested params (e.g., "source_public_id.value"), also track the
+			// top-level field so it can be excluded from the request body schema
+			paramParts := strings.SplitN(param, ".", 2)
+			if len(paramParts) > 1 {
+				if topField := fieldByName(opts, md.Input(), paramParts[0]); topField != nil {
+					fieldNamesInPath[string(topField.FullName())] = struct{}{}
+					fieldNamesInPath[util.MakeFieldName(opts, topField)] = struct{}{}
+				}
+			}
+
+			// Compute display name for the parameter (camelCase by default)
+			displayName := param
+			if !opts.WithProtoNames {
+				displayName = strings.Join(jsonPath, ".")
+			}
+			paramRenames[param] = displayName
+
 			loc := fd.SourceLocations().ByDescriptor(field)
 			newParameter := &v3.Parameter{
-				Name:        param,
+				Name:        displayName,
 				Required:    proto.Bool(true),
 				In:          "path",
 				Description: util.FormatComments(loc),
@@ -157,7 +176,13 @@ func httpRuleToPathMap(opts options.Options, md protoreflect.MethodDescriptor, r
 			if len(matches) == 3 {
 				if matches[2] == "**" {
 					paramName := matches[1]
-					field, _ := resolveField(opts, md.Input(), paramName)
+					field, jsonPath := resolveField(opts, md.Input(), paramName)
+					// Compute display name (camelCase by default)
+					displayName := paramName
+					if field != nil && !opts.WithProtoNames {
+						displayName = strings.Join(jsonPath, ".")
+					}
+					paramRenames[paramName] = displayName
 					var newParameter *v3.Parameter
 					if field != nil {
 						fieldNamesInPath[string(field.FullName())] = struct{}{}
@@ -169,7 +194,7 @@ func httpRuleToPathMap(opts options.Options, md protoreflect.MethodDescriptor, r
 							parameterSchema = base.CreateSchemaProxy(&base.Schema{Type: []string{"string"}})
 						}
 						newParameter = &v3.Parameter{
-							Name:          paramName,
+							Name:          displayName,
 							Required:      proto.Bool(true),
 							In:            "path",
 							Description:   util.FormatComments(loc),
@@ -178,7 +203,7 @@ func httpRuleToPathMap(opts options.Options, md protoreflect.MethodDescriptor, r
 						}
 					} else {
 						newParameter = &v3.Parameter{
-							Name:          paramName,
+							Name:          displayName,
 							Required:      proto.Bool(true),
 							In:            "path",
 							Description:   "The trailing part of the path.",
@@ -359,7 +384,7 @@ func httpRuleToPathMap(opts options.Options, md protoreflect.MethodDescriptor, r
 		pathItem.Patch = op
 	default:
 	}
-	openAPIPath := partsToOpenAPIPath(tokens)
+	openAPIPath := partsToOpenAPIPath(tokens, paramRenames)
 	paths.Set(openAPIPath, pathItem)
 
 	allDeferred := orderedmap.New[string, []*v3.Parameter]()
@@ -370,12 +395,10 @@ func httpRuleToPathMap(opts options.Options, md protoreflect.MethodDescriptor, r
 	for _, binding := range rule.AdditionalBindings {
 		sub := httpRuleToPathMap(opts, md, binding)
 		for pair := sub.PathItems.First(); pair != nil; pair = pair.Next() {
-			path := util.MakePath(opts, pair.Key())
-			paths.Set(path, pair.Value())
+			paths.Set(pair.Key(), pair.Value())
 		}
 		for pair := sub.DeferredParams.First(); pair != nil; pair = pair.Next() {
-			path := util.MakePath(opts, pair.Key())
-			allDeferred.Set(path, pair.Value())
+			allDeferred.Set(pair.Key(), pair.Value())
 		}
 	}
 	dedupeOperations(op.OperationId, paths.ValuesFromOldest())
@@ -444,7 +467,7 @@ func partsToParameter(tokens []Token) []string {
 	return params
 }
 
-func partsToOpenAPIPath(tokens []Token) string {
+func partsToOpenAPIPath(tokens []Token, renames map[string]string) string {
 	var b strings.Builder
 	for _, token := range tokens {
 		switch token.Type {
@@ -467,8 +490,12 @@ func partsToOpenAPIPath(tokens []Token) string {
 				matches := namedPathPattern.FindStringSubmatch("{" + token.Value + "}")
 				if len(matches) == 3 {
 					if matches[2] == "**" {
+						name := matches[1]
+						if renamed, ok := renames[name]; ok {
+							name = renamed
+						}
 						b.WriteString("{")
-						b.WriteString(matches[1])
+						b.WriteString(name)
 						b.WriteString("}")
 						continue
 					}
@@ -494,8 +521,12 @@ func partsToOpenAPIPath(tokens []Token) string {
 					b.WriteByte('}')
 				}
 			} else {
+				name := token.Value
+				if renamed, ok := renames[name]; ok {
+					name = renamed
+				}
 				b.WriteByte('{')
-				b.WriteString(token.Value)
+				b.WriteString(name)
 				b.WriteByte('}')
 			}
 		}

internal/converter/googleapi/paths_test.go

@@ -11,21 +11,52 @@ func TestPartsToOpenAPIPath(t *testing.T) {
 	t.Run("with annotation", func(t *testing.T) {
 		v, err := RunPathPatternLexer("/pet/{pet_id}:addPet")
 		require.NoError(t, err)
-		path := partsToOpenAPIPath(v)
+		path := partsToOpenAPIPath(v, nil)
 		assert.Equal(t, "/pet/{pet_id}:addPet", path)
 	})
 
 	t.Run("with glob pattern", func(t *testing.T) {
 		v, err := RunPathPatternLexer("/users/v1/{name=organizations/*/teams/*/members/*}:activate")
 		require.NoError(t, err)
-		path := partsToOpenAPIPath(v)
+		path := partsToOpenAPIPath(v, nil)
 		assert.Equal(t, "/users/v1/organizations/{organization}/teams/{team}/members/{member}:activate", path)
 	})
 
 	t.Run("with glob pattern containing literal segment", func(t *testing.T) {
 		v, err := RunPathPatternLexer("/users/v1/{name=organizations/*/teams/*/all/members/*}:activate")
 		require.NoError(t, err)
-		path := partsToOpenAPIPath(v)
+		path := partsToOpenAPIPath(v, nil)
 		assert.Equal(t, "/users/v1/organizations/{organization}/teams/{team}/all/members/{member}:activate", path)
 	})
+
+	t.Run("with renames applies camelCase to simple variable", func(t *testing.T) {
+		v, err := RunPathPatternLexer("/v1/resources/{resource_id}")
+		require.NoError(t, err)
+		renames := map[string]string{"resource_id": "resourceId"}
+		path := partsToOpenAPIPath(v, renames)
+		assert.Equal(t, "/v1/resources/{resourceId}", path)
+	})
+
+	t.Run("with renames applies camelCase to multiple variables", func(t *testing.T) {
+		v, err := RunPathPatternLexer("/v1/{account_id}/items/{item_id}")
+		require.NoError(t, err)
+		renames := map[string]string{"account_id": "accountId", "item_id": "itemId"}
+		path := partsToOpenAPIPath(v, renames)
+		assert.Equal(t, "/v1/{accountId}/items/{itemId}", path)
+	})
+
+	t.Run("with renames applies camelCase to glob pattern name", func(t *testing.T) {
+		v, err := RunPathPatternLexer("/v1/{resource_name=**}")
+		require.NoError(t, err)
+		renames := map[string]string{"resource_name": "resourceName"}
+		path := partsToOpenAPIPath(v, renames)
+		assert.Equal(t, "/v1/{resourceName}", path)
+	})
+
+	t.Run("without renames keeps original variable names", func(t *testing.T) {
+		v, err := RunPathPatternLexer("/v1/resources/{resource_id}")
+		require.NoError(t, err)
+		path := partsToOpenAPIPath(v, nil)
+		assert.Equal(t, "/v1/resources/{resource_id}", path)
+	})
 }

internal/converter/testdata/additional_bindings_prefix/additional_bindings_prefix.proto

@@ -0,0 +1,27 @@
+syntax = "proto3";
+
+package additional_bindings_prefix;
+
+import "google/api/annotations.proto";
+
+// Tests that additional_bindings with path-prefix don't double-apply the prefix.
+service PrefixService {
+  rpc GetItem(GetItemRequest) returns (GetItemResponse) {
+    option (google.api.http) = {
+      get: "/items/{item_id}"
+
+      additional_bindings: {
+        get: "/items/latest"
+      }
+    };
+  }
+}
+
+message GetItemRequest {
+  string item_id = 1;
+}
+
+message GetItemResponse {
+  string id = 1;
+  string name = 2;
+}

internal/converter/testdata/additional_bindings_prefix/output/additional_bindings_prefix.openapi.json

@@ -0,0 +1,108 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "additional_bindings_prefix"
+  },
+  "paths": {
+    "/api/v1/items/latest": {
+      "get": {
+        "tags": [
+          "additional_bindings_prefix.PrefixService"
+        ],
+        "summary": "GetItem",
+        "operationId": "additional_bindings_prefix.PrefixService.GetItem2",
+        "parameters": [
+          {
+            "name": "itemId",
+            "in": "query",
+            "schema": {
+              "type": "string",
+              "title": "item_id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/additional_bindings_prefix.GetItemResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/v1/items/{itemId}": {
+      "get": {
+        "tags": [
+          "additional_bindings_prefix.PrefixService"
+        ],
+        "summary": "GetItem",
+        "operationId": "additional_bindings_prefix.PrefixService.GetItem",
+        "parameters": [
+          {
+            "name": "itemId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "item_id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/additional_bindings_prefix.GetItemResponse"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "additional_bindings_prefix.GetItemRequest": {
+        "type": "object",
+        "properties": {
+          "itemId": {
+            "type": "string",
+            "title": "item_id"
+          }
+        },
+        "title": "GetItemRequest",
+        "additionalProperties": false
+      },
+      "additional_bindings_prefix.GetItemResponse": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "title": "id"
+          },
+          "name": {
+            "type": "string",
+            "title": "name"
+          }
+        },
+        "title": "GetItemResponse",
+        "additionalProperties": false
+      }
+    }
+  },
+  "security": [],
+  "tags": [
+    {
+      "name": "additional_bindings_prefix.PrefixService",
+      "description": "Tests that additional_bindings with path-prefix don't double-apply the prefix."
+    }
+  ]
+}