added basic placeholder system

Author: mxritzdev

LinkRouter/App/Configuration/Config.cs

@@ -1,4 +1,7 @@
-using LinkRouter.App.Models;
+using System.Text;
+using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
+using LinkRouter.App.Models;
 
 namespace LinkRouter.App.Configuration;
 
@@ -26,4 +29,83 @@ public class NotFoundBehaviorConfig
         public bool RedirectOn404 { get; set; } = false;
         public string RedirectUrl { get; set; } = "https://example.com/404";
     }
+
+    [JsonIgnore]
+    public static Regex PlaceholderPattern => new(@"\\\{(\d|\w+)\}");
+    
+    [JsonIgnore]
+    public CompiledRoute[]? CompiledRoutes { get; set; }
+    
+    public void CompileRoutes()
+    {
+        var compiledRoutes = new List<CompiledRoute>();
+        
+        foreach (var route in Routes)
+        {
+            if (!route.Route.StartsWith("/"))
+                route.Route = "/" + route.Route;
+            
+            if (!route.Route.EndsWith("/"))
+                route.Route += "/";
+            
+            var compiled = new CompiledRoute
+            {
+                Route = route.Route,
+                RedirectUrl = route.RedirectUrl
+            };
+    
+            var replacements = new List<(int Index, int Length, string NewText)>();
+
+            var escaped = Regex.Escape(route.Route);
+            
+            var matches = PlaceholderPattern.Matches(escaped);
+    
+            
+            foreach (var match in matches.Select(x => x))
+            {
+                // Check if the placeholder is immediately followed by another placeholder
+                
+                Console.WriteLine("matchlenght: "+ (match.Index + match.Length + 2) + " route lenght" + escaped.Length);
+                
+                if (escaped.Length >= match.Index + match.Length + 2 && escaped.Substring(match.Index + match.Length, 2) == "\\{")
+                        throw new InvalidOperationException(
+                            $"Placeholder {match.Groups[1].Value} cannot be immediately followed by another placeholder. " +
+                            $"Please add a string literal as separator.");
+
+                replacements.Add((match.Index, match.Length, "(.+)"));
+            }
+            
+            var compiledRouteBuilder = new StringBuilder(escaped);
+            
+            foreach (var replacement in replacements.OrderByDescending(r => r.Index))
+            {
+                compiledRouteBuilder.Remove(replacement.Index, replacement.Length);
+                compiledRouteBuilder.Insert(replacement.Index, replacement.NewText);
+            }
+
+            compiled.CompiledPattern = new Regex(compiledRouteBuilder.ToString(), RegexOptions.Compiled);
+
+            Console.WriteLine(compiled.CompiledPattern.ToString());
+            
+            var duplicate = matches
+                .Select((m, i) => m.Groups[1].Value)
+                .GroupBy(x => x)
+                .FirstOrDefault(x => x.Count() > 1);
+
+            if (duplicate != null)
+                throw new InvalidOperationException("Cannot use a placeholder twice in the route: " + duplicate.Key);
+            
+            compiled.Placeholders = matches
+                .Select((m, i) => m.Groups[1].Value)
+                .Distinct()
+                .Select((name, i) => (name, i))
+                .ToDictionary(x => x.name, x => x.i + 1);
+            
+            compiledRoutes.Add(compiled);
+        }
+
+        CompiledRoutes = compiledRoutes
+            .ToArray();
+    }
+    
 }

LinkRouter/App/Http/Controllers/RedirectController.cs

@@ -37,38 +37,54 @@ public RedirectController(Config config)
     }
 
     [HttpGet("/{*path}")]
-    public IActionResult RedirectToExternalUrl(string path)
+    public async Task<ActionResult> RedirectToExternalUrl(string path)
     {
-        var redirectRoute = Config.Routes.FirstOrDefault(x => x.Route == path || x.Route == path + "/" || x.Route == "/" + path);
-
-        if (redirectRoute != null)
+        
+        if (!path.EndsWith("/"))
+            path += "/";
+        
+        path = "/" + path;
+        
+        Console.WriteLine(path);
+        
+        var redirectRoute = Config.CompiledRoutes?.FirstOrDefault(x => x.CompiledPattern.IsMatch(path));
+        
+        if (redirectRoute == null)
         {
-            RouteCounter
-                .WithLabels(redirectRoute.Route)
+            NotFoundCounter
+                .WithLabels(path)
                 .Inc();
 
-            return Redirect(redirectRoute.RedirectUrl);
-        }
+            if (Config.NotFoundBehavior.RedirectOn404)
+                return Redirect(Config.NotFoundBehavior.RedirectUrl);
 
-        NotFoundCounter
-            .WithLabels("/" + path)
-            .Inc();
+            return NotFound();
+        }
+        
+        var match = redirectRoute.CompiledPattern.Match(path);
 
-        if (Config.NotFoundBehavior.RedirectOn404)
-            return Redirect(Config.NotFoundBehavior.RedirectUrl);
+        Console.WriteLine(redirectRoute.CompiledPattern);
 
-        return NotFound();
+        string redirectUrl = redirectRoute.RedirectUrl;
+        
+        foreach (var placeholder in redirectRoute.Placeholders)
+        {
+            var value = match.Groups[placeholder.Value].Value;
+            redirectUrl = redirectUrl.Replace("{" + placeholder.Key + "}", value);
+        }
+        
+        return Redirect(redirectUrl);
     }
-    
+
     [HttpGet("/")]
     public IActionResult GetRootRoute()
     {
         RouteCounter
             .WithLabels("/")
             .Inc();
-        
+
         string url = Config.RootRoute;
-        
+
         return Redirect(url);
     }
 }

LinkRouter/App/Models/CompiledRoute.cs

@@ -0,0 +1,10 @@
+using System.Text.RegularExpressions;
+
+namespace LinkRouter.App.Models;
+
+public class CompiledRoute : RedirectRoute
+{
+    public Regex CompiledPattern { get; set; }
+    
+    public Dictionary<string, int> Placeholders { get; set; } = new();
+}

LinkRouter/App/Services/ConfigWatcher.cs

@@ -18,6 +18,7 @@ public ConfigWatcher(ILogger<ConfigWatcher> logger, Config config)
 
     protected override Task ExecuteAsync(CancellationToken stoppingToken)
     {
+        
         if (!File.Exists(ConfigPath))
         {
             Logger.LogWarning("Watched file does not exist: {FilePath}", ConfigPath);
@@ -29,6 +30,8 @@ protected override Task ExecuteAsync(CancellationToken stoppingToken)
             NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.Size | NotifyFilters.CreationTime
         };
 
+        OnChanged(Watcher, new FileSystemEventArgs(WatcherChangeTypes.Created, string.Empty, string.Empty));
+        
         Watcher.Changed += OnChanged;
 
         Watcher.EnableRaisingEvents = true;
@@ -48,6 +51,15 @@ private void OnChanged(object sender, FileSystemEventArgs e)
             Config.RootRoute = config?.RootRoute ?? "https://example.com";
 
             Logger.LogInformation("Config file changed.");
+
+            try
+            {
+                Config.CompileRoutes();
+            } catch (InvalidOperationException ex)
+            {
+                Logger.LogError("Failed to compile routes: " + ex.Message);
+                Environment.Exit(1);
+            }
         }
         catch (IOException ex)
         {