Best Practices

[markalanevans]

Goal

• Maintain single responsibility
• DRY
• Understand what does and doesn't go in an interactor is it a complete replacement for "Service Objects" and ideas like:
• https://github.com/envato/aldous
• https://github.com/krautcomputing/services
• https://github.com/cypriss/mutations

  Ex Stories

• When a bid is created, an Audience record should be created for it.
• When a bid is saved, if it is enabled, an JOB should be queued to update bids for a given audience.

Assuming my "domian area" is "Bidding".

Options

• I could have two interactors add_bid and updated_bid which would have lots of duplicate logic for creating and editing bids. ex:

module Bidding
  class AddBid
    include Interactor
    def call
      begin

        if(context.audience_bid_data.has_key?(:url))

          response = Intenta::Audience.create({
                                                  :url => context.audience_bid_data[:url]
                                              })

          if(response.status == 200)
            audience_id = response.body['data']['audience']['id'].to_i

            @audience_bid = AudienceBid.new(context.audience_bid_data)
            @audience_bid.advertiser_id = context.advertiser_id
            @audience_bid.audience_id = audience_id
            if @audience_bid.save
              context.audience_bid = @audience_bid
              # Cache
              Bidding::BuildAudienceBidCacheWorker.perform_async(context.audience_bid.id)
            else
              context.fail!( error: 'Failed to Create Bid')
            end
          else
            context.fail!(error: 'Failed to Create Audience')
          end
        else
          context.fail!(error: 'Missing param: url')
        end
      rescue Faraday::Error::TimeoutError => error
        context.fail!( error: error.message)
      end
    end
  end
end

Sample usage in a controller:

# POST /audience_bids
  # POST /audience_bids.json
  def create
    @audience_bid = AudienceBid.new(permitted_audience_bid_params)
    @audience_bid.advertiser_id = current_user.advertiser.id
    authorize @audience_bid

    context = {
        :advertiser_id => current_user.advertiser.id,
        :audience_bid_data => permitted_audience_bid_params
    }

    context = Bidding::AddBid.call(context)
    respond_to do |format|
      if context.success?
        format.html { redirect_to context.audience_bid, notice: 'AudienceBid was successfully created.' }
        format.json { render :show, status: :created }
      else
        format.html { render :new }
        format.json { render status: :unprocessable_entity, json: { success: false, info: @response[:error], errors: context.error } }
      end
    end

• I could have a single interactor upsert_bid that does a few simple checks to see if bids already exist.
• I could attach observers to Bid model watching for bids.enabled == true and then queue jobs.
• I could use Whisper and in each interactor subscribe to after_save events and then queue jobs.
• I could just check in the interactor if bids.enabled is true and queue the job there.

So many choices.... How would you organize it?

[laserlemon]

Closing as my upcoming focus will be on development of version 4.0. There are many potential ways to solve the issues you described and I don't think Interactor as a library is opinionated enough to provide an answer as to the "correct" solution.