W-12689957 - Added new components for Async 2.3

aml-org · Feb 5, 2024 · bf237ab · bf237ab
1 parent b7cc307
commit bf237ab
Show file tree

Hide file tree

Showing 26 changed files with 901 additions and 164 deletions.
diff --git a/...ontract/shared/src/main/scala/amf/apicontract/client/platform/model/domain/EndPoint.scala b/...ontract/shared/src/main/scala/amf/apicontract/client/platform/model/domain/EndPoint.scala
@@ -3,11 +3,10 @@ package amf.apicontract.client.platform.model.domain
 import amf.apicontract.client.platform.model.domain.bindings.ChannelBindings
 import amf.apicontract.client.platform.model.domain.federation.EndPointFederationMetadata
 import amf.apicontract.client.platform.model.domain.security.SecurityRequirement
+import amf.apicontract.client.scala.model.domain.{EndPoint => InternalEndPoint}
 import amf.apicontract.internal.convert.ApiClientConverters._
 import amf.core.client.platform.model.StrField
-import amf.core.client.platform.model.domain.{DomainElement, NamedDomainElement}
-import amf.apicontract.client.scala.model.domain.{EndPoint => InternalEndPoint}
-import amf.core.client.platform.model.domain.federation.ShapeFederationMetadata
+import amf.core.client.platform.model.domain.{DomainElement, Linkable, NamedDomainElement}
 
 import scala.scalajs.js.annotation.{JSExportAll, JSExportTopLevel}
 
@@ -16,7 +15,8 @@ import scala.scalajs.js.annotation.{JSExportAll, JSExportTopLevel}
 @JSExportAll
 case class EndPoint(override private[amf] val _internal: InternalEndPoint)
     extends DomainElement
-    with NamedDomainElement {
+    with NamedDomainElement
+    with Linkable {
 
   @JSExportTopLevel("EndPoint")
   def this() = this(InternalEndPoint())
@@ -117,4 +117,6 @@ case class EndPoint(override private[amf] val _internal: InternalEndPoint)
     _internal.withBindings(bindings)
     this
   }
+
+  override def linkCopy(): EndPoint = _internal.linkCopy()
 }
diff --git a/...-contract/shared/src/main/scala/amf/apicontract/client/platform/model/domain/Server.scala b/...-contract/shared/src/main/scala/amf/apicontract/client/platform/model/domain/Server.scala
@@ -4,7 +4,7 @@ import amf.apicontract.client.platform.model.domain.bindings.ServerBindings
 import amf.apicontract.client.platform.model.domain.security.SecurityRequirement
 import amf.apicontract.internal.convert.ApiClientConverters.ClientList
 import amf.core.client.platform.model.StrField
-import amf.core.client.platform.model.domain.DomainElement
+import amf.core.client.platform.model.domain.{DomainElement, Linkable}
 
 import scala.scalajs.js.annotation.{JSExportAll, JSExportTopLevel}
 import amf.apicontract.client.scala.model.domain.{Server => InternalServer}
@@ -13,7 +13,7 @@ import amf.apicontract.internal.convert.ApiClientConverters._
 /** Server model class.
   */
 @JSExportAll
-case class Server(override private[amf] val _internal: InternalServer) extends DomainElement {
+case class Server(override private[amf] val _internal: InternalServer) extends DomainElement with Linkable {
 
   @JSExportTopLevel("Server")
   def this() = this(InternalServer())
@@ -69,4 +69,6 @@ case class Server(override private[amf] val _internal: InternalServer) extends D
     * Parameter is required.
     */
   def withVariable(name: String): Parameter = _internal.withVariable(name)
+
+  override def linkCopy(): Server = _internal.linkCopy()
 }
diff --git a/...i-contract/shared/src/main/scala/amf/apicontract/client/scala/model/domain/EndPoint.scala b/...i-contract/shared/src/main/scala/amf/apicontract/client/scala/model/domain/EndPoint.scala
@@ -7,8 +7,8 @@ import amf.apicontract.internal.annotations.ParentEndPoint
 import amf.apicontract.internal.metamodel.domain.EndPointModel
 import amf.apicontract.internal.metamodel.domain.EndPointModel._
 import amf.core.client.scala.model.StrField
-import amf.core.client.scala.model.domain.NamedDomainElement
-import amf.core.client.scala.model.domain.federation.{FederationMetadata, HasFederationMetadata}
+import amf.core.client.scala.model.domain.federation.HasFederationMetadata
+import amf.core.client.scala.model.domain.{DomainElement, Linkable, NamedDomainElement}
 import amf.core.internal.metamodel.Field
 import amf.core.internal.parser.domain.{Annotations, Fields}
 import amf.core.internal.utils.AmfStrings
@@ -20,7 +20,8 @@ class EndPoint(override val fields: Fields, override val annotations: Annotation
     with SecuredElement
     with ExtensibleWebApiDomainElement
     with ServerContainer
-    with HasFederationMetadata[EndPointFederationMetadata] {
+    with HasFederationMetadata[EndPointFederationMetadata]
+    with Linkable {
 
   def description: StrField      = fields.field(Description)
   def summary: StrField          = fields.field(Summary)
@@ -85,6 +86,11 @@ class EndPoint(override val fields: Fields, override val annotations: Annotation
     }
   }
   override def nameField: Field = Name
+
+  override def linkCopy(): EndPoint = EndPoint()
+
+  /** apply method for create a new instance with fields and annotations. Aux method for copy */
+  override protected def classConstructor: (Fields, Annotations) => Linkable with DomainElement = EndPoint.apply
 }
 
 object EndPoint {

diff --git a/...api-contract/shared/src/main/scala/amf/apicontract/client/scala/model/domain/Server.scala b/...api-contract/shared/src/main/scala/amf/apicontract/client/scala/model/domain/Server.scala
@@ -4,24 +4,29 @@ import amf.apicontract.client.scala.model.domain.bindings.ServerBindings
 import amf.apicontract.internal.metamodel.domain.ServerModel
 import amf.apicontract.internal.metamodel.domain.ServerModel._
 import amf.core.client.scala.model.StrField
+import amf.core.client.scala.model.domain.{DomainElement, Linkable, NamedDomainElement}
+import amf.core.internal.metamodel.Field
 import amf.core.internal.metamodel.domain.DomainElementModel
 import amf.core.internal.parser.domain.{Annotations, Fields}
 import amf.core.internal.utils.AmfStrings
 import org.yaml.model.YMap
 
 /** Server internal model
   */
-case class Server(fields: Fields, annotations: Annotations) extends SecuredElement {
+class Server(override val fields: Fields, override val annotations: Annotations)
+    extends SecuredElement
+    with NamedDomainElement
+    with Linkable {
+
+  override protected def nameField: Field = Name
 
-  def name: StrField            = fields.field(Name)
   def url: StrField             = fields.field(Url)
   def description: StrField     = fields.field(Description)
   def variables: Seq[Parameter] = fields.field(Variables)
   def protocol: StrField        = fields.field(Protocol)
   def protocolVersion: StrField = fields.field(ProtocolVersion)
   def bindings: ServerBindings  = fields.field(Bindings)
 
-  def withName(name: String): this.type                       = set(Name, name)
   def withUrl(url: String): this.type                         = set(Url, url)
   def withDescription(description: String): this.type         = set(Description, description)
   def withVariables(variables: Seq[Parameter]): this.type     = setArray(Variables, variables)
@@ -39,6 +44,12 @@ case class Server(fields: Fields, annotations: Annotations) extends SecuredEleme
 
   /** Value , path + field value that is used to compose the id when the object its adopted */
   override def componentId: String = "/" + url.option().orNull.urlComponentEncoded
+
+  override def linkCopy(): Server = Server().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 = Server.apply
+
 }
 
 object Server {
@@ -47,5 +58,7 @@ object Server {
 
   def apply(ast: YMap): Server = apply(Annotations(ast))
 
-  def apply(annotations: Annotations): Server = Server(Fields(), annotations)
+  def apply(annotations: Annotations): Server = apply(Fields(), annotations)
+
+  def apply(fields: Fields, annotations: Annotations): Server = new Server(fields, annotations)
 }
diff --git a/...ala/amf/apicontract/internal/spec/async/emitters/document/AsyncDeclarationsEmitters.scala b/...ala/amf/apicontract/internal/spec/async/emitters/document/AsyncDeclarationsEmitters.scala
@@ -1,14 +1,6 @@
 package amf.apicontract.internal.spec.async.emitters.document
 
-import amf.apicontract.internal.spec.async.emitters._
-import amf.apicontract.internal.spec.async.emitters.domain.{
-  AsyncApiBindingsDeclarationEmitter,
-  AsyncApiParametersEmitter,
-  AsyncCorrelationIdDeclarationsEmitter,
-  AsyncMessageDeclarationsEmitter,
-  AsyncOperationTraitsDeclarationEmitter,
-  AsyncSecuritySchemesEmitter
-}
+import amf.apicontract.internal.spec.async.emitters.domain._
 import amf.apicontract.internal.spec.common.WebApiDeclarations
 import amf.apicontract.internal.spec.oas.emitter.context.OasLikeSpecEmitterContext
 import amf.core.client.scala.errorhandling.UnhandledErrorHandler
@@ -77,6 +69,20 @@ case class AsyncDeclarationsEmitters(declares: Seq[DomainElement], ordering: Spe
         ordering
       )
 
+    if (declarations.servers.nonEmpty)
+      result += AsyncApiServersDeclarationEmitter(
+        "servers",
+        declarations.servers.values.toSeq,
+        ordering
+      )
+
+    if (declarations.channels.nonEmpty)
+      result += AsyncApiChannelsDeclarationEmitter(
+        "channels",
+        declarations.channels.values.toSeq,
+        ordering
+      )
+
     result
   }
 }
diff --git a/.../scala/amf/apicontract/internal/spec/async/emitters/domain/AsyncApiEndpointsEmitter.scala b/.../scala/amf/apicontract/internal/spec/async/emitters/domain/AsyncApiEndpointsEmitter.scala
@@ -3,12 +3,15 @@ package amf.apicontract.internal.spec.async.emitters.domain
 import amf.apicontract.client.scala.model.domain.{EndPoint, Operation, Parameter}
 import amf.apicontract.internal.metamodel.domain.EndPointModel
 import amf.apicontract.internal.spec.oas.emitter.context.OasLikeSpecEmitterContext
+import amf.apicontract.internal.spec.oas.emitter.domain.OasTagToReferenceEmitter
 import org.mulesoft.common.client.lexical.Position
 import amf.core.internal.parser.domain.FieldEntry
 import amf.core.internal.render.BaseEmitters.{ValueEmitter, pos, traverse}
 import amf.core.internal.render.SpecOrdering
 import amf.core.internal.render.emitters.{EntryEmitter, PartEmitter}
 import amf.shapes.internal.annotations.OrphanOasExtension
+import org.mulesoft.common.client.lexical.Position.ZERO
+import org.yaml.model.YDocument.{EntryBuilder, PartBuilder}
 import org.yaml.model.{YDocument, YNode}
 
 import scala.collection.mutable.ListBuffer
@@ -44,23 +47,47 @@ class AsyncApiSingleEndpointEmitter(channel: EndPoint, ordering: SpecOrdering)(i
   }
 
   override def emit(b: YDocument.PartBuilder): Unit = {
-    val result = ListBuffer[EntryEmitter]()
-    val fs     = channel.fields
-    val bindingOrphanAnnotations =
-      channel.customDomainProperties.filter(_.extension.annotations.contains(classOf[OrphanOasExtension]))
-    fs.entry(EndPointModel.Description).foreach(f => result += ValueEmitter("description", f))
-    fs.entry(EndPointModel.Operations).foreach(f => result ++= operations(f))
-    fs.entry(EndPointModel.Parameters)
-      .foreach(f => result += new AsyncApiParametersEmitter(f.arrayValues[Parameter], ordering))
-    fs.entry(EndPointModel.Bindings)
-      .foreach(f => result += AsyncApiBindingsEmitter(f.value.value, ordering, bindingOrphanAnnotations))
-    b.obj(traverse(ordering.sorted(result), _))
+    if (channel.isLink) {
+      emitLink(b)
+    } else {
+      val result = ListBuffer[EntryEmitter]()
+      val fs     = channel.fields
+      val bindingOrphanAnnotations =
+        channel.customDomainProperties.filter(_.extension.annotations.contains(classOf[OrphanOasExtension]))
+      fs.entry(EndPointModel.Description).foreach(f => result += ValueEmitter("description", f))
+      fs.entry(EndPointModel.Operations).foreach(f => result ++= operations(f))
+      fs.entry(EndPointModel.Parameters)
+        .foreach(f => result += new AsyncApiParametersEmitter(f.arrayValues[Parameter], ordering))
+      fs.entry(EndPointModel.Bindings)
+        .foreach(f => result += AsyncApiBindingsEmitter(f.value.value, ordering, bindingOrphanAnnotations))
+      b.obj(traverse(ordering.sorted(result), _))
+    }
   }
 
   def operations(f: FieldEntry): Seq[AsyncApiOperationEmitter] =
     f.arrayValues[Operation]
       .filter(e => e.method.value().matches("subscribe|publish"))
       .map(o => new AsyncApiOperationEmitter(o, ordering)(spec))
 
+  def emitLink(b: PartBuilder): Unit = {
+    OasTagToReferenceEmitter(channel).emit(b)
+  }
+
   override def position(): Position = pos(channel.annotations)
 }
+
+case class AsyncApiChannelsDeclarationEmitter(key: String, channels: Seq[EndPoint], ordering: SpecOrdering)(implicit
+    val spec: OasLikeSpecEmitterContext
+) extends EntryEmitter {
+
+  override def emit(b: EntryBuilder): Unit = {
+    val namedChannelsEmitters =
+      channels.map(c => new AsyncApiSingleEndpointEmitter(c, ordering))
+    b.entry(
+      key,
+      _.obj(pb => namedChannelsEmitters.foreach(e => e.emit(pb)))
+    )
+  }
+
+  override def position(): Position = channels.headOption.map(b => pos(b.annotations)).getOrElse(ZERO)
+}
diff --git a/...in/scala/amf/apicontract/internal/spec/async/emitters/domain/AsyncApiServersEmitter.scala b/...in/scala/amf/apicontract/internal/spec/async/emitters/domain/AsyncApiServersEmitter.scala
@@ -8,13 +8,16 @@ import amf.apicontract.internal.spec.common.emitter.{
   SecurityRequirementsEmitter
 }
 import amf.apicontract.internal.spec.oas.emitter.context.OasLikeSpecEmitterContext
-import org.mulesoft.common.client.lexical.Position
+import amf.apicontract.internal.spec.oas.emitter.domain.OasTagToReferenceEmitter
 import amf.core.internal.parser.domain.FieldEntry
 import amf.core.internal.render.BaseEmitters.{ValueEmitter, pos, traverse}
 import amf.core.internal.render.SpecOrdering
 import amf.core.internal.render.emitters.{EntryEmitter, PartEmitter}
 import amf.shapes.internal.annotations.OrphanOasExtension
 import amf.shapes.internal.spec.common.emitter.annotations.AnnotationsEmitter
+import org.mulesoft.common.client.lexical.Position
+import org.mulesoft.common.client.lexical.Position.ZERO
+import org.yaml.model.YDocument.{EntryBuilder, PartBuilder}
 import org.yaml.model.{YDocument, YNode}
 
 import scala.collection.mutable.ListBuffer
@@ -50,25 +53,50 @@ class AsyncApiServerPartEmitter(server: Server, ordering: SpecOrdering)(implicit
     extends PartEmitter {
   protected implicit val shapeCtx = AgnosticShapeEmitterContextAdapter(spec)
   override def emit(b: YDocument.PartBuilder): Unit = {
-    val result = ListBuffer[EntryEmitter]()
-    val fs     = server.fields
 
-    val bindingOrphanAnnotations =
-      server.customDomainProperties.filter(_.extension.annotations.contains(classOf[OrphanOasExtension]))
+    if (server.isLink) {
+      emitLink(b)
+    } else {
+      val result = ListBuffer[EntryEmitter]()
+      val fs     = server.fields
+      val bindingOrphanAnnotations =
+        server.customDomainProperties.filter(_.extension.annotations.contains(classOf[OrphanOasExtension]))
 
-    fs.entry(ServerModel.Url).foreach(f => result += ValueEmitter("url", f))
-    fs.entry(ServerModel.Protocol).foreach(f => result += ValueEmitter("protocol", f))
-    fs.entry(ServerModel.ProtocolVersion).foreach(f => result += ValueEmitter("protocolVersion", f))
-    fs.entry(ServerModel.Description).foreach(f => result += ValueEmitter("description", f))
-    fs.entry(ServerModel.Variables).foreach(f => result += OasServerVariablesEmitter(f, ordering))
-    fs.entry(ServerModel.Security).foreach(f => result += SecurityRequirementsEmitter("security", f, ordering))
-    fs.entry(ServerModel.Bindings)
-      .foreach(f => result += AsyncApiBindingsEmitter(f.value.value, ordering, bindingOrphanAnnotations))
+      fs.entry(ServerModel.Url).foreach(f => result += ValueEmitter("url", f))
+      fs.entry(ServerModel.Protocol).foreach(f => result += ValueEmitter("protocol", f))
+      fs.entry(ServerModel.ProtocolVersion).foreach(f => result += ValueEmitter("protocolVersion", f))
+      fs.entry(ServerModel.Description).foreach(f => result += ValueEmitter("description", f))
+      fs.entry(ServerModel.Variables).foreach(f => result += OasServerVariablesEmitter(f, ordering))
+      fs.entry(ServerModel.Security).foreach(f => result += SecurityRequirementsEmitter("security", f, ordering))
+      fs.entry(ServerModel.Bindings)
+        .foreach(f => result += AsyncApiBindingsEmitter(f.value.value, ordering, bindingOrphanAnnotations))
 
-    result ++= AnnotationsEmitter(server, ordering).emitters
+      result ++= AnnotationsEmitter(server, ordering).emitters
+
+      b.obj(traverse(ordering.sorted(result), _))
+    }
 
-    b.obj(traverse(ordering.sorted(result), _))
+  }
+
+  def emitLink(b: PartBuilder): Unit = {
+    OasTagToReferenceEmitter(server).emit(b)
   }
 
   override def position(): Position = pos(server.annotations)
 }
+
+case class AsyncApiServersDeclarationEmitter(key: String, servers: Seq[Server], ordering: SpecOrdering)(implicit
+    val spec: OasLikeSpecEmitterContext
+) extends EntryEmitter {
+
+  override def emit(b: EntryBuilder): Unit = {
+    val namedServersEmitters =
+      servers.map(s => new AsyncApiSingleServerEmitter(s, ordering))
+    b.entry(
+      key,
+      _.obj(pb => namedServersEmitters.foreach(e => e.emit(pb)))
+    )
+  }
+
+  override def position(): Position = servers.headOption.map(b => pos(b.annotations)).getOrElse(ZERO)
+}
diff --git a/...la/amf/apicontract/internal/spec/async/parser/bindings/AsyncOperationBindingsParser.scala b/...la/amf/apicontract/internal/spec/async/parser/bindings/AsyncOperationBindingsParser.scala
@@ -1,9 +1,5 @@
 package amf.apicontract.internal.spec.async.parser.bindings
 
-import amf.apicontract.client.scala.model.domain.bindings.amqp.Amqp091OperationBinding
-import amf.apicontract.client.scala.model.domain.bindings.http.HttpOperationBinding
-import amf.apicontract.client.scala.model.domain.bindings.kafka.KafkaOperationBinding
-import amf.apicontract.client.scala.model.domain.bindings.mqtt.MqttOperationBinding
 import amf.apicontract.client.scala.model.domain.bindings.{OperationBinding, OperationBindings}
 import amf.apicontract.internal.metamodel.domain.bindings._
 import amf.apicontract.internal.spec.async.parser.bindings.AsyncOperationBindingsParser.parserMap
@@ -19,10 +15,8 @@ import amf.apicontract.internal.spec.common.WebApiDeclarations.ErrorOperationBin
 import amf.apicontract.internal.spec.spec.OasDefinitions
 import amf.core.client.scala.model.domain.AmfScalar
 import amf.core.internal.metamodel.Field
-import amf.core.internal.parser.YMapOps
 import amf.core.internal.parser.domain.{Annotations, SearchScope}
 import amf.shapes.internal.spec.common.parser.YMapEntryLike
-import org.yaml.model.{YMap, YMapEntry}
 
 object AsyncOperationBindingsParser {
   private val parserMap: Map[String, BindingParser[OperationBinding]] = Map(

diff --git a/...c/main/scala/amf/apicontract/internal/spec/async/parser/context/Async2WebApiContext.scala b/...c/main/scala/amf/apicontract/internal/spec/async/parser/context/Async2WebApiContext.scala
@@ -1,20 +1,10 @@
 package amf.apicontract.internal.spec.async.parser.context
 
-import amf.apicontract.internal.spec.async._
 import amf.apicontract.internal.spec.async.parser.context.syntax._
 import amf.apicontract.internal.spec.common.AsyncWebApiDeclarations
 import amf.core.client.scala.config.ParsingOptions
 import amf.core.client.scala.parse.document.{ParsedReference, ParserContext}
-import amf.core.internal.remote.{
-  AsyncApi20,
-  AsyncApi21,
-  AsyncApi22,
-  AsyncApi23,
-  AsyncApi24,
-  AsyncApi25,
-  AsyncApi26,
-  Spec
-}
+import amf.core.internal.remote._
 import amf.shapes.internal.spec.async.parser.Async2Settings
 
 import scala.collection.mutable
@@ -142,10 +132,10 @@ object Async2WebApiContext {
     case AsyncApi20 => ctx => Async20VersionFactory()(ctx)
     case AsyncApi21 => ctx => Async20VersionFactory()(ctx)
     case AsyncApi22 => ctx => Async20VersionFactory()(ctx)
-    case AsyncApi23 => ctx => Async20VersionFactory()(ctx)
-    case AsyncApi24 => ctx => Async20VersionFactory()(ctx)
-    case AsyncApi25 => ctx => Async20VersionFactory()(ctx)
-    case AsyncApi26 => ctx => Async20VersionFactory()(ctx)
+    case AsyncApi23 => ctx => Async23VersionFactory()(ctx)
+    case AsyncApi24 => ctx => Async23VersionFactory()(ctx)
+    case AsyncApi25 => ctx => Async23VersionFactory()(ctx)
+    case AsyncApi26 => ctx => Async23VersionFactory()(ctx)
   }
 
   private def bindingSet(spec: Spec): AsyncValidBindingSet = spec match {