Updates

Author: aritchie

skills/shiny-httpserver/SKILL.md

@@ -540,9 +540,15 @@ app.MapGeneratedMediatorEndpoints();       // or Map{Handler}MediatorEndpoints()
 
 1. **Prefer tier 3** for anything with typed parameters; tier 1 for small servers.
 2. **Always declare a `JsonSerializerContext`** and never use the reflection JSON overloads.
-3. **Route constraints are a closed set** — `int`, `long`, `guid`, `bool`, `double`, `decimal`,
-   `alpha`, `minlength(n)`, `maxlength(n)`, `length(n)`. Validate anything else in the handler so it
-   can return a meaningful error instead of a 404.
+3. **Route constraints are a closed set** — `byte`, `short`, `int`, `long`, `float`, `double`,
+   `decimal`, `bool`, `guid`, `alpha`, `datetime`, `dateonly`, `timeonly`, `timespan`,
+   `minlength(n)`, `maxlength(n)`, `length(n)`, `min(n)`, `max(n)`, `range(a,b)`. There is **no
+   `regex`** — validate anything richer in the handler so it can return a meaningful error instead of
+   a 404. Length constraints count characters; `min`/`max`/`range` compare the value and may take
+   negative arguments.
+   A constraint only decides whether the route **matches** — it converts nothing, and the binder
+   handles every `IParsable<T>` regardless. So `{id:int}` on a handler taking a `long` is fine, a
+   refused segment is a **404**, and a matched-but-unparseable one is a **400**.
 4. **Segments are literal or a parameter, never mixed** (`v{version}` is rejected at registration).
 5. **Register middleware before starting**; register routes whenever you like.
 6. **Put auth in front of static files** when they are not public.

src/Shiny.Net.HttpServer.SourceGenerators/RouteTemplateInfo.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 
 namespace Shiny.Net.HttpServer.SourceGenerators;
@@ -156,20 +157,33 @@ public static string Combine(string prefix, string template)
         return new RouteTemplateInfo("/" + normalized, names);
     }
 
+    /// <summary>
+    /// The constraint vocabulary, which must stay identical to
+    /// <c>Shiny.Net.HttpServer.Routing.RouteConstraint.Parse</c>. Anything accepted here and
+    /// rejected there is a route that compiles and never matches; the reverse is a route the
+    /// generator refuses for no reason. Parity is covered by tests.
+    /// </summary>
     static bool IsKnownConstraint(string constraint)
     {
         var paren = constraint.IndexOf('(');
         if (paren < 0)
         {
             switch (constraint.ToLowerInvariant())
             {
+                case "byte":
+                case "short":
                 case "int":
                 case "long":
-                case "guid":
-                case "bool":
+                case "float":
                 case "double":
                 case "decimal":
+                case "bool":
+                case "guid":
                 case "alpha":
+                case "datetime":
+                case "dateonly":
+                case "timeonly":
+                case "timespan":
                     return true;
                 default:
                     return false;
@@ -180,11 +194,43 @@ static bool IsKnownConstraint(string constraint)
             return false;
 
         var name = constraint.Substring(0, paren).ToLowerInvariant();
-        var argument = constraint.Substring(paren + 1, constraint.Length - paren - 2);
+        var arguments = constraint.Substring(paren + 1, constraint.Length - paren - 2);
+
+        var comma = arguments.IndexOf(',');
+        if (comma < 0)
+        {
+            if (!TryParseArgument(arguments, out var value))
+                return false;
 
-        if (!int.TryParse(argument, out var value) || value < 0)
+            switch (name)
+            {
+                // A length cannot be negative; a bound on a value very much can.
+                case "minlength":
+                case "maxlength":
+                case "length":
+                    return value >= 0;
+
+                case "min":
+                case "max":
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        if (name != "range")
             return false;
 
-        return name is "minlength" or "maxlength" or "length";
+        return TryParseArgument(arguments.Substring(0, comma), out var low)
+            && TryParseArgument(arguments.Substring(comma + 1), out var high)
+            && low <= high;
     }
+
+    static bool TryParseArgument(string text, out long value) => long.TryParse(
+        text.Trim(),
+        NumberStyles.Integer,
+        CultureInfo.InvariantCulture,
+        out value
+    );
 }

src/Shiny.Net.HttpServer/Routing/RouteConstraint.cs

@@ -3,38 +3,74 @@
 namespace Shiny.Net.HttpServer.Routing;
 
 /// <summary>
-/// An inline route constraint such as <c>{id:int}</c>.
+/// An inline route constraint such as <c>{id:int}</c> or <c>{page:range(1,100)}</c>.
 /// <para>
 /// Deliberately a closed set evaluated by a switch rather than a pluggable
 /// <c>IRouteConstraint</c> resolved from a container. A closed set is trim-safe, allocation-free,
 /// and covers what route matching is actually for — anything richer belongs in the handler, where
 /// it can return a meaningful error instead of a bare 404.
 /// </para>
+/// <para>
+/// There is no <c>regex</c> constraint, and that is the same decision rather than an omission: it
+/// would put an attacker-influenced pattern on the routing hot path for every request, which is a
+/// denial-of-service surface, and a route that needs a regular expression is a route whose handler
+/// should be explaining what was wrong with the input.
+/// </para>
+/// <para>
+/// A constraint decides whether a route <em>matches</em>. It does not convert anything — binding a
+/// segment to a parameter's type is the binder's job, and it already handles every
+/// <c>IParsable&lt;T&gt;</c>. <c>{id:int}</c> on an endpoint taking a <c>long</c> is legal and does
+/// what it says: match integers, hand the handler a long.
+/// </para>
 /// </summary>
 public sealed class RouteConstraint
 {
     enum Kind
     {
         None,
+
+        // Integers, by width. A narrower constraint is a real filter: {id:byte} does not match 300.
+        Byte,
+        Short,
         Int,
         Long,
-        Guid,
-        Bool,
+
+        // Reals.
+        Float,
         Double,
         Decimal,
+
+        Bool,
+        Guid,
         Alpha,
+
+        // Temporal. Parsed with the invariant culture, so a route means the same thing wherever the
+        // server happens to be running.
+        DateTime,
+        DateOnly,
+        TimeOnly,
+        TimeSpan,
+
+        // Length of the text.
         MinLength,
         MaxLength,
-        Length
+        Length,
+
+        // Value of the number.
+        Min,
+        Max,
+        Range
     }
 
     readonly Kind kind;
-    readonly int argument;
+    readonly long argument;
+    readonly long argument2;
 
-    RouteConstraint(Kind kind, int argument = 0)
+    RouteConstraint(Kind kind, long argument = 0, long argument2 = 0)
     {
         this.kind = kind;
         this.argument = argument;
+        this.argument2 = argument2;
     }
 
     /// <summary>No constraint — any single segment matches.</summary>
@@ -50,13 +86,20 @@ enum Kind
         {
             return text.ToLowerInvariant() switch
             {
+                "byte" => new RouteConstraint(Kind.Byte),
+                "short" => new RouteConstraint(Kind.Short),
                 "int" => new RouteConstraint(Kind.Int),
                 "long" => new RouteConstraint(Kind.Long),
-                "guid" => new RouteConstraint(Kind.Guid),
-                "bool" => new RouteConstraint(Kind.Bool),
+                "float" => new RouteConstraint(Kind.Float),
                 "double" => new RouteConstraint(Kind.Double),
                 "decimal" => new RouteConstraint(Kind.Decimal),
+                "bool" => new RouteConstraint(Kind.Bool),
+                "guid" => new RouteConstraint(Kind.Guid),
                 "alpha" => new RouteConstraint(Kind.Alpha),
+                "datetime" => new RouteConstraint(Kind.DateTime),
+                "dateonly" => new RouteConstraint(Kind.DateOnly),
+                "timeonly" => new RouteConstraint(Kind.TimeOnly),
+                "timespan" => new RouteConstraint(Kind.TimeSpan),
                 _ => null
             };
         }
@@ -65,17 +108,35 @@ enum Kind
             return null;
 
         var name = text[..paren].ToLowerInvariant();
-        var arg = text[(paren + 1)..^1];
-        if (!int.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out var value) || value < 0)
-            return null;
+        var arguments = text[(paren + 1)..^1];
 
-        return name switch
+        var comma = arguments.IndexOf(',');
+        if (comma < 0)
         {
-            "minlength" => new RouteConstraint(Kind.MinLength, value),
-            "maxlength" => new RouteConstraint(Kind.MaxLength, value),
-            "length" => new RouteConstraint(Kind.Length, value),
-            _ => null
-        };
+            if (!TryParseArgument(arguments, out var value))
+                return null;
+
+            return name switch
+            {
+                // A length cannot be negative; a bound on a value very much can.
+                "minlength" => value < 0 ? null : new RouteConstraint(Kind.MinLength, value),
+                "maxlength" => value < 0 ? null : new RouteConstraint(Kind.MaxLength, value),
+                "length" => value < 0 ? null : new RouteConstraint(Kind.Length, value),
+                "min" => new RouteConstraint(Kind.Min, value),
+                "max" => new RouteConstraint(Kind.Max, value),
+                _ => null
+            };
+        }
+
+        if (name != "range")
+            return null;
+
+        if (!TryParseArgument(arguments[..comma], out var low) ||
+            !TryParseArgument(arguments[(comma + 1)..], out var high))
+            return null;
+
+        // An inverted range matches nothing, which is never what someone meant to type.
+        return low > high ? null : new RouteConstraint(Kind.Range, low, high);
     }
 
     public bool Matches(ReadOnlySpan<char> value)
@@ -85,24 +146,50 @@ public bool Matches(ReadOnlySpan<char> value)
             case Kind.None:
                 return true;
 
+            case Kind.Byte:
+                return byte.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out _);
+
+            case Kind.Short:
+                return short.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out _);
+
             case Kind.Int:
                 return int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out _);
 
             case Kind.Long:
                 return long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out _);
 
-            case Kind.Guid:
-                return Guid.TryParse(value, out _);
-
-            case Kind.Bool:
-                return bool.TryParse(value, out _);
+            case Kind.Float:
+                return float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out _);
 
             case Kind.Double:
                 return double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out _);
 
             case Kind.Decimal:
                 return decimal.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out _);
 
+            case Kind.Bool:
+                return bool.TryParse(value, out _);
+
+            case Kind.Guid:
+                return Guid.TryParse(value, out _);
+
+            case Kind.DateTime:
+                return System.DateTime.TryParse(
+                    value,
+                    CultureInfo.InvariantCulture,
+                    DateTimeStyles.None,
+                    out _
+                );
+
+            case Kind.DateOnly:
+                return System.DateOnly.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out _);
+
+            case Kind.TimeOnly:
+                return System.TimeOnly.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out _);
+
+            case Kind.TimeSpan:
+                return System.TimeSpan.TryParse(value, CultureInfo.InvariantCulture, out _);
+
             case Kind.Alpha:
                 if (value.IsEmpty)
                     return false;
@@ -122,6 +209,17 @@ public bool Matches(ReadOnlySpan<char> value)
             case Kind.Length:
                 return value.Length == this.argument;
 
+            case Kind.Min:
+                return TryParseValue(value, out var atLeast) && atLeast >= this.argument;
+
+            case Kind.Max:
+                return TryParseValue(value, out var atMost) && atMost <= this.argument;
+
+            case Kind.Range:
+                return TryParseValue(value, out var within)
+                    && within >= this.argument
+                    && within <= this.argument2;
+
             default:
                 return false;
         }
@@ -133,6 +231,15 @@ public bool Matches(ReadOnlySpan<char> value)
         Kind.MinLength => $"minlength({this.argument})",
         Kind.MaxLength => $"maxlength({this.argument})",
         Kind.Length => $"length({this.argument})",
+        Kind.Min => $"min({this.argument})",
+        Kind.Max => $"max({this.argument})",
+        Kind.Range => $"range({this.argument},{this.argument2})",
         _ => this.kind.ToString().ToLowerInvariant()
     };
+
+    static bool TryParseArgument(ReadOnlySpan<char> text, out long value)
+        => long.TryParse(text.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out value);
+
+    static bool TryParseValue(ReadOnlySpan<char> text, out long value)
+        => long.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out value);
 }