resend 1.13.0 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02a3659fe54719cec434f3a832095f1b7ca944ace42891c84f74f295dcf6c241
-  data.tar.gz: 36879b724cb895f867f470a56daad7b1b1747796fe9fbc4fa45ff1b184d2c6cf
+  metadata.gz: aedf021421daf6882e301c0fb95bc9a9e5139aeefc7df4317c2c19516da45b39
+  data.tar.gz: f815d39241cc898ce249b945f58b2627673d561c5546eed275d5f5337c4d666b
 SHA512:
-  metadata.gz: 22f62c7e2ff8994689eba4ae17978f12455e6c1d98e16b3cb969c4cc36a9750909bfce85dcef5fc7d7b69f714001c46b101c15c42e2b00a03a9717f71efd50bb
-  data.tar.gz: 95d4550369ebee3ee9a1b85fd1347ab6a606cd3a8d0ba8db062da02d1f0bb57c81063ed3073654ef185d444dabeb52e22dc1fd3027914268cbed0a559873b25f
+  metadata.gz: 79ee7639752c4cb1fb7d50c8aebf1959d998fb2aad158a5d6296dc38c0239cc898f6f65fd0bfce71ef5648eeadb0bf6ef17849234048270baed5896b81d9dee4
+  data.tar.gz: 2cab25a4b638ce11011e4fe54166677070cf104cbbca899d63d3db5a5995ce8644634ab9261c348901f5263214cc43121d3c8ba6f4eb9dac8e237baee2d1ccfc

data/README.md

@@ -106,3 +106,43 @@ mailer = UserMailer.with(user: u).welcome_email
 mailer.deliver_now!
 # => {:id=>"b8f94710-0d84-429c-925a-22d3d8f86916", from: 'you@yourdomain.io', to: ["example2@mail.com", "example1@mail.com"]}
 ```
+
+# Rails and ActionMailbox support
+
+This gem also provides an Action Mailbox ingress, so you can receive inbound emails through Resend.
+
+Configure Action Mailbox to use the Resend ingress, and make sure your API key is set (it is used to fetch the full message and its attachments):
+
+```ruby
+# config/environments/production.rb
+config.action_mailbox.ingress = :resend
+```
+
+```ruby
+# config/initializers/resend.rb
+Resend.api_key = "re_123456"
+```
+
+Resend delivers inbound emails as `email.received` webhooks. Create a webhook in the [Resend dashboard](https://resend.com/webhooks) (or via `Resend::Webhooks.create`) subscribed to the `email.received` event and pointed at your app:
+
+```
+https://example.com/rails/action_mailbox/resend/inbound_emails
+```
+
+Then store the webhook's signing secret (`whsec_...`) so the ingress can verify incoming requests. Either add it to your encrypted credentials with `bin/rails credentials:edit`:
+
+```yml
+action_mailbox:
+  resend_signing_secret: whsec_...
+```
+
+or provide it through the `RESEND_INGRESS_SIGNING_SECRET` environment variable.
+
+Each verified webhook is turned back into a full email — using Resend's raw message download when available, and otherwise rebuilding the message from the Received Emails and Attachments APIs — and handed to Action Mailbox for routing like any other ingress:
+
+```ruby
+# app/mailboxes/application_mailbox.rb
+class ApplicationMailbox < ActionMailbox::Base
+  routing /^support@/i => :support
+end
+```

data/app/controllers/action_mailbox/ingresses/resend/inbound_emails_controller.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ActionMailbox
+  module Ingresses
+    module Resend
+      # Ingests inbound emails delivered by Resend's +email.received+ webhook.
+      #
+      # Resend webhooks only carry the received email's metadata, so the full message
+      # (including any attachments) is fetched from the Resend API before being enqueued
+      # for routing. The webhook request is authenticated by verifying its Svix signature
+      # against the webhook's signing secret, which is stored in the
+      # +action_mailbox.resend_signing_secret+ Rails credential or the
+      # +RESEND_INGRESS_SIGNING_SECRET+ environment variable.
+      #
+      # Returns:
+      #
+      # - <tt>204 No Content</tt> if an inbound email is successfully recorded and enqueued for
+      #   routing, or if the event is not an +email.received+ event and was ignored
+      # - <tt>401 Unauthorized</tt> if the request's signature could not be validated
+      # - <tt>404 Not Found</tt> if Action Mailbox is not configured to accept inbound emails
+      #   from Resend
+      # - <tt>422 Unprocessable Entity</tt> if the request's payload is malformed
+      # - <tt>500 Server Error</tt> if the webhook signing secret is missing, the Resend API
+      #   could not be reached, or one of the Active Record database, the Active Storage
+      #   service, or the Active Job backend is misconfigured or unavailable
+      class InboundEmailsController < ActionMailbox::BaseController
+        before_action :authenticate
+
+        def create
+          return head :no_content unless email_received_event?
+          return head :unprocessable_entity if email_id.nil?
+
+          ActionMailbox::InboundEmail.create_and_extract_message_id! raw_email
+          head :no_content
+        rescue JSON::ParserError => e
+          logger.error e.message
+          head :unprocessable_entity
+        end
+
+        private
+
+        def raw_email
+          ::Resend::ActionMailbox::MessageBuilder.new(email_id).raw_email
+        end
+
+        def email_received_event?
+          event["type"] == "email.received"
+        end
+
+        def email_id
+          event.dig("data", "email_id")
+        end
+
+        def event
+          @event ||= JSON.parse(request.raw_post)
+        end
+
+        def authenticate
+          head :unauthorized unless authenticated?
+        end
+
+        def authenticated?
+          if signing_secret.present?
+            verified_signature?
+          else
+            raise ArgumentError, <<~MESSAGE.squish
+              Missing required Resend webhook signing secret. Set action_mailbox.resend_signing_secret
+              in your application's encrypted credentials or provide the RESEND_INGRESS_SIGNING_SECRET
+              environment variable.
+            MESSAGE
+          end
+        end
+
+        def verified_signature?
+          ::Resend::Webhooks.verify(
+            payload: request.raw_post,
+            headers: {
+              svix_id: request.headers["svix-id"],
+              svix_timestamp: request.headers["svix-timestamp"],
+              svix_signature: request.headers["svix-signature"]
+            },
+            webhook_secret: signing_secret
+          )
+        rescue RuntimeError
+          false
+        end
+
+        def signing_secret
+          Rails.application.credentials.dig(:action_mailbox, :resend_signing_secret) ||
+            ENV["RESEND_INGRESS_SIGNING_SECRET"]
+        end
+      end
+    end
+  end
+end

data/lib/resend/action_mailbox/engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module Resend
+  module ActionMailbox
+    # Rails engine that routes Resend's +email.received+ webhooks to the
+    # Action Mailbox ingress controller.
+    class Engine < ::Rails::Engine
+      initializer "resend.action_mailbox.routes" do |app|
+        app.routes.append do
+          post "/rails/action_mailbox/resend/inbound_emails",
+               to: "action_mailbox/ingresses/resend/inbound_emails#create",
+               as: :rails_resend_inbound_emails
+        end
+      end
+    end
+  end
+end

data/lib/resend/action_mailbox/message_builder.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "mail"
+
+module Resend
+  module ActionMailbox
+    # Rebuilds the full RFC 822 source of a received email so it can be ingested
+    # by Action Mailbox.
+    #
+    # Resend's +email.received+ webhook only carries metadata, so the message is
+    # fetched from the Received Emails API. When the API exposes a raw message
+    # download it is used as-is; otherwise the message is reconstructed as a
+    # Mail::Message from its parts, downloading each attachment through the
+    # attachments API.
+    class MessageBuilder
+      # Headers that describe the reconstructed MIME structure and therefore
+      # cannot be copied verbatim from the original message.
+      STRUCTURAL_HEADERS = %w[content-type content-transfer-encoding mime-version].freeze
+
+      # Envelope fields that are set from the API response when the original
+      # header of the same name is not available.
+      ENVELOPE_FIELDS = %i[from to cc bcc reply_to subject message_id].freeze
+
+      # @param email_id [String] The ID of the received email
+      def initialize(email_id)
+        @email_id = email_id
+      end
+
+      # @return [String] the full RFC 822 source of the received email
+      def raw_email
+        raw_download || rebuild_message.to_s
+      end
+
+      private
+
+      def email
+        @email ||= Resend::Emails::Receiving.get(@email_id, html_format: "cid")
+      end
+
+      def raw_download
+        url = fetch(email[:raw], "download_url") unless blank?(email[:raw])
+        download(url) unless blank?(url)
+      end
+
+      def rebuild_message
+        Mail.new.tap do |mail|
+          copy_headers(mail)
+          copy_envelope(mail)
+          add_bodies(mail)
+          add_attachments(mail)
+        end
+      end
+
+      def copy_headers(mail)
+        (email[:headers] || {}).each do |name, value|
+          next if STRUCTURAL_HEADERS.include?(name.to_s.downcase)
+
+          Array(value).each { |val| mail.header[name.to_s] = val }
+        end
+      end
+
+      def copy_envelope(mail)
+        ENVELOPE_FIELDS.each do |field|
+          value = email[field]
+          next if blank?(value) || mail.header[field.to_s.tr("_", "-")]
+
+          mail.public_send("#{field}=", value)
+        end
+
+        mail.date ||= email[:created_at]
+
+        expose_bcc(mail)
+        copy_received_for(mail)
+      end
+
+      # Mail omits Bcc when serializing a message by default, but Action Mailbox
+      # needs it to route the email.
+      def expose_bcc(mail)
+        bcc = mail.header["bcc"]
+        bcc.include_in_headers = true if bcc.respond_to?(:include_in_headers)
+      end
+
+      # Preserve the addresses this email was received for (e.g. through a
+      # forwarding rule) so Action Mailbox can route on them.
+      def copy_received_for(mail)
+        Array(email[:received_for]).each { |address| mail.header["X-Original-To"] = address }
+      end
+
+      def add_bodies(mail)
+        html = presence(email[:html])
+        text = presence(email[:text])
+
+        if html
+          mail.text_part = build_part("text/plain", text) if text
+          mail.html_part = build_part("text/html", html)
+        elsif text
+          mail.content_type "text/plain; charset=UTF-8"
+          mail.body text
+        end
+      end
+
+      def build_part(mime_type, content)
+        Mail::Part.new(content_type: "#{mime_type}; charset=UTF-8", body: content)
+      end
+
+      def add_attachments(mail)
+        Array(email[:attachments]).each { |meta| add_attachment(mail, meta) }
+      end
+
+      def add_attachment(mail, meta)
+        details = Resend::Emails::Receiving::Attachments.get(email_id: @email_id, id: fetch(meta, "id"))
+        filename = fetch(meta, "filename") || details[:filename]
+
+        mail.attachments[filename] = {
+          mime_type: fetch(meta, "content_type") || details[:content_type],
+          content: download(details[:download_url])
+        }
+
+        decorate_attachment(mail.attachments.last, meta)
+      end
+
+      def decorate_attachment(part, meta)
+        content_id = fetch(meta, "content_id")
+        part.content_id = normalize_content_id(content_id) unless blank?(content_id)
+
+        return unless fetch(meta, "content_disposition") == "inline"
+
+        part.content_disposition = "inline; filename=\"#{part.filename}\""
+      end
+
+      def normalize_content_id(content_id)
+        content_id.start_with?("<") ? content_id : "<#{content_id}>"
+      end
+
+      def download(url)
+        response = HTTParty.get(url)
+
+        unless response.code == 200
+          raise Resend::Error::ServerError.new(
+            "Failed to download received email content (HTTP #{response.code})", response.code
+          )
+        end
+
+        response.body
+      end
+
+      # Nested objects come back from the API with string keys, but hand-built
+      # hashes (tests, console usage) often use symbols. Accept both.
+      def fetch(hash, key)
+        hash[key] || hash[key.to_sym]
+      end
+
+      def presence(value)
+        value unless blank?(value)
+      end
+
+      def blank?(value)
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+    end
+  end
+end

data/lib/resend/action_mailbox.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "resend"
+require "resend/action_mailbox/message_builder"
+require "resend/action_mailbox/engine" if defined?(::Rails::Engine)

data/lib/resend/contacts.rb

@@ -58,14 +58,22 @@ module Resend
       # @example List contacts with pagination
       #   Resend::Contacts.list(limit: 10)
       #
+      # @example List contacts scoped to a segment
+      #   Resend::Contacts.list(segment_id: "seg_456", limit: 10)
+      #
       # @example List contacts scoped to an audience
       #   Resend::Contacts.list(audience_id: "aud_456", limit: 10)
       #
       # https://resend.com/docs/api-reference/contacts/list-contacts
       def list(params = {})
-        audience_id = params[:audience_id]
-        path = if audience_id
-                 Resend::PaginationHelper.build_paginated_path("audiences/#{audience_id}/contacts", params)
+        path = if params[:audience_id]
+                 audience_id = params[:audience_id]
+                 Resend::PaginationHelper.build_paginated_path("audiences/#{audience_id}/contacts",
+                                                               params.except(:audience_id))
+               elsif params[:segment_id]
+                 segment_id = params[:segment_id]
+                 Resend::PaginationHelper.build_paginated_path("segments/#{segment_id}/contacts",
+                                                               params.except(:segment_id))
                else
                  Resend::PaginationHelper.build_paginated_path("contacts", params)
                end

data/lib/resend/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Resend
-  VERSION = "1.13.0"
+  VERSION = "1.14.0"
 end

data/lib/resend/webhooks.rb

@@ -117,6 +117,22 @@ module Resend
         Resend::Request.new(path, {}, "get").perform
       end
 
+      # Replay a webhook event
+      #
+      # Queues one more delivery of the event to the webhook. Manual replays do not schedule automatic retries.
+      #
+      # @param webhook_id [String] The webhook ID
+      # @param event_id [String] The webhook event ID
+      #
+      # @return [Hash] The replayed webhook event id and object type
+      #
+      # @example
+      #   Resend::Webhooks.replay_event("4dd369bc-aa82-4ff3-97de-514ae3000ee0", "msg_123")
+      def replay_event(webhook_id, event_id)
+        path = "webhooks/#{webhook_id}/events/#{event_id}/replay"
+        Resend::Request.new(path, {}, "post").perform
+      end
+
       # Retrieve delivery attempts for a webhook event
       #
       # @param webhook_id [String] The webhook ID

data/lib/resend.rb

@@ -44,6 +44,7 @@ require "resend/suppressions/batch"
 
 # Rails
 require "resend/railtie" if defined?(Rails) && defined?(ActionMailer)
+require "resend/action_mailbox" if defined?(Rails) && defined?(ActionMailbox)
 
 # Main Resend module
 module Resend

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: resend
 version: !ruby/object:Gem::Version
-  version: 1.13.0
+  version: 1.14.0
 platform: ruby
 authors:
 - Derich Pacheco
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-26 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -38,7 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.22.0
-description: 
 email: carlosderich@gmail.com
 executables: []
 extensions: []
@@ -46,7 +44,11 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - README.md
+- app/controllers/action_mailbox/ingresses/resend/inbound_emails_controller.rb
 - lib/resend.rb
+- lib/resend/action_mailbox.rb
+- lib/resend/action_mailbox/engine.rb
+- lib/resend/action_mailbox/message_builder.rb
 - lib/resend/api_keys.rb
 - lib/resend/automations.rb
 - lib/resend/automations/runs.rb
@@ -85,7 +87,6 @@ homepage: https://github.com/resend/resend-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -100,8 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 4.0.16
 specification_version: 4
 summary: The Ruby and Rails SDK for resend.com
 test_files: []