@reventlessdev/reventless-core 3.0.0-alpha.293 → 3.0.0-alpha.295

package/src/util/ScheduleTime.res.mjs

@@ -0,0 +1,451 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DateTime from "@reventlessdev/rescript-effect/src/DateTime.res.mjs";
+import * as Cron from "effect/Cron";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DateTime$1 from "effect/DateTime";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let InvalidTime = /* @__PURE__ */Primitive_exceptions.create("ScheduleTime-ReventlessCore.InvalidTime");
+
+let utc = "UTC";
+
+function zoneName(zone) {
+  return Stdlib_Option.getOr(zone, utc);
+}
+
+function zoneOrThrow(name) {
+  let zone = DateTime.zoneMakeNamed(name);
+  if (zone !== undefined) {
+    return Primitive_option.valFromOption(zone);
+  }
+  throw {
+    RE_EXN_ID: InvalidTime,
+    _1: `unknown time zone "` + name + `"`,
+    Error: new Error()
+  };
+}
+
+function intervalMs(interval) {
+  switch (interval.TAG) {
+    case "Minutes" :
+      return interval._0 * 60000;
+    case "Hours" :
+      return interval._0 * 60 * 60000;
+    case "Days" :
+      return interval._0 * 24 * 60 * 60000;
+    case "Weeks" :
+      return interval._0 * 7 * 24 * 60 * 60000;
+  }
+}
+
+function weekdayIndex(day) {
+  switch (day) {
+    case "Mon" :
+      return 1;
+    case "Tue" :
+      return 2;
+    case "Wed" :
+      return 3;
+    case "Thu" :
+      return 4;
+    case "Fri" :
+      return 5;
+    case "Sat" :
+      return 6;
+    case "Sun" :
+      return 0;
+  }
+}
+
+function weekdayName(day) {
+  switch (day) {
+    case "Mon" :
+      return "MON";
+    case "Tue" :
+      return "TUE";
+    case "Wed" :
+      return "WED";
+    case "Thu" :
+      return "THU";
+    case "Fri" :
+      return "FRI";
+    case "Sat" :
+      return "SAT";
+    case "Sun" :
+      return "SUN";
+  }
+}
+
+function errors(time) {
+  let errs = [];
+  let check = (ok, message) => {
+    if (ok) {
+      return;
+    } else {
+      errs.push(message);
+      return;
+    }
+  };
+  let positive = (n, what) => check(n >= 1, what + ` must be at least 1, got ` + n.toString());
+  let clock = (hour, minute) => {
+    check(hour >= 0 && hour <= 23, `hour must be 0 to 23, got ` + hour.toString());
+    check(minute >= 0 && minute <= 59, `minute must be 0 to 59, got ` + minute.toString());
+  };
+  let dayOfMonth = day => check(day >= 1 && day <= 31, `day must be 1 to 31, got ` + day.toString());
+  let monthOfYear = month => check(month >= 1 && month <= 12, `month must be 1 to 12, got ` + month.toString());
+  let zoneKnown = zone => Stdlib_Option.forEach(zone, name => check(Stdlib_Option.isSome(DateTime.zoneMakeNamed(name)), `unknown time zone "` + name + `"`));
+  switch (time.TAG) {
+    case "Every" :
+      positive(time._0._0, "an interval");
+      break;
+    case "Calendar" :
+      let calendar = time.calendar;
+      zoneKnown(time.zone);
+      switch (calendar.TAG) {
+        case "Daily" :
+          clock(calendar.hour, calendar.minute);
+          break;
+        case "Weekly" :
+          check(calendar.days.length !== 0, "a weekly time needs at least one day");
+          clock(calendar.hour, calendar.minute);
+          break;
+        case "Monthly" :
+          dayOfMonth(calendar.day);
+          clock(calendar.hour, calendar.minute);
+          Stdlib_Option.forEach(calendar.every, every => check(every >= 1 && every <= 12, `every must be 1 to 12, got ` + every.toString()));
+          break;
+        case "Yearly" :
+          monthOfYear(calendar.month);
+          dayOfMonth(calendar.day);
+          clock(calendar.hour, calendar.minute);
+          break;
+      }
+      break;
+    case "Once" :
+      let moment = time.moment;
+      zoneKnown(time.zone);
+      if (moment.TAG === "At") {
+        let match = moment._0;
+        monthOfYear(match.month);
+        dayOfMonth(match.day);
+        clock(match.hour, match.minute);
+      } else {
+        positive(moment._0._0, "a period");
+      }
+      break;
+  }
+  return errs;
+}
+
+function validate(time) {
+  let errs = errors(time);
+  if (errs.length === 0) {
+    return;
+  }
+  throw {
+    RE_EXN_ID: InvalidTime,
+    _1: errs.join("; "),
+    Error: new Error()
+  };
+}
+
+function localTimeOf(millis, zone) {
+  let parts = DateTime$1.toParts(DateTime.makeZonedFromMillis(millis, zone));
+  return {
+    year: parts.year,
+    month: parts.month,
+    day: parts.day,
+    hour: parts.hours,
+    minute: parts.minutes
+  };
+}
+
+function afterPeriod(period, from, zone) {
+  let start = DateTime.makeZonedFromMillis(from, zone);
+  switch (period.TAG) {
+    case "Minutes" :
+      return from + period._0 * 60000;
+    case "Hours" :
+      return from + period._0 * 60 * 60000;
+    case "Days" :
+      return DateTime$1.toEpochMillis(DateTime$1.add(start, {
+        days: period._0
+      }));
+    case "Weeks" :
+      return DateTime$1.toEpochMillis(DateTime$1.add(start, {
+        weeks: period._0
+      }));
+    case "Months" :
+      return DateTime$1.toEpochMillis(DateTime$1.add(start, {
+        months: period._0
+      }));
+    case "Years" :
+      return DateTime$1.toEpochMillis(DateTime$1.add(start, {
+        years: period._0
+      }));
+  }
+}
+
+function resolveOnce(time, from) {
+  switch (time.TAG) {
+    case "Every" :
+    case "Calendar" :
+      return time;
+    case "Once" :
+      let period = time.moment;
+      if (period.TAG === "At") {
+        return time;
+      }
+      let zone = time.zone;
+      let tz = zoneOrThrow(Stdlib_Option.getOr(zone, utc));
+      return {
+        TAG: "Once",
+        moment: {
+          TAG: "At",
+          _0: localTimeOf(afterPeriod(period._0, from, tz), tz)
+        },
+        zone: zone
+      };
+  }
+}
+
+function instantOf(param, zone) {
+  let day = param.day;
+  let month = param.month;
+  let year = param.year;
+  let dateTime = DateTime.makeZonedFromParts({
+    year: year,
+    month: month,
+    day: day,
+    hours: param.hour,
+    minutes: param.minute
+  }, zone);
+  if (dateTime !== undefined) {
+    return DateTime$1.toEpochMillis(Primitive_option.valFromOption(dateTime));
+  }
+  throw {
+    RE_EXN_ID: InvalidTime,
+    _1: `no such time: ` + year.toString() + `-` + month.toString() + `-` + day.toString(),
+    Error: new Error()
+  };
+}
+
+function wallClockOf(calendar) {
+  switch (calendar.TAG) {
+    case "Daily" :
+      return [
+        calendar.hour,
+        calendar.minute
+      ];
+    case "Weekly" :
+    case "Monthly" :
+      return [
+        calendar.hour,
+        calendar.minute
+      ];
+    case "Yearly" :
+      return [
+        calendar.hour,
+        calendar.minute
+      ];
+  }
+}
+
+function monthsEvery(every) {
+  if (every <= 1) {
+    return [];
+  } else {
+    return Stdlib_Array.fromInitializer(Primitive_int.div(11, every) + 1 | 0, i => 1 + (i * every | 0) | 0);
+  }
+}
+
+function cronOf(calendar, zone) {
+  let match = wallClockOf(calendar);
+  let minute = match[1];
+  let hour = match[0];
+  let at = (daysOpt, monthsOpt, weekdaysOpt) => {
+    let days = daysOpt !== undefined ? daysOpt : [];
+    let months = monthsOpt !== undefined ? monthsOpt : [];
+    let weekdays = weekdaysOpt !== undefined ? weekdaysOpt : [];
+    return Cron.make({
+      minutes: [minute],
+      hours: [hour],
+      days: days,
+      months: months,
+      weekdays: weekdays,
+      tz: zone
+    });
+  };
+  switch (calendar.TAG) {
+    case "Daily" :
+      return at(undefined, undefined, undefined);
+    case "Weekly" :
+      return at(undefined, undefined, calendar.days.map(weekdayIndex));
+    case "Monthly" :
+      return at([calendar.day], monthsEvery(Stdlib_Option.getOr(calendar.every, 1)), undefined);
+    case "Yearly" :
+      return at([calendar.day], [calendar.month], undefined);
+  }
+}
+
+function nextOnWallClock(cron, after, hour, minute, zone) {
+  let _from = after;
+  let _tries = 0;
+  while (true) {
+    let tries = _tries;
+    let from = _from;
+    let next = Cron.next(cron, new Date(from)).getTime();
+    let parts = DateTime$1.toParts(DateTime.makeZonedFromMillis(next, zone));
+    if (parts.hours === hour && parts.minutes === minute || tries >= 8) {
+      return next;
+    }
+    _tries = tries + 1 | 0;
+    _from = next;
+    continue;
+  };
+}
+
+function nextFiring(time, after) {
+  let interval = resolveOnce(time, after);
+  switch (interval.TAG) {
+    case "Every" :
+      return after + intervalMs(interval._0);
+    case "Calendar" :
+      let calendar = interval.calendar;
+      let tz = zoneOrThrow(Stdlib_Option.getOr(interval.zone, utc));
+      let match = wallClockOf(calendar);
+      return nextOnWallClock(cronOf(calendar, tz), after, match[0], match[1], tz);
+    case "Once" :
+      let localTime = interval.moment;
+      if (localTime.TAG !== "At") {
+        return;
+      }
+      let at = instantOf(localTime._0, zoneOrThrow(Stdlib_Option.getOr(interval.zone, utc)));
+      if (at > after) {
+        return at;
+      } else {
+        return;
+      }
+  }
+}
+
+function pad2(n) {
+  if (n < 10) {
+    return `0` + n.toString();
+  } else {
+    return n.toString();
+  }
+}
+
+function rateOf(n, unit) {
+  return `rate(` + n.toString() + ` ` + unit + (
+    n === 1 ? "" : "s"
+  ) + `)`;
+}
+
+function cronExpressionOf(calendar) {
+  let match = wallClockOf(calendar);
+  let fields;
+  switch (calendar.TAG) {
+    case "Daily" :
+      fields = "* * ? *";
+      break;
+    case "Weekly" :
+      fields = `? * ` + calendar.days.map(weekdayName).join(",") + ` *`;
+      break;
+    case "Monthly" :
+      let every = calendar.every;
+      let month = every !== undefined && every > 1 ? `1/` + every.toString() : "*";
+      fields = calendar.day.toString() + ` ` + month + ` ? *`;
+      break;
+    case "Yearly" :
+      fields = calendar.day.toString() + ` ` + calendar.month.toString() + ` ? *`;
+      break;
+  }
+  return `cron(` + match[1].toString() + ` ` + match[0].toString() + ` ` + fields + `)`;
+}
+
+function toAws(time, setAt) {
+  let interval = resolveOnce(time, setAt);
+  switch (interval.TAG) {
+    case "Every" :
+      let interval$1 = interval._0;
+      let tmp;
+      switch (interval$1.TAG) {
+        case "Minutes" :
+          tmp = rateOf(interval$1._0, "minute");
+          break;
+        case "Hours" :
+          tmp = rateOf(interval$1._0, "hour");
+          break;
+        case "Days" :
+          tmp = rateOf(interval$1._0, "day");
+          break;
+        case "Weeks" :
+          tmp = rateOf(interval$1._0 * 7 | 0, "day");
+          break;
+      }
+      return {
+        expression: tmp,
+        timezone: undefined,
+        startDate: setAt + intervalMs(interval$1),
+        deleteAfterCompletion: false
+      };
+    case "Calendar" :
+      return {
+        expression: cronExpressionOf(interval.calendar),
+        timezone: Stdlib_Option.getOr(interval.zone, utc),
+        startDate: undefined,
+        deleteAfterCompletion: false
+      };
+    case "Once" :
+      let match = interval.moment;
+      if (match.TAG === "At") {
+        let match$1 = match._0;
+        return {
+          expression: `at(` + match$1.year.toString() + `-` + pad2(match$1.month) + `-` + pad2(match$1.day) + `T` + pad2(match$1.hour) + `:` + pad2(match$1.minute) + `:00)`,
+          timezone: Stdlib_Option.getOr(interval.zone, utc),
+          startDate: undefined,
+          deleteAfterCompletion: true
+        };
+      }
+      throw {
+        RE_EXN_ID: InvalidTime,
+        _1: "unresolved once-only time",
+        Error: new Error()
+      };
+  }
+}
+
+let minuteMs = 60000;
+
+export {
+  InvalidTime,
+  utc,
+  zoneName,
+  zoneOrThrow,
+  minuteMs,
+  intervalMs,
+  weekdayIndex,
+  weekdayName,
+  errors,
+  validate,
+  localTimeOf,
+  afterPeriod,
+  resolveOnce,
+  instantOf,
+  wallClockOf,
+  monthsEvery,
+  cronOf,
+  nextOnWallClock,
+  nextFiring,
+  pad2,
+  rateOf,
+  cronExpressionOf,
+  toAws,
+}
+/* DateTime Not a pure module */

package/tests/util/ScheduleTimeTest.res

@@ -0,0 +1,256 @@
+// When each shape of a Schedule.time fires, and that the AWS expression of a calendar
+// time names the same firings the local timer waits for.
+
+open JestGlobals
+open Reventless.Schedule
+
+let at = iso => Date.fromString(iso)->Date.getTime
+let iso = millis => millis->Date.fromTime->Date.toISOString
+
+/** The first `n` firings of `time` after `from`, in UTC. */
+let firings = (time, ~from, ~n) => {
+  let out = []
+  let rec loop = after =>
+    switch out->Array.length < n ? ScheduleTime.nextFiring(time, ~after) : None {
+    | Some(next) =>
+      out->Array.push(next->iso)
+      loop(next)
+    | None => ()
+    }
+  loop(from->at)
+  out
+}
+
+describe("ScheduleTime.nextFiring", () => {
+  testSync("Every counts from the previous firing, with no zone", () => {
+    expect(firings(Every(Hours(2)), ~from="2026-03-29T00:30:00Z", ~n=2))->toEqual([
+      "2026-03-29T02:30:00.000Z",
+      "2026-03-29T04:30:00.000Z",
+    ])
+  })
+
+  testSync("Daily is a wall-clock time in its zone, across both daylight-saving changes", () => {
+    let daily = Calendar({calendar: Daily({hour: 6, minute: 0}), zone: "Europe/Berlin"})
+    expect(firings(daily, ~from="2026-03-28T12:00:00Z", ~n=2))->toEqual([
+      "2026-03-29T04:00:00.000Z",
+      "2026-03-30T04:00:00.000Z",
+    ])
+    expect(firings(daily, ~from="2026-10-24T12:00:00Z", ~n=2))->toEqual([
+      "2026-10-25T05:00:00.000Z",
+      "2026-10-26T05:00:00.000Z",
+    ])
+  })
+
+  testSync("a time in the skipped hour does not fire that day; in the repeated hour, once", () => {
+    let night = Calendar({calendar: Daily({hour: 2, minute: 30}), zone: "Europe/Berlin"})
+    expect(firings(night, ~from="2026-03-27T12:00:00Z", ~n=2))->toEqual([
+      "2026-03-28T01:30:00.000Z",
+      "2026-03-30T00:30:00.000Z",
+    ])
+    expect(firings(night, ~from="2026-10-24T12:00:00Z", ~n=2))->toEqual([
+      "2026-10-25T00:30:00.000Z",
+      "2026-10-26T01:30:00.000Z",
+    ])
+  })
+
+  testSync("Weekly fires on its days only", () => {
+    let weekdays = Calendar({calendar: Weekly({days: [Mon, Fri], hour: 7, minute: 30})})
+    expect(firings(weekdays, ~from="2026-10-16T08:00:00Z", ~n=3))->toEqual([
+      "2026-10-19T07:30:00.000Z",
+      "2026-10-23T07:30:00.000Z",
+      "2026-10-26T07:30:00.000Z",
+    ])
+  })
+
+  testSync("Monthly on the 29th to 31st skips the months without that day", () => {
+    let on = day => Calendar({calendar: Monthly({day, hour: 6, minute: 0})})
+    expect(firings(on(29), ~from="2027-01-30T00:00:00Z", ~n=1))->toEqual([
+      "2027-03-29T06:00:00.000Z",
+    ])
+    expect(firings(on(30), ~from="2027-01-31T00:00:00Z", ~n=1))->toEqual([
+      "2027-03-30T06:00:00.000Z",
+    ])
+    expect(firings(on(31), ~from="2026-04-01T00:00:00Z", ~n=2))->toEqual([
+      "2026-05-31T06:00:00.000Z",
+      "2026-07-31T06:00:00.000Z",
+    ])
+  })
+
+  testSync("Monthly with every fires every so many months, from January", () => {
+    let quarterly = Calendar({calendar: Monthly({day: 1, hour: 6, minute: 0, every: 3})})
+    expect(firings(quarterly, ~from="2026-02-15T00:00:00Z", ~n=4))->toEqual([
+      "2026-04-01T06:00:00.000Z",
+      "2026-07-01T06:00:00.000Z",
+      "2026-10-01T06:00:00.000Z",
+      "2027-01-01T06:00:00.000Z",
+    ])
+  })
+
+  testSync("Yearly on 29 February fires in leap years", () => {
+    let leap = Calendar({calendar: Yearly({month: 2, day: 29, hour: 6, minute: 0})})
+    expect(firings(leap, ~from="2026-01-01T00:00:00Z", ~n=2))->toEqual([
+      "2028-02-29T06:00:00.000Z",
+      "2032-02-29T06:00:00.000Z",
+    ])
+  })
+
+  testSync("Once at a local time fires once, read in its zone; once past, never", () => {
+    let newYear = Once({
+      moment: At({year: 2026, month: 12, day: 31, hour: 23, minute: 59}),
+      zone: "Europe/Berlin",
+    })
+    expect(firings(newYear, ~from="2026-10-16T00:00:00Z", ~n=3))->toEqual([
+      "2026-12-31T22:59:00.000Z",
+    ])
+    expect(firings(newYear, ~from="2027-01-01T00:00:00Z", ~n=1))->toEqual([])
+  })
+})
+
+describe("ScheduleTime.resolveOnce", () => {
+  let resolved = (period, ~from, ~zone="UTC") =>
+    switch Once({moment: After(period), zone})->ScheduleTime.resolveOnce(~from=from->at) {
+    | Once({moment: At(localTime)}) => Some(localTime)
+    | _ => None
+    }
+
+  testSync("a month from 31 January is the last day of February", () => {
+    expect(resolved(Months(1), ~from="2026-01-31T09:00:00Z"))->toEqual(
+      Some({year: 2026, month: 2, day: 28, hour: 9, minute: 0}),
+    )
+  })
+
+  testSync("a day keeps the wall-clock time across a daylight-saving change", () => {
+    expect(resolved(Days(1), ~from="2026-03-28T05:00:00Z", ~zone="Europe/Berlin"))->toEqual(
+      Some({year: 2026, month: 3, day: 29, hour: 6, minute: 0}),
+    )
+  })
+
+  testSync("24 hours are elapsed time across the same change", () => {
+    expect(resolved(Hours(24), ~from="2026-03-28T05:00:00Z", ~zone="Europe/Berlin"))->toEqual(
+      Some({year: 2026, month: 3, day: 29, hour: 7, minute: 0}),
+    )
+  })
+
+  testSync("minutes are counted from the moment it is set, to the minute", () => {
+    expect(resolved(Minutes(10), ~from="2026-10-15T14:02:37Z"))->toEqual(
+      Some({year: 2026, month: 10, day: 15, hour: 14, minute: 12}),
+    )
+  })
+})
+
+describe("ScheduleTime.toAws", () => {
+  let setAt = "2026-10-15T14:02:00Z"->at
+
+  testSync("an interval is a rate, starting one interval later", () => {
+    let aws = Every(Weeks(2))->ScheduleTime.toAws(~setAt)
+    expect(aws.expression)->toBe("rate(14 days)")
+    expect(aws.startDate)->toEqual(Some(setAt +. 14. *. 24. *. 60. *. 60_000.))
+    expect(aws.timezone)->toEqual(None)
+    expect((Every(Minutes(1))->ScheduleTime.toAws(~setAt)).expression)->toBe("rate(1 minute)")
+  })
+
+  testSync("a calendar time is a cron with its zone, UTC when it has none", () => {
+    let daily = Calendar({calendar: Daily({hour: 6, minute: 0})})->ScheduleTime.toAws(~setAt)
+    expect(daily.expression)->toBe("cron(0 6 * * ? *)")
+    expect(daily.timezone)->toEqual(Some("UTC"))
+    let weekly = Calendar({
+      calendar: Weekly({days: [Mon, Tue, Wed, Thu, Fri], hour: 7, minute: 30}),
+      zone: "Europe/Berlin",
+    })->ScheduleTime.toAws(~setAt)
+    expect(weekly.expression)->toBe("cron(30 7 ? * MON,TUE,WED,THU,FRI *)")
+    expect(weekly.timezone)->toEqual(Some("Europe/Berlin"))
+    expect(
+      (
+        Calendar({calendar: Monthly({day: 1, hour: 6, minute: 0, every: 3})})->ScheduleTime.toAws(
+          ~setAt,
+        )
+      ).expression,
+    )->toBe("cron(0 6 1 1/3 ? *)")
+    expect(
+      (
+        Calendar({calendar: Yearly({month: 12, day: 24, hour: 18, minute: 0})})->ScheduleTime.toAws(
+          ~setAt,
+        )
+      ).expression,
+    )->toBe("cron(0 18 24 12 ? *)")
+  })
+
+  testSync("a once-only time is an at in its zone, deleted after it fires", () => {
+    let aws = Once({moment: After(Days(3)), zone: "Europe/Berlin"})->ScheduleTime.toAws(~setAt)
+    expect(aws.expression)->toBe("at(2026-10-18T16:02:00)")
+    expect(aws.timezone)->toEqual(Some("Europe/Berlin"))
+    expect(aws.deleteAfterCompletion)->toBe(true)
+  })
+})
+
+describe("the two platforms agree", () => {
+  // The AWS cron, read as the five-field expression Effect parses, and the local
+  // nextFiring give the same next ten firings. Daylight saving is AWS's documented rule.
+  let fromAws = (calendar, ~zone) => {
+    let fields =
+      calendar
+      ->ScheduleTime.cronExpressionOf
+      ->String.slice(~start=5, ~end=-1)
+      ->String.split(" ")
+      ->Array.map(f => f == "?" ? "*" : f)
+    let expression = fields->Array.slice(~start=0, ~end=5)->Array.join(" ")
+    let tz = ScheduleTime.zoneOrThrow(zone)
+    let (hour, minute) = calendar->ScheduleTime.wallClockOf
+    let cron = Cron.parseOrThrow(expression, tz)
+    let out = []
+    let rec loop = after =>
+      if out->Array.length < 10 {
+        let next = cron->ScheduleTime.nextOnWallClock(~after, ~hour, ~minute, ~zone=tz)
+        out->Array.push(next->iso)
+        loop(next)
+      }
+    loop("2026-01-01T00:00:00Z"->at)
+    out
+  }
+
+  let cases: array<(string, calendar, string)> = [
+    ("daily", Daily({hour: 6, minute: 0}), "UTC"),
+    ("daily in the skipped hour", Daily({hour: 2, minute: 30}), "Europe/Berlin"),
+    (
+      "weekdays",
+      Weekly({days: [Mon, Tue, Wed, Thu, Fri], hour: 7, minute: 30}),
+      "America/New_York",
+    ),
+    ("weekends", Weekly({days: [Sat, Sun], hour: 23, minute: 59}), "Australia/Sydney"),
+    ("monthly on the 31st", Monthly({day: 31, hour: 6, minute: 0}), "Europe/Berlin"),
+    ("quarterly", Monthly({day: 15, hour: 9, minute: 15, every: 3}), "Asia/Kolkata"),
+    ("every five months", Monthly({day: 1, hour: 0, minute: 0, every: 5}), "UTC"),
+    ("yearly", Yearly({month: 3, day: 29, hour: 2, minute: 30}), "Europe/London"),
+  ]
+
+  cases->Array.forEach(((label, calendar, zone)) =>
+    testSync(
+      label,
+      () => {
+        expect(fromAws(calendar, ~zone))->toEqual(
+          firings(Calendar({calendar, zone}), ~from="2026-01-01T00:00:00Z", ~n=10),
+        )
+      },
+    )
+  )
+})
+
+describe("ScheduleTime.validate", () => {
+  testSync("names every problem of a time", () => {
+    let message = switch ScheduleTime.validate(
+      Calendar({calendar: Weekly({days: [], hour: 24, minute: 0}), zone: "Mars/Base"}),
+    ) {
+    | () => ""
+    | exception ScheduleTime.InvalidTime(message) => message
+    }
+    expect(
+      message,
+    )->toBe(`unknown time zone "Mars/Base"; a weekly time needs at least one day; hour must be 0 to 23, got 24`)
+  })
+
+  testSync("accepts a time that can fire", () => {
+    expect(
+      ScheduleTime.errors(Once({moment: After(Years(1)), zone: "Pacific/Auckland"})),
+    )->toEqual([])
+  })
+})