unosend 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 609c63dd5cc0619946cd6a352c91bd010617545e25e7ca30483b696ec6b33118
+  data.tar.gz: 2e5b0b3a9355eda0b2a1868881df40a63f6077594cd4ee89bba7cf667157dafa
+SHA512:
+  metadata.gz: ed43235228610ad7e494f7b3f1a620afa81684402f018a35eaa3ce4744abf18c49b15f32fab90b4b5b49822dfed8410c62e0ad1fb02759a6c7976e3296dabcca
+  data.tar.gz: 26495f31288524001076be96464d2d1ecec193371b994f7494499afd4f95d12baa034c79fe76554de53147ae331915c2ba8a4cd81a42b825ed8fae2d3245dc8d

data/README.md

@@ -0,0 +1,153 @@
+# unosend
+
+Official Ruby SDK for [Unosend](https://unosend.co) - Email API Service.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'unosend'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it directly:
+
+```bash
+gem install unosend
+```
+
+## Quick Start
+
+```ruby
+require 'unosend'
+
+client = Unosend::Client.new('un_your_api_key')
+
+# Send an email
+email = client.emails.send(
+  from: 'hello@yourdomain.com',
+  to: 'user@example.com',
+  subject: 'Hello from Unosend!',
+  html: '<h1>Welcome!</h1><p>Thanks for signing up.</p>'
+)
+
+puts "Email sent: #{email['id']}"
+```
+
+## Features
+
+- 📧 **Emails** - Send transactional emails with HTML/text content
+- 🌐 **Domains** - Manage and verify sending domains
+- 👥 **Audiences** - Create and manage contact lists
+- 📇 **Contacts** - Add, update, and remove contacts
+
+## API Reference
+
+### Emails
+
+```ruby
+# Send an email
+email = client.emails.send(
+  from: 'you@yourdomain.com',
+  to: ['user1@example.com', 'user2@example.com'],
+  subject: 'Hello!',
+  html: '<h1>Hello World</h1>',
+  text: 'Hello World',  # Optional
+  reply_to: 'support@yourdomain.com',
+  cc: ['cc@example.com'],
+  bcc: ['bcc@example.com'],
+  headers: { 'X-Custom-Header' => 'value' },
+  tags: [{ name: 'campaign', value: 'welcome' }]
+)
+
+# Get email by ID
+email = client.emails.get('email_id')
+
+# List emails
+emails = client.emails.list(limit: 10, offset: 0)
+```
+
+### Domains
+
+```ruby
+# Add a domain
+domain = client.domains.create('yourdomain.com')
+
+# Verify domain DNS records
+domain = client.domains.verify('domain_id')
+
+# List domains
+domains = client.domains.list
+
+# Delete domain
+client.domains.delete('domain_id')
+```
+
+### Audiences
+
+```ruby
+# Create an audience
+audience = client.audiences.create('Newsletter Subscribers')
+
+# List audiences
+audiences = client.audiences.list
+
+# Get audience
+audience = client.audiences.get('audience_id')
+
+# Delete audience
+client.audiences.delete('audience_id')
+```
+
+### Contacts
+
+```ruby
+# Add a contact
+contact = client.contacts.create(
+  audience_id: 'audience_id',
+  email: 'user@example.com',
+  first_name: 'John',
+  last_name: 'Doe'
+)
+
+# List contacts in an audience
+contacts = client.contacts.list('audience_id')
+
+# Update a contact
+contact = client.contacts.update('contact_id',
+  first_name: 'Jane',
+  unsubscribed: false
+)
+
+# Delete a contact
+client.contacts.delete('contact_id')
+```
+
+## Error Handling
+
+```ruby
+begin
+  email = client.emails.send(...)
+rescue Unosend::Error => e
+  puts "Error #{e.code}: #{e.message}"
+end
+```
+
+## Configuration
+
+```ruby
+# Custom base URL (for self-hosted instances)
+client = Unosend::Client.new('un_your_api_key',
+  base_url: 'https://your-instance.com/api/v1'
+)
+```
+
+## License
+
+MIT

data/lib/unosend/audiences.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Unosend
+  class Audiences
+    def initialize(client)
+      @client = client
+    end
+
+    # Create a new audience
+    #
+    # @param name [String] Audience name
+    # @return [Hash] The created audience
+    def create(name)
+      @client.request(:post, "/audiences", { name: name })
+    end
+
+    # Get an audience by ID
+    #
+    # @param id [String] Audience ID
+    # @return [Hash] The audience
+    def get(id)
+      @client.request(:get, "/audiences/#{id}")
+    end
+
+    # List all audiences
+    #
+    # @return [Array<Hash>] List of audiences
+    def list
+      @client.request(:get, "/audiences")
+    end
+
+    # Delete an audience
+    #
+    # @param id [String] Audience ID
+    # @return [Hash] Deletion confirmation
+    def delete(id)
+      @client.request(:delete, "/audiences/#{id}")
+    end
+  end
+end

data/lib/unosend/client.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Unosend
+  class Client
+    DEFAULT_BASE_URL = "https://www.unosend.co/api/v1"
+    USER_AGENT = "unosend-ruby/1.0.0"
+
+    attr_reader :emails, :domains, :audiences, :contacts
+
+    def initialize(api_key, base_url: DEFAULT_BASE_URL)
+      raise ArgumentError, "API key is required" if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @base_url = base_url
+
+      @emails = Emails.new(self)
+      @domains = Domains.new(self)
+      @audiences = Audiences.new(self)
+      @contacts = Contacts.new(self)
+    end
+
+    def request(method, path, body = nil)
+      uri = URI.parse("#{@base_url}#{path}")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.read_timeout = 30
+      http.open_timeout = 10
+
+      request = build_request(method, uri, body)
+
+      response = http.request(request)
+      parse_response(response)
+    end
+
+    private
+
+    def build_request(method, uri, body)
+      request = case method.to_s.upcase
+                when "GET"
+                  Net::HTTP::Get.new(uri)
+                when "POST"
+                  Net::HTTP::Post.new(uri)
+                when "PUT"
+                  Net::HTTP::Put.new(uri)
+                when "PATCH"
+                  Net::HTTP::Patch.new(uri)
+                when "DELETE"
+                  Net::HTTP::Delete.new(uri)
+                else
+                  raise ArgumentError, "Unsupported HTTP method: #{method}"
+                end
+
+      request["Authorization"] = "Bearer #{@api_key}"
+      request["Content-Type"] = "application/json"
+      request["User-Agent"] = USER_AGENT
+
+      request.body = body.to_json if body
+
+      request
+    end
+
+    def parse_response(response)
+      body = response.body ? JSON.parse(response.body) : {}
+
+      unless response.is_a?(Net::HTTPSuccess)
+        error = body["error"] || {}
+        raise Error.new(
+          error["message"] || "Unknown error",
+          code: error["code"] || response.code.to_i,
+          status_code: response.code.to_i
+        )
+      end
+
+      body["data"] || body
+    rescue JSON::ParserError
+      raise Error.new("Invalid JSON response", code: 0)
+    end
+  end
+end

data/lib/unosend/contacts.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Unosend
+  class Contacts
+    def initialize(client)
+      @client = client
+    end
+
+    # Create a new contact
+    #
+    # @param audience_id [String] Audience ID
+    # @param email [String] Contact email
+    # @param first_name [String] First name (optional)
+    # @param last_name [String] Last name (optional)
+    # @return [Hash] The created contact
+    def create(audience_id:, email:, first_name: nil, last_name: nil)
+      payload = {
+        audienceId: audience_id,
+        email: email
+      }
+
+      payload[:firstName] = first_name if first_name
+      payload[:lastName] = last_name if last_name
+
+      @client.request(:post, "/contacts", payload)
+    end
+
+    # Get a contact by ID
+    #
+    # @param id [String] Contact ID
+    # @return [Hash] The contact
+    def get(id)
+      @client.request(:get, "/contacts/#{id}")
+    end
+
+    # List contacts in an audience
+    #
+    # @param audience_id [String] Audience ID
+    # @return [Array<Hash>] List of contacts
+    def list(audience_id)
+      @client.request(:get, "/contacts?audienceId=#{audience_id}")
+    end
+
+    # Update a contact
+    #
+    # @param id [String] Contact ID
+    # @param first_name [String] First name (optional)
+    # @param last_name [String] Last name (optional)
+    # @param unsubscribed [Boolean] Unsubscribed status (optional)
+    # @return [Hash] The updated contact
+    def update(id, first_name: nil, last_name: nil, unsubscribed: nil)
+      payload = {}
+      payload[:firstName] = first_name unless first_name.nil?
+      payload[:lastName] = last_name unless last_name.nil?
+      payload[:unsubscribed] = unsubscribed unless unsubscribed.nil?
+
+      @client.request(:patch, "/contacts/#{id}", payload)
+    end
+
+    # Delete a contact
+    #
+    # @param id [String] Contact ID
+    # @return [Hash] Deletion confirmation
+    def delete(id)
+      @client.request(:delete, "/contacts/#{id}")
+    end
+  end
+end

data/lib/unosend/domains.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Unosend
+  class Domains
+    def initialize(client)
+      @client = client
+    end
+
+    # Create a new domain
+    #
+    # @param name [String] Domain name
+    # @return [Hash] The created domain
+    def create(name)
+      @client.request(:post, "/domains", { name: name })
+    end
+
+    # Get a domain by ID
+    #
+    # @param id [String] Domain ID
+    # @return [Hash] The domain
+    def get(id)
+      @client.request(:get, "/domains/#{id}")
+    end
+
+    # List all domains
+    #
+    # @return [Array<Hash>] List of domains
+    def list
+      @client.request(:get, "/domains")
+    end
+
+    # Verify a domain
+    #
+    # @param id [String] Domain ID
+    # @return [Hash] The verified domain
+    def verify(id)
+      @client.request(:post, "/domains/#{id}/verify")
+    end
+
+    # Delete a domain
+    #
+    # @param id [String] Domain ID
+    # @return [Hash] Deletion confirmation
+    def delete(id)
+      @client.request(:delete, "/domains/#{id}")
+    end
+  end
+end

data/lib/unosend/emails.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Unosend
+  class Emails
+    def initialize(client)
+      @client = client
+    end
+
+    # Send an email
+    #
+    # @param from [String] Sender email address
+    # @param to [String, Array<String>] Recipient email address(es)
+    # @param subject [String] Email subject
+    # @param html [String] HTML content (optional)
+    # @param text [String] Plain text content (optional)
+    # @param reply_to [String] Reply-to address (optional)
+    # @param cc [String, Array<String>] CC recipients (optional)
+    # @param bcc [String, Array<String>] BCC recipients (optional)
+    # @param headers [Hash] Custom headers (optional)
+    # @param tags [Array<Hash>] Tags (optional)
+    # @param priority [String] Priority: 'high', 'normal', or 'low' (optional)
+    # @param template_id [String] Template UUID (optional)
+    # @param template_data [Hash] Template variables (optional)
+    # @param scheduled_for [String] ISO 8601 datetime (optional)
+    # @return [Hash] The sent email
+    def send(from:, to:, subject:, html: nil, text: nil, reply_to: nil, cc: nil, bcc: nil, headers: nil, tags: nil, priority: nil, template_id: nil, template_data: nil, scheduled_for: nil)
+      payload = {
+        from: from,
+        to: Array(to),
+        subject: subject
+      }
+
+      payload[:html] = html if html
+      payload[:text] = text if text
+      payload[:reply_to] = reply_to if reply_to
+      payload[:cc] = Array(cc) if cc
+      payload[:bcc] = Array(bcc) if bcc
+      payload[:headers] = headers if headers
+      payload[:tags] = tags if tags
+      payload[:priority] = priority if priority
+      payload[:template_id] = template_id if template_id
+      payload[:template_data] = template_data if template_data
+      payload[:scheduled_for] = scheduled_for if scheduled_for
+
+      @client.request(:post, "/emails", payload)
+    end
+
+    # Get an email by ID
+    #
+    # @param id [String] Email ID
+    # @return [Hash] The email
+    def get(id)
+      @client.request(:get, "/emails/#{id}")
+    end
+
+    # List emails
+    #
+    # @param limit [Integer] Maximum number of results (optional)
+    # @param offset [Integer] Offset for pagination (optional)
+    # @return [Array<Hash>] List of emails
+    def list(limit: nil, offset: nil)
+      path = "/emails"
+      params = []
+      params << "limit=#{limit}" if limit
+      params << "offset=#{offset}" if offset
+      path += "?#{params.join("&")}" unless params.empty?
+
+      @client.request(:get, path)
+    end
+  end
+end

data/lib/unosend/version.rb

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

data/lib/unosend.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "unosend/version"
+require_relative "unosend/client"
+require_relative "unosend/emails"
+require_relative "unosend/domains"
+require_relative "unosend/audiences"
+require_relative "unosend/contacts"
+
+module Unosend
+  class Error < StandardError
+    attr_reader :code, :status_code
+
+    def initialize(message, code: nil, status_code: nil)
+      @code = code
+      @status_code = status_code
+      super(message)
+    end
+  end
+end

data/test.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
+
+require 'unosend'
+
+client = Unosend::Client.new('un_YUp9yHlMtrGvuJqmH6kU_7eXJaU3gPcW')
+
+puts "Testing Ruby SDK..."
+puts ""
+
+puts "Sending email..."
+begin
+  email = client.emails.send(
+    from: 'hello@unosend.co',
+    to: 'bittucreator@gmail.com',
+    subject: 'Test from Ruby SDK',
+    html: '<h1>Hello from Ruby!</h1><p>This email was sent using the official Unosend Ruby SDK.</p>'
+  )
+  puts "Success! Email ID: #{email['id']}"
+rescue Unosend::Error => e
+  puts "Error #{e.code}: #{e.message}"
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: unosend
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Unosend
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-12-27 00:00:00.000000000 Z
+dependencies: []
+description: Send emails with Unosend's powerful API. Features include transactional
+  emails, audience management, and domain verification.
+email:
+- support@unosend.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/unosend.rb
+- lib/unosend/audiences.rb
+- lib/unosend/client.rb
+- lib/unosend/contacts.rb
+- lib/unosend/domains.rb
+- lib/unosend/emails.rb
+- lib/unosend/version.rb
+- test.rb
+homepage: https://unosend.co
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://unosend.co
+  source_code_uri: https://github.com/unosend/unosend-ruby
+  changelog_uri: https://github.com/unosend/unosend-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.0.3.1
+signing_key: 
+specification_version: 4
+summary: Official Ruby SDK for Unosend - Email API Service
+test_files: []