Swagger: POST with Query Parameters fix #611

Author: jknack

jooby-raml/src/test/java/org/jooby/raml/RamlBuilderTest.java

@@ -67,11 +67,23 @@ public Type type() {
       return type;
     }
 
+    @Override
+    public RouteParam type(final Type type) {
+      this.type = type;
+      return this;
+    }
+
     @Override
     public RouteParamType paramType() {
       return paramType;
     }
 
+    @Override
+    public RouteParam paramType(final RouteParamType type) {
+      paramType = type;
+      return this;
+    }
+
     @Override
     public Object value() {
       return value;
@@ -242,7 +254,7 @@ public Spec rsp(final Consumer<Response> rsp) {
   }
 
   private Config conf = ConfigFactory.empty()
-        .withValue("mediaType", ConfigValueFactory.fromAnyRef("application/json"));
+      .withValue("mediaType", ConfigValueFactory.fromAnyRef("application/json"));
 
   @Test
   public void routes() {
@@ -395,8 +407,10 @@ public void bodyParam() {
         "  post:\n" +
         "    description: |-\n" +
         "      Enters the file content for an existing song entity. \n\n" +
-        "       * Use the `binary/octet-stream` content type to specify the content from any consumer (excepting web-browsers).\n\n" +
-        "       * Use the `multipart-form/data` content type to upload a file which content will become the file-content\n" +
+        "       * Use the `binary/octet-stream` content type to specify the content from any consumer (excepting web-browsers).\n\n"
+        +
+        "       * Use the `multipart-form/data` content type to upload a file which content will become the file-content\n"
+        +
         "    body:\n" +
         "      application/json:\n" +
         "        type: integer", raml);
@@ -420,8 +434,10 @@ public void fileParam() {
         "  post:\n" +
         "    description: |-\n" +
         "      Enters the file content for an existing song entity. \n\n" +
-        "       * Use the `binary/octet-stream` content type to specify the content from any consumer (excepting web-browsers).\n\n" +
-        "       * Use the `multipart-form/data` content type to upload a file which content will become the file-content\n" +
+        "       * Use the `binary/octet-stream` content type to specify the content from any consumer (excepting web-browsers).\n\n"
+        +
+        "       * Use the `multipart-form/data` content type to upload a file which content will become the file-content\n"
+        +
         "    body:\n" +
         "      multipart/form-data:\n" +
         "        formParameters:\n" +
@@ -472,7 +488,8 @@ public void rsp2() {
         .build(Arrays.asList(
             route("GET", "/users/:userId", path("userId", int.class, "The id of the user"))
                 .rsp(
-                    rsp -> rsp.type(Person.class).status(200, "Success").status(404, "Not found\nNextLine"))))
+                    rsp -> rsp.type(Person.class).status(200, "Success").status(404,
+                        "Not found\nNextLine"))))
         .trim();
     assertEquals("#%RAML 1.0\n" +
         "mediaType: application/json\n" +

jooby-spec/src/main/java/org/jooby/internal/spec/DocCollector.java

@@ -24,6 +24,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.BiConsumer;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -45,15 +46,15 @@ public class DocCollector extends VoidVisitorAdapter<Context> {
 
   private static final Pattern SPLITTER = Pattern.compile("\\s+\\*");
 
-  private static final Pattern PARAM = Pattern.compile("(@param)\\s+([^\\s]+)([^@]+)");
-
   private static final String RETURNS = "@return";
 
+  private static final String PARAM = "@param";
+
+  private static final String THROWS = "@throws";
+
   private static final Pattern CODE = Pattern
       .compile("<code>\\s*(\\d+)\\s*(=\\s*([^<]+))?\\s*</code>");
 
-  private static final Pattern TYPE = Pattern.compile("\\{@link\\s+([^\\}]+)\\}");
-
   private Map<String, Object> doc = new HashMap<>();
 
   public Map<String, Object> accept(final Node node, final String method, final Context ctx) {
@@ -126,10 +127,8 @@ private Map<String, Object> doc(final Node node, final Context ctx) {
       Map<Integer, String> codes = Collections.emptyMap();
       String tail = clean.substring(Math.max(0, at));
       // params
-      Matcher pmatcher = PARAM.matcher(tail);
-      while (pmatcher.find()) {
-        hash.put(pmatcher.group(2).trim(), pmatcher.group(3).trim());
-      }
+      params(tail, hash::put);
+
       // returns
       String returnText = returnText(tail);
       codes = new LinkedHashMap<>();
@@ -142,17 +141,40 @@ private Map<String, Object> doc(final Node node, final Context ctx) {
           codes.put(status.value(), message);
         }
 
-        Matcher tmatcher = TYPE.matcher(returnText);
-        if (tmatcher.find()) {
-          ctx.resolveType(node, tmatcher.group(1).trim()).ifPresent(t -> hash.put("@type", t));
-        }
+        TypeFromDoc.parse(node, ctx, returnText).ifPresent(type -> hash.put("@type", type));
       }
       hash.put("@statusCodes", codes);
       hash.put("@text", text);
     }
     return hash;
   }
 
+  private void params(final String text, final BiConsumer<String, String> callback) {
+    int at = text.indexOf(PARAM);
+    while (at != -1) {
+      int start = at + PARAM.length();
+      int end = firstOf(text, start, PARAM, RETURNS, THROWS);
+      String raw = text.substring(start, end).trim();
+      int space = raw.indexOf(" ");
+      if (space != -1) {
+        String name = raw.substring(0, space).trim();
+        String desc = raw.substring(space).trim();
+        callback.accept(name, desc);
+      }
+      at = text.indexOf(PARAM, end);
+    }
+  }
+
+  private int firstOf(final String text, final int start, final String... tokens) {
+    for (String token : tokens) {
+      int pos = text.indexOf(token, start);
+      if (pos != -1) {
+        return pos;
+      }
+    }
+    return text.length();
+  }
+
   private String returnText(final String doc) {
     int retIdx = doc.indexOf(RETURNS);
     if (retIdx >= 0) {

jooby-spec/src/main/java/org/jooby/internal/spec/RouteParamImpl.java

@@ -58,6 +58,12 @@ public Type type() {
     return get("type");
   }
 
+  @Override
+  public RouteParam type(final Type type) {
+    put("type", type);
+    return this;
+  }
+
   @Override
   public String name() {
     return get("name");
@@ -68,6 +74,12 @@ public RouteParamType paramType() {
     return RouteParamType.valueOf(get("paramType"));
   }
 
+  @Override
+  public RouteParam paramType(final RouteParamType type) {
+    put("paramType", type.name());
+    return this;
+  }
+
   @Override
   public String toString() {
     return MoreObjects.toStringHelper("")

jooby-spec/src/main/java/org/jooby/internal/spec/TypeFromDoc.java

@@ -0,0 +1,34 @@
+package org.jooby.internal.spec;
+
+import java.lang.reflect.Type;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.github.javaparser.ast.Node;
+import com.google.inject.util.Types;
+
+public class TypeFromDoc {
+
+  private static final Pattern TYPE = Pattern.compile("\\{@link\\s+([^\\}]+)\\}");
+
+
+  public static Optional<Type> parse(final Node node, final Context ctx, final String text) {
+    Matcher matcher = TYPE.matcher(text);
+    Type type = null;
+    while (matcher.find()) {
+      String link = matcher.group(1).trim();
+      String stype = link.split("\\s+")[0];
+      Optional<Type> resolvedType = ctx.resolveType(node, stype);
+      if (resolvedType.isPresent()) {
+        Type ittype = resolvedType.get();
+        if (type != null) {
+          type = Types.newParameterizedType(type, ittype);
+        } else {
+          type = ittype;
+        }
+      }
+    }
+    return Optional.ofNullable(type);
+  }
+}

jooby-spec/src/main/java/org/jooby/spec/RouteParam.java

@@ -38,11 +38,27 @@ public interface RouteParam {
    */
   Type type();
 
+  /**
+   * Set parameter data type.
+   *
+   * @param type Data type.
+   * @return This param.
+   */
+  RouteParam type(Type type);
+
   /**
    * @return Type of HTTP param.
    */
   RouteParamType paramType();
 
+  /**
+   * Set parameter type.
+   *
+   * @param type Paremater type.
+   * @return This param.
+   */
+  RouteParam paramType(RouteParamType type);
+
   /**
    * @return Default value or <code>null</code>
    */
@@ -61,4 +77,4 @@ default boolean optional() {
     return type().toString().startsWith(java.util.Optional.class.getName())
         || value() != null;
   }
-}
+}

jooby-spec/src/main/java/org/jooby/spec/RouteProcessor.java

@@ -29,7 +29,6 @@
 import java.lang.reflect.Type;
 import java.nio.file.Path;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -57,6 +56,7 @@
 import org.jooby.internal.spec.RouteSpecImpl;
 import org.jooby.internal.spec.SourceResolver;
 import org.jooby.internal.spec.SourceResolverImpl;
+import org.jooby.internal.spec.TypeFromDoc;
 import org.jooby.internal.spec.TypeResolverImpl;
 import org.jooby.mvc.Body;
 import org.jooby.mvc.Flash;
@@ -277,7 +277,7 @@ private List<RouteSpec> processInternal(final Class<? extends Jooby> appClass,
               Type retType = (Type) doc.remove("@type");
 
               /** params and return type */
-              List<RouteParam> params = Collections.emptyList();
+              List<RouteParam> params;
               RouteResponse rsp;
               if (method == null) {
                 // script params
@@ -293,6 +293,22 @@ private List<RouteSpec> processInternal(final Class<? extends Jooby> appClass,
                     retDoc, codes);
               }
 
+              // test if body param is present, when present all the other params are set to query
+              params.stream()
+                  .filter(p -> p.paramType() == RouteParamType.BODY)
+                  .findFirst()
+                  .ifPresent(p -> {
+                    params.stream().filter(it -> it != p)
+                        .forEach(it -> it.paramType(RouteParamType.QUERY));
+                  });
+              // ovewrite param type if need it
+              params.stream()
+                  .forEach(p -> {
+                    p.doc().ifPresent(pdoc -> {
+                      TypeFromDoc.parse(entry.getValue(), ctx, pdoc).ifPresent(p::type);
+                    });
+                  });
+
               /** Create spec . */
               specs.add(new RouteSpecImpl(route, summary, desc, params, rsp));
             } else {

jooby-spec/src/test/java/apps/App611.java

@@ -0,0 +1,11 @@
+package apps;
+
+import org.jooby.Jooby;
+
+public class App611 extends Jooby {
+
+  {
+    use(Controller611.class);
+  }
+
+}

jooby-spec/src/test/java/apps/Controller611.java

@@ -0,0 +1,32 @@
+package apps;
+
+import java.util.List;
+import java.util.Optional;
+
+import org.jooby.Deferred;
+import org.jooby.mvc.Body;
+import org.jooby.mvc.POST;
+import org.jooby.mvc.Path;
+import org.jooby.spec.User611;
+
+import com.fasterxml.jackson.databind.node.ArrayNode;
+
+public class Controller611 {
+
+  /**
+   * Find users by email address.
+   *
+   * @param userId User ID.
+   * @param context Context value.
+   * @param emails {@link List} of {@link String mails}.
+   * @return Returns a {@link List} of {@link User611}.
+   */
+  @POST
+  @Path("/friends/email")
+  public Deferred findUsersByEmail(final Long userId, final Optional<String> context,
+      @Body final ArrayNode emails) {
+    return Deferred.deferred(deferred -> {
+      return null;
+    });
+  }
+}

jooby-spec/src/test/java/org/jooby/spec/Issue611Test.java

@@ -0,0 +1,51 @@
+package org.jooby.spec;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.nio.file.Path;
+
+import org.junit.Test;
+
+import apps.App611;
+
+public class Issue611Test extends RouteSpecTest {
+
+  private Path basedir = new File(System.getProperty("user.dir")).toPath();
+
+  @Test
+  public void postWithQueryParamereters() throws Exception {
+    routes(new RouteProcessor().process(new App611(), basedir))
+        .next(r -> {
+          assertEquals("POST", r.method());
+          assertEquals("/friends/email", r.pattern());
+
+          params(r.params())
+              .next(p -> {
+                assertEquals("userId", p.name());
+                assertEquals("User ID.", p.doc().get());
+                assertEquals(RouteParamType.QUERY, p.paramType());
+                assertEquals(false, p.optional());
+                assertEquals(Long.class, p.type());
+              })
+              .next(p -> {
+                assertEquals("context", p.name());
+                assertEquals("Context value.", p.doc().get());
+                assertEquals(RouteParamType.QUERY, p.paramType());
+                assertEquals(true, p.optional());
+                assertEquals("java.util.Optional<java.lang.String>", p.type().getTypeName());
+              }).next(p -> {
+                assertEquals("emails", p.name());
+                assertEquals("{@link List} of {@link String mails}.", p.doc().get());
+                assertEquals(RouteParamType.BODY, p.paramType());
+                assertEquals(false, p.optional());
+                assertEquals("java.util.List<java.lang.String>",
+                    p.type().getTypeName());
+              });
+
+          RouteResponse rsp = r.response();
+          assertEquals("java.util.List<org.jooby.spec.User611>", rsp.type().getTypeName());
+          assertEquals("Returns a {@link List} of {@link User611}.", rsp.doc().get());
+        });
+  }
+}