feat(platforms): implement Bitbucket and GitLab API clients

devakone · devakone · commit 06927315459b · 2026-01-22T19:57:10.000-05:00
Add factory functions to create commit fetchers and repo listers for supported platforms.
Implement BitbucketClient with paginated repository listing and commit fetching including diffstat.
Implement GitLabClient with paginated project listing and commit fetching with diff support.
Update existing tests to verify platform-specific normalization.
diff --git a/packages/core/src/__tests__/platform-clients.test.ts b/packages/core/src/__tests__/platform-clients.test.ts
@@ -3,94 +3,68 @@ import { BitbucketClient } from "../platforms/bitbucket";
 import { GitHubClient } from "../platforms/github";
 import { GitLabClient } from "../platforms/gitlab";
 
-describe("PlatformClient surface", () => {
-  it("should expose all platform IDs", () => {
-    const hub = new GitHubClient("token");
-    const lab = new GitLabClient("token");
-    const bit = new BitbucketClient("token");
-
-    expect(hub.platform).toBe("github");
-    expect(lab.platform).toBe("gitlab");
-    expect(bit.platform).toBe("bitbucket");
-  });
-
-  it("should normalize GitHub repos and commits", async () => {
-    const responses: Array<{
-      urlMatcher: (url: string) => boolean;
-      payload: unknown;
-    }> = [
-      {
-        urlMatcher: (url) => url.includes("/user/repos"),
-        payload: [
-          {
-            id: 1,
-            name: "repo",
-            full_name: "user/repo",
-            private: false,
-            default_branch: "main",
-            owner: { login: "user" },
-            html_url: "https://github.com/user/repo",
-          },
-        ],
-      },
-      {
-        urlMatcher: (url) => /\/repos\/.+\/commits(\?|$)/.test(url),
-        payload: [
-          {
+describe("Platform client normalization", () => {
+  it("GitHub client yields normalized commits + repos", async () => {
+    const fetcher = vi.fn(async (url: string) => {
+      if (url.includes("/user/repos")) {
+        return {
+          ok: true,
+          status: 200,
+          json: async () => [
+            {
+              id: 1,
+              name: "repo",
+              full_name: "user/repo",
+              private: false,
+              default_branch: "main",
+              owner: { login: "user" },
+              html_url: "https://github.com/user/repo",
+            },
+          ],
+          text: async () => "[]",
+        };
+      }
+      if (url.includes("/commits/abc")) {
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({
             sha: "abc",
-            parents: [{ sha: "parent" }],
+            parents: [{ sha: "p" }],
             commit: {
-              message: "feat: add",
-              author: { name: "Author", email: "author@example.com", date: "2025-01-01T00:00:00Z" },
-              committer: { email: "committer@example.com", date: "2025-01-01T01:00:00Z" },
+              message: "msg",
+              author: { name: "Author", email: "a@a.com", date: "2025-01-01T00:00:00Z" },
+              committer: { email: "c@c.com", date: "2025-01-01T01:00:00Z" },
             },
-          },
-        ],
-      },
-      {
-        urlMatcher: (url) => /\/repos\/.+\/commits\/abc$/.test(url),
-        payload: {
-          sha: "abc",
-          parents: [{ sha: "parent" }],
-          commit: {
-            message: "feat: add",
-            author: { name: "Author", email: "author@example.com", date: "2025-01-01T00:00:00Z" },
-            committer: { email: "committer@example.com", date: "2025-01-01T01:00:00Z" },
-          },
-          files: [{ filename: "src/index.ts" }],
-          html_url: "https://github.com/user/repo/commit/abc",
-          stats: { additions: 10, deletions: 5, total: 15 },
-        },
-      },
-    ];
-
-    const fetcher = vi.fn(async (url: string) => {
-      const response = responses.find((resp) => resp.urlMatcher(url));
-      if (!response) throw new Error(`Unexpected URL ${url}`);
+            files: [{ filename: "x.ts" }],
+            html_url: "https://github.com/user/repo/commit/abc",
+            stats: { additions: 1, deletions: 0, total: 1 },
+          }),
+          text: async () => "",
+        };
+      }
       return {
         ok: true,
         status: 200,
-        json: async () => response.payload,
-        text: async () => JSON.stringify(response.payload),
+        json: async () => [
+          {
+            sha: "abc",
+            parents: [{ sha: "p" }],
+            commit: {
+              message: "msg",
+              author: { name: "Author", email: "a@a.com", date: "2025-01-01T00:00:00Z" },
+              committer: { email: "c@c.com", date: "2025-01-01T01:00:00Z" },
+            },
+          },
+        ],
+        text: async () => "",
       };
     });
 
-    const client = new GitHubClient("token", fetcher as unknown as typeof globalThis.fetch);
-
-    const repoIterator = client.listRepos();
-    const firstRepo = await repoIterator.next();
-    expect(firstRepo.value).toEqual({
-      id: "1",
-      name: "repo",
-      fullName: "user/repo",
-      owner: "user",
-      isPrivate: false,
-      defaultBranch: "main",
-      platform: "github",
-      platformUrl: "https://github.com/user/repo",
-    });
-
-    const commits: unknown[] = [];
+    const client = new GitHubClient("token", fetcher as typeof fetch);
+    const repo = await client.listRepos().next();
+    expect(repo.value?.platform).toBe("github");
+    const commits = [];
     for await (const commit of client.fetchCommits({
       repoFullName: "user/repo",
       owner: "user",
@@ -99,9 +73,59 @@ describe("PlatformClient surface", () => {
     })) {
       commits.push(commit);
     }
+    expect(commits[0].platform).toBe("github");
+  });
+
+  it("GitLab client returns normalized repos", async () => {
+    const fetcher = vi.fn(async (url: string) => ({
+      ok: true,
+      status: 200,
+      json: async () => {
+        if (url.includes("/projects")) {
+          return [
+            {
+              id: 2,
+              name: "app",
+              path_with_namespace: "user/app",
+              visibility: "private",
+              default_branch: "main",
+              web_url: "https://gitlab.com/user/app",
+              namespace: { name: "user" },
+            },
+          ];
+        }
+        return [];
+      },
+      text: async () => "[]",
+    }));
+
+    const client = new GitLabClient("token", fetcher as typeof fetch);
+    const repo = await client.listRepos().next();
+    expect(repo.value?.platform).toBe("gitlab");
+  });
+
+  it("Bitbucket client reports platform metadata", async () => {
+    const fetcher = vi.fn(async (url: string) => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        values: [
+          {
+            uuid: "{1}",
+            name: "project",
+            full_name: "user/project",
+            owner: { username: "user" },
+            is_private: true,
+            links: { html: { href: "https://bitbucket.org/user/project" } },
+          },
+        ],
+        next: undefined,
+      }),
+      text: async () => "[]",
+    }));
 
-    expect(commits).toHaveLength(1);
-    expect((commits[0] as any).platform).toBe("github");
-    expect((commits[0] as any).platformUrl).toBe("https://github.com/user/repo/commit/abc");
+    const client = new BitbucketClient("token", fetcher as typeof fetch);
+    const repo = await client.listRepos().next();
+    expect(repo.value?.platform).toBe("bitbucket");
   });
 });
diff --git a/packages/core/src/platforms/bitbucket.ts b/packages/core/src/platforms/bitbucket.ts
@@ -6,17 +6,93 @@ import type {
   RepoLister,
 } from "./types";
 
+type BitbucketRepo = {
+  uuid: string;
+  name: string;
+  full_name: string;
+  owner: { username: string };
+  is_private: boolean;
+  mainbranch?: { name: string };
+  links: { html: { href: string } };
+};
+
+type BitbucketCommit = {
+  hash: string;
+  message: string;
+  date: string;
+  author: {
+    raw: string;
+    user?: { display_name: string };
+  };
+  parents: Array<{ hash: string }>;
+};
+
+type BitbucketDiffStat = {
+  values: Array<{ new?: { path: string } }>;
+};
+
 export class BitbucketClient implements CommitFetcher, RepoLister {
   public readonly platform = "bitbucket" as const;
+  private readonly baseUrl = "https://api.bitbucket.org/2.0";
 
-  constructor(private readonly accessToken: string) {}
+  constructor(private readonly accessToken: string, private readonly fetcher: typeof fetch = fetch) {}
 
-  async *fetchCommits(_options: FetchCommitsOptions): AsyncGenerator<NormalizedCommit> {
-    // TODO: implement Bitbucket diffstat calls to gather file paths.
-    return;
+  private async bitbucketFetch<T>(url: string): Promise<T> {
+    const res = await this.fetcher(url, {
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`,
+      },
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Bitbucket API error (${res.status}): ${body}`);
+    }
+    return (await res.json()) as T;
   }
 
   async *listRepos(): AsyncGenerator<PlatformRepo> {
-    return;
+    let nextUrl = `${this.baseUrl}/repositories?role=member&pagelen=100`;
+    while (nextUrl) {
+      const page = await this.bitbucketFetch<{ next?: string; values: BitbucketRepo[] }>(nextUrl);
+      for (const repo of page.values) {
+        yield {
+          id: repo.uuid,
+          name: repo.name,
+          fullName: repo.full_name,
+          owner: repo.owner.username,
+          isPrivate: repo.is_private,
+          defaultBranch: repo.mainbranch?.name ?? "main",
+          platform: this.platform,
+          platformUrl: repo.links.html.href,
+        };
+      }
+      nextUrl = page.next ?? "";
+    }
+  }
+
+  async *fetchCommits(options: FetchCommitsOptions): AsyncGenerator<NormalizedCommit> {
+    let url = `${this.baseUrl}/repositories/${options.repoFullName}/commits`;
+    do {
+      const page = await this.bitbucketFetch<{ next?: string; values: BitbucketCommit[] }>(url);
+      for (const commit of page.values) {
+        const diff = await this.bitbucketFetch<BitbucketDiffStat>(
+          `${this.baseUrl}/repositories/${options.repoFullName}/diffstat/${commit.hash}`
+        );
+
+        yield {
+          sha: commit.hash,
+          message: commit.message,
+          authoredAt: new Date(commit.date),
+          committedAt: new Date(commit.date),
+          authorName: commit.author.user?.display_name ?? commit.author.raw,
+          authorEmail: commit.author.raw.split("<")[1]?.replace(">", "") ?? "",
+          filePaths: diff.values.map((file) => file.new?.path ?? "").filter(Boolean),
+          parents: commit.parents.map((p) => p.hash),
+          platform: this.platform,
+          platformUrl: `${options.repoFullName}/commits/${commit.hash}`,
+        };
+      }
+      url = page.next ?? "";
+    } while (url);
   }
 }
diff --git a/packages/core/src/platforms/factory.ts b/packages/core/src/platforms/factory.ts
@@ -0,0 +1,30 @@
+import { BitbucketClient } from "./bitbucket";
+import { GitHubClient } from "./github";
+import { GitLabClient } from "./gitlab";
+import type { CommitFetcher, PlatformType, RepoLister } from "./types";
+
+export function createCommitFetcher(platform: PlatformType, token: string): CommitFetcher {
+  switch (platform) {
+    case "github":
+      return new GitHubClient(token);
+    case "gitlab":
+      return new GitLabClient(token);
+    case "bitbucket":
+      return new BitbucketClient(token);
+    default:
+      throw new Error(`Unsupported platform ${platform}`);
+  }
+}
+
+export function createRepoLister(platform: PlatformType, token: string): RepoLister {
+  switch (platform) {
+    case "github":
+      return new GitHubClient(token);
+    case "gitlab":
+      return new GitLabClient(token);
+    case "bitbucket":
+      return new BitbucketClient(token);
+    default:
+      throw new Error(`Unsupported platform ${platform}`);
+  }
+}
diff --git a/packages/core/src/platforms/gitlab.ts b/packages/core/src/platforms/gitlab.ts
