@iann29/rastro 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/component/live.ts

@@ -23,16 +23,23 @@ export const expire = internalMutation({
     if (liveSession.expiryChainDeadline !== args.scheduledDeadline) {
       return { expired: false, rescheduled: false, stale: true };
     }
-    if (liveSession.expiresAt > Date.now()) {
+    const now = Date.now();
+    if (liveSession.expiresAt > now) {
       const state = await ctx.db
         .query("liveSweepStates")
-        .withIndex("by_siteId", (range) => range.eq("siteId", liveSession.siteId))
+        .withIndex("by_siteId", (range) =>
+          range.eq("siteId", liveSession.siteId),
+        )
         .unique();
       const scheduledAt = Math.min(
         liveSession.expiresAt,
-        Date.now() + LIVE_SWEEP_INTERVAL_MS,
+        now + LIVE_SWEEP_INTERVAL_MS,
       );
-      if (!state || state.scheduledAt > scheduledAt) {
+      if (
+        !state ||
+        state.scheduledAt <= now ||
+        state.scheduledAt > scheduledAt
+      ) {
         if (state) {
           await ctx.db.patch("liveSweepStates", state._id, {
             scheduledAt,
@@ -98,9 +105,8 @@ export const sweep = internalMutation({
       return { expired: expired.length, rescheduled: false, stale: false };
     }
 
-    const scheduledAt = expired.length === SWEEP_BATCH_SIZE
-      ? now
-      : now + LIVE_SWEEP_INTERVAL_MS;
+    const scheduledAt =
+      expired.length === SWEEP_BATCH_SIZE ? now : now + LIVE_SWEEP_INTERVAL_MS;
     await ctx.db.patch("liveSweepStates", state._id, { scheduledAt });
     await ctx.scheduler.runAt(scheduledAt, internal.live.sweep, {
       siteId: args.siteId,

package/src/component/localTime.ts

@@ -0,0 +1,167 @@
+import { DAY_MS, HOUR_MS } from "./constants.js";
+
+/**
+ * Local calendar days for a site's timezone. Aggregates are bucketed by UTC
+ * hour and UTC day; a site with a timezone also gets a `localDay` bucket per
+ * calendar day in that zone (see foldAggregates), so "yesterday" in São Paulo
+ * ends at midnight in São Paulo, not at 21:00. Every function here uses the
+ * runtime's Intl data — the same data `validateTimezone` relies on.
+ */
+
+const formatters = new Map<string, Intl.DateTimeFormat>();
+
+function formatter(timeZone: string): Intl.DateTimeFormat {
+  let cached = formatters.get(timeZone);
+  if (!cached) {
+    cached = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+    });
+    formatters.set(timeZone, cached);
+  }
+  return cached;
+}
+
+type LocalParts = {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+};
+
+function localParts(timestamp: number, timeZone: string): LocalParts {
+  const parts: Partial<LocalParts> = {};
+  for (const part of formatter(timeZone).formatToParts(timestamp)) {
+    if (part.type === "literal") continue;
+    parts[part.type as keyof LocalParts] = Number(part.value);
+  }
+  return {
+    year: parts.year ?? 1970,
+    month: parts.month ?? 1,
+    day: parts.day ?? 1,
+    // Some engines print 24 for midnight even with hourCycle h23.
+    hour: (parts.hour ?? 0) % 24,
+    minute: parts.minute ?? 0,
+    second: parts.second ?? 0,
+  };
+}
+
+/** The zone's offset from UTC at `timestamp`, in milliseconds (east is positive). */
+export function localOffsetMs(timestamp: number, timeZone: string): number {
+  const parts = localParts(timestamp, timeZone);
+  const asUtc = Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hour,
+    parts.minute,
+    parts.second,
+  );
+  return asUtc - (timestamp - (((timestamp % 1000) + 1000) % 1000));
+}
+
+function localDateKey(timestamp: number, timeZone: string): number {
+  const parts = localParts(timestamp, timeZone);
+  return parts.year * 10_000 + parts.month * 100 + parts.day;
+}
+
+/**
+ * The first instant of the local calendar day that contains `timestamp`, as
+ * a UTC millisecond timestamp. Where a transition removes midnight (Chile
+ * springs forward at 00:00), the day starts at the first instant that exists.
+ */
+export function localDayStart(timestamp: number, timeZone: string): number {
+  const parts = localParts(timestamp, timeZone);
+  const target = parts.year * 10_000 + parts.month * 100 + parts.day;
+  const guess = Date.UTC(parts.year, parts.month - 1, parts.day);
+  // The offset in force at UTC midnight is usually the one at local midnight
+  // too; around a transition it is not, so a second and third candidate use
+  // the offset observed at the previous guess, and the earliest instant that
+  // still falls on the target date wins.
+  const first = guess - localOffsetMs(guess, timeZone);
+  const second = guess - localOffsetMs(first, timeZone);
+  const third = guess - localOffsetMs(second, timeZone);
+  const candidates = [first, second, third]
+    .filter((candidate) => localDateKey(candidate, timeZone) === target)
+    .sort((left, right) => left - right);
+  return candidates[0] ?? first;
+}
+
+/** The start of the local day after the one starting at `dayStart`. */
+export function nextLocalDayStart(dayStart: number, timeZone: string): number {
+  return localDayStart(dayStart + DAY_MS + 12 * HOUR_MS, timeZone);
+}
+
+/** The start of the local day before the one starting at `dayStart`. */
+export function previousLocalDayStart(
+  dayStart: number,
+  timeZone: string,
+): number {
+  return localDayStart(dayStart - 12 * HOUR_MS, timeZone);
+}
+
+/** Every local day start from `from` through `to`, when `from` is one. */
+export function localDayStarts(
+  from: number,
+  to: number,
+  timeZone: string,
+): number[] {
+  const starts: number[] = [];
+  let cursor = from;
+  while (cursor <= to) {
+    starts.push(cursor);
+    cursor = nextLocalDayStart(cursor, timeZone);
+  }
+  return starts;
+}
+
+/** Whether `[from, to]` covers whole local days in the zone, inclusively. */
+export function isLocalDayAligned(
+  from: number,
+  to: number,
+  timeZone: string,
+): boolean {
+  return (
+    localDayStart(from, timeZone) === from &&
+    localDayStart(to + 1, timeZone) === to + 1
+  );
+}
+
+/**
+ * A site's timezone when it needs its own day buckets: undefined for no
+ * timezone and for zones that never leave UTC, whose local days are the UTC
+ * days already kept.
+ */
+export function localDayTimezone(
+  timezone: string | undefined | null,
+): string | undefined {
+  if (!timezone) return undefined;
+  try {
+    const year = new Date().getUTCFullYear();
+    const january = Date.UTC(year, 0, 1);
+    const july = Date.UTC(year, 6, 1);
+    return localOffsetMs(january, timezone) === 0 &&
+      localOffsetMs(july, timezone) === 0
+      ? undefined
+      : timezone;
+  } catch {
+    return undefined;
+  }
+}
+
+/** One timezone shared by every site, or undefined when they differ. */
+export function sharedLocalTimezone(
+  timezones: Array<string | undefined>,
+): string | undefined {
+  const distinct = new Set(timezones);
+  if (distinct.size !== 1) return undefined;
+  return timezones[0];
+}