@shivaedev/github 0.8.6 → 0.10.0

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);
 }

package/src/viewerRepositoryAccess.ts

@@ -0,0 +1,66 @@
+import { Cache, Effect, Exit, Schema, Stream } from "effect";
+import { decodedPages } from "#pagedLists.ts";
+import type { Representations } from "#representations.ts";
+
+export const InstalledRepository = Schema.Struct({
+	htmlUrl: Schema.String,
+	id: Schema.Number,
+	name: Schema.String,
+	owner: Schema.Struct({ login: Schema.String }),
+	private: Schema.Boolean,
+}).pipe(Schema.encodeKeys({ htmlUrl: "html_url" }));
+
+export interface ViewerRepositoryAccess {
+	readonly administrable: readonly (typeof InstalledRepository.Type & { readonly installationId: number })[];
+	readonly readable: readonly (typeof InstalledRepository.Type & { readonly installationId: number })[];
+}
+
+const Account = Schema.Struct({ login: Schema.String });
+const Installation = Schema.Struct({ id: Schema.Number });
+const Permission = Schema.Struct({ permission: Schema.String });
+
+const installationAccess = Effect.fnUntraced(function* (client: Representations, installationId: number, login: string) {
+	const pages = yield* decodedPages(client, "/installation/repositories?per_page=100", InstalledRepository, {
+		arrayKey: "repositories",
+	}).pipe(Stream.runCollect);
+	const readable: ViewerRepositoryAccess["readable"][number][] = [];
+	const administrable: ViewerRepositoryAccess["administrable"][number][] = [];
+	for (const repository of pages.flatMap((page) => page.items)) {
+		const permissionPath = `/repos/${encodeURIComponent(repository.owner.login)}/${encodeURIComponent(repository.name)}/collaborators/${encodeURIComponent(login)}/permission`;
+		const permission = yield* Effect.flatMap(client.read(permissionPath), (response) => response.decode(Permission)).pipe(
+			Effect.map((grant) => grant.permission),
+			Effect.catchTag("RemoteNotFound", () => Effect.succeed("none")),
+		);
+		const installed = { ...repository, installationId };
+		if (!repository.private || ["read", "triage", "write", "maintain", "admin"].includes(permission)) {
+			readable.push(installed);
+		}
+		if (permission === "admin") {
+			administrable.push(installed);
+		}
+	}
+	return { administrable, readable } satisfies ViewerRepositoryAccess;
+});
+
+export function viewerRepositoryAccess(app: Representations, installation: (id: number) => Effect.Effect<Representations>) {
+	const lookup = Effect.fnUntraced(function* (account: string) {
+		const path = account.startsWith("id:") ? `/user/${account.slice(3)}` : `/users/${encodeURIComponent(account.slice(6))}`;
+		const installations = yield* decodedPages(app, "/app/installations?per_page=100", Installation).pipe(Stream.runCollect);
+		const first = installations.flatMap((page) => page.items)[0];
+		if (first === undefined) {
+			return { administrable: [], readable: [] } satisfies ViewerRepositoryAccess;
+		}
+		const resolver = yield* installation(first.id);
+		const { login } = yield* Effect.flatMap(resolver.read(path), (response) => response.decode(Account));
+		const readable: ViewerRepositoryAccess["readable"][number][] = [];
+		const administrable: ViewerRepositoryAccess["administrable"][number][] = [];
+		for (const { id } of installations.flatMap((page) => page.items)) {
+			const client = yield* installation(id);
+			const access = yield* installationAccess(client, id, login);
+			readable.push(...access.readable);
+			administrable.push(...access.administrable);
+		}
+		return { administrable, readable } satisfies ViewerRepositoryAccess;
+	});
+	return Cache.makeWith(lookup, { capacity: 100, timeToLive: (exit) => (Exit.isSuccess(exit) ? "60 seconds" : 0) });
+}