@shivaedev/github 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/github",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Typed GitHub REST requests, conditional reads and resource budgets for Effect applications",
   "keywords": [
     "effect"
@@ -43,17 +43,17 @@
     "README.md"
   ],
   "dependencies": {
-    "@shivaedev/errors": "0.5.0",
-    "@shivaedev/http": "0.4.0",
+    "@shivaedev/errors": "0.6.0",
+    "@shivaedev/http": "0.5.0",
     "@shivaedev/service": "0.6.1"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.6",
     "@effect/platform-node-shared": "4.0.6",
     "@effect/vitest": "4.0.6",
-    "@shivaedev/quality": "0.56.0",
-    "@shivaedev/test": "0.13.0",
-    "@shivaedev/test-story": "0.34.0",
+    "@shivaedev/quality": "0.57.0",
+    "@shivaedev/test": "0.14.0",
+    "@shivaedev/test-story": "0.35.0",
     "@types/node": "24.19.2",
     "@zip.js/zip.js": "2.24.0",
     "effect": "4.0.6",

package/src/GitHub.ts

@@ -1,6 +1,8 @@
 import { Effect, Schema, Stream } from "effect";
 import { HttpClient } from "effect/http";
+import type { ServiceUnavailable } from "@shivaedev/errors/taxonomy.ts";
 import { defineService } from "@shivaedev/service/defineService.ts";
+import { genericMethod } from "@shivaedev/service/genericMethod.ts";
 import { artifacts } from "#artifacts.ts";
 import { checkRuns } from "#checkRuns.ts";
 import { GitHubConfig } from "#GitHubConfig.ts";
@@ -11,33 +13,34 @@ import { repositoryReads } from "#repositoryReads.ts";
 import { representations } from "#representations.ts";
 import { requests } from "#requests.ts";
 import { stickyComments } from "#stickyComments.ts";
-import { TokenRefresh } from "#TokenRefresh.ts";
 
 export const GitHub = defineService({
 	id: "@shivaedev/github/GitHub",
 	initialize: Effect.gen(function* () {
 		const config = yield* GitHubConfig;
 		const rates = rateLimits();
-		const client = yield* HttpClient.HttpClient;
-		const token = yield* GitHubToken;
-		const refresh = yield* TokenRefresh;
 		return {
 			apiUrl: config.apiUrl,
 			archive: yield* artifacts(config.apiUrl, rates),
 			rates,
-			request: requests(client, token, rates, refresh),
+			request: yield* requests(rates),
 			responseByteLimit: config.responseByteLimit,
 		};
 	}),
 	methods: ({ apiUrl, archive, rates, request, responseByteLimit }) => {
 		const { get, ...client } = representations(apiUrl, request, rates.resource, responseByteLimit);
+		const reads = repositoryReads(client);
 		return {
 			bytes: (path: string, accept: string, limit: number) => Effect.map(request(get(path, accept), limit), (entry) => entry.bytes),
 			...client,
+			list: genericMethod(client.list),
 			...archive,
 			...stickyComments(client),
 			...checkRuns(client),
-			...repositoryReads(client),
+			...reads,
+			listCommits: genericMethod(reads.listCommits),
+			listIssues: genericMethod(reads.listIssues),
+			listPullRequestFiles: genericMethod(reads.listPullRequestFiles),
 			observations: () => Effect.sync(() => [...rates.observations.values()]),
 			resource: (path: string) => Effect.sync(() => rates.resource(new URL(path, apiUrl).pathname)),
 			text: (path: string, accept: string, limit: number) =>
@@ -51,15 +54,24 @@ export function read<TSchema extends Schema.Constraint>(path: string, schema: TS
 	return Effect.flatMap(GitHub, (github) => Effect.flatMap(github.read(path, responseByteLimit), (response) => response.decode(schema)));
 }
 
-export function listPages<TSchema extends Schema.Constraint>(path: string, schema: TSchema, options?: ListOptions | number) {
+export function listPages<TSchema extends Schema.Constraint, E = ServiceUnavailable>(
+	path: string,
+	schema: TSchema,
+	options?: ListOptions<E> | number,
+) {
 	return Stream.unwrap(Effect.map(GitHub, (github) => decodedPages(github, path, schema, options)));
 }
 
-export function list<TSchema extends Schema.Constraint>(path: string, schema: TSchema, options?: ListOptions | number) {
+export function list<TSchema extends Schema.Constraint, E = ServiceUnavailable>(path: string, schema: TSchema, options?: ListOptions<E> | number) {
 	return listPages(path, schema, options).pipe(Stream.flatMap((page) => Stream.fromIterable(page.items)));
 }
 
-export function listBounded<TSchema extends Schema.Constraint>(path: string, schema: TSchema, pageCap: number, options?: ListOptions | number) {
+export function listBounded<TSchema extends Schema.Constraint, E = ServiceUnavailable>(
+	path: string,
+	schema: TSchema,
+	pageCap: number,
+	options?: ListOptions<E> | number,
+) {
 	return listPages(path, schema, options).pipe(
 		Stream.take(pageCap),
 		Stream.runCollect,

package/src/adapters/manualRedirects.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { FetchHttpClient } from "effect/http";
+
+export function manualRedirects<A, E, R>(request: Effect.Effect<A, E, R>) {
+	return request.pipe(Effect.provideService(FetchHttpClient.RequestInit, { credentials: "omit", redirect: "manual" }));
+}

package/src/adapters/mergeResponseHeaders.ts

@@ -0,0 +1,8 @@
+import { HttpClientResponse } from "effect/http";
+
+export function mergeResponseHeaders(cached: HttpClientResponse.HttpClientResponse, response: HttpClientResponse.HttpClientResponse) {
+	return HttpClientResponse.fromWeb(
+		response.request,
+		new Response(null, { headers: { ...cached.headers, ...response.headers }, status: response.status }),
+	);
+}

package/src/adapters/signAppJwt.ts

@@ -0,0 +1,16 @@
+import { sign } from "node:crypto";
+import { Effect, Redacted } from "effect";
+import type { AppCredentials } from "#appJwt.ts";
+import { GitHubAppError } from "#errors.ts";
+
+export function signAppJwt(options: AppCredentials, now: number) {
+	return Effect.try({
+		catch: (cause) => new GitHubAppError({ reason: "sign" }, { cause }),
+		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 Redacted.make(`${input}.${sign("RSA-SHA256", Buffer.from(input), Redacted.value(options.privateKey)).toString("base64url")}`);
+		},
+	});
+}

package/src/adapters/verifySignature.ts

@@ -0,0 +1,13 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { Effect, Redacted } from "effect";
+import { GitHubWebhookSignatureError } from "#errors.ts";
+
+export const verifySignature = Effect.fnUntraced(function* (body: Uint8Array, signature: string | undefined, secret: Redacted.Redacted<string>) {
+	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();
+	}
+});

package/src/appJwt.ts

@@ -1,6 +1,5 @@
-import { sign } from "node:crypto";
-import { Clock, Effect, Redacted } from "effect";
-import { GitHubAppError } from "#errors.ts";
+import { Clock, Effect, type Redacted } from "effect";
+import { signAppJwt } from "#adapters/signAppJwt.ts";
 
 export interface AppCredentials {
 	readonly appId: string;
@@ -9,13 +8,5 @@ export interface AppCredentials {
 
 export const appJwt = Effect.fnUntraced(function* (options: AppCredentials) {
 	const now = Math.floor((yield* Clock.currentTimeMillis) / 1000);
-	return yield* Effect.try({
-		catch: (cause) => new GitHubAppError({ reason: "sign" }, { cause }),
-		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 Redacted.make(`${input}.${sign("RSA-SHA256", Buffer.from(input), Redacted.value(options.privateKey)).toString("base64url")}`);
-		},
-	});
+	return yield* signAppJwt(options, now);
 });

package/src/artifacts.ts

@@ -1,9 +1,10 @@
 import { Effect } from "effect";
-import { FetchHttpClient, HttpClient, type HttpClientError, HttpClientRequest } from "effect/http";
+import { HttpClient, type HttpClientError, HttpClientRequest } from "effect/http";
 import * as HttpStatus from "effect/http/HttpStatus";
 import { readBoundedBody } from "@shivaedev/http/body.ts";
 import type { RemoteStatusError } from "@shivaedev/http/errors.ts";
 import { filterStatus } from "@shivaedev/http/filterStatus.ts";
+import { manualRedirects } from "#adapters/manualRedirects.ts";
 import { resolveApiUrl } from "#adapters/resolveApiUrl.ts";
 import { type ArtifactExtractionOptions, extractArtifactArchive } from "#artifactExtraction.ts";
 import { authenticatedRequest } from "#authenticatedRequest.ts";
@@ -44,10 +45,7 @@ export const artifacts = Effect.fn("GitHub.artifacts")(function* (apiUrl: string
 			if (redirect.status !== HttpStatus.fromLiteral("Found") || location === undefined) {
 				return yield* new GitHubArtifactError({ stage: "redirect", status: redirect.status });
 			}
-			const response = yield* download.get(location).pipe(
-				Effect.provideService(FetchHttpClient.RequestInit, { credentials: "omit", redirect: "manual" }),
-				Effect.mapError((cause) => downloadFailure(path, cause)),
-			);
+			const response = yield* manualRedirects(download.get(location)).pipe(Effect.mapError((cause) => downloadFailure(path, cause)));
 			return yield* readBoundedBody(response, options.byteLimit).pipe(
 				Effect.catchTags({
 					HttpClientError: (cause) => Effect.fail(new GitHubTransportError({ path }, { cause })),

package/src/authenticatedRequest.ts

@@ -1,11 +1,12 @@
 import { DateTime, Effect, Option, Redacted, Stream } from "effect";
-import { FetchHttpClient, type HttpClient, type HttpClientError, HttpClientRequest } from "effect/http";
+import { type HttpClient, type HttpClientError, HttpClientRequest } from "effect/http";
 import * as HttpStatus from "effect/http/HttpStatus";
-import { GitHubTransportError } from "./errors.ts";
-import type { GitHubToken } from "./GitHubToken.ts";
-import { failRateLimited, type RateLimits } from "./rateLimits.ts";
-import { checkStatus, isUnauthorized, isUnchanged } from "./status.ts";
-import type { TokenRefresh } from "./TokenRefresh.ts";
+import { manualRedirects } from "#adapters/manualRedirects.ts";
+import { GitHubTransportError } from "#errors.ts";
+import type { GitHubToken } from "#GitHubToken.ts";
+import { failRateLimited, type RateLimits } from "#rateLimits.ts";
+import { checkStatus, isUnauthorized, isUnchanged } from "#status.ts";
+import type { TokenRefresh } from "#TokenRefresh.ts";
 
 export function authenticatedRequest<R>(
 	client: HttpClient.HttpClient.With<HttpClientError.HttpClientError, R>,
@@ -23,9 +24,7 @@ export function authenticatedRequest<R>(
 		}
 		function send(current: Option.Option<Redacted.Redacted<string>>) {
 			const sent = client.execute(withCredential(input, current));
-			return (
-				mode === "manual" ? sent.pipe(Effect.provideService(FetchHttpClient.RequestInit, { credentials: "omit", redirect: "manual" })) : sent
-			).pipe(Effect.mapError((cause) => new GitHubTransportError({ path }, { cause })));
+			return (mode === "manual" ? manualRedirects(sent) : sent).pipe(Effect.mapError((cause) => new GitHubTransportError({ path }, { cause })));
 		}
 		const credential = yield* accessToken;
 		let response = yield* send(credential);

package/src/cache.ts

@@ -1,5 +1,6 @@
 import type { Schema } from "effect";
 import type { HttpClientResponse } from "effect/http";
+import { mergeResponseHeaders } from "#adapters/mergeResponseHeaders.ts";
 
 export interface CachedResponse {
 	readonly bytes: Uint8Array;
@@ -9,7 +10,7 @@ export interface CachedResponse {
 }
 
 export function revalidatedResponse(cached: CachedResponse, response: HttpClientResponse.HttpClientResponse): CachedResponse {
-	return { ...cached, etag: response.headers.etag ?? cached.etag, response };
+	return { ...cached, etag: response.headers.etag ?? cached.etag, response: mergeResponseHeaders(cached.response, response) };
 }
 
 export function responseCache() {

package/src/errors.ts

@@ -1,5 +1,11 @@
 import { Schema } from "effect";
 
+export class GitHubAddressInvalid extends Schema.TaggedError<GitHubAddressInvalid>()("GitHubAddressInvalid", {}) {}
+
+export class MarkdownBudgetTooSmall extends Schema.TaggedError<MarkdownBudgetTooSmall>()("MarkdownBudgetTooSmall", {
+	byteLimit: Schema.Number,
+}) {}
+
 export class GitHubPermissionDenied extends Schema.TaggedError<GitHubPermissionDenied>()("GitHubPermissionDenied", {
 	path: Schema.String,
 }) {}

package/src/markdown.ts

@@ -23,3 +23,7 @@ export function tableCell(text: string, format: "text" | "code" = "text"): strin
 	const content = text.replace(/\r\n|[\r\n\u2028\u2029]/gu, " ");
 	return format === "code" ? codeSpan(content.replaceAll("|", "\\|")) : plainText(content);
 }
+
+export function details(summary: string, text: string): string {
+	return `<details>\n<summary>${plainText(summary)}</summary>\n\n${plainText(text)}\n\n</details>`;
+}

package/src/markdownRows.ts

@@ -1,9 +1,45 @@
+import { Result } from "effect";
+import { MarkdownBudgetTooSmall } from "./errors.ts";
+
 export interface MarkdownRowsOptions {
 	readonly byteLimit?: number;
 	readonly header?: string;
 }
 
-export function renderRows(rows: readonly string[], { byteLimit = 60_000, header = "" }: MarkdownRowsOptions = {}): string {
+export interface MarkdownRowsSection {
+	readonly header?: string;
+	readonly rows: readonly string[];
+}
+
+export function renderRows(
+	rows: readonly string[],
+	{ byteLimit = 60_000, header = "" }: MarkdownRowsOptions = {},
+): Result.Result<string, MarkdownBudgetTooSmall> {
+	return prepareRows({ header, rows }).render(byteLimit);
+}
+
+export function renderSections(
+	sections: readonly MarkdownRowsSection[],
+	{ byteLimit = 60_000 }: Pick<MarkdownRowsOptions, "byteLimit"> = {},
+): Result.Result<string, MarkdownBudgetTooSmall> {
+	const prepared = sections.filter(({ rows, header = "" }) => rows.length > 0 || header !== "").map(prepareRows);
+	let reserved = prepared.reduce((total, section) => total + section.minimumBytes, 0) + Math.max(0, prepared.length - 1) * 2;
+	let remaining = byteLimit;
+	const bodies: string[] = [];
+	for (const section of prepared) {
+		reserved -= section.minimumBytes;
+		const body = section.render(remaining - reserved);
+		if (Result.isFailure(body)) {
+			return Result.fail(new MarkdownBudgetTooSmall({ byteLimit }));
+		}
+		bodies.push(body.success);
+		remaining -= new TextEncoder().encode(body.success).byteLength + 2;
+		reserved -= 2;
+	}
+	return Result.succeed(bodies.join("\n\n"));
+}
+
+function prepareRows({ rows, header = "" }: MarkdownRowsSection) {
 	const encoder = new TextEncoder();
 	const sizes = [0];
 	for (const row of rows) {
@@ -16,15 +52,24 @@ export function renderRows(rows: readonly string[], { byteLimit = 60_000, header
 	function body(kept: number) {
 		return [...(header === "" ? [] : [header]), ...rows.slice(0, kept)].join("\n");
 	}
-	if (bodySize(rows.length) <= byteLimit) {
-		return body(rows.length);
-	}
-	for (let kept = rows.length - 1; kept >= 0; kept -= 1) {
+	function omitted(kept: number) {
 		const notice = `and ${rows.length - kept} more`;
 		const separator = kept > 0 || header !== "" ? "\n\n" : "";
-		if (bodySize(kept) + separator.length + encoder.encode(notice).byteLength <= byteLimit) {
-			return body(kept) + separator + notice;
-		}
+		return { bytes: bodySize(kept) + separator.length + encoder.encode(notice).byteLength, notice, separator };
 	}
-	throw new RangeError("The byte limit must fit the header and omitted-row notice");
+	return {
+		minimumBytes: rows.length === 0 ? headerBytes : Math.min(bodySize(rows.length), omitted(0).bytes),
+		render(byteLimit: number): Result.Result<string, MarkdownBudgetTooSmall> {
+			if (bodySize(rows.length) <= byteLimit) {
+				return Result.succeed(body(rows.length));
+			}
+			for (let kept = rows.length - 1; kept >= 0; kept -= 1) {
+				const { notice, separator, bytes } = omitted(kept);
+				if (bytes <= byteLimit) {
+					return Result.succeed(body(kept) + separator + notice);
+				}
+			}
+			return Result.fail(new MarkdownBudgetTooSmall({ byteLimit }));
+		},
+	};
 }

package/src/pagedLists.ts

@@ -2,18 +2,18 @@ import { Effect, Option, Schema, Stream } from "effect";
 import type { ServiceUnavailable } from "@shivaedev/errors/taxonomy.ts";
 import type { Representations } from "#representations.ts";
 
-export interface ListOptions {
+export interface ListOptions<E = ServiceUnavailable> {
 	readonly arrayKey?: string | undefined;
-	readonly beforeRequest?: (resource: string) => Effect.Effect<void, ServiceUnavailable>;
+	readonly beforeRequest?: (resource: string) => Effect.Effect<void, E>;
 	readonly onDecodeError?: "fail" | "skip" | undefined;
 	readonly responseByteLimit?: number | undefined;
 }
 
-export function decodedPages<TSchema extends Schema.Constraint>(
+export function decodedPages<TSchema extends Schema.Constraint, E = ServiceUnavailable>(
 	client: Representations,
 	path: string,
 	schema: TSchema,
-	options: ListOptions | number = {},
+	options: ListOptions<E> | number = {},
 ) {
 	const settings = typeof options === "number" ? { responseByteLimit: options } : options;
 	const decode = Schema.decodeUnknownEffect(schema);

package/src/repositoryAddress.ts

@@ -0,0 +1,32 @@
+import { Result } from "effect";
+import { GitHubAddressInvalid } from "./errors.ts";
+
+export interface RepositoryAddress {
+	readonly kind: "remote" | "shorthand" | "pull-request";
+	readonly name: string;
+	readonly number: number | undefined;
+	readonly owner: string;
+	readonly repository: string;
+}
+
+const REPOSITORY =
+	/^(?:(?<remote>(?:git\+)?(?:https?:\/\/github\.com\/|ssh:\/\/git@github\.com\/|git:\/\/github\.com\/|git@github\.com:))|github:)?(?<owner>[A-Za-z0-9-]+)\/(?<name>[\w.-]+?)(?:\.git)?\/?$/u;
+const PULL_REQUEST = /^https:\/\/github\.com\/(?<owner>[A-Za-z0-9-]+)\/(?<name>[\w.-]+)\/pull\/(?<number>[1-9]\d*)$/u;
+
+export function parseRepositoryAddress(address: string): Result.Result<RepositoryAddress, GitHubAddressInvalid> {
+	const input = address.trim();
+	const groups = (PULL_REQUEST.exec(input) ?? REPOSITORY.exec(input))?.groups;
+	const owner = groups?.owner;
+	const name = groups?.name;
+	const number = groups?.number === undefined ? undefined : Number(groups.number);
+	if (owner === undefined || name === undefined || name === "." || name === ".." || (number !== undefined && !Number.isSafeInteger(number))) {
+		return Result.fail(new GitHubAddressInvalid({}));
+	}
+	let kind: RepositoryAddress["kind"] = "shorthand";
+	if (number !== undefined) {
+		kind = "pull-request";
+	} else if (groups?.remote !== undefined) {
+		kind = "remote";
+	}
+	return Result.succeed({ kind, name, number, owner, repository: `${owner}/${name}` });
+}

package/src/repositoryReads.ts

@@ -1,10 +1,11 @@
 import { Effect } from "effect";
+import type { ServiceUnavailable } from "@shivaedev/errors/taxonomy.ts";
 import { Commit, CommitDetail, Comparison, GitTree } from "#gitSchemas.ts";
 import { decodedPages, type ListOptions } from "#pagedLists.ts";
 import { CollaboratorPermission, Issue, PullRequestFile, User } from "#repositorySchemas.ts";
 import type { Representations } from "#representations.ts";
 
-export interface RepositoryListOptions extends ListOptions {
+export interface RepositoryListOptions<E = ServiceUnavailable> extends ListOptions<E> {
 	readonly query?: Readonly<Record<string, string | number | boolean | undefined>>;
 }
 
@@ -12,7 +13,7 @@ export function repositoryReads(client: Representations) {
 	function repository(owner: string, repo: string) {
 		return `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`;
 	}
-	function pathWithQuery(path: string, options?: RepositoryListOptions) {
+	function pathWithQuery<E>(path: string, options?: RepositoryListOptions<E>) {
 		const query = new URLSearchParams({ "per_page": "100" });
 		for (const [key, value] of Object.entries(options?.query ?? {})) {
 			if (value !== undefined) {
@@ -51,11 +52,11 @@ export function repositoryReads(client: Representations) {
 			Effect.flatMap(client.read(username === undefined ? "/user" : `/users/${encodeURIComponent(username)}`, byteLimit), (page) =>
 				page.decode(User),
 			),
-		listCommits: (owner: string, repo: string, options?: RepositoryListOptions) =>
+		listCommits: <E = ServiceUnavailable>(owner: string, repo: string, options?: RepositoryListOptions<E>) =>
 			Effect.succeed(decodedPages(client, pathWithQuery(`${repository(owner, repo)}/commits`, options), Commit, options)),
-		listIssues: (owner: string, repo: string, options?: RepositoryListOptions) =>
+		listIssues: <E = ServiceUnavailable>(owner: string, repo: string, options?: RepositoryListOptions<E>) =>
 			Effect.succeed(decodedPages(client, pathWithQuery(`${repository(owner, repo)}/issues`, options), Issue, options)),
-		listPullRequestFiles: (owner: string, repo: string, number: number, options?: RepositoryListOptions) =>
+		listPullRequestFiles: <E = ServiceUnavailable>(owner: string, repo: string, number: number, options?: RepositoryListOptions<E>) =>
 			Effect.succeed(decodedPages(client, pathWithQuery(`${repository(owner, repo)}/pulls/${number}/files`, options), PullRequestFile, options)),
 	};
 }

package/src/representations.ts

@@ -10,7 +10,7 @@ import type { requests } from "#requests.ts";
 
 export function representations(
 	apiUrl: string,
-	request: ReturnType<typeof requests>,
+	request: Effect.Success<ReturnType<typeof requests>>,
 	resource: (path: string) => string,
 	responseByteLimit = 1024 * 1024,
 ) {
@@ -20,9 +20,9 @@ export function representations(
 	function readRepresentation(path: string, byteLimit = responseByteLimit) {
 		return Effect.map(request(get(path), byteLimit), jsonResponse);
 	}
-	function listRepresentations(
+	function listRepresentations<E = ServiceUnavailable>(
 		path: string,
-		beforeRequest?: (resource: string) => Effect.Effect<void, ServiceUnavailable>,
+		beforeRequest?: (resource: string) => Effect.Effect<void, E>,
 		byteLimit = responseByteLimit,
 	) {
 		const entries = new WeakMap<HttpClientResponse.HttpClientResponse, CachedResponse>();

package/src/requests.ts

@@ -2,20 +2,18 @@ import { Effect } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/http";
 import { readBoundedBody } from "@shivaedev/http/body.ts";
 import { ResponseBodyTooLarge } from "@shivaedev/http/errors.ts";
-import { authenticatedRequest } from "./authenticatedRequest.ts";
-import { type CachedResponse, responseCache, revalidatedResponse } from "./cache.ts";
-import { GitHubTransportError } from "./errors.ts";
-import type { GitHubToken } from "./GitHubToken.ts";
-import type { RateLimits } from "./rateLimits.ts";
-import { isUnchanged } from "./status.ts";
-import type { TokenRefresh } from "./TokenRefresh.ts";
+import { authenticatedRequest } from "#authenticatedRequest.ts";
+import { type CachedResponse, responseCache, revalidatedResponse } from "#cache.ts";
+import { GitHubTransportError } from "#errors.ts";
+import { GitHubToken } from "#GitHubToken.ts";
+import type { RateLimits } from "#rateLimits.ts";
+import { isUnchanged } from "#status.ts";
+import { TokenRefresh } from "#TokenRefresh.ts";
 
-export function requests(
-	client: HttpClient.HttpClient,
-	token: GitHubToken["Service"],
-	rates: RateLimits,
-	refresh: typeof TokenRefresh.Service = undefined,
-) {
+export const requests = Effect.fnUntraced(function* (rates: RateLimits) {
+	const client = yield* HttpClient.HttpClient;
+	const token = yield* GitHubToken;
+	const refresh = yield* TokenRefresh;
 	const cache = responseCache();
 	const send = authenticatedRequest(HttpClient.withScope(client), token, rates, refresh);
 	return Effect.fn("GitHub.request")(function* (input: HttpClientRequest.HttpClientRequest, limit: number) {
@@ -43,4 +41,4 @@ export function requests(
 		}
 		return entry;
 	}, Effect.scoped);
-}
+});

package/src/status.ts

@@ -1,8 +1,8 @@
 import { DateTime, Effect, Option, Schema } from "effect";
-import { HttpClient, type HttpClientResponse } from "effect/http";
+import type { HttpClientResponse } from "effect/http";
 import * as HttpStatus from "effect/http/HttpStatus";
 import { readBoundedText } from "@shivaedev/http/body.ts";
-import { filterStatus } from "@shivaedev/http/filterStatus.ts";
+import { checkStatus as checkResponseStatus } from "@shivaedev/http/checkStatus.ts";
 import { parseRetryAfter } from "@shivaedev/http/parseRetryAfter.ts";
 import { GitHubConversationLocked, GitHubPermissionDenied, GitHubRateLimited } from "#errors.ts";
 
@@ -29,7 +29,7 @@ export const checkStatus = Effect.fnUntraced(function* (response: HttpClientResp
 			return yield* refusal;
 		}
 	}
-	return yield* filterStatus(HttpClient.makeWith(() => Effect.succeed(response), Effect.succeed)).execute(response.request);
+	return yield* checkResponseStatus(response);
 });
 
 const Message = Schema.fromJsonString(Schema.Struct({ message: Schema.String }));

package/src/verifyWebhook.ts

@@ -1,6 +1,6 @@
-import { createHmac, timingSafeEqual } from "node:crypto";
-import { Effect, Redacted, Schema } from "effect";
-import { GitHubWebhookSignatureError } from "#errors.ts";
+import { Effect, type Redacted, Schema } from "effect";
+import { verifySignature } from "#adapters/verifySignature.ts";
+import type { GitHubWebhookSignatureError } from "#errors.ts";
 
 const verify = Effect.fnUntraced(function* <TSchema extends Schema.Constraint>(
 	body: Uint8Array,
@@ -8,13 +8,7 @@ const verify = Effect.fnUntraced(function* <TSchema extends Schema.Constraint>(
 	secret: Redacted.Redacted<string>,
 	schema?: TSchema,
 ) {
-	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();
-	}
+	yield* verifySignature(body, signature, secret);
 	if (schema === undefined) {
 		return;
 	}