tasker-engine 0.1.0

data/app/models/tasker/dependent_system_object_map.rb

@@ -0,0 +1,64 @@
+# typed: false
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: dependent_system_object_maps
+#
+#  remote_id_one                  :string(128)      not null
+#  remote_id_two                  :string(128)      not null
+#  created_at                     :datetime         not null
+#  updated_at                     :datetime         not null
+#  dependent_system_object_map_id :bigint           not null, primary key
+#  dependent_system_one_id        :integer          not null
+#  dependent_system_two_id        :integer          not null
+#
+# Indexes
+#
+#  dependent_system_object_maps_dependent_system_one_id_dependent_  (dependent_system_one_id,dependent_system_two_id,remote_id_one,remote_id_two) UNIQUE
+#  dependent_system_object_maps_dependent_system_one_id_index       (dependent_system_one_id)
+#  dependent_system_object_maps_dependent_system_two_id_index       (dependent_system_two_id)
+#  dependent_system_object_maps_remote_id_one_index                 (remote_id_one)
+#  dependent_system_object_maps_remote_id_two_index                 (remote_id_two)
+#
+# Foreign Keys
+#
+#  dependent_system_object_maps_dependent_system_one_id_foreign  (dependent_system_one_id => dependent_systems.dependent_system_id)
+#  dependent_system_object_maps_dependent_system_two_id_foreign  (dependent_system_two_id => dependent_systems.dependent_system_id)
+#
+
+module Tasker
+  class DependentSystemObjectMap < ApplicationRecord
+    self.primary_key = :dependent_system_object_map_id
+    belongs_to :dependent_system_one, class_name: 'Tasker::DependentSystem'
+    belongs_to :dependent_system_two, class_name: 'Tasker::DependentSystem'
+    validates :remote_id_one, presence: true
+    validates :remote_id_two, presence: true
+
+    def self.find_or_create(system_one_name, system_one_id, system_two_name, system_two_id)
+      system_one = Tasker::DependentSystem.find_or_create_by!(name: system_one_name)
+      system_two = Tasker::DependentSystem.find_or_create_by!(name: system_two_name)
+      # these could be in either order
+      inst = where(
+        remote_id_one: system_one_id,
+        remote_id_two: system_two_id,
+        dependent_system_one_id: system_one.dependent_system_id,
+        dependent_system_two_id: system_two.dependent_system_id
+      ).or(
+        where(
+          remote_id_one: system_two_id,
+          remote_id_two: system_one_id,
+          dependent_system_one_id: system_two.dependent_system_id,
+          dependent_system_two_id: system_one.dependent_system_id
+        )
+      ).first
+      inst ||= create(
+        remote_id_one: system_one_id,
+        remote_id_two: system_two_id,
+        dependent_system_one: system_one,
+        dependent_system_two: system_two
+      )
+      inst
+    end
+  end
+end

data/app/models/tasker/named_step.rb

@@ -0,0 +1,41 @@
+# typed: false
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: named_steps
+#
+#  description         :string(255)
+#  name                :string(128)      not null
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#  dependent_system_id :integer          not null
+#  named_step_id       :integer          not null, primary key
+#
+# Indexes
+#
+#  named_step_by_system_uniq              (dependent_system_id,name) UNIQUE
+#  named_steps_dependent_system_id_index  (dependent_system_id)
+#  named_steps_name_index                 (name)
+#
+# Foreign Keys
+#
+#  named_steps_dependent_system_id_foreign  (dependent_system_id => dependent_systems.dependent_system_id)
+#
+module Tasker
+  class NamedStep < ApplicationRecord
+    self.primary_key = :named_step_id
+    belongs_to :dependent_system
+    has_many :workflow_steps, dependent: :nullify
+    validates :name, presence: true, uniqueness: { scope: :dependent_system_id }
+
+    def self.create_named_steps_from_templates(templates)
+      templates.map do |template|
+        dependent_system = Tasker::DependentSystem.find_or_create_by!(name: template.dependent_system)
+        named_step = NamedStep.find_or_create_by!(name: template.name,
+                                                  dependent_system_id: dependent_system.dependent_system_id)
+        named_step
+      end
+    end
+  end
+end

data/app/models/tasker/named_task.rb

@@ -0,0 +1,121 @@
+# typed: false
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: tasker_named_tasks
+#
+#  description           :string(255)
+#  name                  :string(64)       not null
+#  version               :string(16)       not null
+#  configuration         :jsonb
+#  created_at            :datetime         not null
+#  updated_at            :datetime         not null
+#  named_task_id         :integer          not null, primary key
+#  task_namespace_id     :integer          not null
+#
+# Indexes
+#
+#  named_tasks_name_index                          (name)
+#  named_tasks_namespace_name_version_unique       (task_namespace_id,name,version) UNIQUE
+#  named_tasks_task_namespace_id_index             (task_namespace_id)
+#  named_tasks_version_index                       (version)
+#  named_tasks_configuration_gin_index             (configuration) USING gin
+#
+# Foreign Keys
+#
+#  fk_rails_...  (task_namespace_id => tasker_task_namespaces.task_namespace_id)
+#
+module Tasker
+  class NamedTask < ApplicationRecord
+    self.primary_key = :named_task_id
+
+    belongs_to :task_namespace
+    has_many :tasks, dependent: :nullify
+
+    validates :name, presence: true, length: { maximum: 64 }
+    validates :version, presence: true, format: {
+      with: /\A\d+\.\d+\.\d+\z/,
+      message: 'must be in semver format (e.g., 1.0.0)'
+    }, length: { maximum: 16 }
+    validates :task_namespace_id, uniqueness: { scope: %i[name version] }
+
+    # Default version for new tasks
+    DEFAULT_VERSION = '0.1.0'
+
+    # Default namespace name
+    DEFAULT_NAMESPACE = 'default'
+
+    # Find or create with namespace and version support
+    def self.find_or_create_by_full_name!(name:, namespace_name: DEFAULT_NAMESPACE, version: DEFAULT_VERSION)
+      namespace = TaskNamespace.find_or_create_by!(name: namespace_name)
+      find_or_create_by!(
+        task_namespace: namespace,
+        name: name,
+        version: version
+      )
+    end
+
+    # Full qualified name: namespace.name@version
+    def full_name
+      "#{task_namespace.name}.#{name}@#{version}"
+    end
+
+    # Short name without version: namespace.name
+    def qualified_name
+      "#{task_namespace.name}.#{name}"
+    end
+
+    # Configuration accessor with defaults
+    def config
+      @config ||= (configuration || {}).with_indifferent_access
+    end
+
+    # Get concurrency setting from configuration
+    def concurrent?
+      config.fetch('concurrent', true)
+    end
+
+    # Update configuration
+    def update_config!(new_config)
+      self.configuration = (config || {}).deep_merge(new_config)
+      save!
+      @config = nil # Clear memoized config
+    end
+
+    # Check if this uses the default namespace
+    def default_namespace?
+      task_namespace.default?
+    end
+
+    def namespace_name
+      task_namespace.name
+    end
+
+    # Scope methods for common queries
+    scope :in_namespace, lambda { |namespace|
+      joins(:task_namespace).where(task_namespace: { name: namespace })
+    }
+
+    scope :with_version, ->(version) { where(version: version) }
+
+    scope :latest_versions, lambda {
+      select('DISTINCT ON (task_namespace_id, name) *')
+        .order(:task_namespace_id, :name, version: :desc)
+    }
+
+    # Find latest version of a named task in a namespace
+    def self.find_latest_version(namespace_name, task_name)
+      in_namespace(namespace_name)
+        .where(name: task_name)
+        .order(version: :desc)
+        .first
+    end
+
+    # Check if a specific version exists
+    def self.version_exists?(namespace_name, task_name, version)
+      in_namespace(namespace_name)
+        .exists?(name: task_name, version: version)
+    end
+  end
+end

data/app/models/tasker/named_tasks_named_step.rb

@@ -0,0 +1,82 @@
+# typed: false
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: named_tasks_named_steps
+#
+#  id                  :integer          not null, primary key
+#  default_retry_limit :integer          default(3), not null
+#  default_retryable   :boolean          default(TRUE), not null
+#  skippable           :boolean          default(FALSE), not null
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#  named_step_id       :integer          not null
+#  named_task_id       :integer          not null
+#
+# Indexes
+#
+#  named_tasks_named_steps_named_step_id_index  (named_step_id)
+#  named_tasks_named_steps_named_task_id_index  (named_task_id)
+#  named_tasks_steps_ids_unique                 (named_task_id,named_step_id) UNIQUE
+#
+# Foreign Keys
+#
+#  named_tasks_named_steps_named_step_id_foreign  (named_step_id => named_steps.named_step_id)
+#  named_tasks_named_steps_named_task_id_foreign  (named_task_id => named_tasks.named_task_id)
+#
+module Tasker
+  class NamedTasksNamedStep < ApplicationRecord
+    belongs_to :named_task
+    belongs_to :named_step
+    validates :named_task_id, uniqueness: { scope: :named_step_id }
+    validates :named_step_id, uniqueness: { scope: :named_task_id }
+
+    scope :named_steps_for_named_task, lambda { |named_task_id|
+      where(named_task_id: named_task_id).includes(:named_task).includes(:named_step)
+    }
+
+    def self.find_or_create(
+      named_task,
+      named_step,
+      options = {
+        default_retry_limit: 3,
+        default_retryable: true,
+        skippable: false
+      }
+    )
+      inst = where(named_task_id: named_task.named_task_id, named_step_id: named_step.named_step_id).first
+
+      inst ||= create({ named_task_id: named_task.named_task_id,
+                        named_step_id: named_step.named_step_id }.merge(options))
+
+      inst
+    end
+
+    def self.associate_named_step_with_named_task(named_task, template, named_step)
+      ntns = named_steps_for_named_task(named_task.named_task_id).where(named_step: { name: named_step.name }).first
+      return ntns if ntns
+
+      dependent_system = Tasker::DependentSystem.find_or_create_by!(name: template.dependent_system)
+      named_step = Tasker::NamedStep.find_or_create_by!(name: template.name,
+                                                        dependent_system_id: dependent_system.dependent_system_id)
+      find_or_create(
+        named_task,
+        named_step,
+        {
+          default_retry_limit: template.default_retry_limit,
+          default_retryable: template.default_retryable,
+          skippable: template.skippable
+        }
+      )
+    end
+
+    def task_name
+      named_task.name
+    end
+
+    def step_name
+      named_step.name
+    end
+  end
+end

data/app/models/tasker/step_dag_relationship.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Tasker
+  class StepDagRelationship < ApplicationRecord
+    self.table_name = 'tasker_step_dag_relationships'
+    self.primary_key = 'workflow_step_id'
+
+    # Read-only model backed by database view
+    def readonly?
+      true
+    end
+
+    # Associations to actual models for additional data
+    belongs_to :workflow_step
+    belongs_to :task
+
+    # Scopes for common DAG queries
+    scope :for_task, ->(task_id) { where(task_id: task_id) }
+    scope :root_steps, -> { where(is_root_step: true) }
+    scope :leaf_steps, -> { where(is_leaf_step: true) }
+    scope :with_parents, -> { where('parent_count > 0') }
+    scope :with_children, -> { where('child_count > 0') }
+
+    # Efficient siblings scope leveraging existing WorkflowStepEdge logic
+    # Uses the sophisticated sibling_sql that finds steps with exactly the same parent set
+    scope :siblings_of, lambda { |workflow_step_id|
+      # Get sibling step IDs using the existing, well-tested WorkflowStepEdge logic
+      sibling_edges = WorkflowStepEdge.siblings_of(WorkflowStep.find(workflow_step_id))
+      sibling_step_ids = sibling_edges.pluck(:to_step_id).uniq
+
+      # Return StepDagRelationship records for these siblings
+      where(workflow_step_id: sibling_step_ids)
+    }
+
+    # Helper methods for DAG navigation
+    def root_step?
+      is_root_step
+    end
+
+    def leaf_step?
+      is_leaf_step
+    end
+
+    def has_parents?
+      parent_count.positive?
+    end
+
+    def has_children?
+      child_count.positive?
+    end
+
+    # Parse JSONB arrays for relationship access
+    def parent_step_ids_array
+      return [] if parent_step_ids.blank?
+
+      parent_step_ids.is_a?(Array) ? parent_step_ids : JSON.parse(parent_step_ids)
+    end
+
+    def child_step_ids_array
+      return [] if child_step_ids.blank?
+
+      child_step_ids.is_a?(Array) ? child_step_ids : JSON.parse(child_step_ids)
+    end
+  end
+end

data/app/models/tasker/step_readiness_status.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Tasker
+  # StepReadinessStatus now uses SQL functions for high-performance queries
+  # This class explicitly delegates to the function-based implementation for better maintainability
+  class StepReadinessStatus
+    # Explicit delegation of class methods to function-based implementation
+    def self.for_task(task_id, step_ids = nil)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.for_task(task_id, step_ids)
+    end
+
+    def self.for_steps(task_id, step_ids)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.for_steps(task_id, step_ids)
+    end
+
+    def self.for_tasks(task_ids)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.for_tasks(task_ids)
+    end
+
+    # Task-scoped methods that require task_id parameter
+    def self.ready_for_task(task_id)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.ready_for_task(task_id)
+    end
+
+    def self.blocked_by_dependencies_for_task(task_id)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.blocked_by_dependencies_for_task(task_id)
+    end
+
+    def self.blocked_by_retry_for_task(task_id)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.blocked_by_retry_for_task(task_id)
+    end
+
+    def self.pending_for_task(task_id)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.pending_for_task(task_id)
+    end
+
+    def self.failed_for_task(task_id)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.failed_for_task(task_id)
+    end
+
+    def self.in_progress_for_task(task_id)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.in_progress_for_task(task_id)
+    end
+
+    def self.complete_for_task(task_id)
+      Tasker::Functions::FunctionBasedStepReadinessStatus.complete_for_task(task_id)
+    end
+
+    # For backward compatibility, maintain the active method but point to function-based implementation
+    def self.active
+      Tasker::Functions::FunctionBasedStepReadinessStatus
+    end
+
+    def self.all_steps_complete_for_task?(task)
+      complete = Tasker::Functions::FunctionBasedStepReadinessStatus.complete_for_task(task.task_id)
+      complete.length == task.workflow_steps.count
+    end
+  end
+end