@spaceflow/core 0.1.1

package/src/shared/git-provider/git-provider.service.spec.ts

@@ -0,0 +1,282 @@
+import { vi } from "vitest";
+import { GitProviderService } from "./git-provider.service";
+import type { GitProviderModuleOptions } from "./types";
+import { GiteaAdapter } from "./adapters/gitea.adapter";
+import { GithubAdapter } from "./adapters/github.adapter";
+import { GitlabAdapter } from "./adapters/gitlab.adapter";
+
+/** 直接实例化 service（绕过 NestJS DI） */
+function createService(options: GitProviderModuleOptions): GitProviderService {
+  return new (GitProviderService as any)(options);
+}
+
+describe("GitProviderService", () => {
+  describe("createAdapter", () => {
+    it("provider=gitea 时应创建 GiteaAdapter", () => {
+      const service = createService({ provider: "gitea", baseUrl: "https://g.com", token: "t" });
+      expect((service as any).adapter).toBeInstanceOf(GiteaAdapter);
+    });
+
+    it("provider=github 时应创建 GithubAdapter", () => {
+      const service = createService({
+        provider: "github",
+        baseUrl: "https://api.github.com",
+        token: "t",
+      });
+      expect((service as any).adapter).toBeInstanceOf(GithubAdapter);
+    });
+
+    it("provider=gitlab 时应创建 GitlabAdapter", () => {
+      const service = createService({
+        provider: "gitlab",
+        baseUrl: "https://gitlab.com",
+        token: "t",
+      });
+      expect((service as any).adapter).toBeInstanceOf(GitlabAdapter);
+    });
+
+    it("不支持的 provider 应抛出异常", () => {
+      expect(() =>
+        createService({ provider: "bitbucket" as any, baseUrl: "x", token: "t" }),
+      ).toThrow("不支持的 Git Provider 类型: bitbucket");
+    });
+  });
+
+  describe("代理方法", () => {
+    let service: GitProviderService;
+    let mockAdapter: Record<string, ReturnType<typeof vi.fn>>;
+
+    beforeEach(() => {
+      service = createService({ provider: "gitea", baseUrl: "https://g.com", token: "t" });
+      mockAdapter = {
+        validateConfig: vi.fn(),
+        getRepository: vi.fn().mockResolvedValue({ id: 1 }),
+        getBranch: vi.fn().mockResolvedValue({ name: "main" }),
+        listBranchProtections: vi.fn().mockResolvedValue([]),
+        getBranchProtection: vi.fn().mockResolvedValue({}),
+        createBranchProtection: vi.fn().mockResolvedValue({}),
+        editBranchProtection: vi.fn().mockResolvedValue({}),
+        deleteBranchProtection: vi.fn().mockResolvedValue(undefined),
+        lockBranch: vi.fn().mockResolvedValue({}),
+        unlockBranch: vi.fn().mockResolvedValue(null),
+        unlockBranchSync: vi.fn(),
+        getPullRequest: vi.fn().mockResolvedValue({ id: 1 }),
+        editPullRequest: vi.fn().mockResolvedValue({}),
+        listPullRequests: vi.fn().mockResolvedValue([]),
+        listAllPullRequests: vi.fn().mockResolvedValue([]),
+        getPullRequestCommits: vi.fn().mockResolvedValue([]),
+        getPullRequestFiles: vi.fn().mockResolvedValue([]),
+        getPullRequestDiff: vi.fn().mockResolvedValue("diff"),
+        getCommit: vi.fn().mockResolvedValue({}),
+        getCompareDiff: vi.fn().mockResolvedValue("diff"),
+        getCommitDiff: vi.fn().mockResolvedValue("diff"),
+        getFileContent: vi.fn().mockResolvedValue("content"),
+        createIssue: vi.fn().mockResolvedValue({}),
+        listIssueComments: vi.fn().mockResolvedValue([]),
+        createIssueComment: vi.fn().mockResolvedValue({}),
+        updateIssueComment: vi.fn().mockResolvedValue({}),
+        deleteIssueComment: vi.fn().mockResolvedValue(undefined),
+        createPullReview: vi.fn().mockResolvedValue({}),
+        listPullReviews: vi.fn().mockResolvedValue([]),
+        deletePullReview: vi.fn().mockResolvedValue(undefined),
+        listPullReviewComments: vi.fn().mockResolvedValue([]),
+        getIssueCommentReactions: vi.fn().mockResolvedValue([]),
+        getIssueReactions: vi.fn().mockResolvedValue([]),
+        searchUsers: vi.fn().mockResolvedValue([]),
+        getTeamMembers: vi.fn().mockResolvedValue([]),
+      };
+      (service as any).adapter = mockAdapter;
+    });
+
+    it("validateConfig 应代理到 adapter", () => {
+      service.validateConfig();
+      expect(mockAdapter.validateConfig).toHaveBeenCalled();
+    });
+
+    it("getRepository 应代理到 adapter", async () => {
+      const result = await service.getRepository("o", "r");
+      expect(mockAdapter.getRepository).toHaveBeenCalledWith("o", "r");
+      expect(result).toEqual({ id: 1 });
+    });
+
+    it("getPullRequest 应代理到 adapter", async () => {
+      await service.getPullRequest("o", "r", 42);
+      expect(mockAdapter.getPullRequest).toHaveBeenCalledWith("o", "r", 42);
+    });
+
+    it("lockBranch 应代理到 adapter", async () => {
+      await service.lockBranch("o", "r", "main", { pushWhitelistUsernames: ["bot"] });
+      expect(mockAdapter.lockBranch).toHaveBeenCalledWith("o", "r", "main", {
+        pushWhitelistUsernames: ["bot"],
+      });
+    });
+
+    it("unlockBranchSync 应代理到 adapter", () => {
+      service.unlockBranchSync("o", "r", "main");
+      expect(mockAdapter.unlockBranchSync).toHaveBeenCalledWith("o", "r", "main");
+    });
+
+    it("createPullReview 应代理到 adapter", async () => {
+      const opts = { event: "COMMENT" as const, body: "ok" };
+      await service.createPullReview("o", "r", 1, opts);
+      expect(mockAdapter.createPullReview).toHaveBeenCalledWith("o", "r", 1, opts);
+    });
+
+    it("getFileContent 应代理到 adapter", async () => {
+      const result = await service.getFileContent("o", "r", "a.ts", "main");
+      expect(mockAdapter.getFileContent).toHaveBeenCalledWith("o", "r", "a.ts", "main");
+      expect(result).toBe("content");
+    });
+
+    it("searchUsers 应代理到 adapter", async () => {
+      await service.searchUsers("test", 5);
+      expect(mockAdapter.searchUsers).toHaveBeenCalledWith("test", 5);
+    });
+
+    it("getTeamMembers 应代理到 adapter", async () => {
+      await service.getTeamMembers(99);
+      expect(mockAdapter.getTeamMembers).toHaveBeenCalledWith(99);
+    });
+
+    it("getBranch 应代理到 adapter", async () => {
+      await service.getBranch("o", "r", "main");
+      expect(mockAdapter.getBranch).toHaveBeenCalledWith("o", "r", "main");
+    });
+
+    it("listBranchProtections 应代理到 adapter", async () => {
+      await service.listBranchProtections("o", "r");
+      expect(mockAdapter.listBranchProtections).toHaveBeenCalledWith("o", "r");
+    });
+
+    it("getBranchProtection 应代理到 adapter", async () => {
+      await service.getBranchProtection("o", "r", "main");
+      expect(mockAdapter.getBranchProtection).toHaveBeenCalledWith("o", "r", "main");
+    });
+
+    it("createBranchProtection 应代理到 adapter", async () => {
+      const opts = { branchName: "main" };
+      await service.createBranchProtection("o", "r", opts as any);
+      expect(mockAdapter.createBranchProtection).toHaveBeenCalledWith("o", "r", opts);
+    });
+
+    it("editBranchProtection 应代理到 adapter", async () => {
+      const opts = { enablePush: true };
+      await service.editBranchProtection("o", "r", "main", opts as any);
+      expect(mockAdapter.editBranchProtection).toHaveBeenCalledWith("o", "r", "main", opts);
+    });
+
+    it("deleteBranchProtection 应代理到 adapter", async () => {
+      await service.deleteBranchProtection("o", "r", "main");
+      expect(mockAdapter.deleteBranchProtection).toHaveBeenCalledWith("o", "r", "main");
+    });
+
+    it("unlockBranch 应代理到 adapter", async () => {
+      await service.unlockBranch("o", "r", "main");
+      expect(mockAdapter.unlockBranch).toHaveBeenCalledWith("o", "r", "main");
+    });
+
+    it("editPullRequest 应代理到 adapter", async () => {
+      const opts = { title: "new" };
+      await service.editPullRequest("o", "r", 1, opts as any);
+      expect(mockAdapter.editPullRequest).toHaveBeenCalledWith("o", "r", 1, opts);
+    });
+
+    it("listPullRequests 应代理到 adapter", async () => {
+      await service.listPullRequests("o", "r", "open");
+      expect(mockAdapter.listPullRequests).toHaveBeenCalledWith("o", "r", "open");
+    });
+
+    it("listAllPullRequests 应代理到 adapter", async () => {
+      await service.listAllPullRequests("o", "r", { state: "open" } as any);
+      expect(mockAdapter.listAllPullRequests).toHaveBeenCalledWith("o", "r", { state: "open" });
+    });
+
+    it("getPullRequestCommits 应代理到 adapter", async () => {
+      await service.getPullRequestCommits("o", "r", 1);
+      expect(mockAdapter.getPullRequestCommits).toHaveBeenCalledWith("o", "r", 1);
+    });
+
+    it("getPullRequestFiles 应代理到 adapter", async () => {
+      await service.getPullRequestFiles("o", "r", 1);
+      expect(mockAdapter.getPullRequestFiles).toHaveBeenCalledWith("o", "r", 1);
+    });
+
+    it("getPullRequestDiff 应代理到 adapter", async () => {
+      await service.getPullRequestDiff("o", "r", 1);
+      expect(mockAdapter.getPullRequestDiff).toHaveBeenCalledWith("o", "r", 1);
+    });
+
+    it("getCommit 应代理到 adapter", async () => {
+      await service.getCommit("o", "r", "abc");
+      expect(mockAdapter.getCommit).toHaveBeenCalledWith("o", "r", "abc");
+    });
+
+    it("getCompareDiff 应代理到 adapter", async () => {
+      await service.getCompareDiff("o", "r", "a", "b");
+      expect(mockAdapter.getCompareDiff).toHaveBeenCalledWith("o", "r", "a", "b");
+    });
+
+    it("getCommitDiff 应代理到 adapter", async () => {
+      await service.getCommitDiff("o", "r", "abc");
+      expect(mockAdapter.getCommitDiff).toHaveBeenCalledWith("o", "r", "abc");
+    });
+
+    it("listRepositoryContents 应代理到 adapter", async () => {
+      mockAdapter.listRepositoryContents = vi.fn().mockResolvedValue([]);
+      await service.listRepositoryContents("o", "r", "src", "main");
+      expect(mockAdapter.listRepositoryContents).toHaveBeenCalledWith("o", "r", "src", "main");
+    });
+
+    it("createIssue 应代理到 adapter", async () => {
+      const opts = { title: "bug" };
+      await service.createIssue("o", "r", opts as any);
+      expect(mockAdapter.createIssue).toHaveBeenCalledWith("o", "r", opts);
+    });
+
+    it("listIssueComments 应代理到 adapter", async () => {
+      await service.listIssueComments("o", "r", 1);
+      expect(mockAdapter.listIssueComments).toHaveBeenCalledWith("o", "r", 1);
+    });
+
+    it("createIssueComment 应代理到 adapter", async () => {
+      const opts = { body: "comment" };
+      await service.createIssueComment("o", "r", 1, opts as any);
+      expect(mockAdapter.createIssueComment).toHaveBeenCalledWith("o", "r", 1, opts);
+    });
+
+    it("updateIssueComment 应代理到 adapter", async () => {
+      await service.updateIssueComment("o", "r", 1, "updated");
+      expect(mockAdapter.updateIssueComment).toHaveBeenCalledWith("o", "r", 1, "updated");
+    });
+
+    it("deleteIssueComment 应代理到 adapter", async () => {
+      await service.deleteIssueComment("o", "r", 1);
+      expect(mockAdapter.deleteIssueComment).toHaveBeenCalledWith("o", "r", 1);
+    });
+
+    it("listPullReviews 应代理到 adapter", async () => {
+      await service.listPullReviews("o", "r", 1);
+      expect(mockAdapter.listPullReviews).toHaveBeenCalledWith("o", "r", 1);
+    });
+
+    it("deletePullReview 应代理到 adapter", async () => {
+      await service.deletePullReview("o", "r", 1, 2);
+      expect(mockAdapter.deletePullReview).toHaveBeenCalledWith("o", "r", 1, 2);
+    });
+
+    it("listPullReviewComments 应代理到 adapter", async () => {
+      await service.listPullReviewComments("o", "r", 1, 2);
+      expect(mockAdapter.listPullReviewComments).toHaveBeenCalledWith("o", "r", 1, 2);
+    });
+
+    it("getIssueCommentReactions 应代理到 adapter", async () => {
+      await service.getIssueCommentReactions("o", "r", 1);
+      expect(mockAdapter.getIssueCommentReactions).toHaveBeenCalledWith("o", "r", 1);
+    });
+
+    it("getIssueReactions 应代理到 adapter", async () => {
+      await service.getIssueReactions("o", "r", 1);
+      expect(mockAdapter.getIssueReactions).toHaveBeenCalledWith("o", "r", 1);
+    });
+  });
+});

package/src/shared/git-provider/git-provider.service.ts

@@ -0,0 +1,309 @@
+import { Inject, Injectable } from "@nestjs/common";
+import type {
+  GitProvider,
+  LockBranchOptions,
+  ListPullRequestsOptions,
+} from "./git-provider.interface";
+import {
+  type GitProviderModuleOptions,
+  GIT_PROVIDER_MODULE_OPTIONS,
+  type BranchProtection,
+  type CreateBranchProtectionOption,
+  type EditBranchProtectionOption,
+  type Branch,
+  type Repository,
+  type PullRequest,
+  type PullRequestCommit,
+  type ChangedFile,
+  type CommitInfo,
+  type IssueComment,
+  type CreateIssueCommentOption,
+  type CreateIssueOption,
+  type Issue,
+  type CreatePullReviewOption,
+  type PullReview,
+  type PullReviewComment,
+  type Reaction,
+  type EditPullRequestOption,
+  type User,
+  type RepositoryContent,
+} from "./types";
+import { GiteaAdapter } from "./adapters/gitea.adapter";
+import { GithubAdapter } from "./adapters/github.adapter";
+import { GitlabAdapter } from "./adapters/gitlab.adapter";
+
+/**
+ * Git Provider 统一服务
+ * 根据配置的 provider 类型代理到对应的适配器实现
+ */
+@Injectable()
+export class GitProviderService implements GitProvider {
+  protected readonly adapter: GitProvider;
+
+  constructor(
+    @Inject(GIT_PROVIDER_MODULE_OPTIONS) protected readonly options: GitProviderModuleOptions,
+  ) {
+    this.adapter = this.createAdapter(options);
+  }
+
+  /**
+   * 根据 provider 类型创建对应的适配器
+   */
+  protected createAdapter(options: GitProviderModuleOptions): GitProvider {
+    switch (options.provider) {
+      case "gitea":
+        return new GiteaAdapter(options);
+      case "github":
+        return new GithubAdapter(options);
+      case "gitlab":
+        return new GitlabAdapter(options);
+      default:
+        throw new Error(`不支持的 Git Provider 类型: ${options.provider}`);
+    }
+  }
+
+  // ============ 配置验证 ============
+
+  validateConfig(): void {
+    this.adapter.validateConfig();
+  }
+
+  // ============ 仓库操作 ============
+
+  async getRepository(owner: string, repo: string): Promise<Repository> {
+    return this.adapter.getRepository(owner, repo);
+  }
+
+  // ============ 分支操作 ============
+
+  async getBranch(owner: string, repo: string, branch: string): Promise<Branch> {
+    return this.adapter.getBranch(owner, repo, branch);
+  }
+
+  // ============ 分支保护 ============
+
+  async listBranchProtections(owner: string, repo: string): Promise<BranchProtection[]> {
+    return this.adapter.listBranchProtections(owner, repo);
+  }
+
+  async getBranchProtection(owner: string, repo: string, name: string): Promise<BranchProtection> {
+    return this.adapter.getBranchProtection(owner, repo, name);
+  }
+
+  async createBranchProtection(
+    owner: string,
+    repo: string,
+    options: CreateBranchProtectionOption,
+  ): Promise<BranchProtection> {
+    return this.adapter.createBranchProtection(owner, repo, options);
+  }
+
+  async editBranchProtection(
+    owner: string,
+    repo: string,
+    name: string,
+    options: EditBranchProtectionOption,
+  ): Promise<BranchProtection> {
+    return this.adapter.editBranchProtection(owner, repo, name, options);
+  }
+
+  async deleteBranchProtection(owner: string, repo: string, name: string): Promise<void> {
+    return this.adapter.deleteBranchProtection(owner, repo, name);
+  }
+
+  async lockBranch(
+    owner: string,
+    repo: string,
+    branch: string,
+    options?: LockBranchOptions,
+  ): Promise<BranchProtection> {
+    return this.adapter.lockBranch(owner, repo, branch, options);
+  }
+
+  async unlockBranch(
+    owner: string,
+    repo: string,
+    branch: string,
+  ): Promise<BranchProtection | null> {
+    return this.adapter.unlockBranch(owner, repo, branch);
+  }
+
+  unlockBranchSync(owner: string, repo: string, branch: string): void {
+    this.adapter.unlockBranchSync(owner, repo, branch);
+  }
+
+  // ============ Pull Request 操作 ============
+
+  async getPullRequest(owner: string, repo: string, index: number): Promise<PullRequest> {
+    return this.adapter.getPullRequest(owner, repo, index);
+  }
+
+  async editPullRequest(
+    owner: string,
+    repo: string,
+    index: number,
+    options: EditPullRequestOption,
+  ): Promise<PullRequest> {
+    return this.adapter.editPullRequest(owner, repo, index, options);
+  }
+
+  async listPullRequests(
+    owner: string,
+    repo: string,
+    state?: "open" | "closed" | "all",
+  ): Promise<PullRequest[]> {
+    return this.adapter.listPullRequests(owner, repo, state);
+  }
+
+  async listAllPullRequests(
+    owner: string,
+    repo: string,
+    options?: ListPullRequestsOptions,
+  ): Promise<PullRequest[]> {
+    return this.adapter.listAllPullRequests(owner, repo, options);
+  }
+
+  async getPullRequestCommits(
+    owner: string,
+    repo: string,
+    index: number,
+  ): Promise<PullRequestCommit[]> {
+    return this.adapter.getPullRequestCommits(owner, repo, index);
+  }
+
+  async getPullRequestFiles(owner: string, repo: string, index: number): Promise<ChangedFile[]> {
+    return this.adapter.getPullRequestFiles(owner, repo, index);
+  }
+
+  async getPullRequestDiff(owner: string, repo: string, index: number): Promise<string> {
+    return this.adapter.getPullRequestDiff(owner, repo, index);
+  }
+
+  // ============ Commit 操作 ============
+
+  async getCommit(owner: string, repo: string, sha: string): Promise<CommitInfo> {
+    return this.adapter.getCommit(owner, repo, sha);
+  }
+
+  async getCompareDiff(
+    owner: string,
+    repo: string,
+    baseSha: string,
+    headSha: string,
+  ): Promise<string> {
+    return this.adapter.getCompareDiff(owner, repo, baseSha, headSha);
+  }
+
+  async getCommitDiff(owner: string, repo: string, sha: string): Promise<string> {
+    return this.adapter.getCommitDiff(owner, repo, sha);
+  }
+
+  // ============ 文件操作 ============
+
+  async getFileContent(
+    owner: string,
+    repo: string,
+    filepath: string,
+    ref?: string,
+  ): Promise<string> {
+    return this.adapter.getFileContent(owner, repo, filepath, ref);
+  }
+
+  async listRepositoryContents(
+    owner: string,
+    repo: string,
+    path?: string,
+    ref?: string,
+  ): Promise<RepositoryContent[]> {
+    return this.adapter.listRepositoryContents(owner, repo, path, ref);
+  }
+
+  // ============ Issue 操作 ============
+
+  async createIssue(owner: string, repo: string, options: CreateIssueOption): Promise<Issue> {
+    return this.adapter.createIssue(owner, repo, options);
+  }
+
+  async listIssueComments(owner: string, repo: string, index: number): Promise<IssueComment[]> {
+    return this.adapter.listIssueComments(owner, repo, index);
+  }
+
+  async createIssueComment(
+    owner: string,
+    repo: string,
+    index: number,
+    options: CreateIssueCommentOption,
+  ): Promise<IssueComment> {
+    return this.adapter.createIssueComment(owner, repo, index, options);
+  }
+
+  async updateIssueComment(
+    owner: string,
+    repo: string,
+    commentId: number,
+    body: string,
+  ): Promise<IssueComment> {
+    return this.adapter.updateIssueComment(owner, repo, commentId, body);
+  }
+
+  async deleteIssueComment(owner: string, repo: string, commentId: number): Promise<void> {
+    return this.adapter.deleteIssueComment(owner, repo, commentId);
+  }
+
+  // ============ PR Review 操作 ============
+
+  async createPullReview(
+    owner: string,
+    repo: string,
+    index: number,
+    options: CreatePullReviewOption,
+  ): Promise<PullReview> {
+    return this.adapter.createPullReview(owner, repo, index, options);
+  }
+
+  async listPullReviews(owner: string, repo: string, index: number): Promise<PullReview[]> {
+    return this.adapter.listPullReviews(owner, repo, index);
+  }
+
+  async deletePullReview(
+    owner: string,
+    repo: string,
+    index: number,
+    reviewId: number,
+  ): Promise<void> {
+    return this.adapter.deletePullReview(owner, repo, index, reviewId);
+  }
+
+  async listPullReviewComments(
+    owner: string,
+    repo: string,
+    index: number,
+    reviewId: number,
+  ): Promise<PullReviewComment[]> {
+    return this.adapter.listPullReviewComments(owner, repo, index, reviewId);
+  }
+
+  // ============ Reaction 操作 ============
+
+  async getIssueCommentReactions(
+    owner: string,
+    repo: string,
+    commentId: number,
+  ): Promise<Reaction[]> {
+    return this.adapter.getIssueCommentReactions(owner, repo, commentId);
+  }
+
+  async getIssueReactions(owner: string, repo: string, index: number): Promise<Reaction[]> {
+    return this.adapter.getIssueReactions(owner, repo, index);
+  }
+
+  // ============ 用户操作 ============
+
+  async searchUsers(query: string, limit?: number): Promise<User[]> {
+    return this.adapter.searchUsers(query, limit);
+  }
+
+  async getTeamMembers(teamId: number): Promise<User[]> {
+    return this.adapter.getTeamMembers(teamId);
+  }
+}

package/src/shared/git-provider/index.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./detect-provider";
+export * from "./parse-repo-url";
+export * from "./git-provider.interface";
+export * from "./git-provider.service";
+export * from "./git-provider.module";
+export * from "./adapters";