Merge pull request #1769 from jonjomckay/add-openapi-hidden-support

Added support for OpenAPI operating hiding annotations

Author: jknack

modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/AnnotationParser.java

@@ -17,6 +17,8 @@
 import io.jooby.annotations.Path;
 import io.jooby.annotations.PathParam;
 import io.jooby.annotations.QueryParam;
+import io.swagger.v3.oas.annotations.Hidden;
+import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.models.media.Content;
 import io.swagger.v3.oas.models.media.ObjectSchema;
 import io.swagger.v3.oas.models.media.Schema;
@@ -49,7 +51,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static io.jooby.internal.openapi.AsmUtils.findAnnotationByType;
+import static io.jooby.internal.openapi.AsmUtils.*;
 import static io.jooby.internal.openapi.TypeFactory.KT_FUN_0;
 import static io.jooby.internal.openapi.TypeFactory.KT_KLASS;
 import static java.util.Collections.singletonList;
@@ -236,6 +238,11 @@ private static List<OperationExt> routerMethod(ParserContext ctx, String prefix,
     List<ParameterExt> arguments = routerArguments(ctx, method, requestBody::set);
     ResponseExt response = returnTypes(method);
 
+    // If the method is hidden, don't generate an operation for it
+    if (isHidden(method.visibleAnnotations)) {
+      return result;
+    }
+
     for (String httpMethod : httpMethod(method.visibleAnnotations)) {
       for (String pattern : httpPattern(ctx, classNode, method, httpMethod)) {
         OperationExt operation = new OperationExt(
@@ -266,6 +273,24 @@ private static boolean isDeprecated(List<AnnotationNode> annotations) {
     return false;
   }
 
+  private static boolean isHidden(List<AnnotationNode> annotations) {
+    if (annotations != null) {
+      // If the method is annotated with @Hidden, it's always hidden
+      boolean hiddenAnnotationExists = annotations.stream()
+          .anyMatch(a -> a.desc.equals(Type.getDescriptor(Hidden.class)));
+
+      if (hiddenAnnotationExists) {
+        return true;
+      }
+
+      // If the method is annotated with @Operation, and the value of "hidden" is true, it's hidden
+      return findAnnotationByType(annotations, Operation.class)
+          .stream()
+          .anyMatch(it -> boolValue(toMap(it), "hidden"));
+    }
+    return false;
+  }
+
   private static ResponseExt returnTypes(MethodNode method) {
     Signature signature = Signature.create(method);
     String desc = Optional.ofNullable(method.signature).orElse(method.desc);

modules/jooby-openapi/src/test/java/issues/Issue1768.java

@@ -0,0 +1,25 @@
+package issues;
+
+import io.jooby.openapi.OpenAPIResult;
+import io.jooby.openapi.OpenAPITest;
+import issues.i1768.App1768;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class Issue1768 {
+  @OpenAPITest(value = App1768.class)
+  public void shouldIgnoreHiddenOperations(OpenAPIResult result) {
+    assertEquals("openapi: 3.0.1\n" +
+          "info:\n" +
+          "  title: 1768 API\n" +
+          "  description: 1768 API description\n" +
+          "  version: \"1.0\"\n" +
+          "paths:\n" +
+          "  /c/not-hidden:\n" +
+          "    get:\n" +
+          "      operationId: notHidden\n" +
+          "      responses:\n" +
+          "        \"200\":\n" +
+          "          description: Success\n", result.toYaml());
+  }
+}

modules/jooby-openapi/src/test/java/issues/i1768/App1768.java

@@ -0,0 +1,9 @@
+package issues.i1768;
+
+import io.jooby.Jooby;
+
+public class App1768 extends Jooby {
+  {
+    mvc(new Controller1768());
+  }
+}

modules/jooby-openapi/src/test/java/issues/i1768/Controller1768.java

@@ -0,0 +1,27 @@
+package issues.i1768;
+
+import io.jooby.annotations.GET;
+import io.jooby.annotations.Path;
+import io.swagger.v3.oas.annotations.Hidden;
+import io.swagger.v3.oas.annotations.Operation;
+
+@Path("/c")
+public class Controller1768 {
+
+  @Hidden
+  @GET("/hidden-with-annotation")
+  public void hiddenWithAnnotation() {
+
+  }
+
+  @Operation(hidden = true)
+  @GET("/hidden-with-operation")
+  public void hiddenWithOperation() {
+
+  }
+
+  @GET("/not-hidden")
+  public void notHidden() {
+
+  }
+}