dry-transaction-extra 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b418dfe409a43af2be1442c9816531076a476c16aa459b5203b49fb32d840836
-  data.tar.gz: be20845e12107f4e7b7b8b086dbead6b7920a1baf1bce41bd847922807c3e9d9
+  metadata.gz: 3519bcb78e2b13c959698975e01d44ff031c16abc4d650096054264d14cdf580
+  data.tar.gz: dbd636da4a27423d023889ee8ea6863ac192d10930aa9a107309708218efcc7e
 SHA512:
-  metadata.gz: d48878a62c1a65a8202021d7ccbb4a4e7c63cc4bc75e825a9f115c6060b75fefdd53abb2a2412acd869edaf9cb5f659f8a93804cd9d7d1a9fbf98f887cc464a9
-  data.tar.gz: c5fca1261a2e76d32a2b45ca33c0ab0f51cd911c61f8904306ff8437c6896a183d1108e6d6fbc8d26ec0fdb208d947e52707aa401efd6738e4eb1ad153d1d401
+  metadata.gz: b6dfb9945b340e4c944e3feeadc54edf3b2e150e1f9725c5764667cd9e80a573e613a72ba2654bfc87280d2cb749fc5cdc06ec93b4830d7e4c4b639b0c4631f1
+  data.tar.gz: d77f0cef4644bf1dfa8b96dbad0f89031910857a0f79577aec47d37202a2c8a6dc6de81779fce873d524a387321286c5000d1c2be9fb0c2843c6bdc83591436c

data/lib/dry/transaction/extra/active_record_rescues.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transaction
+    module Extra
+      module ActiveRecordRescues
+        RESCUE_ERRORS = [
+          ActiveRecord::RecordInvalid,
+          ActiveRecord::RecordNotFound,
+          ActiveRecord::RecordNotUnique
+        ].freeze
+
+        def with_broadcast(args)
+          super
+        rescue *RESCUE_ERRORS => e
+          error = adapter.options[:message] || e
+          Failure(
+            Dry::Transaction::StepFailure.call(self, error) do
+              publish(:step_failed, step_name: name, args: args, value: error)
+            end
+          )
+        end
+      end
+    end
+  end
+end

data/lib/dry/transaction/extra/perform_later.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transaction
+    module Extra
+      module PerformLater
+        def self.extended(klass)
+          klass.extend Dry::Core::ClassAttributes
+
+          klass.defines :transaction_job
+        end
+
+        include Dry::Monads::Result::Mixin
+
+        def set(options = {})
+          ConfiguredJob.new(transaction_job, self, options)
+        end
+
+        def perform_later(*args)
+          if validator
+            result = validator.new.call(*args).to_monad
+            return result unless result.success?
+
+            args = [result.value!.to_h]
+          end
+
+          Dry::Monads::Success(transaction_job.new(transaction_class_name: name, args:).enqueue)
+        end
+
+        class ConfiguredJob
+          def initialize(job_class, transaction, options = {})
+            @job_class = job_class
+            @transaction = transaction
+            @options = options
+          end
+
+          def perform_later(*args)
+            if validator
+              result = validator.new.call(*args).to_monad
+              return result unless result.success?
+
+              args = [result.value!.to_h]
+            end
+
+            Dry::Monads::Success(
+              transaction_job.new(transaction_class_name: @transaction.name, args:)
+                .enqueue(@options)
+            )
+          end
+
+          def validator
+            @transaction.validator
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/transaction/extra/steps/async.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Dry
+  module Transaction
+    module Extra
+      module Steps
+        # Executes the step in a background job. Argument is an ActiveJob or anything that
+        # implements `#perform_later`. This can include other Transactions when using the
+        # :perform_later extension.
+        #
+        # If the provided transaction implements a `validate` step, then that validator will be
+        # called on the input before the job is enqueued. This prevents us from enqueuing jobs with
+        # garbage arguemnts that can never be run, and limits the params passed through the message
+        # body into only those relevant to the job.
+        #
+        # Additionally, ActiveJob only allows for the serialization of a few types of values into
+        # the message, Strings, Numbers and ActiveRecord::Model instances (via globalid). Anything
+        # else will raise an ActiveJob::SerializationError.  Calling the validator beforehand helps
+        # strip those out as well.
+        #
+        # Accepts an optional argument of delay:, to allow for jobs to be performed later, instead
+        # of as soon as possible.
+        #
+        # Usage:
+        #
+        # async GuestsCleanupJob              # A job
+        # async Guests::CleanStale            # A transaction
+        # async DoThisLater, delay: 5.minutes # Optional delay for the job
+        #
+        module Async
+          module DSL
+            def async(job, delay: nil)
+              method_name = job.name.underscore.intern
+              step method_name
+              define_method method_name do |input = {}|
+                job = job.set(wait: delay) if delay
+
+                if (validator = job&.validator)
+                  result = validator.new.call(input)
+                  # If the validator failed, don't enqueue the job, but don't
+                  # also fail the step
+                  job.perform_later(**result.to_h) if result.success?
+                else
+                  job.perform_later(**input)
+                end
+
+                Success(input)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/transaction/extra/steps/maybe.rb

@@ -8,42 +8,41 @@ module Dry
           module DSL
             class NoValidatorError < ArgumentError
               def initialize(txn)
-                super "The object provided to the step (#{txn}) does not implement a `validator` method."
+                super("The object provided to the step (#{txn}) does not implement a `validator` method.")
               end
             end
 
-            # Just like the `use` step, this invokes another transaction.
-            # However, it first checks to see if the transaction implements a
-            # `validator` method (usually provided by the validation_dsl
-            # extension), and if so, will call it before invoking the
-            # transaction.
+            # Just like the `use` step, this invokes another transaction. However, it first checks
+            # to see if the transaction implements a `validator` method (usually provided by the
+            # validation_dsl extension), and if so, will call it before invoking the transaction.
             #
-            # If the validation succeeds, then it invokes the transaction as
-            # normal. If it fails, it continues on with the next step, passing
-            # the original input through.
+            # If the validation succeeds, then it invokes the transaction as normal. If it fails, it
+            # continues on with the next step, passing the original input through.
             #
             # @example
             #
             # step :create_user
             # maybe VerifyEmail
             #
-            def maybe(txn_or_container, key = nil, as: nil)
+            def maybe(txn_or_container, key = nil, as: nil, **)
               if key
                 container = txn_or_container
-                method_name = as || "#{container.name}.#{key}".to_sym
+                method_name = as || :"#{container.name}.#{key}"
               else
                 txn = txn_or_container
                 method_name = as || txn.name.to_sym
               end
 
-              merge(method_name, as:)
+              merge(method_name, as:, **)
               define_method method_name do |*args|
                 txn = container[key] if key
-                raise NoValidatorError, txn unless txn.respond_to? :validator
+                txn_class = txn.is_a?(Class) ? txn : txn.class
+                raise NoValidatorError, txn unless txn_class.respond_to? :validator
 
-                result = txn.validator.new.call(*args)
+                result = txn_class.validator.new.call(*args)
                 if result.failure?
-                  # Rails.logger.debug "Skipping #{txn} because of errors: #{result.errors.to_h}"
+                  # publish(:maybe_failed, step_name: method_name, args:, value: result)
+                  Rails.logger.debug "Skipping #{txn} because of errors: #{result.errors.to_h}" if defined?(Rails)
                   return Success(*args)
                 end
 

data/lib/dry/transaction/extra/steps/use.rb

@@ -38,16 +38,16 @@ module Dry
             #
             # # => { user: #<User: id=1> }
             #
-            def use(txn_or_container, key = nil, as: nil)
+            def use(txn_or_container, key = nil, as: nil, **)
               if key
                 container = txn_or_container
-                method_name = as || "#{container.name}.#{key}".to_sym
+                method_name = as || :"#{container.name}.#{key}"
               else
                 txn = txn_or_container
                 method_name = as || txn.name.to_sym
               end
 
-              merge(method_name, as:)
+              merge(method_name, as:, **)
               define_method method_name do |*args|
                 txn = container[key] if key
                 txn.call(*args)

data/lib/dry/transaction/extra/validation_dsl.rb

@@ -26,6 +26,45 @@ module Dry
           # # => #<Dry::Validation::Result{name: "Jane"} errors={}>
           klass.defines :validator
 
+          # Allows overriding the default validation contract class. This is useful if you want to
+          # use a different Contract class with a different configuration.
+          #
+          # @example
+          #
+          # module MyApp
+          #   module Types
+          #     include Dry.Types()
+          #
+          #     Container = Dry::Schema::TypeContainer.new
+          #     Container.register("params.email", String.constrained(format: /@/))
+          #   end
+          #
+          #   class Contract < Dry::Validation::Contract
+          #     config.types = Types::Container
+          #   end
+          # end
+          #
+          # module ApplicationTransaction
+          #   include Dry::Transaction
+          #   include Dry::Transaction::Extra
+          #
+          #   load_extensions :validation
+          #
+          #   validation_contract_class MyApp::Contract
+          # end
+          #
+          # class MyTransaction
+          #   include ApplicationTransaction
+          #
+          #   validate do
+          #     params do
+          #       # Now the custom `:email` type is available in this schema
+          #       required(:email).filled(:email)
+          #     end
+          #   end
+          # end
+          klass.defines :validation_contract_class
+
           require "dry/validation"
           Dry::Validation.load_extensions(:monads)
         end
@@ -65,8 +104,8 @@ module Dry
         #   validate NewUserContract
         # end
         #
-        def validate(contract = nil, &block)
-          validator(contract || Class.new(Dry::Validation::Contract, &block))
+        def validate(contract = nil, &)
+          validator(contract || Class.new(validation_contract_class || Dry::Validation::Contract, &))
 
           valid(validator.new, name: "validate")
         end

data/lib/dry/transaction/extra/version.rb

@@ -3,7 +3,7 @@
 module Dry
   module Transaction
     module Extra
-      VERSION = "0.1.1"
+      VERSION = "0.1.2"
     end
   end
 end

data/lib/dry/transaction/extra.rb

@@ -5,19 +5,23 @@ require_relative "extra/version"
 require "dry/monads"
 require "dry/transaction"
 
-require_relative "extra/steps/tap"
+require_relative "extra/steps/async"
 require_relative "extra/steps/maybe"
 require_relative "extra/steps/merge"
+require_relative "extra/steps/tap"
 require_relative "extra/steps/use"
 require_relative "extra/steps/valid"
 
+require_relative "extra/active_record_rescues"
 require_relative "extra/class_callable"
+require_relative "extra/perform_later"
 require_relative "extra/validation_dsl"
 
 module Dry
   module Transaction
     module Extra
       def self.included(klass)
+        klass.extend Extra::Steps::Async::DSL
         klass.extend Extra::Steps::Maybe::DSL
         klass.extend Extra::Steps::Use::DSL
         klass.extend Extra::Steps::Valid::DSL
@@ -31,6 +35,14 @@ module Dry
         klass.register_extension :class_callable do
           klass.extend ClassCallable
         end
+
+        klass.register_extension :perform_later do
+          klass.extend PerformLater
+        end
+
+        klass.register_extension :active_record_rescues do
+          Dry::Transaction::Step.prepend(ActiveRecordRescues)
+        end
       end
 
       adapters = Dry::Transaction::StepAdapters

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dry-transaction-extra
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Paul Sadauskas
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-18 00:00:00.000000000 Z
+date: 2025-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-monads
@@ -98,7 +97,10 @@ files:
 - Rakefile
 - dry-transaction-extra.gemspec
 - lib/dry/transaction/extra.rb
+- lib/dry/transaction/extra/active_record_rescues.rb
 - lib/dry/transaction/extra/class_callable.rb
+- lib/dry/transaction/extra/perform_later.rb
+- lib/dry/transaction/extra/steps/async.rb
 - lib/dry/transaction/extra/steps/maybe.rb
 - lib/dry/transaction/extra/steps/merge.rb
 - lib/dry/transaction/extra/steps/tap.rb
@@ -113,7 +115,6 @@ licenses:
 metadata:
   homepage_uri: https://github.com/paul/dry-transaction-extra
   source_code_uri: https://github.com/paul/dry-transaction-extra
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,8 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Extra steps and functionality for Dry::Transaction
 test_files: []