sendlayer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fcbeb3e895d3e5a69471af13feb2c2f85b02c6d8babda4e1417266caa848228d
+  data.tar.gz: e82bfac8473f5db810f7d465055b05ca0a92009eafc3c81204a97d0c143c9d00
+SHA512:
+  metadata.gz: aa169ec23cc27a318feac68e0de833b5c89b9e142406d5bcbe3c365b4961c2d487c4f470a05754f330aacc160dc1a66d3c6c6d95f8cf5aef63bfa30f58945ed5
+  data.tar.gz: fa2bdd5529ed366c76b1da611240eb4d026b7dfbec0776537fecd260a1c906ed4d3144f0f6e20314c2d07709fed281b848873f435d36de94d922e41f8170f7f1

data/.env.example

@@ -0,0 +1,3 @@
+# SendLayer API Key
+# Get your API key from https://app.sendlayer.com
+SENDLAYER_API_KEY=your-api-key-here

data/.github/workflows/publish.yml

@@ -0,0 +1,101 @@
+name: Publish Ruby Gem
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2'
+
+      - name: Install dependencies
+        run: |
+          gem install bundler
+          bundle install
+
+      - name: Run tests
+        run: bundle exec rspec
+
+      # - name: Run RuboCop
+      #   run: bundle exec rubocop
+  
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: '3.2'
+
+      - name: Publish to RubyGems
+        uses: rubygems/release-gem@v1
+
+  github-release:
+    needs: publish
+    runs-on: ubuntu-latest
+    steps:  
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2'
+
+      - name: Install dependencies
+        run: |
+          gem install bundler
+          bundle install
+
+      - name: Get version from VERSION file
+        id: get_version
+        run: |
+          VERSION=$(cat lib/sendlayer/version.rb | grep "VERSION = " | sed "s/VERSION = '\(.*\)'/\1/")
+          echo "VERSION=$VERSION" >> $GITHUB_ENV
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Create and push tag
+        run: |
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git tag -a v${{ env.VERSION }} -m "Release v${{ env.VERSION }}"
+          git push origin v${{ env.VERSION }}
+
+      - name: Build gem
+        run: gem build sendlayer.gemspec
+
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: v${{ steps.get_version.outputs.version }}
+          name: Release v${{ steps.get_version.outputs.version }}
+          files: sendlayer-${{ steps.get_version.outputs.version }}.gem
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle
+/public/assets
+.env
+/coverage
+
+*.gem
+*.gem.lock
+
+
+/spec/examples.txt

data/.rubocop.yml

@@ -0,0 +1,27 @@
+AllCops:
+  TargetRubyVersion: 2.7
+  NewCops: enable
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 20
+
+Metrics/AbcSize:
+  Max: 20
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/WordArray:
+  MinSize: 3

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in sendlayer.gemspec
+gemspec
+
+group :development, :test do
+  gem "pry", "~> 0.14"
+  gem "pry-byebug", "~> 3.10"
+end

data/Gemfile.lock

@@ -0,0 +1,106 @@
+PATH
+  remote: .
+  specs:
+    sendlayer (1.0.0)
+      mime-types (~> 3.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    ast (2.4.3)
+    bigdecimal (3.3.0)
+    byebug (12.0.0)
+    coderay (1.1.3)
+    crack (1.0.0)
+      bigdecimal
+      rexml
+    diff-lcs (1.6.2)
+    docile (1.4.1)
+    hashdiff (1.2.1)
+    json (2.15.1)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    method_source (1.1.0)
+    mime-types (3.7.0)
+      logger
+      mime-types-data (~> 3.2025, >= 3.2025.0507)
+    mime-types-data (3.2025.0924)
+    parallel (1.27.0)
+    parser (3.3.9.0)
+      ast (~> 2.4.1)
+      racc
+    prism (1.5.1)
+    pry (0.15.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.11.0)
+      byebug (~> 12.0)
+      pry (>= 0.13, < 0.16)
+    public_suffix (6.0.2)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.3.0)
+    regexp_parser (2.11.3)
+    rexml (3.4.4)
+    rspec (3.13.1)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.5)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.6)
+    rubocop (1.81.1)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.47.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.47.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    ruby-progressbar (1.13.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.13.2)
+    simplecov_json_formatter (0.1.4)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.1.0)
+    webmock (3.25.1)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  arm64-darwin-22
+  x86_64-linux
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  pry (~> 0.14)
+  pry-byebug (~> 3.10)
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.0)
+  sendlayer!
+  simplecov (~> 0.21)
+  webmock (~> 3.0)
+
+BUNDLED WITH
+   2.4.19

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SendLayer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,222 @@
+<a href="https://sendlayer.com">
+<picture>
+  <source media="(prefers-color-scheme: light)" srcset="https://sendlayer.com/wp-content/themes/sendlayer-theme/assets/images/svg/logo-dark.svg">
+  <source media="(prefers-color-scheme: dark)" srcset="https://sendlayer.com/wp-content/themes/sendlayer-theme/assets/images/svg/logo-light.svg">
+  <img alt="SendLayer Logo" width="200px" src="https://sendlayer.com/wp-content/themes/sendlayer-theme/assets/images/svg/logo-light.svg">
+</picture>
+</a>
+
+### SendLayer Ruby SDK
+
+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)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sendlayer'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install sendlayer
+```
+
+## Quick Start
+
+```ruby
+require 'sendlayer'
+
+# Initialize the SDK
+sendlayer = SendLayer::SendLayer.new('your-api-key')
+
+# Send an email
+response = sendlayer.emails.send(
+  from: 'sender@example.com',
+  to: 'recipient@example.com',
+  subject: 'Test Email',
+  text: 'This is a test email'
+)
+
+puts "Email sent! Message ID: #{response['MessageID']}"
+```
+
+## Features
+
+- **Email Module**: Send emails with HTML/text content, attachments, CC/BCC, reply-to, custom headers, and tags
+- **Webhooks Module**: Create, retrieve, and delete webhooks for various email events
+- **Events Module**: Retrieve email events with filtering options
+- **Error Handling**: Clear, typed errors for API and validation issues
+
+## Email
+
+Send emails using the `SendLayer` client:
+
+```ruby
+require 'sendlayer'
+
+sendlayer = SendLayer::SendLayer.new('your-api-key')
+
+# Simple email
+response = sendlayer.emails.send(
+  from: 'sender@example.com',
+  to: 'recipient@example.com',
+  subject: 'Welcome!',
+  text: 'Welcome to our platform!'
+)
+
+# HTML email with sender name
+response = sendlayer.emails.send(
+  from: { email: 'sender@example.com', name: 'Paulie Paloma' },
+  to: 'recipient@example.com',
+  subject: 'Welcome!',
+  html: '<h1>Welcome!</h1><p>Welcome to our platform!</p>'
+)
+
+# Complex email with multiple recipients and attachments
+response = sendlayer.emails.send(
+  from: { email: 'sender@example.com', name: 'Sender' },
+  to: [
+    { email: 'recipient1@example.com', name: 'Recipient 1' },
+    { email: 'recipient2@example.com', name: 'Recipient 2' }
+  ],
+  subject: 'Complex Email',
+  text: 'Plain text fallback',
+  html: '<p>This is a <strong>test email</strong>!</p>',
+  cc: [{ email: 'cc@example.com', name: 'CC' }],
+  bcc: [{ email: 'bcc@example.com', name: 'BCC' }],
+  reply_to: [{ email: 'reply@example.com', name: 'Reply' }],
+  attachments: [
+    { path: 'path/to/file.pdf', type: 'application/pdf' }
+  ],
+  headers: { 'X-Custom-Header' => 'value' },
+  tags: ['tag1', 'tag2']
+)
+```
+
+## Events
+
+```ruby
+require 'sendlayer'
+require 'time'
+
+sendlayer = SendLayer::SendLayer.new('your-api-key')
+
+# Get all events
+all_events = sendlayer.events.get
+puts "Total events: #{all_events['TotalRecords']}"
+
+# Get filtered events (last 24 hours, opened)
+end_time = Time.now
+start_time = end_time - (24 * 60 * 60) # 24 hours ago
+
+filtered_events = sendlayer.events.get(
+  start_date: start_time,
+  end_date: end_time,
+  event: 'opened'
+)
+
+puts "Filtered events: #{filtered_events['TotalRecords']}"
+```
+
+## Webhooks
+
+```ruby
+require 'sendlayer'
+
+sendlayer = SendLayer::SendLayer.new('your-api-key')
+
+# Create a webhook
+webhook = sendlayer.webhooks.create(
+  url: 'https://your-domain.com/webhook',
+  event: 'open'
+)
+puts "Webhook created: #{webhook['WebhookID']}"
+
+# Get all webhooks
+webhooks = sendlayer.webhooks.get
+puts "Webhooks: #{webhooks}"
+
+# Delete a webhook
+sendlayer.webhooks.delete(123)
+```
+
+## Error Handling
+
+The SDK provides specific exception types for different error scenarios:
+
+```ruby
+require 'sendlayer'
+
+begin
+  response = sendlayer.emails.send(
+    from: 'sender@example.com',
+    to: 'recipient@example.com',
+    subject: 'Test Email',
+    text: 'This is a test email'
+  )
+rescue SendLayer::SendLayerAPIError => e
+  puts "API error: #{e.message} (Status: #{e.status_code})"
+rescue SendLayer::SendLayerValidationError => e
+  puts "Validation error: #{e.message}"
+rescue SendLayer::SendLayerAuthenticationError => e
+  puts "Authentication error: #{e.message}"
+rescue SendLayer::SendLayerError => e
+  puts "SendLayer error: #{e.message}"
+rescue => e
+  puts "Unexpected error: #{e.message}"
+end
+```
+
+## 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)
+
+## Supported Events
+
+### Webhook Events
+- `bounce`: Email bounced
+- `click`: Link was clicked
+- `open`: Email was opened
+- `unsubscribe`: User unsubscribed
+- `complaint`: User marked as spam
+- `delivery`: Email was delivered
+
+### Event Tracking Events
+- `accepted`: Email was accepted by the server
+- `rejected`: Email was rejected
+- `delivered`: Email was delivered
+- `opened`: Email was opened
+- `clicked`: Link was clicked
+- `unsubscribed`: User unsubscribed
+- `complained`: User marked as spam
+- `failed`: Email delivery failed
+
+## Requirements
+
+- Ruby 2.7.0 or higher
+- mime-types gem
+
+## More Details
+
+To learn more about using the SendLayer SDK, be sure to check our [Developer Documentation](https://developers.sendlayer.com/sdks/ruby).
+
+## License
+
+MIT License - see [LICENSE](./LICENSE) file for details

data/Rakefile

@@ -0,0 +1,29 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+RuboCop::RakeTask.new
+
+task default: [:spec, :rubocop]
+
+desc 'Run all tests and code quality checks'
+task ci: [:spec, :rubocop]
+
+desc 'Build the gem'
+task :build do
+  sh 'gem build sendlayer.gemspec'
+end
+
+desc 'Install the gem locally'
+task install: :build do
+  sh 'gem install sendlayer-*.gem'
+end
+
+desc 'Clean up generated files'
+task :clean do
+  sh 'rm -f sendlayer-*.gem'
+  sh 'rm -rf coverage/'
+  sh 'rm -rf .rspec_status'
+end

data/examples/events.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+require 'sendlayer'
+
+# Initialize the SDK
+api_key = ENV['SENDLAYER_API_KEY']
+unless api_key
+  puts "Please set SENDLAYER_API_KEY environment variable"
+  exit 1
+end
+
+sendlayer = SendLayer::SendLayer.new(api_key)
+
+begin
+  # Get all events
+  puts "Retrieving all events..."
+  all_events = sendlayer.events.get
+  puts "✅ Retrieved events successfully!"
+  puts "Total events: #{all_events}"
+
+  # Get filtered events (last 7 days)
+  puts "\nRetrieving events from the last 7 days..."
+  end_time = Time.now
+  start_time = end_time - (7 * 24 * 60 * 60) # 7 days ago
+
+  filtered_events = sendlayer.events.get(
+    start_date: start_time,
+    end_date: end_time
+  )
+  puts "✅ Retrieved filtered events successfully!"
+  puts "Events in last 7 days: #{filtered_events['Events']}"
+
+  # Get specific event type (opened)
+  puts "\nRetrieving 'opened' events from the last 24 hours..."
+  end_time = Time.now
+  start_time = end_time - (24 * 60 * 60) # 24 hours ago
+
+  opened_events = sendlayer.events.get(
+    start_date: start_time,
+    end_date: end_time,
+    event: 'opened'
+  )
+  puts "✅ Retrieved 'opened' events successfully!"
+  puts "Opened events in last 24 hours: #{opened_events['TotalRecords']}"
+
+  # Display some sample events
+  if all_events['Events'] && !all_events['Events'].empty?
+    puts "\nSample events:"
+    all_events['Events'].first(3).each_with_index do |event, index|
+      puts "  #{index + 1}. Event: #{event['Event']}, MessageID: #{event['MessageID']}, Timestamp: #{event['Timestamp']}"
+    end
+  end
+
+rescue SendLayer::SendLayerError => e
+  puts "❌ SendLayer Error: #{e.message}"
+rescue => e
+  puts "❌ Unexpected Error: #{e.message}"
+end

data/examples/send_email.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'sendlayer'
+
+
+# Initialize the SDK
+api_key = ENV['SENDLAYER_API_KEY']
+unless api_key
+  puts "Please set SENDLAYER_API_KEY environment variable"
+  exit 1
+end
+
+sendlayer = SendLayer::SendLayer.new(api_key)
+
+begin
+  # Send a simple email
+  puts "Sending a simple email..."
+  response = sendlayer.emails.send(
+    from: 'paulie@example.com',
+    to: 'pattie@example.com',
+    subject: 'Ruby SDK Test Email',
+    text: 'This is a test email sent using the SendLayer Ruby SDK!'
+  )
+  puts "✅ Email sent successfully!"
+  puts "Message ID: #{response}"
+
+  # Send an HTML email with sender name
+  puts "\nSending an HTML email..."
+  response = sendlayer.emails.send(
+    from: { email: 'paulie@example.com', name: 'Paulie Paloma' },
+    to: [
+      {name: 'Pattie Paloma', email:'pattie@example.com'},
+      {name: 'John Doe', email:'john@example.com'}
+    ],
+    subject: 'HTML Email Test',
+    html: '<h1>Hello from Ruby!</h1><p>This is an <strong>HTML</strong> email sent using the SendLayer Ruby SDK.</p>',
+    text: 'Hello from Ruby! This is an HTML email sent using the SendLayer Ruby SDK.',
+    attachments: [
+      {
+        path: './path/to/attachment.pdf',
+        type: 'application/pdf'
+      },
+      { 
+        path: 'https://placehold.co/600x400.png',
+        type: 'image/png'
+      }
+    ]
+  )
+  puts "✅ HTML email sent successfully!"
+  puts "Message ID: #{response}"
+
+rescue SendLayer::SendLayerError => e
+  puts "❌ SendLayer Error: #{e.message}"
+rescue => e
+  puts "❌ Unexpected Error: #{e.message}"
+end

data/examples/webhooks.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'sendlayer'
+
+# Initialize the SDK
+api_key = ENV['SENDLAYER_API_KEY']
+unless api_key
+  puts "Please set SENDLAYER_API_KEY environment variable"
+  exit 1
+end
+
+sendlayer = SendLayer::SendLayer.new(api_key)
+
+begin
+  # Create a webhook
+  puts "Creating a webhook..."
+  webhook = sendlayer.webhooks.create(
+    url: 'https://example.com/webhook',
+    event: 'open'
+  )
+  puts "✅ Webhook created successfully!"
+  puts "Webhook ID: #{webhook}"
+
+  # Get all webhooks
+  puts "\nRetrieving all webhooks..."
+  webhooks = sendlayer.webhooks.get
+  puts "✅ Retrieved #{webhooks.length} webhook(s)"
+  webhooks.each_with_index do |webhook, index|
+    puts " Webhooks:  #{webhooks}"
+  end
+
+  # Delete the webhook we just created
+  # if webhook['WebhookID']
+  puts "\nDeleting webhook..."
+  sendlayer.webhooks.delete(27712)
+  puts "✅ Webhook deleted successfully!"
+  # end
+
+rescue SendLayer::SendLayerError => e
+  puts "❌ SendLayer Error: #{e.message}"
+rescue => e
+  puts "❌ Unexpected Error: #{e.message}"
+end

data/lib/sendlayer/client.rb

@@ -0,0 +1,98 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'timeout'
+
+module SendLayer
+  class Client
+    BASE_URL = 'https://console.sendlayer.com/api/v1/'
+    
+    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
+    end
+
+    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
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.read_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['Authorization'] = "Bearer #{@api_key}"
+      request['User-Agent'] = "SendLayer-Ruby/#{::SendLayer::VERSION}"
+
+      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
+    end
+
+    private
+
+    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
+        )
+      end
+    end
+
+    def parse_error_response(response)
+      return {} unless response.body
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      { 'Error' => response.body }
+    end
+  end
+end

data/lib/sendlayer/emails.rb

@@ -0,0 +1,183 @@
+require 'net/http'
+require 'uri'
+require 'base64'
+require 'securerandom'
+
+# Optional dependency for MIME type detection
+begin
+  require 'mime/types'
+  MIME_TYPES_AVAILABLE = true
+rescue LoadError
+  MIME_TYPES_AVAILABLE = false
+end
+
+module SendLayer
+  class Emails
+    def initialize(client)
+      @client = client
+    end
+
+    def send(from:, to:, subject:, text: nil, html: nil, cc: nil, bcc: nil, reply_to: nil,
+             attachments: nil, headers: nil, tags: nil)
+      
+      # Validate required parameters
+      raise SendLayerValidationError.new("Either 'text' or 'html' content must be provided") if text.nil? && html.nil?
+      
+      # Prepare email data
+      email_data = {
+        From: normalize_recipient(from, 'sender'),
+        To: normalize_recipients(to, 'recipient'),
+        Subject: subject
+      }
+
+      if html
+        email_data[:ContentType] = "HTML"
+        email_data[:HTMLContent] = html
+      else
+        email_data[:ContentType] = "Text"
+        email_data[:PlainContent] = text
+      end
+      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
+      email_data[:Headers] = headers if headers
+
+      if tags
+        unless tags.is_a?(Array) && tags.all? { |t| t.is_a?(String) }
+          raise SendLayerValidationError.new('Tags must be a list of strings')
+        end
+        email_data[:Tags] = tags
+      end
+
+      # Handle attachments
+      if attachments && !attachments.empty?
+        email_data[:Attachments] = process_attachments(attachments)
+      end
+
+      @client.make_request('POST', 'email', email_data)
+    end
+
+    private
+
+    def normalize_recipient(recipient, role = 'recipient')
+      case recipient
+      when String
+        validate_email(recipient, role)
+        { email: recipient }
+      when Hash
+        validate_email(recipient[:email] || recipient['email'], role)
+        {
+          email: recipient[:email] || recipient['email'],
+          name: recipient[:name] || recipient['name']
+        }.compact
+      else
+        raise SendLayerValidationError.new("Invalid #{role} format: #{recipient.class}")
+      end
+    end
+
+    def normalize_recipients(recipients, role = 'recipient')
+      return nil if recipients.nil?
+      
+      case recipients
+      when String
+        [normalize_recipient(recipients, role)]
+      when Array
+        recipients.map { |r| normalize_recipient(r, role) }
+      else
+        raise SendLayerValidationError.new("Invalid #{role}s format: #{recipients.class}")
+      end
+    end
+
+    def validate_email(email, role = 'recipient')
+      email_regex = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
+      unless email_regex.match?(email)
+        raise SendLayerValidationError.new("Invalid #{role} email address: #{email}")
+      end
+      email
+    end
+
+    def process_attachments(attachments)
+      attachments.map do |attachment|
+        case attachment
+        when Hash
+          path = attachment[:path] || attachment['path']
+          type = attachment[:type] || attachment['type']
+          if path.nil? || (path.respond_to?(:strip) && path.strip.empty?)
+            raise SendLayerValidationError.new("Attachment path is required")
+          end
+          encoded_content = read_attachment_content(path)
+          {
+            Content: encoded_content,
+            Type: type || detect_content_type(path),
+            Filename: File.basename(path),
+            Disposition: "attachment",
+            ContentID: SecureRandom.random_number(2**31 - 1)
+          }
+        when String
+          encoded_content = read_attachment_content(attachment)
+          {
+            Content: encoded_content,
+            Type: detect_content_type(attachment),
+            Filename: File.basename(attachment),
+            Disposition: "attachment",
+            ContentID: SecureRandom.random_number(2**31 - 1)
+          }
+        else
+          raise SendLayerValidationError.new("Invalid attachment format: #{attachment.class}")
+        end
+      end
+    end
+
+    def read_attachment_content(path)
+      uri = URI.parse(path) rescue nil
+      is_url = uri && (uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS))
+
+      if is_url
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.is_a?(URI::HTTPS)
+        timeout_ms = (@client.attachment_url_timeout || 30000)
+        http.read_timeout = (timeout_ms.to_f / 1000.0)
+        request = Net::HTTP::Get.new(uri)
+        response = http.request(request)
+        unless response.is_a?(Net::HTTPSuccess)
+          raise SendLayerValidationError.new("Error fetching remote file: HTTP #{response.code}")
+        end
+        return Base64.strict_encode64(response.body)
+      end
+
+      unless File.exist?(path)
+        raise SendLayerValidationError.new("Attachment file not found: #{path}")
+      end
+
+      content = File.binread(path)
+      Base64.strict_encode64(content)
+    rescue => e
+      raise SendLayerValidationError.new("Error reading attachment: #{e.message}")
+    end
+
+    def detect_content_type(path)
+      if MIME_TYPES_AVAILABLE
+        mime_type = MIME::Types.type_for(path).first
+        mime_type ? mime_type.content_type : 'application/octet-stream'
+      else
+        # Fallback to basic file extension detection
+        case File.extname(path).downcase
+        when '.pdf'
+          'application/pdf'
+        when '.txt'
+          'text/plain'
+        when '.html', '.htm'
+          'text/html'
+        when '.jpg', '.jpeg'
+          'image/jpeg'
+        when '.png'
+          'image/png'
+        when '.gif'
+          'image/gif'
+        else
+          'application/octet-stream'
+        end
+      end
+    end
+  end
+end

data/lib/sendlayer/events.rb

@@ -0,0 +1,39 @@
+module SendLayer
+  class Events
+    VALID_EVENTS = %w[accepted rejected delivered opened clicked unsubscribed complained failed].freeze
+
+    def initialize(client)
+      @client = client
+    end
+
+    def get(start_date: nil, end_date: nil, event: nil, message_id: nil, start_from: nil, retrieve_count: nil)
+      validate_events_params(start_date, end_date, event, retrieve_count)
+      
+      params = {}
+      params[:StartDate] = start_date.to_i if start_date
+      params[:EndDate] = end_date.to_i if end_date
+      params[:Event] = event if event
+      params[:MessageID] = message_id if message_id
+      params[:StartFrom] = start_from if start_from
+      params[:RetrieveCount] = retrieve_count if retrieve_count
+
+      @client.make_request('GET', 'events', nil, params)
+    end
+
+    private
+
+    def validate_events_params(start_date, end_date, event, retrieve_count)
+      if start_date && end_date && end_date < start_date
+        raise SendLayerValidationError.new("End date must be after start date")
+      end
+
+      if event && !VALID_EVENTS.include?(event)
+        raise SendLayerValidationError.new("Invalid event: #{event}. Valid events: #{VALID_EVENTS.join(', ')}")
+      end
+
+      if retrieve_count && retrieve_count <= 0
+        raise SendLayerValidationError.new("RetrieveCount must be greater than 0")
+      end
+    end
+  end
+end

data/lib/sendlayer/exceptions.rb

@@ -0,0 +1,26 @@
+module SendLayer
+  class SendLayerError < StandardError
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+      super(message)
+    end
+  end
+
+  class SendLayerAPIError < SendLayerError
+    attr_reader :status_code, :response
+
+    def initialize(message, status_code = nil, response = nil)
+      @status_code = status_code
+      @response = response
+      super(message)
+    end
+  end
+
+  class SendLayerAuthenticationError < SendLayerError; end
+  class SendLayerValidationError < SendLayerError; end
+  class SendLayerNotFoundError < SendLayerError; end
+  class SendLayerRateLimitError < SendLayerError; end
+  class SendLayerInternalServerError < SendLayerError; end
+end

data/lib/sendlayer/version.rb

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

data/lib/sendlayer/webhooks.rb

@@ -0,0 +1,53 @@
+module SendLayer
+  class Webhooks
+    VALID_EVENTS = %w[bounce click open unsubscribe complaint delivery].freeze
+
+    def initialize(client)
+      @client = client
+    end
+
+    def create(url:, event:)
+      validate_webhook_params(url, event)
+      
+      webhook_data = {
+        WebhookURL: url,
+        Event: event
+      }
+
+      @client.make_request('POST', 'webhooks', webhook_data)
+    end
+
+    def get
+      @client.make_request('GET', 'webhooks')
+    end
+
+  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
+
+      @client.make_request('DELETE', "webhooks/#{webhook_id}")
+    end
+
+    private
+
+    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
+
+      # Basic URL validation
+      uri = URI.parse(url)
+      unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+        raise SendLayerValidationError.new("Invalid URL: #{url}")
+      end
+    rescue URI::InvalidURIError
+      raise SendLayerValidationError.new("Invalid URL: #{url}")
+    end
+  end
+end

data/lib/sendlayer.rb

@@ -0,0 +1,19 @@
+require_relative 'sendlayer/version'
+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
+
+    def initialize(api_key, options = {})
+      @client = Client.new(api_key, options)
+      @emails = Emails.new(@client)
+      @webhooks = Webhooks.new(@client)
+      @events = Events.new(@client)
+    end
+  end
+end

data/sendlayer.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'lib/sendlayer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sendlayer"
+  spec.version       = ::SendLayer::VERSION
+  spec.authors       = ["SendLayer"]
+  spec.email         = ["support@sendlayer.com"]
+
+  spec.summary       = "Official Ruby SDK for SendLayer API"
+  spec.description   = "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."
+  spec.homepage      = "https://github.com/sendlayer/sendlayer-ruby"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/sendlayer/sendlayer-ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/sendlayer/sendlayer-ruby/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Dependencies
+  spec.add_dependency "mime-types", "~> 3.4"
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock", "~> 3.0"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+  spec.add_development_dependency "simplecov", "~> 0.21"
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: sendlayer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- SendLayer
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+description: 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.
+email:
+- support@sendlayer.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".env.example"
+- ".github/workflows/publish.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- examples/events.rb
+- examples/send_email.rb
+- examples/webhooks.rb
+- lib/sendlayer.rb
+- lib/sendlayer/client.rb
+- lib/sendlayer/emails.rb
+- lib/sendlayer/events.rb
+- lib/sendlayer/exceptions.rb
+- lib/sendlayer/version.rb
+- lib/sendlayer/webhooks.rb
+- sendlayer.gemspec
+homepage: https://github.com/sendlayer/sendlayer-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sendlayer/sendlayer-ruby
+  source_code_uri: https://github.com/sendlayer/sendlayer-ruby
+  changelog_uri: https://github.com/sendlayer/sendlayer-ruby/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK for SendLayer API
+test_files: []