using new links class on index resource

Author: thefringeninja

src/SqlStreamStore.HAL/IndexMiddleware.cs

@@ -12,20 +12,22 @@ namespace SqlStreamStore.HAL
     internal static class IndexMiddleware
     {
         public static IApplicationBuilder UseIndex(this IApplicationBuilder builder)
-            => builder.MapWhen(IsIndex, inner => inner.Use(Index));
+            => builder.MapWhen(IsIndex, inner => inner.Use(Index()));
 
         private static bool IsIndex(HttpContext context)
             => (context.Request.Path.Value ?? "/") == "/";
 
-        private static MidFunc Index => (context, next) =>
+        private static MidFunc Index()
         {
             var response = new Response(new HALResponse(null)
-                .AddLinks(new Link(Constants.Relations.Feed, "stream"))
-                .AddLinks(new Link(Constants.Relations.Self, string.Empty))
-                .AddLinks(Links.Index(string.Empty))
-                .AddLinks(Links.Find("streams/{streamId}")));
+                .AddLinks(
+                    TheLinks
+                        .RootedAt(string.Empty)
+                        .Index().Self()
+                        .Find()
+                        .Add(Constants.Relations.Feed, "stream")));
 
-            return context.WriteResponse(response);
-        };
+            return (context, next) => context.WriteResponse(response);
+        }
     }
 }

src/SqlStreamStore.HAL/Links.cs

@@ -1,10 +1,98 @@
 namespace SqlStreamStore.HAL
 {
+    using System;
+    using System.Collections.Generic;
+    using System.Runtime.InteropServices;
     using Halcyon.HAL;
 
     internal static class Links
     {
-        public static Link Find(string href) => new Link(Constants.Relations.Find, href, "Find a Stream", replaceParameters: false);
-        public static Link Index(string href) => new Link(Constants.Relations.Index, href, "Index", replaceParameters: false);
+        public static Link Find(string href) =>
+            new Link(Constants.Relations.Find, href, "Find a Stream", replaceParameters: false);
+
+        public static Link Index(string href) =>
+            new Link(Constants.Relations.Index, href, "Index", replaceParameters: false);
+    }
+
+    internal static class LinkExtensions
+    {
+        public static TheLinks Index(this TheLinks links) =>
+            links.Add(Constants.Relations.Index, string.Empty, "Index");
+
+        public static TheLinks Find(this TheLinks links)
+            => links.Add(Constants.Relations.Find, "stream/{streamId}", "Find a Stream");
+    }
+
+    internal class TheLinks
+    {
+        private readonly List<(string rel, string href, string title)> _links;
+        private readonly string _relativePathToRoot;
+
+        public static TheLinks RootedAt(string relativePathToRoot) => new TheLinks(relativePathToRoot);
+
+        private TheLinks(string relativePathToRoot)
+        {
+            if(!string.IsNullOrEmpty(relativePathToRoot))
+            {
+                if(!relativePathToRoot.StartsWith(".."))
+                {
+                    throw new ArgumentException("Non-empty relative path to root must start with '..'",
+                        nameof(relativePathToRoot));
+                }
+
+                if(!relativePathToRoot.EndsWith("/"))
+                {
+                    throw new ArgumentException("Non-empty relative path to root must end with '/'",
+                        nameof(relativePathToRoot));
+                }
+            }
+
+            _relativePathToRoot = relativePathToRoot ?? string.Empty;
+            _links = new List<(string rel, string href, string title)>();
+        }
+
+        public TheLinks Add(string rel, string href, string title = null)
+        {
+            if(rel == null)
+                throw new ArgumentNullException(nameof(rel));
+            if(href == null)
+                throw new ArgumentNullException(nameof(href));
+
+            _links.Add((rel, href, title));
+            return this;
+        }
+
+        public TheLinks Self()
+        {
+            var link = _links[_links.Count - 1];
+
+            return Add(Constants.Relations.Self, link.href, link.title);
+        }
+
+        public TheLinks AddSelf(string rel, string href, string title = null)
+            => Add(rel, href, title)
+                .Add(Constants.Relations.Self, href, title);
+
+        public TheLinks Self(string rel)
+        {
+            return this;
+        }
+
+        public Link[] ToHalLinks()
+        {
+            var links = new Link[_links.Count];
+
+            for(var i = 0; i < _links.Count; i++)
+            {
+                var (rel, href, title) = _links[i];
+                var resolvedHref = $"{_relativePathToRoot}{href}";
+
+                links[i] = new Link(rel, resolvedHref, title, replaceParameters: false);
+            }
+
+            return links;
+        }
+
+        public static implicit operator Link[](TheLinks theLinks) => theLinks.ToHalLinks();
     }
 }