orkestr 1.0.0

data/app/orkestr_nodes/http_request/node.rb

@@ -0,0 +1,88 @@
+require "net/http"
+require "uri"
+
+module Orkestr
+  module Nodes
+    class HttpRequest < Base
+      node_id "http_request"
+      label "HTTP Request"
+      category "integration"
+
+      config_schema do
+        string :method, enum: %w[GET POST PUT DELETE], description: "HTTP method"
+        string :url, description: "Target URL (supports {{variable}} interpolation)"
+        object :headers, required: false, description: "HTTP headers" do
+          # dynamic keys
+        end
+      end
+
+      input_schema do
+        string :body, required: false, description: "Request body (supports {{variable}} interpolation)"
+      end
+
+      output_schema do
+        number :status_code, description: "HTTP response status code"
+        string :response_body, description: "Response body"
+        object :response_headers, required: false, description: "Response headers" do
+          # dynamic keys
+        end
+      end
+
+      TIMEOUT = 30
+
+      def execute(context, input)
+        url = interpolate(config[:url].to_s, context)
+        method = (config[:method] || "GET").upcase
+        headers = build_headers(config[:headers] || {}, context)
+        body = input[:body] ? interpolate(input[:body].to_s, context) : nil
+
+        perform_request(method, url, headers, body)
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        raise ExecutionError, "HTTP timeout: #{e.message}"
+      rescue SocketError, Errno::ECONNREFUSED => e
+        raise ExecutionError, "Network error: #{e.message}"
+      end
+
+      class ExecutionError < StandardError; end
+
+      private
+
+      def perform_request(method, url, headers, body)
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = TIMEOUT
+        http.read_timeout = TIMEOUT
+
+        request = build_request(method, uri, headers, body)
+        response = http.request(request)
+
+        {
+          status_code: response.code.to_i,
+          response_body: response.body,
+          response_headers: response.each_header.to_h
+        }
+      end
+
+      def build_request(method, uri, headers, body)
+        request_class = {
+          "GET" => Net::HTTP::Get,
+          "POST" => Net::HTTP::Post,
+          "PUT" => Net::HTTP::Put,
+          "DELETE" => Net::HTTP::Delete
+        }.fetch(method)
+
+        request = request_class.new(uri)
+        headers.each { |k, v| request[k] = v }
+        request.body = body if body
+        request
+      end
+
+      def build_headers(headers_config, context)
+        headers_config.each_with_object({}) do |(key, value), hash|
+          hash[key.to_s] = interpolate(value.to_s, context)
+        end
+      end
+    end
+  end
+end

data/app/orkestr_nodes/human_action/node.rb

@@ -0,0 +1,103 @@
+module Orkestr
+  module Nodes
+    class HumanAction < Base
+      node_id "human_action"
+      label "Human Action"
+      category "human"
+
+      # Assignees: array of { type, id } objects.
+      # Resolved by priority: input > context > config
+      config_schema do
+        string :description, required: false, description: "Description of the task"
+        array :assignees, required: false, description: "Array of {type, id} objects" do
+          object do
+            string :type, description: "Polymorphic type (e.g. User, Group)"
+            string :id, description: "Record ID"
+          end
+        end
+        string :assignee_key, required: false, description: "Role key for assignees (e.g. reviewer, approver)"
+        string :deadline, required: false, description: "ISO 8601 deadline for the task"
+      end
+
+      def execute(context, input)
+        human_task = create_human_task
+        create_assignees(human_task, context, input)
+        node_execution.update!(status: "waiting")
+        {}
+      end
+
+      private
+
+      def create_human_task
+        form_schema = node_execution.node.config_json.dig("form_schema") || {}
+        Orkestr::HumanTask.create!(
+          node_execution: node_execution,
+          schema_json: form_schema,
+          status: "pending"
+        )
+      end
+
+      def create_assignees(human_task, context, input)
+        assignees = resolve_assignees(context, input)
+        assignees = exclude_already_responded(assignees)
+        return if assignees.empty?
+
+        deadline = resolve_deadline(context, input)
+
+        assignees.each do |assignee|
+          human_task.assignees.create!(
+            assignable_type: assignee[:type],
+            assignable_id: assignee[:id].to_s,
+            key: config[:assignee_key],
+            deadline: deadline
+          )
+        end
+      end
+
+      # Priority: input > context > config
+      def resolve_assignees(context, input)
+        raw = (input || {}).deep_symbolize_keys[:assignees] ||
+              (context || {}).deep_symbolize_keys[:assignees] ||
+              config[:assignees]
+        return [] if raw.blank?
+
+        Array(raw).filter_map do |entry|
+          entry = entry.deep_symbolize_keys if entry.respond_to?(:deep_symbolize_keys)
+          next unless entry[:type].present? && entry[:id].present?
+
+          { type: entry[:type].to_s, id: entry[:id].to_s }
+        end
+      end
+
+      # In cycle workflows, exclude assignees who already completed a task
+      # for this same node in this execution.
+      def exclude_already_responded(assignees)
+        previous = execution.node_executions
+          .where(node_id: node_execution.node_id)
+          .where.not(id: node_execution.id)
+          .where(status: "completed")
+
+        return assignees unless previous.exists?
+
+        responded_ids = Orkestr::Assignee
+          .where(status: "completed")
+          .joins(:human_task)
+          .where(orkestr_human_tasks: { node_execution_id: previous.select(:id) })
+          .pluck(:assignable_id)
+          .map(&:to_s)
+          .to_set
+
+        assignees.reject { |a| responded_ids.include?(a[:id].to_s) }
+      end
+
+      def resolve_deadline(context, input)
+        raw = (input || {}).deep_symbolize_keys[:deadline] ||
+              (context || {}).deep_symbolize_keys[:deadline] ||
+              config[:deadline]
+        raw.present? ? Time.zone.parse(raw.to_s) : nil
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/app/orkestr_nodes/transform/node.rb

@@ -0,0 +1,48 @@
+module Orkestr
+  module Nodes
+    class Transform < Base
+      node_id "transform"
+      label "Transform"
+      category "data"
+
+      config_schema do
+        array :mappings do
+          object do
+            string :source, description: "Source path (dot notation) or template with {{variable}}"
+            string :target, description: "Target key name"
+          end
+        end
+      end
+
+      input_schema do
+        object :context, description: "Workflow context" do
+          # dynamic keys
+        end
+      end
+
+      def execute(context, _input)
+        mappings = config[:mappings] || []
+        result = {}
+
+        mappings.each do |mapping|
+          source = mapping[:source].to_s
+          target = mapping[:target].to_s
+
+          result[target] = if template?(source)
+                             interpolate(source, context)
+          else
+                             dig_value(context, source)
+          end
+        end
+
+        result
+      end
+
+      private
+
+      def template?(source)
+        source.include?("{{") && source.include?("}}")
+      end
+    end
+  end
+end

data/app/orkestr_nodes/wait/node.rb

@@ -0,0 +1,18 @@
+module Orkestr
+  module Nodes
+    class Wait < Base
+      node_id "wait"
+      label "Wait"
+      category "flow"
+
+      config_schema do
+        string :description, required: false, description: "Description of what is being waited for"
+      end
+
+      def execute(_context, _input)
+        node_execution.update!(status: "waiting")
+        {}
+      end
+    end
+  end
+end

data/app/orkestr_triggers/manual/trigger.rb

@@ -0,0 +1,12 @@
+module Orkestr
+  module Triggers
+    class Manual < Base
+      trigger_id "manual"
+      label "Manual Trigger"
+
+      def fire(context = {})
+        start_execution(context)
+      end
+    end
+  end
+end

data/app/orkestr_triggers/scheduled/trigger.rb

@@ -0,0 +1,26 @@
+require "fugit"
+
+module Orkestr
+  module Triggers
+    class Scheduled < Base
+      trigger_id "scheduled"
+      label "Scheduled Trigger"
+
+      config_schema do
+        string :cron, description: "Cron expression (e.g. '0 * * * *')"
+      end
+
+      def fire(context = {})
+        start_execution(context)
+      end
+
+      def should_fire?(time)
+        cron = Fugit::Cron.parse(trigger_config[:cron])
+        return false unless cron
+
+        truncated = Time.at(time.to_i - (time.to_i % 60)).utc
+        cron.match?(truncated)
+      end
+    end
+  end
+end

data/app/orkestr_triggers/webhook/trigger.rb

@@ -0,0 +1,23 @@
+module Orkestr
+  module Triggers
+    class Webhook < Base
+      trigger_id "webhook"
+      label "Webhook Trigger"
+
+      config_schema do
+        string :secret, required: false, description: "Shared secret for signature verification"
+      end
+
+      def fire(context = {})
+        start_execution(context, async: true)
+      end
+
+      def valid_secret?(provided_secret)
+        expected = trigger_config[:secret]
+        return true if expected.blank?
+
+        ActiveSupport::SecurityUtils.secure_compare(expected.to_s, provided_secret.to_s)
+      end
+    end
+  end
+end

data/app/serializers/orkestr/assignee_serializer.rb

@@ -0,0 +1,30 @@
+# == Schema Information
+#
+# Table name: orkestr_assignees
+#
+#  id              :uuid             not null, primary key
+#  assignable_type :string           not null
+#  deadline        :datetime
+#  key             :string
+#  status          :string           default("pending"), not null
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  assignable_id   :string           not null
+#  human_task_id   :uuid             not null
+#
+# Indexes
+#
+#  index_orkestr_assignees_on_assignable_type_and_assignable_id  (assignable_type,assignable_id)
+#  index_orkestr_assignees_on_human_task_id                      (human_task_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (human_task_id => orkestr_human_tasks.id)
+#
+module Orkestr
+  class AssigneeSerializer
+    include Alba::Resource
+
+    attributes :id, :assignable_type, :assignable_id, :key, :status, :deadline, :created_at
+  end
+end

data/app/serializers/orkestr/context_serializer.rb

@@ -0,0 +1,30 @@
+# == Schema Information
+#
+# Table name: orkestr_contexts
+#
+#  id                    :uuid             not null, primary key
+#  contextualizable_type :string
+#  data                  :jsonb            not null
+#  status                :string           default("pending"), not null
+#  created_at            :datetime         not null
+#  updated_at            :datetime         not null
+#  contextualizable_id   :uuid
+#  workflow_id           :uuid
+#
+# Indexes
+#
+#  index_orkestr_contexts_on_contextualizable  (contextualizable_type,contextualizable_id)
+#  index_orkestr_contexts_on_workflow_id       (workflow_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workflow_id => orkestr_workflows.id)
+#
+module Orkestr
+  class ContextSerializer
+    include Alba::Resource
+
+    attributes :id, :contextualizable_type, :contextualizable_id,
+               :workflow_id, :status, :data, :created_at, :updated_at
+  end
+end

data/app/serializers/orkestr/edge_serializer.rb

@@ -0,0 +1,33 @@
+# == Schema Information
+#
+# Table name: orkestr_edges
+#
+#  id             :uuid             not null, primary key
+#  source_handle  :string
+#  created_at     :datetime         not null
+#  updated_at     :datetime         not null
+#  react_flow_id  :string
+#  source_node_id :uuid             not null
+#  target_node_id :uuid             not null
+#  workflow_id    :uuid             not null
+#
+# Indexes
+#
+#  index_orkestr_edges_on_react_flow_id   (react_flow_id)
+#  index_orkestr_edges_on_source_node_id  (source_node_id)
+#  index_orkestr_edges_on_target_node_id  (target_node_id)
+#  index_orkestr_edges_on_workflow_id     (workflow_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (source_node_id => orkestr_nodes.id)
+#  fk_rails_...  (target_node_id => orkestr_nodes.id)
+#  fk_rails_...  (workflow_id => orkestr_workflows.id)
+#
+module Orkestr
+  class EdgeSerializer
+    include Alba::Resource
+
+    attributes :id, :source_node_id, :target_node_id, :source_handle, :react_flow_id, :created_at, :updated_at
+  end
+end

data/app/serializers/orkestr/execution_collection_serializer.rb

@@ -0,0 +1,7 @@
+module Orkestr
+  class ExecutionCollectionSerializer
+    include Alba::Resource
+
+    attributes :id, :workflow_id, :status, :started_at, :finished_at, :created_at, :updated_at
+  end
+end

data/app/serializers/orkestr/execution_log_serializer.rb

@@ -0,0 +1,31 @@
+# == Schema Information
+#
+# Table name: orkestr_execution_logs
+#
+#  id                :uuid             not null, primary key
+#  level             :string           default("info"), not null
+#  message           :text             not null
+#  metadata          :jsonb            not null
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#  execution_id      :uuid             not null
+#  node_execution_id :uuid
+#
+# Indexes
+#
+#  index_orkestr_execution_logs_on_execution_id       (execution_id)
+#  index_orkestr_execution_logs_on_node_execution_id  (node_execution_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (execution_id => orkestr_executions.id)
+#  fk_rails_...  (node_execution_id => orkestr_node_executions.id)
+#
+module Orkestr
+  class ExecutionLogSerializer
+    include Alba::Resource
+
+    attributes :id, :execution_id, :node_execution_id,
+               :level, :message, :metadata, :created_at
+  end
+end

data/app/serializers/orkestr/execution_serializer.rb

@@ -0,0 +1,37 @@
+# == Schema Information
+#
+# Table name: orkestr_executions
+#
+#  id          :uuid             not null, primary key
+#  finished_at :datetime
+#  started_at  :datetime
+#  status      :string           default("pending"), not null
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  context_id  :uuid
+#  workflow_id :uuid             not null
+#
+# Indexes
+#
+#  index_orkestr_executions_on_context_id   (context_id)
+#  index_orkestr_executions_on_workflow_id  (workflow_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (context_id => orkestr_contexts.id)
+#  fk_rails_...  (workflow_id => orkestr_workflows.id)
+#
+module Orkestr
+  class ExecutionSerializer
+    include Alba::Resource
+
+    attributes :id, :workflow_id, :status, :context_id,
+               :started_at, :finished_at, :created_at, :updated_at
+
+    attribute :context_data do |execution|
+      execution.context&.data || {}
+    end
+
+    many :node_executions, resource: NodeExecutionSerializer
+  end
+end

data/app/serializers/orkestr/human_task_serializer.rb

@@ -0,0 +1,46 @@
+# == Schema Information
+#
+# Table name: orkestr_human_tasks
+#
+#  id                :uuid             not null, primary key
+#  completed_at      :datetime
+#  response_json     :json
+#  schema_json       :json             not null
+#  status            :string           default("pending"), not null
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#  execution_id      :uuid             not null
+#  node_execution_id :uuid             not null
+#  node_id           :uuid             not null
+#
+# Indexes
+#
+#  index_orkestr_human_tasks_on_execution_id       (execution_id)
+#  index_orkestr_human_tasks_on_node_execution_id  (node_execution_id)
+#  index_orkestr_human_tasks_on_node_id            (node_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (execution_id => orkestr_executions.id)
+#  fk_rails_...  (node_execution_id => orkestr_node_executions.id)
+#  fk_rails_...  (node_id => orkestr_nodes.id)
+#
+module Orkestr
+  class HumanTaskSerializer
+    include Alba::Resource
+
+    attributes :id, :execution_id, :node_execution_id, :node_id,
+               :status, :schema_json, :response_json,
+               :completed_at, :created_at, :updated_at
+
+    attribute :description do |task|
+      task.node&.config_json&.dig("description")
+    end
+
+    attribute :actions do |task|
+      task.node&.config_json&.dig("actions")
+    end
+
+    many :assignees, resource: AssigneeSerializer
+  end
+end

data/app/serializers/orkestr/node_execution_serializer.rb

@@ -0,0 +1,43 @@
+# == Schema Information
+#
+# Table name: orkestr_node_executions
+#
+#  id           :uuid             not null, primary key
+#  attempt      :integer          default(1), not null
+#  finished_at  :datetime
+#  input_json   :json             not null
+#  output_json  :json             not null
+#  started_at   :datetime
+#  status       :string           default("pending"), not null
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#  execution_id :uuid             not null
+#  node_id      :uuid             not null
+#
+# Indexes
+#
+#  index_orkestr_node_executions_on_execution_id  (execution_id)
+#  index_orkestr_node_executions_on_node_id       (node_id)
+#  index_orkestr_node_executions_unique_active    (execution_id,node_id) UNIQUE WHERE ((status)::text = ANY (ARRAY[('pending'::character varying)::text, ('running'::character varying)::text, ('waiting'::character varying)::text]))
+#
+# Foreign Keys
+#
+#  fk_rails_...  (execution_id => orkestr_executions.id)
+#  fk_rails_...  (node_id => orkestr_nodes.id)
+#
+module Orkestr
+  class NodeExecutionSerializer
+    include Alba::Resource
+
+    attributes :id, :node_id, :status, :input_json, :output_json, :attempt,
+               :started_at, :finished_at, :created_at, :updated_at
+
+    attribute :node_type do |ne|
+      ne.node.node_type
+    end
+
+    attribute :duration do |ne|
+      ne.duration
+    end
+  end
+end

data/app/serializers/orkestr/node_serializer.rb

@@ -0,0 +1,29 @@
+# == Schema Information
+#
+# Table name: orkestr_nodes
+#
+#  id              :uuid             not null, primary key
+#  conditions_json :json             not null
+#  config_json     :json             not null
+#  node_type       :string           not null
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  react_flow_id   :string
+#  workflow_id     :uuid             not null
+#
+# Indexes
+#
+#  index_orkestr_nodes_on_react_flow_id  (react_flow_id)
+#  index_orkestr_nodes_on_workflow_id    (workflow_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workflow_id => orkestr_workflows.id)
+#
+module Orkestr
+  class NodeSerializer
+    include Alba::Resource
+
+    attributes :id, :node_type, :react_flow_id, :config_json, :conditions_json, :created_at, :updated_at
+  end
+end

data/app/serializers/orkestr/workflow_collection_serializer.rb

@@ -0,0 +1,11 @@
+module Orkestr
+  class WorkflowCollectionSerializer
+    include Alba::Resource
+
+    attributes :id, :name, :trigger_type, :created_at, :updated_at
+
+    attribute :executions_count do |workflow|
+      workflow.executions.size
+    end
+  end
+end

data/app/serializers/orkestr/workflow_serializer.rb

@@ -0,0 +1,30 @@
+# == Schema Information
+#
+# Table name: orkestr_workflows
+#
+#  id              :uuid             not null, primary key
+#  default_context :jsonb            not null
+#  graph_json      :json             not null
+#  name            :string           not null
+#  reuse_context   :boolean          default(FALSE), not null
+#  status          :string           default("draft"), not null
+#  trigger_config  :json             not null
+#  trigger_type    :string
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#
+module Orkestr
+  class WorkflowSerializer
+    include Alba::Resource
+
+    attributes :id, :name, :status, :trigger_type, :trigger_config, :graph_json,
+               :default_context, :reuse_context, :created_at, :updated_at
+
+    many :nodes, resource: NodeSerializer
+    many :edges, resource: EdgeSerializer
+
+    attribute :executions_count do |workflow|
+      workflow.executions.size
+    end
+  end
+end