devise_invitable 3.0.4 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d7694e9f3f376c8f60a5d426144eebe986967f33b6ea016ca1f01c65fa19e32
-  data.tar.gz: 40faca7611e16510fe0d45f886e35f6622eb7d1cefe9016be0e93ba6d272e2e4
+  metadata.gz: 14df8dd3f270570211fc502f10b3e0a10a4f81b064a11217b0963f5118f68255
+  data.tar.gz: b1e0b2ffada6cc6099c6aeffef44677549732f08f842e65c6832549f69ba9ef3
 SHA512:
-  metadata.gz: aab0c7da6b34b49475014c55ace27804cff1c95b15012a3209c0cf7f7e42e6612647dbdeb0ddacd8fd6e26353b2617355f8c4e2f25a3dd8a2e4aaf9aa0b89d7e
-  data.tar.gz: 2d7873782c77d7c9076312eea7a57cb8cfc4e54874dbd4705e6133d1a5ed92f981291ec8bc7bd81cf4570836059c2b2aff6fffdf01b54f0056d67e62467a5a50
+  metadata.gz: ea404feea290eb01ed9108f1c541b8df0df3a664813c7ee630ae96c198647858560e126196d1173d521106a11e22a6d000308102d60719a5f220484ff08e4d57
+  data.tar.gz: 35541ff5985d4d3c85ea9b2444b5d8f4ef54f18d1a7bd3ab5d6e77b262b50c5f6b77e38f36927bdc4760e9979f47d80099227080a46fe8048ef2b557cf80f06e

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 3.1.0
+
+- Add bounded, encrypted `invitation_data` for application-specific acceptance
+  context, and an opt-in mode that preserves other invitations for independent
+  acceptance without changing its password or signing it in
+- Keep invite keys out of new invitation records by carrying them in an
+  encrypted, authenticated acceptance token. Existing invitation links with
+  plaintext invite keys remain supported ([#777](https://github.com/scambra/devise_invitable/issues/777))
+- Add opt-in temporary invite-key storage for resource-less invitations that
+  must be approved and delivered later; stored keys are cleared after delivery
+- Add `DeviseInvitable::Invitation#deliver_later`, a lazily loaded default
+  Active Job, an opt-in `deliver_invitation_later` setting for the normal flow,
+  and configurable job class and queue settings for background invitation email
+  delivery without nesting jobs created by `send_devise_notification` overrides
+
 ## 3.0.4
 
 - Avoid using distinct which may fail in postgresql if the model has json column ([935](https://github.com/scambra/devise_invitable/issues/935))

data/README.md

@@ -150,7 +150,9 @@ no limit for any user, `invitation_limit` column is not used.  A setting
 of `0` means they can't send invitations. A setting `n > 0` means they can
 send `n` invitations. You can change `invitation_limit` column for some
 users so they can send more or less invitations, even with global
-`invitation_limit = 0`.
+`invitation_limit = 0`. This setting controls how many invitations an inviter
+may send; use `authenticate_inviter!` for authorization and other
+application-specific conditions.
 
 *   `invite_key`: The key to be used to check existing users when sending an
 invitation. You can use multiple keys. This value must be a hash with the
@@ -172,11 +174,34 @@ polymorphic `invited_by_id` and `invited_by_type` columns in the shared
 invitations table.
 
 *   `create_resource_on_invitation`: create a placeholder resource when the
-invitation is sent. It is disabled by default, so only invite keys are stored
-until acceptance. Enable it when the application needs an addressable resource
-before signup or needs to store additional permitted resource attributes from
-the invitation form. Arbitrary resource attributes are rejected when this is
-disabled.
+invitation is sent. It is disabled by default, so only the invitation record is
+persisted while invite keys remain in the encrypted acceptance token. Enable it
+when the application needs an addressable resource before signup or needs to
+store additional permitted resource attributes from the invitation form.
+Arbitrary resource attributes are rejected when this is disabled.
+
+*   `store_invite_keys_until_delivery`: temporarily store invite keys in the
+invitation record so a skipped, resource-less invitation can be loaded and
+delivered later. It is disabled by default. Stored keys are cleared after
+successful delivery, when they are available in the encrypted acceptance token.
+
+*   `deliver_invitation_later`: enqueue invitation emails with the configured
+invitation delivery job. It is disabled by default, preserving the normal
+`send_devise_notification` hook.
+
+*   `invitation_delivery_job`: job class used by `Invitation#deliver_later`.
+It may be a class or class name and must respond to `perform_later`. The default
+is `DeviseInvitable::InvitationDeliveryJob`.
+
+*   `invitation_delivery_queue_name`: queue used by the default invitation
+delivery job. The default is `:mailers`.
+
+*   `supersede_other_invitations_on_accept`: supersede other pending
+invitations for the same invite keys when one is accepted. Enabled by default.
+Disable it only when each invitation carries independently acceptable
+application context. Remaining invitations are linked to the provisioned
+resource and their tokens stay valid; accepting them does not require or change
+the resource's password.
 
 *   `invited_by_counter_cache`: the column name used for counter_cache column.
 If this is `nil` (default value), the `invited_by` association is declared
@@ -417,6 +442,58 @@ that invitation accepted and supersedes the others. If the invitee registers
 directly, all matching pending invitations are superseded rather than marked
 accepted.
 
+### Pass application context with an invitation
+
+Small application-specific values can be carried in the encrypted acceptance
+token with the `invitation_data` option:
+
+```ruby
+User.invite!(
+  { email: 'new_user@example.com' },
+  current_user,
+  invitation_data: { organization_id: organization.id, role: 'member' }
+)
+```
+
+`invitation_data` must be a JSON-compatible hash whose serialized form is no
+larger than 1,024 bytes. It is deliberately not persisted by devise_invitable.
+After token decoding, JSON object keys are strings. The data is available as
+`current_invitation.invitation_data` in invitation callbacks and controller
+code. For example:
+
+```ruby
+after_invitation_created do |user|
+  InvitationContext.create!(
+    devise_invitation: user.current_invitation,
+    data: user.current_invitation.invitation_data
+  )
+end
+
+after_invitation_accepted do |user|
+  organization_id = user.current_invitation.invitation_data['organization_id']
+  user.memberships.find_or_create_by!(organization_id: organization_id)
+end
+```
+
+Persist the context in an application model when it must survive independently
+of the email link, be processed after another invitation is accepted, or be
+combined with other invitations. Keep it URL-only when each invitation should
+be accepted separately. To preserve the other links in that case:
+
+```ruby
+class User < ApplicationRecord
+  devise :database_authenticatable, :invitable,
+    supersede_other_invitations_on_accept: false
+end
+```
+
+The first accepted invitation provisions the resource normally. Later
+invitations run the acceptance callbacks with their own `invitation_data`, but
+cannot replace or require the existing password and do not automatically sign
+the resource in. Invitation data is a bearer credential; applications must
+re-check referenced resources, authorization, and current roles when accepting
+it.
+
 Placeholder resources expose `invitation_pending?`. Pending placeholders are
 rejected by both Devise's password validation and
 `active_for_authentication?` checks until an invitation is accepted or the
@@ -426,15 +503,21 @@ resource is claimed by direct registration.
 
 Invitation keys commonly contain personal data such as an email address. With
 the default `create_resource_on_invitation: false`, no resource row is created,
-but the invite-key values are stored in plaintext in the
-`devise_invitations.invite_key` JSON column so the resource can be created when
-the invitation is accepted. `invite_key_digest` is used for matching; it does
-not replace the stored values and should not be treated as anonymization.
+and new invitations do not persist the invite-key values in the
+`devise_invitations.invite_key` JSON column. The values are carried in the
+encrypted and authenticated acceptance token and restored only when the link
+is accepted. `invite_key_digest` is stored so the values in the token can be
+verified against the invitation record. Invitations created before this change
+may still have plaintext invite keys; their existing links remain supported.
 
 With `create_resource_on_invitation: true`, the resource and any additional
 attributes or associations supplied to `invite!` are persisted immediately.
 Choose this mode only when the application needs a placeholder and its privacy
-policy permits storing that data before acceptance.
+policy permits storing that data before acceptance. An application may clear
+the placeholder's invite-key attributes after delivery, for example in an
+`after_invitation_created` callback; the encrypted acceptance token restores
+them during acceptance. The application is responsible for allowing the blank
+placeholder attributes and persisting the cleanup.
 
 `invite_for` limits token validity but does not delete invitation or resource
 records. Applications are responsible for choosing a lawful basis for
@@ -445,12 +528,10 @@ Consent is one possible lawful basis under GDPR, but it is not the only one.
 See the [European Commission GDPR principles](https://commission.europa.eu/law/law-topic/data-protection/information-business-and-organisations/principles-gdpr_en)
 and obtain appropriate legal advice for the application.
 
-A one-way hash alone is insufficient for the built-in deferred-invitation
-flow, because devise_invitable must recover the invite keys to create the
-resource at acceptance. Applications that must not retain the email address
-need a custom flow, such as asking the invitee to enter it during acceptance
-and verifying it against a stored digest, or using suitably protected
-reversible storage.
+The acceptance token is a bearer credential: avoid logging it or exposing it
+to third parties. Its encryption key is derived from the Rails application's
+key generator, so changing `secret_key_base` invalidates outstanding encrypted
+invitation links.
 
 If you want to create the invitation but not send it, you can set
 `skip_invitation` to `true`.
@@ -463,8 +544,10 @@ end
 ```
 
 When generating the `accept_user_invitation_url` yourself, you must use the
-`raw_invitation_token`. This value is temporarily available when you invite a
-user and will be decrypted when received.
+`raw_invitation_token`. For new invitations this is an encrypted, authenticated
+envelope containing the underlying Devise token and invite keys. It is
+temporarily available on the object that creates the invitation and is not
+persisted in plaintext.
 
 ```ruby
 accept_user_invitation_url(invitation_token: user.raw_invitation_token)
@@ -474,15 +557,22 @@ When `skip_invitation` is used, the resulting invitation remains pending with
 an unset `invitation_sent_at`. Deliver it later by calling `deliver` on the
 invitation:
 
+For resource-less invitations, first enable temporary invite-key storage:
+
+```ruby
+devise :invitable, store_invite_keys_until_delivery: true
+```
+
 ```ruby
 invitation = user.current_invitation
 invitation.deliver
 ```
 
-This works for both placeholder-backed and resource-less invitations. For a
-resource-less invitation, `deliver` reconstructs the resource from the stored
-invite key. It generates a fresh token, sends the email, and sets
-`invitation_sent_at`. Calling it again after successful delivery does nothing.
+This works for placeholder-backed invitations without additional configuration.
+For a resource-less invitation, `deliver` reconstructs the resource from the
+temporarily stored invite key. It generates a fresh encrypted acceptance token,
+sends the email, clears the stored invite key, and sets `invitation_sent_at`.
+Calling it again after successful delivery does nothing.
 
 For example, an approval workflow can find unsent pending invitations and
 deliver an approved one after applying its own authorization policy:
@@ -508,6 +598,98 @@ User.invite!(email: 'new_user@example.com', skip_invitation: true)
 `DeviseInvitable::Invitation`. With placeholders enabled,
 `invited_to_sign_up?` and `invitation_pending?` return `true` on the resource.
 
+### Background delivery
+
+Devise Invitable includes a lazily loaded Active Job for background invitation
+delivery. To use it for the normal invitation flow, enable it in the Devise
+initializer:
+
+```ruby
+config.deliver_invitation_later = true
+```
+
+```ruby
+User.invite!(email: 'new_user@example.com')
+```
+
+It can also enqueue an invitation that was created without sending its email:
+
+```ruby
+user = User.invite!(email: 'new_user@example.com', skip_invitation: true)
+user.current_invitation.deliver_later
+```
+
+The default job runs on the `mailers` queue. It reconstructs a resource-less
+invitee from the encrypted acceptance token and calls `deliver_now` on the
+configured Devise mailer because it is already executing inside a background
+job. It retains `invitation_sent_at` after successful delivery and leaves
+failed invitations retryable by clearing that timestamp if delivery raises.
+
+The example above does not require `store_invite_keys_until_delivery` because
+the invitation is enqueued while its acceptance token is still available. If
+an invitation will be reloaded and approved before it is enqueued, enable
+temporary invite-key storage:
+
+```ruby
+class User < ApplicationRecord
+  devise :invitable, store_invite_keys_until_delivery: true
+end
+
+invitation = DeviseInvitable::Invitation.find(approved_invitation_id)
+invitation.deliver_later
+```
+
+Stored invite keys are cleared after successful delivery. Placeholder-backed
+invitations do not need this setting because their persisted resource contains
+the delivery address.
+
+Configure the default queue in the Devise initializer:
+
+```ruby
+config.invitation_delivery_queue_name = :critical_mailers
+```
+
+To inherit from the application's `ApplicationJob`, add retries or callbacks,
+or use another compatible job implementation, configure a custom job class:
+
+```ruby
+class ApplicationInvitationDeliveryJob < ApplicationJob
+  queue_as :mailers
+  retry_on MailProviderError
+
+  def perform(invitation, acceptance_token = nil, options = {})
+    DeviseInvitable::InvitationDelivery.deliver_now(
+      invitation,
+      acceptance_token: acceptance_token,
+      options: options
+    )
+  end
+end
+```
+
+```ruby
+config.invitation_delivery_job = 'ApplicationInvitationDeliveryJob'
+```
+
+By default, the normal invitation flow and synchronous `Invitation#deliver`
+continue to use `send_devise_notification`. This is compatible with Devise's
+documented model override that calls Action Mailer's `deliver_later`, including
+for persisted placeholder resources. Action Mailer cannot enqueue an
+unpersisted, resource-less invitee, so enable `deliver_invitation_later` when
+`create_resource_on_invitation` is disabled. Enabling the setting or calling
+`Invitation#deliver_later` gives the invitation job ownership of the queue
+boundary. Inside that job, the gem calls the configured Devise mailer directly
+with `deliver_now`, so a `send_devise_notification` override does not create a
+second job. Other Devise notifications continue to use that override normally.
+
+Applications without Active Job can leave `deliver_invitation_later` disabled
+and continue to use synchronous delivery, or configure any compatible job class
+that responds to `perform_later`.
+
+For immediate resource-less background delivery, the encrypted acceptance
+token is a job argument. Treat the queue as sensitive storage and configure job
+logging so bearer tokens are not exposed. Mail options must also be serializable.
+
 To check if a particular user is created by invitation, irrespective to state
 of invitation one can use `created_by_invite?`
 
@@ -653,6 +835,60 @@ class Admin < ActiveRecord::Base
 end
 ```
 
+### Restricting or disabling invitation endpoints
+
+`authenticate_inviter!` may enforce any application-specific condition, not
+only authentication. For example, it can check roles, permissions,
+relationships, tenant membership, or whether an application workflow has been
+completed.
+
+The filter protects only the invitation controller's `new` and `create`
+actions. Calling `User.invite!` from an authorized application service,
+controller, callback, or background job is unaffected.
+
+To prevent invitations from being sent through the standard invitation form
+while still allowing controlled application workflows, override the filter in
+a custom invitations controller:
+
+```ruby
+class Users::InvitationsController < Devise::InvitationsController
+  protected
+
+    def authenticate_inviter!
+      redirect_to root_path, alert: "Invitations cannot be sent from this page."
+    end
+end
+```
+
+Configure Devise to use the controller:
+
+```ruby
+devise_for :users, controllers: { invitations: "users/invitations" }
+```
+
+The application can then create invitations from its authorized workflow:
+
+```ruby
+User.invite!(email: email)
+```
+
+When the standard form should remain available to some users, call `super` and
+apply the additional policy:
+
+```ruby
+class Users::InvitationsController < Devise::InvitationsController
+  protected
+
+    def authenticate_inviter!
+      super
+      return if performed?
+      return if current_user.allowed_to_invite_users?
+
+      redirect_to root_path, alert: "You are not allowed to send invitations."
+    end
+end
+```
+
 ## Has many invitations
 
 The `DeviseInvitable::Inviter` module defines a `sent_invitations` association

data/app/controllers/devise/invitations_controller.rb

@@ -51,7 +51,8 @@ class Devise::InvitationsController < DeviseController
     yield resource if block_given?
 
     if invitation_accepted
-      if resource.class.allow_insecure_sign_in_after_accept
+      if resource.class.allow_insecure_sign_in_after_accept &&
+          !resource.accepted_invitation_for_provisioned_resource?
         flash_message = resource.active_for_authentication? ? :updated : :updated_not_active
         set_flash_message :notice, flash_message if is_flashing_format?
         resource.after_database_authentication

data/app/controllers/devise_invitable/registrations_controller.rb

@@ -11,7 +11,7 @@ class DeviseInvitable::RegistrationsController < Devise::RegistrationsController
     end
 
     def build_invited_resource(hash)
-      self.resource = resource_class.where(email: hash[:email]).first
+      self.resource = resource_class.to_adapter.find_first(email: hash[:email])
       if self.resource && self.resource.respond_to?(:invited_to_sign_up?) && self.resource.invited_to_sign_up?
         self.resource.attributes = hash
         self.resource.send_confirmation_instructions if self.resource.confirmation_required_for_invited?

data/lib/devise_invitable/acceptance_token.rb

@@ -0,0 +1,58 @@
+require 'active_support/key_generator'
+require 'active_support/message_encryptor'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'json'
+
+module DeviseInvitable
+  class AcceptanceToken
+    CIPHER = 'aes-256-gcm'.freeze
+    MAX_INVITATION_DATA_BYTES = 1_024
+    PURPOSE = 'devise_invitable.invitation'.freeze
+    SALT = 'devise_invitable encrypted invitation'.freeze
+
+    class << self
+      def generate(invitation:, raw_token:, invite_key:, invitation_data: nil)
+        invitation_data = normalize_invitation_data(invitation_data)
+        encryptor.encrypt_and_sign(
+          {
+            invitation_id: invitation.id.to_s,
+            invitable_type: invitation.invitable_type,
+            raw_token: raw_token,
+            invite_key: invite_key.to_h,
+            invitation_data: invitation_data,
+          },
+          purpose: PURPOSE
+        )
+      end
+
+      def normalize_invitation_data(invitation_data)
+        return {} if invitation_data.nil?
+
+        data = invitation_data.to_h
+        serialized_data = JSON.generate(data)
+        if serialized_data.bytesize > MAX_INVITATION_DATA_BYTES
+          raise InvitationDataTooLargeError,
+            "invitation_data exceeds #{MAX_INVITATION_DATA_BYTES} serialized bytes"
+        end
+        data
+      rescue NoMethodError, TypeError, JSON::GeneratorError
+        raise ArgumentError, 'invitation_data must be a JSON-compatible hash'
+      end
+
+      def decode(token)
+        payload = encryptor.decrypt_and_verify(token, purpose: PURPOSE)
+        payload&.with_indifferent_access
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        nil
+      end
+
+      private
+
+        def encryptor
+          key_length = ActiveSupport::MessageEncryptor.key_len(CIPHER)
+          key = Rails.application.key_generator.generate_key(SALT, key_length)
+          ActiveSupport::MessageEncryptor.new(key, cipher: CIPHER, serializer: JSON)
+        end
+    end
+  end
+end

data/lib/devise_invitable/invitation.rb

@@ -9,6 +9,8 @@ module DeviseInvitable
     end
 
   class Invitation < invitation_base
+    attr_accessor :invitation_data, :transient_invite_key
+
     self.table_name = 'devise_invitations' if respond_to?(:table_name=)
 
     if defined?(Mongoid::Document) && !defined?(ActiveRecord::Base)
@@ -80,11 +82,11 @@ module DeviseInvitable
     # Deliver a pending invitation that has not been sent yet. Resource-less
     # invitations are reconstructed from their stored invite key.
     def deliver(options = {})
-      return unless pending? && invitation_sent_at.nil?
+      DeviseInvitable::InvitationDelivery.call(self, options: options)
+    end
 
-      resource = invitable || invitable_type.constantize.new(invite_key)
-      resource.instance_variable_set(:@current_invitation, self)
-      resource.deliver_invitation(options)
+    def deliver_later(options = {})
+      DeviseInvitable::InvitationDelivery.enqueue(self, options: options)
     end
 
     def invite_key
@@ -92,6 +94,15 @@ module DeviseInvitable
       value.respond_to?(:with_indifferent_access) ? value.with_indifferent_access : value
     end
 
+    def invite_key_for_acceptance
+      transient_invite_key.presence || invite_key
+    end
+
+    def clear_invite_key
+      self.transient_invite_key = nil
+      self.invite_key = {} if invite_key.present?
+    end
+
     def self.digest_for(resource_type, invite_key)
       components = invite_key.to_h.map { |key, value| [key.to_s, value.to_s] }.sort.flatten
       Digest::SHA256.hexdigest(([resource_type] + components).join("\0"))
@@ -100,7 +111,17 @@ module DeviseInvitable
     private
 
       def set_invite_key_digest
-        self.invite_key_digest = self.class.digest_for(invitable_type, invite_key)
+        return if transient_invite_key.nil? && invite_key.blank? && invite_key_digest.present?
+
+        self.invite_key_digest = self.class.digest_for(invitable_type, invite_key_for_acceptance)
+        unless transient_invite_key.nil?
+          self.invite_key =
+            if invitable_type.constantize.store_invite_keys_until_delivery
+              transient_invite_key
+            else
+              {}
+            end
+        end
       end
   end
 end

data/lib/devise_invitable/invitation_delivery.rb

@@ -0,0 +1,114 @@
+module DeviseInvitable
+  class InvitationDelivery
+    def self.call(invitation, resource: nil, acceptance_token: nil, options: {})
+      new(
+        invitation,
+        resource: resource,
+        acceptance_token: acceptance_token,
+        options: options
+      ).deliver
+    end
+
+    def self.deliver_now(invitation, resource: nil, acceptance_token: nil, options: {})
+      new(
+        invitation,
+        resource: resource,
+        acceptance_token: acceptance_token,
+        options: options,
+        deliver_now: true
+      ).deliver
+    end
+
+    def self.enqueue(invitation, resource: nil, acceptance_token: nil, options: {})
+      delivery = new(
+        invitation,
+        resource: resource,
+        acceptance_token: acceptance_token,
+        options: options
+      )
+      return unless delivery.deliverable?
+
+      DeviseInvitable.invitation_delivery_job.perform_later(
+        invitation,
+        delivery.acceptance_token,
+        options
+      )
+    end
+
+    def initialize(invitation, resource: nil, acceptance_token: nil, options: {}, deliver_now: false)
+      @invitation = invitation
+      @resource = resource
+      @acceptance_token = acceptance_token
+      @options = options
+      @deliver_now = deliver_now
+    end
+
+    def deliver
+      return unless deliverable?
+
+      token = acceptance_token # Token generation may save the invitation.
+      invitation.invitation_sent_at = Time.now.utc
+      delivery = send_notification(token)
+      invitation.clear_invite_key
+      invitation.save!
+      delivery
+    rescue
+      invitation.invitation_sent_at = nil
+      raise
+    end
+
+    def deliverable?
+      invitation.pending? && invitation.invitation_sent_at.nil?
+    end
+
+    def acceptance_token
+      @acceptance_token ||= resource.send(:prepare_invitation_delivery)
+    end
+
+    private
+
+      attr_reader :invitation, :options
+
+      def send_notification(token)
+        if @deliver_now
+          resource.send(:send_invitation_notification_now, token, options)
+        else
+          resource.send(
+            :send_devise_notification,
+            :invitation_instructions,
+            token,
+            options
+          )
+        end
+      end
+
+      def resource
+        @resource ||= begin
+          resolved_resource = invitation.invitable || resource_from_invite_key
+          resolved_resource.instance_variable_set(:@current_invitation, invitation)
+          resolved_resource
+        end
+      end
+
+      def resource_from_invite_key
+        invite_key = invitation.invite_key_for_acceptance.presence || invite_key_from_token
+        if invite_key.blank?
+          raise DeviseInvitable::MissingInviteKeyError,
+            'Cannot deliver a resource-less invitation without an acceptance token or stored invite key'
+        end
+
+        invitation.invitable_type.constantize.new(invite_key)
+      end
+
+      def invite_key_from_token
+        return unless @acceptance_token
+
+        resource_class = invitation.invitable_type.constantize
+        token_invitation, invite_key = resource_class.send(
+          :invitation_and_key_from_token,
+          @acceptance_token
+        )
+        invite_key if token_invitation&.id == invitation.id
+      end
+  end
+end

data/lib/devise_invitable/invitation_delivery_job.rb

@@ -0,0 +1,15 @@
+require 'active_job'
+
+module DeviseInvitable
+  class InvitationDeliveryJob < ActiveJob::Base
+    queue_as { Devise.invitation_delivery_queue_name }
+
+    def perform(invitation, acceptance_token = nil, options = {})
+      DeviseInvitable::InvitationDelivery.deliver_now(
+        invitation,
+        acceptance_token: acceptance_token,
+        options: options
+      )
+    end
+  end
+end