Time granularity made more robust

Author: matt-aitken

apps/webapp/app/utils/timeGranularity.ts

@@ -1,30 +1,54 @@
+import { z } from "zod";
 import parseDuration from "parse-duration";
 
-export type TimeGranularityBracket = {
-  max: string;
-  granularity: string;
-};
+const DurationString = z
+  .string()
+  .refine(
+    (val) => parseDuration(val) !== null,
+    (val) => ({ message: `Invalid duration string: "${val}"` })
+  );
+
+const BracketSchema = z.object({
+  max: z.union([z.literal("Infinity"), DurationString]),
+  granularity: DurationString,
+});
+
+const BracketsSchema = z
+  .array(BracketSchema)
+  .min(1, "TimeGranularity requires at least one bracket");
+
+export type TimeGranularityBracket = z.input<typeof BracketSchema>;
 
 type ParsedBracket = {
   maxMs: number;
   granularityMs: number;
 };
 
+function requireParsedDuration(input: string): number {
+  const ms = parseDuration(input);
+  if (ms === null) {
+    throw new Error(`Failed to parse duration string: "${input}"`);
+  }
+  return ms;
+}
+
 export class TimeGranularity {
   private readonly parsed: ParsedBracket[];
 
   constructor(brackets: TimeGranularityBracket[]) {
-    if (brackets.length === 0) {
-      throw new Error("TimeGranularity requires at least one bracket");
-    }
+    const validated = BracketsSchema.parse(brackets);
 
-    this.parsed = brackets.map((b) => ({
-      maxMs: parseDuration(b.max) ?? Infinity,
-      granularityMs: parseDuration(b.granularity)!,
+    this.parsed = validated.map((b) => ({
+      maxMs: b.max === "Infinity" ? Infinity : requireParsedDuration(b.max),
+      granularityMs: requireParsedDuration(b.granularity),
     }));
   }
 
   getTimeGranularityMs(from: Date, to: Date): number {
+    if (from.getTime() > to.getTime()) {
+      return this.parsed[this.parsed.length - 1].granularityMs;
+    }
+
     const rangeMs = to.getTime() - from.getTime();
     for (const bracket of this.parsed) {
       if (rangeMs <= bracket.maxMs) {

apps/webapp/test/timeGranularity.test.ts

@@ -48,6 +48,12 @@ describe("TimeGranularity", () => {
     expect(granularity.getTimeGranularityMs(date, date)).toBe(10 * SECOND);
   });
 
+  it("returns the broadest granularity for an inverted range (from > to)", () => {
+    const from = new Date("2025-01-01T01:00:00Z");
+    const to = new Date("2025-01-01T00:00:00Z");
+    expect(granularity.getTimeGranularityMs(from, to)).toBe(10 * MINUTE);
+  });
+
   it("throws when constructed with an empty array", () => {
     expect(() => new TimeGranularity([])).toThrow("at least one bracket");
   });