generatorlabs 2.0.0

data/lib/generatorlabs/cert.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+#
+# This file is part of the Generator Labs Ruby SDK package.
+#
+# (c) Generator Labs <support@generatorlabs.com>
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+
+module GeneratorLabs
+  # Certificate monitoring API namespace
+  class Cert
+    def initialize(handler)
+      @handler = handler
+    end
+
+    # Access certificate error operations
+    # @return [CertErrors]
+    def errors
+      @errors ||= CertErrors.new(@handler)
+    end
+
+    # Access certificate monitor management operations
+    # @return [CertMonitors]
+    def monitors
+      @monitors ||= CertMonitors.new(@handler)
+    end
+
+    # Access certificate profile management operations
+    # @return [CertProfiles]
+    def profiles
+      @profiles ||= CertProfiles.new(@handler)
+    end
+  end
+
+  # Certificate error retrieval
+  class CertErrors
+    def initialize(handler)
+      @handler = handler
+    end
+
+    # Get certificate errors
+    # @param params [nil, Hash] Optional parameters
+    # @return [Hash] Error data
+    def get(params = {})
+      @handler.get('cert/errors', params)
+    end
+
+    # Get all errors with automatic pagination
+    # @param params [Hash] Optional parameters (e.g., page_size)
+    # @return [Array] All errors across all pages
+    def get_all(params = {})
+      all_items = []
+      page = 1
+      params = params.dup
+
+      loop do
+        params[:page] = page
+        response = get(params)
+        errors = response['errors'] || []
+
+        all_items.concat(errors)
+
+        break unless page < (response['total_pages'] || 1) && !errors.empty?
+
+        page += 1
+      end
+
+      all_items
+    end
+  end
+
+  # Certificate monitor management
+  class CertMonitors
+    def initialize(handler)
+      @handler = handler
+    end
+
+    # Get monitors (all, by ID, or by array of IDs)
+    # @param ids [nil, String, Integer, Hash, Array] Optional ID(s) or parameters
+    # @return [Hash] Monitor data
+    def get(*ids)
+      return @handler.get('cert/monitors') if ids.empty?
+
+      # Check if first argument is a hash (parameters)
+      return @handler.get('cert/monitors', ids.first) if ids.first.is_a?(Hash)
+
+      return @handler.get("cert/monitors/#{ids.first}") if ids.length == 1
+
+      @handler.get('cert/monitors', { ids: ids.join(',') })
+    end
+
+    # Get all monitors with automatic pagination
+    # @param params [Hash] Optional parameters (e.g., page_size)
+    # @return [Array] All monitors across all pages
+    def get_all(params = {})
+      all_items = []
+      page = 1
+      params = params.dup
+
+      loop do
+        params[:page] = page
+        response = get(params)
+        monitors = response['monitors'] || []
+
+        all_items.concat(monitors)
+
+        break unless page < (response['total_pages'] || 1) && !monitors.empty?
+
+        page += 1
+      end
+
+      all_items
+    end
+
+    # Create a new certificate monitor
+    # @param params [Hash] Monitor parameters
+    # @return [Hash] Created monitor data
+    def create(params)
+      @handler.post('cert/monitors', params)
+    end
+
+    # Update a certificate monitor
+    # @param id [String, Integer] Monitor ID
+    # @param params [Hash] Updated parameters
+    # @return [Hash] Updated monitor data
+    def update(id, params)
+      @handler.put("cert/monitors/#{id}", params)
+    end
+
+    # Delete a certificate monitor
+    # @param id [String, Integer] Monitor ID
+    # @return [Hash] Deletion confirmation
+    def delete(id)
+      @handler.delete("cert/monitors/#{id}")
+    end
+
+    # Pause monitoring for a certificate
+    # @param id [String, Integer] Monitor ID
+    # @return [Hash] Response
+    def pause(id)
+      @handler.post("cert/monitors/#{id}/pause")
+    end
+
+    # Resume monitoring for a certificate
+    # @param id [String, Integer] Monitor ID
+    # @return [Hash] Response
+    def resume(id)
+      @handler.post("cert/monitors/#{id}/resume")
+    end
+  end
+
+  # Certificate profile management
+  class CertProfiles
+    def initialize(handler)
+      @handler = handler
+    end
+
+    # Get profiles (all, by ID, or by array of IDs)
+    # @param ids [nil, String, Integer, Hash, Array] Optional ID(s) or parameters
+    # @return [Hash] Profile data
+    def get(*ids)
+      return @handler.get('cert/profiles') if ids.empty?
+
+      # Check if first argument is a hash (parameters)
+      return @handler.get('cert/profiles', ids.first) if ids.first.is_a?(Hash)
+
+      return @handler.get("cert/profiles/#{ids.first}") if ids.length == 1
+
+      @handler.get('cert/profiles', { ids: ids.join(',') })
+    end
+
+    # Get all profiles with automatic pagination
+    # @param params [Hash] Optional parameters (e.g., page_size)
+    # @return [Array] All profiles across all pages
+    def get_all(params = {})
+      all_items = []
+      page = 1
+      params = params.dup
+
+      loop do
+        params[:page] = page
+        response = get(params)
+        profiles = response['profiles'] || []
+
+        all_items.concat(profiles)
+
+        break unless page < (response['total_pages'] || 1) && !profiles.empty?
+
+        page += 1
+      end
+
+      all_items
+    end
+
+    # Create a new certificate monitoring profile
+    # @param params [Hash] Profile parameters
+    # @return [Hash] Created profile data
+    def create(params)
+      @handler.post('cert/profiles', params)
+    end
+
+    # Update a certificate monitoring profile
+    # @param id [String, Integer] Profile ID
+    # @param params [Hash] Updated parameters
+    # @return [Hash] Updated profile data
+    def update(id, params)
+      @handler.put("cert/profiles/#{id}", params)
+    end
+
+    # Delete a certificate monitoring profile
+    # @param id [String, Integer] Profile ID
+    # @return [Hash] Deletion confirmation
+    def delete(id)
+      @handler.delete("cert/profiles/#{id}")
+    end
+  end
+end

data/lib/generatorlabs/client.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+#
+# This file is part of the Generator Labs Ruby SDK package.
+#
+# (c) Generator Labs <support@generatorlabs.com>
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+
+module GeneratorLabs
+  # Main API client for Generator Labs.
+  #
+  # The Generator Labs API is a RESTful web service API that lets customers manage
+  # their RBL monitoring hosts, certificate monitoring, contacts, and retrieve
+  # listing information.
+  #
+  # @example Basic usage
+  #   client = GeneratorLabs::Client.new('your_account_sid', 'your_auth_token')
+  #
+  #   # RBL monitoring
+  #   hosts = client.rbl.hosts.get
+  #
+  #   # Certificate monitoring
+  #   monitors = client.cert.monitors.get
+  #
+  #   # Contact management
+  #   contacts = client.contact.contacts.get
+  #
+  # @example With custom configuration
+  #   config = GeneratorLabs::Config.new(
+  #     timeout: 45,
+  #     max_retries: 5,
+  #     retry_backoff: 2.0
+  #   )
+  #   client = GeneratorLabs::Client.new('your_account_sid', 'your_auth_token', config)
+  class Client
+    # @return [String] The account SID (2 uppercase + 32 hex characters)
+    attr_reader :account_sid
+
+    # @return [String] The authentication token (64 hex characters)
+    attr_reader :auth_token
+
+    # @return [Config] The configuration object
+    attr_reader :config
+
+    # Initialize a new Generator Labs client.
+    #
+    # The account SID must be in the format of 2 uppercase letters followed by
+    # 32 hexadecimal characters (e.g., "AC" + 32 hex chars).
+    #
+    # The auth token must be 64 hexadecimal characters.
+    #
+    # @param account_sid [String] Your Generator Labs account SID
+    # @param auth_token [String] Your Generator Labs auth token
+    # @param config [Config, nil] Optional configuration object for custom timeouts and retry behavior
+    # @raise [Error] if account_sid or auth_token format is invalid
+    #
+    # @example
+    #   client = GeneratorLabs::Client.new('ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', 'your_auth_token')
+    #
+    # @example With custom config
+    #   config = GeneratorLabs::Config.new(timeout: 60)
+    #   client = GeneratorLabs::Client.new('ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', 'your_auth_token', config)
+    def initialize(account_sid, auth_token, config = nil)
+      # Validate account SID format
+      raise Error, "Invalid account SID format: #{account_sid}" unless account_sid.match?(/^[A-Z]{2}[0-9a-fA-F]{32}$/)
+
+      # Validate auth token format
+      raise Error, 'Invalid auth token format' unless auth_token.match?(/^[0-9a-fA-F]{64}$/)
+
+      @account_sid = account_sid
+      @auth_token = auth_token
+      @config = config || Config.default
+      @handler = RequestHandler.new(account_sid, auth_token, @config)
+    end
+
+    # Get the RBL monitoring API namespace.
+    #
+    # The RBL namespace provides access to:
+    # - Hosts: Manage monitored hosts (IP addresses and domains)
+    # - Profiles: Manage monitoring profiles (which RBLs to check)
+    # - Sources: Manage RBL sources
+    # - Check: Perform ad-hoc RBL checks
+    # - Listings: Retrieve current RBL listings
+    #
+    # @return [RBL] RBL namespace with endpoints for hosts, profiles, sources, etc.
+    #
+    # @example
+    #   hosts = client.rbl.hosts.get
+    #   listings = client.rbl.listings
+    def rbl
+      @rbl ||= RBL.new(@handler)
+    end
+
+    # Get the Contact management API namespace.
+    #
+    # The Contact namespace provides access to:
+    # - Contacts: Manage individual contacts
+    # - Groups: Manage contact groups
+    #
+    # @return [Contact] Contact namespace with endpoints for contacts and groups
+    #
+    # @example
+    #   contacts = client.contact.contacts.get
+    #   groups = client.contact.groups.get
+    def contact
+      @contact ||= Contact.new(@handler)
+    end
+
+    # Get the Certificate monitoring API namespace.
+    #
+    # The Cert namespace provides access to:
+    # - Monitors: Manage certificate monitors
+    # - Profiles: Manage certificate monitoring profiles
+    # - Errors: Retrieve current certificate errors
+    #
+    # @return [Cert] Cert namespace with endpoints for errors, monitors, and profiles
+    #
+    # @example
+    #   monitors = client.cert.monitors.get
+    #   errors = client.cert.errors.get
+    def cert
+      @cert ||= Cert.new(@handler)
+    end
+  end
+end

data/lib/generatorlabs/config.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+#
+# This file is part of the Generator Labs Ruby SDK package.
+#
+# (c) Generator Labs <support@generatorlabs.com>
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+
+module GeneratorLabs
+  # Configuration options for the Generator Labs API client.
+  #
+  # All fields are optional. If not provided, default values are used.
+  # Create a custom config to override timeouts, retry behavior, or API endpoint.
+  #
+  # @example Basic usage with defaults
+  #   config = GeneratorLabs::Config.new
+  #
+  # @example Custom timeouts and retries
+  #   config = GeneratorLabs::Config.new(
+  #     timeout: 45,
+  #     max_retries: 5,
+  #     retry_backoff: 2.0
+  #   )
+  #   client = GeneratorLabs::Client.new(account_sid, auth_token, config)
+  class Config
+    # @return [Integer] Request timeout in seconds (default: 30)
+    attr_accessor :timeout
+
+    # @return [Integer] Connection timeout in seconds (default: 5)
+    attr_accessor :connect_timeout
+
+    # @return [Integer] Maximum number of retry attempts (default: 3).
+    #   The SDK automatically retries on connection errors, 5xx server errors,
+    #   and 429 rate limit errors.
+    attr_accessor :max_retries
+
+    # @return [Float] Exponential backoff multiplier for retries (default: 1.0).
+    #   Each retry waits retry_backoff^attemptNum seconds.
+    #   Set to 2.0 for exponential backoff (1s, 2s, 4s, 8s, etc.)
+    attr_accessor :retry_backoff
+
+    # @return [String] Custom API base URL (default: "https://api.generatorlabs.com/4.0/").
+    #   Override this for testing or if using a proxy.
+    attr_accessor :base_url
+
+    # Initialize a new configuration.
+    #
+    # @param options [Hash] Configuration options
+    # @option options [Integer] :timeout Request timeout in seconds
+    # @option options [Integer] :connect_timeout Connection timeout in seconds
+    # @option options [Integer] :max_retries Maximum retry attempts
+    # @option options [Float] :retry_backoff Exponential backoff multiplier
+    # @option options [String] :base_url Custom API base URL
+    #
+    # @example
+    #   config = GeneratorLabs::Config.new(timeout: 60, max_retries: 5)
+    def initialize(options = {})
+      @timeout = options.fetch(:timeout, 30)
+      @connect_timeout = options.fetch(:connect_timeout, 5)
+      @max_retries = options.fetch(:max_retries, 3)
+      @retry_backoff = options.fetch(:retry_backoff, 1.0)
+      @base_url = options.fetch(:base_url, 'https://api.generatorlabs.com/4.0/')
+    end
+
+    # Create a default configuration with standard values.
+    #
+    # Returns a Config with:
+    # - timeout: 30 seconds
+    # - connect_timeout: 5 seconds
+    # - max_retries: 3
+    # - retry_backoff: 1.0
+    # - base_url: "https://api.generatorlabs.com/4.0/"
+    #
+    # @return [Config] Default configuration instance
+    #
+    # @example
+    #   config = GeneratorLabs::Config.default
+    def self.default
+      new
+    end
+  end
+end

data/lib/generatorlabs/contact.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+#
+# This file is part of the Generator Labs Ruby SDK package.
+#
+# (c) Generator Labs <support@generatorlabs.com>
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+
+module GeneratorLabs
+  # Contact management API namespace
+  class Contact
+    def initialize(handler)
+      @handler = handler
+    end
+
+    # Access contact management operations
+    # @return [Contacts]
+    def contacts
+      @contacts ||= Contacts.new(@handler)
+    end
+
+    # Access group management operations
+    # @return [Groups]
+    def groups
+      @groups ||= Groups.new(@handler)
+    end
+  end
+
+  # Contact management
+  class Contacts
+    def initialize(handler)
+      @handler = handler
+    end
+
+    # Get contacts (all, by ID, or by array of IDs)
+    # @param ids [nil, String, Integer, Hash, Array] Optional ID(s) or parameters
+    # @return [Hash] Contact data
+    def get(*ids)
+      return @handler.get('contact/contacts') if ids.empty?
+
+      # Check if first argument is a hash (parameters)
+      return @handler.get('contact/contacts', ids.first) if ids.first.is_a?(Hash)
+
+      return @handler.get("contact/contacts/#{ids.first}") if ids.length == 1
+
+      @handler.get('contact/contacts', { ids: ids.join(',') })
+    end
+
+    # Get all contacts with automatic pagination
+    # @param params [Hash] Optional parameters (e.g., page_size)
+    # @return [Array] All contacts across all pages
+    def get_all(params = {})
+      all_items = []
+      page = 1
+      params = params.dup
+
+      loop do
+        params[:page] = page
+        response = get(params)
+        contacts = response['contacts'] || []
+
+        all_items.concat(contacts)
+
+        break unless page < (response['total_pages'] || 1) && !contacts.empty?
+
+        page += 1
+      end
+
+      all_items
+    end
+
+    # Create a new contact
+    # @param params [Hash] Contact parameters
+    # @return [Hash] Created contact data
+    def create(params)
+      @handler.post('contact/contacts', params)
+    end
+
+    # Update a contact
+    # @param id [String, Integer] Contact ID
+    # @param params [Hash] Updated parameters
+    # @return [Hash] Updated contact data
+    def update(id, params)
+      @handler.put("contact/contacts/#{id}", params)
+    end
+
+    # Delete a contact
+    # @param id [String, Integer] Contact ID
+    # @return [Hash] Deletion confirmation
+    def delete(id)
+      @handler.delete("contact/contacts/#{id}")
+    end
+
+    # Pause a contact
+    # @param id [String, Integer] Contact ID
+    # @return [Hash] Response
+    def pause(id)
+      @handler.post("contact/contacts/#{id}/pause")
+    end
+
+    # Resume a contact
+    # @param id [String, Integer] Contact ID
+    # @return [Hash] Response
+    def resume(id)
+      @handler.post("contact/contacts/#{id}/resume")
+    end
+
+    # Confirm a contact with an auth code
+    # @param id [String, Integer] Contact ID
+    # @param params [Hash] Confirmation parameters (authcode)
+    # @return [Hash] Response
+    def confirm(id, params)
+      @handler.post("contact/contacts/#{id}/confirm", params)
+    end
+
+    # Resend confirmation to a contact
+    # @param id [String, Integer] Contact ID
+    # @return [Hash] Response
+    def resend(id)
+      @handler.post("contact/contacts/#{id}/resend")
+    end
+  end
+
+  # Group management
+  class Groups
+    def initialize(handler)
+      @handler = handler
+    end
+
+    # Get groups (all, by ID, or by array of IDs)
+    # @param ids [nil, String, Integer, Hash, Array] Optional ID(s) or parameters
+    # @return [Hash] Group data
+    def get(*ids)
+      return @handler.get('contact/groups') if ids.empty?
+
+      # Check if first argument is a hash (parameters)
+      return @handler.get('contact/groups', ids.first) if ids.first.is_a?(Hash)
+
+      return @handler.get("contact/groups/#{ids.first}") if ids.length == 1
+
+      @handler.get('contact/groups', { ids: ids.join(',') })
+    end
+
+    # Get all groups with automatic pagination
+    # @param params [Hash] Optional parameters (e.g., page_size)
+    # @return [Array] All groups across all pages
+    def get_all(params = {})
+      all_items = []
+      page = 1
+      params = params.dup
+
+      loop do
+        params[:page] = page
+        response = get(params)
+        groups = response['groups'] || []
+
+        all_items.concat(groups)
+
+        break unless page < (response['total_pages'] || 1) && !groups.empty?
+
+        page += 1
+      end
+
+      all_items
+    end
+
+    # Create a new contact group
+    # @param params [Hash] Group parameters
+    # @return [Hash] Created group data
+    def create(params)
+      @handler.post('contact/groups', params)
+    end
+
+    # Update a contact group
+    # @param id [String, Integer] Group ID
+    # @param params [Hash] Updated parameters
+    # @return [Hash] Updated group data
+    def update(id, params)
+      @handler.put("contact/groups/#{id}", params)
+    end
+
+    # Delete a contact group
+    # @param id [String, Integer] Group ID
+    # @return [Hash] Deletion confirmation
+    def delete(id)
+      @handler.delete("contact/groups/#{id}")
+    end
+  end
+end

data/lib/generatorlabs/rate_limit_info.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+#
+# This file is part of the Generator Labs Ruby SDK package.
+#
+# (c) Generator Labs <support@generatorlabs.com>
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+
+module GeneratorLabs
+  # Rate limit information from API response headers.
+  class RateLimitInfo
+    # @return [String] Active rate limit policies, e.g. "1000;w=3600, 100;w=1"
+    attr_reader :limit
+
+    # @return [Integer] Requests remaining in the most restrictive active window
+    attr_reader :remaining
+
+    # @return [Integer] Seconds until the most restrictive window resets
+    attr_reader :reset
+
+    def initialize(limit:, remaining:, reset:)
+      @limit = limit
+      @remaining = remaining
+      @reset = reset
+    end
+  end
+end