@shivaedev/github 0.9.0 → 0.11.0

package/src/artifactExtraction.ts

@@ -0,0 +1,62 @@
+import { Effect, Stream } from "effect";
+import { zipEntries } from "#adapters/zipEntries.ts";
+import {
+	GitHubArtifactCompressionRatio,
+	GitHubArtifactExtractedTooLarge,
+	GitHubArtifactExtractionError,
+	GitHubArtifactSymlink,
+} from "#artifactErrors.ts";
+import { artifactPaths } from "#artifactPaths.ts";
+
+export interface ArtifactExtractionOptions {
+	readonly compressionRatioLimit?: number;
+	readonly totalSizeLimit?: number;
+}
+
+export interface ArtifactFile {
+	readonly bytes: Uint8Array;
+	readonly path: string;
+}
+
+export const extractArtifactArchive = Effect.fn("GitHub.extractArtifactArchive")(function* (bytes: Uint8Array, options: ArtifactExtractionOptions) {
+	const totalSizeLimit = options.totalSizeLimit ?? 100 * 1024 * 1024;
+	const compressionRatioLimit = options.compressionRatioLimit ?? 100;
+	if (!Number.isSafeInteger(totalSizeLimit) || totalSizeLimit < 0 || !Number.isFinite(compressionRatioLimit) || compressionRatioLimit <= 0) {
+		return yield* new GitHubArtifactExtractionError({ reason: "invalid-limits" });
+	}
+	const entries = yield* zipEntries(bytes);
+	const pathOf = artifactPaths();
+	const files: ArtifactFile[] = [];
+	let total = 0;
+	yield* entries.pipe(
+		Stream.runForEach((entry) =>
+			Effect.gen(function* () {
+				const path = yield* pathOf(entry.path, entry.directory);
+				yield* validateEntry(entry, total, { compressionRatioLimit, totalSizeLimit });
+				const content = yield* entry.read({ compressionRatioLimit, remaining: totalSizeLimit - total, totalSizeLimit });
+				total += content.byteLength;
+				if (!entry.directory) {
+					files.push({ bytes: content, path });
+				}
+			}),
+		),
+	);
+	return files;
+});
+
+type ZipEntry = Stream.Success<Effect.Success<ReturnType<typeof zipEntries>>>;
+
+const validateEntry = Effect.fnUntraced(function* (entry: ZipEntry, total: number, options: Required<ArtifactExtractionOptions>) {
+	if (entry.symlink) {
+		return yield* new GitHubArtifactSymlink({ path: entry.path });
+	}
+	if (entry.directory && entry.uncompressedSize !== 0) {
+		return yield* new GitHubArtifactExtractionError({ reason: "invalid-archive" });
+	}
+	if (total + entry.uncompressedSize > options.totalSizeLimit) {
+		return yield* new GitHubArtifactExtractedTooLarge({ limit: options.totalSizeLimit });
+	}
+	if (entry.uncompressedSize > entry.compressedSize * options.compressionRatioLimit) {
+		return yield* new GitHubArtifactCompressionRatio({ limit: options.compressionRatioLimit, path: entry.path });
+	}
+});

package/src/artifactPaths.ts

@@ -0,0 +1,36 @@
+import { Effect } from "effect";
+import { GitHubArtifactDuplicateEntry, GitHubArtifactPathTraversal } from "#artifactErrors.ts";
+
+const safeName = Effect.fnUntraced(function* (path: string, directory: boolean) {
+	const name = directory && path.endsWith("/") ? path.slice(0, -1) : path;
+	const segments = name.split("/");
+	if (/[\\:\0]/u.test(name) || segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+		return yield* new GitHubArtifactPathTraversal({ path });
+	}
+	return { name, segments };
+});
+
+export function artifactPaths() {
+	const entries = new Set<string>();
+	const files = new Set<string>();
+	const directories = new Set<string>();
+	const registerParents = Effect.fnUntraced(function* (path: string, segments: readonly string[]) {
+		for (let index = 1; index < segments.length; index += 1) {
+			const parent = segments.slice(0, index).join("/");
+			if (files.has(parent)) {
+				return yield* new GitHubArtifactDuplicateEntry({ path });
+			}
+			directories.add(parent);
+		}
+	});
+	return Effect.fnUntraced(function* (path: string, directory: boolean) {
+		const { name, segments } = yield* safeName(path, directory);
+		if (entries.has(name) || (!directory && directories.has(name))) {
+			return yield* new GitHubArtifactDuplicateEntry({ path });
+		}
+		yield* registerParents(path, segments);
+		entries.add(name);
+		(directory ? directories : files).add(name);
+		return name;
+	});
+}

package/src/artifacts.ts

@@ -1,16 +1,19 @@
 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 { authenticatedRequest } from "./authenticatedRequest.ts";
-import { GitHubArtifactError, GitHubArtifactTooLarge, GitHubTransportError } from "./errors.ts";
-import type { GitHubToken } from "./GitHubToken.ts";
-import type { RateLimits } from "./rateLimits.ts";
-import type { TokenRefresh } from "./TokenRefresh.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";
+import { GitHubArtifactError, GitHubArtifactTooLarge, GitHubTransportError } from "#errors.ts";
+import { GitHubToken } from "#GitHubToken.ts";
+import type { RateLimits } from "#rateLimits.ts";
+import { TokenRefresh } from "#TokenRefresh.ts";
 
-export interface ArtifactArchiveOptions {
+export interface ArtifactArchiveOptions extends ArtifactExtractionOptions {
 	readonly artifactId: number;
 	readonly byteLimit: number;
 	readonly owner: string;
@@ -23,41 +26,33 @@ function downloadFailure(path: string, cause: HttpClientError.HttpClientError |
 		: new GitHubArtifactError({ stage: "download", status: cause.status });
 }
 
-export function artifacts(
-	apiUrl: string,
-	client: HttpClient.HttpClient,
-	token: GitHubToken["Service"],
-	rates: RateLimits,
-	refresh: typeof TokenRefresh.Service = undefined,
-) {
+export const artifacts = Effect.fn("GitHub.artifacts")(function* (apiUrl: string, rates: RateLimits) {
+	const client = yield* HttpClient.HttpClient;
+	const token = yield* GitHubToken;
+	const refresh = yield* TokenRefresh;
 	const send = authenticatedRequest(HttpClient.withScope(client), token, rates, refresh);
 	const download = filterStatus(HttpClient.withScope(client));
 	return {
-		downloadArtifactArchive: (options: ArtifactArchiveOptions) =>
-			Effect.scoped(
-				Effect.gen(function* () {
-					const path = `/repos/${encodeURIComponent(options.owner)}/${encodeURIComponent(options.repo)}/actions/artifacts/${options.artifactId}/zip`;
-					const redirect = yield* send(HttpClientRequest.get(new URL(path, apiUrl).href, { accept: "application/vnd.github+json" }), "manual").pipe(
-						Effect.catchTags({
-							RemoteGone: (error) => Effect.fail(new GitHubArtifactError({ stage: "redirect", status: error.status }, { cause: error })),
-							RemoteNotFound: (error) => Effect.fail(new GitHubArtifactError({ stage: "redirect", status: error.status }, { cause: error })),
-						}),
-					);
-					const location = redirect.headers.location;
-					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)),
-					);
-					return yield* readBoundedBody(response, options.byteLimit).pipe(
-						Effect.catchTags({
-							HttpClientError: (cause) => Effect.fail(new GitHubTransportError({ path }, { cause })),
-							ResponseBodyTooLarge: (cause) => Effect.fail(new GitHubArtifactTooLarge({ limit: cause.limit }, { cause })),
-						}),
-					);
+		downloadArtifactArchive: Effect.fn("GitHub.downloadArtifactArchive")(function* (options: ArtifactArchiveOptions) {
+			const path = `/repos/${encodeURIComponent(options.owner)}/${encodeURIComponent(options.repo)}/actions/artifacts/${options.artifactId}/zip`;
+			const redirect = yield* send(HttpClientRequest.get(resolveApiUrl(apiUrl, path), { accept: "application/vnd.github+json" }), "manual").pipe(
+				Effect.catchTags({
+					RemoteGone: (error) => Effect.fail(new GitHubArtifactError({ stage: "redirect", status: error.status }, { cause: error })),
+					RemoteNotFound: (error) => Effect.fail(new GitHubArtifactError({ stage: "redirect", status: error.status }, { cause: error })),
 				}),
-			),
+			);
+			const location = redirect.headers.location;
+			if (redirect.status !== HttpStatus.fromLiteral("Found") || location === undefined) {
+				return yield* new GitHubArtifactError({ stage: "redirect", status: redirect.status });
+			}
+			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 })),
+					ResponseBodyTooLarge: (cause) => Effect.fail(new GitHubArtifactTooLarge({ limit: cause.limit }, { cause })),
+				}),
+				Effect.flatMap((bytes) => extractArtifactArchive(bytes, options)),
+			);
+		}, Effect.scoped),
 	};
-}
+});

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/checkRuns.ts

@@ -1,4 +1,5 @@
 import { Effect, Option, Schema, Stream } from "effect";
+import { decodedPages } from "#pagedLists.ts";
 import type { Representations } from "#representations.ts";
 
 export const CheckRunOutput = Schema.Struct({
@@ -50,8 +51,6 @@ 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) }),
@@ -74,10 +73,11 @@ export function checkRuns(client: Representations) {
 		if (name !== undefined) {
 			query.set("check_name", name);
 		}
-		const pages = yield* client.list(`/repos/${owner}/${repo}/commits/${encodeURIComponent(headSha)}/check-runs?${query}`);
+		const pages = decodedPages(client, `/repos/${owner}/${repo}/commits/${encodeURIComponent(headSha)}/check-runs?${query}`, CheckRun, {
+			arrayKey: "check_runs",
+		});
 		return yield* pages.pipe(
-			Stream.mapEffect((page) => page.decode(CheckRunPage)),
-			Stream.flatMap((page) => Stream.fromIterable(page.checkRuns)),
+			Stream.flatMap((page) => Stream.fromIterable(page.items)),
 			Stream.filter((run) => (name === undefined || run.name === name) && (appId === undefined || run.app?.id === appId)),
 			Stream.runFold(
 				() => Option.none<typeof CheckRun.Type>(),

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/gitSchemas.ts

@@ -0,0 +1,52 @@
+import { Schema } from "effect";
+import { PullRequestFile, User } from "#repositorySchemas.ts";
+
+const CommitIdentity = Schema.Struct({ date: Schema.String, email: Schema.String, name: Schema.String });
+const CommitData = Schema.Struct({
+	author: Schema.NullOr(CommitIdentity),
+	committer: Schema.NullOr(CommitIdentity),
+	message: Schema.String,
+	tree: Schema.Struct({ sha: Schema.String, url: Schema.String }),
+});
+
+const commitFields = {
+	author: Schema.NullOr(User),
+	commit: CommitData,
+	committer: Schema.NullOr(User),
+	htmlUrl: Schema.String,
+	parents: Schema.Array(Schema.Struct({ sha: Schema.String, url: Schema.String })),
+	sha: Schema.String,
+};
+
+export const Commit = Schema.Struct(commitFields).pipe(Schema.encodeKeys({ htmlUrl: "html_url" }));
+
+export const CommitDetail = Schema.Struct({
+	...commitFields,
+	files: Schema.optional(Schema.Array(PullRequestFile)),
+	stats: Schema.Struct({ additions: Schema.Number, deletions: Schema.Number, total: Schema.Number }),
+}).pipe(Schema.encodeKeys({ htmlUrl: "html_url" }));
+
+export const Comparison = Schema.Struct({
+	aheadBy: Schema.Number,
+	behindBy: Schema.Number,
+	commits: Schema.Array(Commit),
+	files: Schema.optional(Schema.Array(PullRequestFile)),
+	status: Schema.Literals(["diverged", "ahead", "behind", "identical"]),
+	totalCommits: Schema.Number,
+}).pipe(Schema.encodeKeys({ aheadBy: "ahead_by", behindBy: "behind_by", totalCommits: "total_commits" }));
+
+export const GitTree = Schema.Struct({
+	sha: Schema.String,
+	tree: Schema.Array(
+		Schema.Struct({
+			mode: Schema.String,
+			path: Schema.String,
+			sha: Schema.String,
+			size: Schema.optional(Schema.Number),
+			type: Schema.Literals(["blob", "tree", "commit"]),
+			url: Schema.optional(Schema.String),
+		}),
+	),
+	truncated: Schema.Boolean,
+	url: Schema.String,
+});

package/src/installationClients.ts

@@ -5,34 +5,40 @@ import type { AppCredentials } from "#appJwt.ts";
 import { appTokens } from "#appTokens.ts";
 import { GitHub } from "#GitHub.ts";
 import { GitHubConfig } from "#GitHubConfig.ts";
+import { viewerRepositoryAccess } from "#viewerRepositoryAccess.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 { credentials: supplied } = yield* GitHubAppCredentials;
+		const credentials = { appId: supplied.appId, privateKey: supplied.privateKey };
 		const http = yield* HttpClient.HttpClient;
 		const config = yield* GitHubConfig;
-		return yield* Cache.make({
+		const environment = Layer.mergeAll(Layer.succeed(HttpClient.HttpClient)(http), Layer.succeed(GitHubConfig)(config));
+		const app = yield* Layer.build(GitHub.layer.pipe(Layer.provide(appTokens(credentials)), Layer.provide(environment))).pipe(
+			Effect.scoped,
+			Effect.map((context) => Context.get(context, GitHub)),
+		);
+		const clients = 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(
+				Layer.build(GitHub.layer.pipe(Layer.provide(appTokens({ ...credentials, installationId })), Layer.provide(environment))).pipe(
 					Effect.scoped,
 					Effect.map((context) => Context.get(context, GitHub)),
 				),
 			timeToLive: "30 minutes",
 		});
+		function installation(id: number) {
+			return Cache.get(clients, id).pipe(Effect.tap((client) => Cache.set(clients, id, client)));
+		}
+		return { installation, viewers: yield* viewerRepositoryAccess(app, installation) };
 	}),
-	methods: (clients) => ({
-		installation: (installationId: number) =>
-			Cache.get(clients, installationId).pipe(Effect.tap((client) => Cache.set(clients, installationId, client))),
+	methods: ({ installation, viewers }) => ({
+		installation,
+		viewerRepositories: (account: number | string) =>
+			Cache.get(viewers, typeof account === "number" ? `id:${account}` : `login:${account.toLowerCase()}`),
 	}),
 	requires: [GitHubAppCredentials, HttpClient.HttpClient, GitHubConfig],
 });

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

@@ -0,0 +1,40 @@
+import { Effect, Option, Schema, Stream } from "effect";
+import type { ServiceUnavailable } from "@shivaedev/errors/taxonomy.ts";
+import type { Representations } from "#representations.ts";
+
+export interface ListOptions<E = ServiceUnavailable> {
+	readonly arrayKey?: string | undefined;
+	readonly beforeRequest?: (resource: string) => Effect.Effect<void, E>;
+	readonly onDecodeError?: "fail" | "skip" | undefined;
+	readonly responseByteLimit?: number | undefined;
+}
+
+export function decodedPages<TSchema extends Schema.Constraint, E = ServiceUnavailable>(
+	client: Representations,
+	path: string,
+	schema: TSchema,
+	options: ListOptions<E> | number = {},
+) {
+	const settings = typeof options === "number" ? { responseByteLimit: options } : options;
+	const decode = Schema.decodeUnknownEffect(schema);
+	return Stream.unwrap(client.list(path, settings.beforeRequest, settings.responseByteLimit)).pipe(
+		Stream.mapEffect((page) =>
+			Effect.gen(function* () {
+				const body = yield* page.decode(Schema.Unknown);
+				const source =
+					settings.arrayKey === undefined
+						? body
+						: (yield* Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown))(body))[settings.arrayKey];
+				const values = yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Unknown))(source);
+				const decoded = yield* Effect.forEach(values, (value) =>
+					decode(value).pipe(
+						Effect.map(Option.some),
+						Effect.catchTag("SchemaError", (error) => (settings.onDecodeError === "skip" ? Effect.succeed(Option.none()) : Effect.fail(error))),
+					),
+				);
+				const items = decoded.flatMap(Option.toArray);
+				return { hasNext: page.hasNext, items, skipped: values.length - items.length };
+			}),
+		),
+	);
+}

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

@@ -0,0 +1,62 @@
+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<E = ServiceUnavailable> extends ListOptions<E> {
+	readonly query?: Readonly<Record<string, string | number | boolean | undefined>>;
+}
+
+export function repositoryReads(client: Representations) {
+	function repository(owner: string, repo: string) {
+		return `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`;
+	}
+	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) {
+				query.set(key, String(value));
+			}
+		}
+		return `${path}?${query}`;
+	}
+	return {
+		compareCommits: (owner: string, repo: string, base: string, head: string, byteLimit?: number) =>
+			Effect.flatMap(client.read(`${repository(owner, repo)}/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`, byteLimit), (page) =>
+				page.decode(Comparison),
+			),
+		getCollaboratorPermission: (owner: string, repo: string, username: string, byteLimit?: number) =>
+			Effect.flatMap(client.read(`${repository(owner, repo)}/collaborators/${encodeURIComponent(username)}/permission`, byteLimit), (page) =>
+				page.decode(CollaboratorPermission),
+			),
+		getCommit: (owner: string, repo: string, ref: string, byteLimit?: number) =>
+			Effect.flatMap(client.read(`${repository(owner, repo)}/commits/${encodeURIComponent(ref)}`, byteLimit), (page) => page.decode(CommitDetail)),
+		getIssue: (owner: string, repo: string, number: number, byteLimit?: number) =>
+			Effect.flatMap(client.read(`${repository(owner, repo)}/issues/${number}`, byteLimit), (page) => page.decode(Issue)),
+		getTree: (
+			owner: string,
+			repo: string,
+			sha: string,
+			options?: { readonly recursive?: boolean; readonly responseByteLimit?: number | undefined },
+		) =>
+			Effect.flatMap(
+				client.read(
+					`${repository(owner, repo)}/git/trees/${encodeURIComponent(sha)}${options?.recursive ? "?recursive=1" : ""}`,
+					options?.responseByteLimit,
+				),
+				(page) => page.decode(GitTree),
+			),
+		getUser: (username?: string, byteLimit?: number) =>
+			Effect.flatMap(client.read(username === undefined ? "/user" : `/users/${encodeURIComponent(username)}`, byteLimit), (page) =>
+				page.decode(User),
+			),
+		listCommits: <E = ServiceUnavailable>(owner: string, repo: string, options?: RepositoryListOptions<E>) =>
+			Effect.succeed(decodedPages(client, pathWithQuery(`${repository(owner, repo)}/commits`, options), Commit, options)),
+		listIssues: <E = ServiceUnavailable>(owner: string, repo: string, options?: RepositoryListOptions<E>) =>
+			Effect.succeed(decodedPages(client, pathWithQuery(`${repository(owner, repo)}/issues`, options), Issue, options)),
+		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)),
+	};
+}