sendara 0.1.0

data/lib/sendara/railtie.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Sendara
+  class Configuration
+    attr_accessor :api_key, :base_url, :timeout, :max_retries
+
+    def initialize
+      @api_key = ENV["SENDARA_API_KEY"]
+      @base_url = ENV["SENDARA_BASE_URL"]
+      @timeout = nil
+      @max_retries = nil
+    end
+
+    def client_options
+      options = {}
+      options[:base_url] = base_url unless base_url.nil? || base_url.to_s.empty?
+      options[:timeout] = timeout unless timeout.nil?
+      options[:max_retries] = max_retries unless max_retries.nil?
+      options
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+      reset_client!
+      configuration
+    end
+
+    def client
+      @client ||= build_client
+    end
+
+    def reset_client!
+      @client = nil
+    end
+
+    private
+
+    def build_client
+      key = configuration.api_key
+      raise Error, "Sendara API key is missing. Set ENV[\"SENDARA_API_KEY\"] or config.sendara.api_key." if key.nil? || key.to_s.empty?
+
+      Client.new(key, **configuration.client_options)
+    end
+  end
+
+  class Railtie < ::Rails::Railtie
+    config.sendara = ActiveSupport::OrderedOptions.new
+
+    initializer "sendara.configure" do |app|
+      options = app.config.sendara
+
+      Sendara.configure do |sendara_config|
+        sendara_config.api_key = options.api_key unless options.api_key.nil?
+        sendara_config.base_url = options.base_url unless options.base_url.nil?
+        sendara_config.timeout = options.timeout unless options.timeout.nil?
+        sendara_config.max_retries = options.max_retries unless options.max_retries.nil?
+      end
+    end
+
+    generators do
+      require_relative "generators/install_generator"
+    end
+  end
+end

data/lib/sendara/resource.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sendara
+  class Resource
+    def initialize(client)
+      @client = client
+    end
+
+    protected
+
+    attr_reader :client
+
+    def request(method, path, body: nil, query: {})
+      client.request(method, path, body: body, query: query)
+    end
+
+    def compact_params(hash)
+      hash.reject { |_key, value| value.nil? }
+    end
+
+    def encode(segment)
+      require "erb"
+      ERB::Util.url_encode(segment.to_s)
+    end
+  end
+end

data/lib/sendara/resources/api_keys.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class ApiKeys < Resource
+      def list
+        response = request(:get, "/v1/keys") || {}
+        keys = response["keys"]
+        keys.is_a?(Array) ? keys : []
+      end
+
+      def create(scope: nil, test_mode: nil)
+        body = compact_params("scope" => scope, "test_mode" => test_mode)
+        request(:post, "/v1/keys", body: body) || {}
+      end
+
+      def rotate(id)
+        response = request(:post, "/v1/keys/#{encode(id)}/rotate") || {}
+        response["key"].to_s
+      end
+
+      def revoke(id)
+        request(:delete, "/v1/keys/#{encode(id)}")
+        nil
+      end
+    end
+  end
+end

data/lib/sendara/resources/billing.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class Billing < Resource
+      def get
+        request(:get, "/v1/billing") || {}
+      end
+
+      def checkout(plan: nil, period: nil)
+        body = compact_params("plan" => plan, "period" => period)
+        response = request(:post, "/v1/billing/checkout", body: body) || {}
+        response["url"].to_s
+      end
+
+      def portal
+        response = request(:post, "/v1/billing/portal") || {}
+        response["url"].to_s
+      end
+    end
+  end
+end

data/lib/sendara/resources/broadcasts.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class Broadcasts < Resource
+      def list(limit: nil, offset: nil)
+        query = compact_params("limit" => limit, "offset" => offset)
+        response = request(:get, "/v1/broadcasts", query: query) || {}
+        broadcasts = response["broadcasts"]
+        broadcasts.is_a?(Array) ? broadcasts : []
+      end
+
+      def get(id)
+        request(:get, "/v1/broadcasts/#{encode(id)}") || {}
+      end
+
+      def create(from_email:, name: nil, subject: nil, body_html: nil, body_text: nil,
+                 template_id: nil, message_type: nil, audience_list_id: nil,
+                 recipients: nil, scheduled_at: nil, send_now: nil)
+        request(:post, "/v1/broadcasts", body: broadcast_body(
+          from_email: from_email, name: name, subject: subject, body_html: body_html,
+          body_text: body_text, template_id: template_id, message_type: message_type,
+          audience_list_id: audience_list_id, recipients: recipients,
+          scheduled_at: scheduled_at, send_now: send_now
+        )) || {}
+      end
+
+      def send(id)
+        request(:post, "/v1/broadcasts/#{encode(id)}/send") || {}
+      end
+
+      def cancel(id)
+        request(:post, "/v1/broadcasts/#{encode(id)}/cancel") || {}
+      end
+
+      def delete(id)
+        request(:delete, "/v1/broadcasts/#{encode(id)}")
+        nil
+      end
+
+      def bulk_send(from_email:, name: nil, subject: nil, body_html: nil, body_text: nil,
+                    template_id: nil, message_type: nil, audience_list_id: nil,
+                    recipients: nil, scheduled_at: nil, send_now: nil)
+        request(:post, "/v1/send/bulk", body: broadcast_body(
+          from_email: from_email, name: name, subject: subject, body_html: body_html,
+          body_text: body_text, template_id: template_id, message_type: message_type,
+          audience_list_id: audience_list_id, recipients: recipients,
+          scheduled_at: scheduled_at, send_now: send_now
+        )) || {}
+      end
+
+      private
+
+      def broadcast_body(from_email:, name:, subject:, body_html:, body_text:, template_id:,
+                         message_type:, audience_list_id:, recipients:, scheduled_at:, send_now:)
+        compact_params(
+          "name" => name,
+          "from_email" => from_email,
+          "subject" => subject,
+          "body_html" => body_html,
+          "body_text" => body_text,
+          "template_id" => template_id,
+          "message_type" => message_type,
+          "audience_list_id" => audience_list_id,
+          "recipients" => recipients,
+          "scheduled_at" => scheduled_at,
+          "send_now" => send_now
+        )
+      end
+    end
+  end
+end

data/lib/sendara/resources/contacts.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class Contacts < Resource
+      def lists
+        @lists ||= Lists.new(client)
+      end
+
+      def list(limit: nil, offset: nil)
+        query = compact_params("limit" => limit, "offset" => offset)
+        response = request(:get, "/v1/contacts", query: query) || {}
+        contacts = response["contacts"]
+        contacts.is_a?(Array) ? contacts : []
+      end
+
+      def get(id)
+        request(:get, "/v1/contacts/#{encode(id)}") || {}
+      end
+
+      def create(email: nil, phone_number: nil, device_token: nil, first_name: nil,
+                 last_name: nil, attributes: nil, tags: nil, email_consent: nil,
+                 sms_consent: nil, push_consent: nil, voice_consent: nil)
+        body = contact_body(
+          email: email, phone_number: phone_number, device_token: device_token,
+          first_name: first_name, last_name: last_name, attributes: attributes,
+          tags: tags, email_consent: email_consent, sms_consent: sms_consent,
+          push_consent: push_consent, voice_consent: voice_consent
+        )
+        request(:post, "/v1/contacts", body: body) || {}
+      end
+
+      def update(id, email: nil, phone_number: nil, device_token: nil, first_name: nil,
+                 last_name: nil, attributes: nil, tags: nil, email_consent: nil,
+                 sms_consent: nil, push_consent: nil, voice_consent: nil)
+        body = contact_body(
+          email: email, phone_number: phone_number, device_token: device_token,
+          first_name: first_name, last_name: last_name, attributes: attributes,
+          tags: tags, email_consent: email_consent, sms_consent: sms_consent,
+          push_consent: push_consent, voice_consent: voice_consent
+        )
+        request(:put, "/v1/contacts/#{encode(id)}", body: body) || {}
+      end
+
+      def delete(id)
+        request(:delete, "/v1/contacts/#{encode(id)}")
+        nil
+      end
+
+      def lists_for(id)
+        response = request(:get, "/v1/contacts/#{encode(id)}/lists") || {}
+        lists = response["lists"]
+        lists.is_a?(Array) ? lists : []
+      end
+
+      def activity(id, limit: nil)
+        query = compact_params("limit" => limit)
+        response = request(:get, "/v1/contacts/#{encode(id)}/activity", query: query) || {}
+        events = response["events"]
+        events.is_a?(Array) ? events : []
+      end
+
+      def import(s3_key:, format:)
+        body = { "s3_key" => s3_key, "format" => format }
+        request(:post, "/v1/contacts/import", body: body) || {}
+      end
+
+      def import_inline(rows:, list_id: nil, dry_run: nil)
+        body = compact_params(
+          "rows" => rows,
+          "list_id" => list_id,
+          "dry_run" => dry_run
+        )
+        request(:post, "/v1/contacts/import/inline", body: body) || {}
+      end
+
+      def bulk(ids:, action:, tag: nil, list_id: nil, channel: nil, consent: nil)
+        body = compact_params(
+          "ids" => ids,
+          "action" => action,
+          "tag" => tag,
+          "list_id" => list_id,
+          "channel" => channel,
+          "consent" => consent
+        )
+        response = request(:post, "/v1/contacts/bulk", body: body) || {}
+        (response["affected"] || 0).to_i
+      end
+
+      def segments_preview(segment_rules)
+        response = request(:post, "/v1/contacts/segments/preview",
+                           body: { "segment_rules" => segment_rules }) || {}
+        (response["count"] || 0).to_i
+      end
+
+      def usage
+        request(:get, "/v1/contacts/usage") || {}
+      end
+
+      private
+
+      def contact_body(email:, phone_number:, device_token:, first_name:, last_name:,
+                       attributes:, tags:, email_consent:, sms_consent:, push_consent:,
+                       voice_consent:)
+        compact_params(
+          "email" => email,
+          "phone_number" => phone_number,
+          "device_token" => device_token,
+          "first_name" => first_name,
+          "last_name" => last_name,
+          "attributes" => attributes,
+          "tags" => tags,
+          "email_consent" => email_consent,
+          "sms_consent" => sms_consent,
+          "push_consent" => push_consent,
+          "voice_consent" => voice_consent
+        )
+      end
+    end
+  end
+end

data/lib/sendara/resources/domains.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Sendara
+  module Resources
+    class Domains < Resource
+      def list
+        response = request(:get, "/v1/domains") || {}
+        domains = response["domains"]
+        domains.is_a?(Array) ? domains : []
+      end
+
+      def create(domain)
+        request(:post, "/v1/domains", body: { "domain" => domain }) || {}
+      end
+
+      def get(domain)
+        request(:get, "/v1/domains/#{encode(domain)}") || {}
+      end
+
+      def verify(domain)
+        request(:post, "/v1/domains/#{encode(domain)}/verify") || {}
+      end
+
+      def get_bimi(domain)
+        request(:get, "/v1/domains/#{encode(domain)}/bimi") || {}
+      end
+
+      def set_bimi(domain, logo_url)
+        request(:put, "/v1/domains/#{encode(domain)}/bimi", body: { "logo_url" => logo_url }) || {}
+      end
+
+      def upload_bimi_logo(domain, svg, filename: "logo.svg")
+        body = {
+          "filename" => filename,
+          "content_type" => "image/svg+xml",
+          "data" => Base64.strict_encode64(svg)
+        }
+        request(:post, "/v1/domains/#{encode(domain)}/bimi/logo", body: body) || {}
+      end
+    end
+  end
+end

data/lib/sendara/resources/emails.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class Emails < Resource
+      def send(to:, from: nil, subject: nil, html: nil, text: nil, message_type: nil,
+               template_id: nil, template_vars: nil, metadata: nil, store_payload: nil,
+               test_send: nil, idempotency_key: nil)
+        meta = metadata.nil? ? {} : metadata.dup
+        meta["from_email"] = from unless from.nil?
+
+        body = {
+          "channel" => "email",
+          "idempotency_key" => idempotency_key || Client.generate_idempotency_key,
+          "destination" => { "email" => to },
+          "payload" => {
+            "subject" => subject,
+            "body_html" => html,
+            "body_text" => text
+          },
+          "metadata" => meta
+        }
+
+        body["message_type"] = message_type unless message_type.nil?
+        body["template_id"] = template_id unless template_id.nil?
+        body["template_vars"] = template_vars unless template_vars.nil?
+        body["store_payload"] = store_payload unless store_payload.nil?
+        body["test_send"] = test_send unless test_send.nil?
+
+        send_raw(body)
+      end
+
+      def send_raw(request)
+        request = request.dup
+        request["idempotency_key"] ||= Client.generate_idempotency_key
+        request(:post, "/v1/send", body: request) || {}
+      end
+
+      def send_batch(requests)
+        body = requests.map do |req|
+          req = req.dup
+          req["idempotency_key"] ||= Client.generate_idempotency_key
+          req
+        end
+        request(:post, "/v1/send/batch", body: body) || []
+      end
+    end
+  end
+end

data/lib/sendara/resources/lists.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class Lists < Resource
+      def list(limit: nil, offset: nil)
+        query = compact_params("limit" => limit, "offset" => offset)
+        response = request(:get, "/v1/contacts/lists", query: query) || {}
+        lists = response["lists"]
+        lists.is_a?(Array) ? lists : []
+      end
+
+      def get(id)
+        request(:get, "/v1/contacts/lists/#{encode(id)}") || {}
+      end
+
+      def create(name:, list_type: nil, segment_rules: nil)
+        body = compact_params(
+          "name" => name,
+          "list_type" => list_type,
+          "segment_rules" => segment_rules
+        )
+        request(:post, "/v1/contacts/lists", body: body) || {}
+      end
+
+      def update(id, name: nil, segment_rules: nil)
+        body = compact_params(
+          "name" => name,
+          "segment_rules" => segment_rules
+        )
+        request(:put, "/v1/contacts/lists/#{encode(id)}", body: body) || {}
+      end
+
+      def delete(id)
+        request(:delete, "/v1/contacts/lists/#{encode(id)}")
+        nil
+      end
+
+      def add_member(id, contact_id)
+        request(:post, "/v1/contacts/lists/#{encode(id)}/members",
+                body: { "contact_id" => contact_id }) || {}
+      end
+
+      def remove_member(id, contact_id)
+        request(:delete, "/v1/contacts/lists/#{encode(id)}/members/#{encode(contact_id)}")
+        nil
+      end
+
+      def members(id)
+        response = request(:get, "/v1/contacts/lists/#{encode(id)}/members") || {}
+        members = response["members"]
+        members.is_a?(Array) ? members : []
+      end
+    end
+  end
+end

data/lib/sendara/resources/messages.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class Messages < Resource
+      include Enumerable
+
+      def page(channel: nil, status: nil, from: nil, to: nil, limit: nil, cursor: nil)
+        query = compact_params(
+          "channel" => channel,
+          "status" => status,
+          "from" => from,
+          "to" => to,
+          "limit" => limit,
+          "cursor" => cursor
+        )
+        response = request(:get, "/v1/messages", query: query) || {}
+        MessagePage.from_response(response)
+      end
+
+      def each(channel: nil, status: nil, from: nil, to: nil, limit: nil, cursor: nil, &block)
+        unless block_given?
+          return enum_for(:each, channel: channel, status: status, from: from,
+                                  to: to, limit: limit, cursor: cursor)
+        end
+
+        loop do
+          current = page(channel: channel, status: status, from: from,
+                         to: to, limit: limit, cursor: cursor)
+          current.messages.each(&block)
+          break if current.next_cursor.nil?
+
+          cursor = current.next_cursor
+        end
+      end
+
+      def get(id)
+        request(:get, "/v1/messages/#{encode(id)}") || {}
+      end
+    end
+  end
+end

data/lib/sendara/resources/suppressions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class Suppressions < Resource
+      def list(channel: nil)
+        query = compact_params("channel" => channel)
+        response = request(:get, "/v1/suppressions", query: query) || {}
+        suppressions = response["suppressions"]
+        suppressions.is_a?(Array) ? suppressions : []
+      end
+
+      def create(channel:, recipient:, reason: nil)
+        body = compact_params(
+          "channel" => channel,
+          "recipient" => recipient,
+          "reason" => reason
+        )
+        request(:post, "/v1/suppressions", body: body) || {}
+      end
+
+      def delete(channel, recipient)
+        request(:delete, "/v1/suppressions",
+                query: { "channel" => channel, "recipient" => recipient })
+        nil
+      end
+    end
+  end
+end

data/lib/sendara/resources/templates.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class Templates < Resource
+      def list
+        response = request(:get, "/v1/templates") || {}
+        templates = response["templates"]
+        templates.is_a?(Array) ? templates : []
+      end
+
+      def get(id)
+        request(:get, "/v1/templates/#{encode(id)}") || {}
+      end
+
+      def create(name:, channel: "email", subject: nil, body_text: nil, body_html: nil,
+                 body_json: nil, variables: nil)
+        body = compact_params(
+          "name" => name,
+          "channel" => channel,
+          "subject" => subject,
+          "body_text" => body_text,
+          "body_html" => body_html,
+          "body_json" => body_json,
+          "variables" => variables
+        )
+        request(:post, "/v1/templates", body: body) || {}
+      end
+
+      def update(id, name: nil, subject: nil, body_text: nil, body_html: nil,
+                 body_json: nil, variables: nil, is_active: nil)
+        body = compact_params(
+          "name" => name,
+          "subject" => subject,
+          "body_text" => body_text,
+          "body_html" => body_html,
+          "body_json" => body_json,
+          "variables" => variables,
+          "is_active" => is_active
+        )
+        request(:put, "/v1/templates/#{encode(id)}", body: body) || {}
+      end
+
+      def delete(id)
+        request(:delete, "/v1/templates/#{encode(id)}")
+        nil
+      end
+
+      def render(id, vars = {})
+        request(:post, "/v1/templates/#{encode(id)}/render", body: { "vars" => vars || {} }) || {}
+      end
+    end
+  end
+end

data/lib/sendara/resources/usage.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sendara
+  module Resources
+    class Usage < Resource
+      def get(period: nil)
+        query = compact_params("period" => period)
+        request(:get, "/v1/usage", query: query) || {}
+      end
+    end
+  end
+end

data/lib/sendara/version.rb

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