tasker-engine 1.0.0

data/app/controllers/tasker/metrics_controller.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_dependency 'tasker/application_controller'
+
+module Tasker
+  # Metrics controller providing Prometheus-compatible metrics endpoint.
+  #
+  # This controller provides a single metrics endpoint:
+  # - `/tasker/metrics` - Prometheus format metrics (optional authentication)
+  #
+  # The metrics endpoint uses optional authentication based on the telemetry configuration.
+  # If authentication is disabled or telemetry.metrics_auth_required is false, access is allowed.
+  # If authentication is enabled, users need the `tasker.metrics:index` permission.
+  class MetricsController < ApplicationController
+    # Set cache headers to prevent caching of metrics data
+    before_action :set_cache_headers
+
+    # Metrics endpoint providing Prometheus-compatible metrics
+    # Uses optional authentication based on telemetry configuration
+    #
+    # @return [Text] Prometheus format metrics or JSON error
+    def index
+      result = export_metrics
+
+      if result[:success]
+        render plain: result[:data], content_type: 'text/plain; charset=utf-8'
+      else
+        render json: {
+          error: 'Metrics export failed',
+          message: result[:error],
+          timestamp: result[:timestamp]
+        }, status: :service_unavailable
+      end
+    rescue StandardError => e
+      render json: {
+        error: 'Metrics endpoint failed',
+        message: e.message,
+        timestamp: Time.current.iso8601
+      }, status: :service_unavailable
+    end
+
+    private
+
+    # Override the resource name for authorization
+    # Maps metrics action to metrics resource
+    #
+    # @return [String] The resource name for authorization
+    def tasker_resource_name
+      Tasker::Authorization::ResourceConstants::RESOURCES::METRICS
+    end
+
+    # Override the action name for authorization
+    # Maps index action to index permission
+    #
+    # @return [Symbol] The action name for authorization
+    def tasker_action_name
+      Tasker::Authorization::ResourceConstants::ACTIONS::INDEX
+    end
+
+    # Override authentication check for metrics endpoint
+    # Uses telemetry configuration instead of global auth configuration
+    #
+    # @return [Boolean] True if authentication should be skipped
+    def skip_authentication?
+      !Tasker.configuration.telemetry.metrics_auth_required
+    end
+
+    # Override authorization check for metrics endpoint
+    # Uses telemetry configuration instead of global auth configuration
+    #
+    # @return [Boolean] True if authorization should be skipped
+    def skip_authorization?
+      !Tasker.configuration.telemetry.metrics_auth_required
+    end
+
+    # Export metrics using PrometheusExporter
+    #
+    # @return [Hash] Export result with success status and data
+    def export_metrics
+      return disabled_metrics_response unless metrics_enabled?
+
+      exporter = Tasker::Telemetry::PrometheusExporter.new
+      exporter.safe_export
+    end
+
+    # Check if metrics collection is enabled
+    #
+    # @return [Boolean] True if metrics are enabled
+    def metrics_enabled?
+      Tasker.configuration.telemetry.metrics_enabled
+    end
+
+    # Response when metrics are disabled
+    #
+    # @return [Hash] Disabled metrics response
+    def disabled_metrics_response
+      {
+        success: false,
+        error: 'Metrics collection is disabled',
+        timestamp: Time.current.iso8601
+      }
+    end
+
+    # Set appropriate cache control headers for metrics endpoint
+    def set_cache_headers
+      response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
+      response.headers['Pragma'] = 'no-cache'
+      response.headers['Expires'] = '0'
+    end
+  end
+end

data/app/controllers/tasker/page_sort.rb

@@ -0,0 +1,97 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module PageSort
+    extend ActiveSupport::Concern
+    def build_page_sort_params(model_name, default_sort)
+      @page_sort_params = PageSortParamsBuilder.build(request.params, model_name, default_sort)
+    end
+
+    def page_sort_params
+      @page_sort_params
+    end
+
+    # Service class to build page sort parameters
+    # Reduces complexity by organizing parameter processing logic
+    class PageSortParamsBuilder
+      class << self
+        # Build page sort parameters from request params
+        #
+        # @param params [Hash] Request parameters
+        # @param model_name [String/Symbol] Model name for validation
+        # @param default_sort [Symbol] Default sort column
+        # @return [Hash] Page sort parameters
+        def build(params, model_name, default_sort)
+          valid_sorts = extract_valid_sorts(model_name)
+
+          {
+            limit: extract_limit(params),
+            offset: extract_offset(params),
+            order: build_order_hash(params, valid_sorts, default_sort)
+          }
+        end
+
+        private
+
+        # Extract valid sort columns from model
+        #
+        # @param model_name [String/Symbol] Model name
+        # @return [Array<Symbol>] Valid sort columns
+        def extract_valid_sorts(model_name)
+          model = model_name.to_s.camelize.constantize
+          model.column_names.map(&:to_sym)
+        end
+
+        # Extract limit parameter with default
+        #
+        # @param params [Hash] Request parameters
+        # @return [Integer] Limit value
+        def extract_limit(params)
+          params[:limit] || 20
+        end
+
+        # Extract offset parameter with default
+        #
+        # @param params [Hash] Request parameters
+        # @return [Integer] Offset value
+        def extract_offset(params)
+          params[:offset] || 0
+        end
+
+        # Build order hash with validation
+        #
+        # @param params [Hash] Request parameters
+        # @param valid_sorts [Array<Symbol>] Valid sort columns
+        # @param default_sort [Symbol] Default sort column
+        # @return [Hash] Order hash
+        def build_order_hash(params, valid_sorts, default_sort)
+          sort_by = extract_sort_by(params, valid_sorts, default_sort)
+          sort_order = extract_sort_order(params)
+
+          { sort_by => sort_order }
+        end
+
+        # Extract and validate sort_by parameter
+        #
+        # @param params [Hash] Request parameters
+        # @param valid_sorts [Array<Symbol>] Valid sort columns
+        # @param default_sort [Symbol] Default sort column
+        # @return [Symbol] Validated sort column
+        def extract_sort_by(params, valid_sorts, default_sort)
+          sort_by = params[:sort_by] ? params[:sort_by].to_sym : default_sort
+          valid_sorts.include?(sort_by) ? sort_by : default_sort
+        end
+
+        # Extract and validate sort_order parameter
+        #
+        # @param params [Hash] Request parameters
+        # @return [Symbol] Validated sort order
+        def extract_sort_order(params)
+          sort_order = params[:sort_order] ? params[:sort_order].to_sym : :asc
+          %i[asc desc].include?(sort_order) ? sort_order : :asc
+        end
+      end
+    end
+  end
+end

data/app/controllers/tasker/task_diagrams_controller.rb

@@ -0,0 +1,30 @@
+# typed: false
+# frozen_string_literal: true
+
+require_dependency 'tasker/application_controller'
+
+module Tasker
+  class TaskDiagramsController < ApplicationController
+    include ActionController::MimeResponds
+
+    before_action :set_full_task, only: %i[index]
+
+    # GET /tasks/1/task_diagrams
+    def index
+      respond_to do |format|
+        format.html { render(html: @task.diagram(request.base_url).to_html.html_safe) }
+        format.json { render(json: @task.diagram(request.base_url).to_json, status: :ok) }
+      end
+    end
+
+    private
+
+    def set_full_task
+      @task = query_base.find(params[:task_id])
+    end
+
+    def query_base
+      Tasker::Task.with_all_associated
+    end
+  end
+end

data/app/controllers/tasker/tasks_controller.rb

@@ -0,0 +1,123 @@
+# typed: false
+# frozen_string_literal: true
+
+require_relative 'application_controller'
+
+module Tasker
+  class TasksController < ApplicationController
+    include PageSort
+
+    before_action :set_task, only: %i[update destroy]
+    before_action :set_full_task, only: %i[show]
+    before_action :set_page_sort_params, only: %i[index]
+
+    # GET /tasks
+    def index
+      @tasks =
+        query_base.limit(page_sort_params[:limit]).offset(page_sort_params[:offset]).order(page_sort_params[:order]).all
+      render(json: @tasks, status: :ok, adapter: :json, root: :tasks, each_serializer: Tasker::TaskSerializer)
+    end
+
+    # GET /tasks/1
+    def show
+      include_dependencies = ActiveModel::Type::Boolean.new.cast(params[:include_dependencies])
+
+      render(
+        json: @task,
+        status: :ok,
+        adapter: :json,
+        root: :task,
+        serializer: Tasker::TaskSerializer,
+        include_dependencies: include_dependencies
+      )
+    end
+
+    # POST /tasks
+    def create
+      if task_params_as_symbolized_hash[:name].blank?
+        return render(status: :bad_request,
+                      json: { error: 'invalid parameters: requires task name' })
+      end
+      set_task_request
+      begin
+        # Use namespace and version from task request for handler lookup
+        handler = handler_factory.get(
+          @task_request.name,
+          namespace_name: @task_request.namespace,
+          version: @task_request.version
+        )
+        @task = handler.initialize_task!(@task_request)
+      rescue Tasker::ProceduralError => e
+        @task = Tasker::Task.new
+        @task.errors.add(:name, e.to_s)
+      rescue StandardError => e
+        @task = Tasker::Task.new
+        error_message = "Handler error for #{@task_request.namespace}.#{@task_request.name}@#{@task_request.version}: #{e.message}"
+        @task.errors.add(:handler, error_message)
+      end
+
+      # we don't want to re-run save here because it will remove the
+      # context validation from the handler and check "valid?"
+      if @task.errors.empty?
+        render(json: @task, status: :created, adapter: :json, root: :task, serializer: Tasker::TaskSerializer)
+      else
+        render(status: :bad_request, json: { error: @task.errors })
+      end
+    end
+
+    # PATCH/PUT /tasks/1
+    def update
+      if @task.update(update_task_params)
+        render(json: @task, status: :ok, adapter: :json, root: :task, serializer: Tasker::TaskSerializer)
+      else
+        render(json: { error: @task.errors }, status: :unprocessable_entity)
+      end
+    end
+
+    # DELETE /tasks/1
+    def destroy
+      # Use state machine to transition task to cancelled
+      @task.state_machine.transition_to!(Tasker::Constants::TaskStatuses::CANCELLED)
+      render(status: :ok, json: { cancelled: true })
+    end
+
+    private
+
+    def set_task
+      @task = Tasker::Task.find(params[:id])
+    end
+
+    def set_full_task
+      @task = query_base.find(params[:id])
+    end
+
+    def task_params
+      params.require(:task).permit(:name, :namespace, :version, :initiator, :source_system, :reason, tags: [],
+                                                                                                     context: {})
+    end
+
+    def update_task_params
+      params.require(:task).permit(:reason, tags: [])
+    end
+
+    def set_page_sort_params
+      build_page_sort_params('Tasker::Task', :task_id)
+    end
+
+    def handler_factory
+      @handler_factory ||= Tasker::HandlerFactory.instance
+    end
+
+    def query_base
+      Tasker::Task.with_all_associated
+    end
+
+    def task_params_as_symbolized_hash
+      task_params.to_h.deep_symbolize_keys
+    end
+
+    def set_task_request
+      @task_request = Tasker::Types::TaskRequest.new(task_params_as_symbolized_hash)
+    end
+  end
+end

data/app/controllers/tasker/workflow_steps_controller.rb

@@ -0,0 +1,69 @@
+# typed: false
+# frozen_string_literal: true
+
+require_relative 'application_controller'
+
+module Tasker
+  class WorkflowStepsController < ApplicationController
+    include PageSort
+
+    before_action :set_task, only: %i[index show update destroy]
+    before_action :set_workflow_step, only: %i[show update destroy]
+    before_action :set_page_sort_params, only: [:index]
+
+    # GET /workflow_steps
+    def index
+      @workflow_steps =
+        query_base.limit(page_sort_params[:limit]).offset(page_sort_params[:offset]).order(page_sort_params[:order]).all
+
+      render(json: @workflow_steps, status: :ok, adapter: :json, root: :steps,
+             each_serializer: Tasker::WorkflowStepSerializer)
+    end
+
+    # GET /workflow_steps/1
+    def show
+      render(json: @workflow_step, status: :ok, adapter: :json, root: :step, serializer: Tasker::WorkflowStepSerializer)
+    end
+
+    # PATCH/PUT /workflow_steps/1
+    def update
+      if @workflow_step.update(workflow_step_params)
+        render(json: @workflow_step, status: :ok, adapter: :json, root: :step,
+               serializer: Tasker::WorkflowStepSerializer)
+      else
+        render(json: { error: @workflow_step.errors }, status: :unprocessable_entity)
+      end
+    end
+
+    # DELETE /workflow_steps/1
+    def destroy
+      # Use state machine to transition step to cancelled
+      @workflow_step.state_machine.transition_to!(Constants::WorkflowStepStatuses::CANCELLED)
+      render(status: :ok, json: { cancelled: true })
+    end
+
+    private
+
+    def query_base
+      @task.workflow_steps.includes(:named_step, :step_dag_relationship)
+    end
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_task
+      @task = Task.find(params[:task_id])
+    end
+
+    def set_workflow_step
+      @workflow_step = query_base.find(params[:id])
+    end
+
+    # Only allow a list of trusted parameters through.
+    def workflow_step_params
+      params.require(:workflow_step).permit(:retry_limit, inputs: {})
+    end
+
+    def set_page_sort_params
+      build_page_sort_params('Tasker::WorkflowStep', :workflow_step_id)
+    end
+  end
+end

data/app/graphql/examples/all_tasks.graphql

@@ -0,0 +1,22 @@
+query AllTasks($limit: Int, $offset: Int, $sort_by: String, $sort_order: String) {
+  tasks(
+    limit: $limit,
+    offset: $offset,
+    sortBy: $sort_by,
+    sortOrder: $sort_order
+  ) {
+    taskId,
+    status,
+    workflowSteps {
+      workflowStepId,
+      status
+    },
+    taskAnnotations {
+      taskAnnotationId,
+      annotationType {
+        name
+      },
+      annotation
+    }
+  }
+}

data/app/graphql/examples/pending_tasks.graphql

@@ -0,0 +1,23 @@
+query PendingTasks($limit: Int, $offset: Int, $sort_by: String, $sort_order: String) {
+  tasksByStatus(
+    limit: $limit,
+    offset: $offset,
+    sortBy: $sort_by,
+    sortOrder: $sort_order,
+    status: "pending"
+  ) {
+    taskId,
+    status,
+    workflowSteps {
+      workflowStepId,
+      status
+    },
+    taskAnnotations {
+      taskAnnotationId,
+      annotationType {
+        name
+      },
+      annotation
+    }
+  }
+}

data/app/graphql/tasker/graph_ql_types/annotation_type.rb

@@ -0,0 +1,14 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class AnnotationType < GraphQLTypes::BaseObject
+      field :annotation_type_id, ID, null: false
+      field :name, String, null: false
+      field :description, String, null: true
+      field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :updated_at, GraphQL::Types::ISO8601DateTime, null: false
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_argument.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class BaseArgument < GraphQL::Schema::Argument
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_connection.rb

@@ -0,0 +1,11 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class BaseConnection < GraphQL::Types::Relay::BaseConnection
+      # add `nodes` and `pageInfo` fields, as well as `edge_type(...)` and `node_nullable(...)` overrides
+      # include GraphQL::Types::Relay::ConnectionBehaviors
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_edge.rb

@@ -0,0 +1,10 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class BaseEdge < GraphQL::Schema::Object
+      include GraphQL::Types::Relay::EdgeBehaviors
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_enum.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class BaseEnum < GraphQL::Schema::Enum
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_field.rb

@@ -0,0 +1,10 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class BaseField < GraphQL::Schema::Field
+      argument_class GraphQLTypes::BaseArgument
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_input_object.rb

@@ -0,0 +1,10 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class BaseInputObject < GraphQL::Schema::InputObject
+      argument_class GraphQLTypes::BaseArgument
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_interface.rb

@@ -0,0 +1,14 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    module BaseInterface
+      include GraphQL::Schema::Interface
+      edge_type_class(GraphQLTypes::BaseEdge)
+      connection_type_class(GraphQLTypes::BaseConnection)
+
+      field_class GraphQLTypes::BaseField
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_object.rb

@@ -0,0 +1,10 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class BaseObject < GraphQL::Schema::Object
+      field_class GraphQLTypes::BaseField
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_scalar.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class BaseScalar < GraphQL::Schema::Scalar
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/base_union.rb

@@ -0,0 +1,11 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class BaseUnion < GraphQL::Schema::Union
+      edge_type_class(GraphQLTypes::BaseEdge)
+      connection_type_class(GraphQLTypes::BaseConnection)
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/dependent_system_object_map_type.rb

@@ -0,0 +1,18 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class DependentSystemObjectMapType < GraphQLTypes::BaseObject
+      field :dependent_system_object_map_id, ID, null: false
+      field :dependent_system_one_id, Integer, null: false
+      field :dependent_system_two_id, Integer, null: false
+      field :remote_id_one, String, null: false
+      field :remote_id_two, String, null: false
+      field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :updated_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :dependent_system_one, GraphQLTypes::DependentSystemType, null: true
+      field :dependent_system_two, GraphQLTypes::DependentSystemType, null: true
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/dependent_system_type.rb

@@ -0,0 +1,13 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class DependentSystemType < GraphQLTypes::BaseObject
+      field :dependent_system_id, ID, null: false
+      field :name, String, null: false
+      field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :updated_at, GraphQL::Types::ISO8601DateTime, null: false
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/mutation_type.rb

@@ -0,0 +1,16 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class MutationType < GraphQLTypes::BaseObject
+      description 'Entry point to all mutation data'
+
+      field :create_task, mutation: Mutations::CreateTask
+      field :update_task, mutation: Mutations::UpdateTask
+      field :cancel_task, mutation: Mutations::CancelTask
+      field :update_step, mutation: Mutations::UpdateStep
+      field :cancel_step, mutation: Mutations::CancelStep
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types/named_step_type.rb

@@ -0,0 +1,16 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class NamedStepType < GraphQLTypes::BaseObject
+      field :named_step_id, ID, null: false
+      field :dependent_system_id, Integer, null: false
+      field :name, String, null: false
+      field :description, String, null: true
+      field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :updated_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :dependent_system, GraphQLTypes::DependentSystemType, null: true
+    end
+  end
+end