sendlayer 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcbeb3e895d3e5a69471af13feb2c2f85b02c6d8babda4e1417266caa848228d
-  data.tar.gz: e82bfac8473f5db810f7d465055b05ca0a92009eafc3c81204a97d0c143c9d00
+  metadata.gz: 1cc77f877b3aa02ffaed910ed8c3aa638e5bffb1cbbfc7079ad1081a5ab24a6a
+  data.tar.gz: ea8244c28c69a02113564abdf64dbae9628bd2e5ee64b4ca9d405721787c1859
 SHA512:
-  metadata.gz: aa169ec23cc27a318feac68e0de833b5c89b9e142406d5bcbe3c365b4961c2d487c4f470a05754f330aacc160dc1a66d3c6c6d95f8cf5aef63bfa30f58945ed5
-  data.tar.gz: fa2bdd5529ed366c76b1da611240eb4d026b7dfbec0776537fecd260a1c906ed4d3144f0f6e20314c2d07709fed281b848873f435d36de94d922e41f8170f7f1
+  metadata.gz: f204b10315d62fc5144119634c027eaac56c04be9cac92a850631ff67ea83dffe7c1d905bf4cf3d2b38f3ddfcbe56f0b610bbbf99a6ad83edda3577fd8c9b934
+  data.tar.gz: 1f4039edd2ade871eb665c10d0a4332e785ced3d92ce180220c83e337f0290316ce2c7229e97926fb95fb6e6e26b5036615b23c41ac446c59405ee3a329a30d5

data/.github/workflows/publish.yml

@@ -4,6 +4,13 @@ on:
   push:
     branches:
       - main
+  workflow_dispatch:
+    inputs:
+      skip_rubygems:
+        description: 'Skip RubyGems publishing'
+        required: false
+        default: 'true'
+        type: boolean
 
 permissions:
   contents: write
@@ -34,6 +41,7 @@ jobs:
   publish:
     needs: test
     runs-on: ubuntu-latest
+    if: ${{ !inputs.skip_rubygems || github.event_name == 'push' }}
 
     permissions:
       contents: write
@@ -54,7 +62,8 @@ jobs:
         uses: rubygems/release-gem@v1
 
   github-release:
-    needs: publish
+    needs: [test, publish]
+    if: always() && (needs.publish.result == 'skipped' || needs.publish.result == 'success')
     runs-on: ubuntu-latest
     steps:  
       - name: Checkout code
@@ -75,7 +84,7 @@ jobs:
       - name: Get version from VERSION file
         id: get_version
         run: |
-          VERSION=$(cat lib/sendlayer/version.rb | grep "VERSION = " | sed "s/VERSION = '\(.*\)'/\1/")
+          VERSION=$(ruby -e "require './lib/sendlayer/version'; puts SendLayer::VERSION.strip")
           echo "VERSION=$VERSION" >> $GITHUB_ENV
           echo "version=$VERSION" >> $GITHUB_OUTPUT
 

data/CHANGELOG.md

@@ -0,0 +1,69 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## [1.1.0](https://github.com/sendlayer/sendlayer-ruby/compare/v1.0.0...v1.1.0) (2026-08-25)
+
+Brings the Ruby SDK to parity with the PHP, Python and Node.js 1.1.0 releases.
+
+### Bug Fixes
+
+* Typed exceptions are no longer flattened to the base class. `make_request`
+  called `handle_response` *inside* its own `begin`/`rescue`, so the
+  `SendLayerAuthenticationError` (and every other typed error) raised there was
+  caught by the broad `rescue => e` and re-raised as
+  `SendLayerError.new("Network error: ...")`. Rescuing
+  `SendLayerAuthenticationError` could never match. Only the transport call is
+  guarded now.
+* `Emails#send` no longer discards the plain-text body when both `text` and
+  `html` are supplied. The payload used an `if`/`else` that could only ever emit
+  one of the two fields. Both `HTMLContent` and `PlainContent` are now sent, and
+  `ContentType` is reported as `HTML` whenever an HTML body is present.
+* API error messages are no longer discarded. The client read
+  `error_data['Error']`, but SendLayer returns errors as
+  `{"Errors": [{"Code": ..., "Message": ...}]}`, so every error surfaced a
+  hardcoded default instead of the API's own text. The 401 branch did not read
+  the response body at all. Multiple messages are joined with `; `.
+* Non-JSON error bodies no longer raise `JSON::ParserError` out of the SDK. An
+  HTML error page from a proxy now falls back to the HTTP reason phrase.
+* Undecodable *success* bodies now raise `SendLayerError` instead of
+  `JSON::ParserError`, which is not a `SendLayerError` and so escaped callers
+  rescuing the base type.
+* Connections now time out. `read_timeout` was set but `open_timeout` was not,
+  so a connection that never completed its handshake could hang past the
+  configured timeout.
+* Content consisting of an empty string is now rejected by validation, which
+  previously checked only for `nil` and would send an email with no body.
+
+### Features
+
+* Every exception now carries `status_code`, `response` and `errors`, along with
+  a `codes` helper for branching on SendLayer's numeric error codes. These
+  previously existed only on `SendLayerAPIError`, so reading them after
+  rescuing `SendLayerError` raised `NoMethodError` for every other type.
+* Added a `:headers` option for extra request headers. They are applied before
+  `Authorization`, so a caller cannot accidentally drop authentication.
+* `Client::ERROR_MAP` replaces the hand-rolled `case` chain, so status-to-error
+  mapping is declared in one place.
+
+### Documentation
+
+* Documented the exception attributes, the full exception table, the
+  `SendLayerAPIError` message prefix, and the 30-second default timeout.
+* Added a Configuration section and an explicit HTML-with-plain-text-fallback
+  example.
+
+### Breaking Changes
+
+* `500` maps to `SendLayerInternalServerError`, but other 5xx statuses
+  (502, 503, 504) now raise `SendLayerAPIError` rather than
+  `SendLayerInternalServerError`. This matches the Python and Node.js SDKs.
+  Rescue `SendLayerError` to catch both.
+* Passing `text: ''` or `html: ''` as the only content now raises
+  `SendLayerValidationError`.
+* `SendLayerError#message` is no longer backed by an `attr_reader`. It is
+  inherited from `StandardError`, so `e.message` behaves as before.
+
+## 1.0.0
+
+* Initial public release.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sendlayer (1.0.0)
+    sendlayer (1.1.0)
       mime-types (~> 3.4)
 
 GEM

data/README.md

@@ -10,7 +10,7 @@
 
 The official Ruby SDK for interacting with the SendLayer API, providing a simple and intuitive interface for sending emails, managing webhooks, and retrieving email events.
 
-[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE) [![Publish Ruby Gem](https://github.com/SendLayer/sendlayer-ruby/actions/workflows/publish.yml/badge.svg)](https://github.com/SendLayer/sendlayer-ruby/actions/workflows/publish.yml)
 
 ## Installation
 
@@ -83,6 +83,17 @@ response = sendlayer.emails.send(
   html: '<h1>Welcome!</h1><p>Welcome to our platform!</p>'
 )
 
+# HTML with a plain-text fallback -- supply both and both parts are sent.
+# ContentType is reported as HTML, and clients that cannot render HTML fall
+# back to the plain-text part.
+response = sendlayer.emails.send(
+  from: 'sender@example.com',
+  to: 'recipient@example.com',
+  subject: 'Welcome!',
+  html: '<h1>Welcome!</h1><p>Welcome to our platform!</p>',
+  text: 'Welcome! Welcome to our platform!'
+)
+
 # Complex email with multiple recipients and attachments
 response = sendlayer.emails.send(
   from: { email: 'sender@example.com', name: 'Sender' },
@@ -153,7 +164,16 @@ sendlayer.webhooks.delete(123)
 
 ## Error Handling
 
-The SDK provides specific exception types for different error scenarios:
+Every SendLayer exception carries the same attributes, so you can read them
+without first checking which subclass you rescued:
+
+| Attribute | Description |
+|---|---|
+| `message` | Human-readable message, taken from the API's own error text when available |
+| `status_code` | HTTP status of the response, or `nil` for local errors (timeouts, connection failures, validation) |
+| `response` | Decoded response body, or `{}` when unavailable |
+| `errors` | Raw SendLayer `Errors` entries, each with the API's numeric `Code` and `Message`; empty for local errors |
+| `codes` | Just the numeric codes from `errors`, for branching |
 
 ```ruby
 require 'sendlayer'
@@ -165,28 +185,68 @@ begin
     subject: 'Test Email',
     text: 'This is a test email'
   )
-rescue SendLayer::SendLayerAPIError => e
-  puts "API error: #{e.message} (Status: #{e.status_code})"
+rescue SendLayer::SendLayerAuthenticationError => e
+  puts "Check your API key: #{e.message}"
 rescue SendLayer::SendLayerValidationError => e
   puts "Validation error: #{e.message}"
-rescue SendLayer::SendLayerAuthenticationError => e
-  puts "Authentication error: #{e.message}"
+rescue SendLayer::SendLayerRateLimitError => e
+  puts "Slow down: #{e.message}"
+rescue SendLayer::SendLayerError => e
+  # Base type -- also catches timeouts, connection errors and any API error
+  # without a more specific type.
+  puts "SendLayer error: #{e.message} (status: #{e.status_code.inspect})"
+  puts "Codes: #{e.codes.inspect}"
+end
+```
+
+Branch on SendLayer's numeric error codes with `codes`:
+
+```ruby
 rescue SendLayer::SendLayerError => e
-  puts "SendLayer error: #{e.message}"
-rescue => e
-  puts "Unexpected error: #{e.message}"
+  puts 'That sender domain is not authorised.' if e.codes.include?(14)
 end
 ```
 
+See the [error code reference](https://developers.sendlayer.com/api-reference/error-codes)
+for the full list.
+
 ## Exception Types
 
-- `SendLayer::SendLayerError`: Base exception for all SendLayer errors
-- `SendLayer::SendLayerAPIError`: API-specific errors with status code and response data
-- `SendLayer::SendLayerAuthenticationError`: Invalid API key or authentication issues
-- `SendLayer::SendLayerValidationError`: Invalid parameters or validation errors
-- `SendLayer::SendLayerNotFoundError`: Resource not found (404 errors)
-- `SendLayer::SendLayerRateLimitError`: Rate limit exceeded (429 errors)
-- `SendLayer::SendLayerInternalServerError`: Server errors (5xx errors)
+| Exception | Raised for |
+|---|---|
+| `SendLayer::SendLayerError` | Base type for everything below, and for local errors: timeouts, connection failures and undecodable responses |
+| `SendLayer::SendLayerValidationError` | Invalid parameters (raised locally), and HTTP 400 / 422 |
+| `SendLayer::SendLayerAuthenticationError` | HTTP 401 -- invalid API key |
+| `SendLayer::SendLayerNotFoundError` | HTTP 404 |
+| `SendLayer::SendLayerRateLimitError` | HTTP 429 |
+| `SendLayer::SendLayerInternalServerError` | HTTP 500 |
+| `SendLayer::SendLayerAPIError` | Any other error status, including 5xx other than 500 |
+
+`SendLayerAPIError` is the only type whose `message` is prefixed -- it reads
+`API Error <status>: <message>`. Every other type carries the API's message
+unchanged.
+
+Requests time out after 30 seconds by default and raise `SendLayerError`. A
+`Net::HTTP` exception is never surfaced to the caller.
+
+## Configuration
+
+Pass an options hash as the second argument:
+
+```ruby
+sendlayer = SendLayer::SendLayer.new('your-api-key', {
+  timeout: 60,                      # seconds to wait for the API (default 30)
+  attachment_url_timeout: 45_000,   # ms to wait when fetching a remote attachment (default 30000)
+  headers: { 'X-Request-Id' => 'abc123' } # extra headers sent with every request
+})
+```
+
+| Option | Default | Description |
+|---|---|---|
+| `:timeout` | `30` | Seconds to wait for the API before raising `SendLayerError` |
+| `:attachment_url_timeout` | `30000` | Milliseconds to wait when downloading an attachment from a URL |
+| `:headers` | `{}` | Extra request headers. Cannot override `Authorization` |
+| `:base_url` | SendLayer API v1 | Override the API base URL |
 
 ## Supported Events
 

data/lib/sendlayer/client.rb

@@ -3,96 +3,184 @@ require 'uri'
 require 'json'
 require 'timeout'
 
+require_relative 'version'
+require_relative 'exceptions'
+
 module SendLayer
   class Client
-    BASE_URL = 'https://console.sendlayer.com/api/v1/'
-    
+    BASE_URL = 'https://console.sendlayer.com/api/v1/'.freeze
+
+    # Seconds to wait for the API before giving up.
+    DEFAULT_TIMEOUT = 30
+
+    # HTTP status => [error class, fallback message used when the API response
+    # carries no message of its own].
+    ERROR_MAP = {
+      400 => [SendLayerValidationError,     'Invalid request parameters'],
+      401 => [SendLayerAuthenticationError, 'Invalid API key'],
+      404 => [SendLayerNotFoundError,       'Resource not found'],
+      422 => [SendLayerValidationError,     'Unprocessable Entity'],
+      429 => [SendLayerRateLimitError,      'Rate limit exceeded'],
+      500 => [SendLayerInternalServerError, 'Internal server error']
+    }.freeze
+
     attr_reader :api_key, :base_url, :timeout, :attachment_url_timeout
 
     def initialize(api_key, options = {})
       @api_key = api_key
       @base_url = options[:base_url] || BASE_URL
-      @timeout = options[:timeout] || 30
-      @attachment_url_timeout = options[:attachment_url_timeout] || 30000
+      @timeout = options[:timeout] || DEFAULT_TIMEOUT
+      @attachment_url_timeout = options[:attachment_url_timeout] || 30_000
+      @headers = options[:headers] || {}
     end
 
+    # Make a request to the SendLayer API.
+    #
+    # Always returns a Hash/Array or raises a SendLayerError -- a Net::HTTP
+    # exception is never surfaced to the caller.
     def make_request(method, endpoint, data = nil, params = {})
       uri = URI("#{@base_url}#{endpoint}")
-      
-      # Add query parameters
-      unless params.empty?
-        uri.query = URI.encode_www_form(params)
-      end
+      uri.query = URI.encode_www_form(params) unless params.empty?
 
       http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
+      # Derived from the URI rather than forced on, so an http:// base_url
+      # (a local test server, say) is actually usable.
+      http.use_ssl = uri.scheme == 'https'
       http.read_timeout = @timeout
+      # A connection that never completes its handshake would otherwise hang
+      # past read_timeout, which only covers waiting for the response body.
+      http.open_timeout = @timeout
 
-      case method.upcase
-      when 'GET'
-        request = Net::HTTP::Get.new(uri)
-      when 'POST'
-        request = Net::HTTP::Post.new(uri)
-        request.body = data.to_json if data
-        request['Content-Type'] = 'application/json'
-      when 'DELETE'
-        request = Net::HTTP::Delete.new(uri)
-      else
-        raise SendLayerError.new("Unsupported HTTP method: #{method}")
-      end
+      request = build_request(method, uri, data)
 
-      request['Authorization'] = "Bearer #{@api_key}"
-      request['User-Agent'] = "SendLayer-Ruby/#{::SendLayer::VERSION}"
+      # Only the transport call is guarded. handle_response runs outside this
+      # block so the typed error it raises is not caught and re-wrapped as a
+      # generic "Connection error" -- which previously flattened every API
+      # error to the base SendLayerError.
+      response =
+        begin
+          http.request(request)
+        rescue Timeout::Error
+          raise SendLayerError.new("Request timed out after #{@timeout}s")
+        rescue StandardError => e
+          raise SendLayerError.new("Connection error: #{e.message}")
+        end
 
-      begin
-        response = http.request(request)
-        handle_response(response)
-      rescue Timeout::Error
-        raise SendLayerError.new("Request timeout after #{@timeout} seconds")
-      rescue => e
-        raise SendLayerError.new("Network error: #{e.message}")
-      end
+      handle_response(response)
     end
 
     private
 
+    def build_request(method, uri, data)
+      request =
+        case method.to_s.upcase
+        when 'GET'    then Net::HTTP::Get.new(uri)
+        when 'DELETE' then Net::HTTP::Delete.new(uri)
+        when 'POST'
+          req = Net::HTTP::Post.new(uri)
+          req.body = data.to_json if data
+          req['Content-Type'] = 'application/json'
+          req
+        else
+          raise SendLayerError.new("Unsupported HTTP method: #{method}")
+        end
+
+      request['User-Agent'] = "SendLayer-Ruby/#{::SendLayer::VERSION}"
+      @headers.each { |key, value| request[key.to_s] = value }
+      # Applied after the caller's headers so those cannot drop authentication.
+      request['Authorization'] = "Bearer #{@api_key}"
+      request
+    end
+
     def handle_response(response)
-      case response.code.to_i
-      when 200..299
-        return JSON.parse(response.body) if response.body && !response.body.empty?
-        return {}
-      when 401
-        raise SendLayerAuthenticationError.new("Invalid API key")
-      when 400
-        error_data = parse_error_response(response)
-        raise SendLayerValidationError.new(error_data['Error'] || 'Invalid request parameters')
-      when 404
-        error_data = parse_error_response(response)
-        raise SendLayerNotFoundError.new(error_data['Error'] || 'Resource not found')
-      when 422
-        error_data = parse_error_response(response)
-        raise SendLayerValidationError.new(error_data['Error'] || 'Validation failed')
-      when 429
-        error_data = parse_error_response(response)
-        raise SendLayerRateLimitError.new(error_data['Error'] || 'Rate limit exceeded')
-      when 500..599
-        error_data = parse_error_response(response)
-        raise SendLayerInternalServerError.new(error_data['Error'] || 'Internal server error')
-      else
-        error_data = parse_error_response(response)
-        raise SendLayerAPIError.new(
-          error_data['Error'] || "HTTP #{response.code} error",
-          response.code.to_i,
-          response.body
-        )
+      status = response.code.to_i
+      return parse_success(response, status) if status.between?(200, 299)
+
+      raise build_error(response, status)
+    end
+
+    def parse_success(response, status)
+      # Successful responses with no body (e.g. 204 No Content) decode to {}
+      # rather than raising out of JSON.parse.
+      body = response.body
+      return {} if body.nil? || body.empty?
+
+      data =
+        begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          raise SendLayerError.new('Invalid JSON response from API', status)
+        end
+
+      data.is_a?(Hash) || data.is_a?(Array) ? data : {}
+    end
+
+    # Map an error response onto the appropriate SendLayer error.
+    def build_error(response, status)
+      data = parse_body(response)
+      errors = extract_errors(data)
+      error_class, default = ERROR_MAP[status]
+
+      unless error_class
+        default = status.between?(500, 599) ? 'Server error' : 'API request failed'
+        return SendLayerAPIError.new(extract_message(data, default), status, data, errors)
       end
+
+      error_class.new(extract_message(data, default), status, data, errors)
+    end
+
+    # Decode an error response body.
+    #
+    # Falls back to the HTTP reason phrase when the body isn't JSON, so an HTML
+    # error page from a proxy still produces a usable message instead of raising
+    # a JSON::ParserError out of the SDK.
+    def parse_body(response)
+      data =
+        begin
+          response.body.nil? || response.body.empty? ? nil : JSON.parse(response.body)
+        rescue JSON::ParserError
+          nil
+        end
+
+      return data if data.is_a?(Hash)
+
+      { 'Error' => reason_phrase(response) }
     end
 
-    def parse_error_response(response)
-      return {} unless response.body
-      JSON.parse(response.body)
-    rescue JSON::ParserError
-      { 'Error' => response.body }
+    def reason_phrase(response)
+      phrase = response.message
+      phrase.nil? || phrase.empty? ? 'Unknown error' : phrase
+    end
+
+    # Normalize the SendLayer +Errors+ array from a decoded body.
+    #
+    # SendLayer returns errors as:
+    #
+    #   {"Errors": [{"Code": 14, "Message": "..."}]}
+    #
+    # Returns an empty array when absent or malformed.
+    def extract_errors(data)
+      raw = data['Errors']
+      return [] unless raw.is_a?(Array)
+
+      raw.select { |entry| entry.is_a?(Hash) }
+    end
+
+    # Build a message from the API response, preferring its own text.
+    #
+    # Joins multiple +Errors+ messages with "; ", then falls back to the
+    # singular +Error+ key, then to +default+.
+    def extract_message(data, default)
+      parts = extract_errors(data).filter_map do |entry|
+        message = entry['Message']
+        message.to_s unless message.nil? || message.to_s.empty?
+      end
+      return parts.join('; ') unless parts.empty?
+
+      error = data['Error']
+      return error if error.is_a?(String) && !error.empty?
+
+      default
     end
   end
 end

data/lib/sendlayer/emails.rb

@@ -19,10 +19,15 @@ module SendLayer
 
     def send(from:, to:, subject:, text: nil, html: nil, cc: nil, bcc: nil, reply_to: nil,
              attachments: nil, headers: nil, tags: nil)
-      
+
+      # Empty strings are treated as absent, so a caller passing text: '' gets a
+      # validation error rather than an email with no body.
+      has_html = !html.nil? && html != ''
+      has_text = !text.nil? && text != ''
+
       # Validate required parameters
-      raise SendLayerValidationError.new("Either 'text' or 'html' content must be provided") if text.nil? && html.nil?
-      
+      raise SendLayerValidationError.new("Either 'text' or 'html' content must be provided") unless has_html || has_text
+
       # Prepare email data
       email_data = {
         From: normalize_recipient(from, 'sender'),
@@ -30,13 +35,12 @@ module SendLayer
         Subject: subject
       }
 
-      if html
-        email_data[:ContentType] = "HTML"
-        email_data[:HTMLContent] = html
-      else
-        email_data[:ContentType] = "Text"
-        email_data[:PlainContent] = text
-      end
+      # Both parts are sent when both are supplied. The previous if/else could
+      # only ever emit one of them, which silently dropped the plain-text part.
+      # HTML wins for the declared content type whenever an HTML body is present.
+      email_data[:ContentType] = has_html ? 'HTML' : 'Text'
+      email_data[:HTMLContent] = html if has_html
+      email_data[:PlainContent] = text if has_text
       email_data[:CC] = normalize_recipients(cc) if cc
       email_data[:BCC] = normalize_recipients(bcc) if bcc
       email_data[:ReplyTo] = normalize_recipients(reply_to, 'reply_to') if reply_to
@@ -77,7 +81,7 @@ module SendLayer
 
     def normalize_recipients(recipients, role = 'recipient')
       return nil if recipients.nil?
-      
+
       case recipients
       when String
         [normalize_recipient(recipients, role)]

data/lib/sendlayer/exceptions.rb

@@ -1,20 +1,38 @@
 module SendLayer
+  # Base error for the SendLayer SDK.
+  #
+  # Every SendLayer error carries the same attributes, so callers can read them
+  # without first checking which subclass they rescued:
+  #
+  # - +status_code+ HTTP status of the response, or nil for local errors
+  # - +response+    decoded response body, or {} when unavailable
+  # - +errors+      raw SendLayer +Errors+ entries, each with the API's numeric
+  #                 +Code+ and +Message+; empty for local errors and for
+  #                 responses that aren't in that shape
   class SendLayerError < StandardError
-    attr_reader :message
+    attr_reader :status_code, :response, :errors
 
-    def initialize(message)
-      @message = message
+    def initialize(message = '', status_code = nil, response = nil, errors = nil)
+      @status_code = status_code
+      @response = response.nil? ? {} : response
+      @errors = errors.nil? ? [] : errors
       super(message)
     end
+
+    # Numeric SendLayer error codes carried by this error, for branching:
+    # <tt>if err.codes.include?(14)</tt>.
+    #
+    # See https://developers.sendlayer.com/api-reference/error-codes
+    def codes
+      @errors.filter_map { |entry| entry['Code'] if entry.is_a?(Hash) && entry.key?('Code') }
+    end
   end
 
+  # Raised for API errors not covered by a more specific type.
   class SendLayerAPIError < SendLayerError
-    attr_reader :status_code, :response
-
-    def initialize(message, status_code = nil, response = nil)
-      @status_code = status_code
-      @response = response
-      super(message)
+    def initialize(message, status_code = nil, response = nil, errors = nil)
+      # Historical string form keeps the status prefix.
+      super("API Error #{status_code}: #{message}", status_code, response, errors)
     end
   end
 

data/lib/sendlayer/version.rb

@@ -1,3 +1,3 @@
 module SendLayer
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/sendlayer/webhooks.rb

@@ -8,7 +8,7 @@ module SendLayer
 
     def create(url:, event:)
       validate_webhook_params(url, event)
-      
+
       webhook_data = {
         WebhookURL: url,
         Event: event
@@ -21,9 +21,9 @@ module SendLayer
       @client.make_request('GET', 'webhooks')
     end
 
-  def delete(webhook_id)
+    def delete(webhook_id)
       raise SendLayerValidationError.new("Webhook ID is required") if webhook_id.nil?
-      
+
       unless webhook_id.is_a?(Integer) && webhook_id > 0
         raise SendLayerValidationError.new("Webhook ID must be a positive integer")
       end
@@ -36,7 +36,7 @@ module SendLayer
     def validate_webhook_params(url, event)
       raise SendLayerValidationError.new("URL is required") if url.nil? || url.empty?
       raise SendLayerValidationError.new("Event is required") if event.nil? || event.empty?
-      
+
       unless VALID_EVENTS.include?(event)
         raise SendLayerValidationError.new("Invalid event: #{event}. Valid event types include: #{VALID_EVENTS.join(', ')}")
       end

data/lib/sendlayer.rb

@@ -1,14 +1,22 @@
 require_relative 'sendlayer/version'
+# Loaded before the client: Client::ERROR_MAP resolves these classes at
+# class-definition time, so they must already exist.
+require_relative 'sendlayer/exceptions'
 require_relative 'sendlayer/client'
 require_relative 'sendlayer/emails'
 require_relative 'sendlayer/webhooks'
 require_relative 'sendlayer/events'
-require_relative 'sendlayer/exceptions'
 
 module SendLayer
   class SendLayer
     attr_reader :emails, :webhooks, :events
 
+    # Initialize the SDK.
+    #
+    # @param api_key [String] Your SendLayer API key.
+    # @param options [Hash] Optional settings forwarded to the underlying
+    #   client: +:timeout+ (seconds, default 30), +:attachment_url_timeout+
+    #   (milliseconds), +:headers+ (extra request headers) and +:base_url+.
     def initialize(api_key, options = {})
       @client = Client.new(api_key, options)
       @emails = Emails.new(@client)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sendlayer
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - SendLayer
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-09 00:00:00.000000000 Z
+date: 2026-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types
@@ -121,6 +121,7 @@ files:
 - ".github/workflows/publish.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE