Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

GitHubQuota.ts

100 lines3.6 KB

1import { SourceControlProviderKind } from "@t3tools/contracts";
2import * as Clock from "effect/Clock";
3import * as Context from "effect/Context";
4import * as Effect from "effect/Effect";
5import * as Layer from "effect/Layer";
6import * as Ref from "effect/Ref";
7​
8import * as SourceControlRateLimit from "@t3tools/source-control-core/server/SourceControlRateLimit";
9​
10const RESERVE_RATIO = 0.1;
11​
12type GitHubQuotaResource = string;
13​
14interface QuotaSnapshot {
15 readonly limit: number;
16 readonly remaining: number;
17 readonly resetAtMs: number;
19​
20function quotaFromHeaders(
21 headers: Readonly<Record<string, string | undefined>>,
22): (QuotaSnapshot & { readonly resource: GitHubQuotaResource }) | null {
23 const resource = headers["x-ratelimit-resource"]?.trim();
24 const limit = Number(headers["x-ratelimit-limit"]);
25 const remaining = Number(headers["x-ratelimit-remaining"]);
26 const reset = Number(headers["x-ratelimit-reset"]);
27 if (
28 !resource ||
29 !Number.isFinite(limit) ||
30 limit <= 0 ||
31 !Number.isFinite(remaining) ||
32 remaining < 0 ||
33 !Number.isFinite(reset)
34 ) {
35 return null;
36 }
37 return { resource, limit, remaining, resetAtMs: reset * 1_000 };
39​
40/** Local debits would drift: 304s and requests that never reach GitHub spend nothing. */
41export class GitHubQuota extends Context.Service<
42 GitHubQuota,
43 {
44 readonly admit: (
45 host: string,
46 resource: GitHubQuotaResource,
47 options?: { readonly allowReserve: boolean },
48 ) => Effect.Effect<void, SourceControlRateLimit.SourceControlRateLimitPausedError>;
49 readonly observe: (
50 host: string,
51 headers: Readonly<Record<string, string | undefined>>,
52 ) => Effect.Effect<void>;
53 }
54>()("@t3tools/source-control-github/server/GitHubQuota") {}
55​
56const make = Effect.gen(function* () {
57 const snapshots = yield* Ref.make<ReadonlyMap<string, QuotaSnapshot>>(new Map());
58 const keyOf = (host: string, resource: string, scope: string) =>
59 `${host.trim().toLowerCase()}\0${resource}\0${scope}`;
60​
61 const admit: GitHubQuota["Service"]["admit"] = Effect.fn("GitHubQuota.admit")(
62 function* (host, resource, options) {
63 const now = yield* Clock.currentTimeMillis;
64 const key = keyOf(host, resource, yield* SourceControlRateLimit.CredentialScope);
65 const snapshot = (yield* Ref.get(snapshots)).get(key);
66 if (snapshot === undefined || snapshot.resetAtMs <= now) return;
67 const floor = options?.allowReserve === true ? 1 : snapshot.limit * RESERVE_RATIO;
68 if (snapshot.remaining >= floor) return;
69 return yield* new SourceControlRateLimit.SourceControlRateLimitPausedError({
70 provider: SourceControlProviderKind.make("github"),
71 host: host.trim().toLowerCase(),
72 retryAt: snapshot.resetAtMs,
73 });
74 },
75 );
76​
77 const observe: GitHubQuota["Service"]["observe"] = Effect.fn("GitHubQuota.observe")(
78 function* (host, headers) {
79 const quota = quotaFromHeaders(headers);
80 if (quota === null) return;
81 const key = keyOf(host, quota.resource, yield* SourceControlRateLimit.CredentialScope);
82 yield* Ref.update(snapshots, (current) => {
83 const previous = current.get(key);
84 // Regional responses can increase the balance within a window.
85 if (previous !== undefined && quota.resetAtMs < previous.resetAtMs) return current;
86 const next = new Map(current);
87 next.set(key, {
88 limit: quota.limit,
89 remaining: quota.remaining,
90 resetAtMs: quota.resetAtMs,
91 });
92 return next;
93 });
94 },
95 );
96​
97 return GitHubQuota.of({ admit, observe });
98});
99​
100export const layer = Layer.effect(GitHubQuota, make);