anvil-ruby 0.1.0

data/lib/anvil/client.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+# Try to load multipart support but don't fail if not available
+begin
+  require 'net/http/post/multipart'
+rescue LoadError
+  # Multipart support is optional
+end
+
+module Anvil
+  class Client
+    attr_reader :config, :rate_limiter
+
+    def initialize(api_key: nil, config: nil)
+      @config = config || Anvil.configuration.dup
+      @config.api_key = api_key if api_key
+      @config.validate!
+      @rate_limiter = RateLimiter.new
+    end
+
+    def get(path, params = {}, options = {})
+      request(:get, path, params: params, **options)
+    end
+
+    def post(path, data = {}, options = {})
+      request(:post, path, body: data, **options)
+    end
+
+    def put(path, data = {}, options = {})
+      request(:put, path, body: data, **options)
+    end
+
+    def delete(path, params = {}, options = {})
+      request(:delete, path, params: params, **options)
+    end
+
+    # Execute a raw GraphQL request
+    #
+    # @param query_string [String] The GraphQL query or mutation string
+    # @param variables [Hash] Variables to pass to the query
+    # @return [Hash] The parsed response data
+    def graphql(query_string, variables: {})
+      response = post(config.graphql_url, {
+                        query: query_string,
+                        variables: variables
+                      })
+
+      body = response.body
+      body = response.data if body.is_a?(Anvil::Response)
+
+      if body.is_a?(Hash) && body[:errors] && !body[:errors].empty?
+        messages = body[:errors].map { |e| e[:message] || e['message'] }.compact
+        raise GraphQLError.new(
+          "GraphQL errors: #{messages.join(', ')}",
+          response,
+          graphql_errors: body[:errors]
+        )
+      end
+
+      body.is_a?(Hash) ? body[:data] : body
+    end
+
+    # Execute a GraphQL query
+    #
+    # @param query [String] The GraphQL query string
+    # @param variables [Hash] Variables to pass to the query
+    # @return [Hash] The query result data
+    def query(query:, variables: {})
+      graphql(query, variables: variables)
+    end
+
+    # Execute a GraphQL mutation
+    #
+    # @param mutation [String] The GraphQL mutation string
+    # @param variables [Hash] Variables to pass to the mutation
+    # @return [Hash] The mutation result data
+    def mutation(mutation:, variables: {})
+      graphql(mutation, variables: variables)
+    end
+
+    private
+
+    def request(method, path, params: nil, body: nil, headers: {}, **_options)
+      uri = build_uri(path, params)
+
+      rate_limiter.with_retry do
+        http = build_http(uri)
+        request = build_request(method, uri, body, headers)
+
+        response = http.request(request)
+        wrapped_response = Response.new(response)
+
+        handle_response(wrapped_response)
+      end
+    end
+
+    def build_uri(path, params)
+      uri = URI.parse(path.start_with?('http') ? path : "#{config.base_url}#{path}")
+
+      uri.query = URI.encode_www_form(params) if params && !params.empty?
+
+      uri
+    end
+
+    def build_http(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = config.open_timeout
+      http.read_timeout = config.timeout
+
+      # Debug output only if explicitly requested
+      # Uncomment for debugging:
+      # http.set_debug_output($stdout)
+
+      http
+    end
+
+    def build_request(method, uri, body, headers)
+      klass = case method.to_sym
+              when :get    then Net::HTTP::Get
+              when :post   then Net::HTTP::Post
+              when :put    then Net::HTTP::Put
+              when :delete then Net::HTTP::Delete
+              else
+                raise ArgumentError, "Unsupported HTTP method: #{method}"
+              end
+
+      request = klass.new(uri.request_uri)
+
+      # Set authentication
+      request.basic_auth(config.api_key, '')
+
+      # Set headers
+      default_headers.merge(headers).each do |key, value|
+        request[key] = value
+      end
+
+      # Set body
+      if body
+        if body.is_a?(Hash)
+          request['Content-Type'] = 'application/json'
+          request.body = JSON.generate(body)
+        elsif body.is_a?(String)
+          request.body = body
+        end
+      end
+
+      request
+    end
+
+    def default_headers
+      {
+        'User-Agent' => "Anvil Ruby/#{Anvil::VERSION}",
+        'Accept' => 'application/json'
+      }
+    end
+
+    def handle_response(response)
+      return response if response.success?
+
+      case response.code
+      when 400
+        raise ValidationError.new(response.error_message, response)
+      when 401
+        raise AuthenticationError.new(
+          'Invalid API key. Check your API key at https://app.useanvil.com',
+          response
+        )
+      when 404
+        raise NotFoundError.new(response.error_message, response)
+      when 429
+        # This should be handled by rate_limiter, but just in case
+        raise RateLimitError.new('Rate limit exceeded', response)
+      when 500..599
+        raise ServerError.new(
+          "Server error: #{response.error_message}",
+          response
+        )
+      else
+        raise APIError.new(response.error_message, response)
+      end
+    end
+
+    # Special method for multipart uploads (requires multipart-post gem as optional dependency)
+    def post_multipart(path, params = {}, files = {})
+      unless defined?(Net::HTTP::Post::Multipart)
+        raise LoadError, 'multipart-post gem is required for file uploads. Add it to your Gemfile.'
+      end
+
+      uri = build_uri(path, nil)
+
+      # Convert files to UploadIO objects
+      upload_params = params.dup
+      files.each do |key, file|
+        next unless file.respond_to?(:read)
+
+        upload_params[key] = UploadIO.new(
+          file,
+          'application/octet-stream',
+          File.basename(file.path)
+        )
+      end
+
+      rate_limiter.with_retry do
+        http = build_http(uri)
+        request = Net::HTTP::Post::Multipart.new(uri.path, upload_params)
+        request.basic_auth(config.api_key, '')
+
+        response = http.request(request)
+        wrapped_response = Response.new(response)
+
+        handle_response(wrapped_response)
+      end
+    end
+  end
+end

data/lib/anvil/configuration.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Anvil
+  class Configuration
+    ENVIRONMENTS = %i[development production].freeze
+
+    attr_accessor :api_key, :base_url, :graphql_url, :timeout, :open_timeout
+    attr_reader :environment
+    attr_writer :webhook_token
+
+    def initialize
+      @environment = default_environment
+      @base_url = 'https://app.useanvil.com/api/v1'
+      @graphql_url = 'https://graphql.useanvil.com/' # GraphQL endpoint
+      @timeout = 120         # Read timeout in seconds
+      @open_timeout = 30     # Connection open timeout
+      @api_key = ENV.fetch('ANVIL_API_KEY', nil)
+      @webhook_token = ENV.fetch('ANVIL_WEBHOOK_TOKEN', nil)
+    end
+
+    def environment=(env)
+      env = env.to_sym
+      unless ENVIRONMENTS.include?(env)
+        raise ArgumentError, "Invalid environment: #{env}. Must be one of: #{ENVIRONMENTS.join(', ')}"
+      end
+
+      @environment = env
+    end
+
+    def development?
+      environment == :development
+    end
+
+    def production?
+      environment == :production
+    end
+
+    def webhook_token
+      @webhook_token || ENV.fetch('ANVIL_WEBHOOK_TOKEN', nil)
+    end
+
+    # Rate limits based on environment and plan
+    def rate_limit
+      return 4 if development?
+
+      # Default production rate limit
+      # Can be overridden if needed for custom plans
+      4
+    end
+
+    def validate!
+      return unless api_key.nil? || api_key.empty?
+
+      raise Anvil::ConfigurationError, <<~ERROR
+        No API key configured. Please set your API key using one of these methods:
+
+        1. Rails initializer (config/initializers/anvil.rb):
+           Anvil.configure do |config|
+             config.api_key = Rails.application.credentials.anvil[:api_key]
+           end
+
+        2. Environment variable:
+           export ANVIL_API_KEY="your_api_key_here"
+
+        3. Direct assignment:
+           Anvil.api_key = "your_api_key_here"
+
+        Get your API keys at: https://app.useanvil.com/organizations/settings/api
+      ERROR
+    end
+
+    private
+
+    def default_environment
+      # Check Rails environment if Rails is defined
+      if defined?(Rails)
+        Rails.env.production? ? :production : :development
+      elsif ENV['ANVIL_ENV']
+        ENV['ANVIL_ENV'].to_sym
+      elsif ENV['RACK_ENV']
+        ENV['RACK_ENV'] == 'production' ? :production : :development
+      else
+        :production
+      end
+    end
+  end
+end

data/lib/anvil/env_loader.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Anvil
+  # Simple .env file loader (no dependencies required!)
+  class EnvLoader
+    def self.load(path = '.env')
+      return unless File.exist?(path)
+
+      File.readlines(path).each do |line|
+        line = line.chomp # Remove newline
+
+        # Skip comments and empty lines
+        next if line.strip.empty? || line.strip.start_with?('#')
+
+        # Parse KEY=value format
+        next unless line =~ /\A([A-Z_][A-Z0-9_]*)\s*=\s*(.*)\z/
+
+        key = ::Regexp.last_match(1)
+        value = ::Regexp.last_match(2).strip
+
+        # Remove quotes if present
+        value = value[1..-2] if (value.start_with?('"') && value.end_with?('"')) ||
+                                (value.start_with?("'") && value.end_with?("'"))
+
+        # Set environment variable
+        ENV[key] = value
+      end
+    end
+  end
+end

data/lib/anvil/errors.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Anvil
+  # Base error class for all Anvil errors
+  class Error < StandardError
+    attr_reader :response, :code
+
+    def initialize(message = nil, response = nil)
+      @response = response
+      @code = response&.code
+      super(message || default_message)
+    end
+
+    private
+
+    def default_message
+      'An error occurred with the Anvil API'
+    end
+  end
+
+  # Configuration errors
+  class ConfigurationError < Error; end
+
+  # API errors
+  class APIError < Error
+    attr_reader :status_code, :errors
+
+    def initialize(message, response = nil)
+      @status_code = response&.code&.to_i
+      @errors = parse_errors(response) if response
+      super
+    end
+
+    private
+
+    def parse_errors(response)
+      data = extract_response_data(response)
+      return [] unless data
+
+      data[:errors] || data['errors'] || data[:fields] || data['fields'] || []
+    rescue JSON::ParserError
+      []
+    end
+
+    def extract_response_data(response)
+      return nil unless response
+
+      body = response.respond_to?(:body) ? response.body : response
+      return nil unless body.is_a?(String) || body.is_a?(Hash)
+      return nil if body.respond_to?(:empty?) && body.empty?
+
+      body.is_a?(Hash) ? body : JSON.parse(body)
+    end
+  end
+
+  # Specific API error types
+  class ValidationError < APIError; end
+  class AuthenticationError < APIError; end
+
+  class RateLimitError < APIError
+    attr_reader :retry_after
+
+    def initialize(message, response = nil)
+      super
+      @retry_after = response&.fetch('retry-after', nil)&.to_i if response
+    end
+  end
+
+  class NotFoundError < APIError; end
+  class ServerError < APIError; end
+
+  # Network errors
+  class NetworkError < Error; end
+  class TimeoutError < NetworkError; end
+  class ConnectionError < NetworkError; end
+
+  # File errors
+  class FileError < Error; end
+  class FileNotFoundError < FileError; end
+  class FileTooLargeError < FileError; end
+
+  # GraphQL errors
+  class GraphQLError < APIError
+    attr_reader :graphql_errors
+
+    def initialize(message, response = nil, graphql_errors: [])
+      @graphql_errors = graphql_errors
+      super(message, response)
+    end
+  end
+
+  # Webhook errors
+  class WebhookError < Error; end
+  class WebhookVerificationError < WebhookError; end
+end

data/lib/anvil/rate_limiter.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Anvil
+  class RateLimiter
+    MAX_RETRIES = 3
+    BASE_DELAY = 1.0 # Base delay in seconds
+
+    attr_reader :max_retries, :base_delay
+
+    def initialize(max_retries: MAX_RETRIES, base_delay: BASE_DELAY)
+      @max_retries = max_retries
+      @base_delay = base_delay
+    end
+
+    def with_retry
+      retries = 0
+      last_error = nil
+
+      loop do
+        response = yield
+
+        # Check if we got rate limited
+        if response.code == 429
+          retries += 1
+          if retries > max_retries
+            raise RateLimitError.new(
+              "Rate limit exceeded after #{max_retries} retries",
+              response
+            )
+          end
+
+          delay = calculate_delay(response, retries)
+          sleep(delay)
+          next
+        end
+
+        return response
+      rescue Timeout::Error, Errno::ECONNREFUSED, Errno::ECONNRESET => e
+        last_error = e
+        retries += 1
+
+        raise NetworkError, "Network error after #{max_retries} retries: #{e.message}" if retries > max_retries
+
+        delay = exponential_backoff(retries)
+        sleep(delay)
+      end
+    end
+
+    private
+
+    def calculate_delay(response, retry_count)
+      # Use Retry-After header if available
+      if response.retry_after&.positive?
+        response.retry_after
+      else
+        exponential_backoff(retry_count)
+      end
+    end
+
+    def exponential_backoff(retry_count)
+      # Exponential backoff with jitter
+      delay = base_delay * (2**(retry_count - 1))
+      delay + (rand * delay * 0.1) # Add 10% jitter
+    end
+  end
+end

data/lib/anvil/resources/base.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Anvil
+  module Resources
+    class Base
+      attr_reader :attributes, :client
+
+      def initialize(attributes = {}, client: nil)
+        @attributes = symbolize_keys(attributes)
+        @client = client || default_client
+      end
+
+      # ActiveRecord-like attribute accessors
+      def method_missing(method_name, *args)
+        if method_name.to_s.end_with?('=')
+          attribute = method_name.to_s.chomp('=').to_sym
+          attributes[attribute] = args.first
+        elsif attributes.key?(method_name)
+          attributes[method_name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name.to_s.end_with?('=') || attributes.key?(method_name) || super
+      end
+
+      def to_h
+        attributes
+      end
+
+      def to_json(*args)
+        attributes.to_json(*args)
+      end
+
+      def inspect
+        "#<#{self.class.name} #{attributes.inspect}>"
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && attributes == other.attributes
+      end
+
+      protected
+
+      def default_client
+        @default_client ||= Client.new
+      end
+
+      def symbolize_keys(hash)
+        return {} unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), result|
+          sym_key = key.is_a?(String) ? key.to_sym : key
+          result[sym_key] = value.is_a?(Hash) ? symbolize_keys(value) : value
+        end
+      end
+
+      class << self
+        def client
+          @client ||= Client.new
+        end
+
+        attr_writer :client
+
+        # Override in subclasses to provide resource-specific client
+        def with_client(api_key: nil)
+          original_client = @client
+          @client = Client.new(api_key: api_key)
+          yield
+        ensure
+          @client = original_client
+        end
+
+        # Helper for building resource instances from API responses
+        def build_from_response(response)
+          if response.data.is_a?(Array)
+            response.data.map { |item| new(item) }
+          else
+            new(response.data)
+          end
+        end
+
+        # Common API operations
+        def find(id, client: nil)
+          raise NotImplementedError, "#{self.class.name}#find must be implemented by subclass"
+        end
+
+        def create(attributes = {}, client: nil)
+          raise NotImplementedError, "#{self.class.name}#create must be implemented by subclass"
+        end
+
+        def list(params = {}, client: nil)
+          raise NotImplementedError, "#{self.class.name}#list must be implemented by subclass"
+        end
+      end
+    end
+  end
+end