tasker-engine 1.0.0

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

@@ -0,0 +1,14 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class NamedTaskType < GraphQLTypes::BaseObject
+      field :named_task_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/named_tasks_named_step_type.rb

@@ -0,0 +1,19 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class NamedTasksNamedStepType < GraphQLTypes::BaseObject
+      field :id, ID, null: false
+      field :named_task_id, Integer, null: false
+      field :named_step_id, Integer, null: false
+      field :skippable, Boolean, null: false
+      field :default_retryable, Boolean, null: false
+      field :default_retry_limit, Integer, null: false
+      field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :updated_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :named_task, Tasker::GraphQLTypes::NamedTaskType, null: true
+      field :named_step, Tasker::GraphQLTypes::NamedStepType, null: true
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    module NodeType
+      include GraphQLTypes::BaseInterface
+      # Add the `id` field
+      include GraphQL::Types::Relay::NodeBehaviors
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class QueryType < GraphQLTypes::BaseObject
+      description 'The query root of the Tasker schema'
+
+      include GraphQL::Types::Relay::HasNodeField
+      include GraphQL::Types::Relay::HasNodesField
+
+      field :tasks, resolver: Queries::AllTasks
+      field :tasks_by_status, resolver: Queries::TasksByStatus
+      field :tasks_by_annotation, resolver: Queries::TasksByAnnotation
+      field :task, resolver: Queries::OneTask
+      field :step, resolver: Queries::OneStep
+      field :annotation_types, resolver: Queries::AllAnnotationTypes
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class TaskAnnotationType < GraphQLTypes::BaseObject
+      field :task_annotation_id, ID, null: false
+      field :task_id, Integer, null: false
+      field :annotation_type_id, Integer, null: false
+      field :annotation, GraphQL::Types::JSON, null: true
+      field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :updated_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :task, GraphQLTypes::TaskInterface, null: true
+      field :annotation_type, GraphQLTypes::AnnotationType, null: true
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    module TaskInterface
+      include GraphQL::Schema::Interface
+
+      field :task_id, ID, null: false
+      field :status, String, null: false
+      field :reason, String, null: true
+      field :tags, GraphQL::Types::JSON, 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/task_type.rb

@@ -0,0 +1,26 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class TaskType < GraphQLTypes::BaseObject
+      implements TaskInterface
+
+      field :named_task_id, Integer, null: false
+      field :complete, Boolean, null: false
+      field :requested_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :initiator, String, null: true
+      field :source_system, String, null: true
+      field :bypass_steps, GraphQL::Types::JSON, null: true
+      field :context, GraphQL::Types::JSON, null: true, resolver_method: :resolve_context
+      field :identity_hash, String, null: false
+      field :named_task, GraphQLTypes::NamedTaskType, null: true
+      field :workflow_steps, [GraphQLTypes::WorkflowStepType], null: false
+      field :task_annotations, [GraphQLTypes::TaskAnnotationType], null: false
+
+      def resolve_context
+        :context
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+    class WorkflowStepType < GraphQLTypes::BaseObject
+      field :workflow_step_id, ID, null: false
+      field :task_id, Integer, null: false
+      field :named_step_id, Integer, null: false
+      field :status, String, null: false
+      field :retryable, Boolean, null: false
+      field :retry_limit, Integer, null: true
+      field :in_process, Boolean, null: false
+      field :processed, Boolean, null: false
+      field :processed_at, GraphQL::Types::ISO8601DateTime, null: true
+      field :attempts, Integer, null: true
+      field :last_attempted_at, GraphQL::Types::ISO8601DateTime, null: true
+      field :backoff_request_seconds, Integer, null: true
+      field :inputs, GraphQL::Types::JSON, null: true
+      field :results, GraphQL::Types::JSON, null: true
+      field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :updated_at, GraphQL::Types::ISO8601DateTime, null: false
+      field :skippable, Boolean, null: false
+      field :task, GraphQLTypes::TaskInterface, null: true
+      field :named_step, [GraphQLTypes::NamedStepType], null: true
+
+      # Optimized parent/child fields using scenic view to eliminate N+1 queries
+      field :children, [GraphQLTypes::WorkflowStepType], null: true do
+        description 'Child steps in the workflow DAG'
+      end
+
+      field :parents, [GraphQLTypes::WorkflowStepType], null: true do
+        description 'Parent steps in the workflow DAG'
+      end
+
+      # New efficient fields for IDs only (when full objects aren't needed)
+      field :parent_step_ids, [ID], null: false do
+        description 'IDs of parent steps (efficient lookup via scenic view)'
+      end
+
+      field :child_step_ids, [ID], null: false do
+        description 'IDs of child steps (efficient lookup via scenic view)'
+      end
+
+      # DAG position information from scenic view
+      field :is_root_step, Boolean, null: false do
+        description 'Whether this step has no dependencies'
+      end
+
+      field :is_leaf_step, Boolean, null: false do
+        description 'Whether this step has no downstream dependencies'
+      end
+
+      field :parent_count, Integer, null: false do
+        description 'Number of parent dependencies'
+      end
+
+      field :child_count, Integer, null: false do
+        description 'Number of child dependencies'
+      end
+
+      # Resolver methods using scenic view optimization
+      def parent_step_ids
+        # Handle both WorkflowStep objects and Hash objects from mutations
+        if object.is_a?(Hash)
+          object[:parents_ids] || []
+        else
+          object.step_dag_relationship&.parent_step_ids_array || []
+        end
+      end
+
+      def child_step_ids
+        # Handle both WorkflowStep objects and Hash objects from mutations
+        if object.is_a?(Hash)
+          object[:children_ids] || []
+        else
+          object.step_dag_relationship&.child_step_ids_array || []
+        end
+      end
+
+      def is_root_step
+        # Handle both WorkflowStep objects and Hash objects from mutations
+        if object.is_a?(Hash)
+          parent_step_ids.empty?
+        else
+          object.step_dag_relationship&.is_root_step || false
+        end
+      end
+
+      def is_leaf_step
+        # Handle both WorkflowStep objects and Hash objects from mutations
+        if object.is_a?(Hash)
+          child_step_ids.empty?
+        else
+          object.step_dag_relationship&.is_leaf_step || false
+        end
+      end
+
+      def parent_count
+        # Handle both WorkflowStep objects and Hash objects from mutations
+        if object.is_a?(Hash)
+          parent_step_ids.length
+        else
+          object.step_dag_relationship&.parent_count || 0
+        end
+      end
+
+      def child_count
+        # Handle both WorkflowStep objects and Hash objects from mutations
+        if object.is_a?(Hash)
+          child_step_ids.length
+        else
+          object.step_dag_relationship&.child_count || 0
+        end
+      end
+
+      def parents
+        # Handle both WorkflowStep objects and Hash objects from mutations
+        parent_ids = parent_step_ids
+        return [] if parent_ids.empty?
+
+        # For Hash objects from mutations, we need to fetch the actual WorkflowStep objects
+        if object.is_a?(Hash)
+          # Use task_id from the hash to scope the query
+          task_id = object[:task_id]
+          return [] unless task_id
+
+          WorkflowStep.where(task_id: task_id, workflow_step_id: parent_ids)
+        else
+          # Batch load all parent steps at once
+          WorkflowStep.where(workflow_step_id: parent_ids)
+        end
+      end
+
+      def children
+        # Handle both WorkflowStep objects and Hash objects from mutations
+        child_ids = child_step_ids
+        return [] if child_ids.empty?
+
+        # For Hash objects from mutations, we need to fetch the actual WorkflowStep objects
+        if object.is_a?(Hash)
+          # Use task_id from the hash to scope the query
+          task_id = object[:task_id]
+          return [] unless task_id
+
+          WorkflowStep.where(task_id: task_id, workflow_step_id: child_ids)
+        else
+          # Batch load all child steps at once
+          WorkflowStep.where(workflow_step_id: child_ids)
+        end
+      end
+    end
+  end
+end

data/app/graphql/tasker/graph_ql_types.rb

@@ -0,0 +1,42 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module GraphQLTypes
+  end
+end
+
+# Base classes first
+require_relative 'graph_ql_types/base_argument'
+require_relative 'graph_ql_types/base_field'
+require_relative 'graph_ql_types/base_object'
+require_relative 'graph_ql_types/base_scalar'
+require_relative 'graph_ql_types/base_enum'
+require_relative 'graph_ql_types/base_edge'
+require_relative 'graph_ql_types/base_connection'
+require_relative 'graph_ql_types/base_input_object'
+require_relative 'graph_ql_types/base_interface'
+require_relative 'graph_ql_types/base_union'
+
+# Node interface
+require_relative 'graph_ql_types/node_type'
+
+# Basic types without dependencies
+require_relative 'graph_ql_types/annotation_type'
+require_relative 'graph_ql_types/dependent_system_type'
+require_relative 'graph_ql_types/named_task_type'
+require_relative 'graph_ql_types/named_step_type'
+
+# Interfaces
+require_relative 'graph_ql_types/task_interface'
+
+# Types with dependencies
+require_relative 'graph_ql_types/dependent_system_object_map_type'  # depends on dependent_system_type
+require_relative 'graph_ql_types/named_tasks_named_step_type'       # depends on named_task_type and named_step_type
+require_relative 'graph_ql_types/task_annotation_type' # depends on annotation_type
+require_relative 'graph_ql_types/workflow_step_type' # depends on task_interface
+require_relative 'graph_ql_types/task_type' # depends on task_interface
+
+# Root types last
+require_relative 'graph_ql_types/query_type'
+require_relative 'graph_ql_types/mutation_type'

data/app/graphql/tasker/mutations/base_mutation.rb

@@ -0,0 +1,13 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Mutations
+    class BaseMutation < GraphQL::Schema::RelayClassicMutation
+      argument_class Tasker::GraphQLTypes::BaseArgument
+      field_class Tasker::GraphQLTypes::BaseField
+      input_object_class Tasker::GraphQLTypes::BaseInputObject
+      object_class Tasker::GraphQLTypes::BaseObject
+    end
+  end
+end

data/app/graphql/tasker/mutations/cancel_step.rb

@@ -0,0 +1,29 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Mutations
+    class CancelStep < BaseMutation
+      type Tasker::GraphQLTypes::WorkflowStepType
+
+      argument :task_id, ID, required: true
+      argument :step_id, ID, required: true
+
+      field :step, Tasker::GraphQLTypes::WorkflowStepType, null: false
+      field :errors, [String], null: false
+
+      def resolve(task_id:, step_id:)
+        step = Tasker::WorkflowStep.where({ task_id: task_id, workflow_step_id: step_id }).first
+        return { step: nil, errors: 'no such step' } unless step
+
+        # Use state machine to transition step to cancelled
+        step.state_machine.transition_to!(Tasker::Constants::WorkflowStepStatuses::CANCELLED)
+        if step.errors.empty?
+          Tasker::WorkflowStepSerializer.new(step).to_hash
+        else
+          { step: nil, errors: step.errors }
+        end
+      end
+    end
+  end
+end

data/app/graphql/tasker/mutations/cancel_task.rb

@@ -0,0 +1,29 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Mutations
+    class CancelTask < BaseMutation
+      type Tasker::GraphQLTypes::TaskType
+
+      argument :task_id, ID, required: true
+
+      field :task, Tasker::GraphQLTypes::TaskType, null: false
+      field :errors, [String], null: false
+
+      def resolve(task_id:)
+        task = Tasker::Task.find(task_id)
+        # Use state machine to transition task to cancelled
+        task.state_machine.transition_to!(Tasker::Constants::TaskStatuses::CANCELLED)
+
+        # 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?
+          Tasker::TaskSerializer.new(task).to_hash
+        else
+          { task: nil, errors: task.errors }
+        end
+      end
+    end
+  end
+end

data/app/graphql/tasker/mutations/create_task.rb

@@ -0,0 +1,52 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Mutations
+    class CreateTask < BaseMutation
+      type Tasker::GraphQLTypes::TaskType
+
+      argument :name, String, required: true
+      argument :context, GraphQL::Types::JSON, required: true
+      argument :initiator, String, required: false
+      argument :source_system, String, required: false
+      argument :reason, String, required: false
+      argument :tags, [String], required: false
+      argument :bypass_steps, [String], required: false
+
+      field :task, Tasker::GraphQLTypes::TaskType, null: false
+      field :errors, [String], null: false
+
+      def resolve(**task_params)
+        context = JSON.parse(task_params.fetch(:context, '{}'))
+        task_request = Tasker::Types::TaskRequest.new(task_params.merge({ context: context }))
+        task = nil
+        begin
+          handler = handler_factory.get(
+            task_request.name,
+            namespace_name: task_request.namespace || Tasker::NamedTask::DEFAULT_NAMESPACE,
+            version: task_request.version || Tasker::NamedTask::DEFAULT_VERSION
+          )
+          task = handler.initialize_task!(task_request)
+        rescue Tasker::ProceduralError => e
+          task = Tasker::Task.new
+          task.errors.add(:name, e.to_s)
+        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?
+          Tasker::TaskSerializer.new(task).to_hash
+        else
+          { task: nil, errors: task.errors }
+        end
+      end
+
+      private
+
+      def handler_factory
+        @handler_factory ||= Tasker::HandlerFactory.instance
+      end
+    end
+  end
+end

data/app/graphql/tasker/mutations/update_step.rb

@@ -0,0 +1,36 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Mutations
+    class UpdateStep < BaseMutation
+      ALLOWED_UPDATE_FIELDS = %i[retry_limit inputs].freeze
+      type Tasker::GraphQLTypes::WorkflowStepType
+
+      argument :step_id, ID, required: true
+      argument :task_id, Integer, required: true
+      argument :retry_limit, Integer, required: false
+      argument :inputs, GraphQL::Types::JSON, required: false
+
+      field :step, Tasker::GraphQLTypes::WorkflowStepType, null: false
+      field :errors, [String], null: false
+
+      def resolve(task_id:, step_id:, **args)
+        step = Tasker::WorkflowStep.where({ task_id: task_id, workflow_step_id: step_id }).first
+        return { step: nil, errors: 'no such step' } unless step
+
+        params = {}
+        args.each do |key, val|
+          params[key] = val if key.to_sym.in?(ALLOWED_UPDATE_FIELDS)
+        end
+        step.update!(params) unless params.empty?
+
+        if step.errors.empty?
+          Tasker::WorkflowStepSerializer.new(step).to_hash
+        else
+          { step: nil, errors: step.errors }
+        end
+      end
+    end
+  end
+end

data/app/graphql/tasker/mutations/update_task.rb

@@ -0,0 +1,41 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Mutations
+    class UpdateTask < BaseMutation
+      ALLOWED_UPDATE_FIELDS = %i[reason tags].freeze
+      type Tasker::GraphQLTypes::TaskType
+
+      argument :task_id, ID, required: true
+      argument :reason, String, required: false
+      argument :tags, [String], required: false
+
+      field :task, Tasker::GraphQLTypes::TaskType, null: false
+      field :errors, [String], null: false
+
+      def resolve(task_id:, **args)
+        task = Tasker::Task.find(task_id)
+        params = {}
+        args.each do |key, val|
+          params[key] = val if key.to_sym.in?(ALLOWED_UPDATE_FIELDS)
+        end
+        task.update!(params) unless params.empty?
+
+        # 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?
+          Tasker::TaskSerializer.new(task).to_hash
+        else
+          { task: nil, errors: task.errors }
+        end
+      end
+
+      private
+
+      def handler_factory
+        @handler_factory ||= Tasker::HandlerFactory.instance
+      end
+    end
+  end
+end

data/app/graphql/tasker/queries/all_annotation_types.rb

@@ -0,0 +1,17 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Queries
+    class AllAnnotationTypes < BaseQuery
+      include Helpers
+      type [Tasker::GraphQLTypes::AnnotationType], null: true
+
+      description 'List Annotation Types'
+
+      def resolve
+        AnnotationType.order('name asc')
+      end
+    end
+  end
+end

data/app/graphql/tasker/queries/all_tasks.rb

@@ -0,0 +1,23 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Queries
+    class AllTasks < BaseQuery
+      include Helpers
+      type [Tasker::GraphQLTypes::TaskType], null: true
+
+      description 'Find and sort tasks'
+      argument :limit, Integer, default_value: 20, prepare: ->(limit, _ctx) { [limit, 100].min }, required: false
+      argument :offset, Integer, default_value: 0, required: false
+      argument :sort_by, String, default_value: :requested_at, required: false
+      argument :sort_order, String, default_value: :desc, required: false
+
+      def resolve(limit:, offset:, sort_by:, sort_order:)
+        sorts = page_sort_params(model: Tasker::Task, limit: limit, offset: offset, sort_by: sort_by,
+                                 sort_order: sort_order)
+        Tasker::Task.with_all_associated.limit(sorts[:limit]).offset(sorts[:offset]).order(sorts[:order])
+      end
+    end
+  end
+end

data/app/graphql/tasker/queries/base_query.rb

@@ -0,0 +1,9 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Queries
+    class BaseQuery < GraphQL::Schema::Resolver
+    end
+  end
+end

data/app/graphql/tasker/queries/helpers.rb

@@ -0,0 +1,16 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Queries
+    module Helpers
+      def page_sort_params(model:, limit:, offset:, sort_by:, sort_order:)
+        valid_sorts = model.column_names.map(&:to_sym)
+        sort_by = :created_at if valid_sorts.exclude?(sort_by.to_s.to_sym)
+        sort_order = :asc if %i[asc desc].exclude?(sort_order.to_s.to_sym)
+        order = { sort_by => sort_order }
+        { limit: limit.presence || 20, offset: offset.presence || 0, order: order }
+      end
+    end
+  end
+end

data/app/graphql/tasker/queries/one_step.rb

@@ -0,0 +1,24 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Queries
+    class OneStep < BaseQuery
+      include Helpers
+      type Tasker::GraphQLTypes::WorkflowStepType, null: true
+
+      description 'Find a task by ID'
+      description 'Find a step by taskId and ID'
+      argument :task_id, Integer, required: true
+      argument :step_id, ID, required: true
+
+      def resolve(task_id:, step_id:)
+        Tasker::WorkflowStep
+          .includes(:named_step)
+          .includes(:task)
+          .where({ task_id: task_id, workflow_step_id: step_id })
+          .first
+      end
+    end
+  end
+end

data/app/graphql/tasker/queries/one_task.rb

@@ -0,0 +1,18 @@
+# typed: false
+# frozen_string_literal: true
+
+module Tasker
+  module Queries
+    class OneTask < BaseQuery
+      include Helpers
+      type Tasker::GraphQLTypes::TaskType, null: true
+
+      description 'Find a task by ID'
+      argument :task_id, ID, required: true
+
+      def resolve(task_id:)
+        Tasker::Task.extract_associated.where(task_id: task_id).first
+      end
+    end
+  end
+end