AsyncAPI 3.x: parse servers, bindings, channel parameters and security

core-extra/asyncapi-parser/src/main/java/com/webfuzzing/asyncapi/models/AsyncApiChannel.java

@@ -1,11 +1,15 @@
 package com.webfuzzing.asyncapi.models;
 
+import com.fasterxml.jackson.databind.JsonNode;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 
 /**
  * An entry under {@code channels:}: one addressable place on the broker (a Kafka topic, an AMQP
@@ -14,10 +18,21 @@
  */
 public class AsyncApiChannel {
 
+    /**
+     * The one protocol whose binding decides where a message actually goes.
+     */
+    public static final String KAFKA = "kafka";
+
     private final String name;
 
     private final String address;
 
+    /**
+     * Names of the servers this channel is available on, from its {@code servers} array.
+     * Empty means every server, which is the specification's default.
+     */
+    private final List<String> servers;
+
     /**
      * Key is the channel-local message key, which is what a {@code $ref} of the form
      * {@code #/channels/<channel>/messages/<localKey>} addresses and is frequently not the
@@ -31,10 +46,21 @@ public class AsyncApiChannel {
      */
     private final List<String> messageIds;
 
+    /**
+     * Key is the parameter name, as used by a {@code {placeholder}} in the address.
+     * Value is that parameter's declaration, kept as a raw node.
+     */
+    private final Map<String, JsonNode> parameters;
+
+    private final AsyncApiChannelBindings bindings;
+
     private AsyncApiChannel(Builder builder) {
         this.name = builder.name;
         this.address = builder.address;
+        this.servers = Collections.unmodifiableList(builder.servers);
         this.messageKeys = Collections.unmodifiableMap(new LinkedHashMap<>(builder.messageKeys));
+        this.parameters = Collections.unmodifiableMap(builder.parameters);
+        this.bindings = builder.bindings;
         //distinct, as two local keys may well point at the same message definition
         this.messageIds = Collections.unmodifiableList(
                 new ArrayList<>(new LinkedHashSet<>(this.messageKeys.values())));
@@ -57,12 +83,21 @@ public String getName() {
      *
      * Null on purpose: the specification allows an explicit {@code address: null} to say the
      * address is not known statically and is determined at run time. It may also contain
-     * {@code {parameter}} placeholders, which are left in place here.
+     * {@code {parameter}} placeholders, which are left in place here -- see
+     * {@link #getParameters()}.
      */
     public String getAddress() {
         return address;
     }
 
+    /**
+     * Names of the servers this channel is available on, from the channel's {@code servers}
+     * array. Empty means "all of them", which is the specification's default.
+     */
+    public List<String> getServers() {
+        return servers;
+    }
+
     /**
      * Channel-local message key -&gt; the id of that message in
      * {@link AsyncApiDocument#getMessages()}.
@@ -84,21 +119,74 @@ public List<String> getMessageIds() {
         return messageIds;
     }
 
+    /**
+     * Parameter name -&gt; its declaration node, from {@code parameters:}. These back the
+     * {@code {placeholders}} in {@link #getAddress()}. Kept as raw nodes: resolving an address
+     * to a concrete topic is a run-time concern, not a parsing one.
+     */
+    public Map<String, JsonNode> getParameters() {
+        return parameters;
+    }
+
+    /**
+     * Protocol bindings declared on this channel.
+     */
+    public AsyncApiChannelBindings getBindings() {
+        return bindings;
+    }
+
+    /**
+     * The address to actually use on the wire for a given protocol.
+     *
+     * Normally this is just {@link #getAddress()}, but a binding may override it: the Kafka
+     * binding has its own {@code topic} field, and when present it is the topic that is used
+     * rather than the channel address. The address itself is left untouched so the declaration
+     * stays readable.
+     */
+    public String effectiveAddress(String protocol) {
+
+        String topic = bindings.getKafkaTopic();
+
+        if (protocol != null && KAFKA.equals(protocol.toLowerCase(Locale.ENGLISH))
+                && topic != null && !topic.trim().isEmpty()) {
+            return topic;
+        }
+
+        return address;
+    }
+
     public static class Builder {
 
         private final String name;
         private String address;
+        /** @see AsyncApiChannel#servers */
+        private List<String> servers = Collections.emptyList();
         /** @see AsyncApiChannel#messageKeys */
         private Map<String, String> messageKeys = Collections.emptyMap();
+        /** @see AsyncApiChannel#parameters */
+        private Map<String, JsonNode> parameters = Collections.emptyMap();
+        private AsyncApiChannelBindings bindings = AsyncApiChannelBindings.none();
 
         private Builder(String name) {
-            this.name = name;
+            this.name = Objects.requireNonNull(name, "name");
         }
 
         public Builder address(String address) { this.address = address; return this; }
 
+        public Builder servers(List<String> servers) { this.servers = Objects.requireNonNull(servers, "servers"); return this; }
+
         public Builder messageKeys(Map<String, String> messageKeys) {
-            this.messageKeys = messageKeys;
+            this.messageKeys = Objects.requireNonNull(messageKeys, "messageKeys");
+            return this;
+        }
+
+        public Builder parameters(Map<String, JsonNode> parameters) {
+            this.parameters = Objects.requireNonNull(parameters, "parameters");
+            return this;
+        }
+
+        public Builder bindings(AsyncApiChannelBindings bindings) {
+            this.bindings = Objects.requireNonNull(bindings, "bindings");
             return this;
         }
 

core-extra/asyncapi-parser/src/main/java/com/webfuzzing/asyncapi/models/AsyncApiChannelBindings.java

@@ -0,0 +1,126 @@
+package com.webfuzzing.asyncapi.models;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * The subset of the protocol bindings that a client acts on, plus the untouched originals.
+ *
+ * Only a handful of fields are lifted out, because only a handful change what a client has to
+ * do. Everything else stays in {@link #getRaw()} so nothing is lost and a later transport can
+ * read it without the model having to grow first.
+ */
+public class AsyncApiChannelBindings {
+
+    private final String kafkaTopic;
+
+    private final String amqpIs;
+
+    private final String amqpQueue;
+
+    private final String amqpExchange;
+
+    private final String wsMethod;
+
+    /**
+     * Key is the protocol name, e.g. "kafka" or "amqp".
+     * Value is the binding declared for that protocol, exactly as written.
+     */
+    private final Map<String, JsonNode> raw;
+
+    private AsyncApiChannelBindings(Builder builder) {
+        this.kafkaTopic = builder.kafkaTopic;
+        this.amqpIs = builder.amqpIs;
+        this.amqpQueue = builder.amqpQueue;
+        this.amqpExchange = builder.amqpExchange;
+        this.wsMethod = builder.wsMethod;
+        this.raw = Collections.unmodifiableMap(builder.raw);
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Nothing declared, for a channel that has no bindings at all.
+     */
+    public static AsyncApiChannelBindings none() {
+        return builder().build();
+    }
+
+    /**
+     * {@code bindings.kafka.topic}. When set, it overrides the channel address for Kafka.
+     */
+    public String getKafkaTopic() {
+        return kafkaTopic;
+    }
+
+    /**
+     * {@code bindings.amqp.is}, either "queue" or "routingKey". Decides whether a publisher
+     * should address a queue directly or go through an exchange.
+     */
+    public String getAmqpIs() {
+        return amqpIs;
+    }
+
+    /**
+     * {@code bindings.amqp.queue.name}.
+     */
+    public String getAmqpQueue() {
+        return amqpQueue;
+    }
+
+    /**
+     * {@code bindings.amqp.exchange.name}.
+     */
+    public String getAmqpExchange() {
+        return amqpExchange;
+    }
+
+    /**
+     * {@code bindings.ws.method}, the HTTP method used for the opening handshake.
+     */
+    public String getWsMethod() {
+        return wsMethod;
+    }
+
+    /**
+     * Every binding as declared, keyed by protocol name.
+     */
+    public Map<String, JsonNode> getRaw() {
+        return raw;
+    }
+
+    public static class Builder {
+
+        private String kafkaTopic;
+        private String amqpIs;
+        private String amqpQueue;
+        private String amqpExchange;
+        private String wsMethod;
+        /** @see AsyncApiChannelBindings#raw */
+        private Map<String, JsonNode> raw = Collections.emptyMap();
+
+        private Builder() {
+        }
+
+        public Builder kafkaTopic(String kafkaTopic) { this.kafkaTopic = kafkaTopic; return this; }
+
+        public Builder amqpIs(String amqpIs) { this.amqpIs = amqpIs; return this; }
+
+        public Builder amqpQueue(String amqpQueue) { this.amqpQueue = amqpQueue; return this; }
+
+        public Builder amqpExchange(String amqpExchange) { this.amqpExchange = amqpExchange; return this; }
+
+        public Builder wsMethod(String wsMethod) { this.wsMethod = wsMethod; return this; }
+
+        public Builder raw(Map<String, JsonNode> raw) { this.raw = Objects.requireNonNull(raw, "raw"); return this; }
+
+        public AsyncApiChannelBindings build() {
+            return new AsyncApiChannelBindings(this);
+        }
+    }
+}

core-extra/asyncapi-parser/src/main/java/com/webfuzzing/asyncapi/models/AsyncApiCorrelationId.java

@@ -1,5 +1,7 @@
 package com.webfuzzing.asyncapi.models;
 
+import java.util.Objects;
+
 /**
  * A parsed {@code correlationId.location}, i.e. where in a message the value that pairs a
  * request with its reply is to be written and read.
@@ -35,9 +37,9 @@ public enum Source { HEADER, PAYLOAD }
     private final String description;
 
     public AsyncApiCorrelationId(String raw, Source source, String pointer, String description) {
-        this.raw = raw;
-        this.source = source;
-        this.pointer = pointer;
+        this.raw = Objects.requireNonNull(raw, "raw");
+        this.source = Objects.requireNonNull(source, "source");
+        this.pointer = Objects.requireNonNull(pointer, "pointer");
         this.description = description;
         this.fieldName = fieldNameOf(pointer);
     }