Class: RobotLab::RailsIntegration::Job

Inherits:
ActiveJob::Base
  • Object
show all
Defined in:
lib/robot_lab/rails_integration/job.rb

Overview

Base class for RobotLab background jobs.

Encapsulates the full robot-run lifecycle: robot class resolution, Turbo Stream callback wiring, thread-record persistence, and completion/error broadcasting. Suitable for fiber-safe execution under Solid Queue’s fiber mode (see issue #20 for SQ version details).

Examples:

Minimal subclass using the robot_class DSL

class SupportRobotJob < RobotLab::Job
  queue_as :default
  robot_class SupportRobot
end

# Enqueue (no robot_class: needed — taken from DSL):
SupportRobotJob.perform_later(message: "Hello", thread_id: session_id)

Generic job accepting robot_class at enqueue time

class RobotRunJob < RobotLab::Job
  queue_as :default
end

RobotRunJob.perform_later(
  robot_class: "SupportRobot",
  message:     params[:message],
  thread_id:   session_id
)

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.robot_class ⇒ Class? .robot_class(klass) ⇒ Class

Set or get the default robot class for this job subclass.

Overloads:

  • .robot_class ⇒ Class?

    Returns the configured robot class.

    Returns:

    • (Class, nil) —

      the configured robot class

  • .robot_class(klass) ⇒ Class

    Parameters:

    • klass (Class) —

      the robot class (must respond to .build)

    Returns:

    • (Class) 


40
41
42
 
# File 'lib/robot_lab/rails_integration/job.rb', line 40

def self.robot_class(klass = nil)
  klass ? @robot_class = klass : @robot_class
end

Instance Method Details

#perform(message:, robot_class: nil, thread_id: nil, **context) ⇒ RobotResult

Run a robot as a background job.

When thread_id is provided the job:

  • Finds or creates a RobotLabThread record and updates its last-message fields

  • Wires TurboStreamCallbacks onto the robot (when turbo-rails is present)

  • Persists the RobotResult to RobotLabResult

  • Broadcasts a completion or error event via Turbo Streams

When thread_id is omitted the robot runs in a fire-and-forget mode —no persistence, no broadcasting, result returned directly.

Parameters:

  • message (String) —

    the user message forwarded to robot.run

  • robot_class (String, Class, nil) (defaults to: nil) —

    override; falls back to the class-level DSL

  • thread_id (String, nil) (defaults to: nil) —

    session key for persistence and Turbo broadcasting

  • context (Hash) —

    additional keyword args forwarded to robot.run

Returns:



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/robot_lab/rails_integration/job.rb', line 63

def perform(message:, robot_class: nil, thread_id: nil, **context)
  klass  = resolve_robot_class(robot_class)
  thread = setup_thread(thread_id, message)
  robot  = build_robot(klass, thread_id)
  result = robot.run(message, **context)

  if thread
    persist_result(thread, result)
    broadcast_completion(thread_id)
  end

  result
rescue StandardError => e
  broadcast_error(thread_id, e) if thread_id
  raise
end