Refactor API classes and errors (#29)

* Update base api class name

* Cleanup API errors

.reek.yml

@@ -5,22 +5,18 @@ detectors:
   TooManyStatements:
     exclude:
       - 'Anthropic::Api::Concerns::Validatable#schema'
-      - 'Anthropic::BaseApi#beta_config'
-      - 'Anthropic::BaseApi#version_config'
+      - 'Anthropic::Api::Base#beta_config'
+      - 'Anthropic::Api::Base#version_config'
       - 'Anthropic::Bootstrapper#self.load_betas'
       - 'Anthropic::Bootstrapper#self.load_versions'
       - 'Anthropic::Client::Standard#self.post'
       - 'Anthropic::Client::Streaming#self.post'
-  BooleanParameter:
-    exclude:
-      - 'Anthropic::Messages#initialize'
   DuplicateMethodCall:
     exclude:
-      - 'Anthropic::BaseApi#version_config'
-      - 'Anthropic::Messages#create'
+      - 'Anthropic::Api::Base#version_config'
   InstanceVariableAssumption:
     exclude:
-      - 'Anthropic::BaseApi'
+      - 'Anthropic::Api::Base'
   NestedIterators:
     exclude:
       - 'Anthropic::Bootstrapper#self.load_versions'

lib/anthropic/api/base.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'concerns/requestable'
+require_relative 'concerns/validatable'
+
+module Anthropic
+  module Api
+    # Error for when a beta feature is configured incorrectly.
+    class InvalidBetaConfigurationError < StandardError; end
+
+    # Error for when API version is missing a schema.
+    class MissingSchemaError < StandardError; end
+
+    # Error for when the provided params do not match the API schema
+    class SchemaValidationError < StandardError; end
+
+    # Error for when the API version is not supported.
+    class UnsupportedApiVersionError < StandardError; end
+
+    # Error for when a beta feature is not used correctly.
+    class UnsupportedBetaUseError < StandardError; end
+
+    # Error for when the provided beta is not supported.
+    class UnsupportedBetaError < StandardError; end
+
+    ##
+    # Provides a base class for APIs
+    class Base
+      include Anthropic::Api::Concerns::Requestable
+      include Anthropic::Api::Concerns::Validatable
+
+      def initialize(beta: nil)
+        @beta = beta
+      end
+
+      private
+
+      attr_reader :beta
+
+      def api
+        self.class.name.split('::').last.downcase
+      end
+
+      def version_config
+        return @version_config if defined?(@version_config)
+
+        @version_config ||= catch(:version_found) do
+          found_config = Anthropic.versions[api.to_sym].find { |config| config['version'] == Anthropic.api_version }
+          unless found_config
+            raise Anthropic::Api::UnsupportedApiVersionError, "Unsupported API version: #{Anthropic.api_version}"
+          end
+
+          throw :version_found, found_config
+        end
+      end
+
+      def beta_config
+        return @beta_config if defined?(@beta_config)
+
+        @beta_config = catch(:beta_found) do
+          found_config = Anthropic.betas.find { |config| config['id'] == beta }
+          raise Anthropic::Api::UnsupportedBetaError, "#{beta} not supported" unless found_config
+
+          throw :beta_found, found_config
+        end
+      end
+
+      def beta_loaded?(name)
+        return false unless beta
+
+        beta_config['id'] == name
+      end
+    end
+  end
+end

lib/anthropic/api/completions.rb

@@ -4,7 +4,7 @@ module Anthropic
   module Api
     ##
     # Provides bindings for the Anthropic completions API
-    class Completions < BaseApi
+    class Completions < Base
       def create(**params, &)
         validate!(params)
         return post(params) unless params[:stream]

lib/anthropic/api/concerns/requestable.rb

@@ -26,7 +26,7 @@ def beta_headers
           return {} unless beta
 
           header = beta_config['header']
-          raise Anthropic::Errors::InvalidBetaConfigurationError, "Missing header: #{beta}" unless header
+          raise Anthropic::Api::InvalidBetaConfigurationError, "Missing header: #{beta}" unless header
 
           header
         end

lib/anthropic/api/concerns/validatable.rb

@@ -9,19 +9,19 @@ module Validatable
         def validate!(params)
           JSON::Validator.validate!(schema, params)
         rescue JSON::Schema::ValidationError => error
-          raise Anthropic::Errors::SchemaValidationError, error.message
+          raise Anthropic::Api::SchemaValidationError, error.message
         end
 
         def schema
           api_schema = version_config['schema']
 
           unless api_schema
-            raise Anthropic::Errors::MissingSchemaError, "Missing schema for API version: #{Anthropic.api_version}"
+            raise Anthropic::Api::MissingSchemaError, "Missing schema for API version: #{Anthropic.api_version}"
           end
 
           if beta
             beta_schema = beta_config['schema']
-            raise Anthropic::Errors::InvalidBetaConfigurationError, "Missing beta schema: #{beta}" unless beta_schema
+            raise Anthropic::Api::InvalidBetaConfigurationError, "Missing beta schema: #{beta}" unless beta_schema
 
             api_schema['properties'].merge!(beta_schema)
           end

lib/anthropic/api/messages.rb

@@ -4,11 +4,11 @@ module Anthropic
   module Api
     ##
     # Provides bindings for the Anthropic messages API
-    class Messages < BaseApi
+    class Messages < Base
       def create(**params, &)
         streaming = params[:stream]
         if streaming && beta_loaded?('tools-2024-04-04')
-          raise Anthropic::Errors::UnsupportedBetaUseError, 'Tool use is not yet supported in streaming mode'
+          raise Anthropic::Api::UnsupportedBetaUseError, 'Tool use is not yet supported in streaming mode'
         end
 
         validate!(params)

spec/lib/anthropic/api/completions_spec.rb

@@ -12,13 +12,7 @@
   describe '#create' do
     subject(:call_method) { completions_api.create(**params) }
 
-    context 'with invalid params' do
-      let(:params) { { model: 'foo' } }
-
-      it 'raises an error' do
-        expect { call_method }.to raise_error(Anthropic::Errors::SchemaValidationError)
-      end
-    end
+    shared_examples 'validates the params against the specified API version'
 
     context 'with valid params' do
       # rubocop:disable RSpec/NestedGroups

spec/lib/anthropic/api/messages_spec.rb

@@ -12,13 +12,7 @@
   describe '#create' do
     subject(:call_method) { messages_api.create(**params) }
 
-    context 'with invalid params' do
-      let(:params) { { model: 'foo' } }
-
-      it 'raises an error' do
-        expect { call_method }.to raise_error(Anthropic::Errors::SchemaValidationError)
-      end
-    end
+    shared_examples 'validates the params against the specified API version'
 
     context 'with beta option flagged' do
       subject(:call_method) { described_class.new(beta: 'tools-2024-04-04').create(**params) }
@@ -63,7 +57,7 @@
         end
 
         it 'raises an error' do
-          expect { call_method }.to raise_error(Anthropic::Errors::UnsupportedBetaUseError)
+          expect { call_method }.to raise_error(Anthropic::Api::UnsupportedBetaUseError)
         end
       end
     end
@@ -155,13 +149,6 @@
             expect(response.body).to eq(response_body)
           end
         end
-
-        context 'with invalid API version configured' do
-          it 'raises an error' do
-            allow(Anthropic).to receive(:api_version).and_return('2023-06-02')
-            expect { call_method }.to raise_error(Anthropic::Errors::UnsupportedApiVersionError)
-          end
-        end
       end
       # rubocop:enable RSpec/NestedGroups
     end

spec/support/shared/api_shared_examples.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'validates the params against the specified API version' do
+  context 'with invalid params' do
+    let(:params) { { model: 'foo' } }
+
+    it 'raises an Anthropic::Api:SchemaValidationError' do
+      expect { call_method }.to raise_error(Anthropic::Api::SchemaValidationError)
+    end
+  end
+
+  context 'with invalid API version configured' do
+    it 'raises an Anthropic::Api::UnsupportedApiVersionError' do
+      allow(Anthropic).to receive(:api_version).and_return('2023-06-02')
+      expect { call_method }.to raise_error(Anthropic::Api::UnsupportedApiVersionError)
+    end
+  end
+end