light_service-validated_context 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c16c17a54c9867f59ccbf92ec6d969760eb396719ecda969e12d2fec2b063623
-  data.tar.gz: 62103f8748ab7efc04cad3253d5dc5aabd153ae62e4d022ca0427365dc2f657f
+  metadata.gz: 859cf8786c692bedc1d764b0656629bc7f9e0ddb741a10874d290c723b708e3d
+  data.tar.gz: 18059f28fcbaaa2d54373bdf2cea6c6f8387fc68b07f83f338631e445ba29e5f
 SHA512:
-  metadata.gz: 79c63b97672442aabfdc1215f1ca1e5c92293508da7ab3cea9e23e6453a1b9017f240501af69aa7423780f4b9b77b3ae5eecb53aa4b7d80dbaecb0285b94271e
-  data.tar.gz: 003447c4164440525f526cca2859f3151ebaeb7cc7ba4e32d3ef1f2022b3aa9418ab699400975d4bbe659444678c6df1226716959c00d6c2ccad2a944e547d13
+  metadata.gz: 7d7a6568947199bf4e96296d03825a65b7485227083d02b72b450598db273e72bae5547b19dd9d32d5ca9a85e9b5e676cc5af4f257f974ec4d4d9e59a8c3ed7f
+  data.tar.gz: eb44c15324105179fb1426fc201d2f34d8bb92e5ccc5e1ed2a265e8c8d85eaf66625b287717c6ec452a8789afa240b69b395fa3050c0a1661ed2026a0fb6e5d0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    light_service-validated_context (0.3.0)
+    light_service-validated_context (0.3.1)
       dry-types (~> 1.7.0)
       light-service (>= 0.18.0)
       zeitwerk

data/README.md

@@ -23,7 +23,7 @@ AFAIK this is the only way to achieve the goal. Because of this fact I consider
 ## Goals
 
 - implement an advanced and flexible interface to declare,
-type-check, coerce and describe action's arguments without reinventing the wheel (the wheel we use under the wood is [`dry-types`](https://dry-rb.org/gems/dry-types))
+type-check, coerce and describe action's arguments without reinventing the wheel (the wheel we use under the wood is [`dry-types`](https://dry-rb.org/gems/dry-types/main/custom-types/))
 - testing DX and interfaces
 - study what parts of code are involved into this area of `light-service`'s code base
 
@@ -101,7 +101,7 @@ ActionOne.execute(age: 37, text: 'Too long too pass the constrain')
 ```
 
 Since all the validation and coercion logic is delegated to `dry-types`, you can
-read more about what you can achieve at https://dry-rb.org/gems/dry-types/1.2/
+read more about what you can achieve at https://dry-rb.org/gems/dry-types/main/custom-types/
 
 `VK` objects needs to be created with 2 positional arguments:
 
@@ -116,13 +116,14 @@ You can find more usage example in `spec/support/test_doubles.rb`
 
 ### Custom validation error message
 
-You can set a custom validation error message when instantiating a `VK`
+You can set a custom validation error message when instantiating a `VK` object
 
 ```ruby
-VK.new(:my_integer, Types::Strict::Integer, message: 'Custom validatio message for :my_integer key')
+VK.new(:my_integer, Types::Strict::Integer, message: 'Custom validation message for :my_integer key')
 ```
 
-Messages translated via `I18n` are supported too, following stardard `light-service`'s configuration
+Messages translated via `I18n` are supported too, following standard `light-service`'s
+[configuration](https://github.com/adomokos/light-service/#localizing-messages)
 
 ```ruby
 VK.new(:my_integer, Types::Strict::Integer, message: :my_integer_error_message)
@@ -130,10 +131,15 @@ VK.new(:my_integer, Types::Strict::Integer, message: :my_integer_error_message)
 
 ### Raise vs fail
 
-By default, following original `light-service` implementation, a validation error will raise
-and error.
+By default, following original `light-service` implementation, a validation error will raise a
+`LightService::ExpectedKeysNotInContextError` or `LightService::PromisedKeysNotInContextError`.
 
-May you prefere to fail the action populating outcome's message with error message:
+> NOTE: I know that raised exceptions do not express the concept of "invalid", but I opted
+to preserve the original one in order to make this plugin more droppable-in as possible, thus
+w/o breaking code relying on, for example, rescueing those specific excpetions.
+
+May you prefere to fail the action, populating outcome's message with error message, just do
+`extend LightService::Context::FailOnValidationError` into you action:
 
 ```ruby
 class ActionFailInsteadOfRaise
@@ -151,13 +157,45 @@ result = ActionFailInsteadOfRaise.execute(foo: 12)
 result.message # Here you'll find the validation(s) message(s)
 ```
 
-## Why validation matters?
+### Custom types
+
+As documented in [dry-types doc](https://dry-rb.org/gems/dry-types/main/getting-started/#creating-your-first-type),
+you can be more expressive defining custom types; you can define them reopening the already defined `LightService::Types` module
+(or simply `Types` in the global namespace if it does not conflict with your domain's namespace), e.g.:
+
+```ruby
+module LightService::Types
+  MyExpressiveThing = Hash.schema(
+    name: String,
+    age: Coercible::Integer,
+    foo: Symbol.constrained(included_in: %i[bar baz])
+  )
+end
+
+class ActionOne
+  extend LightService::Action
+  extend LightService::Context::FailOnValidationError
 
-In OO programming there's a rule (strict or "of thumb", IDK) that says to never instantiate an
-invalid object - given the object itself has the concept of _validity_.
+  expects VK.new(:foo, Types::MyBusinessHash)
+
+  executed do |context|
+    # do something...
+  end
+end
+
+result = App::ActionOne.execute(foo: {
+  name: 'Alessandro',
+  age: '37',
+  foo: :bar
+})
+```
+
+Custom types will be reusable, more expressive and moreover will clean your action up a bit.
+
+## Why validation matters?
 
-How many times do you find yourself working with an object already initialized and in memory, but
-you cannot trust its internal status?
+In OO programming there's a rule that says to never instantiate an
+invalid object.
 
 If you cannot trust the state, given the state is internal or delegated to a context object,
 you'll have to do a bunch of validation-oriented logical branches into your logic. E.g.:
@@ -211,8 +249,11 @@ some features, feel free to drop me a line on Mastodon [@alessandrofazzi@mastodo
 | type check                | ❌                      | ✅                                                    | ❌                         | ✅                                 | ✅                                             |
 | data structure type check | ❌                      | ❌                                                    | ❌                         | ❌                                 | ✅                                             |
 | optional                  | ⚠️ through `default`    | ✅ through `allow_nil` (which defaults to `true` 🤔 ❓) | ❌                         | ⚠️ through `default`               | ✅                                             |
-| 1st party code                | ✅                      | ✅                                                     | ✅                         | ❌ ActiveModel::Validation        | ❌ Dry::Types                                  |
+| 1st party code                | ✅                      | ✅                                                     | ✅                         | ⚠️ ActiveModel::Validation        | ❌ Dry::Types                                  |
 
+> NOTE: in `active_interaction` the fact that validation code isn't first party isn't an issue, since
+> the gem is a Rails-only gem and validation is delegated to Rails, thus no additional dependencies
+> are required. `light_service-validated_context` depends on additional gems from the dry-rb ecosystem
 
 ## Development
 

data/lib/light_service/validated_context/context.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
-module ValidatedContext
-  module Context
-    def define_accessor_methods_for_keys(keys)
-      super keys.map(&:to_sym)
+module LightService
+  module ValidatedContext
+    module Context
+      def define_accessor_methods_for_keys(keys)
+        super keys.map(&:to_sym)
+      end
     end
   end
 end

data/lib/light_service/validated_context/expected_key_verifier.rb

@@ -1,29 +1,31 @@
 # frozen_string_literal: true
 
-module ValidatedContext
-  module ExpectedKeyVerifier
-    def keys
-      keys_as_symbols
-    end
+module LightService
+  module ValidatedContext
+    module ExpectedKeyVerifier
+      def keys
+        keys_as_symbols
+      end
 
-    def keys_as_symbols
-      action.expected_keys.map do |key|
-        next key unless key.is_a?(LightService::Context::ValidatedKey)
+      def keys_as_symbols
+        action.expected_keys.map do |key|
+          next key unless key.is_a?(LightService::Context::ValidatedKey)
 
-        key.to_sym
+          key.to_sym
+        end
       end
-    end
 
-    def raw_keys
-      action.expected_keys
-    end
+      def raw_keys
+        action.expected_keys
+      end
 
-    def throw_error_predicate(_keys)
-      type_check_and_coerce_keys!(raw_keys)
+      def throw_error_predicate(_keys)
+        type_check_and_coerce_keys!(raw_keys)
 
-      return false if are_all_keys_valid?
+        return false if are_all_keys_valid?
 
-      should_throw_on_validation_error?
+        should_throw_on_validation_error?
+      end
     end
   end
 end

data/lib/light_service/validated_context/fail_on_validation_error.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
-module ValidatedContext
-  module FailOnValidationError
-    def fail_on_validation_error? = true
-    def throw_on_validation_error? = !fail_on_validation_error?
+module LightService
+  module ValidatedContext
+    module FailOnValidationError
+      def fail_on_validation_error? = true
+      def throw_on_validation_error? = !fail_on_validation_error?
+    end
   end
 end

data/lib/light_service/validated_context/key_verifier.rb

@@ -1,48 +1,50 @@
 # frozen_string_literal: true
 
-module ValidatedContext
-  module KeyVerifier
-    def initialize(context, action)
-      @validation_errors = []
+module LightService
+  module ValidatedContext
+    module KeyVerifier
+      def initialize(context, action)
+        @validation_errors = []
 
-      super(context, action)
-    end
+        super(context, action)
+      end
 
-    # rubocop:disable Metrics/AbcSize
-    # Refactoring this is out of my scope ATM
-    def type_check_and_coerce_keys!(keys)
-      errors = []
-
-      keys.each do |key|
-        next unless key.is_a?(LightService::Context::ValidatedKey)
-
-        begin
-          context[key.label] = key.type[context[key.label] || Dry::Types::Undefined]
-        rescue Dry::Types::CoercionError => e
-          errors << (
-            LightService::Configuration.localization_adapter.failure(key.message, action) ||
-              "[#{action}][:#{key.label}] #{e.message}"
-          )
+      # rubocop:disable Metrics/AbcSize
+      # Refactoring this is out of my scope ATM
+      def type_check_and_coerce_keys!(keys)
+        errors = []
+
+        keys.each do |key|
+          next unless key.is_a?(LightService::Context::ValidatedKey)
+
+          begin
+            context[key.label] = key.type[context[key.label] || Dry::Types::Undefined]
+          rescue Dry::Types::CoercionError => e
+            errors << (
+              LightService::Configuration.localization_adapter.failure(key.message, action) ||
+                "[#{action}][:#{key.label}] #{e.message}"
+            )
+          end
         end
-      end
 
-      @validation_errors = errors
-    end
-    # rubocop:enable Metrics/AbcSize
+        @validation_errors = errors
+      end
+      # rubocop:enable Metrics/AbcSize
 
-    def are_all_keys_valid?
-      @validation_errors.none?
-    end
+      def are_all_keys_valid?
+        @validation_errors.none?
+      end
 
-    def error_message
-      @validation_errors.join(', ')
-    end
+      def error_message
+        @validation_errors.join(', ')
+      end
 
-    def should_throw_on_validation_error?
-      return true unless action.respond_to?(:fail_on_validation_error?) && action.fail_on_validation_error?
+      def should_throw_on_validation_error?
+        return true unless action.respond_to?(:fail_on_validation_error?) && action.fail_on_validation_error?
 
-      context.fail!(error_message)
-      false
+        context.fail!(error_message)
+        false
+      end
     end
   end
 end

data/lib/light_service/validated_context/promised_key_verifier.rb

@@ -1,29 +1,31 @@
 # frozen_string_literal: true
 
-module ValidatedContext
-  module PromisedKeyVerifier
-    def keys
-      keys_as_symbols
-    end
+module LightService
+  module ValidatedContext
+    module PromisedKeyVerifier
+      def keys
+        keys_as_symbols
+      end
 
-    def keys_as_symbols
-      raw_keys.map do |key|
-        next key unless key.is_a?(LightService::Context::ValidatedKey)
+      def keys_as_symbols
+        raw_keys.map do |key|
+          next key unless key.is_a?(LightService::Context::ValidatedKey)
 
-        key.to_sym
+          key.to_sym
+        end
       end
-    end
 
-    def raw_keys
-      action.promised_keys
-    end
+      def raw_keys
+        action.promised_keys
+      end
 
-    def throw_error_predicate(_keys)
-      type_check_and_coerce_keys!(raw_keys)
+      def throw_error_predicate(_keys)
+        type_check_and_coerce_keys!(raw_keys)
 
-      return false if are_all_keys_valid?
+        return false if are_all_keys_valid?
 
-      should_throw_on_validation_error?
+        should_throw_on_validation_error?
+      end
     end
   end
 end

data/lib/light_service/validated_context/validated_key.rb

@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 
-module ValidatedContext
-  class ValidatedKey
-    attr_reader :label, :type, :message
+module LightService
+  module ValidatedContext
+    class ValidatedKey
+      attr_reader :label, :type, :message
 
-    def initialize(label, type, message: nil)
-      @label = label
-      @type = type
-      @message = message
-    end
+      def initialize(label, type, message: nil)
+        @label = label
+        @type = type
+        @message = message
+      end
 
-    def to_sym
-      label.to_sym
-    end
+      def to_sym
+        label.to_sym
+      end
 
-    def to_s
-      label.to_s
+      def to_s
+        label.to_s
+      end
     end
   end
 end

data/lib/light_service/validated_context/version.rb

@@ -2,6 +2,6 @@
 
 module LightService
   module ValidatedContext
-    VERSION = "0.3.0"
+    VERSION = "0.3.1"
   end
 end

data/lib/light_service/validated_context.rb

@@ -1,30 +1,35 @@
 # frozen_string_literal: true
 
 require "zeitwerk"
-loader = Zeitwerk::Loader.for_gem
+loader = Zeitwerk::Loader.new
+loader.tag = 'LightService::I18n'
+loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
+loader.push_dir(__dir__, :namespace => LightService)
 loader.setup
 
 require 'light-service'
 require 'dry-types'
 
-module ValidatedContext; end
+module LightService
+  module ValidatedContext; end
+end
 
 module LightService
   class Context
-    ValidatedKey = ::ValidatedContext::ValidatedKey
-    FailOnValidationError = ::ValidatedContext::FailOnValidationError
-    prepend ::ValidatedContext::Context
+    ValidatedKey = LightService::ValidatedContext::ValidatedKey
+    FailOnValidationError = LightService::ValidatedContext::FailOnValidationError
+    prepend LightService::ValidatedContext::Context
 
     class KeyVerifier
-      prepend ::ValidatedContext::KeyVerifier
+      prepend LightService::ValidatedContext::KeyVerifier
     end
 
     class ExpectedKeyVerifier
-      prepend ::ValidatedContext::ExpectedKeyVerifier
+      prepend LightService::ValidatedContext::ExpectedKeyVerifier
     end
 
     class PromisedKeyVerifier
-      prepend ::ValidatedContext::PromisedKeyVerifier
+      prepend LightService::ValidatedContext::PromisedKeyVerifier
     end
   end
 
@@ -33,7 +38,7 @@ module LightService
   end
 end
 
-# Convenience namespace for implementor
+# Convenience alias for implementor
 Types = LightService::Types unless Module.const_defined?('Types')
 
 # Convenience alias for implementor

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light_service-validated_context
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - "'Alessandro Fazzi'"
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-03 00:00:00.000000000 Z
+date: 2022-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-types