tasker-engine 1.0.0

data/app/models/tasker/application_record.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# typed: false
+
+module Tasker
+  # Abstract base class for all Tasker models that provides optional secondary database support.
+  #
+  # This class follows Rails multi-database conventions using the `connects_to` API.
+  # When secondary database is enabled, it connects to a database named 'tasker' in database.yml.
+  #
+  # @example Basic usage with shared database (default)
+  #   Tasker.configuration do |config|
+  #     config.database.enable_secondary_database = false
+  #   end
+  #
+  # @example Using a dedicated Tasker database
+  #   Tasker.configuration do |config|
+  #     config.database.enable_secondary_database = true
+  #     config.database.name = :tasker
+  #   end
+  #
+  #   # In database.yml:
+  #   production:
+  #     primary:
+  #       database: my_primary_database
+  #       adapter: postgresql
+  #     tasker:
+  #       database: my_tasker_database
+  #       adapter: postgresql
+  #
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    # Configure database connections based on Tasker configuration
+    # This follows Rails multi-database conventions but only when database is actually available
+    def self.configure_database_connections
+      # Ensure Tasker configuration is available - fail fast if not
+      unless defined?(Tasker.configuration)
+        error_message = 'Tasker.configuration is not available. This indicates a Rails initialization order issue. ' \
+                        'Ensure Tasker is properly initialized before models are loaded.'
+        raise StandardError, error_message
+      end
+
+      config = Tasker.configuration.database
+      if config.enable_secondary_database && config.name.present?
+        # Check if the database configuration actually exists before calling connects_to
+        if database_configuration_exists?(config.name)
+          # Use connects_to for proper Rails multi-database support
+          connects_to database: { writing: config.name.to_sym, reading: config.name.to_sym }
+        else
+          warning_message = "Tasker secondary database '#{config.name}' is enabled but not found in database.yml. " \
+                            'Using default database.'
+          Rails.logger.warn warning_message
+        end
+      end
+    rescue ActiveRecord::DatabaseConfigurations::InvalidConfigurationError => e
+      # Log database configuration errors but don't fail startup - this allows for
+      # environments where the secondary database might not be available
+      Rails.logger.warn "Tasker database configuration error: #{e.message}"
+    end
+
+    # Check if a database configuration exists in the current environment
+    def self.database_configuration_exists?(db_name)
+      Rails.application.config.database_configuration.key?(db_name.to_s)
+    end
+
+    # Call the connection configuration method
+    configure_database_connections
+  end
+end

data/app/models/tasker/dependent_system.rb

@@ -0,0 +1,26 @@
+# typed: false
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: dependent_systems
+#
+#  description         :string(255)
+#  name                :string(64)       not null
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#  dependent_system_id :integer          not null, primary key
+#
+# Indexes
+#
+#  dependent_systems_name_index   (name)
+#  dependent_systems_name_unique  (name) UNIQUE
+#
+module Tasker
+  class DependentSystem < ApplicationRecord
+    self.primary_key =  :dependent_system_id
+    has_many :dependent_system_object_maps, dependent: :destroy
+    has_many :named_steps, dependent: :destroy
+    validates :name, presence: true, uniqueness: true
+  end
+end

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/diagram/edge.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Tasker
+  module Diagram
+    # Represents an edge (connection) between nodes in a flowchart diagram
+    class Edge
+      # @return [String] The ID of the source node
+      attr_accessor :source_id
+
+      # @return [String] The ID of the target node
+      attr_accessor :target_id
+
+      # @return [String] The label to display on the edge
+      attr_accessor :label
+
+      # @return [String] The type of edge (e.g., 'solid', 'dashed')
+      attr_accessor :type
+
+      # @return [String] Direction of the arrow (e.g., 'forward', 'back', 'both', 'none')
+      attr_accessor :direction
+
+      # @return [Hash] Additional attributes for the edge
+      attr_accessor :attributes
+
+      # Define constants for style mappings
+      EDGE_STYLES = {
+        'dashed' => '--',
+        'thick' => '==',
+        'dotted' => '-.-',
+        'solid' => '--' # Default
+      }.freeze
+
+      ARROW_STYLES = {
+        'back' => '<',
+        'both' => '<>',
+        'none' => '',
+        'forward' => '>' # Default
+      }.freeze
+
+      # Creates a new diagram edge
+      #
+      # @param source_id [String] The ID of the source node
+      # @param target_id [String] The ID of the target node
+      # @param label [String] The label to display on the edge
+      # @param type [String] The type of edge (default: 'solid')
+      # @param direction [String] Direction of the arrow (default: 'forward')
+      # @param attributes [Hash] Additional attributes for the edge
+      # @return [Edge] A new diagram edge
+      def initialize(source_id:, target_id:, label: '', type: 'solid', direction: 'forward', attributes: {})
+        @source_id = source_id
+        @target_id = target_id
+        @label = label
+        @type = type
+        @direction = direction
+        @attributes = attributes
+      end
+
+      # Convert the edge to a hash representation
+      #
+      # @return [Hash] Hash representation of the edge
+      def to_h
+        {
+          source_id: source_id,
+          target_id: target_id,
+          label: label,
+          type: type,
+          direction: direction,
+          attributes: attributes
+        }.compact
+      end
+
+      # Convert the edge to a JSON string
+      #
+      # @return [String] JSON representation of the edge
+      def to_json(*)
+        to_h.to_json(*)
+      end
+
+      # Generate Mermaid diagram syntax for this edge
+      #
+      # @return [String] Mermaid syntax for the edge
+      def to_mermaid
+        # For labeled edges, use the |label| syntax instead of adding a separate text label
+        if label&.present? # rubocop:disable Lint/RedundantSafeNavigation
+          "#{source_id} -->|\"#{escape_mermaid_text(label)}\"| #{target_id}"
+        else
+          "#{source_id} --> #{target_id}"
+        end
+      end
+
+      private
+
+      # Escape special characters in Mermaid text
+      #
+      # @param text [String] The text to escape
+      # @return [String] Escaped text safe for Mermaid diagrams
+      def escape_mermaid_text(text)
+        # Handle nil values
+        return '' if text.nil?
+
+        # Replace instances of " with ' to avoid breaking the Mermaid syntax
+        text.to_s.tr('"', "'")
+      end
+    end
+  end
+end

data/app/models/tasker/diagram/flowchart.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Tasker
+  module Diagram
+    # Represents a flowchart diagram with nodes and edges
+    class Flowchart
+      # @return [Array<Tasker::Diagram::Node>] The nodes in the flowchart
+      attr_accessor :nodes
+
+      # @return [Array<Tasker::Diagram::Edge>] The edges in the flowchart
+      attr_accessor :edges
+
+      # @return [String] The direction of the flowchart (TD: top-down, LR: left-right, etc.)
+      attr_accessor :direction
+
+      # @return [String] The title of the flowchart
+      attr_accessor :title
+
+      # @return [Hash] Additional attributes for the flowchart
+      attr_accessor :attributes
+
+      # Creates a new flowchart diagram
+      #
+      # @param nodes [Array<Tasker::Diagram::Node>] The nodes in the flowchart
+      # @param edges [Array<Tasker::Diagram::Edge>] The edges in the flowchart
+      # @param direction [String] The direction of the flowchart (default: 'TD')
+      # @param title [String, nil] The title of the flowchart
+      # @param attributes [Hash] Additional attributes for the flowchart
+      # @return [Flowchart] A new flowchart diagram
+      def initialize(nodes: [], edges: [], direction: 'TD', title: nil, attributes: {})
+        @nodes = nodes
+        @edges = edges
+        @direction = direction
+        @title = title
+        @attributes = attributes
+      end
+
+      # Add a node to the flowchart
+      #
+      # @param node [Tasker::Diagram::Node] The node to add
+      # @return [Tasker::Diagram::Node] The added node
+      def add_node(node)
+        @nodes << node
+        node
+      end
+
+      # Add an edge to the flowchart
+      #
+      # @param edge [Tasker::Diagram::Edge] The edge to add
+      # @return [Tasker::Diagram::Edge] The added edge
+      def add_edge(edge)
+        @edges << edge
+        edge
+      end
+
+      # Find a node by its ID
+      #
+      # @param id [String] The ID of the node to find
+      # @return [Tasker::Diagram::Node, nil] The node with the given ID, or nil if not found
+      def find_node(id)
+        @nodes.find { |node| node.id == id }
+      end
+
+      # Find all edges connected to a node
+      #
+      # @param node_id [String] The ID of the node
+      # @param direction [Symbol] :outgoing, :incoming, or :both (default: :both)
+      # @return [Array<Tasker::Diagram::Edge>] The edges connected to the node
+      def find_edges_for_node(node_id, direction = :both)
+        case direction
+        when :outgoing
+          @edges.select { |edge| edge.source_id == node_id }
+        when :incoming
+          @edges.select { |edge| edge.target_id == node_id }
+        else
+          @edges.select { |edge| edge.source_id == node_id || edge.target_id == node_id }
+        end
+      end
+
+      # Convert the flowchart to a hash representation
+      #
+      # @return [Hash] Hash representation of the flowchart
+      def to_h
+        {
+          nodes: nodes.map(&:to_h),
+          edges: edges.map(&:to_h),
+          direction: direction,
+          title: title,
+          attributes: attributes
+        }.compact
+      end
+
+      # Convert the flowchart to a JSON string
+      #
+      # @return [String] JSON representation of the flowchart
+      def to_json(*)
+        to_h.to_json(*)
+      end
+
+      # Generate Mermaid diagram syntax for this flowchart
+      #
+      # @return [String] Mermaid syntax for the flowchart
+      def to_mermaid
+        lines = []
+
+        # Add the flowchart definition
+        lines << "graph #{direction}"
+
+        # Use a subgraph with title if title is present
+        if title
+          lines << "subgraph \"#{title}\""
+          indent = '  '
+        else
+          indent = ''
+        end
+
+        # Add all nodes
+        nodes.each do |node|
+          node.to_mermaid.each do |line|
+            lines << "#{indent}#{line}"
+          end
+        end
+
+        # Add all edges
+        edges.each do |edge|
+          lines << "#{indent}#{edge.to_mermaid}"
+        end
+
+        # Close the subgraph if we have a title
+        lines << 'end' if title
+
+        # Join all lines with newlines
+        lines.join("\n")
+      end
+    end
+  end
+end

data/app/models/tasker/diagram/node.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Tasker
+  module Diagram
+    # Represents a node in a flowchart diagram
+    class Node
+      # @return [String] The unique identifier for this node
+      attr_accessor :id
+
+      # @return [String] The display label for this node
+      attr_accessor :label
+
+      # @return [String] The shape of the node (e.g., 'box', 'circle', 'diamond')
+      attr_accessor :shape
+
+      # @return [String] CSS styling for the node
+      attr_accessor :style
+
+      # @return [String, nil] URL to link to when clicking the node
+      attr_accessor :url
+
+      # @return [Hash] Additional attributes for the node
+      attr_accessor :attributes
+
+      # Creates a new diagram node
+      #
+      # @param id [String] The unique identifier for this node
+      # @param label [String] The display label for this node
+      # @param shape [String] The shape of the node (default: 'box')
+      # @param style [String, nil] CSS styling for the node
+      # @param url [String, nil] URL to link to when clicking the node
+      # @param attributes [Hash] Additional attributes for the node
+      # @return [Node] A new diagram node
+      def initialize(id:, label:, shape: 'box', style: nil, url: nil, attributes: {})
+        @id = id
+        @label = label
+        @shape = shape
+        @style = style
+        @url = url
+        @attributes = attributes
+      end
+
+      # Convert the node to a hash representation
+      #
+      # @return [Hash] Hash representation of the node
+      def to_h
+        {
+          id: id,
+          label: label,
+          shape: shape,
+          style: style,
+          url: url,
+          attributes: attributes
+        }.compact
+      end
+
+      # Convert the node to a JSON string
+      #
+      # @return [String] JSON representation of the node
+      def to_json(*)
+        to_h.to_json(*)
+      end
+
+      # Generate Mermaid diagram syntax for this node
+      #
+      # @return [Array<String>] Array of Mermaid syntax lines for the node
+      def to_mermaid
+        # Use HTML line breaks in the label
+        formatted_label = escape_mermaid_text(label).gsub("\n", '<br/>')
+
+        # Basic node definition
+        node_def = "#{id}[\"#{formatted_label}\"]"
+
+        # Add URL link if present
+        click_def = url ? "click #{id} \"#{escape_mermaid_text(url)}\"" : nil
+
+        # Add style definition if present
+        style_def = style ? "style #{id} #{style}" : nil
+
+        # Return node definition and optional click and style definitions
+        [node_def, click_def, style_def].compact
+      end
+
+      private
+
+      # Escape special characters in Mermaid text
+      #
+      # @param text [String] The text to escape
+      # @return [String] Escaped text safe for Mermaid diagrams
+      def escape_mermaid_text(text)
+        # Handle nil values
+        return '' if text.nil?
+
+        # Replace instances of " with ' to avoid breaking the Mermaid syntax
+        text.to_s.tr('"', "'")
+      end
+    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