lex-github 0.2.4 → 0.3.0

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,36 +9,40 @@ 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
 
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
         end
       end
     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,43 +9,49 @@ 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
 
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
         end
       end
     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,47 +9,53 @@ 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
 
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
         end
       end
     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,30 +9,31 @@ 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) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
         end
       end
     end

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,62 +9,71 @@ 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
 
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
         end
       end
     end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/github/helpers/client'
+
+module Legion
+  module Extensions
+    module Github
+      module Runners
+        module Releases
+          include Legion::Extensions::Github::Helpers::Client
+
+          def list_releases(owner:, repo:, per_page: 30, page: 1, **)
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/releases", per_page: per_page, page: page
+            )
+            { result: response.body }
+          end
+
+          def get_release(owner:, repo:, release_id:, **)
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/releases/#{release_id}"
+            )
+            { result: response.body }
+          end
+
+          def get_latest_release(owner:, repo:, **)
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/releases/latest"
+            )
+            { result: response.body }
+          end
+
+          def get_release_by_tag(owner:, repo:, tag:, **)
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/releases/tags/#{tag}"
+            )
+            { result: response.body }
+          end
+
+          def create_release(owner:, repo:, tag_name:, name: nil, body: nil, # rubocop:disable Metrics/ParameterLists
+                             target_commitish: nil, draft: false, prerelease: false,
+                             generate_release_notes: false, **)
+            payload = { tag_name: tag_name, name: name, body: body,
+                        target_commitish: target_commitish, draft: draft,
+                        prerelease: prerelease,
+                        generate_release_notes: generate_release_notes }.compact
+            response = connection(owner: owner, repo: repo, **).post(
+              "/repos/#{owner}/#{repo}/releases", payload
+            )
+            { result: response.body }
+          end
+
+          def update_release(owner:, repo:, release_id:, **opts)
+            payload = opts.slice(:tag_name, :name, :body, :draft, :prerelease, :target_commitish)
+            response = connection(owner: owner, repo: repo, **opts).patch(
+              "/repos/#{owner}/#{repo}/releases/#{release_id}", payload
+            )
+            { result: response.body }
+          end
+
+          def delete_release(owner:, repo:, release_id:, **)
+            response = connection(owner: owner, repo: repo, **).delete(
+              "/repos/#{owner}/#{repo}/releases/#{release_id}"
+            )
+            { result: response.status == 204 }
+          end
+
+          def list_release_assets(owner:, repo:, release_id:, per_page: 30, page: 1, **)
+            response = connection(owner: owner, repo: repo, **).get(
+              "/repos/#{owner}/#{repo}/releases/#{release_id}/assets",
+              per_page: per_page, page: page
+            )
+            { result: response.body }
+          end
+
+          def delete_release_asset(owner:, repo:, asset_id:, **)
+            response = connection(owner: owner, repo: repo, **).delete(
+              "/repos/#{owner}/#{repo}/releases/assets/#{asset_id}"
+            )
+            { result: response.status == 204 }
+          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/repositories.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,46 +9,52 @@ module Legion
       module Runners
         module Repositories
           include Legion::Extensions::Github::Helpers::Client
+          include Legion::Extensions::Github::Helpers::Cache
 
           def list_repos(username:, per_page: 30, page: 1, **)
-            response = connection(**).get("/users/#{username}/repos", per_page: per_page, page: page)
-            { result: response.body }
+            { result: cached_get("github:user:#{username}:repos:#{page}:#{per_page}") do
+              connection(**).get("/users/#{username}/repos", per_page: per_page, page: page).body
+            end }
           end
 
           def get_repo(owner:, repo:, **)
-            response = connection(**).get("/repos/#{owner}/#{repo}")
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}") { connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}").body } }
           end
 
           def create_repo(name:, description: nil, private: false, **)
             body = { name: name, description: description, private: private }
             response = connection(**).post('/user/repos', body)
+            cache_write("github:repo:#{response.body['full_name']}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def update_repo(owner:, repo:, **opts)
             body = opts.slice(:name, :description, :homepage, :private, :default_branch)
-            response = connection(**opts).patch("/repos/#{owner}/#{repo}", body)
+            response = connection(owner: owner, repo: repo, **opts).patch("/repos/#{owner}/#{repo}", body)
+            cache_write("github:repo:#{owner}/#{repo}", response.body) if response.body['id']
             { result: response.body }
           end
 
           def delete_repo(owner:, repo:, **)
-            response = connection(**).delete("/repos/#{owner}/#{repo}")
+            response = connection(owner: owner, repo: repo, **).delete("/repos/#{owner}/#{repo}")
+            cache_invalidate("github:repo:#{owner}/#{repo}") if response.status == 204
             { result: response.status == 204 }
           end
 
           def list_branches(owner:, repo:, per_page: 30, page: 1, **)
-            response = connection(**).get("/repos/#{owner}/#{repo}/branches", per_page: per_page, page: page)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:branches:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/branches", per_page: per_page, page: page).body
+            end }
           end
 
           def list_tags(owner:, repo:, per_page: 30, page: 1, **)
-            response = connection(**).get("/repos/#{owner}/#{repo}/tags", per_page: per_page, page: page)
-            { result: response.body }
+            { result: cached_get("github:repo:#{owner}/#{repo}:tags:#{page}:#{per_page}") do
+              connection(owner: owner, repo: repo, **).get("/repos/#{owner}/#{repo}/tags", per_page: per_page, page: page).body
+            end }
           end
 
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
         end
       end
     end