bundleup-sdk 0.1.0 → 0.2.0

data/lib/bundleup/client.rb

@@ -1,71 +1,42 @@
 # frozen_string_literal: true
 
 module Bundleup
-  # Main client class for interacting with the BundleUp API
+  # Client for core BundleUp API resources.
   class Client
     attr_reader :api_key
 
-    # Initialize a new BundleUp client
-    #
-    # @param api_key [String] Your BundleUp API key
-    # @raise [ArgumentError] if api_key is nil or empty
     def initialize(api_key)
-      raise ArgumentError, 'API key is required to initialize BundleUp SDK.' if api_key.nil? || api_key.to_s.empty?
+      raise ArgumentError, 'API key is required to initialize BundleUp SDK.' if api_key.nil? || api_key.empty?
 
       @api_key = api_key
     end
 
-    # Access the Connections resource
-    #
-    # @return [Bundleup::Connection] Connection resource instance
     def connections
-      @connections ||= Bundleup::Connection.new(@api_key)
+      @connections ||= Bundleup::Resources::Connection.new(@api_key)
     end
 
-    # Access the Integrations resource
-    #
-    # @return [Bundleup::Integration] Integration resource instance
     def integrations
-      @integrations ||= Bundleup::Integration.new(@api_key)
+      @integrations ||= Bundleup::Resources::Integration.new(@api_key)
     end
 
-    # Access the Webhooks resource
-    #
-    # @return [Bundleup::Webhook] Webhook resource instance
     def webhooks
-      @webhooks ||= Bundleup::Webhook.new(@api_key)
+      @webhooks ||= Bundleup::Resources::Webhook.new(@api_key)
     end
 
-    # Create a Proxy instance for a specific connection
-    #
-    # @param connection_id [String] The connection ID
-    # @return [Bundleup::Proxy] Proxy instance
-    # @raise [ArgumentError] if connection_id is nil or empty
     def proxy(connection_id)
-      if connection_id.nil? || connection_id.to_s.empty?
-        raise ArgumentError,
-              'Connection ID is required to create a Proxy instance.'
+      if connection_id.nil? || connection_id.empty?
+        raise ArgumentError, 'Connection ID is required to create a Proxy instance.'
       end
 
       Bundleup::Proxy.new(@api_key, connection_id)
     end
 
-    # Create Unify instances for a specific connection
-    #
-    # @param connection_id [String] The connection ID
-    # @return [Hash] Hash with :chat, :git, and :pm Unify instances
-    # @raise [ArgumentError] if connection_id is nil or empty
     def unify(connection_id)
-      if connection_id.nil? || connection_id.to_s.empty?
-        raise ArgumentError,
-              'Connection ID is required to create a Unify instance.'
+      if connection_id.nil? || connection_id.empty?
+        raise ArgumentError, 'Connection ID is required to create a Unify instance.'
       end
 
-      {
-        chat: Bundleup::Unify::Chat.new(@api_key, connection_id),
-        git: Bundleup::Unify::Git.new(@api_key, connection_id),
-        pm: Bundleup::Unify::PM.new(@api_key, connection_id)
-      }
+      Bundleup::Unify::Client.new(@api_key, connection_id)
     end
   end
 end

data/lib/bundleup/proxy.rb

@@ -1,115 +1,73 @@
 # frozen_string_literal: true
 
 module Bundleup
-  # Proxy class for making direct calls to integration APIs
+  # Client for proxy API requests.
   class Proxy
     BASE_URL = 'https://proxy.bundleup.io'
 
     attr_reader :api_key, :connection_id
 
-    # Initialize a new Proxy instance
-    #
-    # @param api_key [String] Your BundleUp API key
-    # @param connection_id [String] The connection ID
     def initialize(api_key, connection_id)
       @api_key = api_key
       @connection_id = connection_id
     end
 
-    # Make a GET request
-    #
-    # @param path [String] The request path
-    # @param params [Hash] Query parameters
-    # @return [Hash] Response data
-    def get(path, params = {})
-      request(:get, path, params)
-    end
+    def get(path, headers: {})
+      raise ArgumentError, 'Path is required for GET request' unless path
 
-    # Make a POST request
-    #
-    # @param path [String] The request path
-    # @param body [Hash] Request body
-    # @return [Hash] Response data
-    def post(path, body = {})
-      request(:post, path, body)
+      # Merge any additional headers
+      request_headers = connection.headers.merge(headers)
+      connection.get(path, nil, request_headers)
     end
 
-    # Make a PUT request
-    #
-    # @param path [String] The request path
-    # @param body [Hash] Request body
-    # @return [Hash] Response data
-    def put(path, body = {})
-      request(:put, path, body)
-    end
+    def post(path, body: {}, headers: {})
+      raise ArgumentError, 'Path is required for POST request' unless path
 
-    # Make a PATCH request
-    #
-    # @param path [String] The request path
-    # @param body [Hash] Request body
-    # @return [Hash] Response data
-    def patch(path, body = {})
-      request(:patch, path, body)
+      # Merge any additional headers
+      request_headers = connection.headers.merge(headers)
+      connection.post(path, body.to_json, request_headers)
     end
 
-    # Make a DELETE request
-    #
-    # @param path [String] The request path
-    # @param params [Hash] Query parameters
-    # @return [Hash] Response data
-    def delete(path, params = {})
-      request(:delete, path, params)
+    def put(path, body: {}, headers: {})
+      raise ArgumentError, 'Path is required for PUT request' unless path
+
+      # Merge any additional headers
+      request_headers = connection.headers.merge(headers)
+      connection.put(path, body.to_json, request_headers)
     end
 
-    private
+    def patch(path, body: {}, headers: {})
+      raise ArgumentError, 'Path is required for PATCH request' unless path
 
-    def request(method, path, body = nil)
-      response = connection.public_send(method) do |req|
-        req.url path
-        req.headers['Content-Type'] = 'application/json'
-        req.headers['Authorization'] = "Bearer #{api_key}"
-        req.headers['BU-Connection-Id'] = connection_id
-
-        if body && %i[post patch put].include?(method)
-          req.body = body.to_json
-        elsif body && method == :get
-          req.params.update(body)
-        end
-      end
+      # Merge any additional headers
+      request_headers = connection.headers.merge(headers)
+      connection.patch(path, body.to_json, request_headers)
+    end
+
+    def delete(path, headers: {})
+      raise ArgumentError, 'Path is required for DELETE request' unless path
 
-      handle_response(response)
-    rescue Faraday::Error => e
-      raise APIError, "Proxy request failed: #{e.message}"
+      # Merge any additional headers
+      request_headers = connection.headers.merge(headers)
+      connection.delete(path, nil, request_headers)
     end
 
+    private
+
+    # Memoize the Faraday connection to reuse it across requests
     def connection
-      @connection ||= Faraday.new(url: BASE_URL) do |conn|
-        conn.request :retry, max: 3, interval: 0.5, backoff_factor: 2
-        conn.adapter Faraday.default_adapter
-      end
-    end
+      @connection ||= Faraday.new(url: BASE_URL) do |faraday|
+        faraday.headers = {
+          'Authorization' => "Bearer #{@api_key}",
+          'Content-Type' => 'application/json',
+          'BU-Connection-Id' => @connection_id
+        }
 
-    def handle_response(response)
-      case response.status
-      when 200..299
-        response.body.empty? ? {} : JSON.parse(response.body)
-      when 401
-        raise AuthenticationError, 'Invalid API key'
-      when 400..499
-        error_message = extract_error_message(response)
-        raise InvalidRequestError, error_message
-      when 500..599
-        raise APIError, 'Server error occurred'
-      else
-        raise APIError, "Unexpected response status: #{response.status}"
+        faraday.request :json
+        faraday.response :json, content_type: /\bjson$/
+        faraday.response :raise_error
+        faraday.adapter Faraday.default_adapter
       end
     end
-
-    def extract_error_message(response)
-      body = JSON.parse(response.body)
-      body['error'] || body['message'] || "Request failed with status #{response.status}"
-    rescue JSON::ParserError
-      "Request failed with status #{response.status}"
-    end
   end
 end

data/lib/bundleup/resources/base.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Bundleup
+  module Resources
+    # Base class for API resources.
+    class Base
+      BASE_URL = 'https://api.bundleup.io'
+      API_VERSION = 'v1'
+
+      def initialize(api_key)
+        @api_key = api_key
+      end
+
+      protected
+
+      def list(params: {})
+        response = connection.get(resource_name, params)
+
+        raise "Failed to fetch #{resource_name}: #{response.status}: #{response.body}" unless response.success?
+
+        response.body
+      end
+
+      def create(body: {})
+        response = connection.post(resource_name, body.to_json)
+
+        raise "Failed to create #{resource_name}: #{response.status}" unless response.success?
+
+        response.body
+      end
+
+      def retrieve(id)
+        response = connection.get("#{resource_name}/#{id}")
+
+        raise "Failed to retrieve #{resource_name}: #{response.status}" unless response.success?
+
+        response.body
+      end
+
+      def update(id, body: {})
+        response = connection.put("#{resource_name}/#{id}", body.to_json)
+
+        raise "Failed to update #{resource_name}: #{response.status}" unless response.success?
+
+        response.body
+      end
+
+      def delete(id)
+        response = connection.delete("#{resource_name}/#{id}")
+
+        raise "Failed to delete #{resource_name}: #{response.status}" unless response.success?
+
+        nil
+      end
+
+      private
+
+      # Memoize the Faraday connection to reuse it across requests
+      def connection
+        @connection ||= Faraday.new(url: "#{BASE_URL}/#{API_VERSION}/") do |faraday|
+          faraday.headers = {
+            'Authorization' => "Bearer #{@api_key}",
+            'Content-Type' => 'application/json'
+          }
+
+          faraday.request :json
+          faraday.response :json, content_type: /\bjson$/
+          faraday.response :raise_error
+          faraday.adapter Faraday.default_adapter
+        end
+      end
+
+      def resource_name
+        raise NotImplementedError, 'Subclasses must implement the resource_name method'
+      end
+    end
+  end
+end

data/lib/bundleup/resources/connection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Bundleup
+  module Resources
+    # Client for connection API endpoints.
+    class Connection < Base
+      public :list, :retrieve, :delete
+
+      private
+
+      def resource_name
+        'connections'
+      end
+    end
+  end
+end

data/lib/bundleup/resources/integration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Bundleup
+  module Resources
+    # Client for integration API endpoints.
+    class Integration < Base
+      public :list, :retrieve
+
+      private
+
+      def resource_name
+        'integrations'
+      end
+    end
+  end
+end

data/lib/bundleup/resources/webhook.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Bundleup
+  module Resources
+    # Client for webhook API endpoints.
+    class Webhook < Base
+      public :list, :retrieve, :create, :update, :delete
+
+      private
+
+      def resource_name
+        'webhooks'
+      end
+    end
+  end
+end

data/lib/bundleup/unify/base.rb

@@ -2,17 +2,13 @@
 
 module Bundleup
   module Unify
-    # Base class for all Unify resources
+    # Base class for Unify API clients.
     class Base
       BASE_URL = 'https://unify.bundleup.io'
       API_VERSION = 'v1'
 
       attr_reader :api_key, :connection_id
 
-      # Initialize a new Unify resource
-      #
-      # @param api_key [String] Your BundleUp API key
-      # @param connection_id [String] The connection ID
       def initialize(api_key, connection_id)
         @api_key = api_key
         @connection_id = connection_id
@@ -20,55 +16,21 @@ module Bundleup
 
       private
 
-      def request(method, path, params = {}, include_raw: false)
-        response = connection.public_send(method) do |req|
-          req.url path
-          req.headers['Content-Type'] = 'application/json'
-          req.headers['Authorization'] = "Bearer #{api_key}"
-          req.headers['BU-Connection-Id'] = connection_id
-          req.headers['BU-Include-Raw'] = include_raw.to_s
-
-          if params && %i[post patch put].include?(method)
-            req.body = params.to_json
-          elsif params && method == :get
-            req.params.update(params)
-          end
-        end
-
-        handle_response(response)
-      rescue Faraday::Error => e
-        raise APIError, "Unify request failed: #{e.message}"
-      end
-
+      # Memoize the Faraday connection to reuse it across requests
       def connection
-        @connection ||= Faraday.new(url: BASE_URL) do |conn|
-          conn.request :retry, max: 3, interval: 0.5, backoff_factor: 2
-          conn.adapter Faraday.default_adapter
+        @connection ||= Faraday.new(url: "#{BASE_URL}/#{API_VERSION}/") do |faraday|
+          faraday.headers = {
+            'Authorization' => "Bearer #{@api_key}",
+            'Content-Type' => 'application/json',
+            'BU-Connection-Id' => @connection_id
+          }
+
+          faraday.request :json
+          faraday.response :json, content_type: /\bjson$/
+          faraday.response :raise_error
+          faraday.adapter Faraday.default_adapter
         end
       end
-
-      def handle_response(response)
-        case response.status
-        when 200..299
-          response.body.empty? ? {} : JSON.parse(response.body)
-        when 401
-          raise AuthenticationError, 'Invalid API key'
-        when 400..499
-          error_message = extract_error_message(response)
-          raise InvalidRequestError, error_message
-        when 500..599
-          raise APIError, 'Server error occurred'
-        else
-          raise APIError, "Unexpected response status: #{response.status}"
-        end
-      end
-
-      def extract_error_message(response)
-        body = JSON.parse(response.body)
-        body['error'] || body['message'] || "Request failed with status #{response.status}"
-      rescue JSON::ParserError
-        "Request failed with status #{response.status}"
-      end
     end
   end
 end

data/lib/bundleup/unify/chat.rb

@@ -2,18 +2,17 @@
 
 module Bundleup
   module Unify
-    # Chat resource for unified chat operations
+    # Client for chat-related Unify endpoints.
     class Chat < Base
-      # List channels
-      #
-      # @param params [Hash] Query parameters
-      # @option params [Integer] :limit Number of results to return
-      # @option params [String] :cursor Pagination cursor
-      # @option params [Boolean] :include_raw Include raw response from the integration
-      # @return [Hash] Channels data with pagination info
+      # Fetches channels from the connected chat provider.
       def channels(params = {})
-        include_raw = params.delete(:include_raw) || false
-        request(:get, "/#{API_VERSION}/chat/channels", params, include_raw: include_raw)
+        response = connection.get('chat/channels') do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch chat/channels: #{response.status}" unless response.success?
+
+        response.body
       end
     end
   end

data/lib/bundleup/unify/git.rb

@@ -2,60 +2,56 @@
 
 module Bundleup
   module Unify
-    # Git resource for unified git operations
+    # Client for Git Unify endpoints.
     class Git < Base
-      # List repositories
-      #
-      # @param params [Hash] Query parameters
-      # @option params [Integer] :limit Number of results to return
-      # @option params [String] :cursor Pagination cursor
-      # @option params [Boolean] :include_raw Include raw response from the integration
-      # @return [Hash] Repositories data with pagination info
+      # Fetches repositories from the connected Git provider.
       def repos(params = {})
-        include_raw = params.delete(:include_raw) || false
-        request(:get, "/#{API_VERSION}/git/repos", params, include_raw: include_raw)
+        response = connection.get('git/repos') do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch git/repos: #{response.status}" unless response.success?
+
+        response.body
       end
 
-      # List pull requests
-      #
-      # @param repo_name [String] Repository name
-      # @param params [Hash] Query parameters
-      # @option params [Integer] :limit Number of results to return
-      # @option params [String] :cursor Pagination cursor
-      # @option params [Boolean] :include_raw Include raw response from the integration
-      # @return [Hash] Pull requests data with pagination info
+      # Fetches pull requests for a specific repository from the connected Git provider.
       def pulls(repo_name, params = {})
-        include_raw = params.delete(:include_raw) || false
-        params[:repo_name] = repo_name
-        request(:get, "/#{API_VERSION}/git/pulls", params, include_raw: include_raw)
+        encoded_repo_name = URI.encode_www_form_component(repo_name)
+
+        response = connection.get("git/repos/#{encoded_repo_name}/pulls") do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch git/repos/#{encoded_repo_name}/pulls: #{response.status}" unless response.success?
+
+        response.body
       end
 
-      # List tags
-      #
-      # @param repo_name [String] Repository name
-      # @param params [Hash] Query parameters
-      # @option params [Integer] :limit Number of results to return
-      # @option params [String] :cursor Pagination cursor
-      # @option params [Boolean] :include_raw Include raw response from the integration
-      # @return [Hash] Tags data with pagination info
+      # Fetches tags for a specific repository from the connected Git provider.
       def tags(repo_name, params = {})
-        include_raw = params.delete(:include_raw) || false
-        params[:repo_name] = repo_name
-        request(:get, "/#{API_VERSION}/git/tags", params, include_raw: include_raw)
+        encoded_repo_name = URI.encode_www_form_component(repo_name)
+
+        response = connection.get("git/repos/#{encoded_repo_name}/tags") do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch git/repos/#{encoded_repo_name}/tags: #{response.status}" unless response.success?
+
+        response.body
       end
 
-      # List releases
-      #
-      # @param repo_name [String] Repository name
-      # @param params [Hash] Query parameters
-      # @option params [Integer] :limit Number of results to return
-      # @option params [String] :cursor Pagination cursor
-      # @option params [Boolean] :include_raw Include raw response from the integration
-      # @return [Hash] Releases data with pagination info
+      # Fetches releases for a specific repository from the connected Git provider.
       def releases(repo_name, params = {})
-        include_raw = params.delete(:include_raw) || false
-        params[:repo_name] = repo_name
-        request(:get, "/#{API_VERSION}/git/releases", params, include_raw: include_raw)
+        encoded_repo_name = URI.encode_www_form_component(repo_name)
+
+        response = connection.get("git/repos/#{encoded_repo_name}/releases") do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch git/repos/#{encoded_repo_name}/releases: #{response.status}" unless response.success?
+
+        response.body
       end
     end
   end

data/lib/bundleup/unify/pm.rb

@@ -2,18 +2,17 @@
 
 module Bundleup
   module Unify
-    # PM (Project Management) resource for unified project management operations
+    # Client for project management Unify endpoints.
     class PM < Base
-      # List issues
-      #
-      # @param params [Hash] Query parameters
-      # @option params [Integer] :limit Number of results to return
-      # @option params [String] :cursor Pagination cursor
-      # @option params [Boolean] :include_raw Include raw response from the integration
-      # @return [Hash] Issues data with pagination info
+      # Fetches issues from the connected project management tool.
       def issues(params = {})
-        include_raw = params.delete(:include_raw) || false
-        request(:get, "/#{API_VERSION}/pm/issues", params, include_raw: include_raw)
+        response = connection.get('pm/issues') do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch pm/issues: #{response.status}" unless response.success?
+
+        response.body
       end
     end
   end

data/lib/bundleup/unify.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Bundleup
+  module Unify
+    # Client for Unify API endpoints.
+    class Client
+      attr_reader :api_key, :connection_id
+
+      def initialize(api_key, connection_id)
+        @pm = Bundleup::Unify::PM.new(api_key, connection_id)
+        @chat = Bundleup::Unify::Chat.new(api_key, connection_id)
+        @git = Bundleup::Unify::Git.new(api_key, connection_id)
+      end
+    end
+  end
+end

data/lib/bundleup/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bundleup
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end