fabulous 0.1.0

data/lib/fabulous/client.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Fabulous
+  class Client
+    attr_reader :configuration
+
+    def initialize(configuration = nil)
+      @configuration = configuration || Fabulous.configuration || Configuration.new
+      validate_configuration!
+    end
+
+    def domains
+      @domains ||= Resources::Domain.new(self)
+    end
+
+    def dns
+      @dns ||= Resources::DNS.new(self)
+    end
+
+    def request(action, params = {})
+      params = build_params(action, params)
+      
+      # The Fabulous API uses GET requests with URL parameters
+      url = "/#{action}"
+      
+      response = connection.get(url) do |req|
+        req.params = params
+      end
+
+      # Debug output if ENV variable is set
+      if ENV["DEBUG_FABULOUS"]
+        puts "Request URL: #{configuration.base_url}#{url}"
+        puts "Parameters: #{params.inspect}"
+        puts "HTTP Status: #{response.status}"
+        puts "Response Body:"
+        puts response.body
+        puts
+      end
+
+      Response.new(response.body).tap do |parsed_response|
+        handle_errors(parsed_response)
+      end
+    rescue Faraday::TimeoutError => e
+      raise TimeoutError, "Request timed out: #{e.message}"
+    rescue Faraday::Error => e
+      raise RequestError, "Request failed: #{e.message}"
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new(url: configuration.base_url) do |faraday|
+        faraday.request :url_encoded
+        faraday.adapter Faraday.default_adapter
+        faraday.options.timeout = configuration.timeout
+        faraday.options.open_timeout = configuration.open_timeout
+      end
+    end
+
+    def build_params(action, params)
+      # Don't include action in params, it's part of the URL path
+      {
+        username: configuration.username,
+        password: configuration.password
+      }.merge(params)
+    end
+
+    def handle_errors(response)
+      return if response.success?
+
+      case response.status_code
+      when 300..399
+        raise AuthenticationError.new(response.status_message || "Authentication failed", response.status_code)
+      when 400..499
+        raise RequestError.new(response.status_message || "Request error", response.status_code)
+      when 500..599
+        raise ResponseError.new(response.status_message || "Server error", response.status_code)
+      when 689
+        raise RateLimitError, "Execution time exhausted (300 seconds per 24 hours limit reached)"
+      else
+        raise Error, "Unknown error: #{response.status_message} (code: #{response.status_code})"
+      end
+    end
+
+    def validate_configuration!
+      raise ConfigurationError, "Username and password are required" unless configuration.valid?
+    end
+  end
+end

data/lib/fabulous/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Fabulous
+  class Configuration
+    attr_accessor :username, :password, :base_url, :timeout, :open_timeout
+
+    def initialize
+      @base_url = "https://api.fabulous.com"
+      @timeout = 30
+      @open_timeout = 10
+    end
+
+    def valid?
+      !username.nil? && !password.nil?
+    end
+  end
+end

data/lib/fabulous/errors.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Fabulous
+  class Error < StandardError; end
+  
+  class ConfigurationError < Error; end
+  
+  class AuthenticationError < Error
+    attr_reader :code
+    
+    def initialize(message, code = nil)
+      @code = code
+      super(message)
+    end
+  end
+  
+  class RequestError < Error
+    attr_reader :code
+    
+    def initialize(message, code = nil)
+      @code = code
+      super(message)
+    end
+  end
+  
+  class ResponseError < Error
+    attr_reader :code
+    
+    def initialize(message, code = nil)
+      @code = code
+      super(message)
+    end
+  end
+  
+  class RateLimitError < Error; end
+  
+  class TimeoutError < Error; end
+end

data/lib/fabulous/resources/base.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Fabulous
+  module Resources
+    class Base
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      protected
+
+      def request(action, params = {})
+        client.request(action, params)
+      end
+
+      def paginate(action, params = {}, &block)
+        page = params.delete(:page) || 1
+        all_results = []
+        
+        loop do
+          response = request(action, params.merge(page: page))
+          
+          if block_given?
+            yield response, page
+          else
+            all_results.concat(extract_items(response))
+          end
+          
+          break unless response.paginated? && page < response.page_count
+          page += 1
+        end
+        
+        block_given? ? nil : all_results
+      end
+
+      def extract_items(response)
+        # Override in subclasses to extract the appropriate items
+        response.data.values.first || []
+      end
+    end
+  end
+end

data/lib/fabulous/resources/dns.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Fabulous
+  module Resources
+    class DNS < Base
+      def list_records(domain_name, type: nil)
+        params = { domain: domain_name }
+        params[:type] = type if type
+        
+        response = request("listDNSrecords", params)
+        response.data[:dns_records] || []
+      end
+
+      # MX Records
+      def mx_records(domain_name)
+        response = request("getMXRecords", domain: domain_name)
+        response.data[:mx_records] || []
+      end
+
+      def add_mx_record(domain_name, hostname:, priority:, ttl: 3600)
+        response = request("addMXRecord", {
+          domain: domain_name,
+          hostname: hostname,
+          priority: priority,
+          ttl: ttl
+        })
+        response.success?
+      end
+
+      def update_mx_record(domain_name, record_id:, hostname: nil, priority: nil, ttl: nil)
+        params = {
+          domain: domain_name,
+          recordId: record_id
+        }
+        params[:hostname] = hostname if hostname
+        params[:priority] = priority if priority
+        params[:ttl] = ttl if ttl
+        
+        response = request("updateMXRecord", params)
+        response.success?
+      end
+
+      def delete_mx_record(domain_name, record_id)
+        response = request("deleteMXRecord", domain: domain_name, recordId: record_id)
+        response.success?
+      end
+
+      # CNAME Records
+      def cname_records(domain_name)
+        response = request("getCNAMERecords", domain: domain_name)
+        response.data[:cname_records] || []
+      end
+
+      def add_cname_record(domain_name, alias_name:, target:, ttl: 3600)
+        response = request("addCNAMERecord", {
+          domain: domain_name,
+          alias: alias_name,
+          target: target,
+          ttl: ttl
+        })
+        response.success?
+      end
+
+      def update_cname_record(domain_name, record_id:, alias_name: nil, target: nil, ttl: nil)
+        params = {
+          domain: domain_name,
+          recordId: record_id
+        }
+        params[:alias] = alias_name if alias_name
+        params[:target] = target if target
+        params[:ttl] = ttl if ttl
+        
+        response = request("updateCNAMERecord", params)
+        response.success?
+      end
+
+      def delete_cname_record(domain_name, record_id)
+        response = request("deleteCNAMERecord", domain: domain_name, recordId: record_id)
+        response.success?
+      end
+
+      # A Records
+      def a_records(domain_name)
+        response = request("getARecords", domain: domain_name)
+        response.data[:a_records] || []
+      end
+
+      def add_a_record(domain_name, hostname:, ip_address:, ttl: 3600)
+        response = request("addARecord", {
+          domain: domain_name,
+          hostname: hostname,
+          ipAddress: ip_address,
+          ttl: ttl
+        })
+        response.success?
+      end
+
+      def update_a_record(domain_name, record_id:, hostname: nil, ip_address: nil, ttl: nil)
+        params = {
+          domain: domain_name,
+          recordId: record_id
+        }
+        params[:hostname] = hostname if hostname
+        params[:ipAddress] = ip_address if ip_address
+        params[:ttl] = ttl if ttl
+        
+        response = request("updateARecord", params)
+        response.success?
+      end
+
+      def delete_a_record(domain_name, record_id)
+        response = request("deleteARecord", domain: domain_name, recordId: record_id)
+        response.success?
+      end
+
+      # TXT Records
+      def txt_records(domain_name)
+        response = request("getTXTRecords", domain: domain_name)
+        response.data[:txt_records] || []
+      end
+
+      def add_txt_record(domain_name, hostname:, text:, ttl: 3600)
+        response = request("addTXTRecord", {
+          domain: domain_name,
+          hostname: hostname,
+          text: text,
+          ttl: ttl
+        })
+        response.success?
+      end
+
+      def update_txt_record(domain_name, record_id:, hostname: nil, text: nil, ttl: nil)
+        params = {
+          domain: domain_name,
+          recordId: record_id
+        }
+        params[:hostname] = hostname if hostname
+        params[:text] = text if text
+        params[:ttl] = ttl if ttl
+        
+        response = request("updateTXTRecord", params)
+        response.success?
+      end
+
+      def delete_txt_record(domain_name, record_id)
+        response = request("deleteTXTRecord", domain: domain_name, recordId: record_id)
+        response.success?
+      end
+
+      # AAAA Records (IPv6)
+      def aaaa_records(domain_name)
+        response = request("getAAAARecords", domain: domain_name)
+        response.data[:aaaa_records] || []
+      end
+
+      def add_aaaa_record(domain_name, hostname:, ipv6_address:, ttl: 3600)
+        response = request("addAAAARecord", {
+          domain: domain_name,
+          hostname: hostname,
+          ipv6Address: ipv6_address,
+          ttl: ttl
+        })
+        response.success?
+      end
+
+      def update_aaaa_record(domain_name, record_id:, hostname: nil, ipv6_address: nil, ttl: nil)
+        params = {
+          domain: domain_name,
+          recordId: record_id
+        }
+        params[:hostname] = hostname if hostname
+        params[:ipv6Address] = ipv6_address if ipv6_address
+        params[:ttl] = ttl if ttl
+        
+        response = request("updateAAAARecord", params)
+        response.success?
+      end
+
+      def delete_aaaa_record(domain_name, record_id)
+        response = request("deleteAAAARecord", domain: domain_name, recordId: record_id)
+        response.success?
+      end
+    end
+  end
+end

data/lib/fabulous/resources/domain.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Fabulous
+  module Resources
+    class Domain < Base
+      def list(page: nil, &block)
+        if page
+          response = request("listDomains", page: page)
+          block_given? ? yield(response) : response.data[:domains]
+        else
+          paginate("listDomains", &block)
+        end
+      end
+      
+      def all
+        paginate("listDomains")
+      end
+
+      def check(domain_name)
+        response = request("checkDomain", domain: domain_name)
+        response.data[:available]
+      end
+
+      def info(domain_name)
+        response = request("domainInfo", domain: domain_name)
+        response.data[:domain_info]
+      end
+
+      def register(domain_name, years: 1, nameservers: [], whois_privacy: false, auto_renew: false)
+        params = {
+          domain: domain_name,
+          years: years,
+          whoisPrivacy: whois_privacy,
+          autoRenew: auto_renew
+        }
+        
+        nameservers.each_with_index do |ns, index|
+          params["ns#{index + 1}"] = ns
+        end
+        
+        response = request("registerDomain", params)
+        response.success?
+      end
+
+      def renew(domain_name, years: 1)
+        response = request("renewDomain", domain: domain_name, years: years)
+        response.success?
+      end
+
+      def transfer_in(domain_name, auth_code)
+        response = request("transferIn", domain: domain_name, authCode: auth_code)
+        response.success?
+      end
+
+      def set_nameservers(domain_name, nameservers)
+        params = { domain: domain_name }
+        
+        nameservers.each_with_index do |ns, index|
+          params["ns#{index + 1}"] = ns
+        end
+        
+        response = request("setNameServers", params)
+        response.success?
+      end
+
+      def get_nameservers(domain_name)
+        info = info(domain_name)
+        info[:nameservers] if info
+      end
+
+      def lock(domain_name)
+        response = request("lockDomain", domain: domain_name)
+        response.success?
+      end
+
+      def unlock(domain_name)
+        response = request("unlockDomain", domain: domain_name)
+        response.success?
+      end
+
+      def set_auto_renew(domain_name, enabled: true)
+        response = request("setAutoRenew", domain: domain_name, autoRenew: enabled)
+        response.success?
+      end
+
+      def enable_whois_privacy(domain_name)
+        response = request("enableWhoisPrivacy", domain: domain_name)
+        response.success?
+      end
+
+      def disable_whois_privacy(domain_name)
+        response = request("disableWhoisPrivacy", domain: domain_name)
+        response.success?
+      end
+
+      protected
+
+      def extract_items(response)
+        response.data[:domains] || []
+      end
+    end
+  end
+end

data/lib/fabulous/response.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Fabulous
+  class Response
+    attr_reader :doc, :raw_xml
+
+    def initialize(xml_string)
+      @raw_xml = xml_string
+      @doc = Nokogiri::XML(xml_string)
+    end
+
+    def success?
+      status_code && status_code.to_i == 200
+    end
+
+    def status_code
+      # Try both old and new format
+      @status_code ||= doc.at_xpath("//statusCode")&.text&.to_i || 
+                       doc.at_xpath("//response/status")&.text&.to_i
+    end
+
+    def status_message
+      # Try both old and new format  
+      @status_message ||= doc.at_xpath("//statusText")&.text ||
+                          doc.at_xpath("//response/reason")&.text
+    end
+
+    def data
+      @data ||= parse_data
+    end
+
+    def paginated?
+      # Check if results count exceeds what's shown (pagination needed)
+      total = doc.at_xpath("//results")&.attr("count")&.to_i || 0
+      shown = doc.xpath("//results/result").length
+      total > shown && shown > 0
+    end
+
+    def page_count
+      # Calculate based on total results and page size
+      total = doc.at_xpath("//results")&.attr("count")&.to_i || 0
+      page_size = doc.xpath("//results/result").length
+      return 1 if page_size == 0
+      (total.to_f / page_size).ceil
+    end
+
+    def current_page
+      # Try to get from request params
+      doc.at_xpath("//request/params/param[@name='page']")&.text&.to_i || 1
+    end
+
+    private
+
+    def parse_data
+      result = {}
+      
+      # Parse new format with results
+      if results = doc.xpath("//results/result")
+        result[:domains] = parse_results_domains(results)
+      # Parse old format
+      elsif domains = doc.xpath("//domain")
+        result[:domains] = parse_domains(domains)
+      end
+      
+      if dns_records = doc.xpath("//dnsrecord")
+        result[:dns_records] = parse_dns_records(dns_records)
+      end
+      
+      if mx_records = doc.xpath("//mxrecord")
+        result[:mx_records] = parse_mx_records(mx_records)
+      end
+      
+      if cname_records = doc.xpath("//cnamerecord")
+        result[:cname_records] = parse_cname_records(cname_records)
+      end
+      
+      if a_records = doc.xpath("//arecord")
+        result[:a_records] = parse_a_records(a_records)
+      end
+      
+      # Parse single domain info  
+      if domain_info = doc.at_xpath("//domainInfo")
+        result[:domain_info] = parse_domain_info(domain_info)
+      elsif info_result = doc.at_xpath("//results/result[expiry]")
+        # domainInfo response format
+        result[:domain_info] = {
+          expiry_date: info_result.at_xpath("expiry")&.text,
+          nameservers: info_result.xpath("nameserverss/nameservers").map(&:text),
+          status: info_result.at_xpath("fabstatus")&.text&.capitalize || "Active",
+          auto_renew: info_result.at_xpath("autorenewstatus")&.text == "1",
+          locked: info_result.xpath("registrystatuss/registrystatus").any? { |s| s.text.include?("Prohibited") },
+          whois_privacy: info_result.at_xpath("whoisprivacyenabled")&.text == "1"
+        }
+      elsif domain_element = doc.at_xpath("//domain")
+        # Alternative format for domain info
+        result[:domain_info] = {
+          status: domain_element.at_xpath("status")&.text || "Active"
+        }
+      end
+      
+      # Parse availability check
+      if availability = doc.at_xpath("//availability")
+        result[:available] = availability.text == "true"
+      end
+      
+      result.empty? ? parse_generic : result
+    end
+
+    def parse_results_domains(results)
+      results.map do |result|
+        {
+          name: result.at_xpath("domain")&.text,
+          expiry_date: result.at_xpath("exdate")&.text,
+          status: "Active", # Not provided in new format, assuming active
+          auto_renew: nil, # Not provided in this format
+          locked: nil # Not provided in this format
+        }.compact
+      end
+    end
+
+    def parse_domains(domains)
+      domains.map do |domain|
+        {
+          name: domain.at_xpath("name")&.text,
+          status: domain.at_xpath("status")&.text,
+          expiry_date: domain.at_xpath("expiryDate")&.text,
+          auto_renew: domain.at_xpath("autoRenew")&.text == "true",
+          locked: domain.at_xpath("locked")&.text == "true"
+        }.compact
+      end
+    end
+
+    def parse_domain_info(info)
+      {
+        name: info.at_xpath("name")&.text,
+        status: info.at_xpath("status")&.text,
+        creation_date: info.at_xpath("creationDate")&.text,
+        expiry_date: info.at_xpath("expiryDate")&.text,
+        nameservers: info.xpath("nameservers/nameserver").map(&:text),
+        auto_renew: info.at_xpath("autoRenew")&.text == "true",
+        locked: info.at_xpath("locked")&.text == "true",
+        whois_privacy: info.at_xpath("whoisPrivacy")&.text == "true"
+      }.compact
+    end
+
+    def parse_dns_records(records)
+      records.map do |record|
+        {
+          id: record.at_xpath("id")&.text,
+          type: record.at_xpath("type")&.text,
+          name: record.at_xpath("name")&.text,
+          value: record.at_xpath("value")&.text,
+          ttl: record.at_xpath("ttl")&.text&.to_i,
+          priority: record.at_xpath("priority")&.text&.to_i
+        }.compact
+      end
+    end
+
+    def parse_mx_records(records)
+      records.map do |record|
+        {
+          id: record.at_xpath("id")&.text,
+          hostname: record.at_xpath("hostname")&.text,
+          priority: record.at_xpath("priority")&.text&.to_i,
+          ttl: record.at_xpath("ttl")&.text&.to_i
+        }.compact
+      end
+    end
+
+    def parse_cname_records(records)
+      records.map do |record|
+        {
+          id: record.at_xpath("id")&.text,
+          alias: record.at_xpath("alias")&.text,
+          target: record.at_xpath("target")&.text,
+          ttl: record.at_xpath("ttl")&.text&.to_i
+        }.compact
+      end
+    end
+
+    def parse_a_records(records)
+      records.map do |record|
+        {
+          id: record.at_xpath("id")&.text,
+          hostname: record.at_xpath("hostname")&.text,
+          ip_address: record.at_xpath("ipAddress")&.text,
+          ttl: record.at_xpath("ttl")&.text&.to_i
+        }.compact
+      end
+    end
+
+    def parse_generic
+      # Return all non-status elements as a hash
+      result = {}
+      doc.root.children.each do |child|
+        next if child.text? || child.name =~ /status/i
+        
+        if child.children.length > 1
+          result[child.name.to_sym] = parse_element(child)
+        else
+          result[child.name.to_sym] = child.text
+        end
+      end
+      result
+    end
+
+    def parse_element(element)
+      if element.children.all? { |c| c.text? }
+        element.text
+      else
+        result = {}
+        element.children.each do |child|
+          next if child.text?
+          
+          if result[child.name.to_sym]
+            result[child.name.to_sym] = [result[child.name.to_sym]] unless result[child.name.to_sym].is_a?(Array)
+            result[child.name.to_sym] << parse_element(child)
+          else
+            result[child.name.to_sym] = parse_element(child)
+          end
+        end
+        result
+      end
+    end
+  end
+end