tasker-rb 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67c2fa6d572b21fba2e42334cf90bc2c1ae8a37c5baa2b189334da91c0d795f9
-  data.tar.gz: f38e8d917297f043ad06518224973f18453596341ef3da465d747cf661d8ebd7
+  metadata.gz: a8c5ed3385bea52ede9378bb4cd2f35c4fb03e285a0b811698fa34042b2a0c8a
+  data.tar.gz: a9ce3c0d4d390ae8f0263ca60794c8a0997d99ca6272c52ccd7a8cea579de6ae
 SHA512:
-  metadata.gz: caa3042ef86162a269ca6dfae5c33c47006e32995cca36cf72654bd25bf7be1deb6639d46c2b5b7ad24e1c3dc0567426f32765d696eabd212b43665aaa32e717
-  data.tar.gz: e75885dbaba5b94164bbcbffa2250e5d6d1848e0ad8429691d621213f24caa398d8e4400c713635c4a0ef877594004acc981d341fd5a2e1fe950f7a5c5202556
+  metadata.gz: d7957c47e7f5403a0adc3cbfc917b49196e44e21438276f806809662b0bd3abaa2ff14408e69233dd06e1521fece83cc0f320d3601d152e8ee69730212f3ca58
+  data.tar.gz: e7844fe1ee414c7f3887db916b084c15ac44768885516792964bce9afff6cd807a8b847335428cb367fb7e0042730b8bc95a098e89cc7a24851ca0b96bc8b5db

data/ext/tasker_core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tasker-rb"
-version = "0.1.4"
+version = "0.1.5"
 edition = "2021"
 description = "Ruby bindings for tasker-core: High-performance workflow orchestration"
 readme = "../../../../README.md"
@@ -66,8 +66,8 @@ sqlx = { version = "0.8", features = [
 # Both path (for workspace builds) and version (for standalone/published builds).
 # cargo publish strips the path field, leaving only the version for crates.io resolution.
 # Version pins are updated by scripts/release/update-versions.sh during release-prepare.
-tasker-shared = { path = "../../../../tasker-shared", version = "=0.1.4" }
-tasker-worker = { path = "../../../../tasker-worker", version = "=0.1.4" }
+tasker-shared = { path = "../../../../tasker-shared", version = "=0.1.5" }
+tasker-worker = { path = "../../../../tasker-worker", version = "=0.1.5" }
 # Error handling
 thiserror = "2.0"
 # Async runtime for blocking on futures in FFI
@@ -80,7 +80,7 @@ uuid = { version = "1.11", features = ["serde", "v4", "v7"] }
 workspace_tools = { version = "0.11.0", features = ["full"] }
 
 [dev-dependencies]
-tasker-core = { package = "tasker-core", path = "../../../../", version = "=0.1.4" }
+tasker-core = { package = "tasker-core", path = "../../../../", version = "=0.1.5" }
 
 [features]
 default = []

data/lib/tasker_core/handlers.rb

@@ -4,8 +4,7 @@ module TaskerCore
   # Clean Handlers Domain API
   #
   # This module provides the primary public interface for working with TaskerCore handlers.
-  # It's organized into two main namespaces: Steps and Tasks, mirroring the Rails engine
-  # architecture while providing a clean Ruby interface with enhanced type safety.
+  # It provides a clean Ruby interface with enhanced type safety for step handlers.
   #
   # The Handlers namespace serves as the recommended entry point for handler operations,
   # abstracting the underlying implementation details while preserving method signatures
@@ -60,14 +59,8 @@ module TaskerCore
   #     end
   #   end
   #
-  # @example Task-level handler for workflow coordination
-  #   # Task handlers coordinate multiple steps
-  #   result = TaskerCore::Handlers::Tasks.handle(task_uuid: "123-456")
-  #   # => Orchestrates all steps for the task
-  #
   # Architecture:
   # - **Steps**: Individual business logic units (payment processing, API calls, etc.)
-  # - **Tasks**: Workflow orchestration and step coordination
   # - **API**: Specialized step handlers for HTTP operations with automatic retry
   #
   # Method Signature:
@@ -78,7 +71,6 @@ module TaskerCore
   # - `context.dependency_results` - Results from parent steps
   #
   # @see TaskerCore::Handlers::Steps For step-level business logic
-  # @see TaskerCore::Handlers::Tasks For task-level orchestration
   # @see TaskerCore::StepHandler::Base For low-level step handler implementation
   # @see TaskerCore::StepHandler::Api For HTTP-based handlers
   module Handlers
@@ -131,29 +123,5 @@ module TaskerCore
         end
       end
     end
-
-    # Task Handler API
-    module Tasks
-      require_relative 'task_handler/base'
-
-      # Re-export with clean namespace
-      Base = TaskHandler
-
-      class << self
-        # Handle task with preserved signature
-        # @param task_uuid [Integer] Task ID to handle
-        # @return [Object] Task handle result
-        def handle(task_uuid)
-          Base.new.handle(task_uuid)
-        end
-
-        # Create task handler instance
-        # @param config [Hash] Handler configuration
-        # @return [TaskHandler] Handler instance
-        def create(config: {})
-          Base.new(config: config)
-        end
-      end
-    end
   end
 end

data/lib/tasker_core/models.rb

@@ -192,8 +192,13 @@ module TaskerCore
       #
       # @param results_data [Hash] Hash of step names to their results
       def initialize(results_data)
-        # Use HashWithIndifferentAccess for developer-friendly key access
-        @results = (results_data || {}).with_indifferent_access
+        # Use HashWithIndifferentAccess for developer-friendly key access.
+        # serde_magnus serializes Rust struct field names as Ruby symbols, so
+        # each inner StepExecutionResult hash has symbol keys (:result, :success, etc.).
+        # Convert them to indifferent access so callers can use string or symbol keys.
+        raw = results_data || {}
+        @results = raw.transform_values { |v| v.is_a?(Hash) ? v.with_indifferent_access : v }
+                      .with_indifferent_access
       end
 
       # Get result from a parent step (returns full result hash)

data/lib/tasker_core/registry/handler_registry.rb

@@ -298,7 +298,8 @@ module TaskerCore
         return ENV['TASKER_TEMPLATE_PATH'] if ENV['TASKER_TEMPLATE_PATH']
 
         # 2. Test environment: default to spec/fixtures/templates
-        if test_environment?
+        #    (skip when TASKER_SKIP_EXAMPLE_HANDLERS is set — the app provides its own templates)
+        if test_environment? && ENV['TASKER_SKIP_EXAMPLE_HANDLERS'] != 'true'
           fixtures_path = File.expand_path('../../../spec/fixtures/templates', __dir__)
           return fixtures_path if Dir.exist?(fixtures_path)
         end
@@ -375,7 +376,8 @@ module TaskerCore
         end
 
         # In test environment, add spec/handlers/examples for test fixtures
-        if test_environment?
+        # (skip when TASKER_SKIP_EXAMPLE_HANDLERS is set — the app provides its own handlers)
+        if test_environment? && ENV['TASKER_SKIP_EXAMPLE_HANDLERS'] != 'true'
           spec_dir = File.expand_path('../../../spec/handlers/examples', __dir__)
           Dir.glob("#{spec_dir}/**/").each { |dir| paths << dir } if Dir.exist?(spec_dir)
         end
@@ -423,6 +425,26 @@ module TaskerCore
             # Register with FULL class name so templates can reference it properly
             register_handler(handler_class_name, handler_class)
             registered_count += 1
+
+            # TAS-294: Also register under the DSL handler_name if it differs from the class name.
+            # DSL handlers created via step_handler('dot.notation.name') { ... } have a handler_name
+            # instance method that returns the dot-notation callable (e.g., 'linear_workflow_dsl.step_handlers.linear_step_1')
+            # but are registered above under their Ruby class name (e.g., 'LinearStep1DslHandler').
+            # Templates reference the dot-notation name, so we need both keys in the registry.
+            begin
+              instance = handler_class.new
+              if instance.respond_to?(:handler_name)
+                dsl_name = instance.handler_name
+                if dsl_name && dsl_name != handler_class_name
+                  register_handler(dsl_name, handler_class)
+                  registered_count += 1
+                  logger.debug("✅ Registered DSL handler alias: #{dsl_name}")
+                end
+              end
+            rescue StandardError
+              # Some handlers require config args - skip DSL name registration for those
+            end
+
             logger.debug("✅ Registered preloaded test handler: #{handler_class_name}")
           else
             logger.debug("⚠️ Preloaded handler class not found: #{handler_class_name}")

data/lib/tasker_core/step_handler/base.rb

@@ -80,7 +80,10 @@ module TaskerCore
         class_name.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, '')
       end
 
-      # Get handler metadata for monitoring and introspection
+      # Get handler metadata for monitoring and introspection.
+      # Note: VERSION is currently a no-op — not yet wired through FFI bridges
+      # to StepExecutionMetadata. Reserved for future observability and
+      # compatibility tracking.
       # @return [Hash] Handler metadata
       def metadata
         {

data/lib/tasker_core/step_handler/functional.rb

@@ -0,0 +1,454 @@
+# frozen_string_literal: true
+
+# Functional/block DSL for step handlers (TAS-294).
+#
+# This module provides block-based alternatives to the class-based handler API.
+# It reduces boilerplate for common handler patterns while preserving full access
+# to the underlying StepContext for advanced use cases.
+#
+# The DSL methods auto-wrap return values and classify exceptions:
+# - Hash return -> StepHandlerCallResult.success(result: hash)
+# - StepHandlerCallResult return -> pass through unchanged
+# - PermanentError raised -> StepHandlerCallResult.error(retryable: false)
+# - RetryableError raised -> StepHandlerCallResult.error(retryable: true)
+# - Other errors -> StepHandlerCallResult.error(retryable: true)
+#
+# @example Basic handler
+#   include TaskerCore::StepHandler::Functional
+#
+#   step_handler "process_payment",
+#     depends_on: { cart: "validate_cart" },
+#     inputs: [:payment_info] do |cart:, payment_info:, context:|
+#
+#     raise TaskerCore::Errors::PermanentError, "Payment info required" unless payment_info
+#     result = charge_card(payment_info, cart["total"])
+#     { payment_id: result["id"], amount: cart["total"] }
+#   end
+
+module TaskerCore
+  module StepHandler
+    module Functional
+      # ========================================================================
+      # Helper: Decision
+      # ========================================================================
+
+      # Helper for decision handler return values.
+      #
+      # @example
+      #   decision_handler "route_order",
+      #     depends_on: { order: "validate_order" } do |order:, context:|
+      #     if order["tier"] == "premium"
+      #       Decision.route(["process_premium"], tier: "premium")
+      #     else
+      #       Decision.route(["process_standard"])
+      #     end
+      #   end
+      class Decision
+        attr_reader :type, :steps, :reason, :routing_context
+
+        def initialize(type, steps, reason, routing_context)
+          @type = type
+          @steps = steps
+          @reason = reason
+          @routing_context = routing_context
+          freeze
+        end
+
+        # Route to the specified steps.
+        #
+        # @param steps [Array<String>] Step names to route to
+        # @param routing_context [Hash] Additional routing context
+        # @return [Decision]
+        def self.route(steps, **routing_context)
+          new('create_steps', Array(steps), nil, routing_context)
+        end
+
+        # Skip all branches.
+        #
+        # @param reason [String] Reason for skipping
+        # @param routing_context [Hash] Additional routing context
+        # @return [Decision]
+        def self.skip(reason, **routing_context)
+          new('no_branches', [], reason, routing_context)
+        end
+      end
+
+      # ========================================================================
+      # Helper: BatchConfig
+      # ========================================================================
+
+      # Configuration returned by batch analyzer handlers.
+      #
+      # @example
+      #   batch_analyzer "analyze_orders", worker_template: "process_batch" do |context:|
+      #     BatchConfig.new(total_items: 250, batch_size: 100)
+      #   end
+      class BatchConfig
+        attr_reader :total_items, :batch_size, :metadata
+
+        # @param total_items [Integer] Total number of items to process
+        # @param batch_size [Integer] Size of each batch
+        # @param metadata [Hash] Optional metadata
+        def initialize(total_items:, batch_size:, metadata: {})
+          @total_items = total_items
+          @batch_size = batch_size
+          @metadata = metadata
+          freeze
+        end
+      end
+
+      # ========================================================================
+      # Internal: Auto-wrapping
+      # ========================================================================
+
+      module_function
+
+      # @api private
+      def _wrap_result(result)
+        case result
+        when Types::StepHandlerCallResult::Success,
+             Types::StepHandlerCallResult::Error,
+             Types::StepHandlerCallResult::CheckpointYield
+          result
+        when Hash
+          Types::StepHandlerCallResult.success(result: result)
+        when nil
+          Types::StepHandlerCallResult.success(result: {})
+        else
+          Types::StepHandlerCallResult.success(result: result.respond_to?(:to_h) ? result.to_h : {})
+        end
+      end
+
+      # @api private
+      def _wrap_exception(exception)
+        Types::StepHandlerCallResult.from_exception(exception)
+      end
+
+      # @api private
+      def _inject_args(context, depends_on, inputs)
+        args = { context: context }
+
+        depends_on.each do |param_name, value|
+          if value.is_a?(Array) && value.length == 2
+            step_name, model_cls = value
+            raw = context.get_dependency_result(step_name.to_s)
+            args[param_name.to_sym] = if raw.is_a?(Hash)
+                                        # Convert to plain Hash first — ActiveSupport::HashWithIndifferentAccess
+                                        # stores keys as strings internally even after transform_keys(&:to_sym),
+                                        # which causes Dry::Struct to silently ignore all attributes.
+                                        # Hash() is a no-op on HWIA (since it IS-A Hash); .to_h produces
+                                        # a true plain Hash so symbol keys actually stick.
+                                        symbolized = raw.to_h.transform_keys(&:to_sym)
+                                        known = model_cls.attribute_names
+                                        model_cls.new(**symbolized.slice(*known))
+                                      else
+                                        raw
+                                      end
+          else
+            args[param_name.to_sym] = context.get_dependency_result(value.to_s)
+          end
+        end
+
+        if inputs.is_a?(Class)
+          model_data = {}
+          inputs.attribute_names.each do |attr_name|
+            model_data[attr_name] = context.get_input(attr_name.to_s)
+          end
+          args[:inputs] = inputs.new(**model_data.compact)
+          args[:inputs].validate! if args[:inputs].respond_to?(:validate!)
+        else
+          Array(inputs).each do |input_key|
+            args[input_key.to_sym] = context.get_input(input_key.to_s)
+          end
+        end
+
+        args
+      end
+
+      # ========================================================================
+      # Public DSL Methods
+      # ========================================================================
+
+      # Define a step handler from a block.
+      #
+      # Returns a StepHandler::Base subclass that can be registered with HandlerRegistry.
+      # The block receives injected dependencies, inputs, and context as keyword arguments.
+      # Return values are auto-wrapped as success results, and exceptions are
+      # auto-classified as failure results.
+      #
+      # @param name [String] Handler name (must match step definition)
+      # @param depends_on [Hash] Mapping of parameter names to dependency step names
+      # @param inputs [Array<Symbol, String>] Task context input keys to inject
+      # @param version [String] Handler version (default: "1.0.0")
+      # @yield [**args] Block receiving dependencies, inputs, and context as keyword args
+      # @return [Class] StepHandler::Base subclass
+      #
+      # @example
+      #   ProcessPayment = step_handler "process_payment",
+      #     depends_on: { cart: "validate_cart" },
+      #     inputs: [:payment_info] do |cart:, payment_info:, context:|
+      #
+      #     raise TaskerCore::Errors::PermanentError, "Payment info required" unless payment_info
+      #     result = charge_card(payment_info, cart["total"])
+      #     { payment_id: result["id"], amount: cart["total"] }
+      #   end
+      def step_handler(name, depends_on: {}, inputs: [], version: '1.0.0', &block)
+        raise ArgumentError, 'block required' unless block
+
+        handler_depends = depends_on
+        handler_inputs = inputs
+        handler_block = block
+
+        Class.new(Base) do
+          const_set(:VERSION, version)
+
+          define_method(:handler_name) { name }
+
+          define_method(:call) do |context|
+            args = Functional._inject_args(context, handler_depends, handler_inputs)
+            result = handler_block.call(**args)
+            Functional._wrap_result(result)
+          rescue StandardError => e
+            Functional._wrap_exception(e)
+          end
+        end
+      end
+
+      # Define a decision handler from a block.
+      #
+      # The block should return a `Decision.route(...)` or `Decision.skip(...)`.
+      #
+      # @param name [String] Handler name
+      # @param depends_on [Hash] Mapping of parameter names to dependency step names
+      # @param inputs [Array<Symbol, String>] Task context input keys to inject
+      # @param version [String] Handler version (default: "1.0.0")
+      # @yield [**args] Block returning a Decision
+      # @return [Class] StepHandler::Base subclass with decision capabilities
+      #
+      # @example
+      #   RouteOrder = decision_handler "route_order",
+      #     depends_on: { order: "validate_order" } do |order:, context:|
+      #     if order["tier"] == "premium"
+      #       Decision.route(["process_premium"], tier: "premium")
+      #     else
+      #       Decision.route(["process_standard"])
+      #     end
+      #   end
+      def decision_handler(name, depends_on: {}, inputs: [], version: '1.0.0', &block)
+        raise ArgumentError, 'block required' unless block
+
+        handler_depends = depends_on
+        handler_inputs = inputs
+        handler_block = block
+
+        Class.new(Base) do
+          include Mixins::Decision
+
+          const_set(:VERSION, version)
+
+          define_method(:handler_name) { name }
+
+          define_method(:call) do |context|
+            args = Functional._inject_args(context, handler_depends, handler_inputs)
+            raw_result = handler_block.call(**args)
+
+            case raw_result
+            when Types::StepHandlerCallResult::Success,
+                 Types::StepHandlerCallResult::Error
+              raw_result
+            when Decision
+              result_data = {}
+              if raw_result.type == 'create_steps'
+                result_data[:routing_context] = raw_result.routing_context unless raw_result.routing_context.empty?
+                decision_success(steps: raw_result.steps, result_data: result_data)
+              else
+                result_data[:reason] = raw_result.reason if raw_result.reason
+                result_data[:routing_context] = raw_result.routing_context unless raw_result.routing_context.empty?
+                decision_no_branches(result_data: result_data)
+              end
+            else
+              Functional._wrap_result(raw_result)
+            end
+          rescue StandardError => e
+            Functional._wrap_exception(e)
+          end
+        end
+      end
+
+      # Define a batch analyzer handler.
+      #
+      # The block should return a `BatchConfig` with `total_items` and `batch_size`.
+      # Cursor configs are generated automatically.
+      #
+      # @param name [String] Handler name
+      # @param worker_template [String] Name of the worker template step
+      # @param depends_on [Hash] Mapping of parameter names to dependency step names
+      # @param inputs [Array<Symbol, String>] Task context input keys to inject
+      # @param version [String] Handler version (default: "1.0.0")
+      # @yield [**args] Block returning a BatchConfig
+      # @return [Class] StepHandler::Base subclass
+      #
+      # @example
+      #   AnalyzeOrders = batch_analyzer "analyze_orders",
+      #     worker_template: "process_batch" do |context:|
+      #     BatchConfig.new(total_items: 250, batch_size: 100)
+      #   end
+      def batch_analyzer(name, worker_template:, depends_on: {}, inputs: [], version: '1.0.0', &block)
+        raise ArgumentError, 'block required' unless block
+
+        handler_depends = depends_on
+        handler_inputs = inputs
+        handler_block = block
+        handler_worker_template = worker_template
+
+        Class.new(Base) do
+          include Mixins::Batchable
+
+          const_set(:VERSION, version)
+
+          define_method(:handler_name) { name }
+
+          define_method(:call) do |context|
+            args = Functional._inject_args(context, handler_depends, handler_inputs)
+            raw_result = handler_block.call(**args)
+
+            case raw_result
+            when Types::StepHandlerCallResult::Success,
+                 Types::StepHandlerCallResult::Error
+              raw_result
+            when BatchConfig
+              total_items = raw_result.total_items
+              batch_size = raw_result.batch_size
+              worker_count = (total_items.to_f / batch_size).ceil
+
+              cursor_configs = create_cursor_configs(total_items, worker_count)
+
+              create_batches_outcome(
+                worker_template_name: handler_worker_template,
+                cursor_configs: cursor_configs,
+                total_items: total_items,
+                metadata: raw_result.metadata
+              )
+            else
+              Functional._wrap_result(raw_result)
+            end
+          rescue StandardError => e
+            Functional._wrap_exception(e)
+          end
+        end
+      end
+
+      # Define a batch worker handler.
+      #
+      # The block receives a `batch_context` keyword argument extracted from the
+      # step context, containing cursor configuration for this worker's partition.
+      #
+      # @param name [String] Handler name
+      # @param depends_on [Hash] Mapping of parameter names to dependency step names
+      # @param inputs [Array<Symbol, String>] Task context input keys to inject
+      # @param version [String] Handler version (default: "1.0.0")
+      # @yield [**args] Block receiving batch_context and other injected args
+      # @return [Class] StepHandler::Base subclass
+      #
+      # @example
+      #   ProcessBatch = batch_worker "process_batch" do |batch_context:, context:|
+      #     cursor = batch_context&.dig(:cursor_config)
+      #     # process items from cursor[:start_cursor] to cursor[:end_cursor]
+      #     { processed: true }
+      #   end
+      def batch_worker(name, depends_on: {}, inputs: [], version: '1.0.0', &block)
+        raise ArgumentError, 'block required' unless block
+
+        handler_depends = depends_on
+        handler_inputs = inputs
+        handler_block = block
+
+        Class.new(Base) do
+          include Mixins::Batchable
+
+          const_set(:VERSION, version)
+
+          define_method(:handler_name) { name }
+
+          define_method(:call) do |context|
+            args = Functional._inject_args(context, handler_depends, handler_inputs)
+
+            # Delegate batch context extraction to Batchable mixin
+            args[:batch_context] = get_batch_context(context)
+
+            result = handler_block.call(**args)
+            Functional._wrap_result(result)
+          rescue StandardError => e
+            Functional._wrap_exception(e)
+          end
+        end
+      end
+
+      # Define an API handler from a block.
+      #
+      # The block receives an `api` keyword argument that provides pre-configured
+      # HTTP methods (get, post, put, delete) and result helpers (api_success,
+      # api_failure) from the API mixin, in addition to any declared dependencies,
+      # inputs, and context.
+      #
+      # @param name [String] Handler name (must match step definition)
+      # @param base_url [String] Base URL for API calls
+      # @param depends_on [Hash] Mapping of parameter names to dependency step names
+      # @param inputs [Array<Symbol, String>] Task context input keys to inject
+      # @param version [String] Handler version (default: "1.0.0")
+      # @param timeout [Integer, nil] Request timeout in seconds
+      # @param open_timeout [Integer, nil] Connection open timeout in seconds
+      # @param headers [Hash] Default headers for all requests
+      # @yield [**args] Block receiving api, dependencies, inputs, and context as keyword args
+      # @return [Class] StepHandler::Base subclass with API capabilities
+      #
+      # @example
+      #   FetchUser = api_handler "fetch_user",
+      #     base_url: "https://api.example.com",
+      #     depends_on: { user_id: "validate_user" } do |user_id:, api:, context:|
+      #
+      #     response = api.get("/users/#{user_id}")
+      #     body = JSON.parse(response.body)
+      #     api.api_success(data: body, status: response.status)
+      #   end
+      def api_handler(name, base_url:, depends_on: {}, inputs: [], version: '1.0.0',
+                      timeout: nil, open_timeout: nil, headers: {}, &block)
+        raise ArgumentError, 'block required' unless block
+
+        handler_depends = depends_on
+        handler_inputs = inputs
+        handler_block = block
+        handler_base_url = base_url
+        handler_timeout = timeout
+        handler_open_timeout = open_timeout
+        handler_headers = headers
+
+        Class.new(Base) do
+          include Mixins::API
+
+          const_set(:VERSION, version)
+
+          define_method(:handler_name) { name }
+
+          define_method(:initialize) do
+            super(config: {
+              url: handler_base_url,
+              timeout: handler_timeout,
+              open_timeout: handler_open_timeout,
+              headers: handler_headers
+            }.compact)
+          end
+
+          define_method(:call) do |context|
+            args = Functional._inject_args(context, handler_depends, handler_inputs)
+            args[:api] = self
+            result = handler_block.call(**args)
+            Functional._wrap_result(result)
+          rescue StandardError => e
+            Functional._wrap_exception(e)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tasker_core/step_handler/mixins.rb

@@ -53,6 +53,7 @@
 require_relative 'mixins/api'
 require_relative 'mixins/decision'
 require_relative 'mixins/batchable'
+require_relative 'functional'
 
 module TaskerCore
   module StepHandler

data/lib/tasker_core/template_discovery.rb

@@ -94,11 +94,6 @@ module TaskerCore
         def extract_handlers_from_template(template_data)
           handlers = []
 
-          # Add task handler if present
-          if template_data['task_handler'] && template_data['task_handler']['callable']
-            handlers << template_data['task_handler']['callable']
-          end
-
           # Add step handlers
           if template_data['steps'].is_a?(Array)
             template_data['steps'].each do |step|

data/lib/tasker_core/types/task_template.rb

@@ -139,7 +139,6 @@ module TaskerCore
 
     # Environment-specific overrides
     class EnvironmentOverride < Dry::Struct
-      attribute :task_handler, HandlerOverride.optional.default(nil)
       attribute :steps, Types::Array.of(StepOverride).default([].freeze)
     end
 
@@ -156,7 +155,6 @@ module TaskerCore
       # Self-describing structure
       attribute :description, Types::String.optional.default(nil)
       attribute :metadata, TemplateMetadata.optional.default(nil)
-      attribute :task_handler, HandlerDefinition.optional.default(nil)
       attribute(:system_dependencies, SystemDependencies.default { SystemDependencies.new })
       attribute :domain_events, Types::Array.of(DomainEventDefinition).default([].freeze)
       attribute :input_schema, Types::Hash.optional.default(nil) # JSON Schema
@@ -173,10 +171,7 @@ module TaskerCore
 
       # Extract all callable references
       def all_callables
-        callables = []
-        callables << task_handler.callable if task_handler
-        steps.each { |step| callables << step.handler.callable }
-        callables
+        steps.map { |step| step.handler.callable }
       end
 
       # Check if template is valid for registration
@@ -197,11 +192,6 @@ module TaskerCore
         if environments[environment_name]
           env_override = environments[environment_name]
 
-          # Apply task handler overrides
-          if env_override.task_handler && resolved_template.task_handler && env_override.task_handler.initialization
-            resolved_template.task_handler.initialization.merge!(env_override.task_handler.initialization)
-          end
-
           # Apply step overrides
           env_override.steps.each do |step_override|
             if step_override.name == 'ALL'

data/lib/tasker_core/version.rb

@@ -3,7 +3,7 @@
 module TaskerCore
   # Version synchronization with the core Rust crate
   # This should be kept in sync with the Cargo.toml version
-  VERSION = '0.1.5'
+  VERSION = '0.1.7'
 
   def self.version_info
     {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tasker-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Pete Taylor
@@ -263,12 +263,12 @@ files:
 - lib/tasker_core/step_handler/base.rb
 - lib/tasker_core/step_handler/batchable.rb
 - lib/tasker_core/step_handler/decision.rb
+- lib/tasker_core/step_handler/functional.rb
 - lib/tasker_core/step_handler/mixins.rb
 - lib/tasker_core/step_handler/mixins/api.rb
 - lib/tasker_core/step_handler/mixins/batchable.rb
 - lib/tasker_core/step_handler/mixins/decision.rb
 - lib/tasker_core/subscriber.rb
-- lib/tasker_core/task_handler/base.rb
 - lib/tasker_core/template_discovery.rb
 - lib/tasker_core/tracing.rb
 - lib/tasker_core/types.rb

data/lib/tasker_core/task_handler/base.rb

@@ -1,254 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'logger'
-require 'securerandom'
-
-module TaskerCore
-  module TaskHandler
-    class Base
-      # Ruby task handler for pgmq-based orchestration
-      #
-      # This class provides a simplified interface for task processing using the new
-      # pgmq architecture. Instead of TCP commands, it uses direct pgmq communication
-      # and the embedded orchestrator for step enqueueing.
-      #
-      # Key changes from TCP architecture:
-      # - No command_client dependencies
-      # - Direct pgmq messaging for task initialization
-      # - Embedded orchestrator for step enqueueing
-      # - Simplified error handling and validation
-
-      attr_reader :logger, :task_config
-
-      def initialize(task_config_path: nil, task_config: nil)
-        @logger = TaskerCore::Logger.instance
-        @task_config = task_config || (task_config_path ? load_task_config_from_path(task_config_path) : {})
-        @pgmq_client = nil # Lazy initialization to avoid database connection during setup
-      end
-
-      # Get or create pgmq client (lazy initialization)
-      # @return [TaskerCore::Messaging::PgmqClient] pgmq client instance
-      def pgmq_client
-        @pgmq_client ||= TaskerCore::Messaging::PgmqClient.new
-      end
-
-      # Main task processing method - Rails engine signature: handle(task_uuid)
-      #
-      # Mode-aware processing: Uses embedded FFI orchestrator in embedded mode,
-      # or pure pgmq communication in distributed mode.
-      #
-      # @param task_uuid [Integer] ID of the task to process
-      # @return [Hash] Result of step enqueueing operation
-      def handle(task_uuid)
-        unless task_uuid.is_a?(Integer)
-          raise TaskerCore::Errors::ValidationError.new('task_uuid is required and must be an integer', :task_uuid)
-        end
-
-        mode = orchestration_mode
-        logger.info "🚀 Processing task #{task_uuid} with pgmq orchestration (#{mode} mode)"
-
-        case mode
-        when 'embedded'
-          handle_embedded_mode(task_uuid)
-        when 'distributed'
-          handle_distributed_mode(task_uuid)
-        else
-          raise TaskerCore::Errors::OrchestrationError,
-                "Unknown orchestration mode: #{mode}. Expected 'embedded' or 'distributed'"
-        end
-      rescue TaskerCore::Errors::OrchestrationError => e
-        logger.error "❌ Orchestration error for task #{task_uuid}: #{e.message}"
-        {
-          success: false,
-          task_uuid: task_uuid,
-          error: e.message,
-          error_type: 'OrchestrationError',
-          architecture: 'pgmq',
-          processed_at: Time.now.utc.iso8601
-        }
-      rescue StandardError => e
-        logger.error "❌ Unexpected error processing task #{task_uuid}: #{e.class.name}: #{e.message}"
-        {
-          success: false,
-          task_uuid: task_uuid,
-          error: e.message,
-          error_type: e.class.name,
-          architecture: 'pgmq',
-          processed_at: Time.now.utc.iso8601
-        }
-      end
-
-      # Initialize a new task with workflow steps
-      #
-      # In the pgmq architecture, this sends a task request message to the orchestration
-      # core monitored task_requests_queue, which will be processed by the Rust orchestrator
-      # to create the task record and enqueue initial steps.
-      #
-      # @param task_request [Hash] Task initialization data
-      # @return [void] No return value - operation is async via pgmq
-      def initialize_task(task_request)
-        logger.info '🚀 Initializing task with pgmq architecture'
-
-        task_request = TaskerCore::Types::TaskTypes::TaskRequest.from_hash(task_request)
-
-        # Prepare task request message for pgmq
-        task_request_message = {
-          message_type: 'task_request',
-          task_request: task_request.to_ffi_hash,
-          enqueued_at: Time.now.utc.iso8601,
-          message_id: SecureRandom.uuid
-        }
-
-        # Send message to task_requests_queue for orchestration core processing
-        begin
-          pgmq_client.send_message('task_requests_queue', task_request_message)
-          logger.info "✅ Task request sent to orchestration queue: #{task_request.namespace}/#{task_request.name}"
-
-          # Return void - this is now an async operation
-          nil
-        rescue StandardError => e
-          logger.error "❌ Failed to send task request to orchestration queue: #{e.message}"
-          raise TaskerCore::Errors::OrchestrationError, "Failed to send task request: #{e.message}"
-        end
-      rescue TaskerCore::Errors::ValidationError => e
-        logger.error "❌ Validation error initializing task: #{e.message}"
-        raise e
-      rescue StandardError => e
-        logger.error "❌ Unexpected error initializing task: #{e.class.name}: #{e.message}"
-        raise TaskerCore::Errors::OrchestrationError, "Task initialization failed: #{e.message}"
-      end
-
-      # Check if the pgmq orchestration system is available and ready
-      # @return [Boolean] true if system is ready for task processing
-      def orchestration_ready?
-        orchestrator = TaskerCore.embedded_orchestrator
-        orchestrator.running?
-      rescue StandardError => e
-        logger.warn "⚠️ Failed to check orchestration status: #{e.message}"
-        false
-      end
-
-      # Get status information for this task handler
-      # @return [Hash] Status information including mode and pgmq connectivity
-      def status
-        mode = orchestration_mode
-
-        # Check pgmq availability without forcing connection
-        pgmq_available = begin
-          !pgmq_client.nil?
-        rescue TaskerCore::Errors::Error => e
-          logger.debug "🔍 PGMQ not available: #{e.message}"
-          false
-        end
-
-        status_info = {
-          handler_type: 'TaskHandler::Base',
-          architecture: 'pgmq',
-          orchestration_mode: mode,
-          orchestration_ready: orchestration_ready?,
-          pgmq_available: pgmq_available,
-          task_config_loaded: !task_config.empty?,
-          checked_at: Time.now.utc.iso8601
-        }
-
-        # Include embedded orchestrator status only in embedded mode
-        status_info[:embedded_orchestrator] = embedded_orchestrator_status if mode == 'embedded'
-
-        status_info
-      end
-
-      private
-
-      def load_task_config_from_path(path)
-        return {} unless path && File.exist?(path)
-
-        YAML.load_file(path)
-      rescue StandardError => e
-        logger.warn "Error loading task configuration: #{e.message}"
-        {}
-      end
-
-      def embedded_orchestrator_status
-        orchestrator = TaskerCore.embedded_orchestrator
-        {
-          running: orchestrator.running?,
-          namespaces: orchestrator.namespaces,
-          started_at: orchestrator.started_at&.iso8601
-        }
-      rescue StandardError => e
-        logger.warn "⚠️ Failed to get embedded orchestrator status: #{e.message}"
-        { running: false, error: e.message }
-      end
-
-      # Determine orchestration mode from configuration
-      # @return [String] 'embedded' or 'distributed'
-      def orchestration_mode
-        config = TaskerCore::Config.instance
-        mode = config.orchestration_config.mode
-
-        # Default to embedded mode if not specified or in test environment
-        if mode.nil?
-          if config.test_environment?
-            'embedded'
-          else
-            'distributed'
-          end
-        else
-          mode
-        end
-      rescue StandardError => e
-        logger.warn "⚠️ Failed to determine orchestration mode: #{e.message}, defaulting to distributed"
-        'distributed'
-      end
-
-      # Handle task processing in embedded mode using FFI orchestrator
-      # @param task_uuid [Integer] ID of the task to process
-      # @return [Hash] Result of step enqueueing operation
-      def handle_embedded_mode(task_uuid)
-        # Use embedded orchestrator to enqueue ready steps for the task
-        orchestrator = TaskerCore.embedded_orchestrator
-
-        unless orchestrator.running?
-          raise TaskerCore::Errors::OrchestrationError,
-                'Embedded orchestration system not running. Call TaskerCore.start_embedded_orchestration! first.'
-        end
-
-        # Enqueue steps for the task - this will publish step messages to appropriate queues
-        result = orchestrator.enqueue_steps(task_uuid)
-
-        logger.info "✅ Task #{task_uuid} step enqueueing completed (embedded): #{result}"
-
-        {
-          success: true,
-          task_uuid: task_uuid,
-          message: result,
-          mode: 'embedded',
-          architecture: 'pgmq',
-          processed_at: Time.now.utc.iso8601
-        }
-      end
-
-      # Handle task processing in distributed mode using pure pgmq
-      # @param task_uuid [Integer] ID of the task to process
-      # @return [Hash] Result of step enqueueing operation
-      def handle_distributed_mode(task_uuid)
-        # In distributed mode, we don't directly enqueue steps via FFI
-        # Instead, we could publish a task processing request to a queue
-        # For now, return a message indicating distributed mode handling
-
-        logger.info "✅ Task #{task_uuid} queued for distributed processing"
-
-        {
-          success: true,
-          task_uuid: task_uuid,
-          message: 'Task queued for distributed orchestration processing',
-          mode: 'distributed',
-          architecture: 'pgmq',
-          processed_at: Time.now.utc.iso8601,
-          note: 'Phase 4.5 will complete distributed orchestration integration'
-        }
-      end
-    end
-  end
-end