orkestr 1.0.0

data/app/services/orkestr/workflow_service/import.rb

@@ -0,0 +1,29 @@
+module Orkestr
+  module WorkflowService
+    class Import
+      attr_reader :data
+
+      def initialize(data)
+        @data = data.deep_symbolize_keys
+      end
+
+      def call
+        Workflow.transaction do
+          workflow = Workflow.create!(
+            name: data[:name] || "Imported workflow",
+            status: "draft",
+            trigger_type: data[:trigger_type],
+            trigger_config: data[:trigger_config] || {},
+            default_context: data[:default_context] || {},
+            reuse_context: data[:reuse_context] || false,
+            graph_json: data[:graph_json] || {}
+          )
+
+          WorkflowSynchronizer.new(workflow).call if workflow.graph_json.present?
+
+          workflow
+        end
+      end
+    end
+  end
+end

data/app/services/orkestr/workflow_synchronizer.rb

@@ -0,0 +1,102 @@
+module Orkestr
+  class WorkflowSynchronizer
+    attr_reader :workflow
+
+    def initialize(workflow)
+      @workflow = workflow
+    end
+
+    def call
+      graph = workflow.graph
+      flow_nodes = graph[:nodes] || []
+      flow_edges = graph[:edges] || []
+
+      ActiveRecord::Base.transaction do
+        remove_stale_edges(flow_edges)
+        remove_stale_nodes(flow_nodes)
+        upsert_nodes(flow_nodes)
+        upsert_edges(flow_edges)
+        detect_cycles! unless Orkestr.configuration.allow_cycles
+      end
+    end
+
+    private
+
+    def remove_stale_edges(flow_edges)
+      flow_ids = flow_edges.map { |e| e[:id].to_s }
+      workflow.edges.where.not(react_flow_id: flow_ids).destroy_all
+    end
+
+    def remove_stale_nodes(flow_nodes)
+      flow_ids = flow_nodes.map { |n| n[:id].to_s }
+      workflow.nodes.where.not(react_flow_id: flow_ids).destroy_all
+    end
+
+    # Fields that are internal to the React Flow UI and should not be persisted in config_json
+    UI_INTERNAL_KEYS = %i[type label executionStatus].freeze
+
+    def upsert_nodes(flow_nodes)
+      flow_nodes.each do |flow_node|
+        data = (flow_node[:data] || {}).deep_dup
+        conditions = data.delete(:conditions) || {}
+        UI_INTERNAL_KEYS.each { |key| data.delete(key) }
+        node = workflow.nodes.find_or_initialize_by(react_flow_id: flow_node[:id].to_s)
+        node.update!(
+          node_type: flow_node[:type] || flow_node.dig(:data, :type) || "default",
+          config_json: data,
+          conditions_json: conditions
+        )
+      end
+    end
+
+    def upsert_edges(flow_edges)
+      flow_edges.each do |flow_edge|
+        source = workflow.nodes.find_by!(react_flow_id: flow_edge[:source].to_s)
+        target = workflow.nodes.find_by!(react_flow_id: flow_edge[:target].to_s)
+
+        edge = workflow.edges.find_or_initialize_by(react_flow_id: flow_edge[:id].to_s)
+        edge.update!(
+          source_node: source,
+          target_node: target,
+          source_handle: flow_edge[:sourceHandle]
+        )
+      end
+    end
+
+    def detect_cycles!
+      nodes = workflow.nodes.reload.index_by(&:id)
+      adjacency = Hash.new { |h, k| h[k] = [] }
+
+      workflow.edges.reload.each do |edge|
+        adjacency[edge.source_node_id] << edge.target_node_id
+      end
+
+      visited = Set.new
+      in_stack = Set.new
+
+      nodes.each_key do |node_id|
+        next if visited.include?(node_id)
+
+        if dfs_has_cycle?(node_id, adjacency, visited, in_stack)
+          raise Orkestr::CycleDetectedError, "Workflow graph contains a cycle"
+        end
+      end
+    end
+
+    def dfs_has_cycle?(node_id, adjacency, visited, in_stack)
+      visited.add(node_id)
+      in_stack.add(node_id)
+
+      adjacency[node_id].each do |neighbor|
+        if in_stack.include?(neighbor)
+          return true
+        elsif !visited.include?(neighbor)
+          return true if dfs_has_cycle?(neighbor, adjacency, visited, in_stack)
+        end
+      end
+
+      in_stack.delete(node_id)
+      false
+    end
+  end
+end

data/app/views/layouts/orkestr/application.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Orkestr</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+
+  <%= stylesheet_link_tag    "orkestr/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/layouts/orkestr/ui.html.erb

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Orkestr</title>
+    <style>html, body { margin: 0; padding: 0; height: 100%; }</style>
+    <% Orkestr.configuration.custom_ui_styles.each do |style_path| %>
+      <%= stylesheet_link_tag style_path %>
+    <% end %>
+  </head>
+  <body>
+    <%= yield %>
+    <% Orkestr.configuration.custom_ui_scripts.each do |script_path| %>
+      <%= javascript_include_tag script_path %>
+    <% end %>
+  </body>
+</html>

data/app/views/orkestr/human_tasks/show.html.erb

@@ -0,0 +1,17 @@
+<%# Standalone task form page — uses the web component.
+    Host apps can also embed <orkestr-editor mode="task" task-id="...">
+    inside their own containers (modals, panels, etc.) %>
+<%= javascript_include_tag "orkestr/orkestr-editor", defer: true %>
+
+<div style="max-width:40rem;margin:2rem auto;padding:0 1rem;">
+  <h2 style="font-size:1.25rem;font-weight:600;margin-bottom:1rem;">
+    <%= @task.node&.config_json&.dig("description") || @task.node&.config_json&.dig("label") || "Complete Task" %>
+  </h2>
+
+  <orkestr-editor
+    api-base-url="<%= request.path.sub(%r{/human_tasks.*$}, "") %>"
+    mode="task"
+    task-id="<%= @task.id %>"
+    style="display:block;min-height:200px;">
+  </orkestr-editor>
+</div>

data/app/views/orkestr/ui/index.html.erb

@@ -0,0 +1,8 @@
+<%= javascript_include_tag "orkestr/orkestr-editor", defer: true %>
+
+<% api_base = request.path.sub(%r{/ui.*$}, "") %>
+<orkestr-editor
+  api-base-url="<%= api_base %>"
+  mode="dashboard"
+  style="display: block; width: 100%; height: 100vh;">
+</orkestr-editor>

data/config/routes.rb

@@ -0,0 +1,27 @@
+Orkestr::Engine.routes.draw do
+  post "webhooks/:workflow_id", to: "webhooks#create", as: :webhook
+
+  namespace :api do
+    resources :workflows, only: %i[index show create update destroy] do
+      resources :executions, only: %i[index create]
+    end
+    resources :executions, only: %i[show]
+    resources :human_tasks, only: %i[index show] do
+      member do
+        put :complete
+      end
+    end
+    get "registry/nodes", to: "registry#nodes"
+    get "registry/triggers", to: "registry#triggers"
+  end
+
+  # HTML endpoints for embedding human task forms in host apps (turbo frame compatible)
+  resources :human_tasks, only: %i[show] do
+    member do
+      put :complete
+    end
+  end
+
+  get "ui", to: "ui#index"
+  get "ui/*path", to: "ui#index"
+end

data/db/migrate/20260308204133_enable_pgcrypto_extension.rb

@@ -0,0 +1,5 @@
+class EnablePgcryptoExtension < ActiveRecord::Migration[8.0]
+  def change
+    enable_extension "pgcrypto" unless extension_enabled?("pgcrypto")
+  end
+end

data/db/migrate/20260308204558_create_orkestr_workflows.rb

@@ -0,0 +1,12 @@
+class CreateOrkestrWorkflows < ActiveRecord::Migration[8.0]
+  def change
+    create_table :orkestr_workflows, id: :uuid do |t|
+      t.string :name, null: false
+      t.json :graph_json, null: false, default: {}
+      t.string :trigger_type
+      t.json :trigger_config, null: false, default: {}
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260308204703_create_orkestr_nodes.rb

@@ -0,0 +1,12 @@
+class CreateOrkestrNodes < ActiveRecord::Migration[8.0]
+  def change
+    create_table :orkestr_nodes, id: :uuid do |t|
+      t.references :workflow, null: false, foreign_key: { to_table: :orkestr_workflows }, type: :uuid
+      t.string :node_type, null: false
+      t.json :config_json, null: false, default: {}
+      t.json :conditions_json, null: false, default: {}
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260308204807_create_orkestr_edges.rb

@@ -0,0 +1,12 @@
+class CreateOrkestrEdges < ActiveRecord::Migration[8.0]
+  def change
+    create_table :orkestr_edges, id: :uuid do |t|
+      t.references :workflow, null: false, foreign_key: { to_table: :orkestr_workflows }, type: :uuid
+      t.references :source_node, null: false, foreign_key: { to_table: :orkestr_nodes }, type: :uuid
+      t.references :target_node, null: false, foreign_key: { to_table: :orkestr_nodes }, type: :uuid
+      t.string :source_handle
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260308204931_create_orkestr_executions.rb

@@ -0,0 +1,13 @@
+class CreateOrkestrExecutions < ActiveRecord::Migration[8.0]
+  def change
+    create_table :orkestr_executions, id: :uuid do |t|
+      t.references :executable, polymorphic: true, null: true, type: :uuid
+      t.json :context_json, null: false, default: {}
+      t.string :status, null: false, default: "pending"
+      t.datetime :started_at
+      t.datetime :finished_at
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260308205023_create_orkestr_node_executions.rb

@@ -0,0 +1,16 @@
+class CreateOrkestrNodeExecutions < ActiveRecord::Migration[8.0]
+  def change
+    create_table :orkestr_node_executions, id: :uuid do |t|
+      t.references :execution, null: false, foreign_key: { to_table: :orkestr_executions }, type: :uuid
+      t.references :node, null: false, foreign_key: { to_table: :orkestr_nodes }, type: :uuid
+      t.string :status, null: false, default: "pending"
+      t.json :input_json, null: false, default: {}
+      t.json :output_json, null: false, default: {}
+      t.datetime :started_at
+      t.datetime :finished_at
+      t.integer :attempt, null: false, default: 1
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260308205119_add_react_flow_id_to_nodes.rb

@@ -0,0 +1,6 @@
+class AddReactFlowIdToNodes < ActiveRecord::Migration[8.0]
+  def change
+    add_column :orkestr_nodes, :react_flow_id, :string
+    add_index :orkestr_nodes, :react_flow_id
+  end
+end

data/db/migrate/20260308205123_add_react_flow_id_to_edges.rb

@@ -0,0 +1,6 @@
+class AddReactFlowIdToEdges < ActiveRecord::Migration[8.0]
+  def change
+    add_column :orkestr_edges, :react_flow_id, :string
+    add_index :orkestr_edges, :react_flow_id
+  end
+end

data/db/migrate/20260308205745_add_workflow_to_executions.rb

@@ -0,0 +1,5 @@
+class AddWorkflowToExecutions < ActiveRecord::Migration[8.0]
+  def change
+    add_reference :orkestr_executions, :workflow, null: false, foreign_key: { to_table: :orkestr_workflows }, type: :uuid
+  end
+end

data/db/migrate/20260308205940_make_executable_nullable_on_executions.rb

@@ -0,0 +1,6 @@
+class MakeExecutableNullableOnExecutions < ActiveRecord::Migration[8.0]
+  def change
+    change_column_null :orkestr_executions, :executable_id, true
+    change_column_null :orkestr_executions, :executable_type, true
+  end
+end

data/db/migrate/20260308220730_create_orkestr_human_tasks.rb

@@ -0,0 +1,15 @@
+class CreateOrkestrHumanTasks < ActiveRecord::Migration[8.0]
+  def change
+    create_table :orkestr_human_tasks, id: :uuid do |t|
+      t.references :node_execution, null: false, foreign_key: { to_table: :orkestr_node_executions }, type: :uuid
+      t.references :execution, null: false, foreign_key: { to_table: :orkestr_executions }, type: :uuid
+      t.references :node, null: false, foreign_key: { to_table: :orkestr_nodes }, type: :uuid
+      t.json :schema_json, null: false, default: {}
+      t.json :response_json
+      t.string :status, null: false, default: "pending"
+      t.datetime :completed_at
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260308220900_create_orkestr_assignees.rb

@@ -0,0 +1,13 @@
+class CreateOrkestrAssignees < ActiveRecord::Migration[8.0]
+  def change
+    create_table :orkestr_assignees, id: :uuid do |t|
+      t.references :human_task, null: false, foreign_key: { to_table: :orkestr_human_tasks }, type: :uuid
+      t.string :assignable_type, null: false
+      t.string :assignable_id, null: false
+
+      t.timestamps
+    end
+
+    add_index :orkestr_assignees, %i[assignable_type assignable_id]
+  end
+end

data/db/migrate/20260308234115_add_unique_index_to_node_executions.rb

@@ -0,0 +1,7 @@
+class AddUniqueIndexToNodeExecutions < ActiveRecord::Migration[8.0]
+  def change
+    add_index :orkestr_node_executions, %i[execution_id node_id],
+              unique: true,
+              name: "index_orkestr_node_executions_unique_per_execution"
+  end
+end

data/db/migrate/20260309075336_create_orkestr_contexts.rb

@@ -0,0 +1,10 @@
+class CreateOrkestrContexts < ActiveRecord::Migration[8.0]
+  def change
+    create_table :orkestr_contexts, id: :uuid do |t|
+      t.references :contextualizable, polymorphic: true, null: true, type: :uuid
+      t.jsonb :data, null: false, default: {}
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260309075343_replace_executable_with_context_on_executions.rb

@@ -0,0 +1,11 @@
+class ReplaceExecutableWithContextOnExecutions < ActiveRecord::Migration[8.0]
+  def change
+    add_reference :orkestr_executions, :context, null: true, type: :uuid,
+                  foreign_key: { to_table: :orkestr_contexts }
+
+    remove_index :orkestr_executions, name: :index_orkestr_executions_on_executable
+    remove_column :orkestr_executions, :executable_type, :string
+    remove_column :orkestr_executions, :executable_id, :uuid
+    remove_column :orkestr_executions, :context_json, :json, null: false, default: {}
+  end
+end

data/db/migrate/20260309080416_add_status_key_deadline_to_orkestr_assignees.rb

@@ -0,0 +1,7 @@
+class AddStatusKeyDeadlineToOrkestrAssignees < ActiveRecord::Migration[8.0]
+  def change
+    add_column :orkestr_assignees, :key, :string
+    add_column :orkestr_assignees, :status, :string, null: false, default: "pending"
+    add_column :orkestr_assignees, :deadline, :datetime
+  end
+end

data/db/migrate/20260309082815_add_status_and_workflow_to_orkestr_contexts.rb

@@ -0,0 +1,7 @@
+class AddStatusAndWorkflowToOrkestrContexts < ActiveRecord::Migration[8.0]
+  def change
+    add_column :orkestr_contexts, :status, :string, null: false, default: "pending"
+    add_reference :orkestr_contexts, :workflow, type: :uuid, null: true,
+                  foreign_key: { to_table: :orkestr_workflows }
+  end
+end

data/db/migrate/20260309082816_add_status_default_context_and_reuse_context_to_orkestr_workflows.rb

@@ -0,0 +1,7 @@
+class AddStatusDefaultContextAndReuseContextToOrkestrWorkflows < ActiveRecord::Migration[8.0]
+  def change
+    add_column :orkestr_workflows, :status, :string, null: false, default: "draft"
+    add_column :orkestr_workflows, :default_context, :jsonb, null: false, default: {}
+    add_column :orkestr_workflows, :reuse_context, :boolean, null: false, default: false
+  end
+end

data/db/migrate/20260309083328_create_orkestr_execution_logs.rb

@@ -0,0 +1,14 @@
+class CreateOrkestrExecutionLogs < ActiveRecord::Migration[8.0]
+  def change
+    create_table :orkestr_execution_logs, id: :uuid do |t|
+      t.references :execution, null: false, type: :uuid,
+                   foreign_key: { to_table: :orkestr_executions }
+      t.references :node_execution, null: true, type: :uuid,
+                   foreign_key: { to_table: :orkestr_node_executions }
+      t.string :level, null: false, default: "info"
+      t.text :message, null: false
+      t.jsonb :metadata, null: false, default: {}
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20260310223204_replace_node_executions_unique_index_for_cycle_support.rb

@@ -0,0 +1,18 @@
+class ReplaceNodeExecutionsUniqueIndexForCycleSupport < ActiveRecord::Migration[8.0]
+  def up
+    remove_index :orkestr_node_executions, name: "index_orkestr_node_executions_unique_per_execution"
+
+    add_index :orkestr_node_executions, [:execution_id, :node_id],
+      unique: true,
+      where: "status IN ('pending', 'running', 'waiting')",
+      name: "index_orkestr_node_executions_unique_active"
+  end
+
+  def down
+    remove_index :orkestr_node_executions, name: "index_orkestr_node_executions_unique_active"
+
+    add_index :orkestr_node_executions, [:execution_id, :node_id],
+      unique: true,
+      name: "index_orkestr_node_executions_unique_per_execution"
+  end
+end

data/lib/orkestr/configuration.rb

@@ -0,0 +1,16 @@
+module Orkestr
+  class Configuration
+    attr_accessor :nodes_paths, :triggers_paths, :authenticator, :authorizer, :custom_ui_scripts, :custom_ui_styles,
+                  :allow_cycles
+
+    def initialize
+      @nodes_paths = []
+      @triggers_paths = []
+      @authenticator = nil
+      @authorizer = nil
+      @custom_ui_scripts = []
+      @custom_ui_styles = []
+      @allow_cycles = false
+    end
+  end
+end

data/lib/orkestr/engine.rb

@@ -0,0 +1,48 @@
+module Orkestr
+  class Engine < ::Rails::Engine
+    isolate_namespace Orkestr
+
+    config.generators do |g|
+      g.orm :active_record, primary_key_type: :uuid
+    end
+
+    # Register app/assets/builds so Propshaft finds orkestr/orkestr-editor.js
+    config.paths["app/assets"] << "app/assets/builds"
+
+    initializer "orkestr.assets", before: :append_assets_path do |app|
+      builds_path = root.join("app/assets/builds")
+      app.config.assets.paths.unshift(builds_path) if builds_path.exist?
+    end
+
+    initializer "orkestr.append_migrations" do |app|
+      unless app.root.to_s.match?(root.to_s)
+        config.paths["db/migrate"].expanded.each do |path|
+          app.config.paths["db/migrate"] << path
+        end
+      end
+    end
+
+    # Exclude plugin directories from Zeitwerk autoloading.
+    # They use a custom loader (Orkestr::Nodes::Loader / Orkestr::Triggers::Loader).
+    initializer "orkestr.ignore_plugin_paths", before: :set_autoload_paths do
+      Rails.autoloaders.main.ignore(
+        root.join("app/orkestr_nodes"),
+        root.join("app/orkestr_triggers")
+      )
+    end
+
+    initializer "orkestr.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        require_relative "../../app/helpers/orkestr/ui_helper"
+        include Orkestr::UiHelper
+      end
+    end
+
+    initializer "orkestr.load_plugins" do
+      config.after_initialize do
+        Orkestr::Nodes::Loader.load_all!
+        Orkestr::Triggers::Loader.load_all!
+      end
+    end
+  end
+end

data/lib/orkestr/nodes/base.rb

@@ -0,0 +1,74 @@
+require_relative "schema_dsl"
+require_relative "registry"
+
+module Orkestr
+  module Nodes
+    class Base
+      include SchemaDsl
+
+      def self.inherited(subclass)
+        super
+        TracePoint.new(:end) do |tp|
+          if tp.self == subclass
+            tp.disable
+            Registry.register(subclass) if subclass.node_id
+          end
+        end.enable
+      end
+
+      attr_reader :node_execution
+
+      def initialize(node_execution, resolved_config: nil)
+        @node_execution = node_execution
+        @resolved_config = resolved_config
+      end
+
+      def execute(_context, _input)
+        raise NotImplementedError, "#{self.class.name} must implement #execute"
+      end
+
+      def config
+        @resolved_config || node_execution.node.config
+      end
+
+      def execution
+        node_execution.execution
+      end
+
+      def workflow_context
+        execution.context_data
+      end
+
+      def log(message, level: :info, metadata: {})
+        ExecutionLog.create!(
+          execution: execution,
+          node_execution: node_execution,
+          level: level.to_s,
+          message: message,
+          metadata: metadata
+        )
+      end
+
+      protected
+
+      def dig_value(data, path)
+        return nil if path.blank?
+
+        keys = path.to_s.split(".")
+        keys.reduce(data) do |obj, key|
+          case obj
+          when Hash then obj[key.to_sym] || obj[key.to_s]
+          else nil
+          end
+        end
+      end
+
+      def interpolate(template, data)
+        template.gsub(/\{\{(\s*[\w.]+\s*)\}\}/) do
+          path = ::Regexp.last_match(1).strip
+          dig_value(data, path).to_s
+        end
+      end
+    end
+  end
+end

data/lib/orkestr/nodes/loader.rb

@@ -0,0 +1,32 @@
+module Orkestr
+  module Nodes
+    module Loader
+      class << self
+        def load_all!
+          search_paths.each do |path|
+            load_from(path)
+          end
+        end
+
+        private
+
+        def search_paths
+          paths = []
+          # Engine built-in nodes
+          paths << Orkestr::Engine.root.join("app", "orkestr_nodes")
+          # Configured custom paths
+          Orkestr.configuration.nodes_paths.each { |p| paths << Pathname.new(p) }
+          # Host app nodes
+          paths << Rails.root.join("app", "orkestr_nodes") if defined?(Rails)
+          paths.select(&:exist?).uniq
+        end
+
+        def load_from(base_path)
+          Dir[base_path.join("**/node.rb")].sort.each do |file|
+            require file
+          end
+        end
+      end
+    end
+  end
+end

data/lib/orkestr/nodes/registry.rb

@@ -0,0 +1,34 @@
+module Orkestr
+  module Nodes
+    module Registry
+      class << self
+        def register(node_class)
+          node_class.validate_node_id!
+          registry[node_class.node_id] = node_class
+        end
+
+        def find(id)
+          registry[id]
+        end
+
+        def all
+          registry.values
+        end
+
+        def ids
+          registry.keys
+        end
+
+        def reset!
+          @registry = {}
+        end
+
+        private
+
+        def registry
+          @registry ||= {}
+        end
+      end
+    end
+  end
+end