orchestr8 0.1.0

data/lib/orchestr8/callback_handler.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Orchestr8
+  class CallbackHandler
+    def self.on_perform(active_job_id)
+      step = find_step(active_job_id)
+      return unless step
+
+      step.update!(status: "running", started_at: Time.current)
+    end
+
+    def self.on_success(active_job_id)
+      step = find_step(active_job_id)
+      return unless step
+
+      step.update!(status: "completed", finished_at: Time.current)
+      Scheduler.call(step.workflow)
+    end
+
+    def self.on_failure(active_job_id, error)
+      step = find_step(active_job_id)
+      return unless step
+
+      error_message = "#{error.class}: #{error.message}"
+      error_message += "\n#{error.backtrace&.first(20)&.join("\n")}" if error.backtrace
+      step.update!(status: "failed", error: error_message, finished_at: Time.current)
+      Scheduler.call(step.workflow)
+    end
+
+    def self.find_step(active_job_id)
+      Step.find_by(active_job_id: active_job_id)
+    end
+
+    private_class_method :find_step
+  end
+end

data/lib/orchestr8/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Orchestr8
+  class Configuration
+    attr_accessor :base_controller_class
+
+    def initialize
+      @base_controller_class = "::ActionController::Base"
+    end
+  end
+end

data/lib/orchestr8/dsl.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Orchestr8
+  class DuplicateStepError < StandardError; end
+  class UnknownStepError < StandardError; end
+  class CircularDependencyError < StandardError; end
+
+  module Dsl
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def step_definitions
+        @step_definitions ||= {}
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@step_definitions, step_definitions.dup)
+      end
+
+      def step(name, job:, after: nil, on_failure: :halt, queue: nil)
+        name = name.to_sym
+        raise DuplicateStepError, "Step :#{name} is already defined" if step_definitions.key?(name)
+
+        after_deps = normalize_dependencies(after)
+        validate_dependencies!(after_deps)
+        step_definitions[name] = { job: job, after: after_deps, on_failure: on_failure, queue: queue }
+        detect_cycles!
+      end
+
+      private
+
+      def normalize_dependencies(after)
+        return [] if after.nil?
+
+        Array(after).map(&:to_sym)
+      end
+
+      def validate_dependencies!(deps)
+        deps.each do |dep_name|
+          unless step_definitions.key?(dep_name)
+            raise UnknownStepError,
+                  "Step :#{dep_name} is not defined. Dependencies must reference previously defined steps."
+          end
+        end
+      end
+
+      def detect_cycles!
+        visited = {}
+        in_stack = {}
+        step_definitions.each_key do |name|
+          if detect_cycle_from(name, visited, in_stack)
+            raise CircularDependencyError, "Circular dependency detected in workflow definition"
+          end
+        end
+      end
+
+      def detect_cycle_from(name, visited, in_stack)
+        return false if visited[name]
+        return true if in_stack[name]
+
+        in_stack[name] = true
+        step_definitions[name][:after].each do |dep_name|
+          return true if detect_cycle_from(dep_name, visited, in_stack)
+        end
+        in_stack.delete(name)
+        visited[name] = true
+        false
+      end
+    end
+  end
+end

data/lib/orchestr8/engine.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Orchestr8
+  class Engine < ::Rails::Engine
+    isolate_namespace Orchestr8
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_bot
+      g.factory_bot dir: "spec/factories"
+    end
+
+    initializer "orchestr8.assets" do |app|
+      app.config.assets.precompile += %w[orchestr8/application.css] if app.config.respond_to?(:assets)
+    end
+  end
+end

data/lib/orchestr8/scheduler.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Orchestr8
+  class Scheduler
+    def self.call(workflow)
+      new(workflow).call
+    end
+
+    def initialize(workflow)
+      @workflow = workflow
+    end
+
+    def call
+      workflow.with_lock do
+        loop do
+          ready_steps = find_ready_steps
+          break if ready_steps.empty?
+
+          enqueue_steps(ready_steps)
+          break unless Orchestr8.synchronous?
+
+          workflow.steps.reload
+        end
+
+        update_workflow_status
+      end
+    end
+
+    private
+
+    attr_reader :workflow
+
+    def find_ready_steps
+      workflow.steps.includes(:dependencies).select(&:ready?)
+    end
+
+    def enqueue_steps(steps)
+      steps.each do |step|
+        job_class = step.job_class.constantize
+        job = job_class.new(workflow.arguments)
+        job.queue_name = step.queue if step.queue.present?
+        step.update!(status: "enqueued", active_job_id: job.job_id)
+
+        if Orchestr8.synchronous?
+          step.update!(status: "running", started_at: Time.current)
+          begin
+            job.perform_now
+            step.update!(status: "completed", finished_at: Time.current)
+          rescue StandardError => e
+            error_msg = "#{e.class}: #{e.message}"
+            step.update!(status: "failed", error: error_msg, finished_at: Time.current)
+          end
+        else
+          job.enqueue
+        end
+      end
+    end
+
+    def update_workflow_status
+      steps = workflow.steps.reload
+      all_statuses = steps.map(&:status)
+
+      if all_statuses.all? { |s| s == "completed" }
+        workflow.update!(status: "completed", finished_at: Time.current)
+      elsif nothing_can_progress?(steps)
+        workflow.update!(status: "failed", finished_at: Time.current)
+      elsif workflow.pending? && all_statuses.any? { |s| s == "enqueued" }
+        workflow.update!(status: "running", started_at: Time.current)
+      end
+    end
+
+    def nothing_can_progress?(steps)
+      has_failure = steps.any?(&:failed?)
+      no_active = steps.none? { |s| s.pending? || s.enqueued? || s.running? }
+      no_ready = steps.none?(&:ready?)
+
+      has_failure && no_active && no_ready
+    end
+  end
+end

data/lib/orchestr8/stepable.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Orchestr8
+  module Stepable
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :orchestr8_step
+
+      before_perform :orchestr8_on_perform
+      after_perform :orchestr8_on_success
+    end
+
+    def output(data)
+      return unless orchestr8_step
+
+      orchestr8_step.update!(output: data)
+    end
+
+    def payloads
+      return {} unless orchestr8_step
+
+      orchestr8_step.dependencies.each_with_object({}) do |dep, hash|
+        hash[dep.name.to_sym] = dep.output
+      end
+    end
+
+    private
+
+    def orchestr8_on_perform
+      return if Orchestr8.synchronous?
+
+      CallbackHandler.on_perform(job_id)
+    end
+
+    def orchestr8_on_success
+      return if Orchestr8.synchronous?
+
+      CallbackHandler.on_success(job_id)
+    end
+  end
+end

data/lib/orchestr8/test_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Orchestr8
+  module TestHelper
+    def self.included(base)
+      base.before { Orchestr8.test_mode! }
+      base.after { Orchestr8.reset_test_mode! }
+    end
+  end
+end

data/lib/orchestr8/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Orchestr8
+  VERSION = "0.1.0"
+end

data/lib/orchestr8.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "orchestr8/version"
+require "orchestr8/configuration"
+require "orchestr8/dsl"
+require "orchestr8/stepable"
+require "orchestr8/scheduler"
+require "orchestr8/callback_handler"
+require "orchestr8/engine"
+
+module Orchestr8
+  class << self
+    attr_accessor :synchronous_mode
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    def test_mode!
+      self.synchronous_mode = true
+    end
+
+    def reset_test_mode!
+      self.synchronous_mode = false
+    end
+
+    def synchronous?
+      synchronous_mode == true
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: orchestr8
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Romulo Storel
+bindir: bin
+cert_chain: []
+date: 2026-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: turbo-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: Define multi-step job workflows as directed acyclic graphs. Parallel
+  execution, failure handling, data passing between steps, and a built-in DAG visualizer.
+  No Redis — all state in your database.
+email:
+- romulostorel.dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- app/assets/stylesheets/orchestr8/application.css
+- app/controllers/orchestr8/application_controller.rb
+- app/controllers/orchestr8/steps_controller.rb
+- app/controllers/orchestr8/workflows_controller.rb
+- app/models/orchestr8/step.rb
+- app/models/orchestr8/step_dependency.rb
+- app/models/orchestr8/workflow.rb
+- app/views/layouts/orchestr8/application.html.erb
+- app/views/orchestr8/workflows/_step_node.html.erb
+- app/views/orchestr8/workflows/index.html.erb
+- app/views/orchestr8/workflows/show.html.erb
+- config/routes.rb
+- db/migrate/20260407000000_create_orchestr8_tables.rb
+- lib/generators/orchestr8/install/install_generator.rb
+- lib/orchestr8.rb
+- lib/orchestr8/callback_handler.rb
+- lib/orchestr8/configuration.rb
+- lib/orchestr8/dsl.rb
+- lib/orchestr8/engine.rb
+- lib/orchestr8/scheduler.rb
+- lib/orchestr8/stepable.rb
+- lib/orchestr8/test_helper.rb
+- lib/orchestr8/version.rb
+homepage: https://github.com/romulostorel/orchestr8
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/romulostorel/orchestr8
+  source_code_uri: https://github.com/romulostorel/orchestr8
+  changelog_uri: https://github.com/romulostorel/orchestr8/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: DAG-based job workflow orchestration for Rails
+test_files: []