create 'excluded' interface

Author: hauner

src/main/groovy/com/github/hauner/openapi/spring/converter/InterfaceCollector.groovy

@@ -16,6 +16,10 @@
 
 package com.github.hauner.openapi.spring.converter
 
+import com.github.hauner.openapi.spring.converter.mapping.AmbiguousTypeMappingException
+import com.github.hauner.openapi.spring.converter.mapping.EndpointTypeMapping
+import com.github.hauner.openapi.spring.converter.mapping.Mapping
+import com.github.hauner.openapi.spring.converter.mapping.MappingSchema
 import com.github.hauner.openapi.spring.model.Interface
 import io.swagger.v3.oas.models.Operation
 import io.swagger.v3.oas.models.PathItem
@@ -32,6 +36,25 @@ class InterfaceCollector {
 
     private ApiOptions options
 
+    class MappingSchemaEndpoint implements MappingSchema {
+        String path
+
+        @Override
+        String getPath () {
+            path
+        }
+
+        @Override
+        String getName () {
+            null
+        }
+
+        @Override
+        String getContentType () {
+            null
+        }
+    }
+
     InterfaceCollector(ApiOptions options) {
         this.options = options
     }
@@ -49,7 +72,11 @@ class InterfaceCollector {
         paths.each { Map.Entry<String, PathItem> entry ->
             def operations = collectOperations (entry.value)
             operations.each { op ->
-                String targetInterfaceName = getInterfaceName (op)
+                String targetInterfaceName = getInterfaceName (op, isExcluded (entry.key))
+
+                if (interfaces.containsKey (targetInterfaceName)) {
+                    return
+                }
 
                 def itf = new Interface (
                     pkg: [options.packageName, 'api'].join ('.'),
@@ -63,17 +90,38 @@ class InterfaceCollector {
         interfaces.values () as List
     }
 
+    private boolean isExcluded (String path) {
+        def endpointMatches = options.typeMappings.findAll {
+            it.matches (Mapping.Level.ENDPOINT, new MappingSchemaEndpoint(path: path))
+        }
+
+        if (!endpointMatches.empty) {
+            if (endpointMatches.size () != 1) {
+                throw new AmbiguousTypeMappingException (endpointMatches)
+            }
+
+            def match = endpointMatches.first () as EndpointTypeMapping
+            return match.exclude
+        }
+
+        false
+    }
+
     private List<Operation> collectOperations(PathItem item) {
         new OperationCollector ().collect (item)
     }
 
-    private String getInterfaceName (def op) {
+    private String getInterfaceName (def op, boolean excluded) {
         String targetInterfaceName = INTERFACE_DEFAULT_NAME
 
         if (hasTags (op)) {
             targetInterfaceName = op.tags.first ()
         }
 
+        if (excluded) {
+            targetInterfaceName += 'Excluded'
+        }
+
         targetInterfaceName
     }
 

src/test/groovy/com/github/hauner/openapi/spring/converter/InterfaceCollectorSpec.groovy

@@ -16,7 +16,7 @@
 
 package com.github.hauner.openapi.spring.converter
 
-
+import com.github.hauner.openapi.spring.converter.mapping.EndpointTypeMapping
 import io.swagger.v3.oas.models.Operation
 import io.swagger.v3.oas.models.PathItem
 import io.swagger.v3.oas.models.Paths
@@ -52,4 +52,25 @@ class InterfaceCollectorSpec extends Specification {
         then:
         result.first ().interfaceName == 'Api'
     }
+
+    void "creates 'Excluded' interface when an endpoint should be skipped" () {
+        def options = new ApiOptions(typeMappings: [
+            new EndpointTypeMapping (path: '/foo', exclude: true, typeMappings: [])
+        ])
+
+        def collector = new InterfaceCollector(options)
+
+        def paths = new Paths()
+        paths.put ('/bar', new PathItem(get: new Operation()))
+        paths.put ('/foo', new PathItem(get: new Operation()))
+
+        when:
+        def result = collector.collect (paths)
+
+        then:
+        result.size () == 2
+        result[0].interfaceName == 'Api'
+        result[1].interfaceName == 'ExcludedApi'
+    }
+
 }