feat: add proper handling of query/path/body parameters for rest transport

gapic/generator/generator.py

@@ -54,6 +54,7 @@ def __init__(self, opts: Options) -> None:
         # Add filters which templates require.
         self._env.filters["rst"] = utils.rst
         self._env.filters["snake_case"] = utils.to_snake_case
+        self._env.filters["camel_case"] = utils.to_camel_case
         self._env.filters["sort_lines"] = utils.sort_lines
         self._env.filters["wrap"] = utils.wrap
         self._env.filters["coerce_response_name"] = coerce_response_name
@@ -288,6 +289,8 @@ def _render_template(
                         opts=opts,
                     )
                 )
+                #for method in service.methods.values():
+                    #breakpoint()
             return answer
 
         # This file is not iterating over anything else; return back

gapic/schema/wrappers.py

@@ -767,6 +767,23 @@ def http_opt(self) -> Optional[Dict[str, str]]:
         # TODO(yon-mg): enums for http verbs?
         return answer
 
+    @property
+    def path_params(self) -> Sequence[str]:
+        if self.http_opt is None:
+            return []
+        pattern = r'\{\w+\}'
+        return [x[1:-1] for x in re.findall(pattern, self.http_opt['url'])]
+
+    @property
+    def query_params(self) -> Set[str]:
+        if self.http_opt is None:
+            return set()
+        body = []
+        if 'body' in self.http_opt.keys():
+            body.append(self.http_opt['body'])
+        all_params = self.input.fields.keys()
+        return set(all_params) ^ set(body + list(self.path_params))
+
     # TODO(yon-mg): refactor as there may be more than one method signature
     @utils.cached_property
     def flattened_fields(self) -> Mapping[str, Field]:

gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2

@@ -135,28 +135,42 @@ class {{ service.name }}RestTransport({{ service.name }}Transport):
 
         {%- if 'body' in method.http_opt.keys() %}
         # Jsonify the input
-        data = {{ method.output.ident }}.to_json(
-            {%- if method.http_opt['body'] == '*' %}
+        {%- if method.http_opt['body'] != '*' %}
+        data = {{ method.input.fields[method.http_opt['body']].type.ident }}.to_json(
+            request.{{ method.http_opt['body'] }},
+            including_default_value_fields=False
+        )
+        {%- else %}
+        data = {{ method.input.ident }}.to_json(
             request
-            {%- else %}
-            request.body
-            {%- endif %}
         )
         {%- endif %}
+        {%- endif %}
 
         {# TODO(yon-mg): Write helper method for handling grpc transcoding url #}
         # TODO(yon-mg): need to handle grpc transcoding and parse url correctly
-        #              current impl assumes simpler version of grpc transcoding
+        #               current impl assumes basic case of grpc transcoding
         # Send the request
         url = 'https://{host}{{ method.http_opt['url'] }}'.format(
             host=self._host,
-            {%- for field in method.input.fields.keys() %}
+            {%- for field in method.path_params %}
             {{ field }}=request.{{ field }},
             {%- endfor %}
         )
+
+        potentialParams = {
+            {%- for field in method.query_params %}
+            '{{ field|camel_case }}': request.{{ field }},
+            {%- endfor %}
+        }
+        potentialParams = {k: v for k, v in potentialParams.items() if v}
+        for i, (param_name, param_value) in enumerate(potentialParams.items()):
+            q = '?' if i == 0 else '&'
+            url += q + param_name + '=' + str(param_value).replace(' ', '+')
+
         {% if not method.void %}response = {% endif %}self._session.{{ method.http_opt['verb'] }}(
-            url,
-            {%- if 'body' in method.http_opt.keys() %}
+            url
+            {%- if 'body' in method.http_opt.keys() %},
             json=data,
             {%- endif %}
         )

gapic/utils/__init__.py

@@ -14,6 +14,7 @@
 
 from gapic.utils.cache import cached_property
 from gapic.utils.case import to_snake_case
+from gapic.utils.case import to_camel_case
 from gapic.utils.code import empty
 from gapic.utils.code import nth
 from gapic.utils.code import partition
@@ -38,6 +39,7 @@
     'rst',
     'sort_lines',
     'to_snake_case',
+    'to_camel_case',
     'to_valid_filename',
     'to_valid_module_name',
     'wrap',

gapic/utils/case.py

@@ -45,3 +45,17 @@ def to_snake_case(s: str) -> str:
 
     # Done; return the camel-cased string.
     return s.lower()
+
+def to_camel_case(s: str) -> str:
+    '''Convert any string to camel case.
+
+    This is provided to templates as the ``camel_case`` filter.
+
+    Args:
+        s (str): The input string, provided in snake case.
+
+    Returns:
+        str: The string in camel case with the first letter unchanged.
+    '''
+    items = s.split('_')
+    return items[0] + "".join([x.capitalize() for x in items[1:]])

tests/unit/schema/wrappers/test_method.py

@@ -279,6 +279,55 @@ def test_method_http_opt_no_http_rule():
     assert method.http_opt == None
 
 
+def test_method_path_params():
+    # tests only the basic case of grpc transcoding
+    http_rule = http_pb2.HttpRule(post='/v1/{project}/topics')
+    method = make_method('DoSomething', http_rule=http_rule)
+    assert method.path_params == ['project']
+
+
+def test_method_path_params_no_http_rule():
+    method = make_method('DoSomething')
+    assert method.path_params == []
+
+
+def test_method_query_params():
+    # tests only the basic case of grpc transcoding
+    http_rule = http_pb2.HttpRule(
+        post='/v1/{project}/topics',
+        body='address'
+    )
+    input_message = make_message(
+        'MethodInput',
+        fields=(
+            make_field('region'),
+            make_field('project'),
+            make_field('address')
+        )
+    )
+    method = make_method('DoSomething', http_rule=http_rule, input_message=input_message)
+    assert method.query_params == {'region'}
+
+
+def test_method_query_params_no_body():
+    # tests only the basic case of grpc transcoding
+    http_rule = http_pb2.HttpRule(post='/v1/{project}/topics')
+    input_message = make_message(
+        'MethodInput',
+        fields=(
+            make_field('region'),
+            make_field('project'),
+        )
+    )
+    method = make_method('DoSomething', http_rule=http_rule, input_message=input_message)
+    assert method.query_params == {'region'}
+
+
+def test_method_query_params_no_http_rule():
+    method = make_method('DoSomething')
+    assert method.query_params == set()
+
+
 def test_method_idempotent_yes():
     http_rule = http_pb2.HttpRule(get='/v1/{parent=projects/*}/topics')
     method = make_method('DoSomething', http_rule=http_rule)