@pepys/source-github 0.3.1 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pepys/source-github",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "The pepys GitHub plug-in: pull requests, releases, commits and deploys",
   "license": "MIT",
   "repository": {
@@ -19,9 +19,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@pepys/api": "0.3.1",
-    "@pepys/ingest": "0.3.1",
-    "@pepys/kit": "0.3.1",
+    "@pepys/api": "0.4.1",
+    "@pepys/ingest": "0.4.1",
+    "@pepys/kit": "0.4.1",
     "@zgeoff/std": "0.4.3",
     "kysely": "0.29.8",
     "ts-pattern": "5.9.2",
@@ -30,7 +30,8 @@
   "devDependencies": {
     "@msw/data": "1.1.8",
     "@orpc/client": "2.0.0-beta.50",
-    "@pepys/testing": "0.3.1",
+    "@pepys/mock-network": "0.0.0",
+    "@pepys/testing": "0.4.1",
     "msw": "3.0.3",
     "tiny-invariant": "1.3.3"
   }

package/src/consumers/github-pull-request.ts

@@ -1,11 +1,13 @@
 import {
   initGithubPullRequestModel,
+  readGithubPullRequestAliasRow,
   readGithubPullRequestRow,
   toGithubPullRequestID,
   updateGithubPullRequestModel,
 } from '../generated/github-pull-request-boundary.ts';
 import type {
   EntityID,
+  GithubPullRequestAliasRow,
   GithubPullRequestMessage,
   GithubPullRequestModel,
   GithubPullRequestOperation,
@@ -64,7 +66,71 @@ function mapFact(factJSON: string): GithubPullRequestOperation[] {
     .filter((bump) => !replacedKeys.has(JSON.stringify(bump)))
     .map((bump) => ({ upsert: { github_release_bump: bump } }));
 
-  return [{ upsert: { github_pull_request: row } }, ...removed, ...added];
+  const aliases: GithubPullRequestOperation[] = collectAliases(row)
+    .filter((alias) => shouldTakeAlias(alias, readGithubPullRequestAliasRow(alias.alias)))
+    .map((alias) => ({ upsert: { github_pull_request_alias: alias } }));
+
+  return [{ upsert: { github_pull_request: row } }, ...aliases, ...removed, ...added];
+}
+
+// The URL, and `<owner>/<repo>#<number>` when the URL has the `/<owner>/<repo>/pull/<number>`
+// path. GitHub matches an owner and a repository in any case, so each alias is in lowercase.
+function collectAliases(row: GithubPullRequestRow): GithubPullRequestAliasRow[] {
+  const url = trimTrailingSlash(row.url.toLowerCase());
+
+  const aliases: GithubPullRequestAliasRow[] = [
+    { alias: url, entity_id: row.id, updated_at: row.updated_at },
+  ];
+
+  const parts = url.split('/');
+  const [scheme, gap, host, owner, repository, pull, number] = parts;
+
+  if (
+    parts.length !== 7 ||
+    scheme === undefined ||
+    !scheme.endsWith(':') ||
+    gap !== '' ||
+    host === undefined ||
+    host === '' ||
+    owner === undefined ||
+    owner === '' ||
+    repository === undefined ||
+    repository === '' ||
+    pull !== 'pull' ||
+    number !== `${row.number}`
+  ) {
+    return aliases;
+  }
+
+  aliases.push({
+    alias: `${owner}/${repository}#${row.number}`,
+    entity_id: row.id,
+    updated_at: row.updated_at,
+  });
+
+  return aliases;
+}
+
+function trimTrailingSlash(text: string): string {
+  return text.endsWith('/') ? text.slice(0, -1) : text;
+}
+
+// The holder's own row is no guide after a rename, since its newest fact may name another
+// repository. The alias time keeps the outcome free of arrival order, and a tie between two pull
+// requests goes to the later fact, as it does for the pull request row.
+function shouldTakeAlias(
+  alias: GithubPullRequestAliasRow,
+  holding: GithubPullRequestAliasRow | undefined,
+): boolean {
+  if (holding === undefined) {
+    return true;
+  }
+
+  if (holding.updated_at !== alias.updated_at) {
+    return holding.updated_at < alias.updated_at;
+  }
+
+  return holding.entity_id !== alias.entity_id;
 }
 
 const releaseURLStart = 'https://github.com/';

package/src/families/issue-comment-family.ts

@@ -0,0 +1,19 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+import { buildFamilyTypes } from './build-family-types.ts';
+
+// The `action` values of GitHub's `issue_comment` webhook event, which covers the conversation
+// comments of both issues and pull requests.
+const actions = ['created', 'deleted', 'edited', 'pinned', 'unpinned'] as const;
+
+const payloadSchema = z.looseObject({
+  action: z.string(),
+  comment: z.looseObject({ id: z.number().int() }),
+});
+
+export const issueCommentFamily = defineFactFamily({
+  stream: 'facts.github.issue_comment',
+  api: 'github/2022-11-28',
+  entityKind: 'github:issue_comment',
+  types: buildFamilyTypes('issue_comment', actions, payloadSchema),
+});

package/src/families/repository-family.ts

@@ -0,0 +1,28 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+import { buildFamilyTypes } from './build-family-types.ts';
+
+// The `action` values of GitHub's `repository` webhook event.
+const actions = [
+  'archived',
+  'created',
+  'deleted',
+  'edited',
+  'privatized',
+  'publicized',
+  'renamed',
+  'transferred',
+  'unarchived',
+] as const;
+
+const payloadSchema = z.looseObject({
+  action: z.string(),
+  repository: z.looseObject({ id: z.number().int() }),
+});
+
+export const repositoryFamily = defineFactFamily({
+  stream: 'facts.github.repository',
+  api: 'github/2022-11-28',
+  entityKind: 'github:repo',
+  types: buildFamilyTypes('repository', actions, payloadSchema),
+});

package/src/families/review-comment-family.ts

@@ -0,0 +1,18 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+import { buildFamilyTypes } from './build-family-types.ts';
+
+// The `action` values of GitHub's `pull_request_review_comment` webhook event.
+const actions = ['created', 'deleted', 'edited'] as const;
+
+const payloadSchema = z.looseObject({
+  action: z.string(),
+  comment: z.looseObject({ id: z.number().int() }),
+});
+
+export const reviewCommentFamily = defineFactFamily({
+  stream: 'facts.github.review_comment',
+  api: 'github/2022-11-28',
+  entityKind: 'github:review_comment',
+  types: buildFamilyTypes('review_comment', actions, payloadSchema),
+});

package/src/families/review-thread-family.ts

@@ -0,0 +1,19 @@
+import { defineFactFamily } from '@pepys/kit';
+import { z } from 'zod';
+import { buildFamilyTypes } from './build-family-types.ts';
+
+// The `action` values of GitHub's `pull_request_review_thread` webhook event.
+const actions = ['resolved', 'unresolved'] as const;
+const commentSchema = z.looseObject({ id: z.number().int() });
+
+const payloadSchema = z.looseObject({
+  action: z.string(),
+  thread: z.looseObject({ comments: z.array(commentSchema) }),
+});
+
+export const reviewThreadFamily = defineFactFamily({
+  stream: 'facts.github.review_thread',
+  api: 'github/2022-11-28',
+  entityKind: 'github:review_thread',
+  types: buildFamilyTypes('review_thread', actions, payloadSchema),
+});

package/src/generated/github-pull-request-boundary.ts

@@ -176,6 +176,12 @@ export interface GithubPullRequestRow {
   payload: unknown;
 }
 
+export interface GithubPullRequestAliasRow {
+  alias: string;
+  entity_id: EntityID;
+  updated_at: string;
+}
+
 export interface GithubReleaseBumpRow {
   pull_request_id: EntityID;
   release_repository: string;
@@ -186,6 +192,10 @@ export interface GithubPullRequestKey {
   id: GithubPullRequestID;
 }
 
+export interface GithubPullRequestAliasKey {
+  alias: string;
+}
+
 export interface GithubReleaseBumpKey {
   pull_request_id: EntityID;
   release_repository: string;
@@ -195,6 +205,8 @@ export interface GithubReleaseBumpKey {
 export type GithubPullRequestOperation =
   | { upsert: { github_pull_request: GithubPullRequestRow } }
   | { delete: { github_pull_request: GithubPullRequestKey } }
+  | { upsert: { github_pull_request_alias: GithubPullRequestAliasRow } }
+  | { delete: { github_pull_request_alias: GithubPullRequestAliasKey } }
   | { upsert: { github_release_bump: GithubReleaseBumpRow } }
   | { delete: { github_release_bump: GithubReleaseBumpKey } };
 
@@ -297,6 +309,45 @@ export function readGithubPullRequestRow(key: string): GithubPullRequestRow | un
   };
 }
 
+declare function readGithubPullRequestAliasLength(key: string): number;
+declare function readGithubPullRequestAliasInto(key: string, row: Uint8Array): void;
+
+export function readGithubPullRequestAliasRow(key: string): GithubPullRequestAliasRow | undefined {
+  const length = readGithubPullRequestAliasLength(key);
+
+  if (length < 0) {
+    return undefined;
+  }
+
+  const row = new Uint8Array(length);
+
+  readGithubPullRequestAliasInto(key, row);
+
+  const parsed: unknown = JSON.parse(new TextDecoder().decode(row));
+
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    return undefined;
+  }
+
+  if (!('alias' in parsed) || (typeof parsed.alias !== 'string')) {
+    return undefined;
+  }
+
+  if (!('entity_id' in parsed) || (!isEntityID(parsed.entity_id))) {
+    return undefined;
+  }
+
+  if (!('updated_at' in parsed) || (typeof parsed.updated_at !== 'string')) {
+    return undefined;
+  }
+
+  return {
+    alias: parsed.alias,
+    entity_id: parsed.entity_id,
+    updated_at: parsed.updated_at,
+  };
+}
+
 function isEntityID(value: unknown): value is EntityID {
   return typeof value === 'string';
 }

package/src/generated/github-pull-request.sql

@@ -21,6 +21,15 @@ CREATE TABLE "github_pull_request" (
 
 CREATE INDEX "github_pull_request_repository_id_idx" ON "github_pull_request" ("repository_id");
 
+CREATE TABLE "github_pull_request_alias" (
+  "alias" TEXT NOT NULL,
+  "entity_id" TEXT NOT NULL,
+  "updated_at" TEXT NOT NULL,
+  PRIMARY KEY ("alias")
+);
+
+CREATE INDEX "github_pull_request_alias_entity_id_idx" ON "github_pull_request_alias" ("entity_id");
+
 CREATE TABLE "github_release_bump" (
   "pull_request_id" TEXT NOT NULL,
   "release_repository" TEXT NOT NULL,

package/src/github-pull-request-consumer.ts

@@ -28,6 +28,19 @@ export const githubPullRequestConsumer = defineConsumer({
       indexes: [{ columns: ['repository_id'] }],
     }),
 
+    // Each form a person writes for a pull request: its URL and `<owner>/<repo>#<number>`, in
+    // lowercase, with the update time of the newest fact that names it. A rename adds the new forms
+    // and keeps the old ones. A form moves only to a fact newer than that time.
+    github_pull_request_alias: defineTable({
+      columns: {
+        alias: { kind: 'text' },
+        entity_id: { kind: 'entityID' },
+        updated_at: { kind: 'timestamp' },
+      },
+      primaryKey: ['alias'],
+      indexes: [{ columns: ['entity_id'] }],
+    }),
+
     // One row per release that a bot's pull request names in its body, by the release URL. The rows
     // follow the pull request row: a fact that loses writes none, and one that wins replaces them.
     github_release_bump: defineTable({
@@ -51,6 +64,6 @@ export const githubPullRequestConsumer = defineConsumer({
       updatedAt: 'updated_at',
     },
   ],
-  reads: ['github_pull_request'],
+  reads: ['github_pull_request', 'github_pull_request_alias'],
   links: [],
 });

package/src/github-source.ts

@@ -1,10 +1,14 @@
 import { defineSource } from '@pepys/kit';
 import { deploymentFamily } from './families/deployment-family.ts';
+import { issueCommentFamily } from './families/issue-comment-family.ts';
 import { issueFamily } from './families/issue-family.ts';
 import { pullRequestFamily } from './families/pull-request-family.ts';
 import { pullRequestReviewFamily } from './families/pull-request-review-family.ts';
 import { refFamily } from './families/ref-family.ts';
 import { releaseFamily } from './families/release-family.ts';
+import { repositoryFamily } from './families/repository-family.ts';
+import { reviewCommentFamily } from './families/review-comment-family.ts';
+import { reviewThreadFamily } from './families/review-thread-family.ts';
 import { workflowRunFamily } from './families/workflow-run-family.ts';
 import { readGithubDelivery } from './ingest/read-github-delivery.ts';
 import { pullFailedDeliveries } from './ingest/recovery/pull-failed-deliveries.ts';
@@ -13,7 +17,7 @@ import { pullMarkedObjects } from './ingest/resync/pull-marked-objects.ts';
 // The GitHub App that both pulls call the API as.
 const appEnv = ['PEPYS_GITHUB_APP_ID', 'PEPYS_GITHUB_APP_PRIVATE_KEY'];
 
-// One webhook route, checked by GitHub's signature, for seven families. The recovery pull reads
+// One webhook route, checked by GitHub's signature, for eleven families. The recovery pull reads
 // each failed delivery every hour; the resync pull reads each marked object every minute.
 export const githubSource = defineSource({
   name: 'github',
@@ -25,6 +29,10 @@ export const githubSource = defineSource({
     workflowRunFamily,
     issueFamily,
     pullRequestReviewFamily,
+    reviewCommentFamily,
+    reviewThreadFamily,
+    issueCommentFamily,
+    repositoryFamily,
   ],
   live: {
     kind: 'receive',

package/src/ingest/build-github-fact.ts

@@ -2,7 +2,7 @@ import { parseFactEnvelope } from '@pepys/kit';
 import type { PendingFact, StreamName } from '@pepys/kit';
 import { toTagged } from '@zgeoff/std';
 import { match } from 'ts-pattern';
-import { buildBodyHash } from '../utils/build-body-hash.ts';
+import { buildBodyHash } from './build-body-hash.ts';
 import { githubEventRules } from './github-event-rules.ts';
 
 // `delivery`: a webhook body, from the receive path or the recovery pull. `observation`: an object

package/src/ingest/github-app/read-installation-token.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { requestGithubAPI } from './request-github-api.ts';
+import type { GithubCall } from './request-github-api.ts';
 
 // `not-installed`: the App has no installation on the repository, so it can read nothing there.
 export type InstallationToken =
@@ -14,8 +15,9 @@ const accessTokenSchema = z.looseObject({ token: z.string().min(1) });
 export async function readInstallationToken(
   repository: string,
   appJWT: string,
+  call: GithubCall,
 ): Promise<InstallationToken> {
-  const installation = await requestGithubAPI(`/repos/${repository}/installation`, appJWT);
+  const installation = await requestGithubAPI(`/repos/${repository}/installation`, appJWT, call);
 
   if (installation.status === 404) {
     return { kind: 'not-installed' };
@@ -30,6 +32,7 @@ export async function readInstallationToken(
   const created = await requestGithubAPI(
     `/app/installations/${parsedInstallation.data.id}/access_tokens`,
     appJWT,
+    call,
     'POST',
   );
 

package/src/ingest/github-app/request-github-api.ts

@@ -1,3 +1,4 @@
+import type { Logger } from '@pepys/kit';
 import { githubAPIURL } from './github-api-url.ts';
 
 // One answer of the GitHub REST API. `text` is the body as sent, for a caller that must read a
@@ -9,39 +10,54 @@ export interface GithubAnswer {
   next: string | undefined;
 }
 
+// What each call needs from the pull that makes it: the logger, and the signal that aborts the call
+// when ingest stops.
+export interface GithubCall {
+  log: Logger;
+  signal: AbortSignal;
+}
+
 // One call to the GitHub REST API, with a path or a whole URL from a `link` header. A transport
-// failure answers status 0.
+// failure, an aborted call included, answers status 0.
 export async function requestGithubAPI(
   pathOrURL: string,
   token: string,
+  call: GithubCall,
   method: 'GET' | 'POST' = 'GET',
 ): Promise<GithubAnswer> {
   const url = pathOrURL.startsWith('/') ? `${githubAPIURL}${pathOrURL}` : pathOrURL;
 
-  const response = await sendRequest(url, token, method);
+  const response = await sendRequest(url, token, method, call);
 
   if (response === undefined) {
     return { status: 0, text: '', body: undefined, next: undefined };
   }
 
-  const text = await response.text();
-
   return {
     status: response.status,
-    text,
-    body: parseBody(text),
+    text: response.text,
+    body: parseBody(response.text),
     next: findNextPage(response.headers.get('link')),
   };
 }
 
+interface SentRequest {
+  status: number;
+  text: string;
+  headers: Headers;
+}
+
+// The body is read inside the `try`, so an abort while GitHub still sends it counts as a failed call.
 async function sendRequest(
   url: string,
   token: string,
   method: 'GET' | 'POST',
-): Promise<Response | undefined> {
+  call: GithubCall,
+): Promise<SentRequest | undefined> {
   try {
     const response = await fetch(url, {
       method,
+      signal: call.signal,
       headers: {
         accept: 'application/vnd.github+json',
         authorization: `Bearer ${token}`,
@@ -50,9 +66,14 @@ async function sendRequest(
       },
     });
 
-    return response;
+    const text = await response.text();
+
+    return { status: response.status, text, headers: response.headers };
   } catch (error: unknown) {
-    console.error(`a GitHub API call to ${url} failed`, error);
+    // a call that ingest's stop aborted is no failure
+    if (!call.signal.aborted) {
+      call.log.error(`a GitHub API call to ${url} failed`, error);
+    }
 
     return undefined;
   }

package/src/ingest/github-event-rules.ts

@@ -1,11 +1,15 @@
 import type { FactFamily } from '@pepys/kit';
 import { z } from 'zod';
 import { deploymentFamily } from '../families/deployment-family.ts';
+import { issueCommentFamily } from '../families/issue-comment-family.ts';
 import { issueFamily } from '../families/issue-family.ts';
 import { pullRequestFamily } from '../families/pull-request-family.ts';
 import { pullRequestReviewFamily } from '../families/pull-request-review-family.ts';
 import { refFamily } from '../families/ref-family.ts';
 import { releaseFamily } from '../families/release-family.ts';
+import { repositoryFamily } from '../families/repository-family.ts';
+import { reviewCommentFamily } from '../families/review-comment-family.ts';
+import { reviewThreadFamily } from '../families/review-thread-family.ts';
 import { workflowRunFamily } from '../families/workflow-run-family.ts';
 
 // What a rule reads from one delivery body. `locator` is the API path the resync pull reads the
@@ -95,6 +99,37 @@ const reviewBodySchema = z.looseObject({
   sender: senderSchema,
 });
 
+const commentBodySchema = z.looseObject({
+  action: z.string().min(1),
+  comment: z.looseObject({ id: z.number().int(), updated_at: timeSchema }),
+  sender: senderSchema,
+});
+
+const threadCommentSchema = z.looseObject({
+  id: z.number().int(),
+  in_reply_to_id: z.number().int().nullish(),
+});
+
+const reviewThreadBodySchema = z.looseObject({
+  action: z.string().min(1),
+  thread: z.looseObject({ comments: z.array(threadCommentSchema) }),
+  updated_at: timeSchema.nullish(),
+  pull_request: z.looseObject({ updated_at: timeSchema }),
+  sender: senderSchema,
+});
+
+const secondsOrTimeSchema = z.union([z.number().int(), timeSchema]);
+
+const repositoryBodySchema = z.looseObject({
+  action: z.string().min(1),
+  repository: z.looseObject({
+    id: z.number().int(),
+    created_at: secondsOrTimeSchema.nullish(),
+    updated_at: timeSchema.nullish(),
+  }),
+  sender: senderSchema,
+});
+
 // One rule per webhook event name. Any other event is ignored.
 export const githubEventRules: Readonly<Record<string, GithubEventRule>> = {
   pull_request: {
@@ -261,6 +296,82 @@ export const githubEventRules: Readonly<Record<string, GithubEventRule>> = {
       );
     },
   },
+  pull_request_review_comment: {
+    family: reviewCommentFamily,
+    read: (body) => {
+      const parsed = commentBodySchema.safeParse(body);
+
+      if (!parsed.success) {
+        return 'invalid';
+      }
+
+      return pickFields(reviewCommentFamily, `github.review_comment.${parsed.data.action}`, {
+        entity: `github:review_comment:${parsed.data.comment.id}`,
+        actor: parsed.data.sender,
+        time: parsed.data.comment.updated_at,
+        locator: undefined,
+      });
+    },
+  },
+  pull_request_review_thread: {
+    family: reviewThreadFamily,
+    read: (body) => {
+      const parsed = reviewThreadBodySchema.safeParse(body);
+
+      if (!parsed.success) {
+        return 'invalid';
+      }
+
+      const firstCommentID = findFirstCommentID(parsed.data.thread.comments);
+
+      if (firstCommentID === undefined) {
+        return 'invalid';
+      }
+
+      return pickFields(reviewThreadFamily, `github.review_thread.${parsed.data.action}`, {
+        entity: `github:review_thread:${firstCommentID}`,
+        actor: parsed.data.sender,
+        time: parsed.data.updated_at ?? parsed.data.pull_request.updated_at,
+        locator: undefined,
+      });
+    },
+  },
+  issue_comment: {
+    family: issueCommentFamily,
+    read: (body) => {
+      const parsed = commentBodySchema.safeParse(body);
+
+      if (!parsed.success) {
+        return 'invalid';
+      }
+
+      return pickFields(issueCommentFamily, `github.issue_comment.${parsed.data.action}`, {
+        entity: `github:issue_comment:${parsed.data.comment.id}`,
+        actor: parsed.data.sender,
+        time: parsed.data.comment.updated_at,
+        locator: undefined,
+      });
+    },
+  },
+  repository: {
+    family: repositoryFamily,
+    read: (body) => {
+      const parsed = repositoryBodySchema.safeParse(body);
+
+      if (!parsed.success) {
+        return 'invalid';
+      }
+
+      const repository = parsed.data.repository;
+
+      return pickFields(repositoryFamily, `github.repository.${parsed.data.action}`, {
+        entity: `github:repo:${repository.id}`,
+        actor: parsed.data.sender,
+        time: repository.updated_at ?? toRepositoryTime(repository.created_at),
+        locator: undefined,
+      });
+    },
+  },
 };
 
 interface RuleValues {
@@ -322,3 +433,20 @@ function toAPIPath(url: string | undefined): string | undefined {
 
   return path.startsWith('/repos/') ? path : undefined;
 }
+
+// GitHub points every reply at the first comment of its thread, so a thread whose first comment
+// was deleted still gives that comment's ID.
+function findFirstCommentID(
+  comments: readonly z.infer<typeof threadCommentSchema>[],
+): number | undefined {
+  const first = comments.find(
+    (comment) => comment.in_reply_to_id === undefined || comment.in_reply_to_id === null,
+  );
+
+  return first?.id ?? comments[0]?.in_reply_to_id ?? undefined;
+}
+
+// GitHub's repository schema allows a repository's `created_at` as Unix seconds as well as text.
+function toRepositoryTime(time: number | string | null | undefined): string | null | undefined {
+  return typeof time === 'number' ? new Date(time * 1000).toISOString() : time;
+}

package/src/ingest/recovery/pull-failed-deliveries.ts

@@ -5,7 +5,7 @@ import { buildGithubFact } from '../build-github-fact.ts';
 import { findAppJWT } from '../github-app/find-app-jwt.ts';
 import { pickPullFailure } from '../github-app/pick-pull-failure.ts';
 import { requestGithubAPI } from '../github-app/request-github-api.ts';
-import type { GithubAnswer } from '../github-app/request-github-api.ts';
+import type { GithubAnswer, GithubCall } from '../github-app/request-github-api.ts';
 
 const deliveryDetailSchema = z.looseObject({
   event: z.string(),
@@ -27,7 +27,7 @@ export async function pullFailedDeliveries(
 
   const seenID = cursor === null ? 0n : BigInt(cursor);
 
-  const listed = await readDeliveriesAfter(seenID, appJWT);
+  const listed = await readDeliveriesAfter(seenID, appJWT, context);
 
   if (listed.kind !== 'listed') {
     return pickPullFailure(listed.status);
@@ -36,7 +36,7 @@ export async function pullFailedDeliveries(
   const facts: PendingFact[] = [];
 
   for (const id of collectFailedIDs(listed.items)) {
-    const answer = await requestGithubAPI(`/app/hook/deliveries/${id}`, appJWT);
+    const answer = await requestGithubAPI(`/app/hook/deliveries/${id}`, appJWT, context);
 
     const detail = deliveryDetailSchema.safeParse(answer.body);
 
@@ -55,7 +55,7 @@ export async function pullFailedDeliveries(
     // The receive path answers 413 to a body this large and stores nothing; a batch that held it
     // would be refused whole, with every other delivery and the cursor.
     if (!planAppends([fact.fact]).ok) {
-      console.error(`the GitHub delivery ${id} is larger than one append of the log takes`);
+      context.log.error(`the GitHub delivery ${id} is larger than one append of the log takes`);
       continue;
     }
 
@@ -87,12 +87,16 @@ type DeliveryItem = z.infer<typeof deliveryItemSchema>;
 type DeliveryList = { kind: 'listed'; items: DeliveryItem[] } | { kind: 'failed'; status: number };
 
 // GitHub lists the newest delivery first, so the pages stop at the first one already seen.
-async function readDeliveriesAfter(seenID: bigint, appJWT: string): Promise<DeliveryList> {
+async function readDeliveriesAfter(
+  seenID: bigint,
+  appJWT: string,
+  call: GithubCall,
+): Promise<DeliveryList> {
   const items: DeliveryItem[] = [];
   let url: string | undefined = '/app/hook/deliveries?per_page=100';
 
   while (url !== undefined) {
-    const answer: GithubAnswer = await requestGithubAPI(url, appJWT);
+    const answer: GithubAnswer = await requestGithubAPI(url, appJWT, call);
 
     const page = deliveryListSchema.safeParse(parseDeliveryList(answer.text));
 

package/src/ingest/resync/pull-marked-objects.ts

@@ -7,6 +7,7 @@ import { pickPullFailure } from '../github-app/pick-pull-failure.ts';
 import { readInstallationToken } from '../github-app/read-installation-token.ts';
 import type { InstallationToken } from '../github-app/read-installation-token.ts';
 import { requestGithubAPI } from '../github-app/request-github-api.ts';
+import type { GithubCall } from '../github-app/request-github-api.ts';
 import { collectResyncTargets } from './collect-resync-targets.ts';
 import type { ResyncTarget } from './collect-resync-targets.ts';
 
@@ -34,7 +35,7 @@ export async function pullMarkedObjects(
   const facts: PendingFact[] = [];
 
   for (const target of targets) {
-    const token = await readCachedToken(tokens, target.repository, appJWT);
+    const token = await readCachedToken(tokens, target.repository, appJWT, context);
 
     if (token.kind === 'failed') {
       return pickPullFailure(token.status);
@@ -44,7 +45,7 @@ export async function pullMarkedObjects(
       continue;
     }
 
-    const read = await readObject(target, token.token);
+    const read = await readObject(target, token.token, context);
 
     if (read.kind === 'failed') {
       return pickPullFailure(read.status);
@@ -63,6 +64,7 @@ async function readCachedToken(
   tokens: Map<string, InstallationToken>,
   repository: string,
   appJWT: string,
+  call: GithubCall,
 ): Promise<InstallationToken> {
   const known = tokens.get(repository);
 
@@ -70,7 +72,7 @@ async function readCachedToken(
     return known;
   }
 
-  const token = await readInstallationToken(repository, appJWT);
+  const token = await readInstallationToken(repository, appJWT, call);
 
   tokens.set(repository, token);
 
@@ -87,8 +89,12 @@ type ReadObject =
 // An object the API answers 404 for is left alone. GitHub deletes no pull request, and shows a draft
 // release only to a token that can push, so a 404 cannot prove a delete. A deleted release's own
 // `deleted` delivery sets its tombstone.
-async function readObject(target: ResyncTarget, token: string): Promise<ReadObject> {
-  const answer = await requestGithubAPI(target.path, token);
+async function readObject(
+  target: ResyncTarget,
+  token: string,
+  call: GithubCall,
+): Promise<ReadObject> {
+  const answer = await requestGithubAPI(target.path, token, call);
 
   if (answer.status === 404) {
     return { kind: 'none' };
@@ -106,7 +112,7 @@ async function readObject(target: ResyncTarget, token: string): Promise<ReadObje
     );
   }
 
-  const repository = await requestGithubAPI(`/repos/${target.repository}`, token);
+  const repository = await requestGithubAPI(`/repos/${target.repository}`, token, call);
 
   const parsed = repositorySchema.safeParse(repository.body);