Resolves PR request

Author: Kali-Sh

src/Elders.Cronus/EventStore/PagingOptions.cs

@@ -24,12 +24,12 @@ public PagingOptions(int take, byte[] paginationToken, Order order)
 
     public static PagingOptions Empty() => new PagingOptions();
 
-    public string Serialize()
+    public override string ToString()
     {
         return Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(this));
     }
 
-    public static PagingOptions Deserialize(string paginationToken)
+    public static PagingOptions From(string paginationToken)
     {
         PagingOptions pagingOptions = Empty();
         if (string.IsNullOrEmpty(paginationToken) == false)
@@ -42,19 +42,32 @@ public static PagingOptions Deserialize(string paginationToken)
 }
 public sealed class Order : ValueObject<Order>
 {
-    Order() { }
-
-    Order(string order)
+    private const string AscendingOrder = "ascending";
+    private const string DescendingOrder = "descending";
+    public Order(string order)
     {
-        this.order = order;
+        this.order = GetOrderType(order);
     }
 
     [JsonInclude]
     private readonly string order;
 
-    public static Order Ascending = new Order("ascending");
+    public static Order Ascending = new Order(AscendingOrder);
+
+    public static Order Descending = new Order(DescendingOrder);
 
-    public static Order Descending = new Order("descending");
+    string GetOrderType(string value)
+    {
+        if(string.IsNullOrEmpty(value))
+            throw new ArgumentNullException(nameof(value));
+
+        if (value.Equals(AscendingOrder, StringComparison.OrdinalIgnoreCase))
+            return Ascending;
+        else if (value.Equals(DescendingOrder, StringComparison.OrdinalIgnoreCase))
+            return Descending;
+        else
+            throw new InvalidOperationException("Maimuna");
+    }
 
     public static implicit operator string(Order order)
     {

src/Elders.Cronus/Projections/ProjectionQueryOptions.cs

@@ -3,21 +3,33 @@
 
 namespace Elders.Cronus.Projections.Cassandra;
 
-public readonly struct ProjectionQueryOptions(IBlobId id, ProjectionVersion version, PagingOptions pagingOptions, DateTimeOffset? asOf, int? batchSize)
+public readonly struct ProjectionQueryOptions
 {
     private const int DefaultBatchSize = 1000;
 
+    ProjectionQueryOptions(IBlobId id, ProjectionVersion version, PagingOptions pagingOptions, DateTimeOffset? asOf, int? batchSize)
+    {
+        Id = id;
+        Version = version;
+        PagingOptions = pagingOptions;
+        AsOf = asOf;
+        batchSize ??= DefaultBatchSize;
+        BatchSize = batchSize.Value;
+    }
+
     public ProjectionQueryOptions(IBlobId id, ProjectionVersion version, DateTimeOffset asOf) : this(id, version, default, asOf, DefaultBatchSize) { }
 
     public ProjectionQueryOptions(IBlobId id, ProjectionVersion version, PagingOptions options) : this(id, version, options, null, options.Take) { }
 
-    public IBlobId Id { get; } = id;
+    public ProjectionQueryOptions(IBlobId id, ProjectionVersion version) : this(id, version, null, null, DefaultBatchSize) { }
+
+    public IBlobId Id { get; }
 
-    public ProjectionVersion Version { get; } = version;
+    public ProjectionVersion Version { get; }
 
-    public DateTimeOffset? AsOf { get; } = asOf;
+    public DateTimeOffset? AsOf { get; }
 
-    public PagingOptions PagingOptions { get; } = pagingOptions;
+    public PagingOptions PagingOptions { get; }
 
-    public int BatchSize { get; } = batchSize ?? DefaultBatchSize;
+    public int BatchSize { get; }
 }

src/Elders.Cronus/Projections/ProjectionStream.cs

@@ -29,20 +29,12 @@ public ProjectionStream(ProjectionVersion version, IBlobId projectionId, IEnumer
         this.events = events;
     }
 
-    public async Task<T> RestoreFromHistoryAsync<T>(T projection, Order order = null) where T : IProjectionDefinition
+    public async Task<T> RestoreFromHistoryAsync<T>(T projection) where T : IProjectionDefinition
     {
         if (events.Any() == false)
             return default(T);
 
-        IEnumerable<IEvent> eventsOrderedByTimestamp;
-        if (order is null || order == Order.Ascending)
-        {
-            eventsOrderedByTimestamp = events.OrderBy(@event => @event.Timestamp);
-        }
-        else
-        {
-            eventsOrderedByTimestamp = events.OrderByDescending(@event => @event.Timestamp); // Use load by descening with discretion, it might go bum bam when initizlizing the state, if you dont know what you are doing.
-        }
+        IEnumerable<IEvent> eventsOrderedByTimestamp = events.OrderBy(@event => @event.Timestamp);
 
         projection.InitializeState(projectionId, null);
         foreach (IEvent @event in eventsOrderedByTimestamp)