connector-ruby 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c22469b3849b241124a069729e5b127cb3459d4f9f55458a79b089fc3f33a28
-  data.tar.gz: 66fbf3cb744d58622775bed0a17840f6635984e9fc6a488ea507da5b2f5fbd6c
+  metadata.gz: d3564fee7248f47cf5a37285ef65601563ad281f509ac7e62a7a990219d81a87
+  data.tar.gz: 1edc94f66291c7d36116fb37af9d7546d3d275993e56ecdb49bac5b9afc1775e
 SHA512:
-  metadata.gz: fef0557ed46edaf27e1c50b2e28e0cde341c8343fe394b96c51d3a46e17c1b62ccd2fbc88974abd41c3b59bf37f4b20349d2cd794ede451c7074107ebdd81824
-  data.tar.gz: 706e414863cc4f8d556166a6fd60d2a092593ded6bea22c6617768148e2c596e2121bbf6f934df5170680eeaf40d5421805db07348099a854de5466afd841d0e
+  metadata.gz: 7b1f6ee12c630043c864c2a60e0684e388e50e2cbb53ce868377e6fb5254ce93fc2927dec99efb3841a960316a2924e8a47348d6dee1909f746098065973c3d3
+  data.tar.gz: 168d00e2d6bb2779f8e32a47224bd390a08e70cf13faa05eefcb44f8748aff2deb9e96b19e2a415bff468e3722122348537daae1d0a3e575252133fe781b913b

data/README.md

@@ -1,58 +1,42 @@
 # connector-ruby
 
-Unified channel messaging SDK for Ruby. Framework-agnostic SDK for sending/receiving messages across chat platforms.
+Unified channel messaging SDK for Ruby. Send and receive messages across WhatsApp and Telegram with a consistent API.
 
 ## Installation
 
 ```ruby
-gem "connector-ruby", "~> 0.1"
+gem "connector-ruby"
 ```
 
-## Supported Channels
-
-- WhatsApp Cloud API
-- Telegram Bot API
-
 ## Usage
 
-### WhatsApp
-
 ```ruby
-client = ConnectorRuby::WhatsApp.new(
-  phone_number_id: "...",
-  access_token: "..."
-)
-
-client.send_text(to: "+62812...", text: "Hello!")
-client.send_buttons(to: "+62812...", body: "Choose:", buttons: [
-  { id: "opt1", title: "Option 1" },
-  { id: "opt2", title: "Option 2" }
-])
-client.send_image(to: "+62812...", url: "https://...")
+require "connector_ruby"
 
-event = ConnectorRuby::WhatsApp.parse_webhook(request_body)
-```
-
-### Telegram
+# WhatsApp
+wa = ConnectorRuby::Channels::WhatsApp.new(
+  access_token: ENV["WHATSAPP_TOKEN"],
+  phone_number_id: ENV["WHATSAPP_PHONE_ID"]
+)
+wa.send_text(to: "+1234567890", text: "Hello!")
 
-```ruby
-client = ConnectorRuby::Telegram.new(bot_token: "...")
+# Telegram
+tg = ConnectorRuby::Channels::Telegram.new(bot_token: ENV["TELEGRAM_TOKEN"])
+tg.send_text(to: "chat_id", text: "Hello!")
 
-client.send_text(chat_id: 12345, text: "Hello!")
-event = ConnectorRuby::Telegram.parse_webhook(request_body)
+# Webhook verification
+verifier = ConnectorRuby::WebhookVerifier.new(secret_token: "secret")
+verifier.verify!(request_body, signature_header)
 ```
 
-### Configuration
+## Features
 
-```ruby
-ConnectorRuby.configure do |config|
-  config.whatsapp_phone_number_id = ENV["WA_PHONE_ID"]
-  config.whatsapp_access_token = ENV["WA_TOKEN"]
-  config.telegram_bot_token = ENV["TG_TOKEN"]
-  config.http_timeout = 30
-  config.http_retries = 3
-end
-```
+- WhatsApp Business API (text, buttons, images)
+- Telegram Bot API (text, callbacks)
+- HMAC-SHA256 webhook verification
+- HTTP retry with exponential backoff for 429/5xx
+- Input validation and error handling
+- Logging hooks (on_request, on_response, on_error)
 
 ## License
 

data/lib/connector_ruby/batch_sender.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  class BatchSender
+    RATE_LIMITS = {
+      whatsapp: { messages_per_second: 80 },
+      telegram: { messages_per_second: 30 },
+      messenger: { messages_per_second: 200 },
+      line: { messages_per_second: 100 },
+      slack: { messages_per_second: 1 }
+    }.freeze
+
+    def initialize(channel:)
+      @channel = channel
+      @results = []
+      @errors = []
+    end
+
+    def send_batch(messages)
+      rate = rate_limit_for(@channel)
+      delay = 1.0 / rate
+
+      messages.each_with_index do |msg, i|
+        sleep(delay) if i > 0
+        begin
+          result = yield msg
+          @results << { index: i, status: :sent, result: result }
+        rescue => e
+          @errors << { index: i, status: :failed, error: e.message }
+        end
+      end
+
+      { sent: @results, failed: @errors, total: messages.size }
+    end
+
+    private
+
+    def rate_limit_for(channel)
+      channel_sym = channel.class.name.split("::").last.downcase.to_sym
+      config = RATE_LIMITS[channel_sym] || { messages_per_second: 10 }
+      config[:messages_per_second]
+    end
+  end
+end

data/lib/connector_ruby/channels/line.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  module Channels
+    class Line < Base
+      BASE_URL = "https://api.line.me/v2/bot/message"
+
+      def initialize(channel_access_token: nil)
+        @channel_access_token = channel_access_token || ConnectorRuby.configuration.line_channel_access_token
+        raise ConfigurationError, "LINE channel_access_token is required" unless @channel_access_token
+      end
+
+      def send_text(to:, text:)
+        validate_send!(to: to, text: text)
+        push_message(to, [{ type: "text", text: text }])
+      end
+
+      def send_buttons(to:, text:, buttons:)
+        validate_send!(to: to, text: text)
+        actions = buttons.map do |btn|
+          { type: "postback", label: btn[:title], data: btn[:id] }
+        end
+
+        template = {
+          type: "template",
+          altText: text,
+          template: {
+            type: "buttons",
+            text: text,
+            actions: actions
+          }
+        }
+        push_message(to, [template])
+      end
+
+      def send_image(to:, url:, caption: nil)
+        validate_send!(to: to)
+        messages = [{ type: "image", originalContentUrl: url, previewImageUrl: url }]
+        messages << { type: "text", text: caption } if caption
+        push_message(to, messages)
+      end
+
+      def send_flex(to:, alt_text:, contents:)
+        validate_send!(to: to)
+        flex = {
+          type: "flex",
+          altText: alt_text,
+          contents: contents
+        }
+        push_message(to, [flex])
+      end
+
+      def self.parse_webhook(body)
+        data = body.is_a?(String) ? JSON.parse(body) : body
+
+        events = data["events"]
+        return nil unless events&.any?
+
+        event_data = events[0]
+        case event_data["type"]
+        when "message"
+          parse_message(event_data)
+        when "postback"
+          parse_postback(event_data)
+        end
+      end
+
+      private
+
+      def push_message(to, messages)
+        payload = { to: to, messages: messages }
+        http_client.post("#{BASE_URL}/push", body: payload, headers: auth_headers)
+      end
+
+      def auth_headers
+        { "Authorization" => "Bearer #{@channel_access_token}" }
+      end
+
+      def validate_send!(to:, text: nil)
+        raise ConnectorRuby::Error, "Recipient 'to' cannot be nil or empty" if to.nil? || to.to_s.strip.empty?
+        if text
+          raise ConnectorRuby::Error, "Text cannot be nil or empty" if text.nil? || text.to_s.strip.empty?
+          raise ConnectorRuby::Error, "Text exceeds 5000 character limit" if text.length > 5000
+        end
+      end
+
+      def self.parse_message(event_data)
+        msg = event_data["message"]
+        Event.new(
+          type: :message,
+          channel: :line,
+          from: event_data.dig("source", "userId"),
+          text: msg["text"],
+          timestamp: event_data["timestamp"] ? Time.at(event_data["timestamp"].to_i / 1000) : nil,
+          message_id: msg["id"],
+          metadata: {
+            reply_token: event_data["replyToken"],
+            source_type: event_data.dig("source", "type"),
+            message_type: msg["type"]
+          }
+        )
+      end
+
+      def self.parse_postback(event_data)
+        Event.new(
+          type: :callback,
+          channel: :line,
+          from: event_data.dig("source", "userId"),
+          text: event_data.dig("postback", "data"),
+          timestamp: event_data["timestamp"] ? Time.at(event_data["timestamp"].to_i / 1000) : nil,
+          metadata: {
+            reply_token: event_data["replyToken"],
+            source_type: event_data.dig("source", "type")
+          }
+        )
+      end
+    end
+  end
+end

data/lib/connector_ruby/channels/messenger.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  module Channels
+    class Messenger < Base
+      BASE_URL = "https://graph.facebook.com/v21.0/me/messages"
+
+      def initialize(page_access_token: nil)
+        @page_access_token = page_access_token || ConnectorRuby.configuration.messenger_page_access_token
+        raise ConfigurationError, "Messenger page_access_token is required" unless @page_access_token
+      end
+
+      def send_text(to:, text:)
+        validate_send!(to: to, text: text)
+        payload = {
+          recipient: { id: to },
+          message: { text: text }
+        }
+        post_message(payload)
+      end
+
+      def send_buttons(to:, text:, buttons:)
+        validate_send!(to: to, text: text)
+        formatted = buttons.map do |btn|
+          { type: "postback", title: btn[:title], payload: btn[:id] }
+        end
+
+        payload = {
+          recipient: { id: to },
+          message: {
+            attachment: {
+              type: "template",
+              payload: {
+                template_type: "button",
+                text: text,
+                buttons: formatted
+              }
+            }
+          }
+        }
+        post_message(payload)
+      end
+
+      def send_image(to:, url:, caption: nil)
+        validate_send!(to: to)
+        payload = {
+          recipient: { id: to },
+          message: {
+            attachment: {
+              type: "image",
+              payload: { url: url, is_reusable: true }
+            }
+          }
+        }
+        post_message(payload)
+      end
+
+      def send_quick_replies(to:, text:, replies:)
+        validate_send!(to: to, text: text)
+        formatted = replies.map do |r|
+          { content_type: "text", title: r[:title], payload: r[:id] }
+        end
+
+        payload = {
+          recipient: { id: to },
+          message: { text: text, quick_replies: formatted }
+        }
+        post_message(payload)
+      end
+
+      def self.parse_webhook(body)
+        data = body.is_a?(String) ? JSON.parse(body) : body
+
+        entry = data.dig("entry", 0)
+        return nil unless entry
+
+        messaging = entry.dig("messaging", 0)
+        return nil unless messaging
+
+        if messaging["message"]
+          parse_message(messaging)
+        elsif messaging["postback"]
+          parse_postback(messaging)
+        end
+      end
+
+      private
+
+      def post_message(payload)
+        http_client.post(BASE_URL, body: payload, headers: auth_headers)
+      end
+
+      def auth_headers
+        { "Authorization" => "Bearer #{@page_access_token}" }
+      end
+
+      def validate_send!(to:, text: nil)
+        raise ConnectorRuby::Error, "Recipient 'to' cannot be nil or empty" if to.nil? || to.to_s.strip.empty?
+        if text
+          raise ConnectorRuby::Error, "Text cannot be nil or empty" if text.nil? || text.to_s.strip.empty?
+          raise ConnectorRuby::Error, "Text exceeds 2000 character limit" if text.length > 2000
+        end
+      end
+
+      def self.parse_message(messaging)
+        msg = messaging["message"]
+        sender = messaging.dig("sender", "id")
+
+        Event.new(
+          type: :message,
+          channel: :messenger,
+          from: sender,
+          to: messaging.dig("recipient", "id"),
+          text: msg["text"],
+          timestamp: messaging["timestamp"] ? Time.at(messaging["timestamp"].to_i / 1000) : nil,
+          message_id: msg["mid"],
+          metadata: {
+            is_echo: msg["is_echo"],
+            quick_reply_payload: msg.dig("quick_reply", "payload")
+          }
+        )
+      end
+
+      def self.parse_postback(messaging)
+        postback = messaging["postback"]
+        sender = messaging.dig("sender", "id")
+
+        Event.new(
+          type: :callback,
+          channel: :messenger,
+          from: sender,
+          to: messaging.dig("recipient", "id"),
+          text: postback["payload"],
+          timestamp: messaging["timestamp"] ? Time.at(messaging["timestamp"].to_i / 1000) : nil,
+          metadata: {
+            title: postback["title"]
+          }
+        )
+      end
+    end
+  end
+end

data/lib/connector_ruby/channels/slack.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  module Channels
+    class Slack < Base
+      BASE_URL = "https://slack.com/api"
+
+      def initialize(bot_token: nil)
+        @bot_token = bot_token || ConnectorRuby.configuration.slack_bot_token
+        raise ConfigurationError, "Slack bot_token is required" unless @bot_token
+      end
+
+      def send_text(channel:, text:)
+        validate_send!(channel: channel, text: text)
+        payload = { channel: channel, text: text }
+        api_call("chat.postMessage", payload)
+      end
+
+      def send_buttons(channel:, text:, buttons:)
+        validate_send!(channel: channel, text: text)
+        actions = buttons.map do |btn|
+          {
+            type: "button",
+            text: { type: "plain_text", text: btn[:title] },
+            action_id: btn[:id],
+            value: btn[:id]
+          }
+        end
+
+        payload = {
+          channel: channel,
+          text: text,
+          blocks: [
+            { type: "section", text: { type: "mrkdwn", text: text } },
+            { type: "actions", elements: actions }
+          ]
+        }
+        api_call("chat.postMessage", payload)
+      end
+
+      def send_image(channel:, url:, caption: nil)
+        validate_send!(channel: channel)
+        blocks = [
+          {
+            type: "image",
+            image_url: url,
+            alt_text: caption || "image"
+          }
+        ]
+        blocks.first[:title] = { type: "plain_text", text: caption } if caption
+
+        payload = { channel: channel, text: caption || "Image", blocks: blocks }
+        api_call("chat.postMessage", payload)
+      end
+
+      def send_blocks(channel:, text:, blocks:)
+        validate_send!(channel: channel)
+        payload = { channel: channel, text: text, blocks: blocks }
+        api_call("chat.postMessage", payload)
+      end
+
+      def self.parse_webhook(body)
+        data = body.is_a?(String) ? JSON.parse(body) : body
+
+        # URL verification challenge
+        return { challenge: data["challenge"] } if data["type"] == "url_verification"
+
+        event = data["event"]
+        return nil unless event
+
+        case event["type"]
+        when "message"
+          return nil if event["subtype"] # skip bot messages, edits, etc.
+          parse_message(event)
+        when "app_mention"
+          parse_message(event)
+        end
+      end
+
+      private
+
+      def api_call(method, payload)
+        http_client.post("#{BASE_URL}/#{method}", body: payload, headers: auth_headers)
+      end
+
+      def auth_headers
+        { "Authorization" => "Bearer #{@bot_token}" }
+      end
+
+      def validate_send!(channel:, text: nil)
+        raise ConnectorRuby::Error, "Recipient 'channel' cannot be nil or empty" if channel.nil? || channel.to_s.strip.empty?
+        if text
+          raise ConnectorRuby::Error, "Text cannot be nil or empty" if text.nil? || text.to_s.strip.empty?
+        end
+      end
+
+      def self.parse_message(event)
+        Event.new(
+          type: :message,
+          channel: :slack,
+          from: event["user"],
+          text: event["text"],
+          timestamp: event["ts"] ? Time.at(event["ts"].to_f) : nil,
+          message_id: event["ts"],
+          metadata: {
+            channel_id: event["channel"],
+            channel_type: event["channel_type"],
+            team: event["team"],
+            thread_ts: event["thread_ts"]
+          }
+        )
+      end
+    end
+  end
+end

data/lib/connector_ruby/channels/telegram.rb

@@ -38,6 +38,24 @@ module ConnectorRuby
         api_call("sendPhoto", payload)
       end
 
+      def send_document(chat_id:, url:, caption: nil)
+        validate_send!(chat_id: chat_id)
+        payload = { chat_id: chat_id, document: url }
+        payload[:caption] = caption if caption
+        api_call("sendDocument", payload)
+      end
+
+      def send_location(chat_id:, latitude:, longitude:)
+        validate_send!(chat_id: chat_id)
+        payload = { chat_id: chat_id, latitude: latitude, longitude: longitude }
+        api_call("sendLocation", payload)
+      end
+
+      def send_typing(chat_id:)
+        validate_send!(chat_id: chat_id)
+        api_call("sendChatAction", { chat_id: chat_id, action: "typing" })
+      end
+
       def self.parse_webhook(body)
         data = body.is_a?(String) ? JSON.parse(body) : body
 

data/lib/connector_ruby/channels/whatsapp.rb

@@ -57,6 +57,103 @@ module ConnectorRuby
         post_message(payload)
       end
 
+      def send_template(to:, template_name:, language: "en", components: [])
+        validate_send!(to: to)
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "template",
+          template: {
+            name: template_name,
+            language: { code: language },
+            components: components
+          }
+        }
+        post_message(payload)
+      end
+
+      def send_document(to:, url:, filename: nil, caption: nil)
+        validate_send!(to: to)
+        doc = { link: url }
+        doc[:filename] = filename if filename
+        doc[:caption] = caption if caption
+
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "document",
+          document: doc
+        }
+        post_message(payload)
+      end
+
+      def send_location(to:, latitude:, longitude:, name: nil, address: nil)
+        validate_send!(to: to)
+        location = { latitude: latitude, longitude: longitude }
+        location[:name] = name if name
+        location[:address] = address if address
+
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "location",
+          location: location
+        }
+        post_message(payload)
+      end
+
+      def send_contact(to:, name:, phone:)
+        validate_send!(to: to)
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "contacts",
+          contacts: [{
+            name: { formatted_name: name },
+            phones: [{ phone: phone }]
+          }]
+        }
+        post_message(payload)
+      end
+
+      def send_reaction(to:, message_id:, emoji:)
+        validate_send!(to: to)
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "reaction",
+          reaction: { message_id: message_id, emoji: emoji }
+        }
+        post_message(payload)
+      end
+
+      def send_list(to:, body:, button_text:, sections:)
+        validate_send!(to: to, text: body)
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "interactive",
+          interactive: {
+            type: "list",
+            body: { text: body },
+            action: {
+              button: button_text,
+              sections: sections
+            }
+          }
+        }
+        post_message(payload)
+      end
+
+      def mark_as_read(message_id:)
+        payload = {
+          messaging_product: "whatsapp",
+          status: "read",
+          message_id: message_id
+        }
+        post_message(payload)
+      end
+
       def self.parse_webhook(body, signature: nil)
         data = body.is_a?(String) ? JSON.parse(body) : body
 

data/lib/connector_ruby/configuration.rb

@@ -4,6 +4,9 @@ module ConnectorRuby
   class Configuration
     attr_accessor :whatsapp_phone_number_id, :whatsapp_access_token,
                   :telegram_bot_token,
+                  :messenger_page_access_token,
+                  :line_channel_access_token,
+                  :slack_bot_token,
                   :http_timeout, :http_retries, :http_open_timeout,
                   :on_request, :on_response, :on_error
 
@@ -11,6 +14,9 @@ module ConnectorRuby
       @whatsapp_phone_number_id = nil
       @whatsapp_access_token = nil
       @telegram_bot_token = nil
+      @messenger_page_access_token = nil
+      @line_channel_access_token = nil
+      @slack_bot_token = nil
       @http_timeout = 30
       @http_retries = 3
       @http_open_timeout = 10

data/lib/connector_ruby/delivery_tracker.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  class DeliveryTracker
+    attr_reader :entries
+
+    def initialize
+      @entries = {}
+      @callbacks = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def track(message_id, metadata: {})
+      @entries[message_id] = {
+        status: :sent,
+        sent_at: Time.now,
+        metadata: metadata,
+        history: [{ status: :sent, at: Time.now }]
+      }
+    end
+
+    def update(message_id, status:)
+      entry = @entries[message_id]
+      return nil unless entry
+
+      entry[:status] = status.to_sym
+      entry[:history] << { status: status.to_sym, at: Time.now }
+
+      fire(status.to_sym, message_id, entry)
+      entry
+    end
+
+    def status(message_id)
+      @entries.dig(message_id, :status)
+    end
+
+    def on(status, &block)
+      @callbacks[status.to_sym] << block
+    end
+
+    def pending
+      @entries.select { |_, v| v[:status] == :sent }
+    end
+
+    def delivered
+      @entries.select { |_, v| v[:status] == :delivered }
+    end
+
+    def read
+      @entries.select { |_, v| v[:status] == :read }
+    end
+
+    private
+
+    def fire(status, message_id, entry)
+      @callbacks[status].each { |cb| cb.call(message_id, entry) }
+    end
+  end
+end

data/lib/connector_ruby/message.rb

@@ -4,9 +4,14 @@ module ConnectorRuby
   class Message
     attr_reader :type, :to, :text, :buttons, :image_url, :caption, :metadata
 
-    TYPES = %i[text buttons image template].freeze
+    TYPES = %i[text buttons image template document location contact reaction list].freeze
 
-    def initialize(type:, to:, text: nil, buttons: nil, image_url: nil, caption: nil, metadata: {})
+    attr_reader :document_url, :filename, :latitude, :longitude,
+                :location_name, :address, :phone, :contact_name,
+                :template_name, :language, :components,
+                :emoji, :sections, :button_text
+
+    def initialize(type:, to:, text: nil, buttons: nil, image_url: nil, caption: nil, metadata: {}, **extra)
       @type = type
       @to = to
       @text = text
@@ -14,8 +19,10 @@ module ConnectorRuby
       @image_url = image_url
       @caption = caption
       @metadata = metadata
+      extra.each { |k, v| instance_variable_set(:"@#{k}", v) }
     end
 
+    # Factory methods
     def self.text(to:, text:)
       new(type: :text, to: to, text: text)
     end
@@ -28,6 +35,24 @@ module ConnectorRuby
       new(type: :image, to: to, image_url: url, caption: caption)
     end
 
+    def self.document(to:, url:, filename: nil, caption: nil)
+      new(type: :document, to: to, document_url: url, filename: filename, caption: caption)
+    end
+
+    def self.location(to:, latitude:, longitude:, name: nil, address: nil)
+      new(type: :location, to: to, latitude: latitude, longitude: longitude,
+          location_name: name, address: address)
+    end
+
+    def self.contact(to:, name:, phone:)
+      new(type: :contact, to: to, contact_name: name, phone: phone)
+    end
+
+    # Builder DSL
+    def self.build
+      Builder.new
+    end
+
     def to_h
       {
         type: @type,
@@ -39,5 +64,61 @@ module ConnectorRuby
         metadata: @metadata
       }.compact
     end
+
+    class Builder
+      def initialize
+        @attrs = { metadata: {} }
+      end
+
+      def to(recipient)
+        @attrs[:to] = recipient
+        self
+      end
+
+      def text(content)
+        @attrs[:type] = :text
+        @attrs[:text] = content
+        self
+      end
+
+      def buttons(btns)
+        @attrs[:type] = :buttons
+        @attrs[:buttons] = btns
+        self
+      end
+
+      def image(url, caption: nil)
+        @attrs[:type] = :image
+        @attrs[:image_url] = url
+        @attrs[:caption] = caption
+        self
+      end
+
+      def document(url, filename: nil)
+        @attrs[:type] = :document
+        @attrs[:document_url] = url
+        @attrs[:filename] = filename
+        self
+      end
+
+      def location(lat, lng, name: nil)
+        @attrs[:type] = :location
+        @attrs[:latitude] = lat
+        @attrs[:longitude] = lng
+        @attrs[:location_name] = name
+        self
+      end
+
+      def metadata(hash)
+        @attrs[:metadata] = hash
+        self
+      end
+
+      def build
+        raise ConnectorRuby::Error, "Message requires a recipient" unless @attrs[:to]
+        raise ConnectorRuby::Error, "Message requires a type" unless @attrs[:type]
+        Message.new(**@attrs)
+      end
+    end
   end
 end

data/lib/connector_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConnectorRuby
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/connector_ruby.rb

@@ -10,6 +10,11 @@ require_relative "connector_ruby/webhook_verifier"
 require_relative "connector_ruby/channels/base"
 require_relative "connector_ruby/channels/whatsapp"
 require_relative "connector_ruby/channels/telegram"
+require_relative "connector_ruby/channels/messenger"
+require_relative "connector_ruby/channels/line"
+require_relative "connector_ruby/channels/slack"
+require_relative "connector_ruby/batch_sender"
+require_relative "connector_ruby/delivery_tracker"
 
 module ConnectorRuby
   class << self
@@ -29,4 +34,7 @@ module ConnectorRuby
   # Convenience aliases
   WhatsApp = Channels::WhatsApp
   Telegram = Channels::Telegram
+  Messenger = Channels::Messenger
+  Line = Channels::Line
+  Slack = Channels::Slack
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: connector-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Johannes Dwi Cahyo
@@ -65,10 +65,15 @@ files:
 - Rakefile
 - connector-ruby.gemspec
 - lib/connector_ruby.rb
+- lib/connector_ruby/batch_sender.rb
 - lib/connector_ruby/channels/base.rb
+- lib/connector_ruby/channels/line.rb
+- lib/connector_ruby/channels/messenger.rb
+- lib/connector_ruby/channels/slack.rb
 - lib/connector_ruby/channels/telegram.rb
 - lib/connector_ruby/channels/whatsapp.rb
 - lib/connector_ruby/configuration.rb
+- lib/connector_ruby/delivery_tracker.rb
 - lib/connector_ruby/error.rb
 - lib/connector_ruby/event.rb
 - lib/connector_ruby/http_client.rb