decouplio 1.0.0alpha7 → 1.0.0rc

data/lib/decouplio/new_flow.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+module Decouplio
+  class NewFlow
+    def self.call(logic)
+      logic_container_raw_data = Class.new(Decouplio::LogicDsl, &logic)
+
+      steps = logic_container_raw_data.steps
+
+      compose_steps(steps.delete_at(0), steps)
+    end
+
+    def self.compose_steps(stp, steps)
+      return stp if stp.nil?
+
+      Decouplio::StepValidator.call(stp, steps)
+
+      if stp.is_a?(Decouplio::Steps::BaseOcto)
+        next_success_step, success_resolver = compose_flow_direction(stp, steps, :success)
+        next_failure_step, failure_resolver = compose_flow_direction(stp, steps, :failure)
+        next_on_error, on_error_resolver = compose_flow_direction(stp, steps, :error)
+
+        stp._add_next_steps([next_success_step, next_failure_step, next_on_error])
+        stp._add_resolvers([success_resolver, failure_resolver, on_error_resolver])
+
+        compose_octo(stp, steps)
+      elsif Decouplio::Const::Flows::RESQ_CLASSES.include?(stp.class)
+        next_success_step, success_resolver = compose_flow_direction(stp.step_to_resq, steps, :success)
+        next_failure_step, failure_resolver = compose_flow_direction(stp.step_to_resq, steps, :failure)
+        next_on_error, on_error_resolver = compose_flow_direction(stp.step_to_resq, steps, :error)
+
+        stp.step_to_resq._add_next_steps([next_success_step, next_failure_step, next_on_error])
+        stp.step_to_resq._add_resolvers([success_resolver, failure_resolver, on_error_resolver])
+
+        compose_wrap(stp.step_to_resq) if stp.step_to_resq.is_a?(Decouplio::Steps::BaseWrap)
+
+        # next_success_step, success_resolver = compose_flow_direction(stp.step_to_resq, steps, :success)
+        # next_failure_step, failure_resolver = compose_flow_direction(stp.step_to_resq, steps, :failure)
+        # next_on_error, on_error_resolver = compose_flow_direction(stp.step_to_resq, steps, :error)
+
+        # stp.step_to_resq._add_next_steps([next_success_step, next_failure_step, next_on_error])
+        # stp.step_to_resq._add_resolvers([success_resolver, failure_resolver, on_error_resolver])
+      elsif stp.is_a?(Decouplio::Steps::BaseWrap)
+        compose_wrap(stp)
+        compose_step(stp, steps)
+      else
+        compose_step(stp, steps)
+      end
+
+      next_step_to_process = steps.delete_at(0)
+      compose_steps(next_step_to_process, steps)
+      stp
+    end
+
+    def self.compose_wrap(stp)
+      wrap_first_step = call(stp.wrap_block)
+      stp._add_wrap_first_step(wrap_first_step)
+    end
+
+    def self.compose_octo(stp, steps)
+      linked_hash_case = stp.hash_case.to_h do |key, octo_step|
+        if octo_step.on_success.nil?
+          next_success_step = stp.on_success
+          success_resolver = stp.on_success_resolver
+        else
+          next_success_step, success_resolver = compose_flow_direction(octo_step, steps, :success)
+        end
+
+        if octo_step.on_failure.nil?
+          next_failure_step = stp.on_failure
+          failure_resolver = stp.on_failure_resolver
+        else
+          next_failure_step, failure_resolver = compose_flow_direction(octo_step, steps, :failure)
+        end
+
+        if octo_step.on_error.nil?
+          next_on_error = stp.on_error
+          on_error_resolver = stp.on_error_resolver
+        else
+          next_on_error, on_error_resolver = compose_flow_direction(octo_step, steps, :error)
+        end
+
+        compose_wrap(octo_step)
+
+        octo_step._add_next_steps(
+          [
+            next_success_step,
+            next_failure_step,
+            next_on_error
+          ]
+        )
+        octo_step._add_resolvers(
+          [
+            success_resolver,
+            failure_resolver,
+            on_error_resolver
+          ]
+        )
+
+        if stp.resq
+          octo_resq_step = stp.resq.clone
+          octo_resq_step._add_step_to_resq(octo_step)
+          [key, octo_resq_step]
+        else
+          [key, octo_step]
+        end
+      end
+
+      stp._add_octo_next_steps(linked_hash_case)
+    end
+
+    def self.compose_step(stp, steps)
+      next_success_step, success_resolver = compose_flow_direction(stp, steps, :success)
+      next_failure_step, failure_resolver = compose_flow_direction(stp, steps, :failure)
+
+      stp._add_next_steps([next_success_step, next_failure_step])
+      stp._add_resolvers([success_resolver, failure_resolver])
+    end
+
+    def self.compose_flow_direction(stp, steps, type)
+      case stp
+      when Decouplio::Steps::Step,
+           Decouplio::Steps::InnerActionStep,
+           Decouplio::Steps::ServiceAsStep
+        compose_step_outcome("for_step_#{type}".to_sym, stp, steps)
+      when Decouplio::Steps::Fail,
+           Decouplio::Steps::InnerActionFail,
+           Decouplio::Steps::ServiceAsFail
+        compose_step_outcome("for_fail_#{type}".to_sym, stp, steps)
+      when Decouplio::Steps::Pass,
+           Decouplio::Steps::InnerActionPass,
+           Decouplio::Steps::ServiceAsPass
+        compose_step_outcome("for_pass_#{type}".to_sym, stp, steps)
+      when Decouplio::Steps::IfConditionPass
+        compose_condition_outcome("for_if_pass_#{type}".to_sym, stp, steps)
+      when Decouplio::Steps::IfConditionFail
+        compose_condition_outcome("for_if_fail_#{type}".to_sym, stp, steps)
+      when Decouplio::Steps::UnlessConditionPass
+        compose_condition_outcome("for_unless_pass_#{type}".to_sym, stp, steps)
+      when Decouplio::Steps::UnlessConditionFail
+        compose_condition_outcome("for_unless_fail_#{type}".to_sym, stp, steps)
+      when Decouplio::Steps::Wrap,
+           Decouplio::Steps::WrapWithClass,
+           Decouplio::Steps::WrapWithClassMethod
+        compose_step_outcome("for_wrap_#{type}".to_sym, stp, steps)
+      when Decouplio::Steps::BaseOcto
+        compose_step_outcome("for_octo_#{type}".to_sym, stp, steps)
+      end
+    end
+
+    def self.compose_step_outcome(flow, stp, steps)
+      case flow
+      when :for_fail_success
+        return [nil, false] if stp.finish_him == true
+        return [nil, false] if stp.finish_him == :on_success
+        return [next_failure_step(steps), false] if stp.on_success.nil?
+        return [nil, false] if stp.on_success == :finish_him
+        return [next_success_step(steps), true] if stp.on_success == :PASS
+        return [next_failure_step(steps), false] if stp.on_success == :FAIL
+
+        [next_step(stp.on_success, steps), false]
+      when :for_fail_failure
+        return [nil, false] if stp.finish_him == true
+        return [nil, false] if stp.finish_him == :on_failure
+        return [next_failure_step(steps), false] if stp.on_failure.nil?
+        return [nil, false] if stp.on_failure == :finish_him
+        return [next_success_step(steps), true] if stp.on_failure == :PASS
+        return [next_failure_step(steps), false] if stp.on_failure == :FAIL
+
+        [next_step(stp.on_failure, steps), false]
+      when :for_pass_success
+        return [nil, true] if stp.finish_him == true
+
+        [next_success_step(steps), true]
+      when :for_pass_failure
+        [nil, nil]
+      when :for_step_success, :for_wrap_success, :for_octo_success
+        return [nil, true] if stp.finish_him == :on_success
+        return [next_success_step(steps), true] if stp.on_success.nil?
+        return [nil, true] if stp.on_success == :finish_him
+        return [next_success_step(steps), true] if stp.on_success == :PASS
+        return [next_failure_step(steps), false] if stp.on_success == :FAIL
+
+        [next_step(stp.on_success, steps), true]
+      when :for_step_failure, :for_wrap_failure, :for_octo_failure
+        return [nil, false] if stp.finish_him == :on_failure
+        return [next_failure_step(steps), false] if stp.on_failure.nil?
+        return [nil, false] if stp.on_failure == :finish_him
+        return [next_success_step(steps), true] if stp.on_failure == :PASS
+        return [next_failure_step(steps), false] if stp.on_failure == :FAIL
+
+        [next_step(stp.on_failure, steps), false]
+      when :for_step_error,
+           :for_fail_error,
+           :for_pass_error,
+           :for_octo_error,
+           :for_wrap_error
+        return [nil, false] if stp.finish_him == :on_error
+        return [next_failure_step(steps), false] if stp.on_error.nil?
+        return [nil, false] if stp.on_error == :finish_him
+        return [next_success_step(steps), true] if stp.on_error == :PASS
+        return [next_failure_step(steps), false] if stp.on_error == :FAIL
+
+        [next_step(stp.on_error, steps), false]
+      end
+    end
+
+    def self.compose_condition_outcome(flow, _stp, steps)
+      case flow
+      when :for_if_pass_success, :for_unless_pass_success
+        [next_success_step(steps), nil]
+      when :for_if_pass_failure, :for_unless_pass_failure
+        [next_success_step(steps[1..]), nil]
+      when :for_if_fail_success, :for_unless_fail_success
+        [next_failure_step(steps), nil]
+      when :for_if_fail_failure, :for_unless_fail_failure
+        [next_failure_step(steps[1..]), nil]
+      end
+    end
+
+    def self.next_success_step(steps)
+      steps.detect do |flow_step|
+        [
+          Decouplio::Steps::Step,
+          Decouplio::Steps::Pass,
+          Decouplio::Steps::IfConditionPass,
+          Decouplio::Steps::UnlessConditionPass,
+          Decouplio::Steps::OctoByKey,
+          Decouplio::Steps::OctoByMethod,
+          Decouplio::Steps::InnerActionStep,
+          Decouplio::Steps::InnerActionPass,
+          Decouplio::Steps::ServiceAsStep,
+          Decouplio::Steps::ServiceAsPass,
+          Decouplio::Steps::ResqPass,
+          Decouplio::Steps::ResqWithMappingPass,
+          Decouplio::Steps::Wrap,
+          Decouplio::Steps::WrapWithClass,
+          Decouplio::Steps::WrapWithClassMethod
+        ].include?(flow_step.class)
+      end
+    end
+
+    def self.next_failure_step(steps)
+      steps.detect do |flow_step|
+        [
+          Decouplio::Steps::Fail,
+          Decouplio::Steps::IfConditionFail,
+          Decouplio::Steps::UnlessConditionFail,
+          Decouplio::Steps::InnerActionFail,
+          Decouplio::Steps::ServiceAsFail,
+          Decouplio::Steps::ResqFail,
+          Decouplio::Steps::ResqWithMappingFail
+        ].include?(flow_step.class)
+      end
+    end
+
+    def self.next_step(step_name, steps)
+      steps.each_with_index do |flow_step, index|
+        if flow_step.name == step_name
+          if [
+            Decouplio::Steps::IfConditionFail,
+            Decouplio::Steps::UnlessConditionFail,
+            Decouplio::Steps::IfConditionPass,
+            Decouplio::Steps::UnlessConditionPass
+          ].include?(steps[index - 1].class)
+            return steps[index - 1]
+          else
+            return flow_step
+          end
+        end
+      end
+      raise StandardError, 'Most likely it is a bug, please create an issue here https://github.com/differencialx/decouplio/issues'
+    end
+
+    def self.validate_wrap(logic_container_raw_data)
+      logic_container_raw_data.steps.map(&:class).each do |step_class|
+        next unless Decouplio::Const::Flows::OCTO_CLASSES.include?(step_class)
+
+        raise Decouplio::Errors::OctoInsideWrapError
+      end
+    end
+  end
+end

data/lib/decouplio/octo_hash_case.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'octo_options_validator'
-
 module Decouplio
   class OctoHashCase
     class << self
@@ -16,9 +14,26 @@ module Decouplio
         @hash_case = {}
       end
 
-      def on(strategy_flow, **options)
-        validate_options(options)
-        @hash_case[strategy_flow] = options
+      def on(octo_case, stp = nil, **options, &block)
+        if stp || block_given?
+          validate_options(options)
+          on_success = options.delete(:on_success)
+          on_failure = options.delete(:on_failure)
+          on_error = options.delete(:on_error)
+          wrap_block = block_given? ? block : proc { step(stp, **options) }
+          @hash_case[octo_case] = Decouplio::Steps::Wrap.new(
+            octo_case,
+            wrap_block,
+            on_success,
+            on_failure,
+            on_error,
+            nil
+          )
+        else
+          raise Decouplio::Errors::OctoCaseIsNotDefinedError.new(
+            errored_option: "on :#{octo_case}"
+          )
+        end
       end
 
       private

data/lib/decouplio/octo_options_validator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'errors/options_validation_error'
-
 module Decouplio
   class OctoOptionsValidator
     def self.call(options:)
@@ -13,77 +11,25 @@ module Decouplio
     end
 
     def call
-      validate_option_keys
-      validate_option_count
+      validate_options unless @options.empty?
     end
 
     private
 
-    def validate_option_keys
-      extra_options = (@options.keys - ON_ALLOWED_OPTIONS)
-      return if extra_options.size.zero?
-
-      raise_validation_error(
-        compose_message(
-          STRATEGY_ON_ERROR_MESSAGE,
-          YELLOW,
-          extra_options,
-          EXTRA_OPTIONS_NOT_ALLOWED % extra_options,
-          ON_ALLOWED_OPTIONS,
-          STRATEGY_MANUAL_URL,
-          NO_COLOR
-        )
-      )
-    end
+    def validate_options
+      has_invalid_options = @options.keys.any? { |key| NOT_ALLOWED_OPTIONS.include?(key) }
 
-    def validate_option_count
-      return if @options.keys.size == 1
+      return unless has_invalid_options
 
-      raise_validation_error(
-        compose_message(
-          STRATEGY_ON_ERROR_MESSAGE,
-          YELLOW,
-          @options,
-          ONLY_ONE_OPTION_PER_TIME_IS_ALLOWED,
-          ON_ALLOWED_OPTIONS,
-          STRATEGY_MANUAL_URL,
-          NO_COLOR
-        )
-      )
+      raise_validation_error
     end
 
-    def raise_validation_error(message)
-      raise Decouplio::Errors::OptionsValidationError, message
-    end
-
-    def compose_message(message, *interpolation_params)
-      message % interpolation_params
+    def raise_validation_error
+      raise Decouplio::Errors::OptionsValidationError.new(
+        errored_option: @options
+      )
     end
 
-    ALLOWED_OPTIONS = %i[palp step].freeze
-    YELLOW = "\033[1;33m"
-    NO_COLOR = "\033[0m"
-    STRATEGY_ON_ERROR_MESSAGE = <<~ERROR_MESSAGE
-      %s
-      Next options are not allowed for "on":
-      %s
-
-      Details:
-      %s
-
-      Allowed options are:
-      %s
-
-      Please read the manual about allowed options here:
-      %s
-      %s
-    ERROR_MESSAGE
-    EXTRA_OPTIONS_NOT_ALLOWED = '%s is not allowed for "on"'
-    ONLY_ONE_OPTION_PER_TIME_IS_ALLOWED = 'Only one option is allowed for "on".'
-    ON_ALLOWED_OPTIONS = %i[
-      step
-      palp
-    ].freeze
-    STRATEGY_MANUAL_URL = 'https://stub.strategy.manual.url'
+    NOT_ALLOWED_OPTIONS = %i[finish_him if unless].freeze
   end
 end

data/lib/decouplio/step_validator.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Decouplio
+  class StepValidator
+    def self.call(stp, steps)
+      case stp
+      when Decouplio::Steps::Step
+        validate_name(stp.name)
+        validate_step(stp, steps)
+      when Decouplio::Steps::InnerActionStep, Decouplio::Steps::ServiceAsStep
+        validate_step(stp, steps)
+      when Decouplio::Steps::Fail
+        validate_name(stp.name)
+        validate_fail(stp, steps)
+      when Decouplio::Steps::InnerActionFail, Decouplio::Steps::ServiceAsFail
+        validate_fail(stp, steps)
+      when Decouplio::Steps::Pass
+        validate_name(stp.name)
+        validate_pass(stp, steps)
+      when Decouplio::Steps::ServiceAsPass, Decouplio::Steps::InnerActionPass
+        validate_pass(stp, steps)
+      when Decouplio::Steps::Wrap,
+           Decouplio::Steps::WrapWithClassMethod
+        validate_name(stp.name)
+        validate_finish_him(stp, Decouplio::Errors::WrapFinishHimError)
+        validate_contraversal_key(stp, Decouplio::Errors::WrapControversialKeysError)
+        validate_on_s(stp, steps, Decouplio::Errors::StepIsNotDefinedForWrapError)
+        validate_on_f(stp, steps, Decouplio::Errors::StepIsNotDefinedForWrapError)
+        validate_on_e(stp, steps, Decouplio::Errors::StepIsNotDefinedForWrapError)
+      when Decouplio::Steps::OctoByKey,
+           Decouplio::Steps::OctoByMethod
+        validate_name(stp.name)
+      when Decouplio::Steps::ResqPass,
+           Decouplio::Steps::ResqFail
+        validate_name(stp.name)
+        validate_name(stp.handler_method)
+        call(stp.step_to_resq, steps)
+      when Decouplio::Steps::ResqWithMappingPass,
+           Decouplio::Steps::ResqWithMappingFail
+        validate_name(stp.name)
+        stp.mappings.each do |class_to_handle, handler_method_name|
+          validate_symbol(handler_method_name)
+          validate_name(handler_method_name)
+          validate_class(class_to_handle, handler_method_name)
+          validate_exception_inheritance(class_to_handle)
+        end
+        call(stp.step_to_resq, steps)
+      when Decouplio::Steps::IfConditionPass,
+           Decouplio::Steps::IfConditionFail,
+           Decouplio::Steps::UnlessConditionPass,
+           Decouplio::Steps::UnlessConditionFail
+        validate_name(stp.condition_method)
+      end
+    end
+
+    def self.validate_step(stp, steps)
+      validate_finish_him(stp, Decouplio::Errors::StepFinishHimError)
+      validate_contraversal_key(stp, Decouplio::Errors::StepControversialKeysError)
+      validate_on_s(stp, steps, Decouplio::Errors::StepIsNotDefinedForStepError)
+      validate_on_f(stp, steps, Decouplio::Errors::StepIsNotDefinedForStepError)
+      validate_on_e(stp, steps, Decouplio::Errors::StepIsNotDefinedForStepError)
+    end
+
+    def self.validate_fail(stp, steps)
+      validate_finish_him_for_fail(stp, Decouplio::Errors::FailFinishHimError)
+      validate_contraversal_key(stp, Decouplio::Errors::FailControversialKeysError)
+      validate_on_s(stp, steps, Decouplio::Errors::StepIsNotDefinedForFailError)
+      validate_on_f(stp, steps, Decouplio::Errors::StepIsNotDefinedForFailError)
+      validate_on_e(stp, steps, Decouplio::Errors::StepIsNotDefinedForFailError)
+    end
+
+    def self.validate_pass(stp, steps)
+      validate_finish_him_for_pass(stp, Decouplio::Errors::PassFinishHimError)
+      validate_contraversal_key(stp, Decouplio::Errors::StepControversialKeysError)
+      validate_on_s(stp, steps, Decouplio::Errors::StepIsNotDefinedForPassError)
+      validate_on_f(stp, steps, Decouplio::Errors::StepIsNotDefinedForPassError)
+      validate_on_e(stp, steps, Decouplio::Errors::StepIsNotDefinedForPassError)
+    end
+
+    def self.validate_class(class_to_handle, handler_method_name)
+      return if class_to_handle.is_a?(Class)
+
+      raise Decouplio::Errors::ResqErrorClassError.new(
+        errored_option: class_to_handle,
+        details: handler_method_name
+      )
+    end
+
+    def self.validate_exception_inheritance(class_to_handle)
+      return if class_to_handle < Exception
+
+      raise Decouplio::Errors::InvalidErrorClassError.new(
+        errored_option: class_to_handle,
+        details: class_to_handle
+      )
+    end
+
+    def self.validate_symbol(stp_name)
+      return if stp_name.is_a?(Symbol)
+
+      raise Decouplio::Errors::ResqHandlerMethodError.new(
+        errored_option: stp_name
+      )
+    end
+
+    def self.validate_name(stp_name)
+      if Decouplio::Const::ReservedMethods::NAMES.include?(stp_name)
+        raise Decouplio::Errors::StepNameError.new(
+          errored_option: stp_name
+        )
+      end
+
+      unless stp_name.is_a?(Symbol) ||
+             (
+               (stp_name.is_a?(Class) && stp_name < Decouplio::Action) ||
+               (stp_name.is_a?(Class) && stp.respond_to?(:call))
+             )
+        raise Decouplio::Errors::StepDefinitionError.new(
+          errored_option: stp_name
+        )
+      end
+    end
+
+    def self.validate_on_s(stp, steps, exception_class)
+      return if [nil, :finish_him, :PASS, :FAIL].include?(stp.on_success)
+      return if steps.any? { |s| s.name == stp.on_success }
+
+      raise exception_class.new(
+        errored_option: { on_success: stp.on_success },
+        details: stp.on_success
+      )
+    end
+
+    def self.validate_on_f(stp, steps, exception_class)
+      return if [nil, :finish_him, :PASS, :FAIL].include?(stp.on_failure)
+      return if steps.any? { |s| s.name == stp.on_failure }
+
+      raise exception_class.new(
+        errored_option: { on_failure: stp.on_failure },
+        details: stp.on_failure
+      )
+    end
+
+    def self.validate_on_e(stp, steps, exception_class)
+      return if [nil, :finish_him, :PASS, :FAIL].include?(stp.on_error)
+      return if steps.any? { |s| s.name == stp.on_error }
+
+      raise exception_class.new(
+        errored_option: { on_error: stp.on_error },
+        details: stp.on_error
+      )
+    end
+
+    def self.validate_finish_him(stp, exception_class)
+      return if [nil, :on_success, :on_failure, :on_error].include?(stp.finish_him)
+
+      raise exception_class.new(
+        errored_option: { finish_him: stp.finish_him },
+        details: stp.finish_him
+      )
+    end
+
+    def self.validate_finish_him_for_fail(stp, exception_class)
+      return if [nil, true, :on_success, :on_failure, :on_error].include?(stp.finish_him)
+
+      raise exception_class.new(
+        errored_option: { finish_him: stp.finish_him },
+        details: stp.finish_him
+      )
+    end
+
+    def self.validate_finish_him_for_pass(stp, exception_class)
+      return if [nil, true, :on_error].include?(stp.finish_him)
+
+      raise exception_class.new(
+        errored_option: { finish_him: stp.finish_him },
+        details: stp.finish_him
+      )
+    end
+
+    def self.validate_contraversal_key(stp, exception_class)
+      if stp.on_success && stp.finish_him
+        raise exception_class.new(
+          errored_option: { on_success: stp.on_success, finish_him: stp.finish_him },
+          details: %i[on_success finish_him]
+        )
+      elsif stp.on_failure && stp.finish_him
+        raise exception_class.new(
+          errored_option: { on_failure: stp.on_failure, finish_him: stp.finish_him },
+          details: %i[on_failure finish_him]
+        )
+      elsif stp.on_error && stp.finish_him
+        raise exception_class.new(
+          errored_option: { on_error: stp.on_error, finish_him: stp.finish_him },
+          details: %i[on_error finish_him]
+        )
+      end
+    end
+  end
+end

data/lib/decouplio/steps/base_condition.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class BaseCondition
+      attr_reader :condition_method
+
+      alias name condition_method
+
+      def initialize(condition_method)
+        @condition_method = condition_method
+      end
+
+      def _add_next_steps(steps)
+        @perform_condition_step, @skip_condition_step = steps
+      end
+
+      def _add_resolvers(_); end
+    end
+  end
+end

data/lib/decouplio/steps/base_if_condition.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class BaseIfCondition < Decouplio::Steps::BaseCondition
+      def process(instance)
+        instance.send(@condition_method) ? @perform_condition_step : @skip_condition_step
+      end
+    end
+  end
+end

data/lib/decouplio/steps/base_inner_action.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Decouplio
+  module Steps
+    class BaseInnerAction
+      attr_reader :name, :on_success, :on_failure, :on_error, :finish_him, :on_error_resolver
+
+      def initialize(name, action_class, on_success, on_failure, on_error, finish_him)
+        @name = name
+        @action_class = action_class
+        @on_success = on_success
+        @on_failure = on_failure
+        @on_error = on_error
+        @finish_him = finish_him
+      end
+
+      def process(instance)
+        instance.railway_flow << @name
+        result = @action_class.call(
+          _parent_meta_store: instance.ms,
+          _parent_railway_flow: instance.railway_flow,
+          _parent_ctx: instance.ctx
+        )
+        if result.success?
+          instance.success = @on_success_resolver
+          @on_success
+        else
+          instance.success = @on_failure_resolver
+          @on_failure
+        end
+      end
+
+      def _add_next_steps(steps)
+        @on_success, @on_failure, @on_error = steps
+      end
+
+      def _add_resolvers(resolvers)
+        @on_success_resolver, @on_failure_resolver = resolvers
+      end
+    end
+  end
+end