@oneuptime/common 14.0.0 → 14.0.1

package/Tests/Utils/LabelRuleImportExport.test.ts

@@ -8,6 +8,7 @@ import Label from "../../Models/DatabaseModels/Label";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import MonitorLabelRule from "../../Models/DatabaseModels/MonitorLabelRule";
 import NetworkDeviceLabelRule from "../../Models/DatabaseModels/NetworkDeviceLabelRule";
+import ServiceLevelObjectiveLabelRule from "../../Models/DatabaseModels/ServiceLevelObjectiveLabelRule";
 import TableColumnType from "../../Types/Database/TableColumnType";
 import FilterCondition from "../../Types/Filter/FilterCondition";
 import { JSONObject } from "../../Types/JSON";
@@ -175,6 +176,11 @@ const criteriaByType: Record<string, [string, string, string]> = {
     "serviceDescriptionPattern",
     "serviceLabels",
   ],
+  ServiceLevelObjectiveLabelRule: [
+    "serviceLevelObjectiveNamePattern",
+    "serviceLevelObjectiveDescriptionPattern",
+    "serviceLevelObjectiveLabels",
+  ],
   StatusPageLabelRule: [
     "statusPageNamePattern",
     "statusPageDescriptionPattern",
@@ -590,6 +596,102 @@ describe("portable label rule files", () => {
     },
   );
 
+  /*
+   * SLO label rules match patterns the way network device rules do - a regex,
+   * with a '*' wildcard fallback, on the trimmed pattern - so the two trade
+   * any pattern, and both refuse one whose meaning a regex-only rule type
+   * would change.
+   */
+  test("preserves wildcard SLO patterns when importing SLO rules", () => {
+    expect(
+      parse(
+        [{ ...base, serviceLevelObjectiveNamePattern: "*checkout*" }],
+        ServiceLevelObjectiveLabelRule,
+      ).items[0]!.json["serviceLevelObjectiveNamePattern"],
+    ).toBe("*checkout*");
+  });
+
+  test.each([
+    [NetworkDeviceLabelRule, ServiceLevelObjectiveLabelRule],
+    [ServiceLevelObjectiveLabelRule, NetworkDeviceLabelRule],
+  ])(
+    "moves a wildcard between %p and %p without changing its meaning",
+    (source: DatabaseBaseModelType, destination: DatabaseBaseModelType) => {
+      const sourceField: string =
+        source === NetworkDeviceLabelRule
+          ? "networkDeviceNamePattern"
+          : "serviceLevelObjectiveNamePattern";
+      const destinationField: string =
+        destination === NetworkDeviceLabelRule
+          ? "networkDeviceNamePattern"
+          : "serviceLevelObjectiveNamePattern";
+
+      expect(
+        parse([{ ...base, [sourceField]: "*edge*" }], source, destination)
+          .items[0]!.json[destinationField],
+      ).toBe("*edge*");
+    },
+  );
+
+  test.each(["*checkout*", "checkout.*", " checkout ", "   "])(
+    "rejects moving the SLO pattern %p to a regex-only rule type",
+    (pattern: string) => {
+      expect(() => {
+        parse(
+          [{ ...base, serviceLevelObjectiveNamePattern: pattern }],
+          ServiceLevelObjectiveLabelRule,
+          MonitorLabelRule,
+        );
+      }).toThrow("without changing its meaning");
+    },
+  );
+
+  test.each(["checkout.*", " checkout "])(
+    "rejects importing the regex %p into the broader SLO matcher",
+    (pattern: string) => {
+      expect(() => {
+        parse(
+          [{ ...base, monitorNamePattern: pattern }],
+          MonitorLabelRule,
+          ServiceLevelObjectiveLabelRule,
+        );
+      }).toThrow("without changing its meaning");
+    },
+  );
+
+  test("moves a plain SLO pattern to a regex-only rule type", () => {
+    expect(
+      parse(
+        [{ ...base, serviceLevelObjectiveNamePattern: "^checkout-" }],
+        ServiceLevelObjectiveLabelRule,
+        MonitorLabelRule,
+      ).items[0]!.json["monitorNamePattern"],
+    ).toBe("^checkout-");
+  });
+
+  test("accepts a wildcard, but not an invalid pattern, for SLO rules", () => {
+    expect(() => {
+      parse(
+        [{ ...base, serviceLevelObjectiveDescriptionPattern: "*tier 1*" }],
+        ServiceLevelObjectiveLabelRule,
+      );
+    }).not.toThrow();
+
+    expect(() => {
+      parse(
+        [{ ...base, serviceLevelObjectiveDescriptionPattern: "tier-(1" }],
+        ServiceLevelObjectiveLabelRule,
+      );
+    }).toThrow("is not a valid regular expression or wildcard pattern");
+  });
+
+  // A regex-only rule type still refuses the wildcard syntax outright.
+  test("still rejects a bare wildcard for a regex-only rule type", () => {
+    expect(() => {
+      parse([{ ...base, monitorNamePattern: "*checkout*" }], MonitorLabelRule);
+    }).toThrow("is not a valid regular expression.");
+  });
+
   test("preserves wildcard network patterns when importing network rules", () => {
     expect(
       parse(

package/Tests/Utils/Slo/SloDuration.test.ts

@@ -4,8 +4,6 @@ import {
   formatErrorBudgetRemainingOfTotal,
 } from "../../../Utils/Slo/SloDuration";
 
-const MINUS_SIGN: string = "−";
-
 describe("SloDuration", () => {
   describe("formatDurationCompact", () => {
     it("renders seconds under a minute", () => {
@@ -74,12 +72,38 @@ describe("SloDuration", () => {
 
     it("renders an exhausted-but-not-overspent budget as 0s left", () => {
       expect(formatErrorBudgetRemaining(0)).toBe("0s left");
+      expect(formatErrorBudgetRemaining(-0)).toBe("0s left");
+    });
+
+    it("states the overage as a positive duration with over budget", () => {
+      expect(formatErrorBudgetRemaining(-750)).toBe("12m 30s over budget");
     });
 
-    it("renders an overspent budget with a minus sign and over budget", () => {
-      expect(formatErrorBudgetRemaining(-750)).toBe(
-        `${MINUS_SIGN}12m 30s over budget`,
-      );
+    it("keeps a multi-day overage readable", () => {
+      expect(formatErrorBudgetRemaining(-346980)).toBe("4d 23m over budget");
+    });
+
+    it.each([0.001, 0.4, 0.999])(
+      "distinguishes a positive %ps remainder from an empty budget",
+      (seconds: number) => {
+        expect(formatErrorBudgetRemaining(seconds)).toBe("under 1s left");
+      },
+    );
+
+    it.each([-0.001, -0.4, -0.999])(
+      "preserves a %ps overage instead of rounding it to zero",
+      (seconds: number) => {
+        expect(formatErrorBudgetRemaining(seconds)).toBe(
+          "under 1s over budget",
+        );
+      },
+    );
+
+    it("uses seconds at the one-second boundary without rounding up", () => {
+      expect(formatErrorBudgetRemaining(1)).toBe("1s left");
+      expect(formatErrorBudgetRemaining(-1)).toBe("1s over budget");
+      expect(formatErrorBudgetRemaining(59.9)).toBe("59s left");
+      expect(formatErrorBudgetRemaining(-59.9)).toBe("59s over budget");
     });
 
     it("returns null when the SLO has not been evaluated", () => {
@@ -90,6 +114,7 @@ describe("SloDuration", () => {
     it("returns null for non-finite values", () => {
       expect(formatErrorBudgetRemaining(Number.NaN)).toBeNull();
       expect(formatErrorBudgetRemaining(Number.POSITIVE_INFINITY)).toBeNull();
+      expect(formatErrorBudgetRemaining(Number.NEGATIVE_INFINITY)).toBeNull();
     });
 
     it("rejects a numeric string rather than coercing it", () => {
@@ -97,6 +122,11 @@ describe("SloDuration", () => {
         formatErrorBudgetRemaining("2592" as unknown as number),
       ).toBeNull();
     });
+
+    it("rejects booleans rather than treating them as zero or one", () => {
+      expect(formatErrorBudgetRemaining(false as unknown as number)).toBeNull();
+      expect(formatErrorBudgetRemaining(true as unknown as number)).toBeNull();
+    });
   });
 
   describe("formatErrorBudgetRemainingOfTotal", () => {
@@ -109,40 +139,101 @@ describe("SloDuration", () => {
       ).toBe("12m 30s left of 43m 12s");
     });
 
-    it("keeps the total visible when the budget is overspent", () => {
+    it("identifies the allowance separately from how far over budget it is", () => {
       expect(
         formatErrorBudgetRemainingOfTotal({
           remainingSeconds: -750,
           totalSeconds: 2592,
         }),
-      ).toBe(`${MINUS_SIGN}12m 30s over budget of 43m 12s`);
+      ).toBe("12m 30s over budget · 43m 12s allowed");
     });
 
-    it("omits the total when it is unknown", () => {
+    it("explains the reported multi-day overage against its small allowance", () => {
       expect(
         formatErrorBudgetRemainingOfTotal({
-          remainingSeconds: 750,
-          totalSeconds: null,
+          remainingSeconds: -346980,
+          totalSeconds: 347,
         }),
-      ).toBe("12m 30s left");
+      ).toBe("4d 23m over budget · 5m 47s allowed");
     });
 
-    it("omits a zero total — a brand-new SLO has no elapsed window yet", () => {
+    it("retains the allowance at exactly zero without claiming an overage", () => {
       expect(
         formatErrorBudgetRemainingOfTotal({
           remainingSeconds: 0,
-          totalSeconds: 0,
-        }),
-      ).toBe("0s left");
-    });
-
-    it("returns null when the SLO has not been evaluated", () => {
-      expect(
-        formatErrorBudgetRemainingOfTotal({
-          remainingSeconds: null,
           totalSeconds: 2592,
         }),
-      ).toBeNull();
-    });
+      ).toBe("0s left of 43m 12s");
+    });
+
+    it.each([
+      [0.25, "under 1s left of under 1s"],
+      [-0.25, "under 1s over budget · under 1s allowed"],
+      [0, "0s left of under 1s"],
+    ])(
+      "does not round a subsecond allowance to zero for a %ps remainder",
+      (remainingSeconds: number, expected: string) => {
+        expect(
+          formatErrorBudgetRemainingOfTotal({
+            remainingSeconds,
+            totalSeconds: 0.5,
+          }),
+        ).toBe(expected);
+      },
+    );
+
+    it.each([
+      ["missing", undefined],
+      ["null", null],
+      ["zero", 0],
+      ["negative", -2592],
+      ["NaN", Number.NaN],
+      ["positive infinity", Number.POSITIVE_INFINITY],
+      ["negative infinity", Number.NEGATIVE_INFINITY],
+      ["numeric string", "2592" as unknown as number],
+      ["boolean", true as unknown as number],
+    ])(
+      "omits an unusable %s total while preserving the remaining or over-budget state",
+      (_label: string, totalSeconds: number | null | undefined) => {
+        expect(
+          formatErrorBudgetRemainingOfTotal({
+            remainingSeconds: 750,
+            totalSeconds,
+          }),
+        ).toBe("12m 30s left");
+        expect(
+          formatErrorBudgetRemainingOfTotal({
+            remainingSeconds: -750,
+            totalSeconds,
+          }),
+        ).toBe("12m 30s over budget");
+        expect(
+          formatErrorBudgetRemainingOfTotal({
+            remainingSeconds: 0,
+            totalSeconds,
+          }),
+        ).toBe("0s left");
+      },
+    );
+
+    it.each([
+      ["missing", undefined],
+      ["null", null],
+      ["NaN", Number.NaN],
+      ["positive infinity", Number.POSITIVE_INFINITY],
+      ["negative infinity", Number.NEGATIVE_INFINITY],
+      ["numeric string", "750" as unknown as number],
+      ["boolean", false as unknown as number],
+    ])(
+      "does not let a known total imply an evaluated budget when the remainder is %s",
+      (_label: string, remainingSeconds: number | null | undefined) => {
+        expect(
+          formatErrorBudgetRemainingOfTotal({
+            remainingSeconds,
+            totalSeconds: 2592,
+          }),
+        ).toBeNull();
+      },
+    );
   });
 });

package/Tests/Utils/Slo/SloHealth.test.ts

@@ -58,7 +58,7 @@ const EVERY_NOTICE_INPUT: Array<{ name: string; data: SloNoticeData }> = [
     },
   },
   {
-    name: "generic misconfigured",
+    name: "waiting for evaluation with monitors attached",
     data: { ...MEASURING, sloStatus: SloStatus.Misconfigured },
   },
   { name: "paused", data: { ...MEASURING, sloStatus: SloStatus.Paused } },
@@ -431,17 +431,100 @@ describe("SloHealth", () => {
       expect(notice?.body).toContain(SliType.MonitorUptime);
     });
 
-    it("falls back to a generic reason for Misconfigured", () => {
-      const notice: SloNotice | null = getSloNotice({
-        isEnabled: true,
-        sloStatus: SloStatus.Misconfigured,
-        sliType: SliType.MonitorUptime,
-        monitorCount: 1,
-        targetPercentage: 99.9,
-        lastEvaluatedAt: new Date(),
+    describe("waiting for evaluation after monitors are attached", () => {
+      it.each([
+        { monitorCount: 1, lastEvaluatedAt: null },
+        { monitorCount: 16, lastEvaluatedAt: null },
+        { monitorCount: 1, lastEvaluatedAt: undefined },
+        { monitorCount: 16, lastEvaluatedAt: undefined },
+        {
+          monitorCount: 1,
+          lastEvaluatedAt: new Date("2026-09-21T12:00:00.000Z"),
+        },
+        {
+          monitorCount: 16,
+          lastEvaluatedAt: "2026-09-21T12:00:00.000Z",
+        },
+      ])(
+        "is informational with $monitorCount monitors and lastEvaluatedAt=$lastEvaluatedAt",
+        ({
+          monitorCount,
+          lastEvaluatedAt,
+        }: {
+          monitorCount: number;
+          lastEvaluatedAt: Date | string | null | undefined;
+        }) => {
+          const notice: SloNotice | null = getSloNotice({
+            ...MEASURING,
+            sloStatus: SloStatus.Misconfigured,
+            monitorCount,
+            lastEvaluatedAt,
+          });
+
+          expect(notice?.type).toBe(SloNoticeType.Info);
+          expect(notice?.title).toBe("Waiting for SLO evaluation");
+          expect(notice?.body).toContain("Monitors are attached");
+          expect(notice?.body).toContain("every few minutes");
+          expect(notice?.body).toContain(
+            "once monitor status data is available and the next evaluation completes",
+          );
+          expect(notice?.action).toEqual({
+            label: "View monitors",
+            target: SloNoticeActionTarget.Monitors,
+          });
+        },
+      );
+
+      it.each([undefined, null])(
+        "retains the default monitor-uptime behavior when sliType is %s",
+        (sliType: undefined | null) => {
+          expect(
+            getSloNotice({
+              ...MEASURING,
+              sloStatus: SloStatus.Misconfigured,
+              sliType,
+            })?.type,
+          ).toBe(SloNoticeType.Info);
+        },
+      );
+
+      it.each([0, -1, 100, 101, Number.NaN, Infinity, null, undefined])(
+        "still warns about target %s even with monitors attached",
+        (targetPercentage: number | null | undefined) => {
+          const notice: SloNotice | null = getSloNotice({
+            ...MEASURING,
+            sloStatus: SloStatus.Misconfigured,
+            monitorCount: 16,
+            targetPercentage,
+          });
+
+          expect(notice?.type).toBe(SloNoticeType.Warning);
+          expect(notice?.title).toBe("The target is out of range");
+          expect(notice?.action?.target).toBe(SloNoticeActionTarget.Settings);
+        },
+      );
+
+      it("still warns about an unsupported SLI with monitors attached", () => {
+        const notice: SloNotice | null = getSloNotice({
+          ...MEASURING,
+          sloStatus: SloStatus.Misconfigured,
+          sliType: SliType.Metric,
+          monitorCount: 16,
+        });
+
+        expect(notice?.type).toBe(SloNoticeType.Warning);
+        expect(notice?.title).toBe("This SLO cannot be evaluated");
+        expect(notice?.action).toBeUndefined();
       });
 
-      expect(notice?.title).toBe("This SLO cannot be evaluated");
+      it.each([SloStatus.Healthy, SloStatus.AtRisk, SloStatus.BudgetExhausted])(
+        "stops displaying the notice after evaluation reports %s",
+        (sloStatus: SloStatus) => {
+          expect(
+            getSloNotice({ ...MEASURING, sloStatus, monitorCount: 16 }),
+          ).toBeNull();
+        },
+      );
     });
 
     it("explains Paused", () => {

package/Tests/Utils/Slo/SloMonitorRuleCriteria.test.ts

@@ -1,5 +1,6 @@
 import FilterCondition from "../../../Types/Filter/FilterCondition";
 import ObjectID from "../../../Types/ObjectID";
+import MonitorType from "../../../Types/Monitor/MonitorType";
 import RuleCriteria, {
   RULE_CRITERIA_LEGACY_NEVER_MATCH_PATTERN,
   RULE_CRITERIA_SCHEMA_VERSION,
@@ -385,3 +386,111 @@ describe("getSloMonitorRuleCriteriaKey", () => {
     );
   });
 });
+
+describe("SLO monitor type criteria descriptions", () => {
+  test.each(["", "Invalid monitor type"])(
+    "describes an invalid legacy monitor type as matching no monitors: %p",
+    (monitorType: string) => {
+      expect(
+        describeSloMonitorRuleCriteria({
+          rule: {
+            monitorType: monitorType as MonitorType,
+            monitorNamePattern: ".*",
+          },
+        }),
+      ).toBe(SLO_MONITOR_RULE_INVALID_CRITERIA_DESCRIPTION);
+    },
+  );
+
+  test.each([
+    { operator: RuleCriteriaOperator.Equals, value: "Invalid monitor type" },
+    { operator: RuleCriteriaOperator.NotEquals, value: "" },
+    { operator: RuleCriteriaOperator.Contains, value: MonitorType.API },
+    { operator: RuleCriteriaOperator.HasAnyOf, value: [MonitorType.API] },
+  ])(
+    "describes invalid type criteria as matching no monitors: %p",
+    (filter: Pick<RuleCriteriaFilter, "operator" | "value">) => {
+      expect(
+        describeSloMonitorRuleCriteria({
+          rule: {
+            criteria: criteria(FilterCondition.Any, [
+              { field: "monitorType", ...filter },
+            ]),
+          },
+        }),
+      ).toBe(SLO_MONITOR_RULE_INVALID_CRITERIA_DESCRIPTION);
+    },
+  );
+
+  test.each([RuleCriteriaOperator.Equals, RuleCriteriaOperator.NotEquals])(
+    "describes configured monitor type %s without looking up labels",
+    (operator: RuleCriteriaOperator) => {
+      const rule: SloMonitorRuleCriteriaCarrier = {
+        criteria: criteria(FilterCondition.All, [
+          { field: "monitorType", operator, value: MonitorType.API },
+          {
+            field: "monitorNamePattern",
+            operator: RuleCriteriaOperator.DoesNotMatchPattern,
+            value: "^staging-",
+          },
+        ]),
+        monitorType: MonitorType.Website,
+      };
+      expect(describeSloMonitorRuleCriteria({ rule })).toBe(
+        `Type ${SLO_MONITOR_RULE_OPERATOR_PHRASES[operator]} "API" AND Name does not match pattern "^staging-"`,
+      );
+      expect(getSloMonitorRuleLabelIds(rule)).toEqual([]);
+    },
+  );
+
+  test("describes a legacy monitor type combined with other attributes", () => {
+    expect(
+      describeSloMonitorRuleCriteria({
+        rule: {
+          monitorType: MonitorType.Website,
+          monitorLabels: [{ _id: PRODUCTION_LABEL_ID, name: "Production" }],
+          monitorNamePattern: "^checkout-",
+        },
+      }),
+    ).toBe(
+      'Labels has any of "Production" AND Type is "Website" AND Name matches pattern "^checkout-"',
+    );
+  });
+
+  test("describes a type-only legacy rule as a configured condition", () => {
+    expect(
+      describeSloMonitorRuleCriteria({
+        rule: { monitorType: MonitorType.API },
+      }),
+    ).toBe('Type is "API"');
+  });
+
+  test("detects changes to legacy monitor types for audit and feed updates", () => {
+    const apiKey: string = getSloMonitorRuleCriteriaKey({
+      monitorType: MonitorType.API,
+    });
+    expect(apiKey).not.toBe(
+      getSloMonitorRuleCriteriaKey({ monitorType: MonitorType.Website }),
+    );
+    expect(apiKey).not.toBe(getSloMonitorRuleCriteriaKey({}));
+    expect(getSloMonitorRuleCriteriaKey({ monitorType: null })).toBe(
+      getSloMonitorRuleCriteriaKey({}),
+    );
+  });
+
+  test("ignores legacy monitor type shadows for configured rule identity", () => {
+    const configured: RuleCriteria = criteria(FilterCondition.All, [
+      {
+        field: "monitorType",
+        operator: RuleCriteriaOperator.Equals,
+        value: MonitorType.API,
+      },
+    ]);
+    expect(
+      getSloMonitorRuleCriteriaKey({
+        criteria: configured,
+        monitorType: MonitorType.Website,
+      }),
+    ).toBe(getSloMonitorRuleCriteriaKey({ criteria: configured }));
+  });
+});

package/Tests/Utils/Slo/SloOverviewText.test.ts

@@ -5,6 +5,7 @@ import SloWindowType from "../../../Types/ServiceLevelObjective/SloWindowType";
 import {
   getSliTypeText,
   getSloAtRiskText,
+  getSloBudgetRemainingText,
   getSloDowntimeStatusesText,
   getSloHeadline,
   getSloMonitorCountText,
@@ -79,6 +80,69 @@ describe("getSloTargetText", () => {
   });
 });
 
+describe("getSloBudgetRemainingText", () => {
+  test.each([-99882.8, -120, -0.001, -Number.MIN_VALUE, -Number.MAX_VALUE])(
+    "explains a %p%% remaining budget as exceeded, even if it rounds to zero",
+    (percentage: number) => {
+      expect(getSloBudgetRemainingText(percentage)).toBe("Budget exceeded");
+    },
+  );
+
+  test.each([0, -0])(
+    "distinguishes an exactly exhausted %p%% budget from an overage",
+    (percentage: number) => {
+      expect(getSloBudgetRemainingText(percentage)).toBe("No budget left");
+    },
+  );
+
+  test.each([Number.MIN_VALUE, 0.001, 0.049, 0.05, 0.0999])(
+    "keeps a small positive %p%% budget distinct from no budget left",
+    (percentage: number) => {
+      expect(getSloBudgetRemainingText(percentage)).toBe("<0.1%");
+    },
+  );
+
+  test.each([
+    [0.1, "0.1%"],
+    [0.14, "0.1%"],
+    [0.15, "0.2%"],
+    [15, "15%"],
+    [20, "20%"],
+    [62.5, "62.5%"],
+    [62.56, "62.6%"],
+    [100, "100%"],
+  ])(
+    "shows a positive %p%% remainder as %s without unnecessary decimal places",
+    (percentage: number, expected: string) => {
+      expect(getSloBudgetRemainingText(percentage)).toBe(expected);
+    },
+  );
+
+  test.each([100.01, 150, Number.MAX_VALUE])(
+    "never claims more than a full budget when the input is %p%%",
+    (percentage: number) => {
+      expect(getSloBudgetRemainingText(percentage)).toBe("100%");
+    },
+  );
+
+  test.each([
+    ["missing", undefined],
+    ["null", null],
+    ["NaN", Number.NaN],
+    ["positive infinity", Number.POSITIVE_INFINITY],
+    ["negative infinity", Number.NEGATIVE_INFINITY],
+    ["numeric string", "62.5" as unknown as number],
+    ["negative numeric string", "-99882.8" as unknown as number],
+    ["true", true as unknown as number],
+    ["false", false as unknown as number],
+  ])(
+    "makes no budget claim for %s data",
+    (_label: string, percentage: number | null | undefined) => {
+      expect(getSloBudgetRemainingText(percentage)).toBeNull();
+    },
+  );
+});
+
 describe("getSloMonitorCountText", () => {
   test.each([
     [0, "No monitors"],

package/Types/API/Route.ts

@@ -7,13 +7,30 @@ import { FindOperator } from "typeorm";
 export default class Route extends DatabaseProperty {
   private static readonly SCHEME_PREFIX: RegExp = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
 
+  /*
+   * True when the value, read on its own as a relative reference, would start
+   * with a scheme (RFC 3986 4.2): "javascript:alert(1)", but equally
+   * "bot123:ABC/sendMessage". Route refuses such values so a scheme can never
+   * reach a navigation sink; URL uses this to know when a path it parsed has
+   * to keep its leading "/".
+   */
+  public static hasSchemePrefix(route: string): boolean {
+    return Route.SCHEME_PREFIX.test(route);
+  }
+
   private static validateRoute(route: string): void {
-    if (Route.SCHEME_PREFIX.test(route)) {
+    if (Route.hasSchemePrefix(route)) {
       throw new BadDataException(`Invalid route: ${route}`);
     }
 
+    /*
+     * RFC 3986 path characters: unreserved (which includes "~"), sub-delims,
+     * ":" and "@", plus "/", "?", "#", "[", "]" and "%" for the rest of a
+     * path-and-query. "~" was missing, so "https://example.com/~user" could
+     * not be parsed at all.
+     */
     const matchRouteCharacters: RegExp =
-      /^[a-zA-Z_\d\-!#$%&'()*+,./:;=?@[\]]*$/;
+      /^[a-zA-Z_\d\-!#$%&'()*+,./:;=?@[\]~]*$/;
 
     if (route && !matchRouteCharacters.test(route)) {
       throw new BadDataException(`Invalid route: ${route}`);