系統設計

1type User = { id: number; utcOffset: number; channel: "push" | "sms" | "email" | "none" };
2type Message = { key: string; urgent: boolean; attempt: number };
3type Result = "sent" | "duplicate" | "retry" | "failed" | "deferred";
4 
5const QUIET_START = 22, QUIET_END = 8, MAX_ATTEMPTS = 4;
6 
7function localHour(user: User, nowUtcHours: number): number {
8  return (((Math.floor(nowUtcHours) + user.utcOffset) % 24) + 24) % 24;
9}
10 
11function plan(user: User, nowUtcHours: number, urgent: boolean): "skip" | "send" | "defer" {
12  if (user.channel === "none") return "skip";
13  if (urgent) return "send";
14  const hour = localHour(user, nowUtcHours);
15  return hour >= QUIET_START || hour < QUIET_END ? "defer" : "send";
16}
17 
18function backoffSeconds(attempt: number): number {
19  return 2 ** (attempt - 1);
20}
21 
22function nextAllowedUtc(user: User, nowUtcHours: number): number {
23  const local = ((nowUtcHours + user.utcOffset) % 24 + 24) % 24;
24  return local >= 8 && local < 22 ? nowUtcHours : nowUtcHours + ((8 - local + 24) % 24);
25}
26 
27class Dispatcher {
28  private high: Message[] = [];
29  private low: Message[] = [];
30  private delivered = new Set<string>();
31  private users = new Map<string, User>();
32  private later: Array<{ at: number; message: Message }> = [];
33 
34  // Store deferred work; the caller advances UTC time in sendSecond().
35  schedule(user: User, message: Message, nowUtc: number): "skip" | "send" | "defer" {
36    const decision = plan(user, nowUtc, message.urgent);
37    if (decision === "skip") return decision;
38    this.users.set(message.key, user);
39    if (decision === "defer") this.later.push({ at: nextAllowedUtc(user, nowUtc), message });
40    else this.enqueue(message);
41    return decision;
42  }
43 
44  enqueue(message: Message): void {
45    (message.urgent ? this.high : this.low).push(message);
46  }
47 
48  // One second of sending to a provider that allows `limit` calls.
49  sendSecond(limit: number, provider: (m: Message) => boolean, nowUtc = 0): Result[] {
50    const due = this.later.filter(x => x.at <= nowUtc);
51    this.later = this.later.filter(x => x.at > nowUtc);
52    for (const x of due) this.enqueue(x.message);
53    const results: Result[] = [];
54    let calls = 0;
55    while (calls < limit) {
56      const message = this.high.shift() ?? this.low.shift();
57      if (!message) break;
58      if (this.delivered.has(message.key)) {
59        results.push("duplicate");
60        continue;
61      }
62      const user = this.users.get(message.key);
63      if (user && this.scheduleDecision(user, message, nowUtc)) {
64        results.push("deferred"); continue;
65      }
66      calls++;
67      if (!provider(message)) {
68        results.push(message.attempt < MAX_ATTEMPTS ? "retry" : "failed");
69        continue;
70      }
71      this.delivered.add(message.key);
72      results.push("sent");
73    }
74    return results;
75  }
76 
77  private scheduleDecision(user: User, message: Message, nowUtc: number): boolean {
78    if (plan(user, nowUtc, message.urgent) !== "defer") return false;
79    this.later.push({ at: nextAllowedUtc(user, nowUtc), message });
80    return true;
81  }
82}