lex-github 0.2.5 → 0.3.0

data/lib/legion/extensions/github/runners/checks.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/github/helpers/client'
+
+module Legion
+  module Extensions
+    module Github
+      module Runners
+        module Checks
+          include Legion::Extensions::Github::Helpers::Client
+
+          def create_check_run(owner:, repo:, name:, head_sha:, status: nil, # rubocop:disable Metrics/ParameterLists
+                               conclusion: nil, output: nil, details_url: nil, **)
+            payload = { name: name, head_sha: head_sha, status: status,
+                        conclusion: conclusion, output: output, details_url: details_url }.compact
+            response = connection(owner: owner, repo: repo, **).post(
+              "/repos/#{owner}/#{repo}/check-runs", payload
+            )
+            { result: response.body }
+          end
+
+          def update_check_run(owner:, repo:, check_run_id:, **opts)
+            payload = opts.slice(:name, :status, :conclusion, :output, :details_url,
+                                 :started_at, :completed_at)
+            response = connection(owner: owner, repo: repo, **opts).patch(
+              "/repos/#{owner}/#{repo}/check-runs/#{check_run_id}", payload
+            )
+            { result: response.body }
+          end
+
+          def get_check_run(owner:, repo:, check_run_id:, **)
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/check-runs/#{check_run_id}"
+            )
+            { result: response.body }
+          end
+
+          def list_check_runs_for_ref(owner:, repo:, ref:, check_name: nil, status: nil,
+                                      per_page: 30, page: 1, **)
+            params = { check_name: check_name, status: status,
+                       per_page: per_page, page: page }.compact
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/commits/#{ref}/check-runs", params
+            )
+            { result: response.body }
+          end
+
+          def list_check_suites_for_ref(owner:, repo:, ref:, per_page: 30, page: 1, **)
+            params = { per_page: per_page, page: page }
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/commits/#{ref}/check-suites", params
+            )
+            { result: response.body }
+          end
+
+          def get_check_suite(owner:, repo:, check_suite_id:, **)
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/check-suites/#{check_suite_id}"
+            )
+            { result: response.body }
+          end
+
+          def rerequest_check_suite(owner:, repo:, check_suite_id:, **)
+            response = connection(owner: owner, repo: repo, **).post(
+              "/repos/#{owner}/#{repo}/check-suites/#{check_suite_id}/rerequest"
+            )
+            { result: [201, 204].include?(response.status) }
+          end
+
+          def list_check_run_annotations(owner:, repo:, check_run_id:, per_page: 30, page: 1, **)
+            params = { per_page: per_page, page: page }
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/check-runs/#{check_run_id}/annotations", params
+            )
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/github/runners/comments.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/github/helpers/client'
+require 'legion/extensions/github/helpers/cache'
 
 module Legion
   module Extensions
@@ -8,30 +9,35 @@ module Legion
       module Runners
         module Comments
           include Legion::Extensions::Github::Helpers::Client
+          include Legion::Extensions::Github::Helpers::Cache
 
           def list_comments(owner:, repo:, issue_number:, per_page: 30, page: 1, **)
             params = { per_page: per_page, page: page }
-            response = connection(**).get("/repos/#{owner}/#{repo}/issues/#{issue_number}/comments", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:issues:#{issue_number}:comments:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/issues/#{issue_number}/comments", params).body
+            end }
           end
 
           def get_comment(owner:, repo:, comment_id:, **)
-            response = connection(**).get("/repos/#{owner}/#{repo}/issues/comments/#{comment_id}")
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:comments:#{comment_id}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/issues/comments/#{comment_id}").body
+            end }
           end
 
           def create_comment(owner:, repo:, issue_number:, body:, **)
-            response = connection(**).post("/repos/#{owner}/#{repo}/issues/#{issue_number}/comments", { body: body })
+            response = connection(owner: owner, repo: repo, **).post("/repos/#{owner}/#{repo}/issues/#{issue_number}/comments", { body: body })
             { result: response.body }
           end
 
           def update_comment(owner:, repo:, comment_id:, body:, **)
-            response = connection(**).patch("/repos/#{owner}/#{repo}/issues/comments/#{comment_id}", { body: body })
+            response = connection(owner: owner, repo: repo, **).patch("/repos/#{owner}/#{repo}/issues/comments/#{comment_id}", { body: body })
+            cache_write("github:repo:#{owner}/#{repo}:comments:#{comment_id}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def delete_comment(owner:, repo:, comment_id:, **)
-            response = connection(**).delete("/repos/#{owner}/#{repo}/issues/comments/#{comment_id}")
+            response = connection(owner: owner, repo: repo, **).delete("/repos/#{owner}/#{repo}/issues/comments/#{comment_id}")
+            cache_invalidate("github:repo:#{owner}/#{repo}:comments:#{comment_id}") if response.status == 204
             { result: response.status == 204 }
           end
 

data/lib/legion/extensions/github/runners/commits.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/github/helpers/client'
+require 'legion/extensions/github/helpers/cache'
 
 module Legion
   module Extensions
@@ -8,23 +9,27 @@ module Legion
       module Runners
         module Commits
           include Legion::Extensions::Github::Helpers::Client
+          include Legion::Extensions::Github::Helpers::Cache
 
           def list_commits(owner:, repo:, sha: nil, per_page: 30, page: 1, **)
             params = { per_page: per_page, page: page }
             params[:sha] = sha if sha
-            response = connection(**).get("/repos/#{owner}/#{repo}/commits", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:commits:#{sha}:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/commits", params).body
+            end }
           end
 
           def get_commit(owner:, repo:, ref:, **)
-            response = connection(**).get("/repos/#{owner}/#{repo}/commits/#{ref}")
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:commits:#{ref}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/commits/#{ref}").body
+            end }
           end
 
           def compare_commits(owner:, repo:, base:, head:, per_page: 30, page: 1, **)
             params = { per_page: per_page, page: page }
-            response = connection(**).get("/repos/#{owner}/#{repo}/compare/#{base}...#{head}", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:commits:compare:#{base}...#{head}:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/compare/#{base}...#{head}", params).body
+            end }
           end
 
           include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&

data/lib/legion/extensions/github/runners/contents.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/github/helpers/client'
+require 'legion/extensions/github/helpers/cache'
 
 module Legion
   module Extensions
@@ -8,9 +9,10 @@ module Legion
       module Runners
         module Contents
           include Legion::Extensions::Github::Helpers::Client
+          include Legion::Extensions::Github::Helpers::Cache
 
           def commit_files(owner:, repo:, branch:, files:, message:, **)
-            conn = connection(**)
+            conn = connection(owner: owner, repo: repo, **)
 
             ref = conn.get("/repos/#{owner}/#{repo}/git/ref/heads/#{branch}")
             commit_sha = ref.body.dig('object', 'sha')

data/lib/legion/extensions/github/runners/deployments.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/github/helpers/client'
+
+module Legion
+  module Extensions
+    module Github
+      module Runners
+        module Deployments
+          include Legion::Extensions::Github::Helpers::Client
+
+          def list_deployments(owner:, repo:, environment: nil, ref: nil, per_page: 30, page: 1, **)
+            params = { environment: environment, ref: ref,
+                       per_page: per_page, page: page }.compact
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/deployments", params
+            )
+            { result: response.body }
+          end
+
+          def get_deployment(owner:, repo:, deployment_id:, **)
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/deployments/#{deployment_id}"
+            )
+            { result: response.body }
+          end
+
+          def create_deployment(owner:, repo:, ref:, environment: 'production',
+                                description: nil, auto_merge: true, required_contexts: nil, **)
+            payload = { ref: ref, environment: environment, description: description,
+                        auto_merge: auto_merge, required_contexts: required_contexts }.compact
+            response = connection(owner: owner, repo: repo, **).post(
+              "/repos/#{owner}/#{repo}/deployments", payload
+            )
+            { result: response.body }
+          end
+
+          def delete_deployment(owner:, repo:, deployment_id:, **)
+            response = connection(owner: owner, repo: repo, **).delete(
+              "/repos/#{owner}/#{repo}/deployments/#{deployment_id}"
+            )
+            { result: response.status == 204 }
+          end
+
+          def list_deployment_statuses(owner:, repo:, deployment_id:, per_page: 30, page: 1, **)
+            params = { per_page: per_page, page: page }
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/deployments/#{deployment_id}/statuses", params
+            )
+            { result: response.body }
+          end
+
+          def create_deployment_status(owner:, repo:, deployment_id:, state:,
+                                       description: nil, environment_url: nil, log_url: nil, **)
+            payload = { state: state, description: description,
+                        environment_url: environment_url, log_url: log_url }.compact
+            response = connection(owner: owner, repo: repo, **).post(
+              "/repos/#{owner}/#{repo}/deployments/#{deployment_id}/statuses", payload
+            )
+            { result: response.body }
+          end
+
+          def get_deployment_status(owner:, repo:, deployment_id:, status_id:, **)
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/deployments/#{deployment_id}/statuses/#{status_id}"
+            )
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/github/runners/gists.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/github/helpers/client'
+require 'legion/extensions/github/helpers/cache'
 
 module Legion
   module Extensions
@@ -8,31 +9,35 @@ module Legion
       module Runners
         module Gists
           include Legion::Extensions::Github::Helpers::Client
+          include Legion::Extensions::Github::Helpers::Cache
 
           def list_gists(per_page: 30, page: 1, **)
-            response = connection(**).get('/gists', per_page: per_page, page: page)
-            { result: response.body }
+            cred = resolve_credential
+            fp = cred&.dig(:metadata, :credential_fingerprint) || 'anonymous'
+            { result: cached_get("github:user:gists:#{fp}:#{page}:#{per_page}") { connection(**).get('/gists', per_page: per_page, page: page).body } }
           end
 
           def get_gist(gist_id:, **)
-            response = connection(**).get("/gists/#{gist_id}")
-            { result: response.body }
+            { result: cached_get("github:gist:#{gist_id}") { connection(**).get("/gists/#{gist_id}").body } }
           end
 
           def create_gist(files:, description: nil, public: false, **)
             payload = { files: files, description: description, public: public }
             response = connection(**).post('/gists', payload)
+            cache_write("github:gist:#{response.body['id']}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def update_gist(gist_id:, files: nil, description: nil, **)
             payload = { files: files, description: description }.compact
             response = connection(**).patch("/gists/#{gist_id}", payload)
+            cache_write("github:gist:#{gist_id}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def delete_gist(gist_id:, **)
             response = connection(**).delete("/gists/#{gist_id}")
+            cache_invalidate("github:gist:#{gist_id}") if response.status == 204
             { result: response.status == 204 }
           end
 

data/lib/legion/extensions/github/runners/issues.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/github/helpers/client'
+require 'legion/extensions/github/helpers/cache'
 
 module Legion
   module Extensions
@@ -8,38 +9,44 @@ module Legion
       module Runners
         module Issues
           include Legion::Extensions::Github::Helpers::Client
+          include Legion::Extensions::Github::Helpers::Cache
 
           def list_issues(owner:, repo:, state: 'open', per_page: 30, page: 1, **)
             params = { state: state, per_page: per_page, page: page }
-            response = connection(**).get("/repos/#{owner}/#{repo}/issues", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:issues:#{state}:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/issues", params).body
+            end }
           end
 
           def get_issue(owner:, repo:, issue_number:, **)
-            response = connection(**).get("/repos/#{owner}/#{repo}/issues/#{issue_number}")
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:issues:#{issue_number}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/issues/#{issue_number}").body
+            end }
           end
 
           def create_issue(owner:, repo:, title:, body: nil, labels: [], assignees: [], **)
             payload = { title: title, body: body, labels: labels, assignees: assignees }
-            response = connection(**).post("/repos/#{owner}/#{repo}/issues", payload)
+            response = connection(owner: owner, repo: repo, **).post("/repos/#{owner}/#{repo}/issues", payload)
+            cache_write("github:repo:#{owner}/#{repo}:issues:#{response.body['number']}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def update_issue(owner:, repo:, issue_number:, **opts)
             payload = opts.slice(:title, :body, :state, :labels, :assignees)
-            response = connection(**opts).patch("/repos/#{owner}/#{repo}/issues/#{issue_number}", payload)
+            response = connection(owner: owner, repo: repo, **opts).patch("/repos/#{owner}/#{repo}/issues/#{issue_number}", payload)
+            cache_write("github:repo:#{owner}/#{repo}:issues:#{issue_number}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def list_issue_comments(owner:, repo:, issue_number:, per_page: 30, page: 1, **)
             params = { per_page: per_page, page: page }
-            response = connection(**).get("/repos/#{owner}/#{repo}/issues/#{issue_number}/comments", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:issues:#{issue_number}:comments:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/issues/#{issue_number}/comments", params).body
+            end }
           end
 
           def create_issue_comment(owner:, repo:, issue_number:, body:, **)
-            response = connection(**).post("/repos/#{owner}/#{repo}/issues/#{issue_number}/comments", { body: body })
+            response = connection(owner: owner, repo: repo, **).post("/repos/#{owner}/#{repo}/issues/#{issue_number}/comments", { body: body })
             { result: response.body }
           end
 

data/lib/legion/extensions/github/runners/labels.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/github/helpers/client'
+require 'legion/extensions/github/helpers/cache'
 
 module Legion
   module Extensions
@@ -8,42 +9,48 @@ module Legion
       module Runners
         module Labels
           include Legion::Extensions::Github::Helpers::Client
+          include Legion::Extensions::Github::Helpers::Cache
 
           def list_labels(owner:, repo:, per_page: 30, page: 1, **)
             params = { per_page: per_page, page: page }
-            response = connection(**).get("/repos/#{owner}/#{repo}/labels", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:labels:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/labels", params).body
+            end }
           end
 
           def get_label(owner:, repo:, name:, **)
-            response = connection(**).get("/repos/#{owner}/#{repo}/labels/#{name}")
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:labels:#{name}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/labels/#{name}").body
+            end }
           end
 
           def create_label(owner:, repo:, name:, color:, description: nil, **)
             payload = { name: name, color: color, description: description }.compact
-            response = connection(**).post("/repos/#{owner}/#{repo}/labels", payload)
+            response = connection(owner: owner, repo: repo, **).post("/repos/#{owner}/#{repo}/labels", payload)
+            cache_write("github:repo:#{owner}/#{repo}:labels:#{name}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def update_label(owner:, repo:, name:, new_name: nil, color: nil, description: nil, **)
             payload = { new_name: new_name, color: color, description: description }.compact
-            response = connection(**).patch("/repos/#{owner}/#{repo}/labels/#{name}", payload)
+            response = connection(owner: owner, repo: repo, **).patch("/repos/#{owner}/#{repo}/labels/#{name}", payload)
+            cache_write("github:repo:#{owner}/#{repo}:labels:#{name}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def delete_label(owner:, repo:, name:, **)
-            response = connection(**).delete("/repos/#{owner}/#{repo}/labels/#{name}")
+            response = connection(owner: owner, repo: repo, **).delete("/repos/#{owner}/#{repo}/labels/#{name}")
+            cache_invalidate("github:repo:#{owner}/#{repo}:labels:#{name}") if response.status == 204
             { result: response.status == 204 }
           end
 
           def add_labels_to_issue(owner:, repo:, issue_number:, labels:, **)
-            response = connection(**).post("/repos/#{owner}/#{repo}/issues/#{issue_number}/labels", { labels: labels })
+            response = connection(owner: owner, repo: repo, **).post("/repos/#{owner}/#{repo}/issues/#{issue_number}/labels", { labels: labels })
             { result: response.body }
           end
 
           def remove_label_from_issue(owner:, repo:, issue_number:, name:, **)
-            response = connection(**).delete("/repos/#{owner}/#{repo}/issues/#{issue_number}/labels/#{name}")
+            response = connection(owner: owner, repo: repo, **).delete("/repos/#{owner}/#{repo}/issues/#{issue_number}/labels/#{name}")
             { result: response.status == 204 }
           end
 

data/lib/legion/extensions/github/runners/organizations.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/github/helpers/client'
+require 'legion/extensions/github/helpers/cache'
 
 module Legion
   module Extensions
@@ -8,26 +9,27 @@ module Legion
       module Runners
         module Organizations
           include Legion::Extensions::Github::Helpers::Client
+          include Legion::Extensions::Github::Helpers::Cache
 
           def list_user_orgs(username:, per_page: 30, page: 1, **)
-            response = connection(**).get("/users/#{username}/orgs", per_page: per_page, page: page)
-            { result: response.body }
+            { result: cached_get("github:user:#{username}:orgs:#{page}:#{per_page}") do
+              connection(**).get("/users/#{username}/orgs", per_page: per_page, page: page).body
+            end }
           end
 
           def get_org(org:, **)
-            response = connection(**).get("/orgs/#{org}")
-            { result: response.body }
+            { result: cached_get("github:org:#{org}") { connection(owner: org, **).get("/orgs/#{org}").body } }
           end
 
           def list_org_repos(org:, type: 'all', per_page: 30, page: 1, **)
             params = { type: type, per_page: per_page, page: page }
-            response = connection(**).get("/orgs/#{org}/repos", params)
-            { result: response.body }
+            { result: cached_get("github:org:#{org}:repos:#{type}:#{page}:#{per_page}") { connection(owner: org, **).get("/orgs/#{org}/repos", params).body } }
           end
 
           def list_org_members(org:, per_page: 30, page: 1, **)
-            response = connection(**).get("/orgs/#{org}/members", per_page: per_page, page: page)
-            { result: response.body }
+            { result: cached_get("github:org:#{org}:members:#{page}:#{per_page}") do
+              connection(owner: org, **).get("/orgs/#{org}/members", per_page: per_page, page: page).body
+            end }
           end
 
           include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&

data/lib/legion/extensions/github/runners/pull_requests.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/github/helpers/client'
+require 'legion/extensions/github/helpers/cache'
 
 module Legion
   module Extensions
@@ -8,57 +9,66 @@ module Legion
       module Runners
         module PullRequests
           include Legion::Extensions::Github::Helpers::Client
+          include Legion::Extensions::Github::Helpers::Cache
 
           def list_pull_requests(owner:, repo:, state: 'open', per_page: 30, page: 1, **)
             params = { state: state, per_page: per_page, page: page }
-            response = connection(**).get("/repos/#{owner}/#{repo}/pulls", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:pulls:#{state}:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/pulls", params).body
+            end }
           end
 
           def get_pull_request(owner:, repo:, pull_number:, **)
-            response = connection(**).get("/repos/#{owner}/#{repo}/pulls/#{pull_number}")
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:pulls:#{pull_number}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/pulls/#{pull_number}").body
+            end }
           end
 
           def create_pull_request(owner:, repo:, title:, head:, base:, body: nil, draft: false, **)
             payload = { title: title, head: head, base: base, body: body, draft: draft }
-            response = connection(**).post("/repos/#{owner}/#{repo}/pulls", payload)
+            response = connection(owner: owner, repo: repo, **).post("/repos/#{owner}/#{repo}/pulls", payload)
+            cache_write("github:repo:#{owner}/#{repo}:pulls:#{response.body['number']}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def update_pull_request(owner:, repo:, pull_number:, **opts)
             payload = opts.slice(:title, :body, :state, :base)
-            response = connection(**opts).patch("/repos/#{owner}/#{repo}/pulls/#{pull_number}", payload)
+            response = connection(owner: owner, repo: repo, **opts).patch("/repos/#{owner}/#{repo}/pulls/#{pull_number}", payload)
+            cache_write("github:repo:#{owner}/#{repo}:pulls:#{pull_number}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def merge_pull_request(owner:, repo:, pull_number:, commit_title: nil, merge_method: 'merge', **)
             payload = { commit_title: commit_title, merge_method: merge_method }.compact
-            response = connection(**).put("/repos/#{owner}/#{repo}/pulls/#{pull_number}/merge", payload)
+            response = connection(owner: owner, repo: repo, **).put("/repos/#{owner}/#{repo}/pulls/#{pull_number}/merge", payload)
+            cache_invalidate("github:repo:#{owner}/#{repo}:pulls:#{pull_number}")
             { result: response.body }
           end
 
           def list_pull_request_commits(owner:, repo:, pull_number:, per_page: 30, page: 1, **)
             params = { per_page: per_page, page: page }
-            response = connection(**).get("/repos/#{owner}/#{repo}/pulls/#{pull_number}/commits", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:pulls:#{pull_number}:commits:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/pulls/#{pull_number}/commits", params).body
+            end }
           end
 
           def list_pull_request_files(owner:, repo:, pull_number:, per_page: 30, page: 1, **)
             params = { per_page: per_page, page: page }
-            response = connection(**).get("/repos/#{owner}/#{repo}/pulls/#{pull_number}/files", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:pulls:#{pull_number}:files:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/pulls/#{pull_number}/files", params).body
+            end }
           end
 
           def list_pull_request_reviews(owner:, repo:, pull_number:, per_page: 30, page: 1, **)
             params = { per_page: per_page, page: page }
-            response = connection(**).get("/repos/#{owner}/#{repo}/pulls/#{pull_number}/reviews", params)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:pulls:#{pull_number}:reviews:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/pulls/#{pull_number}/reviews", params).body
+            end }
           end
 
           def create_review(owner:, repo:, pull_number:, body:, comments: [], event: 'COMMENT', **)
             payload = { event: event, body: body, comments: comments }
-            response = connection(**).post("/repos/#{owner}/#{repo}/pulls/#{pull_number}/reviews", payload)
+            response = connection(owner: owner, repo: repo, **).post("/repos/#{owner}/#{repo}/pulls/#{pull_number}/reviews", payload)
             { result: response.body }
           end