issue-db 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 779e0ce2c1a8f2e535cc64b2cc16bf40932910840e0732248526c59f61d9581f
-  data.tar.gz: 94a2a6179637d713752cdac2d613417bac05aa9e72cff034eb33319ca769f469
+  metadata.gz: '0889d29fc2e002b9183fef5943de872699603c5b42deeb4f932fefd8b123a76e'
+  data.tar.gz: 8f6857bcc87f3ee10d684182981fc1874480036fe24e4ea695132af58e55576e
 SHA512:
-  metadata.gz: 98d45809be1fc30ddbe0b30df98b0a191bb10d925d6844a550cc8da423bcf39582d676be24c4ff32f3bba29a03800af48d3b8990c2925869e36e90acb01c245a
-  data.tar.gz: c1ac7316e67afb2ecebd66f63bdeefc8d730b95fac4fbd6371e4b1f1fc71f1be10abf9e2207dc05d428121b8ec512f40c98c2bb858ba87b84b91f766e22ab8dc
+  metadata.gz: 445ec2095bde6974d26a473d069fd4307633b2c5732780c4bdc9010b2ac838c104efee1205440ebb59465c9c8cbb54046c4d35f8fea2a280549f4cd90bad4467
+  data.tar.gz: '028a3c2cbd04049f6ca2d6b9c8f16ac22e9a7cc5a0b5e4e66c8b4064548284331d7c09efd0449f65f84b46b78f8400121ad7b43a913025149d8b1030e35849cf'

data/README.md

@@ -7,4 +7,406 @@
 [![release](https://github.com/runwaylab/issue-db/actions/workflows/release.yml/badge.svg)](https://github.com/runwaylab/issue-db/actions/workflows/release.yml)
 [![coverage](./docs/assets/coverage.svg)](./docs/assets/coverage.svg)
 
-A Ruby Gem to use GitHub Issues as a NoSQL JSON document db
+A Ruby Gem to use GitHub Issues as a NoSQL JSON document db.
+
+![issue-db](./docs/assets/issue-db.png)
+
+## Quick Start ⚡
+
+The `issue-db` gem uses CRUD operations to read and write data to a GitHub repository using issues as the records. The title of the issue is used as the unique key for the record and the body of the issue is used to store the data in JSON format.
+
+Here is an extremely basic example of using the `issue-db` gem:
+
+```ruby
+require "issue_db"
+
+# The GitHub repository to use as the database
+repo = "runwaylab/grocery-orders"
+
+# Create a new database instance
+db = IssueDB.new(repo)
+
+# Write a new record to the database
+db.create("order_number_123", { location: "London", items: [ "cookies", "espresso" ] })
+
+# Read the newly created record from the database
+record = db.read("order_number_123")
+
+puts record.data # => {location: "London", items: ["cookies", "espresso"]}
+```
+
+> A more detailed example can be found below.
+
+## Installation 🚚
+
+You may install this Gem from either [RubyGems](https://rubygems.org/gems/issue-db) or [GitHub Packages](https://github.com/runwaylab/issue-db/pkgs/rubygems/issue-db).
+
+RubyGems:
+
+```ruby
+source "https://rubygems.org"
+
+gem "issue-db", "X.X.X" # Replace X.X.X with the version you want to use
+```
+
+GitHub Packages:
+
+```ruby
+source "https://rubygems.pkg.github.com/runwaylab" do
+  gem "issue-db", "X.X.X" # Replace X.X.X with the version you want to use
+end
+```
+
+Command Line Installation:
+
+```sh
+gem install issue-db --version "X.X.X"
+```
+
+## Usage 💻
+
+The following CRUD operations are available for the `issue-db` gem:
+
+> Note: All methods return the `IssueDB::Record` of the object which was involved in the operation
+
+### `db.create(key, data, options = {})`
+
+- `key` (String) - The unique key for the record. This is the title of the GitHub issue. It must be unique within the database.
+- `data` (Hash) - The data to write to the record. This can be any valid JSON data type (String, Number, Boolean, Array, Object, or nil).
+- `options` (Hash) - A hash of options to configure the create operation.
+
+Example:
+
+```ruby
+record = db.create("order_number_123", { location: "London", items: [ "cookies", "espresso" ] })
+
+# with the `body_before` and `body_after` options to add markdown text before and after the data in the GitHub issue body
+# this can be useful if you want to add additional context to the data in the issue body for humans to read
+# more on this in another section of the README below
+options = { body_before: "some markdown text before the data", body_after: "some markdown text after the data" }
+record = db.create("order_number_123", { location: "London", items: [ "cookies", "espresso" ] }, options)
+```
+
+Notes:
+
+- If the key already exists in the database, the `create` method will return the existing record without modifying it.
+
+### `db.read(key, options = {})`
+
+- `key` (String) - The unique key for the record. This is the title of the GitHub issue.
+- `options` (Hash) - A hash of options to configure the read operation.
+
+Example:
+
+```ruby
+record = db.read("order_number_123")
+
+# with the `include_closed` option to include records that have been deleted (i.e. the GitHub issue is closed)
+options = { include_closed: true }
+record = db.read("order_number_123", options)
+```
+
+### `db.update(key, data, options = {})`
+
+- `key` (String) - The unique key for the record. This is the title of the GitHub issue.
+- `data` (Hash) - The data to write to the record. This can be any valid JSON data type (String, Number, Boolean, Array, Object, or nil).
+- `options` (Hash) - A hash of options to configure the update operation.
+
+Example:
+
+```ruby
+record = db.update("order_number_123", { location: "London", items: [ "cookies", "espresso", "chips" ] })
+
+# with the `body_before` and `body_after` options to add markdown text before and after the data in the GitHub issue body
+# this can be useful if you want to add additional context to the data in the issue body for humans to read
+# more on this in another section of the README below
+options = { body_before: "# Order 123\n\nData:", body_after: "Please do not edit the body of this issue" }
+record = db.update("order_number_123", { location: "London", items: [ "cookies", "espresso", "chips" ] }, options)
+```
+
+### `db.delete(key, options = {})`
+
+- `key` (String) - The unique key for the record. This is the title of the GitHub issue.
+- `options` (Hash) - A hash of options to configure the delete operation.
+
+Example:
+
+```ruby
+record = db.delete("order_number_123")
+```
+
+### `db.list_keys(options = {})`
+
+- `options` (Hash) - A hash of options to configure the list operation.
+
+Example:
+
+```ruby
+keys = db.list_keys
+
+# with the `include_closed` option to include records that have been deleted (i.e. the GitHub issue is closed)
+options = { include_closed: true }
+keys = db.list_keys(options)
+```
+
+### `db.list(options = {})`
+
+- `options` (Hash) - A hash of options to configure the list operation.
+
+Example:
+
+```ruby
+records = db.list
+
+# with the `include_closed` option to include records that have been deleted (i.e. the GitHub issue is closed)
+options = { include_closed: true }
+records = db.list(options)
+```
+
+### `db.refresh!`
+
+Force a refresh of the database cache. This will make a request to the GitHub API to get the latest data from the GitHub issues in the repository.
+
+This can be useful if you have made changes to the database outside of the gem and don't want to wait for the cache to refresh. By default, the cache refreshes every 60 seconds. Modified records (such as an `update` operation) will be refreshed automatically into the cache so that subsequent reads will return the updated data. The only time you really need to worry about refreshing the cache is if you have made changes to the database outside of the gem or if there is another service using this gem that is also making changes to the database.
+
+Example:
+
+```ruby
+db.refresh!
+```
+
+## Options 🛠
+
+This section will go into detail around how you can configure the `issue-db` gem to behave:
+
+### Environment Variables 🌍
+
+| Name | Description | Default Value |
+|------|-------------|---------------|
+| `LOG_LEVEL` | The log level to use for the `issue-db` gem. Can be one of `DEBUG`, `INFO`, `WARN`, `ERROR`, or `FATAL` | `INFO` |
+| `ISSUE_DB_LABEL` | The label to use for the issues that are used as records in the database. This value is required and it is what this gem uses to scan a repo for the records it is aware of. | `issue-db` |
+| `ISSUE_DB_CACHE_EXPIRY` | The number of seconds to cache the database in memory. The database is cached in memory to avoid making a request to the GitHub API for every operation. The default value is 60 seconds. | `60` |
+| `ISSUE_DB_SLEEP` | The number of seconds to sleep between requests to the GitHub API in the event of an error | `3` |
+| `ISSUE_DB_RETRIES` | The number of retries to make when there is an error making a request to the GitHub API | `10` |
+| `ISSUE_DB_GITHUB_TOKEN` | The GitHub personal access token to use for authenticating with the GitHub API. You can also use a GitHub app or pass in your own authenticated Octokit.rb instance | `nil` |
+
+## Authentication 🔒
+
+The `issue-db` gem uses the [`Octokit.rb`](https://github.com/octokit/octokit.rb) library under the hood for interactions with the GitHub API. You have three options for authentication when using the `issue-db` gem:
+
+> Note: The order displayed below is also the order of priority that this Gem uses to authenticate.
+
+1. Pass in your own authenticated `Octokit.rb` instance to the `IssueDB.new` method
+2. Use a GitHub App by setting the `ISSUE_DB_GITHUB_APP_ID`, `ISSUE_DB_GITHUB_APP_INSTALLATION_ID`, and `ISSUE_DB_GITHUB_APP_KEY` environment variables
+3. Use a GitHub personal access token by setting the `ISSUE_DB_GITHUB_TOKEN` environment variable
+
+> Using a GitHub App is the suggested method
+
+Here are examples of each of these options:
+
+### Using a GitHub Personal Access Token
+
+```ruby
+# Assuming you have a GitHub personal access token set as the ISSUE_DB_GITHUB_TOKEN env var
+require "issue_db"
+
+db = IssueDB.new("<org>/<repo>") # THAT'S IT! 🎉
+```
+
+### Using a GitHub App
+
+This is the single best way to use the `issue-db` gem because GitHub Apps have increased rate limits, fine-grained permissions, and are more secure than using a personal access token. All you have to do is provide three environment variables and the `issue-db` gem will take care of the rest:
+
+- `ISSUE_DB_GITHUB_APP_ID`
+- `ISSUE_DB_GITHUB_APP_INSTALLATION_ID`
+- `ISSUE_DB_GITHUB_APP_KEY`
+
+Here is an example of how you can use a GitHub app with the `issue-db` gem:
+
+```ruby
+# Assuming you have the following three environment variables set:
+
+# 1: ISSUE_DB_GITHUB_APP_ID
+# app ids are found on the App's settings page
+
+# 2: ISSUE_DB_GITHUB_APP_INSTALLATION_ID
+# installation ids look like this:
+# https://github.com/organizations/<org>/settings/installations/<8_digit_id>
+
+# 3. ISSUE_DB_GITHUB_APP_KEY
+# app keys are found on the App's settings page and can be downloaded
+# format: "-----BEGIN...key\n...END-----\n" (this will be one super long string and that's okay)
+# make sure this key in your env is a single line string with newlines as "\n"
+
+# With all three of these environment variables set, you can proceed with ease!
+db = IssueDB.new("<org>/<repo>") # THAT'S IT! 🎉
+```
+
+### Using Your Own Authenticated `Octokit.rb` Instance
+
+```ruby
+require "octokit"
+
+# Create your own authenticated Octokit.rb instance
+# You should probably set the page_size to 100 and auto_paginate to true
+octokit = Octokit::Client.new(access_token: "<TOKEN>", page_size: 100)
+octokit.auto_paginate = true
+
+db = IssueDB.new("<org>/<repo>", octokit_client: octokit)
+```
+
+## Advanced Example 🚀
+
+Here is a more advanced example of using the `issue-db` gem that demonstrates many different features of the gem:
+
+```ruby
+# Assuming you have a GitHub personal access token set as the ISSUE_DB_GITHUB_TOKEN env var
+require "issue_db"
+
+# The GitHub repository to use as the database
+repo = "runwaylab/grocery-orders"
+
+# Create a new database instance
+db = IssueDB.new(repo)
+
+# Write a new record to the database where the title of the issue is the unique key
+new_issue = db.create("order_number_123", { location: "London", items: [ "cookies", "espresso" ] })
+
+# View the record data and the source data which contains the GitHub issue object
+puts new_issue.data # => {location: "London", items: ["cookies", "espresso"]}
+puts new_issue.source_data.state # => "open" (the GitHub issue is open so the record is active)
+puts new_issue.source_data.html_url # => "https://github.com/runwaylab/grocery-orders/issues/<number>" (the URL of the GitHub issue which is the DB record)
+
+# Update the record
+updated_issue = db.update("order_number_123", { location: "London", items: [ "cookies", "espresso", "chips" ] })
+
+# View the updated record data
+puts updated_issue.data # => {location: "London", items: ["cookies", "espresso", "chips"]}
+
+# Get the record by key
+record = db.read("order_number_123")
+
+# View the record data
+puts record.data # => {location: "London", items: ["cookies", "espresso", "chips"]}
+
+# Delete the record
+deleted_record = db.delete("order_number_123")
+puts deleted_record.source_data.state # => "closed" (the GitHub issue is closed as "completed" so the record is inactive)
+
+# List all keys in the database including closed records
+keys = db.list_keys({ include_closed: true })
+
+puts keys # => ["order_number_123"]
+
+# List all records in the database including closed records
+records = db.list({ include_closed: true })
+
+# Inspection of the first record in the list
+puts records.first.data # => {location: "London", items: ["cookies", "espresso", "chips"]}
+puts records.first.source_data.state # => "closed" (the GitHub issue is closed as "completed" so the record is inactive)
+
+# Force a refresh of the database cache (useful if you have made changes to the database outside of the gem and don't want to wait for the cache to refresh)
+db.refresh!
+```
+
+## Embedding Markdown in the Issue Body 📝
+
+With this library, you can write markdown text into the issue body **in addition** to the JSON data. Pretty cool right?
+
+This can be especially useful if you want to add additional context to the data in the issue body for humans to read. For example, you want to open an issue to track the status of an employee who has a laptop that is running an out of date operating system. You might want to do a `db.write()` operation with machine readable data but _also_ include a note for the employee to read. Here is an example of how you can do that:
+
+```ruby
+body_before_text = <<~BODY
+# Out of Date Operating System 🚨
+
+<!--- HUMANS: DO NOT EDIT THIS ISSUE BODY ;) -->
+
+It looks like your laptop is running an out of date operating system. This is a security risk.
+
+Please update your OS as soon as possible.
+
+## Details
+BODY
+
+body_after_text = <<~BODY
+> Thank you for your attention to this matter.
+BODY
+
+options = { body_before: body_before_text, body_after: body_after_text }
+data = { operating_system: "macOS 1.2.3", last_updated_at: "2024-09-30", user: "Celeste", location: "California", out_of_date: true, employee_id: 123 }
+record = db.create("Out of Date OS - EmployeeID: 123", data, options) # this assumes that employee IDs are unique in this example
+```
+
+Running that code snippet will result in a database record (GitHub issue) being created that has the following markdown body:
+
+````markdown
+# Out of Date Operating System 🚨
+
+<!--- HUMANS: DO NOT EDIT THIS ISSUE BODY ;) -->
+
+It looks like your laptop is running an out of date operating system. This is a security risk.
+
+Please update your OS as soon as possible.
+
+## Details
+
+<!--- issue-db-start -->
+```json
+{
+  "operating_system": "macOS 1.2.3",
+  "last_updated_at": "2024-09-30",
+  "user": "Celeste",
+  "location": "California",
+  "out_of_date": true
+}
+```
+<!--- issue-db-end -->
+
+> Thank you for your attention to this matter.
+````
+
+Here is a screenshot of exactly how this issue would render in GitHub:
+
+![example1](./docs/assets/example1.png)
+
+And here is a link to the actual issue in GitHub: [issue link](https://github.com/runwaylab/issue-db/issues/19)
+
+Now the best part about this, is that we can still use the `db.read()` method flawlessly and get the data back in a machine readable format, and we can even get back the markdown text as well! Here is an example of how you can do that:
+
+```ruby
+record = db.read("Out of Date OS - EmployeeID: 123")
+
+puts record.data # => {"operating_system"=>"macOS 1.2.3", "last_updated_at"=>"2024-09-30", "user"=>"Celeste", "location"=>"California", "out_of_date"=>true, "employee_id"=>123}
+puts record.body_before # the markdown text before the data in the issue body (as seen above, not going to repeat it here - its long)
+puts record.body_after # ditto ^
+# puts record.source_data.body # useful for getting the raw markdown text of the issue body as is
+```
+
+Here is a screenshot of the output of the script above:
+
+![example2](./docs/assets/example2.png)
+
+## Record Attributes 📦
+
+Database "items" are called Records in this library. Records are represented by a `IssueDB::Record` object. Records are actually just GitHub issues under the hood!
+
+Records have the following attributes:
+
+- `key` (String) - The unique key for the record. This is the title of the GitHub issue.
+- `data` (Hash) - The data for the record. This can be any valid JSON data type (String, Number, Boolean, Array, Object, or nil).
+- `source_data` (Octokit::Issue) - The GitHub issue object that is the source of the record. This value is returned by Octokit and is a Sawyer::Resource object.
+- `body_before` (String) - The markdown text before the data in the issue body.
+- `body_after` (String) - The markdown text after the data in the issue body.
+
+Example:
+
+```ruby
+record = db.read("order_number_123")
+
+puts record.key # => "order_number_123"
+puts record.data # => { "location"=>"London", "items"=>[ "cookies", "espresso", "chips" ] }
+puts record.data["location"] # => "London"
+puts record.source_data.state # => "open" (the GitHub issue is open so the record is active)
+puts record.body_before # => "some markdown text before the data"
+puts record.body_after # => "some markdown text after the data"
+```

data/issue-db.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "retryable", "~> 3.0", ">= 3.0.5"
   spec.add_dependency "octokit", "~> 9.2"
   spec.add_dependency "faraday-retry", "~> 2.2", ">= 2.2.1"
+  spec.add_dependency "jwt", "~> 2.9", ">= 2.9.3"
 
   spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 

data/lib/issue_db/authentication.rb

@@ -1,20 +1,30 @@
 # frozen_string_literal: true
 
 require "octokit"
+require_relative "utils/github_app"
 
 class AuthenticationError < StandardError; end
 
 module Authentication
-  def self.login(client = nil)
+  def self.login(client = nil, log = nil)
     # if the client is not nil, use the pre-provided client
-    return client unless client.nil?
+    unless client.nil?
+      log.debug("using pre-provided client") if log
+      return client
+    end
 
-    # if the client is nil, check for GitHub App env vars
-    # TODO
+    # if the client is nil, check for GitHub App env vars first
+    # first, check if all three of the following env vars are set and have values
+    # ISSUE_DB_GITHUB_APP_ID, ISSUE_DB_GITHUB_APP_INSTALLATION_ID, ISSUE_DB_GITHUB_APP_KEY
+    if ENV.fetch("ISSUE_DB_GITHUB_APP_ID", nil) && ENV.fetch("ISSUE_DB_GITHUB_APP_INSTALLATION_ID", nil) && ENV.fetch("ISSUE_DB_GITHUB_APP_KEY", nil)
+      log.debug("using github app authentication") if log
+      return GitHubApp.new
+    end
 
-    # if the client is nil and no GitHub App env vars were found, check for the GITHUB_TOKEN
-    token = ENV.fetch("GITHUB_TOKEN", nil)
+    # if the client is nil and no GitHub App env vars were found, check for the ISSUE_DB_GITHUB_TOKEN
+    token = ENV.fetch("ISSUE_DB_GITHUB_TOKEN", nil)
     if token
+      log.debug("using github token authentication") if log
       octokit = Octokit::Client.new(access_token: token, page_size: 100)
       octokit.auto_paginate = true
       return octokit

data/lib/issue_db/models/record.rb

@@ -7,8 +7,9 @@ class IssueParseError < StandardError; end
 class Record
   include Parse
 
-  attr_reader :body_before, :data, :body_after, :source_data
+  attr_reader :body_before, :data, :body_after, :source_data, :key
   def initialize(data)
+    @key = data.title
     @source_data = data
     parse!
   end

data/lib/issue_db/utils/github_app.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# This class provides a wrapper around the Octokit client for GitHub App authentication.
+# It handles token generation and refreshing, and delegates method calls to the Octokit client.
+# Helpful: https://github.com/octokit/handbook?tab=readme-ov-file#github-app-authentication-json-web-token
+
+# Why? In some cases, you may not want to have a static long lived token like a GitHub PAT when authenticating...
+# with octokit.rb.
+# Most importantly, this class will handle automatic token refreshing for you out-of-the-box. Simply provide the...
+# correct environment variables, call `GitHubApp.new`, and then use the returned object as you would an Octokit client.
+
+require "octokit"
+require "jwt"
+
+class GitHubApp
+  TOKEN_EXPIRATION_TIME = 2700 # 45 minutes
+  JWT_EXPIRATION_TIME = 600 # 10 minutes
+
+  def initialize
+    # app ids are found on the App's settings page
+    @app_id = fetch_env_var("ISSUE_DB_GITHUB_APP_ID").to_i
+
+    # installation ids look like this:
+    # https://github.com/organizations/<org>/settings/installations/<8_digit_id>
+    @installation_id = fetch_env_var("ISSUE_DB_GITHUB_APP_INSTALLATION_ID").to_i
+
+    # app keys are found on the App's settings page and can be downloaded
+    # format: "-----BEGIN...key\n...END-----\n"
+    # make sure this key in your env is a single line string with newlines as "\n"
+    @app_key = fetch_env_var("ISSUE_DB_GITHUB_APP_KEY").gsub(/\\+n/, "\n")
+
+    @client = nil
+    @token_refresh_time = nil
+  end
+
+  private
+
+  # Fetches the value of an environment variable and raises an error if it is not set.
+  # @param key [String] The name of the environment variable.
+  # @return [String] The value of the environment variable.
+  def fetch_env_var(key)
+    ENV.fetch(key) { raise "environment variable #{key} is not set" }
+  end
+
+  # Caches the octokit client if it is not nil and the token has not expired
+  # If it is nil or the token has expired, it creates a new client
+  # @return [Octokit::Client] The octokit client
+  def client
+    if @client.nil? || token_expired?
+      @client = create_client
+    end
+
+    @client
+  end
+
+  # A helper method for generating a JWT token for the GitHub App
+  # @return [String] The JWT token
+  def jwt_token
+    private_key = OpenSSL::PKey::RSA.new(@app_key)
+
+    payload = {}.tap do |opts|
+      opts[:iat] = Time.now.to_i - 60 # issued at time, 60 seconds in the past to allow for clock drift
+      opts[:exp] = opts[:iat] + JWT_EXPIRATION_TIME # JWT expiration time (10 minute maximum)
+      opts[:iss] = @app_id # GitHub App ID
+    end
+
+    JWT.encode(payload, private_key, "RS256")
+  end
+
+  # Creates a new octokit client and fetches a new installation access token
+  # @return [Octokit::Client] The octokit client
+  def create_client
+    client = ::Octokit::Client.new(bearer_token: jwt_token)
+    access_token = client.create_app_installation_access_token(@installation_id)[:token]
+    client = ::Octokit::Client.new(access_token:)
+    client.auto_paginate = true
+    client.per_page = 100
+    @token_refresh_time = Time.now
+    client
+  end
+
+  # GitHub App installation access tokens expire after 1h
+  # This method checks if the token has expired and returns true if it has
+  # It is very cautious and expires tokens at 45 minutes to account for clock drift
+  # @return [Boolean] True if the token has expired, false otherwise
+  def token_expired?
+    @token_refresh_time.nil? || (Time.now - @token_refresh_time) > TOKEN_EXPIRATION_TIME
+  end
+
+  # This method is called when a method is called on the GitHub class that does not exist.
+  # It delegates the method call to the Octokit client.
+  # @param method [Symbol] The name of the method being called.
+  # @param args [Array] The arguments passed to the method.
+  # @param block [Proc] An optional block passed to the method.
+  # @return [Object] The result of the method call on the Octokit client.
+  def method_missing(method, *args, &block)
+    client.send(method, *args, &block)
+  end
+
+  # This method is called to check if the GitHub class responds to a method.
+  # It checks if the Octokit client responds to the method.
+  # @param method [Symbol] The name of the method being checked.
+  # @param include_private [Boolean] Whether to include private methods in the check.
+  # @return [Boolean] True if the Octokit client responds to the method, false otherwise.
+  def respond_to_missing?(method, include_private = false)
+    client.respond_to?(method, include_private) || super
+  end
+end

data/lib/issue_db.rb

@@ -29,7 +29,7 @@ class IssueDB
     @log = log || RedactingLogger.new($stdout, level: ENV.fetch("LOG_LEVEL", "INFO").upcase)
     Retry.setup!(log: @log)
     @version = VERSION
-    @client = Authentication.login(octokit_client)
+    @client = Authentication.login(octokit_client, @log)
     @repo = Repository.new(repo)
     @label = label || ENV.fetch("ISSUE_DB_LABEL", "issue-db")
     @cache_expiry = cache_expiry || ENV.fetch("ISSUE_DB_CACHE_EXPIRY", 60).to_i
@@ -41,7 +41,7 @@ class IssueDB
   end
 
   def read(key, options = {})
-    db.read(key)
+    db.read(key, options)
   end
 
   def update(key, data, options = {})

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Version
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: issue-db
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - runwaylab
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-28 00:00:00.000000000 Z
+date: 2024-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redacting-logger
@@ -79,6 +79,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.2.1
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.9.3
 description: 'A Ruby Gem to use GitHub Issues as a NoSQL JSON document db
 
   '
@@ -97,6 +117,7 @@ files:
 - lib/issue_db/models/record.rb
 - lib/issue_db/models/repository.rb
 - lib/issue_db/utils/generate.rb
+- lib/issue_db/utils/github_app.rb
 - lib/issue_db/utils/init.rb
 - lib/issue_db/utils/parse.rb
 - lib/issue_db/utils/retry.rb