feat(clients): flatten body parameters

Author: millotp

clients/algoliasearch-client-go/README.md

@@ -47,37 +47,34 @@ import "github.com/algolia/algoliasearch-client-go/v4/algolia/search"
 client, err := search.NewClient("YOUR_APP_ID", "YOUR_API_KEY")
 
 // Add a new record to your Algolia index
-response, err := client.SaveObject(client.NewApiSaveObjectRequest(
-  "<YOUR_INDEX_NAME>", map[string]any{"objectID": "id", "test": "val"},
-))
+saveResponse, err := client.SaveObject("<YOUR_INDEX_NAME>", map[string]any{"objectID": "id", "test": "val"})
 if err != nil {
   // handle the eventual error
   panic(err)
 }
 
 // use the model directly
-print(response)
+print(saveResponse)
 
 // Poll the task status to know when it has been indexed
-taskResponse, err := searchClient.WaitForTask("<YOUR_INDEX_NAME>", response.TaskID, nil, nil, nil)
+_, err = client.WaitForTask("<YOUR_INDEX_NAME>", saveResponse.TaskID)
 if err != nil {
   panic(err)
 }
 
 // Fetch search results, with typo tolerance
-response, err := client.Search(client.NewApiSearchRequest(
-
-  search.NewEmptySearchMethodParams().SetRequests(
-    []search.SearchQuery{*search.SearchForHitsAsSearchQuery(
-      search.NewEmptySearchForHits().SetIndexName("<YOUR_INDEX_NAME>").SetQuery("<YOUR_QUERY>").SetHitsPerPage(50))}),
-))
+response, err := client.Search([]search.SearchQuery{
+  *search.SearchForHitsAsSearchQuery(search.NewSearchForHits("<YOUR_INDEX_NAME>").SetQuery("<YOUR_QUERY>").SetHitsPerPage(50)),
+}, nil)
 if err != nil {
   // handle the eventual error
   panic(err)
 }
 
 // use the model directly
 print(response)
+
+return 0
 ```
 
 For full documentation, visit the **[Algolia Go API Client](https://www.algolia.com/doc/libraries/go/)**.

generators/src/main/java/com/algolia/codegen/AlgoliaGoGenerator.java

@@ -11,6 +11,7 @@
 import io.swagger.v3.oas.models.servers.Server;
 import java.io.File;
 import java.util.*;
+import java.util.stream.Collectors;
 import org.openapitools.codegen.*;
 import org.openapitools.codegen.languages.GoClientCodegen;
 import org.openapitools.codegen.model.ModelMap;
@@ -78,6 +79,10 @@ public void processOpenAPI(OpenAPI openAPI) {
     super.processOpenAPI(openAPI);
     Helpers.generateServers(super.fromServers(openAPI.getServers()), additionalProperties);
     Timeouts.enrichBundle(openAPI, additionalProperties);
+    additionalProperties.put(
+      "appDescription",
+      Arrays.stream(openAPI.getInfo().getDescription().split("\n")).map(line -> "// " + line).collect(Collectors.joining("\n")).trim()
+    );
   }
 
   @Override
@@ -140,6 +145,126 @@ public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs)
   @Override
   public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<ModelMap> models) {
     OperationsMap operations = super.postProcessOperationsWithModels(objs, models);
+
+    // Flatten body params to remove the wrapping object
+    for (CodegenOperation ope : operations.getOperations().getOperation()) {
+      // clean up the description
+      String[] lines = ope.unescapedNotes.split("\n");
+      ope.notes = (lines[0] + "\n" + Arrays.stream(lines).skip(1).map(line -> "// " + line).collect(Collectors.joining("\n"))).trim();
+
+      for (CodegenParameter param : ope.optionalParams) {
+        param.nameInPascalCase = Helpers.capitalize(param.baseName);
+      }
+
+      CodegenParameter bodyParam = ope.bodyParam;
+      if (bodyParam == null) {
+        continue;
+      }
+      bodyParam.nameInPascalCase = Helpers.capitalize(bodyParam.baseName);
+      if (!bodyParam.isModel) {
+        continue;
+      }
+
+      // check for colision with other params
+      boolean hasCollision = false;
+      for (CodegenProperty prop : bodyParam.getVars()) {
+        for (CodegenParameter param : ope.allParams) {
+          if (param.paramName.equals(prop.baseName)) {
+            hasCollision = true;
+            break;
+          }
+        }
+      }
+      if (hasCollision) {
+        System.out.println("Operation " + ope.operationId + " has a body param with the same name as another param, skipping flattening");
+        continue;
+      }
+
+      if (ope.operationId.equals("Browse")) {
+        System.out.println(
+          ope.allParams.size() +
+          " params   " +
+          ope.requiredParams.size() +
+          " required params " +
+          ope.optionalParams.size() +
+          " optional params"
+        );
+      }
+
+      bodyParam.vendorExtensions.put("x-flat-body", bodyParam.getVars().size() > 0);
+
+      if (bodyParam.getVars().size() > 0) {
+        ope.allParams.removeIf(param -> param.isBodyParam);
+        ope.requiredParams.removeIf(param -> param.isBodyParam);
+        ope.optionalParams.removeIf(param -> param.isBodyParam);
+      }
+
+      for (CodegenProperty prop : bodyParam.getVars()) {
+        // there is no easy way to convert a prop to a param, we need to copy all the fields
+        CodegenParameter param = new CodegenParameter();
+
+        prop.nameInLowerCase = toParamName(prop.baseName);
+        param.nameInPascalCase = Helpers.capitalize(prop.baseName);
+        param.paramName = toParamName(prop.baseName);
+        param.baseName = prop.baseName;
+        param.baseType = prop.baseType;
+        param.dataType = prop.dataType;
+        param.datatypeWithEnum = prop.datatypeWithEnum;
+        param.description = prop.description;
+        param.example = prop.example;
+        param.isModel = prop.isModel;
+        param.isArray = prop.isArray;
+        param.isContainer = prop.isContainer;
+        param.isMap = prop.isMap;
+        param.isEnum = prop.isEnum;
+        param.isEnumRef = prop.isEnumRef;
+        param.isPrimitiveType = prop.isPrimitiveType;
+        param.isString = prop.isString;
+        param.isNumeric = prop.isNumeric;
+        param.isBoolean = prop.isBoolean;
+        param.isDate = prop.isDate;
+        param.isDateTime = prop.isDateTime;
+        param.isFreeFormObject = prop.isFreeFormObject;
+        param.isNullable = prop.isNullable;
+        param.jsonSchema = prop.jsonSchema;
+        param.required = prop.required;
+        param.vendorExtensions = prop.vendorExtensions;
+        param.allowableValues = prop.allowableValues;
+
+        if (prop.required) {
+          ope.requiredParams.add(param);
+          ope.hasRequiredParams = true;
+        } else {
+          ope.optionalParams.add(param);
+          ope.hasOptionalParams = true;
+        }
+        ope.allParams.add(param);
+      }
+
+      System.out.println(
+        ope.operationId +
+        "  has " +
+        ope.requiredParams.size() +
+        " required params and " +
+        ope.optionalParams.size() +
+        " optional params   " +
+        bodyParam.getVars().size() +
+        " body params  "
+      );
+
+      // If the optional param struct only has 1 param, we can remove the wrapper
+      if (ope.optionalParams.size() == 1) {
+        CodegenParameter param = ope.optionalParams.get(0);
+
+        // move it to required, it's easier to handle im mustache
+        ope.hasOptionalParams = false;
+        ope.optionalParams.clear();
+
+        ope.hasRequiredParams = true;
+        ope.requiredParams.add(param);
+      }
+    }
+
     ModelPruner.removeOrphans(this, operations, models);
     Helpers.removeHelpers(operations);
     GenericPropagator.propagateGenericsToOperations(operations, models);

generators/src/main/java/com/algolia/codegen/AlgoliaJavascriptGenerator.java

@@ -237,20 +237,13 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo
         continue;
       }
 
-      boolean hasBodyParams = !ope.bodyParams.isEmpty();
+      boolean hasBodyParams = ope.bodyParam != null;
       boolean hasHeaderParams = !ope.headerParams.isEmpty();
       boolean hasQueryParams = !ope.queryParams.isEmpty();
       boolean hasPathParams = !ope.pathParams.isEmpty();
 
       // If there is nothing but body params, we just check if it's a single param
-      if (
-        hasBodyParams &&
-        !hasHeaderParams &&
-        !hasQueryParams &&
-        !hasPathParams &&
-        ope.bodyParams.size() == 1 &&
-        !ope.bodyParams.get(0).isArray
-      ) {
+      if (hasBodyParams && !hasHeaderParams && !hasQueryParams && !hasPathParams && !ope.bodyParam.isArray) {
         // At this point the single parameter is already an object, to avoid double wrapping we skip
         // it
         ope.vendorExtensions.put("x-is-single-body-param", true);

generators/src/main/java/com/algolia/codegen/cts/tests/ParametersWithDataType.java

@@ -60,7 +60,7 @@ public void enhanceParameters(Map<String, Object> parameters, Map<String, Object
     IJsonSchemaValidationProperties spec = null;
     String paramName = null;
     // special case if there is only bodyParam which is not an array
-    if (operation != null && operation.allParams.size() == 1 && operation.bodyParams.size() == 1 && !operation.bodyParam.isArray) {
+    if (operation != null && operation.allParams.size() == 1 && operation.bodyParam != null && !operation.bodyParam.isArray) {
       spec = operation.bodyParam;
       paramName = operation.bodyParam.paramName;
     }
@@ -71,7 +71,7 @@ public void enhanceParameters(Map<String, Object> parameters, Map<String, Object
     if (paramName == null) {
       if (parameters != null) {
         for (Entry<String, Object> param : parameters.entrySet()) {
-          CodegenParameter specParam = null;
+          IJsonSchemaValidationProperties specParam = null;
           if (operation != null) {
             for (CodegenParameter sp : operation.allParams) {
               if (sp.paramName.equals(param.getKey())) {
@@ -83,9 +83,42 @@ public void enhanceParameters(Map<String, Object> parameters, Map<String, Object
               throw new CTSException("Parameter " + param.getKey() + " not found in the root parameter");
             }
           }
-          Map<String, Object> paramWithType = traverseParams(param.getKey(), param.getValue(), specParam, "", 0, false);
-          parametersWithDataType.add(paramWithType);
-          parametersWithDataTypeMap.put((String) paramWithType.get("key"), paramWithType);
+          // for go, we flatten the body params
+          if (
+            language.equals("go") &&
+            specParam != null &&
+            ((CodegenParameter) specParam).isBodyParam &&
+            operation != null &&
+            operation.bodyParam != null &&
+            operation.bodyParam.isModel &&
+            operation.bodyParam.required
+          ) {
+            // check for colision with other params
+            boolean hasCollision = false;
+            for (CodegenProperty prop : operation.bodyParam.getVars()) {
+              for (CodegenParameter otherParam : operation.allParams) {
+                if (otherParam.paramName.equals(prop.baseName)) {
+                  hasCollision = true;
+                  break;
+                }
+              }
+            }
+            if (!hasCollision) {
+              // flatten the body params by skipping one level
+              Map<String, Object> bodyParams = (Map<String, Object>) param.getValue();
+              for (CodegenProperty prop : operation.bodyParam.getVars()) {
+                Object nestedParam = bodyParams.get(prop.baseName);
+
+                Map<String, Object> paramWithType = traverseParams(prop.baseName, nestedParam, prop, "", 0, false);
+                parametersWithDataType.add(paramWithType);
+                parametersWithDataTypeMap.put((String) paramWithType.get("key"), paramWithType);
+              }
+            }
+          } else {
+            Map<String, Object> paramWithType = traverseParams(param.getKey(), param.getValue(), specParam, "", 0, false);
+            parametersWithDataType.add(paramWithType);
+            parametersWithDataTypeMap.put((String) paramWithType.get("key"), paramWithType);
+          }
         }
       }
     } else {

generators/src/main/java/com/algolia/codegen/cts/tests/Snippet.java

@@ -85,6 +85,8 @@ public void addMethodCall(Map<String, Object> context, ParametersWithDataType pa
         }
       }
 
+      TestsGenerator.setOptionalParameters(ope, context);
+
       paramsType.enhanceParameters(parameters, context, ope);
     } catch (CTSException e) {
       e.setTestName((String) context.get("testName"));

generators/src/main/java/com/algolia/codegen/cts/tests/TestsClient.java

@@ -156,6 +156,7 @@ public void run(Map<String, CodegenModel> models, Map<String, CodegenOperation>
               // default to true because most api calls are asynchronous
               testOut.put("isAsyncMethod", (boolean) ope.vendorExtensions.getOrDefault("x-asynchronous-helper", true));
 
+              setOptionalParameters(ope, stepOut);
               addRequestOptions(paramsType, step.requestOptions, stepOut);
 
               methodCount++;

generators/src/main/java/com/algolia/codegen/cts/tests/TestsGenerator.java

@@ -11,9 +11,7 @@
 import java.nio.file.Paths;
 import java.util.*;
 import org.apache.commons.lang3.ArrayUtils;
-import org.openapitools.codegen.CodegenModel;
-import org.openapitools.codegen.CodegenOperation;
-import org.openapitools.codegen.SupportingFile;
+import org.openapitools.codegen.*;
 
 public abstract class TestsGenerator {
 
@@ -134,4 +132,30 @@ protected void addRequestOptions(ParametersWithDataType paramsType, RequestOptio
       output.put("requestOptions", requestOptions);
     }
   }
+
+  public static void setOptionalParameters(CodegenOperation ope, Map<String, Object> test) {
+    long bodyPropsOptional = 0;
+    if (ope.bodyParam != null) {
+      if (ope.bodyParam.isModel && ope.bodyParam.required) {
+        // check for colision with other params
+        boolean hasCollision = false;
+        for (CodegenProperty prop : ope.bodyParam.getVars()) {
+          for (CodegenParameter param : ope.allParams) {
+            if (param.paramName.equals(prop.baseName)) {
+              hasCollision = true;
+              break;
+            }
+          }
+        }
+
+        if (!hasCollision) {
+          bodyPropsOptional = ope.bodyParam.getVars().stream().filter(prop -> !prop.required).count();
+        }
+      }
+    }
+
+    // hasOptionalWrapper if there is more that one optional param, after the body has been
+    // flattened, only relevant for go
+    test.put("hasOptionalWrapper", ope.optionalParams.size() + bodyPropsOptional > 1);
+  }
 }

generators/src/main/java/com/algolia/codegen/cts/tests/TestsRequest.java

@@ -161,6 +161,7 @@ public void run(Map<String, CodegenModel> models, Map<String, CodegenOperation>
           test.put("hasParams", ope.hasParams);
           test.put("isHelper", isHelper);
 
+          setOptionalParameters(ope, test);
           addRequestOptions(paramsType, req.requestOptions, test);
 
           // Determines whether the endpoint is expected to return a response payload deserialized

playground/go/analytics.go

@@ -13,9 +13,7 @@ func testAnalytics(appID, apiKey string) int {
 		panic(err)
 	}
 
-	getTopFilterForAttributeResponse, err := analyticsClient.GetTopFilterForAttribute(
-		analyticsClient.NewApiGetTopFilterForAttributeRequest("myAttribute1,myAttribute2", indexName),
-	)
+	getTopFilterForAttributeResponse, err := analyticsClient.GetTopFilterForAttribute("myAttribute1,myAttribute2", indexName, nil)
 	if err != nil {
 		fmt.Printf("request error with GetTopFilterForAttribute: %v\n", err)
 		return 1

playground/go/ingestion.go

@@ -13,14 +13,14 @@ func testIngestion(appID, apiKey string) int {
 	}
 
 	// another example to generate payload for a request.
-	_, payload, err := ingestionClient.ListTasksWithHTTPInfo(ingestionClient.NewApiListTasksRequest())
+	res, err := ingestionClient.ListTasks(nil)
 	if err != nil {
 		fmt.Printf("request error: %v\n", err)
 
 		return 1
 	}
 
-	fmt.Println(string(payload))
+	fmt.Println(res)
 
 	return 0
 }