dd46282 · 4837233 · 4ec255e
@@ -4,6 +4,17 @@
Connect another forge at `/settings/origins` the way you connect Forgejo: type i
- **Picker:** `GET /api/v1/user/repos` lists the token's account's repositories, private ones included, in the Gitea shape. Only that route speaks the Gitea shape; a repository's own JSON is unchanged.
- **Credential:** the token travels as `Authorization: token …` for the API (accepted as a Bearer token) and as Basic through `GIT_CONFIG_*` for git — never argv, never config.
- **Mirror:** brings the code and its history. The origin's card and `GET /api/v1/user/origins` (`carries`) say what did not come: issues, pulls, comments and labels (not yet), how the app runs (not yet), and its data and secrets (never by default).
- **Mirror:** brings the code and its history, and the issues, pulls and comments, read in the forge's own JSON (`src/origins/providers/forge-work.ts`) with the real author kept. The origin's card and `GET /api/v1/user/origins` (`carries`) say what did not come: labels and how the app runs (not yet), and its data and secrets (never by default).
- **Write-through:** a comment, an issue or a state change here goes to the other forge first, with the connecting person's token (`rw` needed), and is refused with nothing changed here when the forge is down or says no. A pull is opened there with `createPull` (the contribute path); its merge comes back with the next sync.
Not in this piece, in order: sign in through OAuth, migrate an app whole with its run and build, follow upstream between forges with a pull back, and the one-page paste-a-link path. Test: `test/forge-origin.test.ts` runs two forges against each other.
Not yet: webhooks and a catch-up for missed events, review and check state coming back live, guest rules for a crew on the receiving side, following upstream with one action.
Not in the first piece, in order: sign in through OAuth, migrate an app whole with its run and build, follow upstream between forges with a pull back, and the one-page paste-a-link path. Test: `test/forge-origin.test.ts` runs two forges against each other.
## Both doors, and what was exercised
The terminal reaches the same code as the web and the API: `src/tui/screens/issue.ts` and `pull.ts` comment and change state through `addCommentThrough` and `setIssueStateThrough` (`src/actions/issues.ts`), which call `providers.createComment` / `setState` when the repository is a mirror. No terminal screen or entry changed, so the write-through tests cover it; there is no separate terminal path to test.
A forge's comments carry no edit time, so `updatedAt` is read when the forge sends one and is the creation time otherwise: an edited comment syncs once the forge reports edits. A thread is paged to its end; one of more than 100,000 comments is a failed sync, never a short one.
The preview of the pull was not exercised: the write-through is proven by `test/forge-origin.test.ts` (two forges in one process, including the origin going down and coming back), not by hand on the preview.
@@ -0,0 +1,78 @@
/**
 * The work on another forge, read and written in that forge's own JSON.
 *
 * A forge's issues, pulls and comments are not Gitea's: the author is
 * `authorName` (or `originAuthor` when the thread was itself brought across),
 * labels are `{name}`, a list pages by `next_cursor` and a thread by `next`.
 * Plain data in, plain data out: these turn one such value into the shape
 * every provider returns, and `ForgeProvider` does the calling.
 */
import type { RemoteComment, RemoteIssue } from "../types.ts";
import { asId, asNumber, asState, asString, asTime, field, labelNames } from "./http.ts";
const authorOf = (raw: unknown): string =>
  asString(field(raw, "originAuthor")) || asString(field(raw, "authorName"));
/** An issue, or a pull when it carries branches. */
export function toForgeWork(raw: unknown, webUrl: string, fullName: string): RemoteIssue {
  const created = asTime(field(raw, "createdAt")) ?? new Date().toISOString();
  const number = asNumber(field(raw, "number"));
  const base = asString(field(raw, "baseBranch"));
  const issue: RemoteIssue = {
    remoteId: asId(field(raw, "id")),
    number,
    title: asString(field(raw, "title")),
    body: asString(field(raw, "body")),
    author: authorOf(raw),
    state: asState(field(raw, "state")),
    labels: labelNames(field(raw, "labels")),
    createdAt: created,
    updatedAt: asTime(field(raw, "updatedAt")) ?? created,
    closedAt: asTime(field(raw, "closedAt")),
    htmlUrl: `${webUrl}/${fullName}/${base === "" ? "issues" : "pulls"}/${number}`,
    comments: asNumber(field(raw, "comments")),
  };
  if (base === "") return issue;
  return {
    ...issue,
    pull: {
      baseBranch: base,
      headBranch: asString(field(raw, "headBranch")),
      headRepo: asString(field(raw, "originHeadRepo")) || fullName,
      baseOid: asString(field(raw, "baseOid")),
      headOid: asString(field(raw, "headOid")),
      mergedAt: asTime(field(raw, "mergedAt")),
      draft: false,
    },
  };
}
/**
 * A comment, linked to its thread (a pull answers at `issues/N` too) at the
 * anchor the thread page gives it. A forge's comments carry no edit time of
 * their own; `updatedAt` is read when one does, else the creation time.
 */
export function toForgeComment(
  raw: unknown,
  webUrl: string,
  fullName: string,
  number: number,
): RemoteComment {
  const created = asTime(field(raw, "createdAt")) ?? new Date().toISOString();
  const id = asId(field(raw, "id"));
  return {
    remoteId: id,
    author: authorOf(raw),
    body: asString(field(raw, "body")),
    createdAt: created,
    updatedAt: asTime(field(raw, "updatedAt")) ?? created,
    htmlUrl: `${webUrl}/${fullName}/issues/${number}#c-${id}`,
  };
}
/** The cursor a list hands back, as the string the next call sends. */
export function forgeCursor(raw: unknown): string | null {
  const next = field(raw, "next_cursor") ?? field(raw, "next");
  return typeof next === "number" || (typeof next === "string" && next !== "") ? String(next) : null;
}
@@ -4,14 +4,15 @@
 * A forge answers the Gitea dialect only for the one list connecting needs,
 * `GET /user/repos`; who you are and one repository are read in its own
 * shape, so the rest of its API grows no Gitea fields. Git comes over HTTPS
 * as ever. What a forge does not yet answer to an origin is its issues,
 * pulls, comments and labels: those reads say "none" rather than failing, so
 * the mirror brings the code across and settles, and the origin's `carries`
 * note says what did not come.
 * as ever. Issues, pulls and comments are read and written in its own JSON
 * (`forge-work.ts`); labels do not come yet and say "none" rather than
 * failing, and the origin's `carries` note says so.
 */
import type {
  ListIssuesQuery,
  Page,
  RemoteComment,
  ProviderResult,
  RemoteIdentity,
  RemoteLabel,
@@ -21,8 +22,10 @@
import type {
} from "../types.ts";
import { ForgejoProvider, nextPage, toRepo } from "./forgejo.ts";
import { NO_ACCOUNT } from "../words.ts";
import { forgeCursor, toForgeComment, toForgeWork } from "./forge-work.ts";
import { asArray, asString, dig, fail, field, seg, splitFullName, succeed } from "./http.ts";
const MAX_COMMENT_PAGES = 1000;
const NONE = { ok: true, value: [] } as const;
export class ForgeProvider extends ForgejoProvider {
@@ -89,7 +92,148 @@
export class ForgeProvider extends ForgejoProvider {
    return Promise.resolve(NONE);
  }
  override listIssues(): Promise<ProviderResult<Page<RemoteIssue>>> {
    return Promise.resolve({ ok: true, value: { items: [], next: null } });
  private repoPath(fullName: string): string | undefined {
    const named = splitFullName(fullName);
    return named ? `/repos/${seg(named.owner)}/${seg(named.name)}` : undefined;
  }
  /** Issues or pulls, newest first, a page at a time. */
  override async listIssues(
    fullName: string,
    query: ListIssuesQuery,
  ): Promise<ProviderResult<Page<RemoteIssue>>> {
    const base = this.repoPath(fullName);
    if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
    const limit = await this.pageSize();
    const result = await this.api.call({
      path: `${base}/${query.kind === "pull" ? "pulls" : "issues"}`,
      query: {
        state: query.state,
        limit,
        ...(query.cursor === undefined ? {} : { cursor: query.cursor }),
      },
    });
    if (!result.ok) return result;
    const rows = asArray(field(result.value.data, "items")).filter(
      (raw) => raw !== null && typeof raw === "object",
    );
    const items = rows
      .map((raw) => toForgeWork(raw, this.webUrl, fullName))
      .filter((i) => query.since === undefined || i.updatedAt >= query.since);
    return succeed({ items, next: forgeCursor(result.value.data) });
  }
  override async getIssue(fullName: string, number: number): Promise<ProviderResult<RemoteIssue>> {
    const base = this.repoPath(fullName);
    if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
    let result = await this.api.call({ path: `${base}/issues/${number}` });
    // A pull answers at `/issues` too, but only `/pulls` carries its branches and merge.
    if (result.ok && asString(field(result.value.data, "kind")) === "pull")
      result = await this.api.call({ path: `${base}/pulls/${number}`, query: { diff: 0 } });
    if (!result.ok) return result;
    return succeed(toForgeWork(result.value.data, this.webUrl, fullName));
  }
  override async listComments(
    fullName: string,
    number: number,
    since?: string,
  ): Promise<ProviderResult<readonly RemoteComment[]>> {
    const base = this.repoPath(fullName);
    if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
    const comments: RemoteComment[] = [];
    let after: string | undefined;
    // A thread comes oldest first, `next` the id to continue after. Paging
    // stops at the end of the thread; a thread that never ends is a failure,
    // not a short list.
    for (let page = 0; ; page++) {
      if (page >= MAX_COMMENT_PAGES)
        return fail("invalid_response", `thread ${number} has more than ${MAX_COMMENT_PAGES * 100} comments`);
      const result = await this.api.call({
        path: `${base}/issues/${number}/comments`,
        query: { limit: 100, ...(after === undefined ? {} : { after }) },
      });
      if (!result.ok) return result;
      for (const raw of asArray(field(result.value.data, "comments")))
        comments.push(toForgeComment(raw, this.webUrl, fullName, number));
      after = forgeCursor(result.value.data) ?? undefined;
      if (after === undefined) break;
    }
    return succeed(since === undefined ? comments : comments.filter((c) => c.updatedAt >= since));
  }
  override async createIssue(
    fullName: string,
    input: { title: string; body: string; labels?: readonly string[] },
  ): Promise<ProviderResult<RemoteIssue>> {
    const base = this.repoPath(fullName);
    if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
    const result = await this.api.call({
      path: `${base}/issues`,
      method: "POST",
      body: { title: input.title, body: input.body },
    });
    if (!result.ok) return result;
    return succeed(toForgeWork(result.value.data, this.webUrl, fullName));
  }
  override async createComment(
    fullName: string,
    number: number,
    body: string,
  ): Promise<ProviderResult<RemoteComment>> {
    const base = this.repoPath(fullName);
    if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
    const result = await this.api.call({
      path: `${base}/issues/${number}/comments`,
      method: "POST",
      body: { body },
    });
    if (!result.ok) return result;
    return succeed(toForgeComment(result.value.data, this.webUrl, fullName, number));
  }
  override async createPull(
    fullName: string,
    input: { title: string; body: string; base: string; head: string },
  ): Promise<ProviderResult<RemoteIssue>> {
    const named = splitFullName(fullName);
    if (!named) return fail("not_found", `not a repository name: ${fullName}`);
    const path = `/repos/${seg(named.owner)}/${seg(named.name)}`;
    // A fork's branch is `owner:branch`; a forge names it as head plus headRepo.
    const parts = input.head.split(":");
    if (parts.length > 2 || parts.some((p) => p === ""))
      return fail("not_found", `not a branch: ${input.head}`);
    const [owner, branch] = parts.length === 2 ? parts : [undefined, parts[0]];
    const name = named.name;
    const result = await this.api.call({
      path: `${path}/pulls`,
      method: "POST",
      body: {
        title: input.title,
        body: input.body,
        base: input.base,
        head: branch,
        ...(owner === undefined ? {} : { headRepo: `${owner}/${name}` }),
      },
    });
    if (!result.ok) return result;
    return succeed(toForgeWork(result.value.data, this.webUrl, fullName));
  }
  override async setState(
    fullName: string,
    number: number,
    state: "open" | "closed",
  ): Promise<ProviderResult<RemoteIssue>> {
    const base = this.repoPath(fullName);
    if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
    const result = await this.api.call({
      path: `${base}/issues/${number}`,
      method: "PATCH",
      body: { state },
    });
    if (!result.ok) return result;
    return succeed(toForgeWork(result.value.data, this.webUrl, fullName));
  }
}
@@ -24,4 +24,4 @@
export const PATH_IS_DIRECTORY = "that path is a directory, not a file";
 * and in the API, so a mirror of a friend's app never reads as the whole of it.
 */
export const FORGE_NOT_CARRIED =
  "Code comes across, and the repository's history. Not yet: issues, pulls, comments, labels, and how the app runs. Never by default: its data and its secrets.";
  "Code comes across, and the repository's history. Issues, pulls and comments read and write through. Not yet: labels, and how the app runs. Never by default: its data and its secrets.";
@@ -5,11 +5,16 @@
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { createToken } from "../src/core/tokens.ts";
import { getUserByName } from "../src/core/users.ts";
import { getOriginById } from "../src/core/origins.ts";
import { getPull } from "../src/core/pulls.ts";
import { getRepo } from "../src/core/repos.ts";
import { listComments, listIssues } from "../src/core/issues.ts";
import { discover } from "../src/origins/discover.ts";
import { providerForOrigin } from "../src/origins/credential.ts";
import { resolveOid } from "../src/git/merge.ts";
import { repoDir } from "../src/git/repos.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { syncsSettled } from "../src/origins/sync.ts";
import { syncOrigin, syncsSettled } from "../src/origins/sync.ts";
import { mirrorAndWait } from "./fake-origin.ts";
import { seedAdmin } from "./helpers/admin.ts";
import { proveAll } from "./helpers/verified.ts";
@@ -69,11 +74,15 @@
describe("a forge is an origin", () => {
      dirs.push(dir);
      return dir;
    };
    friend = createApp({ dataDir: await make(), port: 0 });
    // A fixed port, so the friend can go down and come back at the same address.
    const probe = Bun.serve({ port: 0, fetch: () => new Response("") });
    const friendPort = probe.port as number;
    await probe.stop(true);
    friend = createApp({ dataDir: await make(), port: friendPort });
    friendServers = await serve(friend);
    await seedAdmin(friend, { username: "bob", email: "[email protected]", password: BOB });
    proveAll(friend);
    friendToken = createToken(friend.db, getUserByName(friend.db, "bob")!.id, "alice", "ro").token;
    friendToken = createToken(friend.db, getUserByName(friend.db, "bob")!.id, "alice", "rw").token;
    await makeRepo("private", "secret-app");
    await makeRepo("public", "open-app");
@@ -163,4 +172,156 @@
describe("a forge is an origin", () => {
    const listed = await fetch(`${friendServers.url}/api/v1/user/repos`);
    expect(listed.status).toBe(401);
  });
  describe("work crosses", () => {
    const bobApi = (path: string, init: RequestInit = {}) =>
      fetch(`${friendServers.url}${path}`, {
        ...init,
        headers: {
          "content-type": "application/json",
          authorization: basic("bob", BOB),
          ...(init.headers as Record<string, string> | undefined),
        },
      });
    const sync = async () => {
      const origin = getOriginById(mine.db, originId)!;
      await syncOrigin(mine, origin);
    };
    const local = () => getRepo(mine.db, "alice", "secret-app")!;
    test("an issue and a comment written there arrive here, under their author", async () => {
      const made = await bobApi("/api/v1/repos/bob/secret-app/issues", {
        method: "POST",
        body: JSON.stringify({ title: "It crashes", body: "on start" }),
      });
      expect(made.status).toBe(201);
      const number = ((await made.json()) as { number: number }).number;
      await bobApi(`/api/v1/repos/bob/secret-app/issues/${number}/comments`, {
        method: "POST",
        body: JSON.stringify({ body: "me too" }),
      });
      await sync();
      const issue = listIssues(mine.db, local().id, { state: "all" }).find((i) => i.title === "It crashes");
      expect(issue?.originAuthor).toBe("bob");
      expect(listComments(mine.db, issue!.id).map((c) => c.body)).toContain("me too");
    });
    test("a comment written here lands there", async () => {
      const issue = listIssues(mine.db, local().id, { state: "all" })[0]!;
      const wrote = await mineApi(`/api/v1/repos/alice/secret-app/issues/${issue.number}/comments`, {
        method: "POST",
        body: JSON.stringify({ body: "looking now" }),
      });
      expect(wrote.status).toBe(201);
      const there = await bobApi(`/api/v1/repos/bob/secret-app/issues/${issue.number}/comments`);
      expect(JSON.stringify(await there.json())).toContain("looking now");
    });
    test("a pull opens on the origin, and its merge comes back", async () => {
      const edit = await bobApi("/api/v1/repos/bob/secret-app/contents", {
        method: "POST",
        body: JSON.stringify({
          branch: "feature",
          message: "a change",
          files: [{ path: "NOTE.md", content: "hi\n" }],
        }),
      });
      expect(edit.status).toBeLessThan(300);
      const origin = getOriginById(mine.db, originId)!;
      const provider = providerForOrigin(mine, origin);
      expect(provider.ok).toBe(true);
      if (!provider.ok) return;
      const opened = await provider.value.createPull("bob/secret-app", {
        title: "A change",
        body: "from the other side",
        base: "main",
        head: "feature",
      });
      expect(opened.ok).toBe(true);
      if (!opened.ok) return;
      expect(opened.value.pull?.headBranch).toBe("feature");
      expect(opened.value.state).toBe("open");
      const merged = await bobApi(`/api/v1/repos/bob/secret-app/pulls/${opened.value.number}/merge`, {
        method: "POST",
        body: JSON.stringify({}),
      });
      expect(merged.status).toBeLessThan(300);
      const again = await provider.value.getIssue("bob/secret-app", opened.value.number);
      expect(again.ok && again.value.pull?.mergedAt).toBeTruthy();
      await sync();
      const ours = getPull(mine.db, local().id, opened.value.number);
      expect(ours?.title).toBe("A change");
      expect(ours?.mergedAt).not.toBeNull();
    });
    test("an origin that is down leaves what was brought and refuses what would be lost, then catches up", async () => {
      const snapshot = () =>
        listIssues(mine.db, local().id, { state: "all" }).map((i) => ({
          number: i.number,
          title: i.title,
          state: i.state,
          comments: listComments(mine.db, i.id).map((c) => c.body),
        }));
      const before = snapshot();
      friendServers.stop();
      const report = await syncOrigin(mine, getOriginById(mine.db, originId)!);
      expect(report.error).not.toBe("");
      expect(snapshot()).toEqual(before);
      const issue = listIssues(mine.db, local().id, { state: "all" })[0]!;
      const wrote = await mineApi(`/api/v1/repos/alice/secret-app/issues/${issue.number}/comments`, {
        method: "POST",
        body: JSON.stringify({ body: "while it is down" }),
      });
      expect(wrote.status).toBeGreaterThanOrEqual(500);
      expect(snapshot()).toEqual(before);
      // Written there while it was away from here: an issue and a comment.
      friendServers = await serve(friend);
      const made = await bobApi("/api/v1/repos/bob/secret-app/issues", {
        method: "POST",
        body: JSON.stringify({ title: "Written while down", body: "catch me up" }),
      });
      expect(made.status).toBe(201);
      const number = ((await made.json()) as { number: number }).number;
      await bobApi(`/api/v1/repos/bob/secret-app/issues/${number}/comments`, {
        method: "POST",
        body: JSON.stringify({ body: "missed event" }),
      });
      const again = await syncOrigin(mine, getOriginById(mine.db, originId)!);
      expect(again.error).toBe("");
      const caught = listIssues(mine.db, local().id, { state: "all" }).find(
        (i) => i.title === "Written while down",
      );
      expect(caught?.originAuthor).toBe("bob");
      expect(listComments(mine.db, caught!.id).map((c) => c.body)).toContain("missed event");
    });
    test("a comment links to its thread, not the repository", async () => {
      const provider = providerForOrigin(mine, getOriginById(mine.db, originId)!);
      if (!provider.ok) throw new Error("no provider");
      const issue = listIssues(mine.db, local().id, { state: "all" })[0]!;
      const read = await provider.value.listComments("bob/secret-app", issue.number);
      expect(read.ok).toBe(true);
      if (!read.ok) return;
      const first = read.value[0]!;
      expect(first.htmlUrl).toBe(
        `${friendServers.url}/bob/secret-app/issues/${issue.number}#c-${first.remoteId}`,
      );
    });
    test("a head with more than one colon is refused", async () => {
      const provider = providerForOrigin(mine, getOriginById(mine.db, originId)!);
      if (!provider.ok) throw new Error("no provider");
      for (const head of ["a:b:c", ":x", "x:"]) {
        const refused = await provider.value.createPull("bob/secret-app", {
          title: "t",
          body: "",
          base: "main",
          head,
        });
        expect(refused.ok).toBe(false);
      }
    });
  });
});
		@@ -4,6 +4,17 @@ Connect another forge at `/settings/origins` the way you connect Forgejo: type i
4	4
5	5	- Picker: `GET /api/v1/user/repos` lists the token's account's repositories, private ones included, in the Gitea shape. Only that route speaks the Gitea shape; a repository's own JSON is unchanged.
6	6	- Credential: the token travels as `Authorization: token …` for the API (accepted as a Bearer token) and as Basic through `GIT_CONFIG_*` for git — never argv, never config.
7		- Mirror: brings the code and its history. The origin's card and `GET /api/v1/user/origins` (`carries`) say what did not come: issues, pulls, comments and labels (not yet), how the app runs (not yet), and its data and secrets (never by default).
	7	- Mirror: brings the code and its history, and the issues, pulls and comments, read in the forge's own JSON (`src/origins/providers/forge-work.ts`) with the real author kept. The origin's card and `GET /api/v1/user/origins` (`carries`) say what did not come: labels and how the app runs (not yet), and its data and secrets (never by default).
	8	- Write-through: a comment, an issue or a state change here goes to the other forge first, with the connecting person's token (`rw` needed), and is refused with nothing changed here when the forge is down or says no. A pull is opened there with `createPull` (the contribute path); its merge comes back with the next sync.
8	9
9		Not in this piece, in order: sign in through OAuth, migrate an app whole with its run and build, follow upstream between forges with a pull back, and the one-page paste-a-link path. Test: `test/forge-origin.test.ts` runs two forges against each other.
	10	Not yet: webhooks and a catch-up for missed events, review and check state coming back live, guest rules for a crew on the receiving side, following upstream with one action.
	11
	12	Not in the first piece, in order: sign in through OAuth, migrate an app whole with its run and build, follow upstream between forges with a pull back, and the one-page paste-a-link path. Test: `test/forge-origin.test.ts` runs two forges against each other.
	13
	14	## Both doors, and what was exercised
	15
	16	The terminal reaches the same code as the web and the API: `src/tui/screens/issue.ts` and `pull.ts` comment and change state through `addCommentThrough` and `setIssueStateThrough` (`src/actions/issues.ts`), which call `providers.createComment` / `setState` when the repository is a mirror. No terminal screen or entry changed, so the write-through tests cover it; there is no separate terminal path to test.
	17
	18	A forge's comments carry no edit time, so `updatedAt` is read when the forge sends one and is the creation time otherwise: an edited comment syncs once the forge reports edits. A thread is paged to its end; one of more than 100,000 comments is a failed sync, never a short one.
	19
	20	The preview of the pull was not exercised: the write-through is proven by `test/forge-origin.test.ts` (two forges in one process, including the origin going down and coming back), not by hand on the preview.
		@@ -0,0 +1,78 @@
	1	/**
	2	* The work on another forge, read and written in that forge's own JSON.
	3	*
	4	* A forge's issues, pulls and comments are not Gitea's: the author is
	5	* `authorName` (or `originAuthor` when the thread was itself brought across),
	6	* labels are `{name}`, a list pages by `next_cursor` and a thread by `next`.
	7	* Plain data in, plain data out: these turn one such value into the shape
	8	* every provider returns, and `ForgeProvider` does the calling.
	9	*/
	10
	11	import type { RemoteComment, RemoteIssue } from "../types.ts";
	12	import { asId, asNumber, asState, asString, asTime, field, labelNames } from "./http.ts";
	13
	14	const authorOf = (raw: unknown): string =>
	15	asString(field(raw, "originAuthor")) \|\| asString(field(raw, "authorName"));
	16
	17	/** An issue, or a pull when it carries branches. */
	18	export function toForgeWork(raw: unknown, webUrl: string, fullName: string): RemoteIssue {
	19	const created = asTime(field(raw, "createdAt")) ?? new Date().toISOString();
	20	const number = asNumber(field(raw, "number"));
	21	const base = asString(field(raw, "baseBranch"));
	22	const issue: RemoteIssue = {
	23	remoteId: asId(field(raw, "id")),
	24	number,
	25	title: asString(field(raw, "title")),
	26	body: asString(field(raw, "body")),
	27	author: authorOf(raw),
	28	state: asState(field(raw, "state")),
	29	labels: labelNames(field(raw, "labels")),
	30	createdAt: created,
	31	updatedAt: asTime(field(raw, "updatedAt")) ?? created,
	32	closedAt: asTime(field(raw, "closedAt")),
	33	htmlUrl: `${webUrl}/${fullName}/${base === "" ? "issues" : "pulls"}/${number}`,
	34	comments: asNumber(field(raw, "comments")),
	35	};
	36	if (base === "") return issue;
	37	return {
	38	...issue,
	39	pull: {
	40	baseBranch: base,
	41	headBranch: asString(field(raw, "headBranch")),
	42	headRepo: asString(field(raw, "originHeadRepo")) \|\| fullName,
	43	baseOid: asString(field(raw, "baseOid")),
	44	headOid: asString(field(raw, "headOid")),
	45	mergedAt: asTime(field(raw, "mergedAt")),
	46	draft: false,
	47	},
	48	};
	49	}
	50
	51	/**
	52	* A comment, linked to its thread (a pull answers at `issues/N` too) at the
	53	* anchor the thread page gives it. A forge's comments carry no edit time of
	54	* their own; `updatedAt` is read when one does, else the creation time.
	55	*/
	56	export function toForgeComment(
	57	raw: unknown,
	58	webUrl: string,
	59	fullName: string,
	60	number: number,
	61	): RemoteComment {
	62	const created = asTime(field(raw, "createdAt")) ?? new Date().toISOString();
	63	const id = asId(field(raw, "id"));
	64	return {
	65	remoteId: id,
	66	author: authorOf(raw),
	67	body: asString(field(raw, "body")),
	68	createdAt: created,
	69	updatedAt: asTime(field(raw, "updatedAt")) ?? created,
	70	htmlUrl: `${webUrl}/${fullName}/issues/${number}#c-${id}`,
	71	};
	72	}
	73
	74	/** The cursor a list hands back, as the string the next call sends. */
	75	export function forgeCursor(raw: unknown): string \| null {
	76	const next = field(raw, "next_cursor") ?? field(raw, "next");
	77	return typeof next === "number" \|\| (typeof next === "string" && next !== "") ? String(next) : null;
	78	}
		@@ -4,14 +4,15 @@
4	4	* A forge answers the Gitea dialect only for the one list connecting needs,
5	5	* `GET /user/repos`; who you are and one repository are read in its own
6	6	* shape, so the rest of its API grows no Gitea fields. Git comes over HTTPS
7		* as ever. What a forge does not yet answer to an origin is its issues,
8		* pulls, comments and labels: those reads say "none" rather than failing, so
9		* the mirror brings the code across and settles, and the origin's `carries`
10		* note says what did not come.
	7	* as ever. Issues, pulls and comments are read and written in its own JSON
	8	* (`forge-work.ts`); labels do not come yet and say "none" rather than
	9	* failing, and the origin's `carries` note says so.
11	10	*/
12	11
13	12	import type {
	13	ListIssuesQuery,
14	14	Page,
	15	RemoteComment,
15	16	ProviderResult,
16	17	RemoteIdentity,
17	18	RemoteLabel,
		@@ -21,8 +22,10 @@ import type {
21	22	} from "../types.ts";
22	23	import { ForgejoProvider, nextPage, toRepo } from "./forgejo.ts";
23	24	import { NO_ACCOUNT } from "../words.ts";
	25	import { forgeCursor, toForgeComment, toForgeWork } from "./forge-work.ts";
24	26	import { asArray, asString, dig, fail, field, seg, splitFullName, succeed } from "./http.ts";
25	27
	28	const MAX_COMMENT_PAGES = 1000;
26	29	const NONE = { ok: true, value: [] } as const;
27	30
28	31	export class ForgeProvider extends ForgejoProvider {
		@@ -89,7 +92,148 @@ export class ForgeProvider extends ForgejoProvider {
89	92	return Promise.resolve(NONE);
90	93	}
91	94
92		override listIssues(): Promise<ProviderResult<Page<RemoteIssue>>> {
93		return Promise.resolve({ ok: true, value: { items: [], next: null } });
	95	private repoPath(fullName: string): string \| undefined {
	96	const named = splitFullName(fullName);
	97	return named ? `/repos/${seg(named.owner)}/${seg(named.name)}` : undefined;
	98	}
	99
	100	/** Issues or pulls, newest first, a page at a time. */
	101	override async listIssues(
	102	fullName: string,
	103	query: ListIssuesQuery,
	104	): Promise<ProviderResult<Page<RemoteIssue>>> {
	105	const base = this.repoPath(fullName);
	106	if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
	107	const limit = await this.pageSize();
	108	const result = await this.api.call({
	109	path: `${base}/${query.kind === "pull" ? "pulls" : "issues"}`,
	110	query: {
	111	state: query.state,
	112	limit,
	113	...(query.cursor === undefined ? {} : { cursor: query.cursor }),
	114	},
	115	});
	116	if (!result.ok) return result;
	117	const rows = asArray(field(result.value.data, "items")).filter(
	118	(raw) => raw !== null && typeof raw === "object",
	119	);
	120	const items = rows
	121	.map((raw) => toForgeWork(raw, this.webUrl, fullName))
	122	.filter((i) => query.since === undefined \|\| i.updatedAt >= query.since);
	123	return succeed({ items, next: forgeCursor(result.value.data) });
	124	}
	125
	126	override async getIssue(fullName: string, number: number): Promise<ProviderResult<RemoteIssue>> {
	127	const base = this.repoPath(fullName);
	128	if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
	129	let result = await this.api.call({ path: `${base}/issues/${number}` });
	130	// A pull answers at `/issues` too, but only `/pulls` carries its branches and merge.
	131	if (result.ok && asString(field(result.value.data, "kind")) === "pull")
	132	result = await this.api.call({ path: `${base}/pulls/${number}`, query: { diff: 0 } });
	133	if (!result.ok) return result;
	134	return succeed(toForgeWork(result.value.data, this.webUrl, fullName));
	135	}
	136
	137	override async listComments(
	138	fullName: string,
	139	number: number,
	140	since?: string,
	141	): Promise<ProviderResult<readonly RemoteComment[]>> {
	142	const base = this.repoPath(fullName);
	143	if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
	144	const comments: RemoteComment[] = [];
	145	let after: string \| undefined;
	146	// A thread comes oldest first, `next` the id to continue after. Paging
	147	// stops at the end of the thread; a thread that never ends is a failure,
	148	// not a short list.
	149	for (let page = 0; ; page++) {
	150	if (page >= MAX_COMMENT_PAGES)
	151	return fail("invalid_response", `thread ${number} has more than ${MAX_COMMENT_PAGES * 100} comments`);
	152	const result = await this.api.call({
	153	path: `${base}/issues/${number}/comments`,
	154	query: { limit: 100, ...(after === undefined ? {} : { after }) },
	155	});
	156	if (!result.ok) return result;
	157	for (const raw of asArray(field(result.value.data, "comments")))
	158	comments.push(toForgeComment(raw, this.webUrl, fullName, number));
	159	after = forgeCursor(result.value.data) ?? undefined;
	160	if (after === undefined) break;
	161	}
	162	return succeed(since === undefined ? comments : comments.filter((c) => c.updatedAt >= since));
	163	}
	164
	165	override async createIssue(
	166	fullName: string,
	167	input: { title: string; body: string; labels?: readonly string[] },
	168	): Promise<ProviderResult<RemoteIssue>> {
	169	const base = this.repoPath(fullName);
	170	if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
	171	const result = await this.api.call({
	172	path: `${base}/issues`,
	173	method: "POST",
	174	body: { title: input.title, body: input.body },
	175	});
	176	if (!result.ok) return result;
	177	return succeed(toForgeWork(result.value.data, this.webUrl, fullName));
	178	}
	179
	180	override async createComment(
	181	fullName: string,
	182	number: number,
	183	body: string,
	184	): Promise<ProviderResult<RemoteComment>> {
	185	const base = this.repoPath(fullName);
	186	if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
	187	const result = await this.api.call({
	188	path: `${base}/issues/${number}/comments`,
	189	method: "POST",
	190	body: { body },
	191	});
	192	if (!result.ok) return result;
	193	return succeed(toForgeComment(result.value.data, this.webUrl, fullName, number));
	194	}
	195
	196	override async createPull(
	197	fullName: string,
	198	input: { title: string; body: string; base: string; head: string },
	199	): Promise<ProviderResult<RemoteIssue>> {
	200	const named = splitFullName(fullName);
	201	if (!named) return fail("not_found", `not a repository name: ${fullName}`);
	202	const path = `/repos/${seg(named.owner)}/${seg(named.name)}`;
	203	// A fork's branch is `owner:branch`; a forge names it as head plus headRepo.
	204	const parts = input.head.split(":");
	205	if (parts.length > 2 \|\| parts.some((p) => p === ""))
	206	return fail("not_found", `not a branch: ${input.head}`);
	207	const [owner, branch] = parts.length === 2 ? parts : [undefined, parts[0]];
	208	const name = named.name;
	209	const result = await this.api.call({
	210	path: `${path}/pulls`,
	211	method: "POST",
	212	body: {
	213	title: input.title,
	214	body: input.body,
	215	base: input.base,
	216	head: branch,
	217	...(owner === undefined ? {} : { headRepo: `${owner}/${name}` }),
	218	},
	219	});
	220	if (!result.ok) return result;
	221	return succeed(toForgeWork(result.value.data, this.webUrl, fullName));
	222	}
	223
	224	override async setState(
	225	fullName: string,
	226	number: number,
	227	state: "open" \| "closed",
	228	): Promise<ProviderResult<RemoteIssue>> {
	229	const base = this.repoPath(fullName);
	230	if (base === undefined) return fail("not_found", `not a repository name: ${fullName}`);
	231	const result = await this.api.call({
	232	path: `${base}/issues/${number}`,
	233	method: "PATCH",
	234	body: { state },
	235	});
	236	if (!result.ok) return result;
	237	return succeed(toForgeWork(result.value.data, this.webUrl, fullName));
94	238	}
95	239	}
		@@ -24,4 +24,4 @@ export const PATH_IS_DIRECTORY = "that path is a directory, not a file";
24	24	* and in the API, so a mirror of a friend's app never reads as the whole of it.
25	25	*/
26	26	export const FORGE_NOT_CARRIED =
27		"Code comes across, and the repository's history. Not yet: issues, pulls, comments, labels, and how the app runs. Never by default: its data and its secrets.";
	27	"Code comes across, and the repository's history. Issues, pulls and comments read and write through. Not yet: labels, and how the app runs. Never by default: its data and its secrets.";
		@@ -5,11 +5,16 @@ import { join } from "node:path";
5	5	import { createApp, type App } from "../src/app.ts";
6	6	import { createToken } from "../src/core/tokens.ts";
7	7	import { getUserByName } from "../src/core/users.ts";
	8	import { getOriginById } from "../src/core/origins.ts";
	9	import { getPull } from "../src/core/pulls.ts";
	10	import { getRepo } from "../src/core/repos.ts";
	11	import { listComments, listIssues } from "../src/core/issues.ts";
8	12	import { discover } from "../src/origins/discover.ts";
	13	import { providerForOrigin } from "../src/origins/credential.ts";
9	14	import { resolveOid } from "../src/git/merge.ts";
10	15	import { repoDir } from "../src/git/repos.ts";
11	16	import { serve, type Servers } from "../src/http/server.ts";
12		import { syncsSettled } from "../src/origins/sync.ts";
	17	import { syncOrigin, syncsSettled } from "../src/origins/sync.ts";
13	18	import { mirrorAndWait } from "./fake-origin.ts";
14	19	import { seedAdmin } from "./helpers/admin.ts";
15	20	import { proveAll } from "./helpers/verified.ts";
		@@ -69,11 +74,15 @@ describe("a forge is an origin", () => {
69	74	dirs.push(dir);
70	75	return dir;
71	76	};
72		friend = createApp({ dataDir: await make(), port: 0 });
	77	// A fixed port, so the friend can go down and come back at the same address.
	78	const probe = Bun.serve({ port: 0, fetch: () => new Response("") });
	79	const friendPort = probe.port as number;
	80	await probe.stop(true);
	81	friend = createApp({ dataDir: await make(), port: friendPort });
73	82	friendServers = await serve(friend);
74	83	await seedAdmin(friend, { username: "bob", email: "[email protected]", password: BOB });
75	84	proveAll(friend);
76		friendToken = createToken(friend.db, getUserByName(friend.db, "bob")!.id, "alice", "ro").token;
	85	friendToken = createToken(friend.db, getUserByName(friend.db, "bob")!.id, "alice", "rw").token;
77	86	await makeRepo("private", "secret-app");
78	87	await makeRepo("public", "open-app");
79	88
		@@ -163,4 +172,156 @@ describe("a forge is an origin", () => {
163	172	const listed = await fetch(`${friendServers.url}/api/v1/user/repos`);
164	173	expect(listed.status).toBe(401);
165	174	});
	175
	176	describe("work crosses", () => {
	177	const bobApi = (path: string, init: RequestInit = {}) =>
	178	fetch(`${friendServers.url}${path}`, {
	179	...init,
	180	headers: {
	181	"content-type": "application/json",
	182	authorization: basic("bob", BOB),
	183	...(init.headers as Record<string, string> \| undefined),
	184	},
	185	});
	186	const sync = async () => {
	187	const origin = getOriginById(mine.db, originId)!;
	188	await syncOrigin(mine, origin);
	189	};
	190	const local = () => getRepo(mine.db, "alice", "secret-app")!;
	191
	192	test("an issue and a comment written there arrive here, under their author", async () => {
	193	const made = await bobApi("/api/v1/repos/bob/secret-app/issues", {
	194	method: "POST",
	195	body: JSON.stringify({ title: "It crashes", body: "on start" }),
	196	});
	197	expect(made.status).toBe(201);
	198	const number = ((await made.json()) as { number: number }).number;
	199	await bobApi(`/api/v1/repos/bob/secret-app/issues/${number}/comments`, {
	200	method: "POST",
	201	body: JSON.stringify({ body: "me too" }),
	202	});
	203	await sync();
	204	const issue = listIssues(mine.db, local().id, { state: "all" }).find((i) => i.title === "It crashes");
	205	expect(issue?.originAuthor).toBe("bob");
	206	expect(listComments(mine.db, issue!.id).map((c) => c.body)).toContain("me too");
	207	});
	208
	209	test("a comment written here lands there", async () => {
	210	const issue = listIssues(mine.db, local().id, { state: "all" })[0]!;
	211	const wrote = await mineApi(`/api/v1/repos/alice/secret-app/issues/${issue.number}/comments`, {
	212	method: "POST",
	213	body: JSON.stringify({ body: "looking now" }),
	214	});
	215	expect(wrote.status).toBe(201);
	216	const there = await bobApi(`/api/v1/repos/bob/secret-app/issues/${issue.number}/comments`);
	217	expect(JSON.stringify(await there.json())).toContain("looking now");
	218	});
	219
	220	test("a pull opens on the origin, and its merge comes back", async () => {
	221	const edit = await bobApi("/api/v1/repos/bob/secret-app/contents", {
	222	method: "POST",
	223	body: JSON.stringify({
	224	branch: "feature",
	225	message: "a change",
	226	files: [{ path: "NOTE.md", content: "hi\n" }],
	227	}),
	228	});
	229	expect(edit.status).toBeLessThan(300);
	230	const origin = getOriginById(mine.db, originId)!;
	231	const provider = providerForOrigin(mine, origin);
	232	expect(provider.ok).toBe(true);
	233	if (!provider.ok) return;
	234	const opened = await provider.value.createPull("bob/secret-app", {
	235	title: "A change",
	236	body: "from the other side",
	237	base: "main",
	238	head: "feature",
	239	});
	240	expect(opened.ok).toBe(true);
	241	if (!opened.ok) return;
	242	expect(opened.value.pull?.headBranch).toBe("feature");
	243	expect(opened.value.state).toBe("open");
	244	const merged = await bobApi(`/api/v1/repos/bob/secret-app/pulls/${opened.value.number}/merge`, {
	245	method: "POST",
	246	body: JSON.stringify({}),
	247	});
	248	expect(merged.status).toBeLessThan(300);
	249	const again = await provider.value.getIssue("bob/secret-app", opened.value.number);
	250	expect(again.ok && again.value.pull?.mergedAt).toBeTruthy();
	251	await sync();
	252	const ours = getPull(mine.db, local().id, opened.value.number);
	253	expect(ours?.title).toBe("A change");
	254	expect(ours?.mergedAt).not.toBeNull();
	255	});
	256
	257	test("an origin that is down leaves what was brought and refuses what would be lost, then catches up", async () => {
	258	const snapshot = () =>
	259	listIssues(mine.db, local().id, { state: "all" }).map((i) => ({
	260	number: i.number,
	261	title: i.title,
	262	state: i.state,
	263	comments: listComments(mine.db, i.id).map((c) => c.body),
	264	}));
	265	const before = snapshot();
	266	friendServers.stop();
	267	const report = await syncOrigin(mine, getOriginById(mine.db, originId)!);
	268	expect(report.error).not.toBe("");
	269	expect(snapshot()).toEqual(before);
	270
	271	const issue = listIssues(mine.db, local().id, { state: "all" })[0]!;
	272	const wrote = await mineApi(`/api/v1/repos/alice/secret-app/issues/${issue.number}/comments`, {
	273	method: "POST",
	274	body: JSON.stringify({ body: "while it is down" }),
	275	});
	276	expect(wrote.status).toBeGreaterThanOrEqual(500);
	277	expect(snapshot()).toEqual(before);
	278
	279	// Written there while it was away from here: an issue and a comment.
	280	friendServers = await serve(friend);
	281	const made = await bobApi("/api/v1/repos/bob/secret-app/issues", {
	282	method: "POST",
	283	body: JSON.stringify({ title: "Written while down", body: "catch me up" }),
	284	});
	285	expect(made.status).toBe(201);
	286	const number = ((await made.json()) as { number: number }).number;
	287	await bobApi(`/api/v1/repos/bob/secret-app/issues/${number}/comments`, {
	288	method: "POST",
	289	body: JSON.stringify({ body: "missed event" }),
	290	});
	291	const again = await syncOrigin(mine, getOriginById(mine.db, originId)!);
	292	expect(again.error).toBe("");
	293	const caught = listIssues(mine.db, local().id, { state: "all" }).find(
	294	(i) => i.title === "Written while down",
	295	);
	296	expect(caught?.originAuthor).toBe("bob");
	297	expect(listComments(mine.db, caught!.id).map((c) => c.body)).toContain("missed event");
	298	});
	299
	300	test("a comment links to its thread, not the repository", async () => {
	301	const provider = providerForOrigin(mine, getOriginById(mine.db, originId)!);
	302	if (!provider.ok) throw new Error("no provider");
	303	const issue = listIssues(mine.db, local().id, { state: "all" })[0]!;
	304	const read = await provider.value.listComments("bob/secret-app", issue.number);
	305	expect(read.ok).toBe(true);
	306	if (!read.ok) return;
	307	const first = read.value[0]!;
	308	expect(first.htmlUrl).toBe(
	309	`${friendServers.url}/bob/secret-app/issues/${issue.number}#c-${first.remoteId}`,
	310	);
	311	});
	312
	313	test("a head with more than one colon is refused", async () => {
	314	const provider = providerForOrigin(mine, getOriginById(mine.db, originId)!);
	315	if (!provider.ok) throw new Error("no provider");
	316	for (const head of ["a:b:c", ":x", "x:"]) {
	317	const refused = await provider.value.createPull("bob/secret-app", {
	318	title: "t",
	319	body: "",
	320	base: "main",
	321	head,
	322	});
	323	expect(refused.ok).toBe(false);
	324	}
	325	});
	326	});
166	327	});