mailflow 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f617724f63d55f15c40dd14b1b7156f29d7d0dfccf267c11cf9f7f8a5191424a
+  data.tar.gz: efe48e465aeb2b3c6f41989410277a814b0c34691e2f4725c2f4470ea746a1af
+SHA512:
+  metadata.gz: f376c6309c998b0d778b63aacc595b51cf6985d4f21841ab11b15cdc6f1bd793ed3ba0b2f5a60c9e61f1e90397b40eefabe05cd8dd3b8fde5c6574cb797e5f83
+  data.tar.gz: f653456b8f272d9255723cbf8b7e8d09e0894c80e56db4eb4df18190da2a1fe5716de889b70573eddd807a9682774a510135f50faa204b3e455d5b94c842a851

data/lib/mailflow/attachment.rb

@@ -0,0 +1,15 @@
+require 'base64'
+
+module Mailflow
+  class Attachment
+    attr_reader :filename, :content_type, :size, :hash, :data
+
+    def initialize(attributes)
+      @filename = attributes['filename']
+      @content_type = attributes['content_type']
+      @size = attributes['size']
+      @hash = attributes['hash']
+      @data = Base64.decode64(attributes['data'])
+    end
+  end
+end

data/lib/mailflow/client.rb

@@ -0,0 +1,39 @@
+require 'moonrope_client'
+require 'mailflow/message_scope'
+require 'mailflow/send_message'
+require 'mailflow/send_raw_message'
+
+module Mailflow
+  class Client
+    attr_reader :host, :server_key
+
+    def self.instance
+      @instance ||= new(Mailflow.config.host, Mailflow.config.server_key)
+    end
+
+    def initialize(host, server_key)
+      @host = host
+      @server_key = server_key
+    end
+
+    def messages
+      @messages ||= MessageScope.new(self)
+    end
+
+    def send_message(&block)
+      send_message = SendMessage.new(self)
+      block.call(send_message)
+      send_message.send!
+    end
+
+    def send_raw_message(&block)
+      send_raw_message = SendRawMessage.new(self)
+      block.call(send_raw_message)
+      send_raw_message.send!
+    end
+
+    def moonrope
+      @moonrope ||= MoonropeClient::Connection.new(@host, headers: { 'X-Server-API-Key' => @server_key }, ssl: true)
+    end
+  end
+end

data/lib/mailflow/config.rb

@@ -0,0 +1,18 @@
+module Mailflow
+  class Config
+    attr_accessor :host, :server_key
+
+    def initialize
+      @host = ENV['MAILFLOW_HOST']
+      @server_key = ENV['MAILFLOW_KEY']
+    end
+
+    def host
+      @host ||= raise(Error, "The host has not been configured. Please set it using the `Mailflow.configure` block or utilize the `MAILFLOW_HOST` environment variable.")
+    end
+
+    def server_key
+      @server_key ||= raise(Error, "The server key has not been configured. Please set it using the `Mailflow.configure` block or make use of the `MAILFLOW_KEY` environment variable.")
+    end
+  end
+end

data/lib/mailflow/error.rb

@@ -0,0 +1,30 @@
+module Mailflow
+  class Error < StandardError; end
+
+  class MessageNotFound < Error
+    def initialize(id)
+      @id = id
+    end
+
+    def message
+      "No message was found that matches the provided ID. '#{@id}'"
+    end
+
+    alias to_s message
+  end
+
+  class SendError < Error
+    def initialize(code, error_message)
+      @code = code
+      @error_message = error_message
+    end
+
+    attr_reader :code, :error_message
+
+    def message
+      "[#{@code}] #{@error_message}"
+    end
+
+    alias to_s message
+  end
+end

data/lib/mailflow/header_set.rb

@@ -0,0 +1,25 @@
+module Mailflow
+  class HeaderSet
+    attr_reader :headers
+
+    def initialize(headers)
+      @headers = headers.transform_keys(&:to_s).transform_keys(&:downcase)
+    end
+
+    def [](name)
+      headers[name.to_s.downcase]
+    end
+
+    def has_key?(key)
+      headers.has_key?(key.to_s.downcase)
+    end
+
+    def method_missing(*args, &block)
+      headers.send(*args, &block)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      headers.respond_to?(method_name) || super
+    end
+  end
+end

data/lib/mailflow/message.rb

@@ -0,0 +1,104 @@
+require 'mailflow/error'
+require 'mailflow/header_set'
+require 'mailflow/attachment'
+
+module Mailflow
+  class Message
+    attr_reader :id, :token, :headers, :attachments, :raw_message
+
+    def self.find_with_scope(scope, id)
+      api = scope.client.moonrope.messages.message(id: id.to_i, _expansions: scope.expansions)
+      if api.success?
+        Message.new(scope.client, api.data)
+      elsif api.status == 'error' && api.data['code'] == 'MessageNotFound'
+        raise MessageNotFound.new(id)
+      else
+        raise Error, "Couldn't load message from API (#{api.data})"
+      end
+    end
+
+    def self.method_missing(name, *args, &block)
+      if MessageScope.instance_methods(false).include?(name)
+        Mailflow::Client.instance.messages.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def initialize(client, attributes)
+      @client = client
+      @attributes = attributes
+      @id = @attributes['id']
+      @token = @attributes['token']
+      @headers = HeaderSet.new(from_expansion(:headers))
+      @attachments = from_expansion(:attachments).map { |a| Attachment.new(a) }
+      @raw_message = Base64.decode64(from_expansion(:raw_message))
+    end
+
+    ATTRIBUTES = {
+      status: [:status, :status],
+      last_delivery_attempt: [:status, :last_delivery_attempt, :timestamp],
+      held?: [:status, :held, :boolean],
+      hold_expiry: [:status, :hold_expiry, :timestamp],
+      rcpt_to: [:details, :rcpt_to],
+      mail_from: [:details, :mail_from],
+      subject: [:details, :subject],
+      message_id: [:details, :message_id],
+      timestamp: [:details, :timestamp, :timestamp],
+      direction: [:details, :direction],
+      size: [:details, :size],
+      bounce?: [:details, :bounce, :boolean],
+      bounce_for_id: [:details, :bounce],
+      tag: [:details, :tag],
+      received_with_ssl?: [:details, :received_with_ssl, :boolean],
+      inspected?: [:inspection, :inspected, :boolean],
+      spam?: [:inspection, :spam, :boolean],
+      spam_score: [:inspection, :spam_score],
+      threat?: [:inspection, :threat, :boolean],
+      threat_details: [:inspection, :threat_details],
+      plain_body: [:plain_body],
+      html_body: [:html_body]
+    }
+
+    def method_missing(name, *args, &block)
+      if mapping = ATTRIBUTES[name.to_sym]
+        expansion, attribute, type = mapping
+        value = from_expansion(expansion, attribute)
+        case type
+          when :timestamp
+            value ? Time.at(value) : nil
+          when :boolean
+            value == 1
+          else
+            value
+        end
+      else
+        super
+      end
+    end
+
+    private
+
+      def from_expansion(expansion, attribute = nil, loaded = false)
+        if @attributes.key?(expansion.to_s) || loaded
+          attribute ? @attributes[expansion.to_s][attribute.to_s] : @attributes[expansion.to_s]
+        else
+          load_expansions(expansion)
+          from_expansion(expansion, attribute, true)
+        end
+      end
+
+      def load_expansions(*names)
+        api = @client.moonrope.messages.message(id: self.id, _expansions: names)
+        if api.success?
+          names.each do |expansion_name|
+            if api.data.key?(expansion_name.to_s)
+              @attributes[expansion_name.to_s] = api.data[expansion_name.to_s]
+            end
+          end
+        else
+          raise Mailflow::Error, "Couldn't load expansion data (#{names.join(', ')}) for message ID '#{self.id}'"
+        end
+      end
+  end
+end

data/lib/mailflow/message_scope.rb

@@ -0,0 +1,26 @@
+require 'mailflow/message'
+
+module Mailflow
+  class MessageScope
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+      @includes = []
+    end
+
+    def includes(*includes)
+      @includes.concat(includes)
+      self
+    end
+
+    def expansions
+      return true if @includes.include?(:all)
+      @includes.map(&:to_s)
+    end
+
+    def find_by_id(id)
+      Message.find_with_scope(self, id)
+    end
+  end
+end

data/lib/mailflow/send_message.rb

@@ -0,0 +1,69 @@
+require 'base64'
+require 'mailflow/send_result'
+
+module Mailflow
+  class SendMessage
+    attr_reader :client
+    attr_accessor :attributes
+
+    def initialize(client)
+      @client = client
+      initialize_attributes
+    end
+
+    def send!
+      api = client.moonrope.request(:send, :message, attributes)
+      return SendResult.new(client, api.data) if api.success?
+
+      raise SendError.new(api.data['code'], api.data['message']) if api.status == 'error'
+
+      raise Error, "API response unsuccessful: #{api.data}"
+    end
+
+    %i[from sender subject tag reply_to plain_body html_body].each do |method_name|
+      define_method(method_name) do |value|
+        attributes[method_name] = value
+      end
+    end
+
+    %i[to cc bcc].each do |method_name|
+      define_method(method_name) do |*addresses|
+        add_addresses(method_name, addresses)
+      end
+    end
+
+    def header(key, value)
+      attributes[:headers][key.to_s] = value
+    end
+
+    def attach(filename, content_type, data)
+      attributes[:attachments] << {
+        name: filename,
+        content_type: content_type,
+        data: Base64.encode64(data)
+      }
+    end
+
+    private
+
+      def initialize_attributes
+        @attributes = {
+          to: [],
+          cc: [],
+          bcc: [],
+          headers: {},
+          attachments: []
+        }
+      end
+
+      def add_addresses(type, addresses)
+        sanitized_addresses = sanitize_addresses(addresses)
+        attributes[type] += sanitized_addresses
+      end
+
+      def sanitize_addresses(addresses)
+        # implement address sanitization logic here
+        addresses
+      end
+  end
+end

data/lib/mailflow/send_raw_message.rb

@@ -0,0 +1,43 @@
+require 'base64'
+require 'mailflow/send_result'
+
+module Mailflow
+  class SendRawMessage
+    attr_accessor :attributes
+
+    def initialize(client)
+      @client = client
+      @attributes = {}
+    end
+
+    def send!
+      api = @client.moonrope.request(:send, :raw, @attributes)
+      handle_api_response(api)
+    end
+
+    def mail_from(address)
+      @attributes[:mail_from] = address
+    end
+
+    def rcpt_to(*addresses)
+      @attributes[:rcpt_to] ||= []
+      @attributes[:rcpt_to] += addresses
+    end
+
+    def data(data)
+      @attributes[:data] = Base64.encode64(data)
+    end
+
+    private
+
+      def handle_api_response(api)
+        if api.success?
+          SendResult.new(@client, api.data)
+        elsif api.status == 'error'
+          raise SendError.new(api.data['code'], api.data['message'])
+        else
+          raise Error, "Couldn't send message"
+        end
+      end
+  end
+end

data/lib/mailflow/send_result.rb

@@ -0,0 +1,27 @@
+module Mailflow
+  class SendResult
+    attr_reader :message_id, :recipients
+
+    def initialize(client, result)
+      @client = client
+      @message_id = result['message_id']
+      @recipients = build_recipients(result['messages'])
+    end
+
+    def [](recipient)
+      recipients[recipient.to_s.downcase]
+    end
+
+    def size
+      recipients.size
+    end
+
+    private
+
+      def build_recipients(messages)
+        messages.each_with_object({}) do |(recipient, message_details), hash|
+          hash[recipient.to_s.downcase] = Message.new(@client, message_details)
+        end
+      end
+  end
+end

data/lib/mailflow/version.rb

@@ -0,0 +1,3 @@
+module Mailflow
+  VERSION = '0.0.1'
+end

data/lib/mailflow.rb

@@ -0,0 +1,22 @@
+require 'mailflow'
+require 'mailflow/client'
+require 'mailflow/config'
+
+module Mailflow
+  class << self
+    attr_reader :config
+
+    def configure
+      @config ||= Config.new
+      yield config if block_given?
+    end
+
+    def send_message(&block)
+      Mailflow::Client.instance.send_message(&block)
+    end
+
+    def send_raw_message(&block)
+      Mailflow::Client.instance.send_raw_message(&block)
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: mailflow
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mailflow
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: moonrope-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Mailflow Ruby library
+email:
+- support@mailflow.cloud
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mailflow.rb
+- lib/mailflow/attachment.rb
+- lib/mailflow/client.rb
+- lib/mailflow/config.rb
+- lib/mailflow/error.rb
+- lib/mailflow/header_set.rb
+- lib/mailflow/message.rb
+- lib/mailflow/message_scope.rb
+- lib/mailflow/send_message.rb
+- lib/mailflow/send_raw_message.rb
+- lib/mailflow/send_result.rb
+- lib/mailflow/version.rb
+homepage: https://mailflow.cloud
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: Mailflow Ruby library
+test_files: []