use_cases 0.3.8 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad9722f48d9d6f073a9699cb042c246d935994b4384e340e3b985c35ea6a697b
-  data.tar.gz: 8d3cc6daeef1b64fb86a96a9e6ff13a3b95ef328ff2a4e453696cae0724a1572
+  metadata.gz: 0c1ed9f7d86b9109062b207489f37e67f84b93e676d7e81b930f219abbd47224
+  data.tar.gz: 2b9234f7075cb8240836875845d5d61036caa9a3c7feeb72abf31d2dd5830f91
 SHA512:
-  metadata.gz: aefef04cfa79694d593848a6c245ad3d282416fdf28de6a934581f8fa15bfadf1faf5fccf1624a272b997473619af36841464feb8b1f26b6329ee8333a688e4b
-  data.tar.gz: 00bb31d99dfd4e9f1d98d99778b1263e4d32949dc5270af41f78d19dba6a460afeba44797219984dcbe964c516c150e2c0ee1db1392645760de14a7599ae2876
+  metadata.gz: fe3e66534633de66dff8811dad8a3d2c9f0f350d392db60a7e91989d11a861510e32937abc77f47ff8d74b9439a8c6bb321e18d655f655af0778bf676efcc28f
+  data.tar.gz: 4da7071b68b859462feda741591b9862330f9b7dbe5ad127a76ff6052ac13bf7622241620c17a3ef20ee52e6f8b16c67e44b398f01621643df646b6d94759e62

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [1.0.1] - 2021-12-19
+
+- Async published events are now suffixed by `".aync"`
+
+## [1.0.0] - 2021-12-19
+
+- Fixed some minor bugs that have been pending todos.
+- Deprecated the `UseCases::Base` superclass as a DSL injection method. You must now use the `UseCase` module.
+- Added the `publish` option for steps, which allows the publishing of an event when a step is completed.
+
 ## [0.1.0] - 2021-09-21
 
 - Added the basic DSL of them with the following modules:
@@ -9,7 +19,7 @@
   - Notifications [WIP]
   - StackRunner 
   - Stack
-  - StepResult
+  - UseCases::Result
   - Steps
   - Validate
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    use_cases (0.3.7)
+    use_cases (1.0.2)
       activesupport
       dry-events
       dry-matcher

data/README.md

@@ -4,17 +4,17 @@
 
 # UseCases
 
-## Currently Unstable! Use at your own risk.
+`UseCases` is a dry-ecosystem-based gem that implements a DSL for the use case pattern using the railway programming paradigm.
 
-`UseCases` is a gem based on the [dry-transaction](https://dry-rb.org/gems/dry-transaction/) DSL that implements macros commonly used internally by Ring Twice.
-
-`UseCases` does not however use `dry-transaction` behind the scenes. Instead it relies on other `dry` libraries like [dry-validation](https://dry-rb.org/gems/dry-validation/), [dry-events](https://dry-rb.org/gems/dry-validation/) and [dry-monads](https://dry-rb.org/gems/dry-validation/) to implement a DSL that can be flexible enough for our needs.
+It's concept is largely based on `dry-transaction` but does not use it behind the scenes. Instead it relies on other `dry` libraries like [dry-validation](https://dry-rb.org/gems/dry-validation/), [dry-events](https://dry-rb.org/gems/dry-validation/) and [dry-monads](https://dry-rb.org/gems/dry-validation/) to implement a DSL that can be flexible enough for your needs.
 
 ## Why `UseCases` came about:
 
 1. It allows you to use `dry-validation` without much gymastics.
 2. It abstracts common steps like **authorization** and **validation** into macros.
 3. It solves what we consider a problem of `dry-transaction`. The way it funnels down `input` through `Dry::Monads` payloads alone. `UseCases` offers more flexibility in a way that still promotes functional programming values.
+4. It implements a simple pub/sub mechanism which can be async when `ActiveJob` is a project dependency.
+5. It implements an `enqueue` mechanism to delay execution of steps, also using `ActiveJob` as a dependency.
 
 ## Installation
 
@@ -34,25 +34,34 @@ Or install it yourself as:
 
 ## Usage
 
-To fully understand `UseCases`, make sure to read [dry-transaction](https://dry-rb.org/gems/dry-transaction/0.13/)'s documentation first.
+To get a good basis to get started on `UseCases`, make sure to read [dry-transaction](https://dry-rb.org/gems/dry-transaction/0.13/)'s documentation first.
 
 ### Validations
 
 See [dry-validation](https://dry-rb.org/gems/dry-validation/)
 
-### Step Adapters
-
-https://dry-rb.org/gems/dry-transaction/0.13/step-adapters/
+### Creating a Use Case
 
 **Basic Example**
 
 ```ruby
-class YourCase < UseCases::Base
-  params {}
+class DeleteUser
+  include UseCase
+
+  check :current_user_is_user?
+  step :build_user
+  map :persist_user
+
+  private
+
+  def current_user_is_user?(params, current_user)
+  end
+
+  def build_user(params, current_user)
+  end
 
-  step :do_something
 
-  def do_something(params, current_user)
+  def do_something(user, params, current_user)
     params[:should_fail] ? Failure([:failed, "failed"]) : Success("it succeeds!")
   end
 end

data/lib/use_case.rb

@@ -6,20 +6,16 @@ require "dry/monads/do"
 require "dry/monads/do/all"
 require "dry/matcher/result_matcher"
 
-require "use_cases/authorize"
 require "use_cases/dsl"
-require "use_cases/errors"
-require "use_cases/validate"
 require "use_cases/stack"
 require "use_cases/params"
 require "use_cases/stack_runner"
-require "use_cases/step_result"
-require "use_cases/notifications"
-require "use_cases/prepare"
+require "use_cases/result"
 require "use_cases/step_adapters"
 require "use_cases/module_optins"
 
 module UseCase
+  extend UseCases::DSL
   extend UseCases::ModuleOptins
 
   def self.included(base)
@@ -33,7 +29,6 @@ module UseCase
       extend UseCases::ModuleOptins
 
       include UseCases::StepAdapters
-      include UseCases::Notifications
     end
   end
 
@@ -41,7 +36,6 @@ module UseCase
 
   def initialize(*)
     @stack = UseCases::Stack.new(self.class.__steps__).bind(self)
-    # self.class.bind_step_subscriptions
   end
 
   def call(params, current_user = nil)

data/lib/use_cases/dsl.rb

@@ -17,19 +17,5 @@ module UseCases
     def __steps__
       @__steps__ ||= []
     end
-
-    def subscribe(listeners)
-      @listeners = listeners
-
-      if listeners.is_a?(Hash)
-        listeners.each do |step_name, listener|
-          __steps__.detect { |step| step.name == step_name }.subscribe(listener)
-        end
-      else
-        __steps__.each do |step|
-          step.subscribe(listeners)
-        end
-      end
-    end
   end
 end

data/lib/use_cases/events/publish_job.rb

@@ -0,0 +1,19 @@
+
+return unless defined? ActiveJob
+
+module UseCases
+  module Events
+    class PublishJob < ActiveJob::Base
+      def perform(publish_key, payload)
+        publish_key += '.async'
+        UseCases.publisher.publish(publish_key, payload)
+      end
+
+      private
+
+      def publisher
+        UseCases.publisher
+      end
+    end
+  end
+end

data/lib/use_cases/events/publisher.rb

@@ -0,0 +1,9 @@
+require 'dry/events/publisher'
+
+module UseCases
+  module Events
+    class Publisher
+      include Dry::Events::Publisher[:use_cases]
+    end
+  end
+end

data/lib/use_cases/events/subscriber.rb

@@ -0,0 +1,6 @@
+module UseCases
+  module Events
+    class Subscriber
+    end
+  end
+end

data/lib/use_cases/module_optins/authorized.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "use_cases/step_adapters/check"
+
+module UseCases
+  module ModuleOptins
+    module Authorized
+      def self.included(base)
+        super
+        base.class_eval do
+          extend DSL
+        end
+      end
+
+      module DSL
+        DEFAULT_OPTIONS = {
+          failure: :unauthorized,
+          failure_message: "Not Authorized",
+          merge_input_as: :resource
+        }
+
+        def authorize(name, options = {})
+          options = DEFAULT_OPTIONS.merge(options)       
+
+          check name, options
+        end
+      end
+    end
+  end
+end

data/lib/use_cases/module_optins/prepared.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "use_cases/step_adapters/tee"
+
+module UseCases
+  module ModuleOptins
+    module Prepared
+      def self.included(base)
+        super
+        base.class_eval do
+          extend DSL
+        end
+      end
+
+      module DSL
+        def prepare(name, options = {})
+          __steps__.unshift StepAdapters::Tee.new(name, nil, options)
+        end
+      end
+    end
+  end
+end

data/lib/use_cases/module_optins/publishing.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "use_cases/events/publisher"
+require "use_cases/events/subscriber"
+require "use_cases/events/publish_job"
+
+module UseCases
+  module ModuleOptins
+    module Publishing
+      def self.included(base)
+        super
+        base.prepend DoCallPatch
+      end
+
+      module DoCallPatch
+        def do_call(*args)
+          super(*args, method(:publish_step_result).to_proc)
+        end
+
+        def publish_step_result(step_result, step_object)
+          publish_key = step_object.options[:publish]
+          publish_key += step_result.success? ? ".success" : ".failure"
+          payload = step_result.value!
+          return unless publish_key
+
+          register_event(publish_key)
+          peform_publish(publish_key, payload)
+        end
+
+        def register_event(publish_key)
+          return if UseCases.publisher.class.events[publish_key]
+
+          UseCases.publisher.class.register_event(publish_key)
+        end
+
+        def peform_publish(publish_key, payload)
+          UseCases.publisher.publish(publish_key, payload)
+          return unless defined? UseCases::Events::PublishJob
+
+          UseCases::Events::PublishJob.perform_later(publish_key, payload.to_json)
+        end
+      end
+    end
+  end
+end

data/lib/use_cases/module_optins/transactional.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module UseCases
+  module ModuleOptins
+    module Transactional
+      class TransactionHandlerUndefined < StandardError; end
+
+      class TransactionHandlerInvalid < StandardError; end
+
+      def self.included(base)
+        super
+        base.prepend DoCallPatch
+      end
+
+      module DoCallPatch
+        def do_call(*args)
+          unless respond_to?(:transaction_handler)
+            raise TransactionHandlerUndefined, "when using *transactional*, make sure to include a transaction handler in your dependencies."
+          end
+
+          raise TransactionHandlerInvalid, "Make sure your transaction_handler implements #transaction." unless transaction_handler.respond_to?(:transaction)
+
+          transaction_handler.transaction { super }
+        end
+      end
+    end
+  end
+end

data/lib/use_cases/module_optins/validated.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "dry/validation/contract"
+
+module UseCases
+  module ModuleOptins
+    module Validated
+      class NoValidationError < StandardError; end
+
+      def self.included(base)
+        super
+        base.class_eval do
+          extend DSL
+          extend ClassMethods
+          prepend CallPatch
+        end
+      end
+
+      module CallPatch
+        def call(*args)
+          unless stack.include_step?(:validate)
+            raise NoValidationError,
+                  "Make sure to define params validations by using *params*" \
+                  "*schema*, *json*, *rule* or *option* macros in your use case."
+          end
+
+          super
+        end
+      end
+
+      module DSL
+        def params(*args, &blk)
+          _setup_validation
+
+          _contract_class.params(*args, &blk)
+        end
+
+        def schema(*args, &blk)
+          _setup_validation
+
+          _contract_class.schema(*args, &blk)
+        end
+
+        def rule(*args, &blk)
+          _setup_validation
+
+          _contract_class.rule(*args, &blk)
+        end
+
+        def json(*args, &blk)
+          _setup_validation
+
+          _contract_class.json(*args, &blk)
+        end
+
+        def option(*args, &blk)
+          _contract_class.option(*args, &blk)
+        end
+      end
+
+      private
+
+      def validate(params, *_args)
+        return Failure([:validation_error, "*params* must be a hash."]) unless params.respond_to?(:merge)
+
+        validation = contract.call(params)
+
+        if validation.success?
+          params.merge!(validation.to_h)
+          Success(validation.to_h)
+        else
+          Failure([:validation_error, validation.errors.to_h])
+        end
+      end
+
+      def contract
+        return self.class._contract_class.new if self.class._contract_class_defined?
+      end
+
+      module ClassMethods
+        def _setup_validation
+          _define_contract_class unless _contract_class_defined?
+          _define_validation_step unless _validation_step_defined?
+        end
+
+        def _define_validation_step
+          step :validate
+        end
+
+        def _contract_class
+          self::Contract
+        end
+
+        def _define_contract_class
+          const_set(:Contract, Class.new(Dry::Validation::Contract))
+        end
+
+        def _contract_class_name
+          "#{name}::Contract"
+        end
+
+        def _contract_class_defined?
+          Object.const_defined? _contract_class_name
+        end
+
+        def _validation_step_defined?
+          __steps__.map(&:name).include?(:validate)
+        end
+      end
+    end
+  end
+end

data/lib/use_cases/module_optins.rb

@@ -1,39 +1,37 @@
 # frozen_string_literal: true
 
-require "use_cases/authorize"
-require "use_cases/prepare"
-require "use_cases/transaction"
-require "use_cases/validate"
+require "use_cases/module_optins/prepared"
+require "use_cases/module_optins/transactional"
+require "use_cases/module_optins/validated"
+require "use_cases/module_optins/publishing"
+require "use_cases/module_optins/authorized"
 
 module UseCases
   module ModuleOptins
     attr_accessor :options
 
+    OPTINS = {
+      authorized: Authorized,
+      transactional: Transactional,
+      validated: Validated,
+      prepared: Prepared,
+      publishing: Publishing
+    }
+
     def [](*options)
-      @modules = []
-      @modules << UseCases::Authorize if options.include?(:authorized)
-      @modules << UseCases::Transaction if options.include?(:transactional)
-      @modules << UseCases::Validate if options.include?(:validated)
-      @modules << UseCases::Prepare if options.include?(:prepared)
-      self
-    end
+      modules = [self]
 
-    def included(base)
-      super
-      @modules ||= []
-      return if @modules.empty?
+      OPTINS.each do |key, module_constant|
+        modules << module_constant if options.include?(key)
+      end
 
-      base.include(*@modules)
-      @modules = nil
-    end
+      supermodule = Module.new
 
-    def inherited(base)
-      super
-      @modules ||= []
-      return if @modules.empty?
+      supermodule.define_singleton_method(:included) do |base|
+        base.include(*modules)
+      end
 
-      base.include(*@modules)
-      @modules = nil
+      supermodule
     end
 
     def descendants

data/lib/use_cases/{step_result.rb → result.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module UseCases
-  class StepResult < Dry::Monads::Result
+  class Result < Dry::Monads::Result
     attr_reader :step, :result
 
     def initialize(step, result)
@@ -14,7 +14,7 @@ module UseCases
       return result if result_not_monad?
       return nil if result_empty?
 
-      result.success? ? result.value! : result
+      result.success? ? result.value! : result.failure
     end
     alias value! value
 
@@ -23,25 +23,23 @@ module UseCases
     end
 
     def failure?
-      value.is_a?(Dry::Monads::Result::Failure)
-    end
-
-    def failure
-      failure? && value.failure
+      result.is_a?(Dry::Monads::Result::Failure)
     end
 
     def success
       success? && value
     end
 
+    def failure
+      failure? && value
+    end
+
     def nil?
       value.nil?
     end
 
     def to_result
-      value.to_result if failure?
-
-      result
+      self
     end
 
     def result_empty?
@@ -51,5 +49,13 @@ module UseCases
     def result_not_monad?
       !result.is_a?(Dry::Monads::Result)
     end
+
+    def inspect
+      if failure?
+        "UseCases::Result.Failure(#{value.inspect})"
+      else
+        "UseCases::Result.Success(#{value.inspect})"
+      end
+    end
   end
 end

data/lib/use_cases/rspec/matchers.rb

@@ -38,13 +38,15 @@ RSpec::Matchers.define(:be_failure_with) do |*expected_failure|
     expect(test_subject.failure).to eql expected_failure
   end
 
+  expected_result, expected_code = expect_failure
+
   failure_message do |test_subject|
     if test_subject.failure?
-      "the use case was expected to fail with #{expected_result.inspect} but it returned #{test_subject.failure.inspect}"
+      "the use case was expected to fail with #{expected_code} and #{expected_result.inspect} but it returned #{test_subject.failure.inspect}"
     else
       "the use case was expected to fail but it succeeded with #{test_subject.success.inspect}"
     end
-  end    
+  end
 end
 
 RSpec::Matchers.define(:be_successful_with) do |expected_result|
@@ -59,5 +61,5 @@ RSpec::Matchers.define(:be_successful_with) do |expected_result|
     else
       "the use case was expected to succeed but it failed with #{test_subject.failure.inspect}"
     end
-  end    
+  end
 end

data/lib/use_cases/stack_runner.rb

@@ -8,9 +8,7 @@ module UseCases
       @stack = stack
     end
 
-    def call(*args, &around_block)
-      return around_block.call { do_call(*args) } if around_block
-
+    def call(*args)
       do_call(*args)
     end
 
@@ -19,6 +17,7 @@ module UseCases
     def do_call(*args)
       stack.call do
         result = _run_step(stack, args)
+        args.last.call(result, stack.current_step) if args.last.is_a? Proc
 
         return result if result.failure?
 
@@ -28,29 +27,21 @@ module UseCases
 
     def _run_step(stack, args)
       step = stack.current_step
-      expected_args_count = step.args_count
-      step_args = _assert_step_arguments_with_count(stack, args)
+      step_args = _assert_step_arguments(stack, args)
 
       raise MissingStepError, "Missing ##{step.name} implementation." if step.missing?
 
-      if expected_args_count != step_args.count
-        raise StepArgumentError,
-              "##{step.name} expects #{expected_args_count} arguments it only received #{step_args.count}, make sure your previous step Success() statement has a payload."
-      end
-
       step.call(*step_args)
     end
 
-    def _assert_step_arguments_with_count(stack, args)
-      step_args_count = stack.current_step.args_count
-
+    def _assert_step_arguments(stack, args)
       if _should_prepend_previous_step_result_to_args?(stack)
         prev_step_result_value = stack.previous_step_value
 
         args = [prev_step_result_value] + args
       end
 
-      args.first(step_args_count)
+      args
     end
 
     def _should_prepend_previous_step_result_to_args?(stack)

data/lib/use_cases/step_active_job_adapter.rb

@@ -16,7 +16,7 @@ module UseCases
     def deserialize_step_arguments(args)
       args.map do |arg|
         if arg.is_a?(Hash) && arg.delete("_serialized_by_use_case")
-          arg.delete('_class').constantize.new(arg)
+          arg.delete("_class").constantize.new(arg)
         else
           arg
         end

data/lib/use_cases/step_adapters/abstract.rb

@@ -1,21 +1,12 @@
 # frozen_string_literal: true
 
 require "dry/monads/all"
+require "byebug"
 
 module UseCases
   module StepAdapters
     class Abstract
       include Dry::Monads
-
-      # include Dry::Events::Publisher[name || object_id]
-
-      # def self.inherited(subclass)
-      #   super
-      #   subclass.register_event(:step)
-      #   subclass.register_event(:step_succeeded)
-      #   subclass.register_event(:step_failed)
-      # end
-
       include Dry::Monads[:result]
 
       attr_reader :name, :object, :failure, :options
@@ -31,22 +22,11 @@ module UseCases
       end
 
       def call(*args)
-        around_call(name, args: args) do
-          before_call(name, args: args)
-
-          result = StepResult.new(self, do_call(*args))
-
-          if result.success?
-            after_call_success(name, args: args, value: result.value)
-          else
-            after_call_failure(name, args: args, value: result.value)
-          end
-
-          result
-        end
+        UseCases::Result.new(self, do_call(*args))
       end
 
-      def do_call(*args)
+      def do_call(*initial_args)
+        args = callable_args(initial_args)
         callable_proc.call(*args)
       end
 
@@ -54,45 +34,71 @@ module UseCases
         self.class.new(name, object, options)
       end
 
+      def callable_args(args)
+        if callable_args_count > args.count
+          raise StepArgumentError,
+                "##{step.name} expects #{expected_args_count} arguments it only received #{step_args.count}, make sure your previous step Success() statement has a payload."
+        end
+
+        return args.first(callable_args_count) unless external? && selects_external_args?
+
+        hashed_args(args)
+      end
+
+      def hashed_args(args)
+        {
+          params: args.first,
+          current_user: args.last,
+          previous_step_result: args.last
+        }.slice(pass_option)
+      end
+
       def callable_proc
         callable_object.method(callable_method).to_proc
       end
 
       def callable_object
-        case options[:with]
+        case with_option
         when NilClass, FalseClass then object
-        when String, Symbol       then object.send(options[:with])
-        else                           options[:with]
+        when Symbol               then object.send(with_option)
+        when String               then UseCases.config.container[with_option]
+        else                           with_option
         end
       end
 
       def callable_method
-        case options[:with]
+        case with_option
         when NilClass, FalseClass then name
         else                           :call
         end
       end
 
-      def external?
-        options[:with].present?
+      def with_option
+        options[:with]
       end
 
-      def args_count
-        callable_proc.parameters.count
+      def pass_option
+        options[:pass]
       end
 
-      def missing?
-        !callable_object.respond_to?(callable_method, true)
+      def previous_input_param_name
+        options[:merge_input_as] || :input
       end
 
-      def before_call(*args); end
+      def external?
+        with_option.present?
+      end
 
-      def after_call_success(*args); end
+      def selects_external_args?
+        pass_option.present?
+      end
 
-      def after_call_failure(*args); end
+      def callable_args_count
+        callable_proc.parameters.count
+      end
 
-      def around_call(*_args, &blk)
-        blk.call
+      def missing?
+        !callable_object.respond_to?(callable_method, true)
       end
     end
   end

data/lib/use_cases/step_adapters.rb

@@ -11,6 +11,7 @@ require "use_cases/step_active_job_adapter"
 module UseCases
   module StepAdapters
     def self.included(base)
+      super
       base.class_eval do
         register_adapter StepAdapters::Step
         register_adapter StepAdapters::Tee

data/lib/use_cases/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module UseCases
-  VERSION = "0.3.8"
+  VERSION = "1.0.4"
 end

data/lib/use_cases.rb

@@ -1,11 +1,38 @@
 # frozen_string_literal: true
 
+require "dry/configurable"
+
 require_relative "use_case"
 require_relative "use_cases/version"
-require_relative "use_cases/base"
 
 module UseCases
-  def self.register_type(type_name, klass)
+  class StepArgumentError < ArgumentError; end
+
+  class MissingStepError < NoMethodError; end
+
+  class PreviousStepInvalidReturn < StandardError; end
+
+  extend Dry::Configurable
+
+  setting :container, reader: true
+  setting :publisher, ::UseCases::Events::Publisher.new, reader: true
+  setting :subscribers, [], reader: true
+
+  def self.configure(&blk)
+    super
+    finalize_subscriptions!
+  end
+
+  def self.finalize_subscriptions!
+    subscribe(*subscribers)
+    return unless UseCases::Events::Subscriber.respond_to?(:descendants)
+
+    usecase_subscriber_children = UseCases::Events::Subscriber.descendants
+    subscribe(*usecase_subscriber_children)
+    subscribers.concat(usecase_subscriber_children)
+  end
 
+  def self.subscribe(*subscribers)
+    subscribers.each { |subscriber| publisher.subscribe(subscriber) }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: use_cases
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 1.0.4
 platform: ruby
 authors:
 - Ring Twice
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-06 00:00:00.000000000 Z
+date: 2022-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -145,30 +145,30 @@ files:
 - bin/setup
 - lib/use_case.rb
 - lib/use_cases.rb
-- lib/use_cases/authorize.rb
-- lib/use_cases/base.rb
 - lib/use_cases/dsl.rb
-- lib/use_cases/errors.rb
+- lib/use_cases/events/publish_job.rb
+- lib/use_cases/events/publisher.rb
+- lib/use_cases/events/subscriber.rb
 - lib/use_cases/module_optins.rb
-- lib/use_cases/notifications.rb
+- lib/use_cases/module_optins/authorized.rb
+- lib/use_cases/module_optins/prepared.rb
+- lib/use_cases/module_optins/publishing.rb
+- lib/use_cases/module_optins/transactional.rb
+- lib/use_cases/module_optins/validated.rb
 - lib/use_cases/params.rb
-- lib/use_cases/prepare.rb
+- lib/use_cases/result.rb
 - lib/use_cases/rspec/matchers.rb
 - lib/use_cases/stack.rb
 - lib/use_cases/stack_runner.rb
 - lib/use_cases/step_active_job_adapter.rb
 - lib/use_cases/step_adapters.rb
 - lib/use_cases/step_adapters/abstract.rb
-- lib/use_cases/step_adapters/authorize.rb
 - lib/use_cases/step_adapters/check.rb
 - lib/use_cases/step_adapters/enqueue.rb
 - lib/use_cases/step_adapters/map.rb
 - lib/use_cases/step_adapters/step.rb
 - lib/use_cases/step_adapters/tee.rb
 - lib/use_cases/step_adapters/try.rb
-- lib/use_cases/step_result.rb
-- lib/use_cases/transaction.rb
-- lib/use_cases/validate.rb
 - lib/use_cases/version.rb
 - use_cases.gemspec
 homepage: https://github.com/listminut/use_cases

data/lib/use_cases/authorize.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module UseCases
-  module Authorize
-    class NoAuthorizationError < StandardError; end
-
-    def self.included(base)
-      base.class_eval do
-        extend DSL
-      end
-    end
-
-    module DSL
-      def authorize(step_name, options = {})
-        options[:failure] = :unauthorized
-        check step_name, **options
-      end
-    end
-  end
-end

data/lib/use_cases/base.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "use_case"
-module UseCases
-  class Base
-    include UseCase
-  end
-end

data/lib/use_cases/errors.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module UseCases
-  class StepArgumentError < ArgumentError; end
-
-  class MissingStepError < NoMethodError; end
-
-  class PreviousStepInvalidReturn < StandardError; end
-end

data/lib/use_cases/notifications.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module UseCases
-  module Notifications
-    def self.included(base)
-      base.extend DSL
-    end
-
-    module DSL
-      def subscribe_to_step(event_id, listener)
-        step_subscriptions << StepSubscription.new(event_id, listener)
-      end
-
-      def bind_step_subscriptions
-        step_subscriptions.each { |subscription| subscription.bind(__steps__) }
-      end
-
-      def step_subscriptions
-        @step_subscriptions ||= []
-      end
-    end
-
-    class StepSubscription
-      attr_reader :event_id, :listener, :steps
-
-      def initialize(event_id, listener)
-        @event_id = event_id
-        @listener = listener
-      end
-
-      def bind(steps)
-        @steps = steps
-
-        step = steps.find { |s| s.name == step_name }
-        step.subscribe(event_predicate, listener)
-      end
-
-      def event_predicate
-        predicate = event_id.to_s.gsub(step_name.to_s, "")
-
-        "step#{predicate}".to_sym
-      end
-
-      def step_name
-        steps.map(&:name).find { |step_name| step_name.start_with?(event_id.to_s) }
-      end
-    end
-  end
-end

data/lib/use_cases/prepare.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "use_cases/step_adapters/tee"
-
-module UseCases
-  module Prepare
-    def self.included(base)
-      base.class_eval do
-        extend DSL
-      end
-    end
-
-    module DSL
-      def prepare(name, options = {})
-        __steps__.unshift StepAdapters::Tee.new(name, nil, options)
-      end
-    end
-  end
-end

data/lib/use_cases/step_adapters/authorize.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "use_cases/step_adapters/check"
-
-module UseCases
-  module StepAdapters
-    class Authorize < UseCases::StepAdapters::Check
-      class InvalidReturnValue < StandardError; end
-
-      def do_call(*args)
-        result = super(*args)
-        prev_result = previous_step_result.value
-        raise InvalidReturnValue, "The return value should not be a Monad." if result.is_a?(Dry::Monads::Result)
-
-        failure_code = options[:failure] || :unauthorized
-        failure_message = options[:failure_message] || "Not Authorized"
-
-        result ? Success(prev_result) : Failure([failure_code, failure_message])
-      end
-    end
-  end
-end

data/lib/use_cases/transaction.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module UseCases
-  module Transaction
-    class TransactionHandlerUndefined < StandardError; end
-
-    class TransactionHandlerInvalid < StandardError; end
-
-    def self.included(base)
-      base.prepend DoCallPatch
-    end
-
-    module DoCallPatch
-      def do_call(*args)
-        unless respond_to?(:transaction_handler)
-          raise TransactionHandlerUndefined, "when using *transactional*, make sure to include a transaction handler in your dependencies."
-        end
-
-        raise TransactionHandlerInvalid, "Make sure your transaction_handler implements #transaction." unless transaction_handler.respond_to?(:transaction)
-
-        transaction_handler.transaction { super }
-      end
-    end
-  end
-end

data/lib/use_cases/validate.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/validation/contract"
-
-module UseCases
-  module Validate
-    class NoValidationError < StandardError; end
-
-    def self.included(base)
-      base.class_eval do
-        extend DSL
-        extend ClassMethods
-        prepend CallPatch
-      end
-    end
-
-    module CallPatch
-      def call(*args)
-        unless stack.include_step?(:validate)
-          raise NoValidationError,
-                "Make sure to define params validations by using *params*" \
-                "*schema*, *json*, *rule* or *option* macros in your use case."
-        end
-
-        super
-      end
-    end
-
-    module DSL
-      def params(*args, &blk)
-        _setup_validation
-
-        _contract_class.params(*args, &blk)
-      end
-
-      def schema(*args, &blk)
-        _setup_validation
-
-        _contract_class.schema(*args, &blk)
-      end
-
-      def rule(*args, &blk)
-        _setup_validation
-
-        _contract_class.rule(*args, &blk)
-      end
-
-      def json(*args, &blk)
-        _setup_validation
-
-        _contract_class.json(*args, &blk)
-      end
-
-      def option(*args, &blk)
-        _contract_class.option(*args, &blk)
-      end
-    end
-
-    private
-
-    def validate(params, current_user)
-      return Failure([:validation_error, "*params* must be a hash."]) unless params.respond_to?(:merge)
-
-      validation = contract.call(params)
-
-      if validation.success?
-        params.merge!(validation.to_h)
-        Success(validation.to_h)
-      else
-        Failure([:validation_error, validation.errors.to_h])
-      end
-    end
-
-    def contract
-      return self.class._contract_class.new if self.class._contract_class_defined?
-    end
-
-    module ClassMethods
-      def _setup_validation
-        _define_contract_class unless _contract_class_defined?
-        _define_validation_step unless _validation_step_defined?
-      end
-
-      def _define_validation_step
-        step :validate
-      end
-
-      def _contract_class
-        self::Contract
-      end
-
-      def _define_contract_class
-        const_set(:Contract, Class.new(Dry::Validation::Contract))
-      end
-
-      def _contract_class_name
-        "#{name}::Contract"
-      end
-
-      def _contract_class_defined?
-        Object.const_defined? _contract_class_name
-      end
-
-      def _validation_step_defined?
-        __steps__.map(&:name).include?(:validate)
-      end
-    end
-  end
-end