@shivaedev/effect-github 0.0.0-stage → 0.2.0

package/dist/requests.js

@@ -0,0 +1,57 @@
+import { DateTime, Effect, Option, Redacted } from "effect";
+import { HttpClientRequest } from "effect/http";
+import { readBoundedBody } from "@shivaedev/platform/http-client/body.ts";
+import { ResponseBodyTooLarge } from "@shivaedev/platform/http-client/errors.ts";
+import { responseCache } from "./cache.js";
+import { GitHubTransportError } from "./errors.js";
+import { failRateLimited } from "./rateLimits.js";
+import { checkStatus, isUnchanged } from "./status.js";
+export function requests(client, token, rates) {
+    const cache = responseCache();
+    const accessToken = Effect.isEffect(token) ? token : Effect.succeed(token);
+    return Effect.fn("GitHub.request")(function* (input, limit) {
+        const path = new URL(input.url).pathname;
+        const resource = rates.resource(path);
+        const blocked = rates.blocked.get(resource);
+        if (blocked !== undefined && DateTime.isGreaterThan(blocked.retryAt, yield* DateTime.now)) {
+            return yield* failRateLimited(path, blocked, rates.observations.get(resource)?.remaining);
+        }
+        const key = `${input.url} ${input.headers.accept}`;
+        const cached = input.method === "GET" ? cache.get(key) : undefined;
+        const request = requestHeaders(input, cached, yield* accessToken);
+        const response = yield* client.execute(request).pipe(Effect.mapError(() => new GitHubTransportError({ path })));
+        const observedResource = rates.observe(response);
+        if (isUnchanged(response) && cached !== undefined) {
+            rates.failures.delete(observedResource);
+            rates.blocked.delete(observedResource);
+            if (cached.bytes.byteLength > limit) {
+                return yield* new ResponseBodyTooLarge({ limit });
+            }
+            return cached;
+        }
+        yield* checkStatus(response, observedResource, rates.failures.get(observedResource) ?? 0).pipe(Effect.catchTag("HttpClientError", () => Effect.fail(new GitHubTransportError({ path }))), Effect.catchTag("GitHubRateLimited", (error) => {
+            rates.blocked.set(error.resource, error);
+            rates.failures.set(error.resource, (rates.failures.get(error.resource) ?? 0) + 1);
+            return failRateLimited(path, error, rates.observations.get(error.resource)?.remaining);
+        }));
+        rates.failures.delete(observedResource);
+        rates.blocked.delete(observedResource);
+        const bytes = yield* readBoundedBody(response, limit).pipe(Effect.catchTag("HttpClientError", () => Effect.fail(new GitHubTransportError({ path }))));
+        const entry = { bytes, decoded: new Map(), response };
+        if (input.method === "GET" && response.headers.etag !== undefined) {
+            cache.set(key, entry);
+        }
+        return entry;
+    });
+}
+function requestHeaders(input, cached, token) {
+    let request = HttpClientRequest.removeHeader(input, "if-none-match").pipe(HttpClientRequest.setHeader("X-GitHub-Api-Version", "2022-11-28"));
+    if (Option.isSome(token)) {
+        request = HttpClientRequest.setHeader(request, "Authorization", `Bearer ${Redacted.value(token.value)}`);
+    }
+    if (cached?.response.headers.etag !== undefined) {
+        request = HttpClientRequest.setHeader(request, "If-None-Match", cached.response.headers.etag);
+    }
+    return request;
+}
+//# sourceMappingURL=requests.js.map

package/dist/requests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requests.js","sourceRoot":"","sources":["../src/requests.ts"],"names":[],"mappings":"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"}

package/dist/status.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { type HttpClientResponse } from "effect/http";
+import { GitHubRateLimited } from "./errors.ts";
+export declare function isUnchanged(response: HttpClientResponse.HttpClientResponse): boolean;
+export declare const checkStatus: (response: HttpClientResponse.HttpClientResponse, resource: string, failures?: any) => Effect.Effect<HttpClientResponse.HttpClientResponse, GitHubRateLimited | import("effect/http/HttpClientError").HttpClientError | import("@shivaedev/platform/http-client/errors.ts").ResponseBodyTooLarge | import("@shivaedev/platform/http-client/errors.ts").RemoteStatusError, never>;
+//# sourceMappingURL=status.d.ts.map

package/dist/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAkB,MAAM,QAAQ,CAAC;AAC1D,OAAO,EAAc,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIlE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,wBAAgB,WAAW,CAAC,QAAQ,EAAE,kBAAkB,CAAC,kBAAkB,WAE1E;AAED,eAAO,MAAM,WAAW,kXAiBtB,CAAC"}

package/dist/status.js

@@ -0,0 +1,33 @@
+import { DateTime, Effect, Option, Schema } from "effect";
+import { HttpClient } from "effect/http";
+import { readBoundedText } from "@shivaedev/platform/http-client/body.ts";
+import { filterStatus } from "@shivaedev/platform/http-client/filterStatus.ts";
+import { parseRetryAfter } from "@shivaedev/platform/http-client/parseRetryAfter.ts";
+import { GitHubRateLimited } from "./errors.js";
+export function isUnchanged(response) {
+    return response.status === 304;
+}
+export const checkStatus = Effect.fnUntraced(function* (response, resource, failures = 0) {
+    const { status, headers } = response;
+    if (status === 403 || status === 429) {
+        const limitedByHeaders = status === 429 || headers["x-ratelimit-remaining"] === "0" || headers["retry-after"] !== undefined;
+        const limitedByMessage = !limitedByHeaders && status === 403 && (yield* messageNamesRateLimit(response));
+        if (limitedByHeaders || limitedByMessage) {
+            const now = yield* DateTime.now;
+            const reset = Number(headers["x-ratelimit-reset"] ?? 0) * 1000;
+            const fallback = headers["x-ratelimit-remaining"] === "0" && reset > DateTime.toEpochMillis(now)
+                ? reset
+                : DateTime.toEpochMillis(now) + Math.min(15 * 60_000, 60_000 * 2 ** failures);
+            const retryAt = parseRetryAfter(headers["retry-after"], now) ?? DateTime.makeUnsafe(fallback);
+            return yield* new GitHubRateLimited({ resource, retryAt });
+        }
+    }
+    return yield* filterStatus(HttpClient.makeWith(() => Effect.succeed(response), Effect.succeed)).execute(response.request);
+});
+const Message = Schema.fromJsonString(Schema.Struct({ message: Schema.String }));
+const messageNamesRateLimit = Effect.fnUntraced(function* (response) {
+    const text = yield* readBoundedText(response, 64 * 1024);
+    const body = Schema.decodeUnknownOption(Message)(text);
+    return Option.isSome(body) && /rate limit/iu.test(body.value.message);
+});
+//# sourceMappingURL=status.js.map

package/dist/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"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"}

package/dist/verifyWebhook.d.ts

@@ -0,0 +1,4 @@
+import { Effect, Redacted, Schema } from "effect";
+import { GitHubWebhookSignatureError } from "./errors.ts";
+export declare const verifyWebhook: <TSchema extends Schema.Constraint>(body: Uint8Array<ArrayBufferLike>, signature: string | undefined, secret: Redacted.Redacted<string>, schema: TSchema) => Effect.Effect<TSchema["Type"], GitHubWebhookSignatureError | Schema.SchemaError, TSchema["DecodingServices"]>;
+//# sourceMappingURL=verifyWebhook.d.ts.map

package/dist/verifyWebhook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyWebhook.d.ts","sourceRoot":"","sources":["../src/verifyWebhook.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAE1D,eAAO,MAAM,aAAa,GAAgC,OAAO,SAAS,MAAM,CAAC,UAAU,wOAczF,CAAC"}

package/dist/verifyWebhook.js

@@ -0,0 +1,14 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { Effect, Redacted, Schema } from "effect";
+import { GitHubWebhookSignatureError } from "./errors.js";
+export const verifyWebhook = Effect.fnUntraced(function* (body, signature, secret, schema) {
+    if (signature === undefined || !/^sha256=[0-9a-f]{64}$/u.test(signature)) {
+        return yield* new GitHubWebhookSignatureError();
+    }
+    const expected = createHmac("sha256", Redacted.value(secret)).update(body).digest();
+    if (!timingSafeEqual(expected, Buffer.from(signature.slice(7), "hex"))) {
+        return yield* new GitHubWebhookSignatureError();
+    }
+    return yield* Schema.decodeUnknownEffect(Schema.fromJsonString(schema))(new TextDecoder().decode(body));
+});
+//# sourceMappingURL=verifyWebhook.js.map

package/dist/verifyWebhook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyWebhook.js","sourceRoot":"","sources":["../src/verifyWebhook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAE1D,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EACvD,IAAgB,EAChB,SAA6B,EAC7B,MAAiC,EACjC,MAAe;IAEf,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QAC1E,OAAO,KAAK,CAAC,CAAC,IAAI,2BAA2B,EAAE,CAAC;IACjD,CAAC;IACD,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;IACpF,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC;QACxE,OAAO,KAAK,CAAC,CAAC,IAAI,2BAA2B,EAAE,CAAC;IACjD,CAAC;IACD,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AACzG,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,73 @@
 {
   "name": "@shivaedev/effect-github",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Typed GitHub REST requests, conditional reads and resource budgets for Effect applications",
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-github#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShivaeDev/platform.git",
+    "directory": "packages/effect-github"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./src/test-support/*",
+    "#*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "exports": {
+    "./*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "README.md"
+  ],
+  "dependencies": {
+    "@shivaedev/effect-service": "0.4.1",
+    "@shivaedev/platform": "0.28.0"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.5",
+    "@effect/platform-node-shared": "4.0.5",
+    "@effect/vitest": "4.0.5",
+    "@shivaedev/effect-test": "0.8.1",
+    "@shivaedev/quality": "0.38.0",
+    "@shivaedev/test-story": "0.19.0",
+    "@types/node": "24.19.2",
+    "effect": "4.0.5",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "effect": "4.0.5"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
 }

package/src/GitHub.ts

@@ -0,0 +1,87 @@
+import { Effect, Schema, Stream } from "effect";
+import { HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/http";
+import { defineService } from "@shivaedev/effect-service/defineService.ts";
+import type { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { paginate } from "@shivaedev/platform/http-client/paginate.ts";
+import type { CachedResponse } from "./cache.ts";
+import { GitHubConfig } from "./GitHubConfig.ts";
+import { GitHubToken } from "./GitHubToken.ts";
+import { jsonResponse } from "./json.ts";
+import { rateLimits } from "./rateLimits.ts";
+import { requests } from "./requests.ts";
+
+export const GitHub = defineService({
+	id: "@shivaedev/effect-github/GitHub",
+	initialize: Effect.gen(function* () {
+		const config = yield* GitHubConfig;
+		const rates = rateLimits();
+		return {
+			apiUrl: config.apiUrl,
+			rates,
+			request: requests(yield* HttpClient.HttpClient, yield* GitHubToken, rates),
+		};
+	}),
+	methods: ({ apiUrl, rates, request }) => {
+		function get(path: string, accept = "application/vnd.github+json") {
+			return HttpClientRequest.get(new URL(path, apiUrl).href, { headers: { Accept: accept } });
+		}
+		function readRepresentation(path: string) {
+			return Effect.map(request(get(path), 1024 * 1024), jsonResponse);
+		}
+		function listRepresentations(path: string, beforeRequest?: (resource: string) => Effect.Effect<void, ServiceUnavailable>) {
+			const entries = new WeakMap<HttpClientResponse.HttpClientResponse, CachedResponse>();
+			function fetchPage(input: HttpClientRequest.HttpClientRequest) {
+				return (beforeRequest?.(rates.resource(new URL(input.url).pathname)) ?? Effect.void).pipe(
+					Effect.andThen(request(input, 1024 * 1024)),
+					Effect.map((entry) => {
+						entries.set(entry.response, entry);
+						return entry.response;
+					}),
+				);
+			}
+			const client = HttpClient.makeWith(
+				(effect: Effect.Effect<HttpClientRequest.HttpClientRequest>) => Effect.flatMap(effect, fetchPage),
+				Effect.succeed,
+			);
+			return Effect.succeed(
+				paginate(client, get(path)).pipe(
+					Stream.mapEffect((response) => Effect.fromNullishOr(entries.get(response))),
+					Stream.map(jsonResponse),
+				),
+			);
+		}
+		function writeRepresentation(method: "POST" | "PATCH", path: string, body: unknown) {
+			return HttpClientRequest.make(method)(new URL(path, apiUrl).href, { headers: { Accept: "application/vnd.github+json" } }).pipe(
+				HttpClientRequest.bodyJson(body),
+				Effect.flatMap((input) => request(input, 1024 * 1024)),
+				Effect.map(jsonResponse),
+			);
+		}
+		return {
+			bytes: (path: string, accept: string, limit: number) => Effect.map(request(get(path, accept), limit), (entry) => entry.bytes),
+			list: listRepresentations,
+			observations: () => Effect.sync(() => [...rates.observations.values()]),
+			read: readRepresentation,
+			resource: (path: string) => Effect.sync(() => rates.resource(new URL(path, apiUrl).pathname)),
+			text: (path: string, accept: string, limit: number) =>
+				Effect.map(request(get(path, accept), limit), (entry) => new TextDecoder().decode(entry.bytes)),
+			write: writeRepresentation,
+		};
+	},
+	requires: [HttpClient.HttpClient, GitHubToken],
+});
+
+export function read<TSchema extends Schema.Constraint>(path: string, schema: TSchema) {
+	return Effect.flatMap(GitHub, (github) => Effect.flatMap(github.read(path), (response) => response.decode(schema)));
+}
+
+export function list<TSchema extends Schema.Constraint>(path: string, schema: TSchema) {
+	return Stream.unwrap(Effect.flatMap(GitHub, (github) => github.list(path))).pipe(
+		Stream.mapEffect((response) => response.decode(Schema.Array(schema))),
+		Stream.flatMap(Stream.fromIterable),
+	);
+}
+
+export function write<TSchema extends Schema.Constraint>(method: "POST" | "PATCH", path: string, body: unknown, schema: TSchema) {
+	return Effect.flatMap(GitHub, (github) => Effect.flatMap(github.write(method, path, body), (response) => response.decode(schema)));
+}

package/src/GitHubConfig.ts

@@ -0,0 +1,5 @@
+import { Context } from "effect";
+
+export const GitHubConfig = Context.Reference<{ readonly apiUrl: string }>("@shivaedev/effect-github/GitHubConfig", {
+	defaultValue: () => ({ apiUrl: "https://api.github.com" }),
+});

package/src/GitHubToken.ts

@@ -0,0 +1,18 @@
+import { Config, Context, Effect, Layer, type Option, type Redacted } from "effect";
+import type { GitHubAppError } from "./errors.ts";
+
+type Token = Option.Option<Redacted.Redacted<string>>;
+
+export class GitHubToken extends Context.Service<GitHubToken, Token | Effect.Effect<Token, GitHubAppError>>()(
+	"@shivaedev/effect-github/GitHubToken",
+) {
+	static readonly fromEnv = Layer.effect(GitHubToken)(
+		Effect.gen(function* () {
+			const token = yield* Config.Redacted("GH_TOKEN").pipe(
+				Config.orElse(() => Config.Redacted("GITHUB_TOKEN")),
+				Config.option,
+			);
+			return token;
+		}),
+	);
+}

package/src/cache.ts

@@ -0,0 +1,25 @@
+import type { Schema } from "effect";
+import type { HttpClientResponse } from "effect/http";
+
+export interface CachedResponse {
+	readonly bytes: Uint8Array;
+	readonly decoded: Map<Schema.Constraint, unknown>;
+	readonly response: HttpClientResponse.HttpClientResponse;
+}
+
+export function responseCache() {
+	const entries = new Map<string, CachedResponse>();
+	return {
+		get: (key: string) => entries.get(key),
+		set(key: string, entry: CachedResponse) {
+			entries.delete(key);
+			entries.set(key, entry);
+			if (entries.size > 1000) {
+				const first = entries.keys().next();
+				if (!first.done) {
+					entries.delete(first.value);
+				}
+			}
+		},
+	};
+}

package/src/errors.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+
+export class GitHubRateLimited extends Schema.TaggedError<GitHubRateLimited>()("GitHubRateLimited", {
+	resource: Schema.String,
+	retryAt: Schema.DateTimeUtc,
+}) {}
+
+export class GitHubTransportError extends Schema.TaggedError<GitHubTransportError>()("GitHubTransportError", {
+	path: Schema.String,
+}) {}
+
+export class GitHubAppError extends Schema.TaggedError<GitHubAppError>()("GitHubAppError", {
+	stage: Schema.Literals(["sign", "exchange"]),
+	status: Schema.optional(Schema.Number),
+}) {}
+
+export class GitHubWebhookSignatureError extends Schema.TaggedError<GitHubWebhookSignatureError>()("GitHubWebhookSignatureError", {}) {}

package/src/githubApp.ts

@@ -0,0 +1,66 @@
+import { sign } from "node:crypto";
+import { Clock, Effect, Exit, Layer, Option, Redacted, Schema } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { readBoundedJson } from "@shivaedev/platform/http-client/body.ts";
+import { GitHubAppError } from "./errors.ts";
+import { GitHubConfig } from "./GitHubConfig.ts";
+import { GitHubToken } from "./GitHubToken.ts";
+
+export type GitHubAppOptions = {
+	readonly appId: string;
+	readonly privateKey: Redacted.Redacted<string>;
+} & ({ readonly installationId: number } | { readonly owner: string; readonly repository: string });
+
+const Installation = Schema.Struct({ id: Schema.Number });
+const AccessToken = Schema.Struct({ expiresAt: Schema.DateFromString, token: Schema.RedactedFromValue(Schema.String) }).pipe(
+	Schema.encodeKeys({ expiresAt: "expires_at" }),
+);
+
+export function githubApp(options: GitHubAppOptions) {
+	return Layer.effect(GitHubToken)(
+		Effect.gen(function* () {
+			const client = yield* HttpClient.HttpClient;
+			const { apiUrl } = yield* GitHubConfig;
+			const clock = yield* Clock.Clock;
+			let installationId = "installationId" in options ? options.installationId : undefined;
+			const request = appRequests(client, apiUrl);
+			const exchange = Effect.gen(function* () {
+				const now = Math.floor((yield* Clock.currentTimeMillis) / 1000);
+				const jwt = yield* Effect.try({
+					catch: () => new GitHubAppError({ stage: "sign" }),
+					try: () => {
+						const header = Buffer.from(JSON.stringify({ alg: "RS256", typ: "JWT" })).toString("base64url");
+						const payload = Buffer.from(JSON.stringify({ exp: now + 600, iat: now - 60, iss: options.appId })).toString("base64url");
+						const input = `${header}.${payload}`;
+						return `${input}.${sign("RSA-SHA256", Buffer.from(input), Redacted.value(options.privateKey)).toString("base64url")}`;
+					},
+				});
+				if (installationId === undefined && "owner" in options) {
+					const path = `/repos/${encodeURIComponent(options.owner)}/${encodeURIComponent(options.repository)}/installation`;
+					installationId = (yield* request("GET", path, jwt, Installation)).id;
+				}
+				return yield* request("POST", `/app/installations/${installationId}/access_tokens`, jwt, AccessToken);
+			});
+			const cached = yield* Effect.cachedWithTTL(exchange, (exit) =>
+				Exit.isSuccess(exit) ? Math.max(0, exit.value.expiresAt.getTime() - clock.currentTimeMillisUnsafe() - 300_000) : 0,
+			);
+			return Effect.map(cached, ({ token }) => Option.some(token));
+		}),
+	);
+}
+
+function appRequests(client: HttpClient.HttpClient, apiUrl: string) {
+	return Effect.fnUntraced(function* <TSchema extends Schema.Constraint>(method: "GET" | "POST", path: string, jwt: string, schema: TSchema) {
+		const response = yield* client
+			.execute(
+				HttpClientRequest.make(method)(new URL(path, apiUrl).href, {
+					headers: { Accept: "application/vnd.github+json", Authorization: `Bearer ${jwt}`, "X-GitHub-Api-Version": "2022-11-28" },
+				}),
+			)
+			.pipe(Effect.mapError(() => new GitHubAppError({ stage: "exchange" })));
+		if (response.status < 200 || response.status >= 300) {
+			return yield* new GitHubAppError({ stage: "exchange", status: response.status });
+		}
+		return yield* readBoundedJson(response, 64 * 1024, schema).pipe(Effect.mapError(() => new GitHubAppError({ stage: "exchange" })));
+	});
+}

package/src/json.ts

@@ -0,0 +1,16 @@
+import { Effect, Schema } from "effect";
+import type { CachedResponse } from "./cache.ts";
+
+export const decodeJson = Effect.fnUntraced(function* <TSchema extends Schema.Constraint>(entry: CachedResponse, schema: TSchema) {
+	const cached = entry.decoded.get(schema);
+	if (entry.decoded.has(schema) && Schema.is(schema)(cached)) {
+		return cached;
+	}
+	const value = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(schema))(new TextDecoder().decode(entry.bytes));
+	entry.decoded.set(schema, value);
+	return value;
+});
+
+export function jsonResponse(entry: CachedResponse) {
+	return { decode: <TSchema extends Schema.Constraint>(schema: TSchema) => decodeJson(entry, schema) };
+}

package/src/rateLimits.ts

@@ -0,0 +1,56 @@
+import { Clock, DateTime, Effect } from "effect";
+import type { HttpClientResponse } from "effect/http";
+import type { GitHubRateLimited } from "./errors.ts";
+
+export interface RateLimitObservation {
+	readonly limit: number;
+	readonly remaining: number;
+	readonly reset: DateTime.Utc;
+	readonly resource: string;
+	readonly used: number;
+}
+
+export function rateLimits() {
+	const observations = new Map<string, RateLimitObservation>();
+	const blocked = new Map<string, GitHubRateLimited>();
+	const failures = new Map<string, number>();
+	const resources = new Map<string, string>();
+	function resource(path: string) {
+		return resources.get(path) ?? (path.startsWith("/search/") ? "search" : "core");
+	}
+	return {
+		blocked,
+		failures,
+		observations,
+		observe(response: HttpClientResponse.HttpClientResponse) {
+			const headers = response.headers;
+			const path = new URL(response.request.url).pathname;
+			const name = headers["x-ratelimit-resource"] ?? resource(path);
+			resources.set(path, name);
+			const values = ["limit", "remaining", "used", "reset"].map((key) => headers[`x-ratelimit-${key}`]);
+			if (values.every((value) => value !== undefined && Number.isFinite(Number(value)))) {
+				observations.set(name, {
+					limit: Number(headers["x-ratelimit-limit"]),
+					remaining: Number(headers["x-ratelimit-remaining"]),
+					reset: DateTime.makeUnsafe(Number(headers["x-ratelimit-reset"]) * 1000),
+					resource: name,
+					used: Number(headers["x-ratelimit-used"]),
+				});
+			}
+			return name;
+		},
+		resource,
+	};
+}
+
+export type RateLimits = ReturnType<typeof rateLimits>;
+
+export const failRateLimited = Effect.fnUntraced(function* (path: string, error: GitHubRateLimited, remaining: number | undefined) {
+	const fields = { path, remaining, resource: error.resource, retryAt: DateTime.formatIso(error.retryAt) };
+	yield* Effect.logWarning("GitHub rate limited", fields);
+	const span = yield* Effect.currentSpan.pipe(Effect.option);
+	if (span._tag === "Some") {
+		span.value.event("GitHub.rateLimited", yield* Clock.currentTimeNanos, fields);
+	}
+	return yield* error;
+});

package/src/requests.ts

@@ -0,0 +1,68 @@
+import { DateTime, Effect, Option, Redacted } from "effect";
+import { type HttpClient, HttpClientRequest } from "effect/http";
+import { readBoundedBody } from "@shivaedev/platform/http-client/body.ts";
+import { ResponseBodyTooLarge } from "@shivaedev/platform/http-client/errors.ts";
+import { type CachedResponse, responseCache } from "./cache.ts";
+import { GitHubTransportError } from "./errors.ts";
+import type { GitHubToken } from "./GitHubToken.ts";
+import { failRateLimited, type RateLimits } from "./rateLimits.ts";
+import { checkStatus, isUnchanged } from "./status.ts";
+
+export function requests(client: HttpClient.HttpClient, token: GitHubToken["Service"], rates: RateLimits) {
+	const cache = responseCache();
+	const accessToken = Effect.isEffect(token) ? token : Effect.succeed(token);
+	return Effect.fn("GitHub.request")(function* (input: HttpClientRequest.HttpClientRequest, limit: number) {
+		const path = new URL(input.url).pathname;
+		const resource = rates.resource(path);
+		const blocked = rates.blocked.get(resource);
+		if (blocked !== undefined && DateTime.isGreaterThan(blocked.retryAt, yield* DateTime.now)) {
+			return yield* failRateLimited(path, blocked, rates.observations.get(resource)?.remaining);
+		}
+		const key = `${input.url} ${input.headers.accept}`;
+		const cached = input.method === "GET" ? cache.get(key) : undefined;
+		const request = requestHeaders(input, cached, yield* accessToken);
+		const response = yield* client.execute(request).pipe(Effect.mapError(() => new GitHubTransportError({ path })));
+		const observedResource = rates.observe(response);
+		if (isUnchanged(response) && cached !== undefined) {
+			rates.failures.delete(observedResource);
+			rates.blocked.delete(observedResource);
+			if (cached.bytes.byteLength > limit) {
+				return yield* new ResponseBodyTooLarge({ limit });
+			}
+			return cached;
+		}
+		yield* checkStatus(response, observedResource, rates.failures.get(observedResource) ?? 0).pipe(
+			Effect.catchTag("HttpClientError", () => Effect.fail(new GitHubTransportError({ path }))),
+			Effect.catchTag("GitHubRateLimited", (error) => {
+				rates.blocked.set(error.resource, error);
+				rates.failures.set(error.resource, (rates.failures.get(error.resource) ?? 0) + 1);
+				return failRateLimited(path, error, rates.observations.get(error.resource)?.remaining);
+			}),
+		);
+		rates.failures.delete(observedResource);
+		rates.blocked.delete(observedResource);
+		const bytes = yield* readBoundedBody(response, limit).pipe(
+			Effect.catchTag("HttpClientError", () => Effect.fail(new GitHubTransportError({ path }))),
+		);
+		const entry: CachedResponse = { bytes, decoded: new Map(), response };
+		if (input.method === "GET" && response.headers.etag !== undefined) {
+			cache.set(key, entry);
+		}
+		return entry;
+	});
+}
+
+function requestHeaders(
+	input: HttpClientRequest.HttpClientRequest,
+	cached: CachedResponse | undefined,
+	token: Option.Option<Redacted.Redacted<string>>,
+) {
+	let request = HttpClientRequest.removeHeader(input, "if-none-match").pipe(HttpClientRequest.setHeader("X-GitHub-Api-Version", "2022-11-28"));
+	if (Option.isSome(token)) {
+		request = HttpClientRequest.setHeader(request, "Authorization", `Bearer ${Redacted.value(token.value)}`);
+	}
+	if (cached?.response.headers.etag !== undefined) {
+		request = HttpClientRequest.setHeader(request, "If-None-Match", cached.response.headers.etag);
+	}
+	return request;
+}

package/src/status.ts

@@ -0,0 +1,37 @@
+import { DateTime, Effect, Option, Schema } from "effect";
+import { HttpClient, type HttpClientResponse } from "effect/http";
+import { readBoundedText } from "@shivaedev/platform/http-client/body.ts";
+import { filterStatus } from "@shivaedev/platform/http-client/filterStatus.ts";
+import { parseRetryAfter } from "@shivaedev/platform/http-client/parseRetryAfter.ts";
+import { GitHubRateLimited } from "./errors.ts";
+
+export function isUnchanged(response: HttpClientResponse.HttpClientResponse) {
+	return response.status === 304;
+}
+
+export const checkStatus = Effect.fnUntraced(function* (response: HttpClientResponse.HttpClientResponse, resource: string, failures = 0) {
+	const { status, headers } = response;
+	if (status === 403 || status === 429) {
+		const limitedByHeaders = status === 429 || headers["x-ratelimit-remaining"] === "0" || headers["retry-after"] !== undefined;
+		const limitedByMessage = !limitedByHeaders && status === 403 && (yield* messageNamesRateLimit(response));
+		if (limitedByHeaders || limitedByMessage) {
+			const now = yield* DateTime.now;
+			const reset = Number(headers["x-ratelimit-reset"] ?? 0) * 1000;
+			const fallback =
+				headers["x-ratelimit-remaining"] === "0" && reset > DateTime.toEpochMillis(now)
+					? reset
+					: DateTime.toEpochMillis(now) + Math.min(15 * 60_000, 60_000 * 2 ** failures);
+			const retryAt = parseRetryAfter(headers["retry-after"], now) ?? DateTime.makeUnsafe(fallback);
+			return yield* new GitHubRateLimited({ resource, retryAt });
+		}
+	}
+	return yield* filterStatus(HttpClient.makeWith(() => Effect.succeed(response), Effect.succeed)).execute(response.request);
+});
+
+const Message = Schema.fromJsonString(Schema.Struct({ message: Schema.String }));
+
+const messageNamesRateLimit = Effect.fnUntraced(function* (response: HttpClientResponse.HttpClientResponse) {
+	const text = yield* readBoundedText(response, 64 * 1024);
+	const body = Schema.decodeUnknownOption(Message)(text);
+	return Option.isSome(body) && /rate limit/iu.test(body.value.message);
+});