From 59085ba9ea3e9a0455c999817aa1612281f9198b Mon Sep 17 00:00:00 2001
From: Joseph Doherty <dohejw01@gmail.com>
Date: Sat, 28 Feb 2026 11:53:44 -0500
Subject: [PATCH] feat(batch8): implement store enum parity group B

---
 .../JetStream/StoreParity.cs                  | 242 ++++++++++++++++++
 .../JetStream/StoreTypes.cs                   |   6 +
 .../JetStream/StoreTypesTests.cs              |  99 +++++++
 porting.db                                    | Bin 6516736 -> 6524928 bytes
 4 files changed, 347 insertions(+)

diff --git a/dotnet/src/ZB.MOM.NatsNet.Server/JetStream/StoreParity.cs b/dotnet/src/ZB.MOM.NatsNet.Server/JetStream/StoreParity.cs
index 69e6681..900d58a 100644
--- a/dotnet/src/ZB.MOM.NatsNet.Server/JetStream/StoreParity.cs
+++ b/dotnet/src/ZB.MOM.NatsNet.Server/JetStream/StoreParity.cs
@@ -1,4 +1,6 @@
 using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 using ZB.MOM.NatsNet.Server.Internal.DataStructures;
 
 namespace ZB.MOM.NatsNet.Server;
@@ -274,3 +276,243 @@ public static class StoreParity
             => _set.Range(f);
     }
 }
+
+public static class StoreEnumParityExtensions
+{
+    public static string String(this RetentionPolicy value)
+        => value switch
+        {
+            RetentionPolicy.LimitsPolicy => "Limits",
+            RetentionPolicy.InterestPolicy => "Interest",
+            RetentionPolicy.WorkQueuePolicy => "WorkQueue",
+            _ => "Unknown Retention Policy",
+        };
+
+    public static string String(this DiscardPolicy value)
+        => value switch
+        {
+            DiscardPolicy.DiscardOld => "DiscardOld",
+            DiscardPolicy.DiscardNew => "DiscardNew",
+            _ => "Unknown Discard Policy",
+        };
+
+    public static string String(this StorageType value)
+        => value switch
+        {
+            StorageType.MemoryStorage => "Memory",
+            StorageType.FileStorage => "File",
+            _ => "Unknown Storage Type",
+        };
+}
+
+public sealed class RetentionPolicyJsonConverter : JsonConverter<RetentionPolicy>
+{
+    public override RetentionPolicy Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+            throw new JsonException("can not unmarshal token");
+
+        return reader.GetString() switch
+        {
+            "limits" => RetentionPolicy.LimitsPolicy,
+            "interest" => RetentionPolicy.InterestPolicy,
+            "workqueue" => RetentionPolicy.WorkQueuePolicy,
+            var value => throw new JsonException($"can not unmarshal \"{value}\""),
+        };
+    }
+
+    public override void Write(Utf8JsonWriter writer, RetentionPolicy value, JsonSerializerOptions options)
+    {
+        switch (value)
+        {
+            case RetentionPolicy.LimitsPolicy:
+                writer.WriteStringValue("limits");
+                break;
+            case RetentionPolicy.InterestPolicy:
+                writer.WriteStringValue("interest");
+                break;
+            case RetentionPolicy.WorkQueuePolicy:
+                writer.WriteStringValue("workqueue");
+                break;
+            default:
+                throw new JsonException($"can not marshal {value}");
+        }
+    }
+}
+
+public sealed class DiscardPolicyJsonConverter : JsonConverter<DiscardPolicy>
+{
+    public override DiscardPolicy Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+            throw new JsonException("can not unmarshal token");
+
+        var token = reader.GetString() ?? string.Empty;
+        return token.ToLowerInvariant() switch
+        {
+            "old" => DiscardPolicy.DiscardOld,
+            "new" => DiscardPolicy.DiscardNew,
+            _ => throw new JsonException($"can not unmarshal \"{token}\""),
+        };
+    }
+
+    public override void Write(Utf8JsonWriter writer, DiscardPolicy value, JsonSerializerOptions options)
+    {
+        switch (value)
+        {
+            case DiscardPolicy.DiscardOld:
+                writer.WriteStringValue("old");
+                break;
+            case DiscardPolicy.DiscardNew:
+                writer.WriteStringValue("new");
+                break;
+            default:
+                throw new JsonException($"can not marshal {value}");
+        }
+    }
+}
+
+public sealed class StorageTypeJsonConverter : JsonConverter<StorageType>
+{
+    public override StorageType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+            throw new JsonException("can not unmarshal token");
+
+        return reader.GetString() switch
+        {
+            "memory" => StorageType.MemoryStorage,
+            "file" => StorageType.FileStorage,
+            var value => throw new JsonException($"can not unmarshal \"{value}\""),
+        };
+    }
+
+    public override void Write(Utf8JsonWriter writer, StorageType value, JsonSerializerOptions options)
+    {
+        switch (value)
+        {
+            case StorageType.MemoryStorage:
+                writer.WriteStringValue("memory");
+                break;
+            case StorageType.FileStorage:
+                writer.WriteStringValue("file");
+                break;
+            default:
+                throw new JsonException($"can not marshal {value}");
+        }
+    }
+}
+
+public sealed class AckPolicyJsonConverter : JsonConverter<AckPolicy>
+{
+    public override AckPolicy Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+            throw new JsonException("can not unmarshal token");
+
+        return reader.GetString() switch
+        {
+            "none" => AckPolicy.AckNone,
+            "all" => AckPolicy.AckAll,
+            "explicit" => AckPolicy.AckExplicit,
+            var value => throw new JsonException($"can not unmarshal \"{value}\""),
+        };
+    }
+
+    public override void Write(Utf8JsonWriter writer, AckPolicy value, JsonSerializerOptions options)
+    {
+        switch (value)
+        {
+            case AckPolicy.AckNone:
+                writer.WriteStringValue("none");
+                break;
+            case AckPolicy.AckAll:
+                writer.WriteStringValue("all");
+                break;
+            case AckPolicy.AckExplicit:
+                writer.WriteStringValue("explicit");
+                break;
+            default:
+                throw new JsonException($"can not marshal {value}");
+        }
+    }
+}
+
+public sealed class ReplayPolicyJsonConverter : JsonConverter<ReplayPolicy>
+{
+    public override ReplayPolicy Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+            throw new JsonException("can not unmarshal token");
+
+        return reader.GetString() switch
+        {
+            "instant" => ReplayPolicy.ReplayInstant,
+            "original" => ReplayPolicy.ReplayOriginal,
+            var value => throw new JsonException($"can not unmarshal \"{value}\""),
+        };
+    }
+
+    public override void Write(Utf8JsonWriter writer, ReplayPolicy value, JsonSerializerOptions options)
+    {
+        switch (value)
+        {
+            case ReplayPolicy.ReplayInstant:
+                writer.WriteStringValue("instant");
+                break;
+            case ReplayPolicy.ReplayOriginal:
+                writer.WriteStringValue("original");
+                break;
+            default:
+                throw new JsonException($"can not marshal {value}");
+        }
+    }
+}
+
+public sealed class DeliverPolicyJsonConverter : JsonConverter<DeliverPolicy>
+{
+    public override DeliverPolicy Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+            throw new JsonException("can not unmarshal token");
+
+        return reader.GetString() switch
+        {
+            "all" or "undefined" => DeliverPolicy.DeliverAll,
+            "last" => DeliverPolicy.DeliverLast,
+            "last_per_subject" => DeliverPolicy.DeliverLastPerSubject,
+            "new" => DeliverPolicy.DeliverNew,
+            "by_start_sequence" => DeliverPolicy.DeliverByStartSequence,
+            "by_start_time" => DeliverPolicy.DeliverByStartTime,
+            var value => throw new JsonException($"can not unmarshal \"{value}\""),
+        };
+    }
+
+    public override void Write(Utf8JsonWriter writer, DeliverPolicy value, JsonSerializerOptions options)
+    {
+        switch (value)
+        {
+            case DeliverPolicy.DeliverAll:
+                writer.WriteStringValue("all");
+                break;
+            case DeliverPolicy.DeliverLast:
+                writer.WriteStringValue("last");
+                break;
+            case DeliverPolicy.DeliverLastPerSubject:
+                writer.WriteStringValue("last_per_subject");
+                break;
+            case DeliverPolicy.DeliverNew:
+                writer.WriteStringValue("new");
+                break;
+            case DeliverPolicy.DeliverByStartSequence:
+                writer.WriteStringValue("by_start_sequence");
+                break;
+            case DeliverPolicy.DeliverByStartTime:
+                writer.WriteStringValue("by_start_time");
+                break;
+            default:
+                writer.WriteStringValue("undefined");
+                break;
+        }
+    }
+}
diff --git a/dotnet/src/ZB.MOM.NatsNet.Server/JetStream/StoreTypes.cs b/dotnet/src/ZB.MOM.NatsNet.Server/JetStream/StoreTypes.cs
index 0783c52..c6fbb00 100644
--- a/dotnet/src/ZB.MOM.NatsNet.Server/JetStream/StoreTypes.cs
+++ b/dotnet/src/ZB.MOM.NatsNet.Server/JetStream/StoreTypes.cs
@@ -23,6 +23,7 @@ namespace ZB.MOM.NatsNet.Server;
 // ---------------------------------------------------------------------------
 
 /// <summary>Determines how messages are stored for retention.</summary>
+[JsonConverter(typeof(StorageTypeJsonConverter))]
 public enum StorageType
 {
     /// <summary>On disk, designated by the JetStream config StoreDir.</summary>
@@ -228,6 +229,7 @@ public interface IStreamStore
 // ---------------------------------------------------------------------------
 
 /// <summary>Determines how messages in a stream are retained.</summary>
+[JsonConverter(typeof(RetentionPolicyJsonConverter))]
 public enum RetentionPolicy
 {
     /// <summary>Messages are retained until any given limit is reached.</summary>
@@ -245,6 +247,7 @@ public enum RetentionPolicy
 // ---------------------------------------------------------------------------
 
 /// <summary>Determines how the store proceeds when message or byte limits are hit.</summary>
+[JsonConverter(typeof(DiscardPolicyJsonConverter))]
 public enum DiscardPolicy
 {
     /// <summary>Remove older messages to return to the limits.</summary>
@@ -542,6 +545,7 @@ public sealed class ConsumerState
 // ---------------------------------------------------------------------------
 
 /// <summary>Determines how the consumer should acknowledge delivered messages.</summary>
+[JsonConverter(typeof(AckPolicyJsonConverter))]
 public enum AckPolicy
 {
     /// <summary>No acks required for delivered messages.</summary>
@@ -559,6 +563,7 @@ public enum AckPolicy
 // ---------------------------------------------------------------------------
 
 /// <summary>Determines how the consumer replays messages already queued in the stream.</summary>
+[JsonConverter(typeof(ReplayPolicyJsonConverter))]
 public enum ReplayPolicy
 {
     /// <summary>Replay messages as fast as possible.</summary>
@@ -573,6 +578,7 @@ public enum ReplayPolicy
 // ---------------------------------------------------------------------------
 
 /// <summary>Determines how the consumer selects the first message to deliver.</summary>
+[JsonConverter(typeof(DeliverPolicyJsonConverter))]
 public enum DeliverPolicy
 {
     /// <summary>Deliver all messages (default).</summary>
diff --git a/dotnet/tests/ZB.MOM.NatsNet.Server.Tests/JetStream/StoreTypesTests.cs b/dotnet/tests/ZB.MOM.NatsNet.Server.Tests/JetStream/StoreTypesTests.cs
index 5dfbedd..9a369e0 100644
--- a/dotnet/tests/ZB.MOM.NatsNet.Server.Tests/JetStream/StoreTypesTests.cs
+++ b/dotnet/tests/ZB.MOM.NatsNet.Server.Tests/JetStream/StoreTypesTests.cs
@@ -1,4 +1,5 @@
 using System.Text;
+using System.Text.Json;
 using Shouldly;
 using ZB.MOM.NatsNet.Server;
 
@@ -223,6 +224,104 @@ public class StoreTypesTests
         StoreParity.IsPermissionError(null).ShouldBeFalse();
     }
 
+    [Fact]
+    public void RetentionPolicy_StringParity_ReturnsExpectedText()
+    {
+        RetentionPolicy.LimitsPolicy.String().ShouldBe("Limits");
+        RetentionPolicy.InterestPolicy.String().ShouldBe("Interest");
+        RetentionPolicy.WorkQueuePolicy.String().ShouldBe("WorkQueue");
+        ((RetentionPolicy)99).String().ShouldBe("Unknown Retention Policy");
+    }
+
+    [Fact]
+    public void RetentionPolicy_JsonParity_RoundTripsExpectedTokens()
+    {
+        JsonSerializer.Serialize(RetentionPolicy.LimitsPolicy).ShouldBe("\"limits\"");
+        JsonSerializer.Serialize(RetentionPolicy.InterestPolicy).ShouldBe("\"interest\"");
+        JsonSerializer.Serialize(RetentionPolicy.WorkQueuePolicy).ShouldBe("\"workqueue\"");
+
+        JsonSerializer.Deserialize<RetentionPolicy>("\"limits\"").ShouldBe(RetentionPolicy.LimitsPolicy);
+        JsonSerializer.Deserialize<RetentionPolicy>("\"interest\"").ShouldBe(RetentionPolicy.InterestPolicy);
+        JsonSerializer.Deserialize<RetentionPolicy>("\"workqueue\"").ShouldBe(RetentionPolicy.WorkQueuePolicy);
+    }
+
+    [Fact]
+    public void RetentionPolicy_UnmarshalInvalid_Throws()
+    {
+        Should.Throw<JsonException>(() => JsonSerializer.Deserialize<RetentionPolicy>("\"bogus\""));
+    }
+
+    [Fact]
+    public void DiscardPolicy_StringAndJsonParity_MatchesGo()
+    {
+        DiscardPolicy.DiscardOld.String().ShouldBe("DiscardOld");
+        DiscardPolicy.DiscardNew.String().ShouldBe("DiscardNew");
+        ((DiscardPolicy)99).String().ShouldBe("Unknown Discard Policy");
+
+        JsonSerializer.Serialize(DiscardPolicy.DiscardOld).ShouldBe("\"old\"");
+        JsonSerializer.Serialize(DiscardPolicy.DiscardNew).ShouldBe("\"new\"");
+        JsonSerializer.Deserialize<DiscardPolicy>("\"OLD\"").ShouldBe(DiscardPolicy.DiscardOld);
+        JsonSerializer.Deserialize<DiscardPolicy>("\"new\"").ShouldBe(DiscardPolicy.DiscardNew);
+    }
+
+    [Fact]
+    public void StorageType_StringAndJsonParity_MatchesGo()
+    {
+        StorageType.MemoryStorage.String().ShouldBe("Memory");
+        StorageType.FileStorage.String().ShouldBe("File");
+        ((StorageType)99).String().ShouldBe("Unknown Storage Type");
+
+        JsonSerializer.Serialize(StorageType.MemoryStorage).ShouldBe("\"memory\"");
+        JsonSerializer.Serialize(StorageType.FileStorage).ShouldBe("\"file\"");
+        JsonSerializer.Deserialize<StorageType>("\"memory\"").ShouldBe(StorageType.MemoryStorage);
+        JsonSerializer.Deserialize<StorageType>("\"file\"").ShouldBe(StorageType.FileStorage);
+    }
+
+    [Fact]
+    public void AckPolicy_JsonParity_MatchesGo()
+    {
+        JsonSerializer.Serialize(AckPolicy.AckNone).ShouldBe("\"none\"");
+        JsonSerializer.Serialize(AckPolicy.AckAll).ShouldBe("\"all\"");
+        JsonSerializer.Serialize(AckPolicy.AckExplicit).ShouldBe("\"explicit\"");
+
+        JsonSerializer.Deserialize<AckPolicy>("\"none\"").ShouldBe(AckPolicy.AckNone);
+        JsonSerializer.Deserialize<AckPolicy>("\"all\"").ShouldBe(AckPolicy.AckAll);
+        JsonSerializer.Deserialize<AckPolicy>("\"explicit\"").ShouldBe(AckPolicy.AckExplicit);
+        Should.Throw<JsonException>(() => JsonSerializer.Deserialize<AckPolicy>("\"bad\""));
+    }
+
+    [Fact]
+    public void ReplayPolicy_JsonParity_MatchesGo()
+    {
+        JsonSerializer.Serialize(ReplayPolicy.ReplayInstant).ShouldBe("\"instant\"");
+        JsonSerializer.Serialize(ReplayPolicy.ReplayOriginal).ShouldBe("\"original\"");
+
+        JsonSerializer.Deserialize<ReplayPolicy>("\"instant\"").ShouldBe(ReplayPolicy.ReplayInstant);
+        JsonSerializer.Deserialize<ReplayPolicy>("\"original\"").ShouldBe(ReplayPolicy.ReplayOriginal);
+        Should.Throw<JsonException>(() => JsonSerializer.Deserialize<ReplayPolicy>("\"bad\""));
+    }
+
+    [Fact]
+    public void DeliverPolicy_JsonParity_MapsUndefinedToAll()
+    {
+        JsonSerializer.Serialize(DeliverPolicy.DeliverAll).ShouldBe("\"all\"");
+        JsonSerializer.Serialize(DeliverPolicy.DeliverLast).ShouldBe("\"last\"");
+        JsonSerializer.Serialize(DeliverPolicy.DeliverLastPerSubject).ShouldBe("\"last_per_subject\"");
+        JsonSerializer.Serialize(DeliverPolicy.DeliverNew).ShouldBe("\"new\"");
+        JsonSerializer.Serialize(DeliverPolicy.DeliverByStartSequence).ShouldBe("\"by_start_sequence\"");
+        JsonSerializer.Serialize(DeliverPolicy.DeliverByStartTime).ShouldBe("\"by_start_time\"");
+        JsonSerializer.Serialize((DeliverPolicy)99).ShouldBe("\"undefined\"");
+
+        JsonSerializer.Deserialize<DeliverPolicy>("\"all\"").ShouldBe(DeliverPolicy.DeliverAll);
+        JsonSerializer.Deserialize<DeliverPolicy>("\"undefined\"").ShouldBe(DeliverPolicy.DeliverAll);
+        JsonSerializer.Deserialize<DeliverPolicy>("\"last\"").ShouldBe(DeliverPolicy.DeliverLast);
+        JsonSerializer.Deserialize<DeliverPolicy>("\"last_per_subject\"").ShouldBe(DeliverPolicy.DeliverLastPerSubject);
+        JsonSerializer.Deserialize<DeliverPolicy>("\"new\"").ShouldBe(DeliverPolicy.DeliverNew);
+        JsonSerializer.Deserialize<DeliverPolicy>("\"by_start_sequence\"").ShouldBe(DeliverPolicy.DeliverByStartSequence);
+        JsonSerializer.Deserialize<DeliverPolicy>("\"by_start_time\"").ShouldBe(DeliverPolicy.DeliverByStartTime);
+        Should.Throw<JsonException>(() => JsonSerializer.Deserialize<DeliverPolicy>("\"bad\""));
+    }
+
     private static void AppendUVarInt(List<byte> buffer, ulong value)
     {
         while (value >= 0x80)
diff --git a/porting.db b/porting.db
index 5110e5779319a6da9a76a7e8a6f6bfd4a258e0c8..4484a1ed67b3903d7eece0d6e537a968e6068c91 100644
GIT binary patch
delta 6133
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
B(JlZ0

delta 1568
zcmY+>TTB#Z6bJB``F3V^cE7z)gjR47(2<L_P!PF^P_$yL%H9jeWeRLV6K*aLFE3(w
zz%+=cji(JS*gmwek)|}w^r^8AwZ^oDCi-AwD>S5}t*NA1dr4FKXQyuA;g_8McfL70
zJ7;)moDI*NViW0dR1lQXGnv(5^h3S6K(hTla-qPuP#~_Kp)2!Z9^IK2731E#__cW4
zGA*p@=<Dh4jt)lcy-2P^>Txo!^f<8xD-%Cvy)N`W?(w5Y?TK^*DU?Wuk#;B25K>tp
z4O;WA3;BsSfM()lcn4DAWw>s1Er=gmy{&?<;!X?F|96^=io4>qbK(~y4@<{0_!9q~
z-{4pHC;TF7Wj<ERW4x0`_#R%tx6sstr~Uj1k3x5crC*FcPDrxIx`o~6M<gG;E_+;-
z<v(n+k4RHC$;rtwCgqkbA9Y4wiN<2lP99s84y{W4t5P57vL~0u#-#Q1uIy<u?5CtV
zsdneAU>_J9YPZYA{dc4v)T%*Ov#@>ngb$!9idP+|a^sbbDkEOCqFNKLT2RGj@McP#
zmO?umd+<r(GaPj)OOfKYj^WIlaTJv~;|MBq#$i<Ej3MK_X{kBOHsq|snNmu8R{F_!
z=yUtIQTMHME5;Q?-e(zOi>z2WO8zwQ65aB#J8tz$;j<(`EH2;dESAI+`mK?L$^DIW
zEnRNY929F}C6=O!qH_8!$XZDH$l|5xAS<M$d^w2~zS%{Gd|EPn5Ms6T_8FU(Tw%7A
zmL`~k_J`R4^9&C->GLqlHXFZ&nNDZDvX}ZItc(hKIH#L_c971NDe*HmH3wLZd3ij*
z0xKFk_}`S#nFs?5$e@4~Y@mW29KgW|E^r$&5l=w1oU=X@$TuZzqRbk%PUE^~qcN*{
zLJHN)B`?v^P2EZ5xAn5o$}SHi!4r@SYaj(u;YoN3)<PPj!#eOn2CRon$bxLxU{rQ(
z{Aw}R`lGc{8Fe?fE;|2o*7B2%8}fo&X_>S?U|CX!m@4$B_tc%Xlgmr0GL%NGz+$Ad
zYCntgR!D0!R}kM#T3E}Y%&ZJf^<gb&e(HGRT3E}W!aj?G{tjz<S2TJfT6Vl)Oh&YB
ziAq|uIqLOk4fNV2EOyebIcdqa{P6NlHu$xJ)P7ZpH@2DUxb4@P%vT5ov=W-QlFsRk
zfEG4?L<wre=Dl4(EoAPvEu^XRX%Me^`7f2z{h(HF?h}nd@~ma{^Ak)NRdfwDK@Q|X
z9^}Jj*aA<(Gf)79@GKNTF>Hkr*aoFg2IWuzm9QPEU<Xt~4Lk?6uoHH{^ROH0U=O?i
zd*Mac2m9dw)PoQF5P%?rAPf<B2^ydgn&2QbLkqM*8|d(|q3G@ZJW5qnQE->LV$S#Z
Z0{1#1_S5QBRW!2nmPMN(zS{9f`4=DC`u6|;