Best Practices on organizing complex business logic

class User < ApplicationRecord
  
  # Data integrity validations
  validates :name, presence: true, length: { minimum: 3 }
  validate :email_format_is_correct

  # Associations
  belongs_to :organization

  private
  def email_format_is_correct
    # ....
  end

end

class Organization < ApplicationRecord
  
  # Data integrity validations
  validates :name, presence: true, length: { minimum: 3 }

  # Associations
  has_many :users

end

• User name
• User Email
• Organisation name
• Would you llike to subscribe to a newsletter?

• User email is required for this form.
• The user's email must be on a "white list" that is hosted on an external service for the form to be valid (i.e we need to do an external API call to check).

• If the user or organization fail to save, neither should be created and no "side effects" should be triggered.

• Send email to user
• Add user to mailchimp contact list.
• If user selected to enroll in newsletter, enroll it

• Forms that write on multiple models.
• Handle simultaneously model-level validations and contextual validations.
• Steps that depend on other steps: e.g If the user is not in the whitelist, a validation error should stop the execution and return the error in the user email field.
• Data integrity constraints: you would probably like to save both the user and the organization inside a database transaction.
• Trigger side-effects.
• Conditional side effects: If user selected to enroll in newsletter, enroll it

# app/use_cases/signup.rb
class Signup
  include ActiveModel::Model

  attr_accessor :user, :organization, :join_newsletter

  # Delegatation
  delegate :name, :email, to: :user, prefix: true
  delagate :name, to: :organization, prefix: true
 
  def initialize(signup_params)
    @user = User.new(user_params(signup_params))
    @organization = Organization.new(organization_params(signup_params))
  end

  # Contextual Validations
  validates :user_email, presence: true
  validate :user_email_is_on_whitelist

  def save
    # QUESTION: how to bubble up model-level validation to from object?
    if valid?
      ActiveRecord::Base.transaction do
        save_user
        save_organisation
        send_email_to_user
        add_user_to_mailchimp
        enroll_user_to_newsletter if join_newsletter
      end
      
      true
    else
      false
    end

  end

  private
  
  # Custom Validations
  def user_email_is_on_whitelist
    # QUESTION: using wrapper object that calls to external API as a service
    # Does that make sense?
    unless Service::WhitelistValidator.new(user_email).valid?
      errors.add(:user_email, "Your email is not on the whitelist")
    end
  end

  # Input parsing
  def join_newsletter
     ActiveRecord::Type::Boolean.new.cast(@join_newsletter)
  end

  # Strong Params for each internal model
  # QUESTION: the form object is taking the responsibility of strong params. Is this the right place?
  def user_params(signup_params)
    signup_params.require(:user).permit(:name, :email)
  end

  def organization_params(signup_params)
    signup_params.require(:organisation).permit(:name)
  end
  
  # Business logic

  def save_user
    @user.save!
  end

  def save_organisation
    @organisation.save!
  end

  def send_email_to_user
    UserMailer.send_welcome_email(user).deliver_later
  end

  def add_user_to_mailchimp
    Service::MailChimpContact.new(user).create
  end

  def enroll_user_to_newsletter
    Service::NewsLetterEnroller.new(user).enroll
  end


end