@shivaedev/github 0.8.6 → 0.9.0

package/src/authenticatedRequest.ts

@@ -1,4 +1,4 @@
-import { DateTime, Effect, Option, Redacted } from "effect";
+import { DateTime, Effect, Option, Redacted, Stream } from "effect";
 import { FetchHttpClient, type HttpClient, type HttpClientError, HttpClientRequest } from "effect/http";
 import * as HttpStatus from "effect/http/HttpStatus";
 import { GitHubTransportError } from "./errors.ts";
@@ -30,12 +30,14 @@ export function authenticatedRequest<R>(
 		const credential = yield* accessToken;
 		let response = yield* send(credential);
 		if (isUnauthorized(response) && refresh !== undefined) {
+			yield* Effect.scoped(Stream.toPull(response.stream));
 			yield* refresh(credential);
 			response = yield* send(yield* accessToken);
 		}
 		const observedResource = rates.observe(response);
 		if (!((mode === "revalidate" && isUnchanged(response)) || (mode === "manual" && response.status === HttpStatus.fromLiteral("Found")))) {
 			yield* checkStatus(response, observedResource, rates.failures.get(observedResource) ?? 0).pipe(
+				Effect.onError(() => Effect.scoped(Stream.toPull(response.stream))),
 				Effect.catchTag("HttpClientError", (cause) => Effect.fail(new GitHubTransportError({ path }, { cause }))),
 				Effect.catchTag("GitHubRateLimited", (error) => {
 					rates.blocked.set(error.resource, error);

package/src/cache.ts

@@ -4,9 +4,14 @@ import type { HttpClientResponse } from "effect/http";
 export interface CachedResponse {
 	readonly bytes: Uint8Array;
 	readonly decoded: Map<Schema.Constraint, unknown>;
+	readonly etag?: string | undefined;
 	readonly response: HttpClientResponse.HttpClientResponse;
 }
 
+export function revalidatedResponse(cached: CachedResponse, response: HttpClientResponse.HttpClientResponse): CachedResponse {
+	return { ...cached, etag: response.headers.etag ?? cached.etag, response };
+}
+
 export function responseCache() {
 	const entries = new Map<string, CachedResponse>();
 	return {

package/src/checkRuns.ts

@@ -1,4 +1,4 @@
-import { Effect, Schema } from "effect";
+import { Effect, Option, Schema, Stream } from "effect";
 import type { Representations } from "#representations.ts";
 
 export const CheckRunOutput = Schema.Struct({
@@ -8,16 +8,22 @@ export const CheckRunOutput = Schema.Struct({
 });
 
 export const CheckRunConclusion = Schema.Literals(["action_required", "cancelled", "failure", "neutral", "success", "skipped", "stale", "timed_out"]);
-export const CheckRunStatus = Schema.Literals(["queued", "in_progress", "completed"]);
+export const CheckRunStatus = Schema.Literals(["queued", "in_progress", "completed", "waiting", "requested", "pending"]);
 
-export const CreateCheckRun = Schema.Struct({
-	conclusion: Schema.optional(CheckRunConclusion),
+const createFields = {
 	detailsUrl: Schema.optional(Schema.String),
 	headSha: Schema.String,
 	name: Schema.String,
 	output: Schema.optional(CheckRunOutput),
-	status: CheckRunStatus,
-}).pipe(Schema.encodeKeys({ detailsUrl: "details_url", headSha: "head_sha" }));
+};
+export const CreateCheckRun = Schema.Union([
+	Schema.Struct({ ...createFields, conclusion: Schema.optional(CheckRunConclusion), status: Schema.Literals(["queued", "in_progress"]) }).pipe(
+		Schema.encodeKeys({ detailsUrl: "details_url", headSha: "head_sha" }),
+	),
+	Schema.Struct({ ...createFields, conclusion: CheckRunConclusion, status: Schema.Literal("completed") }).pipe(
+		Schema.encodeKeys({ detailsUrl: "details_url", headSha: "head_sha" }),
+	),
+]);
 
 export const UpdateCheckRun = Schema.Union([
 	Schema.Struct({
@@ -34,6 +40,7 @@ export const UpdateCheckRun = Schema.Union([
 ]);
 
 export const CheckRun = Schema.Struct({
+	app: Schema.optional(Schema.NullOr(Schema.Struct({ id: Schema.Number }))),
 	conclusion: Schema.NullOr(CheckRunConclusion),
 	detailsUrl: Schema.NullOr(Schema.String),
 	headSha: Schema.String,
@@ -43,17 +50,50 @@ export const CheckRun = Schema.Struct({
 	status: CheckRunStatus,
 }).pipe(Schema.encodeKeys({ detailsUrl: "details_url", headSha: "head_sha" }));
 
+const CheckRunPage = Schema.Struct({ checkRuns: Schema.Array(CheckRun) }).pipe(Schema.encodeKeys({ checkRuns: "check_runs" }));
+
+export const FindCheckRun = Schema.Union([
+	Schema.Struct({ appId: Schema.optional(Schema.Number), headSha: Schema.String, name: Schema.String }),
+	Schema.Struct({ appId: Schema.Number, headSha: Schema.String, name: Schema.optional(Schema.String) }),
+]);
+
 export function checkRuns(client: Representations) {
-	return {
-		createCheckRun: Effect.fn("GitHub.createCheckRun")(function* (owner: string, repo: string, input: typeof CreateCheckRun.Type) {
-			const body = yield* Schema.encodeEffect(CreateCheckRun)(input);
-			const response = yield* client.write("POST", `/repos/${owner}/${repo}/check-runs`, body);
-			return yield* response.decode(CheckRun);
-		}),
-		updateCheckRun: Effect.fn("GitHub.updateCheckRun")(function* (owner: string, repo: string, id: number, input: typeof UpdateCheckRun.Type) {
-			const body = yield* Schema.encodeEffect(UpdateCheckRun)(input);
-			const response = yield* client.write("PATCH", `/repos/${owner}/${repo}/check-runs/${id}`, body);
-			return yield* response.decode(CheckRun);
-		}),
-	};
+	const createCheckRun = Effect.fn("GitHub.createCheckRun")(function* (owner: string, repo: string, input: typeof CreateCheckRun.Type) {
+		const body = yield* Schema.encodeEffect(CreateCheckRun)(input);
+		const response = yield* client.write("POST", `/repos/${owner}/${repo}/check-runs`, body);
+		return yield* response.decode(CheckRun);
+	});
+	const updateCheckRun = Effect.fn("GitHub.updateCheckRun")(function* (owner: string, repo: string, id: number, input: typeof UpdateCheckRun.Type) {
+		const body = yield* Schema.encodeEffect(UpdateCheckRun)(input);
+		const response = yield* client.write("PATCH", `/repos/${owner}/${repo}/check-runs/${id}`, body);
+		return yield* response.decode(CheckRun);
+	});
+	const findLatestCheckRun = Effect.fn("GitHub.findLatestCheckRun")(function* (owner: string, repo: string, input: typeof FindCheckRun.Type) {
+		const { headSha, name, appId } = yield* Schema.decodeUnknownEffect(FindCheckRun)(input);
+		const query = new URLSearchParams({ filter: "all", "per_page": "100" });
+		if (name !== undefined) {
+			query.set("check_name", name);
+		}
+		const pages = yield* client.list(`/repos/${owner}/${repo}/commits/${encodeURIComponent(headSha)}/check-runs?${query}`);
+		return yield* pages.pipe(
+			Stream.mapEffect((page) => page.decode(CheckRunPage)),
+			Stream.flatMap((page) => Stream.fromIterable(page.checkRuns)),
+			Stream.filter((run) => (name === undefined || run.name === name) && (appId === undefined || run.app?.id === appId)),
+			Stream.runFold(
+				() => Option.none<typeof CheckRun.Type>(),
+				(latest, run) => (Option.isNone(latest) || run.id > latest.value.id ? Option.some(run) : latest),
+			),
+		);
+	});
+	const upsertCheckRun = Effect.fn("GitHub.upsertCheckRun")(function* (
+		owner: string,
+		repo: string,
+		input: typeof CreateCheckRun.Type,
+		appId?: number,
+	) {
+		yield* Schema.encodeEffect(CreateCheckRun)(input);
+		const existing = yield* findLatestCheckRun(owner, repo, { appId, headSha: input.headSha, name: input.name });
+		return yield* Option.isSome(existing) ? updateCheckRun(owner, repo, existing.value.id, input) : createCheckRun(owner, repo, input);
+	});
+	return { createCheckRun, findLatestCheckRun, updateCheckRun, upsertCheckRun };
 }

package/src/githubApp.ts

@@ -1,12 +1,7 @@
-import { Cache, Clock, Context, Effect, Exit, Layer, Option, Redacted, Schema } from "effect";
-import { HttpClient, HttpClientRequest } from "effect/http";
-import { readBoundedJson } from "@shivaedev/http/body.ts";
-import { filterStatus } from "@shivaedev/http/filterStatus.ts";
-import { type AppCredentials, appJwt } from "#appJwt.ts";
-import { GitHubAppError } from "#errors.ts";
-import { GitHubConfig } from "#GitHubConfig.ts";
-import { GitHubToken } from "#GitHubToken.ts";
-import { TokenRefresh } from "#TokenRefresh.ts";
+import { Layer } from "effect";
+import type { AppCredentials } from "#appJwt.ts";
+import { appTokens } from "#appTokens.ts";
+import { GitHubApp, GitHubAppCredentials } from "#installationClients.ts";
 
 export interface InstallationScope {
 	readonly permissions?: Readonly<Record<string, "read" | "write" | "admin">>;
@@ -21,76 +16,7 @@ export type GitHubAppOptions = AppCredentials &
 		| { readonly installationId?: never; readonly owner?: never; readonly repository?: never; readonly scope?: never }
 	);
 
-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.effectContext(
-		Effect.gen(function* () {
-			if (!("installationId" in options || "owner" in options)) {
-				return Context.make(GitHubToken, Effect.map(appJwt(options), Option.some)).pipe(Context.add(TokenRefresh, undefined));
-			}
-			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 jwt = yield* appJwt(options);
-				if (installationId === undefined && "owner" in options && options.owner !== undefined) {
-					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, {
-					permissions: options.scope?.permissions,
-					repositories: options.scope?.repositories,
-					"repository_ids": options.scope?.repositoryIds,
-				});
-			});
-			const cache = yield* Cache.makeWith((_: undefined) => exchange, {
-				capacity: 1,
-				timeToLive: (exit) => (Exit.isSuccess(exit) ? Math.max(0, exit.value.expiresAt.getTime() - clock.currentTimeMillisUnsafe() - 300_000) : 0),
-			});
-			return Context.make(
-				GitHubToken,
-				Effect.map(Cache.get(cache, undefined), ({ token }) => Option.some(token)),
-			).pipe(
-				Context.add(TokenRefresh, (rejected) =>
-					Cache.invalidateWhen(cache, undefined, ({ token }) => Option.isSome(rejected) && token === rejected.value),
-				),
-			);
-		}),
-	);
-}
-
-function appRequests(client: HttpClient.HttpClient, apiUrl: string) {
-	const checked = filterStatus(client);
-	return Effect.fnUntraced(function* <TSchema extends Schema.Constraint>(
-		method: "GET" | "POST",
-		path: string,
-		jwt: Redacted.Redacted<string>,
-		schema: TSchema,
-		body?: unknown,
-	) {
-		let input = HttpClientRequest.make(method)(new URL(path, apiUrl).href, {
-			headers: { Accept: "application/vnd.github+json", Authorization: `Bearer ${Redacted.value(jwt)}`, "X-GitHub-Api-Version": "2022-11-28" },
-		});
-		if (body !== undefined) {
-			input = yield* HttpClientRequest.bodyJson(input, body).pipe(Effect.mapError((cause) => new GitHubAppError({ reason: "encode" }, { cause })));
-		}
-		const response = yield* checked
-			.execute(input)
-			.pipe(
-				Effect.mapError((cause) =>
-					cause._tag === "HttpClientError"
-						? new GitHubAppError({ reason: "transport" }, { cause })
-						: new GitHubAppError({ reason: "status", status: cause.status }),
-				),
-			);
-		return yield* readBoundedJson(response, 64 * 1024, schema).pipe(
-			Effect.mapError((cause) => new GitHubAppError({ reason: cause._tag === "HttpClientError" ? "transport" : "response" }, { cause })),
-		);
-	});
+	const authentication = appTokens(options);
+	return Layer.merge(authentication, GitHubApp.layer.pipe(Layer.provide(Layer.succeed(GitHubAppCredentials)({ credentials: options }))));
 }

package/src/installationClients.ts

@@ -0,0 +1,44 @@
+import { Cache, Context, Effect, Layer } from "effect";
+import { HttpClient } from "effect/http";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import type { AppCredentials } from "#appJwt.ts";
+import { appTokens } from "#appTokens.ts";
+import { GitHub } from "#GitHub.ts";
+import { GitHubConfig } from "#GitHubConfig.ts";
+
+export const GitHubAppCredentials = Context.Service<{ readonly credentials: AppCredentials }>("@shivaedev/github/AppCredentials");
+
+export const GitHubApp = defineService({
+	id: "@shivaedev/github/GitHubApp",
+	initialize: Effect.gen(function* () {
+		const { credentials } = yield* GitHubAppCredentials;
+		const http = yield* HttpClient.HttpClient;
+		const config = yield* GitHubConfig;
+		return yield* Cache.make({
+			capacity: 100,
+			lookup: (installationId: number) =>
+				Layer.build(
+					GitHub.layer.pipe(
+						Layer.provide(appTokens({ ...credentials, installationId })),
+						Layer.provide(Layer.succeed(HttpClient.HttpClient)(http)),
+						Layer.provide(Layer.succeed(GitHubConfig)(config)),
+					),
+				).pipe(
+					Effect.scoped,
+					Effect.map((context) => Context.get(context, GitHub)),
+				),
+			timeToLive: "30 minutes",
+		});
+	}),
+	methods: (clients) => ({
+		installation: (installationId: number) =>
+			Cache.get(clients, installationId).pipe(Effect.tap((client) => Cache.set(clients, installationId, client))),
+	}),
+	requires: [GitHubAppCredentials, HttpClient.HttpClient, GitHubConfig],
+});
+
+export function withInstallation<A, E, R>(installationId: number, effect: Effect.Effect<A, E, R>) {
+	return Effect.flatMap(GitHubApp, (app) =>
+		Effect.flatMap(app.installation(installationId), (client) => Effect.provideService(effect, GitHub, client)),
+	);
+}

package/src/json.ts

@@ -1,7 +1,11 @@
 import { Effect, Schema } from "effect";
+import * as HttpStatus from "effect/http/HttpStatus";
 import type { CachedResponse } from "./cache.ts";
 
 export const decodeJson = Effect.fnUntraced(function* <TSchema extends Schema.Constraint>(entry: CachedResponse, schema: TSchema) {
+	if (entry.response.status === HttpStatus.fromLiteral("NoContent")) {
+		return yield* Schema.decodeUnknownEffect(schema)(undefined);
+	}
 	const cached = entry.decoded.get(schema);
 	if (entry.decoded.has(schema) && Schema.is(schema)(cached)) {
 		return cached;

package/src/representations.ts

@@ -45,9 +45,9 @@ export function representations(
 			),
 		);
 	}
-	function writeRepresentation(method: "POST" | "PATCH", path: string, body: unknown, byteLimit = responseByteLimit) {
+	function writeRepresentation(method: "POST" | "PATCH" | "PUT" | "DELETE", path: string, body?: unknown, byteLimit = responseByteLimit) {
 		return HttpClientRequest.make(method)(new URL(path, apiUrl).href, { headers: { Accept: "application/vnd.github+json" } }).pipe(
-			HttpClientRequest.bodyJson(body),
+			(input) => (body === undefined ? Effect.succeed(input) : HttpClientRequest.bodyJson(input, body)),
 			Effect.flatMap((input) => request(input, byteLimit)),
 			Effect.map(jsonResponse),
 		);

package/src/requests.ts

@@ -1,9 +1,9 @@
 import { Effect } from "effect";
-import { type HttpClient, HttpClientRequest } from "effect/http";
+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 } from "./cache.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";
@@ -17,28 +17,30 @@ export function requests(
 	refresh: typeof TokenRefresh.Service = undefined,
 ) {
 	const cache = responseCache();
-	const send = authenticatedRequest(client, token, rates, refresh);
+	const send = authenticatedRequest(HttpClient.withScope(client), token, rates, refresh);
 	return Effect.fn("GitHub.request")(function* (input: HttpClientRequest.HttpClientRequest, limit: number) {
-		const key = `${input.url} ${input.headers.accept}`;
+		const key = JSON.stringify([input.url, input.urlParams, input.headers.accept]);
 		const cached = input.method === "GET" ? cache.get(key) : undefined;
 		let request = HttpClientRequest.removeHeader(input, "if-none-match");
-		if (cached?.response.headers.etag !== undefined) {
-			request = HttpClientRequest.setHeader(request, "If-None-Match", cached.response.headers.etag);
+		if (cached?.etag !== undefined) {
+			request = HttpClientRequest.setHeader(request, "If-None-Match", cached.etag);
 		}
 		const response = yield* send(request, cached === undefined ? undefined : "revalidate");
 		if (isUnchanged(response) && cached !== undefined) {
 			if (cached.bytes.byteLength > limit) {
 				return yield* new ResponseBodyTooLarge({ limit });
 			}
-			return cached;
+			const entry = revalidatedResponse(cached, response);
+			cache.set(key, entry);
+			return entry;
 		}
 		const bytes = yield* readBoundedBody(response, limit).pipe(
 			Effect.catchTag("HttpClientError", (cause) => Effect.fail(new GitHubTransportError({ path: new URL(input.url).pathname }, { cause }))),
 		);
-		const entry: CachedResponse = { bytes, decoded: new Map(), response };
+		const entry: CachedResponse = { bytes, decoded: new Map(), etag: response.headers.etag, response };
 		if (input.method === "GET" && response.headers.etag !== undefined) {
 			cache.set(key, entry);
 		}
 		return entry;
-	});
+	}, Effect.scoped);
 }