rigid_workflow 1.0.0

data/app/controllers/rigid_workflow/runs_controller.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+module RigidWorkflow
+  # Manages workflow run CRUD operations and bulk actions.
+  # Provides views for listing, filtering, and controlling workflow runs.
+  class RunsController < ApplicationController
+    helper WorkflowsHelper
+
+    def index
+      @runs = filter_runs.page(page_params)
+    end
+
+    def pending_runs
+      @runs = filter_runs(%i[pending]).page(page_params)
+      render :index
+    end
+
+    def active_runs
+      @runs = filter_runs(%i[running]).page(page_params)
+      render :index
+    end
+
+    def completed_runs
+      @runs = filter_runs(%i[completed]).page(page_params)
+      render :index
+    end
+
+    def failed_runs
+      @runs = filter_runs(%i[failed]).page(page_params)
+      render :index
+    end
+
+    def show
+      @run =
+        RigidWorkflow::Run.includes(steps: :attempts, signals: []).find(
+          params[:id]
+        )
+      respond_to do |format|
+        format.html
+        format.json do
+          render json: {
+                   workflow: @run,
+                   steps:
+                     @run
+                       .steps
+                       .includes(:attempts)
+                       .order(:id)
+                       .map { |s|
+                         s.attributes.merge(
+                           attempts:
+                             s.attempts.order(:attempt_number).map(&:attributes)
+                         )
+                       },
+                   signals: @run.signals.order(:id)
+                 }
+        end
+      end
+    end
+
+    ALLOWED_BULK_ACTIONS = %i[retry cancel].freeze
+
+    def bulk_action
+      permitted = bulk_action_params
+      return render_error("Invalid action") unless permitted[:action]
+
+      runs = RigidWorkflow::Run.where(id: permitted[:ids])
+      success_count = 0
+      errors = []
+
+      runs.each do |run|
+        begin
+          case permitted[:action]
+          when :retry
+            run.retry!
+          when :cancel
+            run.cancel!
+          end
+          success_count += 1
+        rescue => error
+          errors << "#{run.id}: #{error.message}"
+        end
+      end
+
+      action_label =
+        permitted[:action] == :retry ? "retry" : permitted[:action].to_s
+      notice =
+        "Applied #{action_label} to #{success_count} #{"run".pluralize(success_count)}."
+      notice +=
+        " #{errors.join(', ')} #{"run".pluralize(errors.size)} failed." if errors.any?
+
+      # Redirect to show page if single run, otherwise to referrer or list
+      if permitted[:ids].size == 1
+        redirect_to runs_show_path(permitted[:ids].first), notice: notice
+      else
+        redirect_to request.referrer || admin_rigid_workflow_runs_path,
+                    notice: notice
+      end
+    end
+
+    private
+
+    def bulk_action_params
+      permitted = params.permit(:authenticity_token, :bulk_action, ids: [])
+      {
+        ids: Array(permitted[:ids]).select(&:present?),
+        action:
+          (
+            if ALLOWED_BULK_ACTIONS.include?(permitted[:bulk_action]&.to_sym)
+              permitted[:bulk_action].to_sym
+            else
+              nil
+            end
+          )
+      }
+    end
+
+    def render_error(message)
+      redirect_to request.referrer || admin_rigid_workflow_runs_path,
+                  alert: message
+    end
+
+    def page_params
+      page = params[:page].to_i
+      page.positive? ? page : 1
+    end
+
+    def filter_runs(statuses = nil, workflow_class: nil)
+      RigidWorkflow::Run.filter_runs(
+        statuses,
+        workflow_class: workflow_class || params[:workflow]
+      )
+    end
+  end
+end

data/app/controllers/rigid_workflow/workflows_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RigidWorkflow
+  # Provides workflow statistics and failed workflow reporting.
+  # Shows workflow performance metrics and error details.
+  class WorkflowsController < ApplicationController
+    def index
+      @stats = self.class.stats_for_ever
+    end
+  end
+end

data/app/helpers/rigid_workflow/runs_helper.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module RigidWorkflow
+  # Serializes workflow runs to JSON for API responses.
+  module RunsHelper
+    def run_to_json(run)
+      {
+        workflow: {
+          id: run.id,
+          workflow_class: run.workflow_class,
+          status: run.status,
+          version: run.version,
+          params: run.params,
+          memory: run.memory,
+          created_at: run.created_at,
+          started_at: run.started_at,
+          finished_at: run.finished_at
+        },
+        steps:
+          run.steps.order(created_at: :asc).map { |step| serialize_step(step) },
+        signals:
+          run
+            .signals
+            .order(created_at: :asc)
+            .map { |signal| serialize_signal(signal) }
+      }
+    end
+
+    private
+
+    def serialize_step(step)
+      attempt = step.current_attempt
+      {
+        id: step.id,
+        step_name: step.step_name,
+        activity_class: step.activity_class,
+        status: step.status,
+        attempt: step.attempt_count,
+        max_attempts: step.max_attempts,
+        input: step.input,
+        output: step.output,
+        error_details: step.error_details,
+        created_at: step.created_at,
+        started_at: attempt&.started_at || step.created_at,
+        finished_at: attempt&.finished_at,
+        scheduled_at: step.scheduled_at,
+        failed_at: attempt&.failed_at
+      }
+    end
+
+    def serialize_signal(signal)
+      {
+        id: signal.id,
+        name: signal.name,
+        payload: signal.payload,
+        received_at: signal.received_at,
+        canceled_at: signal.canceled_at,
+        expires_at: signal.expires_at,
+        created_at: signal.created_at,
+        updated_at: signal.updated_at
+      }
+    end
+  end
+end

data/app/helpers/rigid_workflow/workflows_helper.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RigidWorkflow
+  # Formats workflow attributes for display in views.
+  # Handles identifiers, datetimes, durations, JSON, and status badges.
+  module WorkflowsHelper
+    IDENTIFIER_KEYS = %w[id workflow_run_id run_id].freeze
+    DATETIME_KEYS = %w[created_at updated_at finished_at started_at].freeze
+    CLASSNAME_KEYS = %w[
+      job_class
+      class_name
+      activity_class
+      workflow_class
+    ].freeze
+    DURATION_KEYS = %w[duration].freeze
+    JSON_KEYS = %w[memory params].freeze
+    STATUS_KEYS = %w[status].freeze
+
+    def format_attribute(key, value)
+      return format_identifier(value) if IDENTIFIER_KEYS.include?(key)
+      return format_datetime(value) if DATETIME_KEYS.include?(key)
+      return format_classname(value) if CLASSNAME_KEYS.include?(key)
+      return format_duration(value) if DURATION_KEYS.include?(key)
+      return format_json(value) if JSON_KEYS.include?(key)
+      return format_status(value) if STATUS_KEYS.include?(key)
+      format_default(value)
+    end
+
+    def format_identifier(value)
+      return content_tag(:span, "—", class: "text-gray-400") if value.blank?
+      content_tag(
+        :code,
+        value,
+        class: "text-xs font-mono text-gray-500 select-all"
+      )
+    end
+
+    def format_datetime(value)
+      return content_tag(:span, "—", class: "text-gray-400") if value.blank?
+      content_tag(
+        :span,
+        local_time(value, format: "%Y-%m-%d %H:%M:%S"),
+        class: "text-sm"
+      )
+    end
+
+    def format_classname(value)
+      return content_tag(:span, "—", class: "text-gray-400") if value.blank?
+      content_tag(
+        :code,
+        value,
+        class: "text-sm font-mono font-medium text-gray-900 select-all"
+      )
+    end
+
+    def format_duration(value)
+      return content_tag(:span, "—", class: "text-gray-400") if value.blank?
+      mins = value > 60 ? "#{(value / 60.0).floor}m" : ""
+      secs = (value < 60 ? "%.2gs" : "%.0fs") % (value % 60)
+      content_tag(:span, "#{mins}#{secs}", class: "text-sm")
+    end
+
+    def format_json(value)
+      return content_tag(:span, "—", class: "text-gray-400") if value.blank?
+      content_tag(
+        :pre,
+        JSON.pretty_generate(value),
+        class: "text-xs max-h-30 overflow-y-auto"
+      )
+    end
+
+    def format_status(value)
+      badge_class =
+        case value.to_s.downcase
+        when "completed"
+          "bg-green-100 text-green-800"
+        when "failed", "error", "cancelled"
+          "bg-red-100 text-red-800"
+        when "pending"
+          "bg-yellow-100 text-yellow-800"
+        else
+          "bg-gray-100 text-gray-800"
+        end
+
+      content_tag(
+        :span,
+        value.to_s.humanize,
+        class:
+          "inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium #{badge_class}"
+      )
+    end
+
+    def format_default(value)
+      value.to_s.presence || content_tag(:span, "—", class: "text-gray-400")
+    end
+
+    def run_actions_for(status)
+      case status.to_s
+      when "pending", "compensating"
+        "cancel"
+      when "running"
+        "retry, cancel"
+      when "failed"
+        "retry"
+      else
+        ""
+      end
+    end
+  end
+end

data/app/javascript/rigid_workflow/application.js

@@ -0,0 +1,9 @@
+import "@hotwired/turbo-rails";
+import LocalTime from "local-time";
+import "rigid_workflow/controllers";
+
+LocalTime.start();
+
+document.addEventListener("turbo:morph", () => {
+  LocalTime.run();
+});

data/app/javascript/rigid_workflow/controllers/application.js

@@ -0,0 +1,7 @@
+import { Application } from "@hotwired/stimulus";
+
+const application = Application.start();
+application.debug = false;
+window.Stimulus = application;
+
+export { application };

data/app/javascript/rigid_workflow/controllers/index.js

@@ -0,0 +1,4 @@
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading";
+import { application } from "rigid_workflow/controllers/application";
+
+eagerLoadControllersFrom("rigid_workflow/controllers", application);

data/app/javascript/rigid_workflow/controllers/selection_controller.js

@@ -0,0 +1,91 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static targets = [
+    "row",
+    "actionBar",
+    "selectAll",
+    "actionForm",
+    "action",
+    "actionButton",
+    "count",
+  ];
+
+  toggleAll() {
+    const isChecked = this.selectAllTarget.checked;
+    this.rowTargets.forEach((cb) => (cb.checked = isChecked));
+    this.updateActionBar();
+  }
+
+  toggleRow() {
+    const allChecked = this.rowTargets.every((cb) => cb.checked);
+    const someChecked = this.rowTargets.some((cb) => cb.checked);
+
+    this.selectAllTarget.checked = allChecked;
+    this.selectAllTarget.indeterminate = someChecked && !allChecked;
+    this.updateActionBar();
+  }
+
+  deselectAll() {
+    this.rowTargets.forEach((cb) => (cb.checked = false));
+    this.selectAllTarget.checked = false;
+    this.selectAllTarget.indeterminate = false;
+    this.updateActionBar();
+  }
+
+  updateActionBar() {
+    const selectedRows = this.rowTargets.filter((cb) => cb.checked);
+    const hasSelection = selectedRows.length > 0;
+
+    if (hasSelection) {
+      this.actionBarTarget.classList.remove("hidden");
+    } else {
+      this.actionBarTarget.classList.add("hidden");
+    }
+
+    this.actionButtonTargets.forEach((btn) => {
+      const type = btn.dataset.type;
+      let count = 0;
+      selectedRows.forEach((cb) => {
+        const actions = cb
+          .closest("tr")
+          .dataset.actions.split(",")
+          .map((a) => a.trim());
+        if (actions.includes(type)) count++;
+      });
+
+      btn.querySelector('[data-selection-target="count"]').textContent = count;
+      btn.disabled = count === 0;
+      btn.classList.toggle("opacity-50", count === 0);
+      btn.classList.toggle("cursor-not-allowed", count === 0);
+    });
+  }
+
+  submitBulk(event) {
+    if (event.currentTarget.disabled) return;
+    this.actionTarget.value = event.currentTarget.dataset.type;
+
+    // Collect IDs from checked checkboxes
+    const ids = new Set();
+    this.rowTargets.forEach(cb => {
+      if (cb.checked) ids.add(cb.value);
+    });
+
+    // Include IDs from existing hidden fields (for single-item views like show page)
+    this.actionFormTarget.querySelectorAll('input[name="ids[]"]').forEach(el => {
+      ids.add(el.value);
+    });
+
+    // Rebuild ids[] inputs
+    this.actionFormTarget.querySelectorAll('input[name="ids[]"]').forEach(el => el.remove());
+    ids.forEach(id => {
+      const input = document.createElement('input');
+      input.type = 'hidden';
+      input.name = 'ids[]';
+      input.value = id;
+      this.actionFormTarget.appendChild(input);
+    });
+
+    this.actionFormTarget.submit();
+  }
+}

data/app/javascript/rigid_workflow/controllers/workflow_viz_controller.js

@@ -0,0 +1,160 @@
+import { Controller } from "@hotwired/stimulus";
+
+// vis-timeline standalone build loads into window.vis
+const { DataSet, Timeline } = window.vis;
+
+function formatDuration(duration) {
+  if (duration > 3600 * 1000) {
+    return `${(duration / (3600 * 1000)).toFixed(0)}h`;
+  } else if (duration > 60 * 1000) {
+    return `${(duration / (60 * 1000)).toFixed(0)}m`;
+  } else if (duration >= 1000) {
+    return `${(duration / 1000).toFixed(0)}s`;
+  } else {
+    return `${duration}ms`;
+  }
+}
+
+export default class extends Controller {
+  static targets = ["chart", "listItemTemplate"];
+  static values = { runId: String };
+
+  async connect() {
+    try {
+      const response = await fetch(`/admin/rigid_workflow/runs/${this.runIdValue}.json`);
+      const data = await response.json();
+      this.workflowData = data;
+      this.render(data);
+    } catch (error) {
+      console.error("Failed to load workflow run:", error);
+    }
+  }
+
+  backgroundForStatus(status) {
+    switch (status) {
+      case "completed":
+        return "!bg-green-100 !border-green-300";
+      case "pending":
+        return "!bg-yellow-100 !border-yellow-300";
+      case "failed":
+        return "!bg-red-100 !border-red-300";
+      default:
+        return "!bg-gray-100 !border-gray-300";
+    }
+  }
+
+  render(data) {
+    this.workflowData = data;
+    this.steps = data.steps;
+    this.signals = data.signals;
+
+    const items = new DataSet();
+    const startDate = new Date(data.workflow.started_at);
+    const runEndDate = data.workflow.finished_at
+      ? new Date(data.workflow.finished_at)
+      : new Date(data.workflow.updated_at);
+
+    const duration = runEndDate - startDate;
+    const duration_suffix = formatDuration(duration);
+
+    // Workflow overall
+    items.add({
+      id: data.workflow.id,
+      content: `<div class="flex items-center justify-between gap-2"><span>${data.workflow.workflow_class} <i>${duration_suffix}</i></span></div>`,
+      start: startDate,
+      end: runEndDate,
+      type: "range",
+      selectable: false,
+      className: `timeline-status-${data.workflow.status} ${this.backgroundForStatus(data.workflow.status)} !rounded !shadow-sm !font-medium !text-sm !text-gray-900`,
+      order: data.workflow.id,
+    });
+
+    // Steps - render individual attempts
+    data.steps.forEach((step) => {
+      if (step.attempts && step.attempts.length > 0) {
+        step.attempts.forEach((attempt) => {
+          const startDate = new Date(attempt.started_at || step.started_at || step.created_at);
+          const endDate = new Date(
+            attempt.finished_at || attempt.failed_at || step.finished_at || +runEndDate,
+          );
+
+          const attempt_suffix = step.attempts.length > 1 ? ` (#${attempt.attempt_number})` : "";
+          const duration = endDate - startDate;
+          const duration_suffix = formatDuration(duration);
+
+          items.add({
+            id: attempt.id,
+            content: `<div class="flex items-center justify-between gap-2"><span>${step.step_name}${attempt_suffix}</span><span class="text-xs text-gray-500 ml-2"> <i>${duration_suffix}</i></span></div>`,
+            start: startDate,
+            end: endDate,
+            type: "range",
+            className: `timeline-status-${attempt.status} cursor-pointer ${this.backgroundForStatus(attempt.status)} !rounded !shadow-sm !font-medium !text-sm !text-gray-900`,
+            order: step.id + attempt.attempt_number * 0.001,
+          });
+        });
+      } else {
+        // Fallback: render step if no attempts
+        const startDate = new Date(step.started_at || step.created_at);
+        const endDate = new Date(step.finished_at || +runEndDate);
+
+        const duration = endDate - startDate;
+        const duration_suffix = formatDuration(duration);
+
+        items.add({
+          id: step.id,
+          content: `<div class="flex items-center justify-between gap-2"><span>${step.step_name} <i>${duration_suffix}</i></span></div>`,
+          start: startDate,
+          end: endDate,
+          type: "range",
+          className: `timeline-status-${step.status} cursor-pointer !bg-blue-100 !border-blue-300 !rounded !shadow-sm !font-medium !text-sm !text-gray-900`,
+          order: step.id,
+        });
+      }
+    });
+
+    // Signals
+    data.signals.forEach((signal, index) => {
+      const startDate = new Date(signal.created_at);
+      const endDate = new Date(
+        signal.received_at || signal.expires_at || signal.canceled_at || +runEndDate,
+      );
+      const isTimer = !!signal.expires_at;
+
+      // Determine status for signal/timer
+      let signalStatus = "pending";
+      if (signal.canceled_at) {
+        signalStatus = "canceled";
+      } else if (signal.received_at) {
+        signalStatus = "completed";
+      }
+
+      items.add({
+        id: signal.id,
+        content: `<div class="flex items-center justify-between gap-2"><span>${signal.name}</span></div>`,
+        start: startDate,
+        end: endDate,
+        type: "range",
+        className: `timeline-status-${signalStatus} cursor-pointer ${signal.canceled_at ? "!bg-gray-100 !border-gray-300" : isTimer ? "!bg-yellow-100 !border-yellow-300" : "!bg-purple-100 !border-purple-300"} !rounded !shadow-sm !font-medium !text-sm !text-gray-900`,
+        order: signal.id,
+      });
+    });
+
+    const options = {
+      orientation: "top",
+      stack: true,
+      showCurrentTime: false,
+      min: startDate - 0.1 * duration,
+      max: runEndDate - 0.2 * -duration,
+      zoomMax: duration * 1.3,
+      zoomMin: 500,
+      zoomKey: "shiftKey",
+      horizontalScroll: true,
+      verticalScroll: true,
+      minHeight: 250,
+      order: (a, b) => a.order - b.order,
+    };
+
+    this.chartTarget.innerHTML = "";
+    const timeline = new Timeline(this.chartTarget, items, options);
+  }
+}

data/app/jobs/rigid_workflow/activity_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RigidWorkflow
+  # Executes a workflow activity.
+  # Runs on the :activities queue.
+  class ActivityJob < ::ActiveJob::Base
+    queue_as :activities
+    limits_concurrency group: "rigid_workflow_step", key: ->(step_id, *) { step_id }
+
+    def perform(step_id)
+      Step.execute_activity(step_id)
+    end
+  end
+end

data/app/jobs/rigid_workflow/timer_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RigidWorkflow
+  # Processes timed signals that have expired.
+  # Runs on the :timers queue.
+  class TimerJob < ::ActiveJob::Base
+    queue_as :timers
+
+    def perform(signal_id)
+      Signal.process_signal(signal_id)
+    end
+  end
+end

data/app/jobs/rigid_workflow/workflow_job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RigidWorkflow
+  # Executes workflow advancement by scheduling the next iteration.
+  # Runs on the :workflows queue with per-run concurrency limits.
+  class WorkflowJob < ::ActiveJob::Base
+    queue_as :workflows
+    limits_concurrency group: "rigid_workflow", key: ->(run_id, *) { run_id }
+
+    def perform(run_id)
+      workflow_run = RigidWorkflow::Run.find_by(id: run_id)
+      return if workflow_run.nil? || workflow_run.finished?
+
+      RigidWorkflow::Orchestrator.advance!(workflow_run)
+    end
+  end
+end