emailit 2.0.1

data/lib/emailit/base_client.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Emailit
+  class BaseClient
+    DEFAULT_API_BASE = "https://api.emailit.com"
+
+    attr_reader :api_key, :api_base
+
+    def initialize(config)
+      config = { api_key: config } if config.is_a?(String)
+      config = symbolize_keys(config)
+
+      raise ArgumentError, "api_key is required" if config[:api_key].nil? || config[:api_key].empty?
+
+      @api_key = config[:api_key]
+      @api_base = (config[:api_base] || DEFAULT_API_BASE).chomp("/")
+      @timeout = config[:timeout] || 30
+      @open_timeout = config[:open_timeout] || 10
+    end
+
+    def request(method, path, params = nil)
+      uri = build_uri(path, method == :get ? params : nil)
+      req = build_request(method, uri, method == :get ? nil : params)
+
+      begin
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.read_timeout = @timeout
+        http.open_timeout = @open_timeout
+
+        response = http.request(req)
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError, Net::OpenTimeout => e
+        raise ConnectionError, "Could not connect to the Emailit API: #{e.message}"
+      rescue IOError, Net::ReadTimeout => e
+        raise ConnectionError, "Communication with Emailit API failed: #{e.message}"
+      end
+
+      status_code = response.code.to_i
+      headers = {}
+      response.each_header { |k, v| headers[k] = v }
+      body = response.body || ""
+
+      api_response = ApiResponse.new(status_code, headers, body)
+
+      handle_error_response(api_response) if status_code >= 400
+
+      api_response
+    end
+
+    private
+
+    def build_uri(path, query_params = nil)
+      uri = URI.parse("#{@api_base}#{path}")
+      if query_params && !query_params.empty?
+        uri.query = URI.encode_www_form(query_params)
+      end
+      uri
+    end
+
+    def build_request(method, uri, body_params)
+      klass = case method
+              when :get    then Net::HTTP::Get
+              when :post   then Net::HTTP::Post
+              when :patch  then Net::HTTP::Patch
+              when :put    then Net::HTTP::Put
+              when :delete then Net::HTTP::Delete
+              else raise ArgumentError, "Unsupported HTTP method: #{method}"
+              end
+
+      req = klass.new(uri)
+      req["Authorization"] = "Bearer #{@api_key}"
+      req["Content-Type"] = "application/json"
+      req["User-Agent"] = "emailit-ruby/#{VERSION}"
+      req.body = JSON.generate(body_params) if body_params
+      req
+    end
+
+    def handle_error_response(response)
+      message = extract_error_message(response)
+      raise ApiError.from_response(
+        message,
+        http_status: response.status_code,
+        http_body: response.body,
+        json_body: response.json,
+        http_headers: response.headers
+      )
+    end
+
+    def extract_error_message(response)
+      json = response.json
+      if json.is_a?(Hash)
+        error = json["error"]
+        if error.is_a?(String)
+          msg = error
+          msg += ": #{json["message"]}" if json["message"]
+          return msg
+        end
+
+        if error.is_a?(Hash) && error["message"]
+          return error["message"]
+        end
+      end
+
+      "API request failed with status #{response.status_code}"
+    end
+
+    def symbolize_keys(hash)
+      hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+    end
+  end
+end

data/lib/emailit/collection.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Collection < EmailitObject
+    include Enumerable
+
+    def data
+      @values["data"] || []
+    end
+
+    def each(&block)
+      data.each(&block)
+    end
+
+    def count
+      data.length
+    end
+    alias size count
+    alias length count
+
+    def has_more?
+      !@values["next_page_url"].nil?
+    end
+  end
+end

data/lib/emailit/delivery_method.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Emailit
+  class DeliveryMethod
+    attr_reader :settings
+
+    def initialize(settings = {})
+      @settings = settings
+      raise ArgumentError, "Emailit API key is required. Set config.action_mailer.emailit_settings = { api_key: 'your_key' }" unless @settings[:api_key]
+
+      @client = EmailitClient.new(@settings[:api_key])
+    end
+
+    def deliver!(mail)
+      params = build_params(mail)
+      @client.emails.send(params)
+    end
+
+    private
+
+    def build_params(mail)
+      params = {}
+
+      params["from"] = mail.from&.first || mail[:from]&.to_s
+      params["to"] = Array(mail.to)
+      params["subject"] = mail.subject if mail.subject
+
+      if mail.cc && !mail.cc.empty?
+        params["cc"] = Array(mail.cc)
+      end
+
+      if mail.bcc && !mail.bcc.empty?
+        params["bcc"] = Array(mail.bcc)
+      end
+
+      if mail.reply_to && !mail.reply_to.empty?
+        params["reply_to"] = Array(mail.reply_to).first
+      end
+
+      if mail.multipart?
+        mail.parts.each do |part|
+          case part.content_type
+          when /text\/html/
+            params["html"] = part.body.decoded
+          when /text\/plain/
+            params["text"] = part.body.decoded
+          end
+        end
+      elsif mail.content_type&.include?("text/html")
+        params["html"] = mail.body.decoded
+      else
+        params["text"] = mail.body.decoded
+      end
+
+      if mail.attachments.any?
+        params["attachments"] = mail.attachments.map do |attachment|
+          {
+            "filename" => attachment.filename,
+            "content" => Base64.strict_encode64(attachment.body.decoded),
+            "content_type" => attachment.content_type.split(";").first,
+          }
+        end
+      end
+
+      if mail.header["X-Emailit-Tags"]
+        params["tags"] = mail.header["X-Emailit-Tags"].to_s.split(",").map(&:strip)
+      end
+
+      params
+    end
+  end
+end

data/lib/emailit/emailit_client.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Emailit
+  class EmailitClient < BaseClient
+    def emails
+      @emails ||= Services::EmailService.new(self)
+    end
+
+    def domains
+      @domains ||= Services::DomainService.new(self)
+    end
+
+    def api_keys
+      @api_keys ||= Services::ApiKeyService.new(self)
+    end
+
+    def audiences
+      @audiences ||= Services::AudienceService.new(self)
+    end
+
+    def subscribers
+      @subscribers ||= Services::SubscriberService.new(self)
+    end
+
+    def templates
+      @templates ||= Services::TemplateService.new(self)
+    end
+
+    def suppressions
+      @suppressions ||= Services::SuppressionService.new(self)
+    end
+
+    def email_verifications
+      @email_verifications ||= Services::EmailVerificationService.new(self)
+    end
+
+    def email_verification_lists
+      @email_verification_lists ||= Services::EmailVerificationListService.new(self)
+    end
+
+    def webhooks
+      @webhooks ||= Services::WebhookService.new(self)
+    end
+
+    def contacts
+      @contacts ||= Services::ContactService.new(self)
+    end
+
+    def events
+      @events ||= Services::EventService.new(self)
+    end
+  end
+end

data/lib/emailit/emailit_object.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Emailit
+  class EmailitObject
+    attr_reader :values
+    attr_accessor :last_response
+
+    def initialize(values = {})
+      @values = values || {}
+    end
+
+    def [](key)
+      @values[key.to_s]
+    end
+
+    def []=(key, value)
+      @values[key.to_s] = value
+    end
+
+    def key?(key)
+      @values.key?(key.to_s)
+    end
+
+    def to_hash
+      @values
+    end
+    alias to_h to_hash
+
+    def to_json(*args)
+      JSON.generate(@values, *args)
+    end
+
+    def to_s
+      JSON.pretty_generate(@values)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @values.key?(name.to_s) || super
+    end
+
+    def method_missing(name, *args)
+      key = name.to_s
+      if key.end_with?("=")
+        @values[key.chomp("=")] = args.first
+      elsif @values.key?(key)
+        @values[key]
+      else
+        super
+      end
+    end
+
+    def refresh_from(values)
+      @values = values
+      self
+    end
+  end
+end

data/lib/emailit/errors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Error < StandardError; end
+
+  class ConnectionError < Error; end
+
+  class ApiError < Error
+    attr_reader :http_status, :http_body, :json_body, :http_headers
+
+    def initialize(message = nil, http_status: 0, http_body: "", json_body: nil, http_headers: {})
+      @http_status = http_status
+      @http_body = http_body
+      @json_body = json_body
+      @http_headers = http_headers
+      super(message)
+    end
+
+    def self.from_response(message, http_status:, http_body:, json_body:, http_headers:)
+      klass = case http_status
+              when 401 then AuthenticationError
+              when 429 then RateLimitError
+              when 422 then UnprocessableEntityError
+              when 400, 404 then InvalidRequestError
+              else self
+              end
+
+      klass.new(message, http_status: http_status, http_body: http_body, json_body: json_body, http_headers: http_headers)
+    end
+  end
+
+  class AuthenticationError < ApiError; end
+  class InvalidRequestError < ApiError; end
+  class RateLimitError < ApiError; end
+  class UnprocessableEntityError < ApiError; end
+end

data/lib/emailit/events/webhook_event.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Emailit
+  module Events
+    class WebhookEvent < EmailitObject
+      EVENT_TYPE = ""
+
+      def self.construct_from(payload)
+        init_event_map unless @event_map_initialized
+
+        type = payload["type"]
+
+        if type && @event_map[type]
+          @event_map[type].new(payload)
+        else
+          new(payload)
+        end
+      end
+
+      def event_data
+        data = @values["data"]
+        return nil unless data
+
+        data["object"] || data
+      end
+
+      def self.init_event_map
+        @event_map = {
+          "email.accepted" => EmailAccepted,
+          "email.scheduled" => EmailScheduled,
+          "email.delivered" => EmailDelivered,
+          "email.bounced" => EmailBounced,
+          "email.attempted" => EmailAttempted,
+          "email.failed" => EmailFailed,
+          "email.rejected" => EmailRejected,
+          "email.suppressed" => EmailSuppressed,
+          "email.received" => EmailReceived,
+          "email.complained" => EmailComplained,
+          "email.clicked" => EmailClicked,
+          "email.loaded" => EmailLoaded,
+          "domain.created" => DomainCreated,
+          "domain.updated" => DomainUpdated,
+          "domain.deleted" => DomainDeleted,
+          "audience.created" => AudienceCreated,
+          "audience.updated" => AudienceUpdated,
+          "audience.deleted" => AudienceDeleted,
+          "subscriber.created" => SubscriberCreated,
+          "subscriber.updated" => SubscriberUpdated,
+          "subscriber.deleted" => SubscriberDeleted,
+          "contact.created" => ContactCreated,
+          "contact.updated" => ContactUpdated,
+          "contact.deleted" => ContactDeleted,
+          "template.created" => TemplateCreated,
+          "template.updated" => TemplateUpdated,
+          "template.deleted" => TemplateDeleted,
+          "suppression.created" => SuppressionCreated,
+          "suppression.updated" => SuppressionUpdated,
+          "suppression.deleted" => SuppressionDeleted,
+          "email_verification.created" => EmailVerificationCreated,
+          "email_verification.updated" => EmailVerificationUpdated,
+          "email_verification.deleted" => EmailVerificationDeleted,
+          "email_verification_list.created" => EmailVerificationListCreated,
+          "email_verification_list.updated" => EmailVerificationListUpdated,
+          "email_verification_list.deleted" => EmailVerificationListDeleted,
+        }
+        @event_map_initialized = true
+      end
+      private_class_method :init_event_map
+    end
+
+    class EmailAccepted < WebhookEvent
+      EVENT_TYPE = "email.accepted"
+    end
+
+    class EmailScheduled < WebhookEvent
+      EVENT_TYPE = "email.scheduled"
+    end
+
+    class EmailDelivered < WebhookEvent
+      EVENT_TYPE = "email.delivered"
+    end
+
+    class EmailBounced < WebhookEvent
+      EVENT_TYPE = "email.bounced"
+    end
+
+    class EmailAttempted < WebhookEvent
+      EVENT_TYPE = "email.attempted"
+    end
+
+    class EmailFailed < WebhookEvent
+      EVENT_TYPE = "email.failed"
+    end
+
+    class EmailRejected < WebhookEvent
+      EVENT_TYPE = "email.rejected"
+    end
+
+    class EmailSuppressed < WebhookEvent
+      EVENT_TYPE = "email.suppressed"
+    end
+
+    class EmailReceived < WebhookEvent
+      EVENT_TYPE = "email.received"
+    end
+
+    class EmailComplained < WebhookEvent
+      EVENT_TYPE = "email.complained"
+    end
+
+    class EmailClicked < WebhookEvent
+      EVENT_TYPE = "email.clicked"
+    end
+
+    class EmailLoaded < WebhookEvent
+      EVENT_TYPE = "email.loaded"
+    end
+
+    class DomainCreated < WebhookEvent
+      EVENT_TYPE = "domain.created"
+    end
+
+    class DomainUpdated < WebhookEvent
+      EVENT_TYPE = "domain.updated"
+    end
+
+    class DomainDeleted < WebhookEvent
+      EVENT_TYPE = "domain.deleted"
+    end
+
+    class AudienceCreated < WebhookEvent
+      EVENT_TYPE = "audience.created"
+    end
+
+    class AudienceUpdated < WebhookEvent
+      EVENT_TYPE = "audience.updated"
+    end
+
+    class AudienceDeleted < WebhookEvent
+      EVENT_TYPE = "audience.deleted"
+    end
+
+    class SubscriberCreated < WebhookEvent
+      EVENT_TYPE = "subscriber.created"
+    end
+
+    class SubscriberUpdated < WebhookEvent
+      EVENT_TYPE = "subscriber.updated"
+    end
+
+    class SubscriberDeleted < WebhookEvent
+      EVENT_TYPE = "subscriber.deleted"
+    end
+
+    class ContactCreated < WebhookEvent
+      EVENT_TYPE = "contact.created"
+    end
+
+    class ContactUpdated < WebhookEvent
+      EVENT_TYPE = "contact.updated"
+    end
+
+    class ContactDeleted < WebhookEvent
+      EVENT_TYPE = "contact.deleted"
+    end
+
+    class TemplateCreated < WebhookEvent
+      EVENT_TYPE = "template.created"
+    end
+
+    class TemplateUpdated < WebhookEvent
+      EVENT_TYPE = "template.updated"
+    end
+
+    class TemplateDeleted < WebhookEvent
+      EVENT_TYPE = "template.deleted"
+    end
+
+    class SuppressionCreated < WebhookEvent
+      EVENT_TYPE = "suppression.created"
+    end
+
+    class SuppressionUpdated < WebhookEvent
+      EVENT_TYPE = "suppression.updated"
+    end
+
+    class SuppressionDeleted < WebhookEvent
+      EVENT_TYPE = "suppression.deleted"
+    end
+
+    class EmailVerificationCreated < WebhookEvent
+      EVENT_TYPE = "email_verification.created"
+    end
+
+    class EmailVerificationUpdated < WebhookEvent
+      EVENT_TYPE = "email_verification.updated"
+    end
+
+    class EmailVerificationDeleted < WebhookEvent
+      EVENT_TYPE = "email_verification.deleted"
+    end
+
+    class EmailVerificationListCreated < WebhookEvent
+      EVENT_TYPE = "email_verification_list.created"
+    end
+
+    class EmailVerificationListUpdated < WebhookEvent
+      EVENT_TYPE = "email_verification_list.updated"
+    end
+
+    class EmailVerificationListDeleted < WebhookEvent
+      EVENT_TYPE = "email_verification_list.deleted"
+    end
+  end
+end

data/lib/emailit/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "delivery_method"
+
+module Emailit
+  class Railtie < Rails::Railtie
+    initializer "emailit.add_delivery_method" do
+      ActiveSupport.on_load(:action_mailer) do
+        ActionMailer::Base.add_delivery_method(:emailit, Emailit::DeliveryMethod)
+      end
+    end
+  end
+end

data/lib/emailit/resources/api_key.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class ApiKey < ApiResource
+    OBJECT_NAME = "api_key"
+  end
+end

data/lib/emailit/resources/audience.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Audience < ApiResource
+    OBJECT_NAME = "audience"
+  end
+end

data/lib/emailit/resources/contact.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Contact < ApiResource
+    OBJECT_NAME = "contact"
+  end
+end

data/lib/emailit/resources/domain.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Domain < ApiResource
+    OBJECT_NAME = "domain"
+  end
+end

data/lib/emailit/resources/email.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Email < ApiResource
+    OBJECT_NAME = "email"
+  end
+end

data/lib/emailit/resources/email_verification.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class EmailVerification < ApiResource
+    OBJECT_NAME = "email_verification"
+  end
+end

data/lib/emailit/resources/email_verification_list.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class EmailVerificationList < ApiResource
+    OBJECT_NAME = "email_verification_list"
+  end
+end

data/lib/emailit/resources/event.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Event < ApiResource
+    OBJECT_NAME = "event"
+  end
+end

data/lib/emailit/resources/subscriber.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Subscriber < ApiResource
+    OBJECT_NAME = "subscriber"
+  end
+end

data/lib/emailit/resources/suppression.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Suppression < ApiResource
+    OBJECT_NAME = "suppression"
+  end
+end

data/lib/emailit/resources/template.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Template < ApiResource
+    OBJECT_NAME = "template"
+  end
+end

data/lib/emailit/resources/webhook.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Emailit
+  class Webhook < ApiResource
+    OBJECT_NAME = "webhook"
+  end
+end