cloudflare-email 0.3.0 → 0.4.0

data/lib/cloudflare/email/ingress.rb

@@ -35,19 +35,30 @@ module Cloudflare
         # framework records and memberships share the resolved tenant context.
         # Custom endpoints may instead persist body/metadata in their own store.
         def persist_action_mailbox!
-          ::ActionMailbox::InboundEmail.transaction do
-            inbound = ::ActionMailbox::InboundEmail.create_and_extract_message_id!(body,
-              message_checksum: message_checksum, message_id: stable_message_id)
-            if inbound
-              blob = inbound.raw_email.blob
-              blob.update!(metadata: blob.metadata.merge(storage_metadata))
-            end
-            inbound
+          result = persist_rails_record
+          result.record if result.created?
+        end
+
+        # Verify once, resolve the envelope recipient before storage, then use
+        # the kit's ordinary Rails membership path. A duplicate can repair a
+        # missing membership without scheduling Rails processing again.
+        def receive_into_mailbox!
+          result = nil
+          Mailboxes.receive(recipient: envelope.fetch("to")) do
+            result = persist_rails_record
+            result.record
           end
+          result.record if result.created?
         end
 
         private
 
+        def persist_rails_record
+          require "mailbox_kit/inbound_email"
+          MailboxKit::InboundEmail.persist(source: body, message_checksum: message_checksum,
+            message_id: stable_message_id, metadata: storage_metadata)
+        end
+
         # ActionMailbox's fallback includes Socket.gethostname. A replay on a
         # different Rails host must use the same database identity, while the
         # original MIME stays untouched. Preserve parseable provider IDs.

data/lib/cloudflare/email/mailboxes/configuration.rb

@@ -1,28 +1,23 @@
-require "active_record"
+require "mailbox_kit/mailboxes/configuration"
 require "cloudflare/email/error"
 
 module Cloudflare
   module Email
+    Mailboxes = MailboxKit::Mailboxes unless const_defined?(:Mailboxes, false)
     module Mailboxes
-      class Unavailable < Cloudflare::Email::Error; end
 
-      class << self
+      module CloudflareConfiguration
         def configure(directory_base: ::ActiveRecord::Base, client_resolver: nil)
-          if const_defined?(:ReceivingDomain, false)
-            raise ConfigurationError, "configure mailboxes before loading mailbox models"
-          end
-          unless directory_base.is_a?(Class) && directory_base <= ::ActiveRecord::Base
-            raise ConfigurationError, "directory_base must be an ActiveRecord base class"
-          end
           if client_resolver && !client_resolver.respond_to?(:call)
             raise ConfigurationError, "client_resolver must be callable"
           end
-          @directory_base = directory_base
+          super(directory_base: directory_base)
           @client_resolver = client_resolver
         end
+      end
+      singleton_class.prepend(CloudflareConfiguration)
 
-        def directory_base = @directory_base || ::ActiveRecord::Base
-
+      class << self
         def delivery_handler = rails_setting(:outbox_delivery_handler)
         def recipient_handler = rails_setting(:outbox_recipient_handler)
 
@@ -42,9 +37,6 @@ module Cloudflare
           client
         end
 
-        def enabled? = @enabled == true
-        def enable! = @enabled = true
-
         private
 
         def rails_setting(name)

data/lib/cloudflare/email/mailboxes/inbound_retention.rb

@@ -1,14 +1 @@
-module Cloudflare
-  module Email
-    module Mailboxes
-      # ActionMailbox normally deletes processed mail after its retention window.
-      # A mailbox membership owns the raw source until explicit application purge.
-      module InboundRetention
-        def incinerate
-          return if Mailboxes.enabled? && Message.where(inbound_email_id: id).exists?
-          super
-        end
-      end
-    end
-  end
-end
+require "mailbox_kit/mailboxes/inbound_retention"

data/lib/cloudflare/email/mailboxes/models.rb

@@ -1,159 +1,20 @@
-require "active_record"
 require "cloudflare/email/active_record/base"
-
+require "mailbox_kit/mailboxes/configuration"
+require "mailbox_kit/mailboxes/models"
 module Cloudflare
   module Email
     module Mailboxes
-      # Domains are an administrator-maintained receiving directory. An active
-      # record is an assertion by the application, not DNS ownership verification.
-      class ReceivingDomain < Mailboxes.directory_base
-        self.table_name = "cloudflare_email_receiving_domains"
-        STATES = %w[pending active suspended].freeze
-        attr_readonly :domain, :tenant_key, :account_id
-        before_validation(on: :create) { self.domain = domain.to_s.strip.downcase }
-        validates :tenant_key, :account_id, presence: true
-        validates :domain, presence: true, uniqueness: true,
-          length: { maximum: 253 },
-          format: { with: /\A[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+\z/ }
-        validates :state, inclusion: { in: STATES }
-        validate do
-          errors.add(:domain, "has an oversized label") if domain.to_s.split(".").any? { |label| label.length > 63 }
+      Mailbox.has_many :outbound_messages, class_name: "MailboxKit::Mailboxes::OutboundMessage"
+      # A process may also serve core-only tenants without the outbound schema.
+      Mailbox.before_destroy do
+        if self.class.connection.data_source_exists?(OutboundMessage.table_name) && outbound_messages.exists?
+          raise ::ActiveRecord::DeleteRestrictionError, :outbound_messages
         end
-        scope :active, -> { where(state: "active") }
       end
-
-      module TenantIdentity
-        extend ActiveSupport::Concern
-        included do
-          attr_readonly :tenant_key
-          validates :tenant_key, presence: true
-          before_validation :assign_tenant_identity
-          validate :validate_tenant_identity
-          before_destroy :assert_tenant_identity!
-        end
-
-        private
-
-        def assign_tenant_identity
-          self.tenant_key ||= Tenancy.current_key
-        end
-
-        def validate_tenant_identity
-          return unless Tenancy.enabled? || Tenancy.current_key
-          Tenancy.require_context!
-          errors.add(:tenant_key, "does not match the current tenant") unless tenant_key == Tenancy.current_key
-        end
-
-        def assert_tenant_identity!
-          return unless Tenancy.enabled? || Tenancy.current_key
-          Tenancy.require_context!
-          raise ArgumentError, "record belongs to another tenant" unless tenant_key == Tenancy.current_key
-        end
-
-        def validate_parent_tenant(parent, attribute)
-          errors.add(attribute, "belongs to another tenant") if parent && parent.tenant_key != tenant_key
-        end
-      end
-
-      class Mailbox < Cloudflare::Email::ActiveRecord::Base
-        include TenantIdentity
-        self.table_name = "cloudflare_email_mailboxes"
-        has_many :addresses, class_name: "Cloudflare::Email::Mailboxes::Address", dependent: :restrict_with_exception
-        has_many :messages, class_name: "Cloudflare::Email::Mailboxes::Message", dependent: :restrict_with_exception
-        has_many :outbound_messages, class_name: "Cloudflare::Email::Mailboxes::OutboundMessage", dependent: :restrict_with_exception
-        validates :name, presence: true, length: { maximum: 255 }
-        validates :state, inclusion: { in: %w[active suspended] }
-        scope :active, -> { where(state: "active") }
-      end
-
-      class Address < Cloudflare::Email::ActiveRecord::Base
-        include TenantIdentity
-        self.table_name = "cloudflare_email_addresses"
-        belongs_to :mailbox, class_name: "Cloudflare::Email::Mailboxes::Mailbox"
-        attr_readonly :mailbox_id, :receiving_domain_id, :local_part, :domain, :address
-        before_validation :normalize_address, on: :create
-        validates :mailbox, :receiving_domain_id, presence: true
-        validates :local_part, length: { in: 1..64 },
-          format: { with: /\A[a-z0-9!\#$%&'*+\/=\?^_`{|}~-]+(?:\.[a-z0-9!\#$%&'*+\/=\?^_`{|}~-]+)*\z/ }
-        validates :address, uniqueness: true, length: { maximum: 254 }
-        validates :state, inclusion: { in: %w[pending active suspended] }
-        validate :validate_directory
-        validate :validate_catch_all
-        validate { validate_parent_tenant(mailbox, :mailbox) }
-        scope :active, -> { where(state: "active") }
-
-        def receiving_domain
-          ReceivingDomain.find_by(id: receiving_domain_id)
-        end
-
-        private
-
-        def normalize_address
-          self.local_part = local_part.to_s.strip.downcase
-          self.domain = domain.to_s.strip.downcase
-          self.address = "#{local_part}@#{domain}"
-        end
-
-        def validate_directory
-          registered = receiving_domain
-          unless registered && registered.domain == domain && registered.tenant_key == tenant_key
-            errors.add(:receiving_domain_id, "must match this tenant and domain")
-            return
-          end
-          if new_record? && registered.state != "active"
-            errors.add(:receiving_domain_id, "must be active before creating addresses")
-          end
-        end
-
-        def validate_catch_all
-          # Existing exact-address installations need not migrate until they
-          # opt into catch-all receiving.
-          return unless has_attribute?(:catch_all) && self[:catch_all]
-          errors.add(:catch_all_evidence, "is required") if self[:catch_all_evidence].to_s.strip.empty?
-          if will_save_change_to_catch_all? && state != "active"
-            errors.add(:catch_all, "requires an active address")
-          end
-          return unless state == "active"
-          errors.add(:catch_all, "requires an active mailbox") unless mailbox&.state == "active"
-          errors.add(:catch_all, "requires an active receiving domain") unless receiving_domain&.state == "active"
-          if self.class.where(receiving_domain_id: receiving_domain_id, catch_all: true, state: "active").where.not(id: id).exists?
-            errors.add(:catch_all, "already exists for this receiving domain")
-          end
-        end
-      end
-
-      class Message < Cloudflare::Email::ActiveRecord::Base
-        include TenantIdentity
-        self.table_name = "cloudflare_email_mailbox_messages"
-        belongs_to :mailbox, class_name: "Cloudflare::Email::Mailboxes::Mailbox"
-        attr_readonly :mailbox_id, :inbound_email_id, :recipient
-        validates :mailbox, :inbound_email_id, :recipient, presence: true
-        # The unique database index also supports create_or_find_by! retries.
-        validate { validate_parent_tenant(mailbox, :mailbox) }
-        scope :unread, -> { where(read_at: nil) }
-        scope :inbox, -> { where(archived_at: nil) }
-
-        def mark_read!
-          update!(read_at: Time.current)
-        end
-
-        def mark_unread!
-          update!(read_at: nil)
-        end
-
-        def archive!
-          update!(archived_at: Time.current)
-        end
-
-        def unarchive!
-          update!(archived_at: nil)
-        end
-      end
-
       class OutboundMessage < Cloudflare::Email::ActiveRecord::Base
         include TenantIdentity
         self.table_name = "cloudflare_email_mailbox_outbound_messages"
-        belongs_to :mailbox, class_name: "Cloudflare::Email::Mailboxes::Mailbox"
+        belongs_to :mailbox, class_name: "MailboxKit::Mailboxes::Mailbox"
         belongs_to :outbound_delivery, class_name: "Cloudflare::Email::ActiveRecord::OutboundDelivery"
         attr_readonly :mailbox_id, :outbound_delivery_id
         validates :mailbox, :outbound_delivery, presence: true

data/lib/cloudflare/email/mailboxes/service.rb

@@ -1,121 +1,11 @@
 require "digest"
-require "cloudflare/email/envelope"
-
+require "mailbox_kit/mailboxes/service"
 module Cloudflare
   module Email
     module Mailboxes
-      # A routing snapshot, not a model or an authorization token. Use it inside
-      # the yielded tenant context; later jobs must resolve/check policy again.
-      Destination = Struct.new(:tenant_key, :mailbox_id, :address_id,
-        :receiving_domain_id, :recipient, :owner_ref, :catch_all, keyword_init: true) do
-        def initialize(**attributes)
-          super(**{ catch_all: false }.merge(attributes).transform_values { |value| value.is_a?(String) ? value.dup.freeze : value })
-          freeze
-        end
-      end
-
-      class << self
-        # Call after host authorization. The directory is a control-plane API,
-        # not a public endpoint accepting arbitrary customer domain claims.
-        def register_domain(domain:, tenant_key:, account_id:)
-          Tenancy.normalize_key(tenant_key)
-          ReceivingDomain.create!(domain: domain, tenant_key: tenant_key, account_id: account_id)
-        end
-
-        def activate_domain!(id, evidence:, sending_enabled: false)
-          raise ArgumentError, "verification evidence is required" if evidence.to_s.strip.empty?
-          domain = ReceivingDomain.find(id)
-          domain.update!(state: "active", provisioning_evidence: evidence,
-            verified_at: Time.now.utc, sending_enabled: sending_enabled)
-          domain
-        end
-
-        def for_tenant(key)
-          raise ArgumentError, "a block is required" unless block_given?
-          Tenancy.with(key) { yield Session.new(key) }
-        end
-
-        # Only call after verifying the complete ingress HMAC. Resolve before
-        # ActionMailbox or ActiveStorage accesses a tenant connection.
-        def receive(recipient:, &block)
-          raise ArgumentError, "persistence block required" unless block
-          in_recipient_tenant(recipient) do |session, address, directory|
-            session.receive(address, directory) do |destination|
-              # Preserve strict callbacks accepted before destinations were yielded.
-              block.lambda? && block.arity.zero? ? block.call : block.call(destination)
-            end
-          end
-        end
-
-        # Lookup only: the host owns persistence and the block's return value.
-        # Verify ingress before calling this API. No ActionMailbox is required.
-        def with_recipient(recipient:)
-          raise ArgumentError, "a block is required" unless block_given?
-          in_recipient_tenant(recipient) do |session, address, directory|
-            session.with_recipient(address, directory) { |destination| yield destination }
-          end
-        end
-
-        def canonical_address(value)
-          unless Envelope.valid_address?(value)
-            raise ValidationError, "mailbox address must be an ASCII dot-atom address"
-          end
-          value.downcase
-        end
-
-        private
-
-        def in_recipient_tenant(recipient)
-          address = canonical_address(recipient)
-          directory = ReceivingDomain.find_by(domain: address.split("@", 2).last, state: "active")
-          raise Unavailable, "receiving domain unavailable" unless directory
-          for_tenant(directory.tenant_key) do |session|
-            yield session, address, directory
-          end
-        end
-      end
-
-      class Session
-        attr_reader :tenant_key
-
-        def initialize(tenant_key)
-          @tenant_key = tenant_key
-        end
-
-        def mailboxes
-          context!
-          Mailbox.where(tenant_key: tenant_key)
-        end
-
-        def create(name:, address:, owner_ref: nil)
-          context!
-          Mailbox.transaction do
-            mailbox = Mailbox.create!(tenant_key: tenant_key, name: name, owner_ref: owner_ref)
-            add_address(mailbox.id, address: address)
-            mailbox
-          end
-        end
-
-        def add_address(mailbox_id, address:)
-          mailbox = active_mailbox!(mailbox_id)
-          canonical = Mailboxes.canonical_address(address)
-          local, domain = canonical.split("@", 2)
-          directory = ReceivingDomain.find_by!(domain: domain, tenant_key: tenant_key, state: "active")
-          Address.create!(tenant_key: tenant_key, mailbox_id: mailbox.id,
-            receiving_domain_id: directory.id, local_part: local, domain: domain,
-            address: canonical, state: "pending")
-        end
-
-        def activate_address!(address_id, evidence:)
-          context!
-          raise ArgumentError, "route verification evidence is required" if evidence.to_s.strip.empty?
-          address = Address.where(tenant_key: tenant_key).find(address_id)
-          active_mailbox!(address.mailbox_id)
-          active_domain!(address)
-          address.update!(state: "active", provisioning_evidence: evidence)
-          address
-        end
-
+      # Provider-specific behavior is installed only when the Cloudflare
+      # integration is explicitly loaded. Core sessions remain receiving-only.
+      module CloudflareSession
         def provision_address!(address_id, provisioner:, worker_name:)
           context!
           raise ArgumentError, "provision outside a database transaction" if Address.connection.transaction_open?
@@ -128,85 +18,11 @@ module Cloudflare
           activate_address!(address.id, evidence: "Cloudflare address rule provisioned for Worker #{worker_name}")
         end
 
-        # This records the host's verified provider routing decision; it does
-        # not provision Cloudflare DNS/rules or authorize arbitrary From values.
-        def enable_catch_all(address_id, evidence:)
-          context!
-          catch_all_schema!
-          raise ArgumentError, "catch-all route verification evidence is required" if evidence.to_s.strip.empty?
-          Address.transaction do
-            address = Address.where(tenant_key: tenant_key, state: "active").find(address_id)
-            active_mailbox!(address.mailbox_id)
-            active_domain!(address)
-            address.update!(catch_all: true, catch_all_evidence: evidence)
-            address
-          end
-        end
-
-        def disable_catch_all(address_id)
-          context!
-          catch_all_schema!
-          # Disabling is permitted even after suspension; retain the previous
-          # verification evidence for operator inspection.
-          Address.where(tenant_key: tenant_key).find(address_id).tap { |address| address.update!(catch_all: false) }
-        end
-
-        def suspend(mailbox_id)
-          mailboxes.find(mailbox_id).tap { |mailbox| mailbox.update!(state: "suspended") }
-        end
-
-        def resume(mailbox_id)
-          mailboxes.find(mailbox_id).tap { |mailbox| mailbox.update!(state: "active") }
-        end
-
-        def messages(mailbox_id)
-          mailbox = mailboxes.find(mailbox_id)
-          Message.where(tenant_key: tenant_key, mailbox_id: mailbox.id)
-        end
-
-        def addresses(mailbox_id)
-          mailbox = mailboxes.find(mailbox_id)
-          Address.where(tenant_key: tenant_key, mailbox_id: mailbox.id)
-        end
-
-        def suspend_address(mailbox_id, address_id)
-          addresses(mailbox_id).find(address_id).tap { |address| address.update!(state: "suspended") }
-        end
-
         def outbound_messages(mailbox_id)
           mailbox = mailboxes.find(mailbox_id)
           OutboundMessage.where(tenant_key: tenant_key, mailbox_id: mailbox.id)
         end
 
-        def inbound_email(mailbox_id, message_id)
-          message = messages(mailbox_id).find(message_id)
-          ensure_storage_connection!
-          ::ActionMailbox::InboundEmail.find(message.inbound_email_id)
-        end
-
-        # Explicit permanent removal. Archive is the reversible default.
-        # Other mailbox memberships retain their shared raw source.
-        def purge_message(mailbox_id, message_id)
-          context!
-          ensure_storage_connection!
-          Message.transaction do
-            message = messages(mailbox_id).find(message_id)
-            inbound_id = message.inbound_email_id
-            message.destroy!
-            unless Message.where(inbound_email_id: inbound_id).exists?
-              ::ActionMailbox::InboundEmail.find_by(id: inbound_id)&.destroy!
-            end
-          end
-        end
-
-        def mark_read(mailbox_id, message_id, read: true)
-          messages(mailbox_id).find(message_id).update!(read_at: read ? Time.now.utc : nil)
-        end
-
-        def archive(mailbox_id, message_id, archived: true)
-          messages(mailbox_id).find(message_id).update!(archived_at: archived ? Time.now.utc : nil)
-        end
-
         def prepare(mailbox_id, operation_key:, mail:)
           context!
           raise ArgumentError, "operation_key is required" unless operation_key.is_a?(String) && !operation_key.strip.empty?
@@ -223,6 +39,7 @@ module Cloudflare
             raise ValidationError, "MIME and envelope sender must match the mailbox address"
           end
           domain = active_domain!(address)
+          raise Unavailable, "domain is not enabled for Cloudflare sending" if domain.account_id.to_s.strip.empty?
           raise Unavailable, "domain is not enabled for sending" unless domain.sending_enabled
           key = "mailbox:#{Digest::SHA256.hexdigest(JSON.generate([tenant_key, mailbox.id, operation_key]))}"
           Mailbox.transaction do
@@ -247,6 +64,7 @@ module Cloudflare
           delivery = linked_delivery!(mailbox.id, operation_key)
           address = authorized_sender!(mailbox, delivery.from_address)
           domain = active_domain!(address)
+          raise Unavailable, "domain is not enabled for Cloudflare sending" if domain.account_id.to_s.strip.empty?
           raise Unavailable, "domain is not enabled for sending" unless domain.sending_enabled && domain.account_id == delivery.account_id
           ActiveRecord::Outbox.deliver(delivery, client: Mailboxes.client_for(tenant_key, delivery.account_id))
           handler = Mailboxes.delivery_handler
@@ -284,77 +102,7 @@ module Cloudflare
           links.last&.id
         end
 
-        def receive(address, directory)
-          context!
-          ensure_storage_connection! if defined?(::ActionMailbox::InboundEmail)
-          Mailbox.transaction do
-            destination = resolve_destination(address, directory)
-            inbound = yield destination
-            Message.create_or_find_by!(tenant_key: tenant_key, mailbox_id: destination.mailbox_id,
-              inbound_email_id: inbound.id) { |row| row.recipient = address } if inbound
-            inbound
-          end
-        end
-
-        def with_recipient(address, directory)
-          context!
-          yield resolve_destination(address, directory)
-        end
-
         private
-
-        def resolve_destination(address, directory)
-          destination = Address.where(tenant_key: tenant_key, address: address,
-            receiving_domain_id: directory.id).first
-          fallback = destination.nil?
-          if fallback && catch_all_schema_available?
-            destination = Address.where(tenant_key: tenant_key, receiving_domain_id: directory.id,
-              catch_all: true, state: "active").first
-          end
-          # An exact pending/suspended address intentionally reserves its name.
-          # It must never fall through to another mailbox's catch-all.
-          raise Unavailable, "mailbox address unavailable" unless destination&.state == "active"
-          mailbox = active_mailbox!(destination.mailbox_id)
-          active_domain!(destination)
-          Destination.new(tenant_key: tenant_key, mailbox_id: mailbox.id,
-            address_id: destination.id, receiving_domain_id: directory.id,
-            recipient: address, owner_ref: mailbox.owner_ref, catch_all: fallback)
-        rescue ::ActiveRecord::RecordNotFound
-          raise Unavailable, "mailbox address unavailable"
-        end
-
-        def context!
-          raise ConfigurationError, "mailbox session used outside its tenant context" unless Tenancy.require_context! == tenant_key
-        end
-
-        def catch_all_schema_available?
-          Address.connection.column_exists?(Address.table_name, :catch_all) &&
-            Address.connection.column_exists?(Address.table_name, :catch_all_evidence)
-        end
-
-        def catch_all_schema!
-          unless catch_all_schema_available?
-            raise ConfigurationError, "run cloudflare:email:mailboxes:catch_all migrations for this tenant first"
-          end
-        end
-
-        def ensure_storage_connection!
-          unless defined?(::ActionMailbox::InboundEmail) && ::ActionMailbox::InboundEmail.connection_pool == Mailbox.connection_pool &&
-              ::ActiveStorage::Blob.connection_pool == Mailbox.connection_pool
-            raise ConfigurationError, "ActionMailbox, ActiveStorage and mailbox records must share the tenant connection"
-          end
-        end
-
-        def active_mailbox!(id)
-          context!
-          mailboxes.where(state: "active").find(id)
-        end
-
-        def active_domain!(address)
-          ReceivingDomain.find_by!(id: address.receiving_domain_id, domain: address.domain,
-            tenant_key: tenant_key, state: "active")
-        end
-
         def authorized_sender!(mailbox, address)
           Address.where(tenant_key: tenant_key, mailbox_id: mailbox.id, state: "active")
             .find_by!(address: Mailboxes.canonical_address(address))
@@ -367,6 +115,7 @@ module Cloudflare
           delivery
         end
       end
+      Session.include(CloudflareSession)
     end
   end
 end

data/lib/cloudflare/email/mailboxes.rb

@@ -9,3 +9,4 @@ require "cloudflare/email/mailboxes/service"
 require "cloudflare/email/mailboxes/jobs"
 
 Cloudflare::Email::Mailboxes.enable!
+require "mailbox_kit/railtie" if defined?(::Rails::Railtie)

data/lib/cloudflare/email/management/adapter.rb

@@ -1,31 +1,9 @@
+require "mailbox-kit"
+require "mailbox_kit/management/adapter"
 module Cloudflare
   module Email
     module Management
-      # A host supplies authentication, mailbox ownership and domain entitlement.
-      # Defaults deliberately grant no access. No principal comes from params.
-      class Adapter
-        attr_reader :controller
-
-        def initialize(controller = nil)
-          @controller = controller
-        end
-
-        def authenticate! = false
-        def tenant_key = nil
-        def mailboxes(session) = session.mailboxes.none
-        def allowed?(action, mailbox = nil) = false
-        def domains(session) = []
-
-        # Override these two hooks when the host keeps a linked product model or
-        # uses a deployment policy to activate/provision verified addresses.
-        def create_mailbox(session, name:, address:)
-          session.create(name: name, address: address)
-        end
-
-        def add_address(session, mailbox, address:)
-          session.add_address(mailbox.id, address: address)
-        end
-      end
+      Adapter = MailboxKit::Management::Adapter
     end
   end
 end

data/lib/cloudflare/email/management/configuration.rb

@@ -1,17 +1,10 @@
+require "mailbox_kit/management/configuration"
 module Cloudflare
   module Email
     module Management
-      class Configuration
-        attr_accessor :adapter, :back_path
-      end
-
-      def self.configuration
-        @configuration ||= Configuration.new
-      end
-
-      def self.configure
-        yield configuration
-      end
+      Configuration = MailboxKit::Management::Configuration
+      def self.configuration = MailboxKit::Management.configuration
+      def self.configure(&block) = MailboxKit::Management.configure(&block)
     end
   end
 end

data/lib/cloudflare/email/management/engine.rb

@@ -8,6 +8,8 @@ module Cloudflare
         isolate_namespace Cloudflare::Email::Management
         config.root = File.expand_path("../../../..", __dir__)
 
+        config.paths["app/views"] << File.join(MailboxKit::ROOT, "app/views")
+
         config.paths["config/routes.rb"] = "lib/cloudflare/email/management/routes.rb"
       end
     end