feat(bindings): add SNS AWS bindings

src/LEGO.AsyncAPI.Readers/Bindings/AsyncApiSnsBindingsDeserializer.cs

@@ -0,0 +1,41 @@
+namespace LEGO.AsyncAPI.Readers
+{
+
+    using LEGO.AsyncAPI.Models.Bindings.Sns;
+    using LEGO.AsyncAPI.Readers.ParseNodes;
+
+    internal static partial class AsyncApiV2Deserializer
+    {
+        private static FixedFieldMap<SnsChannelBinding> snsChannelBindingFixedFields = new()
+        {
+            { "name", (a, n) => { a.Name = n.GetScalarValue(); } },
+            { "policy", (a, n) => { a.Policy = LoadPolicy(n); } },
+        };
+
+        private static FixedFieldMap<Policy> policyFixedFields = new()
+        {
+            { "statements", (a, n) => { a.Statements = n.CreateSimpleList(s => LoadStatement(s)); } },
+        };
+
+        private static FixedFieldMap<Statement> statementFixedFields = new()
+        {
+            { "principal", (a, n) => { a.Principal = n.GetScalarValue(); } },
+        };
+
+        private static Policy LoadPolicy(ParseNode node)
+        {
+            var mapNode = node.CheckMapNode("policy");
+            var policy = new Policy();
+            ParseMap(mapNode, policy, policyFixedFields, null);
+            return policy;
+        }
+
+        private static Statement LoadStatement(ParseNode node)
+        {
+            var mapNode = node.CheckMapNode("statement");
+            var statement = new Statement();
+            ParseMap(mapNode, statement, statementFixedFields, null);
+            return statement;
+        }
+    }
+}

src/LEGO.AsyncAPI/Models/AsyncApiConstants.cs

@@ -138,5 +138,8 @@ public static class AsyncApiConstants
         public const string MaxMessageBytes = "max.message.bytes";
         public const string TopicConfiguration = "topicConfiguration";
         public const string GeoReplication = "geo-replication";
+        public const string Policy = "policy";
+        public const string Statements = "statements";
+        public const string Principal = "principal";
     }
 }

src/LEGO.AsyncAPI/Models/Bindings/BindingType.cs

@@ -17,5 +17,8 @@ public enum BindingType
 
         [Display("pulsar")]
         Pulsar,
+
+        [Display("sns")]
+        Sns,
     }
 }

src/LEGO.AsyncAPI/Models/Bindings/Sns/OrderingConfiguration.cs

@@ -0,0 +1,20 @@
+namespace LEGO.AsyncAPI.Models.Bindings.Sns;
+
+public class OrderingConfiguration
+{
+    /// <summary>
+    /// What type of SNS Topic is this?
+    /// </summary>
+    public Ordering Type { get; set; }
+
+    /// <summary>
+    /// True to turn on de-duplication of messages for a channel.
+    /// </summary>
+    public bool ContentBasedDeduplication { get; set; }
+}
+
+public enum Ordering
+{
+    Standard,
+    Fifo
+}

src/LEGO.AsyncAPI/Models/Bindings/Sns/Policy.cs

@@ -0,0 +1,27 @@
+using System;
+using LEGO.AsyncAPI.Models.Interfaces;
+using LEGO.AsyncAPI.Writers;
+
+namespace LEGO.AsyncAPI.Models.Bindings.Sns;
+
+using System.Collections.Generic;
+
+public class Policy : IAsyncApiElement
+{
+    /// <summary>
+    /// An array of statement objects, each of which controls a permission for this topic.
+    /// </summary>
+    public List<Statement> Statements { get; set; }
+
+    public void Serialize(IAsyncApiWriter writer)
+    {
+        if (writer is null)
+        {
+            throw new ArgumentNullException(nameof(writer));
+        }
+
+        writer.WriteStartObject();
+        writer.WriteOptionalCollection(AsyncApiConstants.Statements, this.Statements, (w, t) => t.Serialize(w));
+        writer.WriteEndObject();
+    }
+}

src/LEGO.AsyncAPI/Models/Bindings/Sns/SnsChannelBinding.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using LEGO.AsyncAPI.Writers;
+
+namespace LEGO.AsyncAPI.Models.Bindings.Sns;
+
+using LEGO.AsyncAPI.Models.Interfaces;
+
+/// <summary>
+/// Binding class for SNS channel settings.
+/// </summary>
+public class SnsChannelBinding : IChannelBinding
+{
+    /// <summary>
+    /// The name of the topic. Can be different from the channel name to allow flexibility around AWS resource naming limitations.
+    /// </summary>
+    public string Name { get; set; }
+
+    /// <summary>
+    /// By default, we assume an unordered SNS topic. This field allows configuration of a FIFO SNS Topic.
+    /// </summary>
+    public OrderingConfiguration Ordering { get; set; }
+
+    /// <summary>
+    /// The security policy for the SNS Topic.
+    /// </summary>
+    public Policy Policy { get; set; }
+
+    /// <summary>
+    /// Key-value pairs that represent AWS tags on the topic.
+    /// </summary>
+    public Dictionary<string, string> Tags { get; set; }
+
+    /// <summary>
+    /// The version of this binding.
+    /// </summary>
+    public string BindingVersion { get; set; }
+
+    public BindingType Type => BindingType.Sns;
+
+    public bool UnresolvedReference { get; set; }
+
+    public AsyncApiReference Reference { get; set; }
+
+    public IDictionary<string, IAsyncApiExtension> Extensions { get; set; } = new Dictionary<string, IAsyncApiExtension>();
+
+    public void SerializeV2WithoutReference(IAsyncApiWriter writer)
+    {
+        if (writer is null)
+        {
+            throw new ArgumentNullException(nameof(writer));
+        }
+
+        writer.WriteStartObject();
+        writer.WriteOptionalProperty(AsyncApiConstants.Name, this.Name);
+        writer.WriteOptionalObject(AsyncApiConstants.Policy, this.Policy, (w, t) => t.Serialize(w));
+
+        writer.WriteEndObject();
+    }
+
+    public void SerializeV2(IAsyncApiWriter writer)
+    {
+        if (writer is null)
+        {
+            throw new ArgumentNullException(nameof(writer));
+        }
+
+        if (this.Reference != null && !writer.GetSettings().ShouldInlineReference(this.Reference))
+        {
+            this.Reference.SerializeV2(writer);
+            return;
+        }
+
+        this.SerializeV2WithoutReference(writer);
+
+    }
+}

src/LEGO.AsyncAPI/Models/Bindings/Sns/Statement.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using LEGO.AsyncAPI.Models.Interfaces;
+using LEGO.AsyncAPI.Writers;
+
+namespace LEGO.AsyncAPI.Models.Bindings.Sns;
+
+public class Statement : IAsyncApiElement
+{
+    public Effect Effect { get; set; }
+
+    /// <summary>
+    /// The AWS account or resource ARN that this statement applies to.
+    /// </summary>
+    // public StringOrStringList Principal { get; set; }
+    public string Principal { get; set; }
+
+    /// <summary>
+    /// The SNS permission being allowed or denied e.g. sns:Publish
+    /// </summary>
+    // public StringOrStringList Action { get; set; }
+
+    public void Serialize(IAsyncApiWriter writer)
+    {
+        if (writer is null)
+        {
+            throw new ArgumentNullException(nameof(writer));
+        }
+
+        writer.WriteStartObject();
+        // writer.WriteOptionalObject(AsyncApiConstants.Principal, this.Principal, (w, t) => t.Serialize(w));
+        writer.WriteOptionalProperty(AsyncApiConstants.Principal, this.Principal);
+        writer.WriteEndObject();
+    }
+}
+
+public enum Effect
+{
+    Allow,
+    Deny
+}
+
+public class StringOrStringList : IAsyncApiElement
+{
+    public string StringValue { get; set; }
+
+    public List<string> StringList { get; set; }
+}

src/LEGO.AsyncAPI/Writers/AsyncApiWriterExtensions.cs

@@ -234,6 +234,8 @@ public static void WriteRequiredCollection<T>(
         {
             writer.WriteCollectionInternal(name, elements, action);
         }
+
+        // public static void WriteOptionalObjectCollection<T>(this )
 
         /// <summary>
         /// Write the optional AsyncApi element map (string to string mapping).

test/LEGO.AsyncAPI.Tests/Bindings/Sns/SnsBindings_Should.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace LEGO.AsyncAPI.Tests.Bindings.Sns
+{
+    using NUnit.Framework;
+    using System.Collections.Generic;
+    using FluentAssertions;
+    using LEGO.AsyncAPI.Models;
+    using LEGO.AsyncAPI.Models.Bindings.Sns;
+    using LEGO.AsyncAPI.Readers;
+
+    internal class SnsBindings_Should
+    {
+        [Test]
+        public void SnsChannelBinding_WithFilledObject_SerializesAndDeserializes()
+        {
+            // Arrange
+            var expected = 
+                @"bindings:
+  sns:
+    name: myTopic
+    policy:
+      statements:
+        - principal: hello";
+
+            var channel = new AsyncApiChannel();
+            channel.Bindings.Add(new SnsChannelBinding()
+            {
+                Name = "myTopic",
+                Policy = new Policy()
+                {
+                    Statements = new List<Statement>()
+                    {
+                        new Statement()
+                        {
+                            Principal = "hello",
+                        },
+                    },
+                },
+            });
+
+            // Act
+            var actual = channel.SerializeAsYaml(AsyncApiVersion.AsyncApi2_0);
+
+            // Assert
+            actual = actual.MakeLineBreaksEnvironmentNeutral();
+            expected = expected.MakeLineBreaksEnvironmentNeutral();
+
+            var binding = new AsyncApiStringReader().ReadFragment<AsyncApiChannel>(actual, AsyncApiVersion.AsyncApi2_0, out _);
+
+            // Assert
+            Assert.AreEqual(actual, expected);
+            binding.Should().BeEquivalentTo(channel);
+
+        }
+    }
+}