supersendtx 0.8.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eca4d44a3a130a37fb7055f295cd6f37ed780c145189a1ce40d4318f7fd5d309
+  data.tar.gz: 5a4728dd67281d5323c284c32e21ef03943f602987428c2c76452fee6c80e904
+SHA512:
+  metadata.gz: 303ae619a3dc9bc631c2938acf710bf25d63639c2612a96fe1229e6e3d3e5d40ef0a9a24d0a4c8ed837963f41814e6012e1f7eef8c160c0c1494adce1f6d4e7e
+  data.tar.gz: dda61e8e034f98c653c0ca8adb4f75de2226065a6f9126d416487e3f5d20c48f7d94bfd10bea34229dff32f054c5402673d0326cbb8d9bf2e2378a1397a5a51c

data/.gitignore

@@ -0,0 +1,4 @@
+/spec/reports/
+/.bundle/
+/Gemfile.lock
+*.gem

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem "minitest", "~> 5.25"
+end

data/README.md

@@ -0,0 +1,24 @@
+# SuperSend TX Ruby SDK
+
+Official Ruby client for the [SuperSend TX](https://supersendtx.com) transactional email API.
+
+```bash
+gem install supersendtx
+```
+
+```ruby
+require "supersendtx"
+
+tx = SuperSendTX::Client.new("stx_your_key_here")
+
+result = tx.emails.send(
+  from: "you@yourdomain.com",
+  to: "user@example.com",
+  subject: "Hello",
+  html: "<p>It works.</p>"
+)
+
+puts result["id"], result["status"]
+```
+
+Docs: https://docs.supersendtx.com/sdks/ruby

data/lib/supersendtx/client.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SuperSendTX
+  class Client
+    attr_reader :emails, :domains, :webhooks, :templates, :suppressions
+
+    def initialize(api_key, base_url: HttpClient::DEFAULT_API_BASE_URL, transport: nil)
+      http = HttpClient.new(api_key, base_url: base_url, transport: transport)
+      @emails = EmailsResource.new(http)
+      @domains = DomainsResource.new(http)
+      @webhooks = WebhooksResource.new(http)
+      @templates = TemplatesResource.new(http)
+      @suppressions = SuppressionsResource.new(http)
+      @http = http
+    end
+
+    def request(method, path, body: nil, headers: {})
+      @http.request(method, path, body: body, headers: headers)
+    end
+  end
+end

data/lib/supersendtx/error.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module SuperSendTX
+  class Error < StandardError
+    attr_reader :status, :details, :error_code, :upgrade_url
+
+    def initialize(message, status:, details: nil, error_code: nil, upgrade_url: nil)
+      super(message)
+      @status = status
+      @details = details
+      @error_code = error_code
+      @upgrade_url = upgrade_url
+    end
+
+    def self.from_response(status, body)
+      err = body.is_a?(Hash) ? body["error"] : nil
+
+      case err
+      when String
+        new(err, status: status)
+      when Hash
+        new(
+          err["message"] || "Request failed with status #{status}",
+          status: status,
+          details: err["details"],
+          error_code: err["code"]&.to_s,
+          upgrade_url: err["upgrade_url"]&.to_s
+        )
+      else
+        new("Request failed with status #{status}", status: status)
+      end
+    end
+  end
+end

data/lib/supersendtx/http.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module SuperSendTX
+  class HttpClient
+    DEFAULT_API_BASE_URL = "https://api.supersendtx.com"
+
+    def initialize(api_key, base_url: DEFAULT_API_BASE_URL, transport: nil)
+      raise ArgumentError, "SuperSend TX API key must start with stx_" unless api_key.start_with?("stx_")
+
+      @api_key = api_key
+      @base_url = base_url.chomp("/")
+      @transport = transport
+    end
+
+    def request(method, path, body: nil, headers: {})
+      request_headers = {
+        "Authorization" => "Bearer #{@api_key}",
+        "Content-Type" => "application/json"
+      }.merge(headers)
+
+      return @transport.call(method, path, body, request_headers) if @transport
+
+      uri = URI.parse("#{@base_url}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+
+      request_class = Net::HTTP.const_get(method.capitalize)
+      request = request_class.new(uri.request_uri)
+      request_headers.each { |key, value| request[key] = value }
+      request.body = JSON.generate(body) if body
+
+      response = http.request(request)
+      parsed = response.body.to_s.empty? ? {} : JSON.parse(response.body)
+
+      raise Error.from_response(response.code.to_i, parsed) if response.code.to_i >= 400
+
+      parsed
+    end
+
+    def query(params)
+      filtered = params.compact
+      return "" if filtered.empty?
+
+      "?#{URI.encode_www_form(filtered)}"
+    end
+  end
+end

data/lib/supersendtx/resources.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module SuperSendTX
+  class EmailsResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list(limit: nil, cursor: nil)
+      @http.request("GET", "/emails#{@http.query({ "limit" => limit, "cursor" => cursor })}")
+    end
+
+    def get(email_id)
+      @http.request("GET", "/emails/#{URI.encode_www_form_component(email_id)}")
+    end
+
+    def send(from: nil, to: nil, **params)
+      params["from"] = from if from
+      params["to"] = to if to
+      body = serialize_send_params(params)
+      headers = {}
+      idempotency_key = params["idempotency_key"] || params["idempotencyKey"]
+      headers["Idempotency-Key"] = idempotency_key.to_s if idempotency_key
+
+      @http.request("POST", "/emails", body: body, headers: headers)
+    end
+
+    def batch(emails)
+      serialized = emails.map { |email| serialize_send_params(email) }
+      @http.request("POST", "/emails/batch", body: { "emails" => serialized })
+    end
+
+    def cancel(email_id)
+      @http.request("PATCH", "/emails/#{URI.encode_www_form_component(email_id)}", body: { "cancel" => true })
+    end
+
+    def resend(email_id)
+      @http.request("POST", "/emails/#{URI.encode_www_form_component(email_id)}/resend")
+    end
+
+    def test_webhook(**params)
+      @http.request("POST", "/emails/test", body: params)
+    end
+
+    def insights(window: "30d")
+      @http.request("GET", "/deliverability#{@http.query({ "window" => window })}")
+    end
+
+    private
+
+    def serialize_send_params(params)
+      body = {
+        "from" => params["from"] || params[:from],
+        "to" => params["to"] || params[:to]
+      }
+
+      %w[subject html text reply_to replyTo cc bcc tags headers tag template].each do |key|
+        value = params[key] || params[key.to_sym]
+        next if value.nil?
+
+        mapped = key == "replyTo" ? "reply_to" : key
+        body[mapped] = value
+      end
+
+      body["html"] = params["htmlBody"] || params[:htmlBody] if params["htmlBody"] || params[:htmlBody]
+      body["text"] = params["textBody"] || params[:textBody] if params["textBody"] || params[:textBody]
+      body["scheduled_at"] = params["scheduled_at"] || params[:scheduled_at] if params["scheduled_at"] || params[:scheduled_at]
+      body["scheduled_at"] ||= params["scheduledAt"] || params[:scheduledAt]
+      body["unsubscribe"] = params["unsubscribe"] || params[:unsubscribe] if params.key?("unsubscribe") || params.key?(:unsubscribe)
+
+      body
+    end
+  end
+
+  class DomainsResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list(limit: nil, cursor: nil, inbound_enabled: nil)
+      @http.request(
+        "GET",
+        "/domains#{@http.query({ "limit" => limit, "cursor" => cursor, "inbound_enabled" => inbound_enabled })}"
+      )
+    end
+
+    def get(id_or_name)
+      @http.request("GET", "/domains/#{URI.encode_www_form_component(id_or_name)}")
+    end
+
+    def create(name, inbound_enabled: nil)
+      body = { "name" => name }
+      body["inbound_enabled"] = inbound_enabled unless inbound_enabled.nil?
+      @http.request("POST", "/domains", body: body)
+    end
+
+    def verify(id_or_name)
+      @http.request("POST", "/domains/#{URI.encode_www_form_component(id_or_name)}", body: { "action" => "verify" })
+    end
+
+    def apply(id_or_name, provider: "cloudflare", credentials: nil)
+      body = { "action" => "apply", "provider" => provider }
+      body["credentials"] = credentials if credentials
+      @http.request("POST", "/domains/#{URI.encode_www_form_component(id_or_name)}", body: body)
+    end
+
+    def update(id_or_name, **params)
+      @http.request("PATCH", "/domains/#{URI.encode_www_form_component(id_or_name)}", body: params)
+    end
+
+    def delete(id_or_name)
+      @http.request("DELETE", "/domains/#{URI.encode_www_form_component(id_or_name)}")
+    end
+  end
+
+  class WebhooksResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list(limit: nil, cursor: nil)
+      @http.request("GET", "/webhooks#{@http.query({ "limit" => limit, "cursor" => cursor })}")
+    end
+
+    def get(webhook_id)
+      @http.request("GET", "/webhooks/#{URI.encode_www_form_component(webhook_id)}")
+    end
+
+    def create(**params)
+      @http.request("POST", "/webhooks", body: params)
+    end
+
+    def update(webhook_id, **params)
+      @http.request("PATCH", "/webhooks/#{URI.encode_www_form_component(webhook_id)}", body: params)
+    end
+
+    def delete(webhook_id)
+      @http.request("DELETE", "/webhooks/#{URI.encode_www_form_component(webhook_id)}")
+    end
+  end
+
+  class TemplatesResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list(limit: nil, cursor: nil, status: nil)
+      @http.request(
+        "GET",
+        "/templates#{@http.query({ "limit" => limit, "cursor" => cursor, "status" => status })}"
+      )
+    end
+
+    def get(id_or_alias)
+      @http.request("GET", "/templates/#{URI.encode_www_form_component(id_or_alias)}")
+    end
+
+    def create(**params)
+      @http.request("POST", "/templates", body: params)
+    end
+
+    def update(id_or_alias, **params)
+      @http.request("PATCH", "/templates/#{URI.encode_www_form_component(id_or_alias)}", body: params)
+    end
+
+    def delete(id_or_alias)
+      @http.request("DELETE", "/templates/#{URI.encode_www_form_component(id_or_alias)}")
+    end
+
+    def publish(id_or_alias)
+      @http.request("POST", "/templates/#{URI.encode_www_form_component(id_or_alias)}", body: { "action" => "publish" })
+    end
+  end
+
+  class SuppressionsResource
+    def initialize(http)
+      @http = http
+    end
+
+    def list(limit: nil, cursor: nil, email: nil)
+      @http.request(
+        "GET",
+        "/suppressions#{@http.query({ "limit" => limit, "cursor" => cursor, "email" => email })}"
+      )
+    end
+
+    def create(**params)
+      @http.request("POST", "/suppressions", body: params)
+    end
+
+    def remove(id_or_email)
+      if id_or_email.include?("@")
+        return @http.request("DELETE", "/suppressions#{@http.query({ "email" => id_or_email })}")
+      end
+
+      @http.request("DELETE", "/suppressions/#{URI.encode_www_form_component(id_or_email)}")
+    end
+  end
+end

data/lib/supersendtx/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SuperSendTX
+  VERSION = "0.8.2"
+end

data/lib/supersendtx.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "supersendtx/version"
+require_relative "supersendtx/error"
+require_relative "supersendtx/http"
+require_relative "supersendtx/resources"
+require_relative "supersendtx/client"
+
+module SuperSendTX
+end

data/supersendtx.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "lib/supersendtx/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "supersendtx"
+  spec.version = SuperSendTX::VERSION
+  spec.authors = ["SuperSend TX"]
+  spec.email = ["support@supersendtx.com"]
+
+  spec.summary = "SuperSend TX transactional email API client for Ruby"
+  spec.description = "Official Ruby client for the SuperSend TX REST API."
+  spec.homepage = "https://supersendtx.com"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => "https://github.com/Super-Send/supersendtx-sdks/tree/main/ruby",
+    "documentation_uri" => "https://docs.supersendtx.com/sdks/ruby",
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| f.start_with?("spec/") }
+  rescue StandardError
+    Dir.glob("{lib}/**/*", base: __dir__) + ["README.md", "supersendtx.gemspec"]
+  end
+
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: supersendtx
+version: !ruby/object:Gem::Version
+  version: 0.8.2
+platform: ruby
+authors:
+- SuperSend TX
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-07-29 00:00:00.000000000 Z
+dependencies: []
+description: Official Ruby client for the SuperSend TX REST API.
+email:
+- support@supersendtx.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- lib/supersendtx.rb
+- lib/supersendtx/client.rb
+- lib/supersendtx/error.rb
+- lib/supersendtx/http.rb
+- lib/supersendtx/resources.rb
+- lib/supersendtx/version.rb
+- supersendtx.gemspec
+homepage: https://supersendtx.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://supersendtx.com
+  source_code_uri: https://github.com/Super-Send/supersendtx-sdks/tree/main/ruby
+  documentation_uri: https://docs.supersendtx.com/sdks/ruby
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: SuperSend TX transactional email API client for Ruby
+test_files: []