W-15425051: support kafka 0.1.0, 0.2.0 and 0.3.0

amf-api-contract/shared/src/main/scala/amf/apicontract/client/platform/model/domain/bindings/kafka/KafkaChannelBinding.scala

@@ -0,0 +1,98 @@
+package amf.apicontract.client.platform.model.domain.bindings.kafka
+
+import amf.apicontract.client.platform.model.domain.bindings.{BindingVersion, ChannelBinding}
+import amf.apicontract.client.scala.model.domain.bindings.kafka.{
+  KafkaTopicConfiguration => InternalKafkaTopicConfiguration,
+  KafkaChannelBinding => InternalKafkaChannelBinding,
+  KafkaChannelBinding030 => InternalKafkaChannelBinding030,
+  KafkaChannelBinding040 => InternalKafkaChannelBinding040
+}
+import amf.apicontract.internal.convert.ApiClientConverters._
+import amf.core.client.platform.model.{IntField, StrField}
+import amf.core.client.platform.model.domain.DomainElement
+import scala.scalajs.js.annotation.{JSExportAll, JSExportTopLevel}
+
+@JSExportAll
+abstract class KafkaChannelBinding(override private[amf] val _internal: InternalKafkaChannelBinding)
+    extends ChannelBinding
+    with BindingVersion {
+  override protected def bindingVersion: StrField = _internal.bindingVersion
+  override def withBindingVersion(bindingVersion: String): this.type = {
+    _internal.withBindingVersion(bindingVersion)
+    this
+  }
+
+  def topic: StrField      = _internal.topic
+  def partitions: IntField = _internal.partitions
+  def replicas: IntField   = _internal.replicas
+
+  def withTopic(topic: String): this.type = {
+    _internal.withTopic(topic)
+    this
+  }
+
+  def withPartitions(partitions: Int): this.type = {
+    _internal.withPartitions(partitions)
+    this
+  }
+
+  def withReplicas(replicas: Int): this.type = {
+    _internal.withReplicas(replicas)
+    this
+  }
+}
+
+@JSExportAll
+case class KafkaChannelBinding030(override private[amf] val _internal: InternalKafkaChannelBinding030)
+    extends KafkaChannelBinding(_internal) {
+  @JSExportTopLevel("KafkaChannelBinding030")
+  def this() = this(InternalKafkaChannelBinding030())
+  override def linkCopy(): KafkaChannelBinding030 = _internal.linkCopy()
+}
+
+@JSExportAll
+case class KafkaChannelBinding040(override private[amf] val _internal: InternalKafkaChannelBinding040)
+    extends KafkaChannelBinding(_internal) {
+  @JSExportTopLevel("KafkaChannelBinding040")
+  def this() = this(InternalKafkaChannelBinding040())
+  override def linkCopy(): KafkaChannelBinding040 = _internal.linkCopy()
+
+  def topicConfiguration: KafkaTopicConfiguration = _internal.topicConfiguration
+  def withTopicConfiguration(topicConfiguration: KafkaTopicConfiguration): this.type = {
+    _internal.withTopicConfiguration(topicConfiguration)
+    this
+  }
+}
+
+@JSExportAll
+case class KafkaTopicConfiguration(override private[amf] val _internal: InternalKafkaTopicConfiguration)
+    extends DomainElement {
+  @JSExportTopLevel("KafkaTopicConfiguration")
+  def this() = this(InternalKafkaTopicConfiguration())
+  def cleanupPolicy: ClientList[StrField] = _internal.cleanupPolicy.asClient
+  def retentionMs: IntField               = _internal.retentionMs
+  def retentionBytes: IntField            = _internal.retentionBytes
+  def deleteRetentionMs: IntField         = _internal.deleteRetentionMs
+  def maxMessageBytes: IntField           = _internal.maxMessageBytes
+
+  def withCleanupPolicy(cleanupPolicy: ClientList[String]): this.type = {
+    _internal.withCleanupPolicy(cleanupPolicy.asInternal)
+    this
+  }
+  def withRetentionMs(retentionMs: Int): this.type = {
+    _internal.withRetentionMs(retentionMs)
+    this
+  }
+  def withRetentionBytes(retentionBytes: Int): this.type = {
+    _internal.withRetentionBytes(retentionBytes)
+    this
+  }
+  def withDeleteRetentionMs(deleteRetentionMs: Int): this.type = {
+    _internal.withDeleteRetentionMS(deleteRetentionMs)
+    this
+  }
+  def withMaxMessageBytes(maxMessageBytes: Int): this.type = {
+    _internal.withMaxMessageBytes(maxMessageBytes)
+    this
+  }
+}

amf-api-contract/shared/src/main/scala/amf/apicontract/client/platform/model/domain/bindings/kafka/KafkaMessageBinding.scala

@@ -3,28 +3,64 @@ package amf.apicontract.client.platform.model.domain.bindings.kafka
 import amf.apicontract.client.platform.model.domain.bindings.{BindingVersion, MessageBinding}
 import amf.core.client.platform.model
 import amf.core.client.platform.model.domain.Shape
+import amf.core.client.platform.model.StrField
 import amf.apicontract.internal.convert.ApiClientConverters._
-import amf.apicontract.client.scala.model.domain.bindings.kafka.{KafkaMessageBinding => InternalKafkaMessageBinding}
+import amf.apicontract.client.scala.model.domain.bindings.kafka.{
+  KafkaMessageBinding => InternalKafkaMessageBinding,
+  KafkaMessageBinding010 => InternalKafkaMessageBinding010,
+  KafkaMessageBinding030 => InternalKafkaMessageBinding030
+}
 
 import scala.scalajs.js.annotation.{JSExportAll, JSExportTopLevel}
 
 @JSExportAll
-case class KafkaMessageBinding(override private[amf] val _internal: InternalKafkaMessageBinding)
+abstract class KafkaMessageBinding(override private[amf] val _internal: InternalKafkaMessageBinding)
     extends MessageBinding
     with BindingVersion {
-  @JSExportTopLevel("KafkaMessageBinding")
-  def this() = this(InternalKafkaMessageBinding())
+  override protected def bindingVersion: model.StrField = _internal.bindingVersion
+  override def withBindingVersion(bindingVersion: String): this.type = {
+    _internal.withBindingVersion(bindingVersion)
+    this
+  }
 
   def messageKey: Shape = _internal.messageKey
-
   def withKey(key: Shape): this.type = {
     _internal.withKey(key)
     this
   }
-  override protected def bindingVersion: model.StrField = _internal.bindingVersion
+}
 
-  override def withBindingVersion(bindingVersion: String): this.type = {
-    _internal.withBindingVersion(bindingVersion)
+@JSExportAll
+case class KafkaMessageBinding010(override private[amf] val _internal: InternalKafkaMessageBinding010)
+    extends KafkaMessageBinding(_internal) {
+  @JSExportTopLevel("InternalKafkaMessageBinding010")
+  def this() = this(InternalKafkaMessageBinding010())
+
+  override def linkCopy(): KafkaMessageBinding = _internal.linkCopy()
+}
+
+@JSExportAll
+case class KafkaMessageBinding030(override private[amf] val _internal: InternalKafkaMessageBinding030)
+    extends KafkaMessageBinding(_internal) {
+  @JSExportTopLevel("InternalKafkaMessageBinding030")
+  def this() = this(InternalKafkaMessageBinding030())
+
+  def schemaIdLocation: StrField        = _internal.schemaIdLocation
+  def schemaIdPayloadEncoding: StrField = _internal.schemaIdPayloadEncoding
+  def schemaLookupStrategy: StrField    = _internal.schemaLookupStrategy
+
+  def withSchemaIdLocation(schemaIdLocation: String): this.type = {
+    _internal.withSchemaIdLocation(schemaIdLocation)
+    this
+  }
+
+  def withSchemaIdPayloadEncoding(schemaIdPayloadEncoding: String): this.type = {
+    _internal.withSchemaIdPayloadEncoding(schemaIdPayloadEncoding)
+    this
+  }
+
+  def withSchemaLookupStrategy(schemaLookupStrategy: String): this.type = {
+    _internal.withSchemaLookupStrategy(schemaLookupStrategy)
     this
   }
 

amf-api-contract/shared/src/main/scala/amf/apicontract/client/platform/model/domain/bindings/kafka/KafkaServerBinding.scala

@@ -0,0 +1,37 @@
+package amf.apicontract.client.platform.model.domain.bindings.kafka
+
+import amf.apicontract.client.platform.model.domain.bindings.{BindingVersion, ServerBinding}
+import amf.apicontract.client.scala.model.domain.bindings.kafka.{KafkaServerBinding => InternalKafkaServerBinding}
+import amf.apicontract.internal.convert.ApiClientConverters._
+import amf.core.client.platform.model.StrField
+
+import scala.scalajs.js.annotation.{JSExportAll, JSExportTopLevel}
+
+@JSExportAll
+case class KafkaServerBinding(override private[amf] val _internal: InternalKafkaServerBinding)
+    extends ServerBinding
+    with BindingVersion {
+  @JSExportTopLevel("KafkaServerBinding")
+  def this() = this(InternalKafkaServerBinding())
+  override protected def bindingVersion: StrField = _internal.bindingVersion
+  override def withBindingVersion(bindingVersion: String): this.type = {
+    _internal.withBindingVersion(bindingVersion)
+    this
+  }
+
+  def schemaRegistryUrl: StrField    = _internal.schemaRegistryUrl
+  def schemaRegistryVendor: StrField = _internal.schemaRegistryVendor
+
+  def withSchemaRegistryUrl(schemaRegistryUrl: String): this.type = {
+    _internal.withSchemaRegistryUrl(schemaRegistryUrl)
+    this
+  }
+
+  def withSchemaRegistryVendor(schemaRegistryVendor: String): this.type = {
+    _internal.withSchemaRegistryVendor(schemaRegistryVendor)
+    this
+  }
+
+  override def linkCopy(): KafkaServerBinding = _internal.linkCopy()
+
+}

amf-api-contract/shared/src/main/scala/amf/apicontract/client/scala/model/domain/bindings/amqp/Amqp091ChannelBinding.scala

@@ -70,8 +70,6 @@ class Amqp091ChannelBinding010(override val fields: Fields, override val annotat
 
   override def componentId: String = "/amqp091-channel-010"
 
-  override def key: StrField = fields.field(Amqp010Model.key)
-
   override def exchange: Amqp091ChannelExchange010                 = fields.field(Amqp010Model.Exchange)
   override def queue: Amqp091Queue010                              = fields.field(Amqp010Model.Queue)
   def withExchange(exchange: Amqp091ChannelExchange010): this.type = set(Amqp010Model.Exchange, exchange)
@@ -130,8 +128,6 @@ class Amqp091ChannelBinding020(override val fields: Fields, override val annotat
 
   override def componentId: String = "/amqp091-channel-020"
 
-  override def key: StrField = fields.field(Amqp020Model.key)
-
   override def exchange: Amqp091ChannelExchange020                 = fields.field(Amqp020Model.Exchange)
   override def queue: Amqp091Queue020                              = fields.field(Amqp020Model.Queue)
   def withExchange(exchange: Amqp091ChannelExchange020): this.type = set(Amqp020Model.Exchange, exchange)

amf-api-contract/shared/src/main/scala/amf/apicontract/client/scala/model/domain/bindings/kafka/KafkaChannelBinding.scala

@@ -0,0 +1,108 @@
+package amf.apicontract.client.scala.model.domain.bindings.kafka
+
+import amf.apicontract.client.scala.model.domain.bindings.{BindingVersion, ChannelBinding}
+import amf.apicontract.internal.metamodel.domain.bindings.{
+  KafkaChannelBinding030Model,
+  KafkaChannelBinding040Model,
+  KafkaChannelBindingModel,
+  KafkaTopicConfigurationModel
+}
+import amf.apicontract.internal.metamodel.domain.bindings.KafkaChannelBindingModel._
+import amf.core.client.scala.model.{IntField, StrField}
+import amf.core.client.scala.model.domain.{DomainElement, Linkable}
+import amf.core.internal.metamodel.{Field}
+import amf.core.internal.parser.domain.{Annotations, Fields}
+import amf.shapes.client.scala.model.domain.Key
+
+abstract class KafkaChannelBinding(override val fields: Fields, override val annotations: Annotations)
+    extends ChannelBinding
+    with BindingVersion
+    with Key {
+  override protected def bindingVersionField: Field = BindingVersion
+  override val key: StrField                        = fields.field(KafkaChannelBindingModel.key)
+  override def componentId: String                  = "/kafka-channel"
+
+  def topic: StrField      = fields.field(Topic)
+  def partitions: IntField = fields.field(Partitions)
+  def replicas: IntField   = fields.field(Replicas)
+
+  def withTopic(topic: String): this.type        = set(Topic, topic)
+  def withPartitions(partitions: Int): this.type = set(Partitions, partitions)
+  def withReplicas(replicas: Int): this.type     = set(Replicas, replicas)
+}
+
+class KafkaChannelBinding030(override val fields: Fields, override val annotations: Annotations)
+    extends KafkaChannelBinding(fields, annotations) {
+  override def meta: KafkaChannelBinding030Model.type = KafkaChannelBinding030Model
+  override def componentId: String                    = "/kafka-channel-030"
+  override def linkCopy(): KafkaChannelBinding030     = KafkaChannelBinding030().withId(id)
+
+  /** apply method for create a new instance with fields and annotations. Aux method for copy */
+  override protected def classConstructor: (Fields, Annotations) => Linkable with DomainElement =
+    KafkaChannelBinding030.apply
+}
+
+object KafkaChannelBinding030 {
+  def apply(): KafkaChannelBinding030 = apply(Annotations())
+
+  def apply(annotations: Annotations): KafkaChannelBinding030 = apply(Fields(), annotations)
+
+  def apply(fields: Fields, annotations: Annotations): KafkaChannelBinding030 =
+    new KafkaChannelBinding030(fields, annotations)
+}
+
+class KafkaChannelBinding040(override val fields: Fields, override val annotations: Annotations)
+    extends KafkaChannelBinding(fields, annotations) {
+  override def meta: KafkaChannelBinding040Model.type = KafkaChannelBinding040Model
+  override def componentId: String                    = "/kafka-channel-040"
+  override def linkCopy(): KafkaChannelBinding040     = KafkaChannelBinding040().withId(id)
+
+  def topicConfiguration: KafkaTopicConfiguration = fields.field(KafkaChannelBinding040Model.TopicConfiguration)
+  def withTopicConfiguration(topicConfiguration: KafkaTopicConfiguration): this.type =
+    set(KafkaChannelBinding040Model.TopicConfiguration, topicConfiguration)
+
+  /** apply method for create a new instance with fields and annotations. Aux method for copy */
+  override protected def classConstructor: (Fields, Annotations) => Linkable with DomainElement =
+    KafkaChannelBinding040.apply
+}
+
+object KafkaChannelBinding040 {
+  def apply(): KafkaChannelBinding040 = apply(Annotations())
+
+  def apply(annotations: Annotations): KafkaChannelBinding040 = apply(Fields(), annotations)
+
+  def apply(fields: Fields, annotations: Annotations): KafkaChannelBinding040 =
+    new KafkaChannelBinding040(fields, annotations)
+}
+
+class KafkaTopicConfiguration(override val fields: Fields, override val annotations: Annotations)
+    extends DomainElement {
+  override def meta: KafkaTopicConfigurationModel.type = KafkaTopicConfigurationModel
+  override def componentId: String                     = "/kafka-topic-configuration"
+
+  def cleanupPolicy: Seq[StrField] = fields.field(KafkaTopicConfigurationModel.CleanupPolicy)
+  def retentionMs: IntField        = fields.field(KafkaTopicConfigurationModel.RetentionMs)
+  def retentionBytes: IntField     = fields.field(KafkaTopicConfigurationModel.RetentionBytes)
+  def deleteRetentionMs: IntField  = fields.field(KafkaTopicConfigurationModel.DeleteRetentionMs)
+  def maxMessageBytes: IntField    = fields.field(KafkaTopicConfigurationModel.MaxMessageBytes)
+
+  def withCleanupPolicy(cleanupPolicy: Seq[String]): this.type =
+    set(KafkaTopicConfigurationModel.CleanupPolicy, cleanupPolicy)
+  def withRetentionMs(retentionMs: Int): this.type =
+    set(KafkaTopicConfigurationModel.RetentionMs, retentionMs)
+  def withRetentionBytes(retentionBytes: Int): this.type =
+    set(KafkaTopicConfigurationModel.RetentionBytes, retentionBytes)
+  def withDeleteRetentionMS(deleteRetentionMS: Int): this.type =
+    set(KafkaTopicConfigurationModel.DeleteRetentionMs, deleteRetentionMS)
+  def withMaxMessageBytes(maxMessageBytes: Int): this.type =
+    set(KafkaTopicConfigurationModel.MaxMessageBytes, maxMessageBytes)
+}
+
+object KafkaTopicConfiguration {
+  def apply(): KafkaTopicConfiguration = apply(Annotations())
+
+  def apply(annotations: Annotations): KafkaTopicConfiguration = apply(Fields(), annotations)
+
+  def apply(fields: Fields, annotations: Annotations): KafkaTopicConfiguration =
+    new KafkaTopicConfiguration(fields, annotations)
+}