@schafevormfenster/rest-commons 0.1.1

package/src/time/flexible-time-parser.ts

@@ -0,0 +1,122 @@
+import dayjs from "dayjs";
+import isoWeek from "dayjs/plugin/isoWeek.js";
+import utc from "dayjs/plugin/utc.js";
+
+import { ISO8601Schema } from "./iso8601.types";
+import {
+  RelativeTimeSchema,
+  FlexibleTimeSchema,
+  FlexibleTime,
+} from "./time-schemas";
+
+dayjs.extend(isoWeek);
+dayjs.extend(utc);
+
+/**
+ * Parse a flexible time input (ISO 8601 or relative format) to ISO 8601 string
+ * Uses Zod schemas for validation instead of manual parsing
+ * All calculations are performed in UTC timezone
+ */
+// eslint-disable-next-line sonarjs/cognitive-complexity -- Complex time parsing logic requires multiple conditional branches
+export function parseFlexibleTime(
+  input: FlexibleTime,
+  baseTime: Date = new Date()
+): string {
+  // First, validate that input is a valid flexible time format
+  const flexibleResult = FlexibleTimeSchema.safeParse(input);
+  if (!flexibleResult.success) {
+    throw new Error(
+      `Invalid time format: ${input}. Expected ISO 8601 date, 'now', 'today', 'tomorrow', 'yesterday', relative format (1s, 2m, 3h, 4d, 5w, -1d, -2w), or week notation (week-start, week-end, week-start+1w, week-end-2w)`
+    );
+  }
+
+  // Try to parse as ISO 8601 first using Zod validation
+  const isoResult = ISO8601Schema.safeParse(input);
+  if (isoResult.success) {
+    return isoResult.data;
+  }
+
+  // Try to parse as relative time using Zod validation
+  const relativeResult = RelativeTimeSchema.safeParse(input);
+  if (relativeResult.success) {
+    // Check if it's week notation format
+    const weekMatch = input.match(/^week-(start|end)(([+-])\d+w)?$/);
+    if (weekMatch) {
+      const [, boundary, offsetPart] = weekMatch;
+      let weekOffset = 0;
+
+      // Parse offset if present (e.g., "+1w", "-2w")
+      if (offsetPart) {
+        const offsetMatch = offsetPart.match(/^([+-])(\d+)w$/);
+        if (offsetMatch) {
+          const [, sign, amount] = offsetMatch;
+          weekOffset = Number.parseInt(amount, 10);
+          if (sign === "-") {
+            weekOffset = -weekOffset;
+          }
+          
+          // Zero offset is not allowed
+          if (weekOffset === 0) {
+            throw new Error(`Week offset cannot be zero: ${offsetPart}`);
+          }
+        }
+      }
+
+      // Calculate week boundary based on type (in UTC)
+      return boundary === "start" ? dayjs.utc(baseTime).add(weekOffset, "week").startOf("isoWeek").toISOString() : dayjs.utc(baseTime).add(weekOffset, "week").endOf("isoWeek").endOf("day").toISOString();
+    }
+
+    // Handle literal values
+    if (input === "now") {
+      return baseTime.toISOString();
+    }
+
+    if (input === "today") {
+      return dayjs.utc(baseTime).startOf("day").toISOString();
+    }
+
+    // Map shortcuts to relative time format
+    let normalizedInput = input;
+    if (input === "tomorrow") {
+      normalizedInput = "1d";
+    } else if (input === "yesterday") {
+      normalizedInput = "-1d";
+    }
+
+    // Extract the validated parts using regex (since Zod already validated the format)
+    const match = normalizedInput.match(/^(-?\d+)([smhdw])$/);
+    if (!match) {
+      throw new Error(`Invalid time format: ${input}`);
+    }
+
+    const [, amountString, unit] = match;
+    const amount = Number.parseInt(amountString, 10);
+
+    if (amount === 0) {
+      throw new Error(`Time amount cannot be zero: ${amount}`);
+    }
+
+    // Map unit to Day.js unit names
+    const unitMap: Record<string, dayjs.ManipulateType> = {
+      s: "second",
+      m: "minute",
+      h: "hour",
+      d: "day",
+      w: "week",
+    };
+
+    const dayjsUnit = unitMap[unit];
+    return dayjs.utc(baseTime).add(amount, dayjsUnit).toISOString();
+  }
+
+  throw new Error(
+    `Invalid time format: ${input}. Expected ISO 8601 date, 'now', 'today', 'tomorrow', 'yesterday', relative format (1s, 2m, 3h, 4d, 5w, -1d, -2w), or week notation (week-start, week-end, week-start+1w, week-end-2w)`
+  );
+}
+
+/**
+ * Create a flexible time parser with a specific base time (useful for testing)
+ */
+export function createFlexibleTimeParser(baseTime: Date) {
+  return (input: FlexibleTime) => parseFlexibleTime(input, baseTime);
+}

package/src/time/flexible-time.schema.test.ts

@@ -0,0 +1,243 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  FlexibleTimeFutureSchema,
+  FlexibleTimePastSchema,
+  FlexibleTimeSchema,
+} from "./flexible-time.schema";
+
+describe("FlexibleTimeSchema", () => {
+  describe("ISO8601 datetime validation", () => {
+    it("should accept valid ISO8601 datetime with Z", () => {
+      const result = FlexibleTimeSchema.safeParse("2024-01-15T12:00:00Z");
+      expect(result.success).toBe(true);
+    });
+
+    it("should accept valid ISO8601 datetime with timezone offset", () => {
+      const result = FlexibleTimeSchema.safeParse("2024-01-15T12:00:00+05:00");
+      expect(result.success).toBe(true);
+    });
+
+    it("should accept valid ISO8601 datetime with milliseconds", () => {
+      const result = FlexibleTimeSchema.safeParse("2024-01-15T12:00:00.123Z");
+      expect(result.success).toBe(true);
+    });
+
+    it("should reject date without time", () => {
+      const result = FlexibleTimeSchema.safeParse("2024-01-15");
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("relative time validation", () => {
+    it("should accept minutes format", () => {
+      const result = FlexibleTimeSchema.safeParse("30m");
+      expect(result.success).toBe(true);
+    });
+
+    it("should accept hours format", () => {
+      const result = FlexibleTimeSchema.safeParse("3h");
+      expect(result.success).toBe(true);
+    });
+
+    it("should accept days format", () => {
+      const result = FlexibleTimeSchema.safeParse("7d");
+      expect(result.success).toBe(true);
+    });
+
+    it("should accept weeks format", () => {
+      const result = FlexibleTimeSchema.safeParse("2w");
+      expect(result.success).toBe(true);
+    });
+
+    it("should accept months format", () => {
+      const result = FlexibleTimeSchema.safeParse("1M");
+      expect(result.success).toBe(true);
+    });
+
+    it("should reject invalid relative time format", () => {
+      const result = FlexibleTimeSchema.safeParse("5x");
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject relative time with spaces", () => {
+      const result = FlexibleTimeSchema.safeParse("5 d");
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject relative time without amount", () => {
+      const result = FlexibleTimeSchema.safeParse("d");
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject relative time without unit", () => {
+      const result = FlexibleTimeSchema.safeParse("5");
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should reject empty string", () => {
+      const result = FlexibleTimeSchema.safeParse("");
+      expect(result.success).toBe(false);
+    });
+
+    it("should reject invalid format", () => {
+      const result = FlexibleTimeSchema.safeParse("invalid");
+      expect(result.success).toBe(false);
+    });
+
+    it("should accept large relative time values", () => {
+      const result = FlexibleTimeSchema.safeParse("365d");
+      expect(result.success).toBe(true);
+    });
+  });
+});
+
+describe("FlexibleTimePastSchema", () => {
+  describe("transformation", () => {
+    it("should transform ISO8601 to normalized ISO8601", () => {
+      const result = FlexibleTimePastSchema.parse("2024-01-15T12:00:00Z");
+      expect(result).toBe("2024-01-15T12:00:00.000Z");
+    });
+
+    it("should transform relative time to ISO8601 (past direction)", () => {
+      const result = FlexibleTimePastSchema.parse("1d");
+      // Should be a valid ISO8601 string representing 1 day ago
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      
+      // Verify it's in the past
+      const parsedDate = new Date(result);
+      const now = new Date();
+      expect(parsedDate.getTime()).toBeLessThan(now.getTime());
+    });
+
+    it("should transform minutes to ISO8601 (past)", () => {
+      const result = FlexibleTimePastSchema.parse("30m");
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+    });
+
+    it("should transform hours to ISO8601 (past)", () => {
+      const result = FlexibleTimePastSchema.parse("3h");
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+    });
+
+    it("should transform weeks to ISO8601 (past)", () => {
+      const result = FlexibleTimePastSchema.parse("2w");
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+    });
+
+    it("should transform months to ISO8601 (past)", () => {
+      const result = FlexibleTimePastSchema.parse("1M");
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+    });
+  });
+
+  describe("validation before transformation", () => {
+    it("should reject invalid formats", () => {
+      expect(() => FlexibleTimePastSchema.parse("invalid")).toThrow();
+    });
+
+    it("should reject malformed ISO8601", () => {
+      expect(() => FlexibleTimePastSchema.parse("2024-13-01")).toThrow();
+    });
+
+    it("should reject malformed relative time", () => {
+      expect(() => FlexibleTimePastSchema.parse("5x")).toThrow();
+    });
+  });
+});
+
+describe("FlexibleTimeFutureSchema", () => {
+  describe("transformation", () => {
+    it("should transform ISO8601 to normalized ISO8601", () => {
+      const result = FlexibleTimeFutureSchema.parse("2024-01-15T12:00:00Z");
+      expect(result).toBe("2024-01-15T12:00:00.000Z");
+    });
+
+    it("should transform relative time to ISO8601 (future direction)", () => {
+      const result = FlexibleTimeFutureSchema.parse("1d");
+      // Should be a valid ISO8601 string representing 1 day in future
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      
+      // Verify it's in the future
+      const parsedDate = new Date(result);
+      const now = new Date();
+      expect(parsedDate.getTime()).toBeGreaterThan(now.getTime());
+    });
+
+    it("should transform minutes to ISO8601 (future)", () => {
+      const result = FlexibleTimeFutureSchema.parse("30m");
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      
+      const parsedDate = new Date(result);
+      const now = new Date();
+      expect(parsedDate.getTime()).toBeGreaterThan(now.getTime());
+    });
+
+    it("should transform hours to ISO8601 (future)", () => {
+      const result = FlexibleTimeFutureSchema.parse("3h");
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      
+      const parsedDate = new Date(result);
+      const now = new Date();
+      expect(parsedDate.getTime()).toBeGreaterThan(now.getTime());
+    });
+
+    it("should transform weeks to ISO8601 (future)", () => {
+      const result = FlexibleTimeFutureSchema.parse("2w");
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      
+      const parsedDate = new Date(result);
+      const now = new Date();
+      expect(parsedDate.getTime()).toBeGreaterThan(now.getTime());
+    });
+
+    it("should transform months to ISO8601 (future)", () => {
+      const result = FlexibleTimeFutureSchema.parse("1M");
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      
+      const parsedDate = new Date(result);
+      const now = new Date();
+      expect(parsedDate.getTime()).toBeGreaterThan(now.getTime());
+    });
+  });
+
+  describe("validation before transformation", () => {
+    it("should reject invalid formats", () => {
+      expect(() => FlexibleTimeFutureSchema.parse("invalid")).toThrow();
+    });
+
+    it("should reject malformed ISO8601", () => {
+      expect(() => FlexibleTimeFutureSchema.parse("2024-13-01")).toThrow();
+    });
+
+    it("should reject malformed relative time", () => {
+      expect(() => FlexibleTimeFutureSchema.parse("5x")).toThrow();
+    });
+  });
+});
+
+describe("direction comparison (Past vs Future)", () => {
+  it("should produce different results for same relative time input", () => {
+    const pastResult = FlexibleTimePastSchema.parse("1d");
+    const futureResult = FlexibleTimeFutureSchema.parse("1d");
+    
+    expect(pastResult).not.toBe(futureResult);
+    
+    const pastDate = new Date(pastResult);
+    const futureDate = new Date(futureResult);
+    const now = new Date();
+    
+    expect(pastDate.getTime()).toBeLessThan(now.getTime());
+    expect(futureDate.getTime()).toBeGreaterThan(now.getTime());
+  });
+
+  it("should produce same result for ISO8601 input regardless of direction", () => {
+    const iso = "2024-01-15T12:00:00Z";
+    const pastResult = FlexibleTimePastSchema.parse(iso);
+    const futureResult = FlexibleTimeFutureSchema.parse(iso);
+    
+    expect(pastResult).toBe(futureResult);
+  });
+});

package/src/time/flexible-time.schema.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+
+import { ISO8601Schema } from "./iso8601.schema";
+import { RelativeTimeSchema } from "./relative-time.schema";
+import { parseFlexibleTime } from "./time-helpers";
+
+/**
+ * Core validation schema for flexible time input
+ * Accepts either ISO8601 datetime or relative time expression
+ * Validates format but does not transform
+ */
+export const FlexibleTimeSchema = z.union([ISO8601Schema, RelativeTimeSchema]);
+
+export type FlexibleTime = z.infer<typeof FlexibleTimeSchema>;
+
+/**
+ * Transformation schema that converts flexible time to ISO8601
+ * Direction: past (relative times subtract from current time)
+ * @example
+ * FlexibleTimePastSchema.parse("1d") // "2024-01-14T12:00:00.000Z"
+ * FlexibleTimePastSchema.parse("2024-01-15T12:00:00Z") // "2024-01-15T12:00:00.000Z"
+ */
+export const FlexibleTimePastSchema = FlexibleTimeSchema.transform((value) =>
+  parseFlexibleTime(value, new Date(), "past")
+);
+
+/**
+ * Transformation schema that converts flexible time to ISO8601
+ * Direction: future (relative times add to current time)
+ * @example
+ * FlexibleTimeFutureSchema.parse("1d") // "2024-01-16T12:00:00.000Z"
+ * FlexibleTimeFutureSchema.parse("2024-01-15T12:00:00Z") // "2024-01-15T12:00:00.000Z"
+ */
+export const FlexibleTimeFutureSchema = FlexibleTimeSchema.transform((value) =>
+  parseFlexibleTime(value, new Date(), "future")
+);
+
+/**
+ * Deprecated: Use FlexibleTimePastSchema instead
+ * @deprecated
+ */
+export const SinceParameterSchema = FlexibleTimePastSchema;
+export type SinceParameter = z.infer<typeof SinceParameterSchema>;

package/src/time/is-relative-time.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "vitest";
+
+import { isRelativeTime } from "./is-relative-time";
+
+describe("isRelativeTime", () => {
+  it("should identify valid relative time expressions", () => {
+    expect(isRelativeTime("1d")).toBe(true);
+    expect(isRelativeTime("30m")).toBe(true);
+    expect(isRelativeTime("2h")).toBe(true);
+    expect(isRelativeTime("1w")).toBe(true);
+    expect(isRelativeTime("3M")).toBe(true);
+    expect(isRelativeTime("999d")).toBe(true);
+  });
+
+  it("should reject invalid expressions", () => {
+    expect(isRelativeTime("2024-07-26T15:20:00Z")).toBe(false);
+    expect(isRelativeTime("invalid")).toBe(false);
+    expect(isRelativeTime("1x")).toBe(false);
+    expect(isRelativeTime("1day")).toBe(false);
+    expect(isRelativeTime("")).toBe(false);
+    expect(isRelativeTime("1.5d")).toBe(false);
+  });
+});

package/src/time/is-relative-time.ts

@@ -0,0 +1,9 @@
+/**
+ * Check if a string is a relative time expression
+ *
+ * @param value - String to check
+ * @returns true if it's a relative time expression
+ */
+export const isRelativeTime = (value: string): boolean => {
+  return /^(\d+)[mhdwM]$/.test(value);
+};

package/src/time/iso8601.schema.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+/**
+ * Core validation schema for ISO8601 datetime strings
+ * Validates format but does not transform
+ */
+export const ISO8601Schema = z
+  .string()
+  .describe("Datetime in ISO8601 format")
+  .regex(
+    /^((?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))(Z|[\+-]\d{2}:\d{2})?)$/,
+    "Must be a valid ISO8601 datetime (e.g., '2024-01-01T12:00:00Z')"
+  );
+
+export type ISO8601 = z.infer<typeof ISO8601Schema>;
+
+/**
+ * Core validation schema for ISO8601 date strings (YYYY-MM-DD)
+ * Validates format but does not transform
+ */
+export const ISO8601DateSchema = z
+  .string()
+  .describe("Date in ISO8601 format")
+  .regex(
+    /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/,
+    "Date must be in YYYY-MM-DD format with valid month (01-12) and day (01-31)"
+  );
+
+export type ISO8601Date = z.infer<typeof ISO8601DateSchema>;

package/src/time/iso8601.types.test.ts

@@ -0,0 +1,112 @@
+import { describe, test, expect } from "vitest";
+import { ZodError } from "zod";
+
+import { ISO8601Schema, ISO8601DateSchema } from "./iso8601.types";
+
+describe("ISO8601Schema", () => {
+  describe("valid formats", () => {
+    test("accepts full ISO8601 format with Z timezone", () => {
+      const dateString = "2023-04-12T14:30:45Z";
+      const result = ISO8601Schema.parse(dateString);
+      expect(result).toBe(new Date(dateString).toISOString());
+    });
+
+    test("accepts ISO8601 with milliseconds", () => {
+      const dateString = "2023-04-12T14:30:45.123Z";
+      const result = ISO8601Schema.parse(dateString);
+      expect(result).toBe(new Date(dateString).toISOString());
+    });
+
+    test("accepts ISO8601 with positive timezone offset", () => {
+      const dateString = "2023-04-12T14:30:45+02:00";
+      const result = ISO8601Schema.parse(dateString);
+      expect(result).toBe(new Date(dateString).toISOString());
+    });
+
+    test("accepts ISO8601 with negative timezone offset", () => {
+      const dateString = "2023-04-12T14:30:45-05:00";
+      const result = ISO8601Schema.parse(dateString);
+      expect(result).toBe(new Date(dateString).toISOString());
+    });
+  });
+
+  describe("invalid formats", () => {
+    test("rejects non-ISO8601 string", () => {
+      const dateString = "April 12, 2023";
+      expect(() => ISO8601Schema.parse(dateString)).toThrow(ZodError);
+    });
+
+    test("rejects date without time", () => {
+      const dateString = "2023-04-12";
+      expect(() => ISO8601Schema.parse(dateString)).toThrow(ZodError);
+    });
+
+    test("rejects time without date", () => {
+      const dateString = "14:30:45Z";
+      expect(() => ISO8601Schema.parse(dateString)).toThrow(ZodError);
+    });
+
+    test("rejects malformed ISO8601 (incorrect separators)", () => {
+      const dateString = "2023/04/12T14:30:45Z";
+      expect(() => ISO8601Schema.parse(dateString)).toThrow(ZodError);
+    });
+
+    test("rejects malformed ISO8601 (incorrect time format)", () => {
+      const dateString = "2023-04-12T14-30-45Z";
+      expect(() => ISO8601Schema.parse(dateString)).toThrow(ZodError);
+    });
+  });
+
+  describe("transformation", () => {
+    test("transforms valid ISO8601 to date ISO string", () => {
+      const dateString = "2023-04-12T14:30:45Z";
+      const result = ISO8601Schema.parse(dateString);
+      expect(typeof result).toBe("string");
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      expect(result).toBe(new Date(dateString).toISOString());
+    });
+  });
+});
+
+describe("ISO8601DateSchema", () => {
+  describe("valid formats", () => {
+    test("accepts valid ISO8601 date format", () => {
+      const dateString = "2023-04-12";
+      const result = ISO8601DateSchema.parse(dateString);
+      expect(result).toBe(dateString);
+    });
+
+    test("accepts date with leading zeros", () => {
+      const dateString = "2023-01-05";
+      const result = ISO8601DateSchema.parse(dateString);
+      expect(result).toBe(dateString);
+    });
+  });
+
+  describe("invalid formats", () => {
+    test("rejects non-ISO8601 date string", () => {
+      const dateString = "04/12/2023";
+      expect(() => ISO8601DateSchema.parse(dateString)).toThrow(ZodError);
+    });
+
+    test("rejects date with time", () => {
+      const dateString = "2023-04-12T14:30:45Z";
+      expect(() => ISO8601DateSchema.parse(dateString)).toThrow(ZodError);
+    });
+
+    test("rejects date with incorrect separator", () => {
+      const dateString = "2023/04/12";
+      expect(() => ISO8601DateSchema.parse(dateString)).toThrow(ZodError);
+    });
+
+    test("rejects malformed date format", () => {
+      const dateString = "20230412";
+      expect(() => ISO8601DateSchema.parse(dateString)).toThrow(ZodError);
+    });
+
+    test("rejects invalid date values", () => {
+      const dateString = "2023-13-45"; // Invalid month and day
+      expect(() => ISO8601DateSchema.parse(dateString)).toThrow(ZodError);
+    });
+  });
+});

package/src/time/iso8601.types.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+export const ISO8601Schema = z
+  .string()
+  .describe("Datetime in ISO8601 format")
+  .regex(
+    /^((?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))(Z|[\+-]\d{2}:\d{2})?)$/
+  )
+  .transform((v) => new Date(v).toISOString());
+
+export type ISO8601 = z.infer<typeof ISO8601Schema>;
+
+// ensure valid month and valid day
+export const ISO8601DateSchema = z
+  .string()
+  .describe("Date in ISO8601 format")
+  .regex(
+    /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/,
+    "Date must be in YYYY-MM-DD format with valid month (01-12) and day (01-31)"
+  );
+export type ISO8601Date = z.infer<typeof ISO8601DateSchema>;

package/src/time/parse-relative-time.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+import { parseRelativeTime } from "./parse-relative-time";
+
+describe("parseRelativeTime", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2024-07-26T15:20:00Z"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("should parse minutes correctly", () => {
+    expect(parseRelativeTime("30m")).toBe("2024-07-26T14:50:00.000Z");
+    expect(parseRelativeTime("90m")).toBe("2024-07-26T13:50:00.000Z");
+  });
+
+  it("should parse hours correctly", () => {
+    expect(parseRelativeTime("1h")).toBe("2024-07-26T14:20:00.000Z");
+    expect(parseRelativeTime("24h")).toBe("2024-07-25T15:20:00.000Z");
+  });
+
+  it("should parse days correctly", () => {
+    expect(parseRelativeTime("1d")).toBe("2024-07-25T15:20:00.000Z");
+    expect(parseRelativeTime("7d")).toBe("2024-07-19T15:20:00.000Z");
+  });
+
+  it("should parse weeks correctly", () => {
+    expect(parseRelativeTime("1w")).toBe("2024-07-19T15:20:00.000Z");
+    expect(parseRelativeTime("2w")).toBe("2024-07-12T15:20:00.000Z");
+  });
+
+  it("should parse months correctly", () => {
+    expect(parseRelativeTime("1M")).toBe("2024-06-26T15:20:00.000Z");
+    expect(parseRelativeTime("2M")).toBe("2024-05-26T15:20:00.000Z");
+  });
+
+  it("should throw error for invalid formats", () => {
+    expect(() => parseRelativeTime("invalid")).toThrow(
+      "Invalid relative time format"
+    );
+    expect(() => parseRelativeTime("1x")).toThrow(
+      "Invalid relative time format"
+    );
+    expect(() => parseRelativeTime("")).toThrow("Invalid relative time format");
+  });
+});