Fix path param with pattern

generator/template.go

@@ -77,18 +77,23 @@ func fieldName(r *registry.Registry) func(name string) string {
 	}
 }
 
+var (
+	// match {field} or {field=pattern}, return param and pattern
+	pathParamRegexp = regexp.MustCompile(`{([^=}/]+)(?:=([^}]+))?}`)
+)
+
 func renderURL(r *registry.Registry) func(method data.Method) string {
 	fieldNameFn := fieldName(r)
 	return func(method data.Method) string {
 		methodURL := method.URL
-		reg := regexp.MustCompile("{([^}]+)}")
-		matches := reg.FindAllStringSubmatch(methodURL, -1)
+		matches := pathParamRegexp.FindAllStringSubmatch(methodURL, -1)
 		fieldsInPath := make([]string, 0, len(matches))
 		if len(matches) > 0 {
 			slog.Debug("url matches", slog.Any("matches", matches))
 			for _, m := range matches {
 				expToReplace := m[0]
-				fieldName := fieldNameFn(m[1])
+				fieldNameRaw := m[1]
+				fieldName := fieldNameFn(fieldNameRaw)
 				part := fmt.Sprintf(`${req.%s}`, fieldName)
 				methodURL = strings.ReplaceAll(methodURL, expToReplace, part)
 				fieldsInPath = append(fieldsInPath, fmt.Sprintf(`"%s"`, fieldName))

test/integration/defaultConfig/defaultConfig_test.ts

@@ -128,6 +128,14 @@ describe("test default configuration", () => {
     });
   });
 
+  it("http post body check request with path param pattern", async () => {
+    const result = await CounterService.HTTPPostWithPathParamPattern(
+      { a: "first/10", req: { b: 15 }, c: "second/is/23" },
+      { pathPrefix: "http://localhost:8081" }
+    );
+    expect(result.postResult).to.equal("first/10second/is/23");
+  });
+
   it("http get request with optional fields", async () => {
     const result = await CounterService.HTTPGetWithOptionalFields(
       {},

test/integration/noStaticClasses/noStaticClasses_test.ts

@@ -135,6 +135,14 @@ describe("test with client class", () => {
     });
   });
 
+  it("http post body check request with path param pattern", async () => {
+    const result = await client.httpPostWithPathParamPattern(
+      { a: "first/10", req: { b: 15 }, c: "second/is/23" },
+      { pathPrefix: "http://localhost:8081" }
+    );
+    expect(result.postResult).to.equal("first/10second/is/23");
+  });
+
   it("http get request with optional fields", async () => {
     const result = await client.httpGetWithOptionalFields({});
 

test/integration/protos/service.proto

@@ -115,6 +115,16 @@ message HTTPGetWithZeroValueURLSearchParamsResponse {
   ZeroValueMsg zero_value_msg = 3;
 }
 
+message HttpPostWithPathParamPatternRequest {
+  string a = 1;
+  PostRequest req = 2;
+  string c = 3;
+}
+
+message HttpPostWithPathParamPatternResponse {
+  string post_result = 1;
+}
+
 message OptionalFieldsRequest {}
 
 message OptionalFieldsResponse {
@@ -237,6 +247,12 @@ service CounterService {
       get: "/path/query"
     };
   }
+  rpc HTTPPostWithPathParamPattern(HttpPostWithPathParamPatternRequest) returns (HttpPostWithPathParamPatternResponse) {
+    option (google.api.http) = {
+      post: "/post/{a=first/*}/{c=**}"
+      body: "req"
+    };
+  }
   rpc HTTPGetWithOptionalFields(OptionalFieldsRequest) returns (OptionalFieldsResponse) {
     option (google.api.http) = {
       get: "/optional"

test/integration/service.go

@@ -135,3 +135,9 @@ func (r *RealCounterService) HTTPGetWithOptionalFields(ctx context.Context, in *
 func p[T any](v T) *T {
 	return &v
 }
+
+func (r *RealCounterService) HTTPPostWithPathParamPattern(ctx context.Context, in *HttpPostWithPathParamPatternRequest) (*HttpPostWithPathParamPatternResponse, error) {
+	return &HttpPostWithPathParamPatternResponse{
+		PostResult: in.GetA() + in.GetC(),
+	}, nil
+}

test/integration/useProtoNames/useProtoNames_test.ts

@@ -63,6 +63,14 @@ describe("test with original proto names", () => {
     });
   });
 
+  it("http post body check request with path param pattern", async () => {
+    const result = await CounterService.HTTPPostWithPathParamPattern(
+      { a: "first/10", req: { b: 15 }, c: "second/is/23" },
+      { pathPrefix: "http://localhost:8081" }
+    );
+    expect(result.post_result).to.equal("first/10second/is/23");
+  });
+
   it("http get request with optional fields", async () => {
     const result = await CounterService.HTTPGetWithOptionalFields(
       {},