class Checkout < Mutations::BaseMutation
argument :input, Types::CheckoutInput, required: true
type Types::CheckoutOutput
def resolve(input:)
checkout = Checkout.new(input.merge(user: current_user))
if job = checkout.commit
{ checkout: checkout, job: job, errors: [], status: :in_progress }
else
{ checkout: nil, job: nil, errors: checkout.errors, status: :error }
end
end
private
def current_user
context[:current_user]
end
end
Checkout service object and call the method on it
(#commit). This returns an object for tracking the background job
on success; on failure it returns nil and sets errors on the
checkout instance. Finally we return either the checkout and job
objects with an in-progress status, or the errors with an error
status.class Checkout
extend ActiveModel::Naming
def initialize(args)
@user = args[:user]
@payment_token = args[:payment_token]
@order = args[:order]
@errors = ActiveModel::Errors.new(self)
end
##
# @return [ActiveModel::Errors] checkout errors
attr_reader :errors
##
# Advance the cart to the next step, preventing the user from double-checking
# out. Enqueue a job to complete the charge.
#
# On failure, sets errors on {#errors}.
#
# @return the [ActiveJob] instance, or falsy on failure
def commit
@order.update(state: :processing)
PaymentProcessorJob.perform_later(@payment_token, @order)
end
end
Checkout service obect takes the arguments from
the API: user, payment token, and the order we are purchasing. We make use of
Rails' error objects via the ActiveModel::Naming module and the
ActiveModel::Errors class.
The actual checkout action (#commit) does two things: update the
order's state, and enqueue a background job to communicate with the payment
processor. This method has a bug.def commit
if @order.update(state: :processing)
PaymentProcessorJob.perform_later(@payment_token, @order)
else
@errors.merge!(@order.errors)
false
end
end
#update returns
whether it succeeded. On success, proceed as before: enqueue a payment job. On
failure set the errors on ourselves and return false. This fulfills the
contract of the method.def commit
if @order.update(state: :processing)
enqueue_payment_job
else
@errors.merge!(@order.errors)
false
end
end
private
def enqueue_payment_job
job = PaymentProcessorJob.perform_later(@payment_token, @order)
return job if job
@errors.add(:base, :job_failed)
unless @order.update(state: :pending)
@errors.merge!(@order.errors)
end
false
end
def commit
if job = PaymentProcessorJob.new(@payment_token, @order).enqueue(wait: 5)
if @order.update(state: :processing)
job
else
job.cancel
@errors.merge!(@order.errors)
false
end
else
@errors.add(:base, :job_failed)
false
end
end
class JobStatusChanged < Subscriptions::BaseSubscription
field :provider_job_id, Types::Integer, null: false
type Types::JobStatus
def update(provider_job_id:)
job_status = object
if job_status.success? || job_status.failure?
unsubscribe
end
super
end
end
provider_job_id in ActiveJob). When our job would
like to broadcast an update to its subscribers, it will communicate this to
graphql-ruby via a custom JobStatus object. If the status is a success or
failure -- if it is finished -- we unsubscribe the client; we will have nothing
more to say. Regardless we broadcast out the job status for the client (via
super).class PaymentProcessorJob < ApplicationJob
##
# Capture the payment then notify the subscriptions about how it went.
#
# @return void
def perform(payment_token, order)
PaymentProvider.capture!(payment_token, order.total_price)
order.update(state: :completed)
notify_graphql(:ok)
rescue PaymentProvider::Error => e
notify_graphql(:fail, e)
end
private
def notify_graphql(status, exn = nil)
OurAppGraphQLSchema.subscriptions.trigger(
"jobStatusChanged",
{ provider_job_id: provider_job_id },
job_status_for(status, exn),
)
end
def job_status_for(status, exn)
case status
when :ok
JobStatus.new(success: true)
when :fail
JobStatus.new(success: false, errors: Array(exn.message))
end
end
end
JobStatus data class we
create.class PaymentProcessorJob < ApplicationJob
rescue_from StandardError do |job, exn|
job.notify_graphql(:fail, exn)
raise exn
end
def perform(payment_token, order)
PaymentProvider.capture!(payment_token, order.total_price)
order.update(state: :completed)
notify_graphql(:ok)
end
end
rescue_from control method to notify
all subscribers about all exceptions, and then re-raise the
exception.class PaymentProcessorJob < ApplicationJob
discard_on EOFError, Errno::ECONNRESET, Errno::EINVAL, Net::HTTPBadResponse,
Timeout::Error, ActiveJob::DeserializationError
retry_on Net::HTTPHeaderSyntaxError, Net::ProtocolError do |job, exn|
job.notify_graphql(:retry, exn)
end
private
def job_status_for(status, exn)
case status
when :ok
JobStatus.new(success: true)
when :fail
JobStatus.new(success: false, errors: Array(exn.message))
when :retry
JobStatus.new(success: nil, status: :retry)
end
end
end
discard_on and
retry_on control methods to describe what to do on various
exceptions. If we retry then we notify the subscribers with that fact, through
our JobStatus data object.def perform(payment_token, order)
PaymentProvider.capture!(payment_token, order.total_price)
unless order.update(state: :completed)
Mailer.notify_cx_about_stuck_order(payment_token, order)
end
notify_graphql(:ok)
end
#update. If it fails, we notify our customer
support team and move on with life.