rails_mailersend 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2b230567dfd55a4b5874d501dd4c25ff67cea0fc2cb80972001c97f37e81bde1
+  data.tar.gz: c1cd9f9a8031b4457299aa5c5d38bb3e693efdbf2fed4284aa629f8f2df27a24
+SHA512:
+  metadata.gz: e840f9652bfc94d57480738c8642b50be72af6dafc689f5e79c0ed41c1866b57ddc569c6d9de53d0bb3f854303ce7bb4c6b4f767886c8dc740f8bf615334e15f
+  data.tar.gz: 0375b493a5bec2b0782c224d7fe74951426fc132a08888d78464d5f7beda3345d43e21a8109420803a88a1bf4ed0a458c80f5d269406e95fa2cc5f91539eb098

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dan Loman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# rails_mailersend
+
+MailerSend for Rails: an Action Mailer delivery method, and an optional Action
+Mailbox ingress for inbound mail.
+
+This existed as a copied `lib/action_mailer/mailersend_delivery.rb` in four apps.
+Three of the copies were identical and one had drifted ahead with typed errors and
+a nil-text-part fix — which is the usual shape of copied code, and the reason for
+the gem.
+
+## Install
+
+```ruby
+gem "rails_mailersend"
+```
+
+The name is inverted because `mailersend_rails` on RubyGems is an unrelated gem by
+another author, and RubyGems refuses a new name that differs from an existing one
+only by its separators — so `mailersend-rails` is out too. Nothing inside moved
+for it: the constant is `MailersendRails` in `lib/mailersend_rails.rb`, and
+one-line `lib/rails_mailersend.rb` is there so Bundler's auto-require lands
+somewhere real without a `require:` option in your Gemfile.
+
+```ruby
+# config/environments/production.rb
+config.action_mailer.delivery_method = :mailersend
+```
+
+That's the whole outbound setup. Adding the gem registers the delivery method; no
+initializer and no `require` of a file under `lib/`.
+
+## Configuration
+
+The token is read from Rails credentials, falling back to the environment:
+
+```yaml
+# rails credentials:edit
+mailersend:
+  api_token: ms_...
+  inbound_secret: ...   # only for inbound
+```
+
+```bash
+MAILERSEND_API_TOKEN=ms_...
+MAILERSEND_INBOUND_SECRET=...
+```
+
+Or set it explicitly:
+
+```ruby
+MailersendRails.configure do |config|
+  config.api_token = Vault.read("mailersend/token")
+  config.log_tag = "inbound"          # prefixes the ingress log lines
+  config.header_prefix = "X-Acme-"    # namespaces the headers the ingress stamps
+end
+```
+
+`header_prefix` defaults to `X-Mailersend-`, and is worth setting once to the
+app's own house prefix. The names go into messages that are then stored, so
+changing it later leaves every message already on disk answering to a name
+nothing reads.
+
+Delivery failures raise `MailersendRails::DeliveryMethod::DeliveryError` rather
+than returning quietly, so the enqueuing job retries and the failure is visible.
+For an app where sign-in is by magic link, a swallowed delivery error looks
+exactly like a broken app to the person waiting.
+
+## Inbound mail
+
+Optional, and only loads when the app has Action Mailbox. MailerSend posts the
+complete RFC822 message, so unlike the Mailgun or Postmark ingresses there is
+nothing to rebuild — this hands the message straight to Action Mailbox and lets
+`ApplicationMailbox` routing decide what it is.
+
+```ruby
+# app/controllers/inbound/mailersend_controller.rb
+class Inbound::MailersendController < MailersendRails::Inbound::Controller
+end
+
+# config/routes.rb
+post "inbound/mailersend" => "inbound/mailersend#create"
+```
+
+Point a MailerSend inbound route at that URL and put the route's secret in
+`mailersend.inbound_secret`.
+
+Five things it handles that are easy to get wrong:
+
+**The validation ping is answered before the secret is checked.** A route's secret
+is generated when the route is saved, so there is no secret to configure until the
+route exists — and the route cannot exist while the endpoint refuses the ping for
+want of one. Answering first breaks the deadlock. It is safe because it does
+nothing: no message read, nothing created, nothing disclosed.
+
+**Envelope recipients are stamped onto the message as `X-Original-To`.** Routing
+keys on the recipient, and the headers frequently do not carry it: a sender who
+Bccs you leaves no header at all, because stripping Bcc in transit is the entire
+point of Bcc. The address survives only in the SMTP envelope. This is the same
+move Action Mailbox's own Postmark ingress makes.
+
+**Envelope addresses are filtered before being written into headers.** Header
+injection would otherwise be one crafted address away — an address containing a
+newline could add arbitrary headers, or close the header block and forge a body.
+
+**MailerSend's SPF and DKIM verdicts are stamped on as `<prefix>SPF` and
+`<prefix>DKIM`.** They are the one part of the payload a forger cannot write: a
+`From:` line is whatever the sender typed, and these are the only evidence about
+it that arrives from outside the message. Each is normalized to one word from a
+fixed list — `pass`, `fail`, `softfail`, `neutral`, or `none` — so nothing in the
+payload can put anything else into a header. `none` means MailerSend said nothing,
+which is distinguishable from a message that never came through the ingress at
+all, since that one has no such header.
+
+**Headers in the ingress's own namespace are cleared off an arriving message
+before its own are stamped.** Otherwise a sender supplies the verdict that is
+supposed to judge them, or an `X-Original-To` naming somewhere the message was
+never delivered. The whole prefix is reserved, and so is `X-Original-To`. A
+message carrying none of them is passed through byte for byte.
+
+The signature is verified against the exact bytes MailerSend signed, before
+anything parses them; checking against a re-serialised body would verify our own
+JSON encoder rather than the sender.
+
+## Tests
+
+```bash
+bundle exec rake test
+```
+
+The parts most worth getting right — the payload guard rails and signature
+verification — are plain Ruby and tested without a Rails app.

data/lib/mailersend_rails/configuration.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module MailersendRails
+  # Credentials first, ENV as the escape hatch for CI and one-off scripts.
+  #
+  # Plain Ruby on purpose -- this and the inbound helpers load without Rails, so
+  # they can be tested on their own.
+  #
+  # Every app that copied this code hard-coded the credentials path, which is the
+  # main reason the copies drifted: one app keeps the token somewhere else and the
+  # file forks. Both sources are checked here so neither app has to patch it.
+  class Configuration
+    class MissingApiToken < StandardError; end
+    class MissingInboundSecret < StandardError; end
+
+    DEFAULT_HEADER_PREFIX = "X-Mailersend-"
+
+    attr_writer :api_token, :inbound_secret
+    attr_accessor :log_tag
+    attr_reader :header_prefix
+
+    def initialize
+      @log_tag = "mailersend"
+      @header_prefix = DEFAULT_HEADER_PREFIX
+    end
+
+    # The namespace for the headers the ingress stamps onto an arriving message,
+    # and the same namespace it clears off one first.
+    #
+    # Worth setting to the app's own house prefix, and worth setting once: these
+    # names are written into messages that are then stored, so changing the prefix
+    # later leaves every message already on disk answering to a name nothing reads.
+    #
+    # Normalized to end in a hyphen, because `X-Acme` and `X-Acme-` differ by one
+    # character and the first one produces `X-AcmeSPF`.
+    def header_prefix=(value)
+      prefix = value.to_s.strip
+      raise ArgumentError, "header_prefix cannot be blank" if prefix.empty?
+
+      @header_prefix = prefix.end_with?("-") ? prefix : "#{prefix}-"
+    end
+
+    def api_token
+      @api_token ||= credential(:api_token) || ENV["MAILERSEND_API_TOKEN"]
+    end
+
+    def api_token!
+      token = api_token
+      return token unless token.nil? || token.empty?
+
+      raise MissingApiToken, "No MailerSend API token. Set credentials mailersend.api_token, " \
+                             "or the MAILERSEND_API_TOKEN environment variable. Outbound mail " \
+                             "cannot be sent without it."
+    end
+
+    # The inbound *route's* secret, shown under the route URL in MailerSend's
+    # domain settings. Not the signing secret used for activity webhooks -- they
+    # are different values, and swapping them fails every request on signature.
+    def inbound_secret
+      @inbound_secret ||= credential(:inbound_secret) || ENV["MAILERSEND_INBOUND_SECRET"]
+    end
+
+    def inbound_secret?
+      secret = inbound_secret
+      !(secret.nil? || secret.empty?)
+    end
+
+    private
+      def credential(key)
+        return nil unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+
+        Rails.application.credentials.dig(:mailersend, key)
+      end
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+
+    def reset_configuration!
+      @config = nil
+    end
+  end
+end

data/lib/mailersend_rails/delivery_method.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+require_relative "version"
+
+module MailersendRails
+  # An Action Mailer delivery method for MailerSend.
+  #
+  # Failures raise rather than returning quietly, so the enqueuing job retries and
+  # the error is visible. Swallowing them means a magic link that silently goes
+  # nowhere, which looks to the person waiting for it exactly like a broken app.
+  #
+  # The API is posted to directly rather than through mailersend-ruby. Sending is
+  # a single POST of a JSON body this class already assembles itself, and the SDK
+  # asks a lot in return: http, which it pins a major version behind and so holds
+  # back every application that carries it, plus an FFI parser that has to be
+  # compiled into every image.
+  class DeliveryMethod
+    class DeliveryError < StandardError; end
+
+    DEFAULT_ENDPOINT = "https://api.mailersend.com/v1/email"
+
+    # The SDK's timeouts, kept because they are sensible: long enough for a slow
+    # accept, short enough that a wedged connection fails into the retry rather
+    # than occupying a worker.
+    OPEN_TIMEOUT = 15
+    READ_TIMEOUT = 30
+
+    attr_reader :settings
+
+    def initialize(settings = {})
+      @settings = settings || {}
+    end
+
+    def deliver!(mail)
+      response = post(payload_for(mail))
+
+      return response if success?(response)
+
+      raise DeliveryError, "MailerSend returned #{response.code}: #{response.body}"
+    end
+
+    private
+      # MailerSend treats an absent field as "not set" but rejects several of them
+      # sent empty, so anything we have nothing for is dropped rather than blanked.
+      def payload_for(mail)
+        {
+          "from" => address_in(mail[:from]),
+          "to" => addresses_in(mail[:to]),
+          "cc" => addresses_in(mail[:cc]),
+          "bcc" => addresses_in(mail[:bcc]),
+          "reply_to" => Array(mail.reply_to).empty? ? {} : address_in(mail[:reply_to]),
+          "subject" => mail.subject,
+          "text" => mail.text_part&.body&.decoded,
+          "html" => html_for(mail)
+        }.reject { |_, value| omit?(value) }
+      end
+
+      def html_for(mail)
+        mail.html_part&.body&.decoded || mail.body.decoded
+      end
+
+      def address_in(field)
+        as_recipient(Mail::Address.new(field.to_s))
+      end
+
+      # `mail[:to]` is one field whose `to_s` is the whole comma-joined list, and
+      # `Mail::Address.new` on that parses the first address and drops the rest --
+      # which is how a three-person ops alias arrives as one person, silently and
+      # only in production. The field already holds the addresses parsed.
+      def addresses_in(field)
+        Array(field&.addrs).map { |address| as_recipient(address) }
+      end
+
+      def as_recipient(address)
+        { "email" => address.address, "name" => address.display_name }
+      end
+
+      def omit?(value)
+        value == [] || value == {} || value.to_s.strip.empty?
+      end
+
+      def success?(response)
+        response.code.to_s.start_with?("2")
+      end
+
+      # Overridable so a test, or a staging environment, can point somewhere other
+      # than the live API.
+      def endpoint
+        @endpoint ||= URI(settings[:endpoint] || DEFAULT_ENDPOINT)
+      end
+
+      def post(payload)
+        request = Net::HTTP::Post.new(endpoint)
+        request["Authorization"] = "Bearer #{MailersendRails.config.api_token!}"
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+        request["User-Agent"] = "mailersend_rails/#{MailersendRails::VERSION}"
+        request.body = JSON.generate(payload)
+
+        Net::HTTP.start(
+          endpoint.hostname, endpoint.port,
+          use_ssl: endpoint.scheme == "https",
+          open_timeout: OPEN_TIMEOUT, read_timeout: READ_TIMEOUT
+        ) { |http| http.request(request) }
+      end
+  end
+end

data/lib/mailersend_rails/inbound/controller.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module MailersendRails
+  module Inbound
+    # Every email that arrives, from anywhere, for any reason.
+    #
+    # This is an ingress, not a feature: it knows nothing about what the mail is
+    # for. MailerSend posts the message as JSON, `data.raw` is the complete RFC822
+    # message, and this hands it to Action Mailbox. `ApplicationMailbox` routing
+    # then decides what the message *is*. A second kind of inbound mail becomes a
+    # new mailbox and one routing line, not a second endpoint, second secret and
+    # second DNS record.
+    #
+    # Mount it in the host app:
+    #
+    #   class Inbound::MailersendController < MailersendRails::Inbound::Controller
+    #   end
+    #
+    #   post "inbound/mailersend" => "inbound/mailersend#create"
+    #
+    # Deliberately an ActionController::Base rather than the app's own base class:
+    # an ingress has no session, no tenancy and no browser, and a modern-browser
+    # gate would answer a webhook with 406.
+    class Controller < ActionController::Base
+      skip_forgery_protection
+
+      # Order matters. The validation ping is answered before the secret is
+      # required, because the two deadlock otherwise -- see answer_validation_ping.
+      before_action :answer_validation_ping
+      before_action :require_secret
+      before_action :verify_signature
+
+      def create
+        return reject("posted a body we couldn't read as a JSON object") unless payload.parseable?
+        return reject("posted a message with no raw MIME") unless payload.raw_message?
+
+        # Rescues RecordNotUnique internally and returns nil, so a retried webhook
+        # is already a no-op here.
+        ActionMailbox::InboundEmail.create_and_extract_message_id!(
+          payload.message_with_transport_headers
+        )
+
+        head :no_content
+      end
+
+      private
+        # MailerSend checks a new route by posting {"type": "webhook.test"}.
+        #
+        # It has to be answered before the secret is checked, because the two
+        # deadlock: a route's secret is generated when the route is saved, so
+        # there is no secret to configure until the route exists, and the route
+        # cannot exist while we refuse the ping for want of one.
+        #
+        # Safe because it does nothing -- no message is read, nothing is created,
+        # nothing is disclosed. Its signature is deliberately not verified, since
+        # MailerSend signs the test with a secret published in their own docs, so
+        # checking it would prove nothing about who sent it.
+        def answer_validation_ping
+          return unless payload.validation_ping?
+
+          log(:info, "answered a validation ping")
+          head :ok
+        end
+
+        # Fails closed, and loudly. An unconfigured secret would otherwise make
+        # every comparison fail against an empty key -- indistinguishable in the
+        # log from a provider misconfiguration, and the fix is entirely different.
+        def require_secret
+          return if MailersendRails.config.inbound_secret?
+
+          log(:error, "no inbound secret configured; refusing inbound mail")
+          head :service_unavailable
+        end
+
+        def verify_signature
+          return if Signature.valid?(
+            secret: MailersendRails.config.inbound_secret,
+            body: request.raw_post,
+            given: request.headers["Signature"]
+          )
+
+          log(:warn, "rejected an inbound post with a bad signature")
+          head :unauthorized
+        end
+
+        def payload
+          @payload ||= Payload.parse(request.raw_post)
+        end
+
+        def reject(reason)
+          log(:warn, reason)
+          head :unprocessable_content
+        end
+
+        def log(level, message)
+          Rails.logger.public_send(level, "[#{MailersendRails.config.log_tag}] #{message}")
+        end
+    end
+  end
+end

data/lib/mailersend_rails/inbound/payload.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "../configuration"
+
+module MailersendRails
+  module Inbound
+    # Everything about an inbound MailerSend post that can be decided without a
+    # request object. Pulled out of the controller so the parts most worth getting
+    # right -- the header-injection guard, the envelope-recipient stamping and the
+    # transport's verdicts -- are testable on their own.
+    class Payload
+      # A plausible single address. Anything else is dropped rather than trusted.
+      ADDRESS = /\A[^\s<>@]+@[^\s<>@]+\z/
+      MAX_RECIPIENTS = 10
+
+      # The one header the ingress writes under a name it doesn't own: Action
+      # Mailbox's own Postmark ingress writes this, and code downstream looks for
+      # it by that name, so it isn't namespaced. It is still ours, though, and a
+      # sender's copy of it is cleared with the rest.
+      ORIGINAL_TO = "X-Original-To"
+
+      # MailerSend reports SPF in received-SPF shorthand -- `+` pass, `-` fail,
+      # `~` softfail, `?` neutral -- and DKIM as a boolean. Each becomes one word
+      # from a fixed list, so nothing in the payload can put anything else into a
+      # header.
+      SPF_CODES = {
+        "+" => "pass", "-" => "fail", "~" => "softfail", "?" => "neutral",
+        "pass" => "pass", "fail" => "fail", "softfail" => "softfail", "neutral" => "neutral"
+      }.freeze
+
+      def self.parse(body)
+        new(JSON.parse(body.to_s))
+      rescue JSON::ParserError
+        new(nil)
+      end
+
+      def initialize(data)
+        @data = data.is_a?(Hash) ? data : nil
+      end
+
+      def parseable? = !@data.nil?
+
+      def to_h = @data || {}
+
+      # MailerSend won't save a route whose endpoint doesn't answer, and it checks
+      # by posting {"type": "webhook.test"}.
+      def validation_ping? = to_h["type"] == "webhook.test"
+
+      # The complete RFC822 message. MailerSend hands it over intact, which is why
+      # there is nothing to rebuild here the way the Mailgun or Postmark ingresses
+      # have to.
+      def raw_message = to_h.dig("data", "raw")
+
+      def raw_message? = raw_message.to_s.strip != ""
+
+      # Who the message was actually delivered to.
+      #
+      # Routing keys on the recipient, and the headers frequently don't carry it:
+      # a sender who Bcc's you leaves no header at all, because stripping Bcc in
+      # transit is the entire point of Bcc. The address survives only in the SMTP
+      # envelope.
+      def envelope_recipients
+        Array(to_h.dig("data", "recipients", "rcptTo"))
+          .filter_map { |entry| entry["email"] if entry.is_a?(Hash) }
+          .map { |address| address.to_s.strip }
+          .grep(ADDRESS)
+          .uniq
+          .first(MAX_RECIPIENTS)
+      end
+
+      # What MailerSend's own checks made of the sender, in one word each. "none"
+      # when it said nothing, so a reader downstream can tell a failed check from
+      # a message that never passed through here at all.
+      def spf_verdict
+        check = to_h.dig("data", "spf_check")
+        code = check.is_a?(Hash) ? check["code"] : check
+
+        SPF_CODES.fetch(code.to_s.strip.downcase, "none")
+      end
+
+      def dkim_verdict
+        case to_h.dig("data", "dkim_check")
+        when true, "true", "pass" then "pass"
+        when false, "false", "fail" then "fail"
+        else "none"
+        end
+      end
+
+      def spf_header = "#{header_prefix}SPF"
+
+      def dkim_header = "#{header_prefix}DKIM"
+
+      # The raw message with what the transport knew stamped on the front: who it
+      # was actually delivered to, and the SPF and DKIM verdicts.
+      #
+      # The verdicts are the one thing in the payload a forger cannot write, which
+      # is what makes them worth carrying -- a From: line is whatever the sender
+      # typed, and this is the only evidence about it that arrives from outside the
+      # message. Any header of ours the sender supplied is cleared first, so the
+      # first one downstream reads is always the ingress's.
+      #
+      # The address filter above is load-bearing: an envelope recipient containing
+      # a newline could otherwise add arbitrary headers, or close the header block
+      # and forge a body.
+      def message_with_transport_headers
+        stamped = envelope_recipients.map { |address| "#{ORIGINAL_TO}: #{address}\n" }
+        stamped << "#{spf_header}: #{spf_verdict}\n"
+        stamped << "#{dkim_header}: #{dkim_verdict}\n"
+
+        stamped.join + strip_reserved_headers(raw_message.to_s)
+      end
+
+      private
+        def header_prefix = MailersendRails.config.header_prefix
+
+        # Every header the ingress writes, wherever in the block the sender put it.
+        # The prefix is a namespace and everything under it is ours; X-Original-To
+        # is one name, so the colon is required and X-Original-Tomato survives.
+        def reserved_header
+          /\A(?:#{Regexp.escape(ORIGINAL_TO)}\s*:|#{Regexp.escape(header_prefix)})/i
+        end
+
+        # Header lines named for us, folded continuations included. Only the header
+        # block is touched; the body is the sender's. A message carrying none of
+        # ours is returned byte-for-byte, which is the overwhelmingly common case.
+        def strip_reserved_headers(raw)
+          header_block, separator, body = raw.partition(/\r?\n\r?\n/)
+          return raw if separator.empty?
+
+          lines = header_block.split(/\r?\n(?![ \t])/)
+          kept = lines.reject { |line| line.match?(reserved_header) }
+          return raw if kept.size == lines.size
+
+          kept.join("\n") + separator + body
+        end
+    end
+  end
+end

data/lib/mailersend_rails/inbound/signature.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module MailersendRails
+  module Inbound
+    # Verified against the exact bytes MailerSend signed, before anything parses
+    # them. A signature checked against a re-serialised body verifies our own JSON
+    # encoder rather than the sender -- key order and whitespace both move.
+    module Signature
+      def self.expected(secret:, body:)
+        OpenSSL::HMAC.hexdigest("SHA256", secret.to_s, body.to_s)
+      end
+
+      def self.valid?(secret:, body:, given:)
+        return false if secret.to_s.empty? || given.to_s.empty?
+
+        secure_compare(expected(secret: secret, body: body), given.to_s)
+      end
+
+      def self.secure_compare(a, b)
+        if defined?(ActiveSupport::SecurityUtils)
+          ActiveSupport::SecurityUtils.secure_compare(a, b)
+        else
+          a.bytesize == b.bytesize && OpenSSL.secure_compare(a, b)
+        end
+      end
+      private_class_method :secure_compare
+    end
+  end
+end

data/lib/mailersend_rails/railtie.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module MailersendRails
+  # The whole point of the gem: adding it registers the delivery method, so an app
+  # only has to say `config.action_mailer.delivery_method = :mailersend`.
+  class Railtie < ::Rails::Railtie
+    initializer "mailersend_rails.delivery_method" do
+      ActiveSupport.on_load(:action_mailer) do
+        require "mailersend_rails/delivery_method"
+        ActionMailer::Base.add_delivery_method :mailersend, MailersendRails::DeliveryMethod
+      end
+    end
+
+    # Only loaded when the app actually has Action Mailbox, so the gem is usable
+    # for outbound alone.
+    initializer "mailersend_rails.inbound" do
+      ActiveSupport.on_load(:action_controller_base) do
+        require "mailersend_rails/inbound/controller" if defined?(ActionMailbox)
+      end
+    end
+  end
+end

data/lib/mailersend_rails/version.rb

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

data/lib/mailersend_rails.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "mailersend_rails/version"
+require "mailersend_rails/configuration"
+require "mailersend_rails/inbound/payload"
+require "mailersend_rails/inbound/signature"
+require "mailersend_rails/railtie" if defined?(::Rails::Railtie)
+
+module MailersendRails
+  autoload :DeliveryMethod, "mailersend_rails/delivery_method"
+
+  module Inbound
+    autoload :Controller, "mailersend_rails/inbound/controller"
+  end
+end

data/lib/rails_mailersend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# The gem is `rails_mailersend`, so Bundler's auto-require looks for this file. Everything
+# lives under `mailersend_rails`, which is the spelling that matches the constant.
+#
+# The inversion is not a style choice. `mailersend_rails` on RubyGems is an unrelated gem by
+# another author, and RubyGems refuses a new name that differs from an existing one only by
+# its separators — which rules out `mailersend-rails` as well.
+require "mailersend_rails"

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: rails_mailersend
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Dan Loman
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: actionmailer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: |-
+  Adds a :mailersend Action Mailer delivery method and, optionally, an inbound
+  ingress that hands MailerSend's posted RFC822 message to Action Mailbox --
+  including the envelope-recipient stamping that Bcc'd mail depends on.
+email:
+- daniel.h.loman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/mailersend_rails.rb
+- lib/mailersend_rails/configuration.rb
+- lib/mailersend_rails/delivery_method.rb
+- lib/mailersend_rails/inbound/controller.rb
+- lib/mailersend_rails/inbound/payload.rb
+- lib/mailersend_rails/inbound/signature.rb
+- lib/mailersend_rails/railtie.rb
+- lib/mailersend_rails/version.rb
+- lib/rails_mailersend.rb
+homepage: https://github.com/namolnad/mailersend-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/namolnad/mailersend-rails
+  source_code_uri: https://github.com/namolnad/mailersend-rails
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: 'MailerSend for Rails: an Action Mailer delivery method and an Action Mailbox
+  ingress'
+test_files: []