easy_talk 3.1.0 → 3.2.0

data/lib/easy_talk/types/composer.rb

@@ -16,6 +16,10 @@ module EasyTalk
         self.class.name
       end
 
+      def to_s
+        name.to_s
+      end
+
       # Represents a composition type that allows all of the specified types.
       class AllOf < Composer
         def self.name

data/lib/easy_talk/validation_adapters/active_model_adapter.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module EasyTalk
+  module ValidationAdapters
+    # ActiveModel validation adapter.
+    #
+    # This is the default adapter that converts JSON Schema constraints into
+    # ActiveModel validations. It provides the same validation behavior as
+    # the original EasyTalk::ValidationBuilder.
+    #
+    # @example Using the ActiveModel adapter (default)
+    #   class User
+    #     include EasyTalk::Model
+    #
+    #     define_schema do
+    #       property :email, String, format: 'email'
+    #     end
+    #   end
+    #
+    #   user = User.new(email: 'invalid')
+    #   user.valid? # => false
+    #   user.errors[:email] # => ["must be a valid email address"]
+    #
+    class ActiveModelAdapter < Base
+      # Apply validations based on property type and constraints.
+      #
+      # @return [void]
+      def apply_validations
+        # Determine if the type is boolean
+        type_class = get_type_class(@type)
+        is_boolean = type_class == [TrueClass, FalseClass] ||
+                     type_class == TrueClass ||
+                     type_class == FalseClass ||
+                     TypeIntrospection.boolean_type?(@type)
+
+        # Determine if the type is an array (empty arrays should be valid)
+        is_array = type_class == Array || @type.is_a?(T::Types::TypedArray)
+
+        # Skip presence validation for booleans, nilable types, and arrays
+        # (empty arrays are valid - use min_items constraint if you need non-empty)
+        apply_presence_validation unless optional? || is_boolean || nilable_type? || is_array
+
+        if nilable_type?
+          # For nilable types, get the inner type and apply validations to it
+          inner_type = extract_inner_type(@type)
+          apply_type_validations(inner_type)
+        else
+          apply_type_validations(@type)
+        end
+
+        # Common validations for most types
+        apply_enum_validation if @constraints[:enum]
+        apply_const_validation if @constraints[:const]
+      end
+
+      private
+
+      # Apply validations based on the type of the property
+      def apply_type_validations(type)
+        type_class = get_type_class(type)
+
+        if type_class == String
+          apply_string_validations
+        elsif type_class == Integer
+          apply_integer_validations
+        elsif [Float, BigDecimal].include?(type_class)
+          apply_number_validations
+        elsif type_class == Array
+          apply_array_validations(type)
+        elsif type_class == [TrueClass,
+                             FalseClass] || [TrueClass,
+                                             FalseClass].include?(type_class) || TypeIntrospection.boolean_type?(type)
+          apply_boolean_validations
+        elsif type_class.is_a?(Object) && type_class.include?(EasyTalk::Model)
+          apply_object_validations
+        end
+      end
+
+      # Add presence validation for the property
+      def apply_presence_validation
+        @klass.validates @property_name, presence: true
+      end
+
+      # Validate string-specific constraints
+      def apply_string_validations
+        # Handle format constraints
+        apply_format_validation(@constraints[:format]) if @constraints[:format]
+
+        # Handle pattern (regex) constraints
+        if @constraints[:pattern]
+          @klass.validates @property_name, format: { with: Regexp.new(@constraints[:pattern]) },
+                                           allow_nil: optional?
+        end
+
+        # Handle length constraints
+        apply_length_validations
+      end
+
+      # Apply length validations for strings
+      def apply_length_validations
+        length_options = {}
+        length_options[:minimum] = @constraints[:min_length] if valid_length_constraint?(:min_length)
+        length_options[:maximum] = @constraints[:max_length] if valid_length_constraint?(:max_length)
+        return unless length_options.any?
+
+        length_options[:allow_nil] = optional? || nilable_type?
+        @klass.validates @property_name, length: length_options
+      rescue ArgumentError
+        # Silently ignore invalid length constraints
+      end
+
+      # Check if a length constraint is valid
+      def valid_length_constraint?(key)
+        @constraints[key].is_a?(Numeric) && @constraints[key] >= 0
+      end
+
+      # Apply format-specific validations (email, url, etc.)
+      def apply_format_validation(format)
+        format_configs = {
+          'email' => { with: URI::MailTo::EMAIL_REGEXP, message: 'must be a valid email address' },
+          'uri' => { with: URI::DEFAULT_PARSER.make_regexp, message: 'must be a valid URL' },
+          'url' => { with: URI::DEFAULT_PARSER.make_regexp, message: 'must be a valid URL' },
+          'uuid' => { with: /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i,
+                      message: 'must be a valid UUID' },
+          'date' => { with: /\A\d{4}-\d{2}-\d{2}\z/, message: 'must be a valid date in YYYY-MM-DD format' },
+          'date-time' => { with: /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?\z/,
+                           message: 'must be a valid ISO 8601 date-time' },
+          'time' => { with: /\A\d{2}:\d{2}:\d{2}(?:\.\d+)?\z/, message: 'must be a valid time in HH:MM:SS format' }
+        }
+
+        config = format_configs[format.to_s]
+        return unless config
+
+        config[:allow_nil] = optional? || nilable_type?
+        @klass.validates @property_name, format: config
+      end
+
+      # Validate integer-specific constraints
+      def apply_integer_validations
+        apply_numeric_validations(only_integer: true)
+      end
+
+      # Validate number-specific constraints
+      def apply_number_validations
+        apply_numeric_validations(only_integer: false)
+      end
+
+      # Apply numeric validations for integers and floats
+      def apply_numeric_validations(only_integer: false)
+        options = { only_integer: only_integer }
+
+        # Add range constraints - only if they are numeric
+        options[:greater_than_or_equal_to] = @constraints[:minimum] if @constraints[:minimum].is_a?(Numeric)
+        options[:less_than_or_equal_to] = @constraints[:maximum] if @constraints[:maximum].is_a?(Numeric)
+        options[:greater_than] = @constraints[:exclusive_minimum] if @constraints[:exclusive_minimum].is_a?(Numeric)
+        options[:less_than] = @constraints[:exclusive_maximum] if @constraints[:exclusive_maximum].is_a?(Numeric)
+
+        @klass.validates @property_name, numericality: options
+
+        # Add multiple_of validation
+        apply_multiple_of_validation if @constraints[:multiple_of]
+      rescue ArgumentError
+        # Silently ignore invalid numeric constraints
+      end
+
+      # Apply multiple_of validation for numeric types
+      def apply_multiple_of_validation
+        prop_name = @property_name
+        multiple_of_value = @constraints[:multiple_of]
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          record.errors.add(prop_name, "must be a multiple of #{multiple_of_value}") if value && (value % multiple_of_value != 0)
+        end
+      end
+
+      # Validate array-specific constraints
+      def apply_array_validations(type)
+        # Validate array length
+        if @constraints[:min_items] || @constraints[:max_items]
+          length_options = {}
+          length_options[:minimum] = @constraints[:min_items] if @constraints[:min_items]
+          length_options[:maximum] = @constraints[:max_items] if @constraints[:max_items]
+
+          @klass.validates @property_name, length: length_options
+        end
+
+        # Validate uniqueness within the array
+        apply_unique_items_validation if @constraints[:unique_items]
+
+        # Validate array item types if using T::Array[SomeType]
+        apply_array_item_type_validation(type) if type.is_a?(T::Types::TypedArray)
+      end
+
+      # Apply unique items validation for arrays
+      def apply_unique_items_validation
+        prop_name = @property_name
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          record.errors.add(prop_name, 'must contain unique items') if value && value.uniq.length != value.length
+        end
+      end
+
+      # Apply array item type and nested model validation
+      def apply_array_item_type_validation(type)
+        # Get inner type from T::Types::TypedArray (uses .type, which returns T::Types::Simple)
+        inner_type_wrapper = type.type
+        inner_type = inner_type_wrapper.respond_to?(:raw_type) ? inner_type_wrapper.raw_type : inner_type_wrapper
+        prop_name = @property_name
+        is_easy_talk_model = inner_type.is_a?(Class) && inner_type.include?(EasyTalk::Model)
+
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          next unless value.is_a?(Array)
+
+          value.each_with_index do |item, index|
+            unless item.is_a?(inner_type)
+              record.errors.add(prop_name, "item at index #{index} must be a #{inner_type}")
+              next
+            end
+
+            # Recursively validate nested EasyTalk::Model items
+            next unless is_easy_talk_model && !item.valid?
+
+            item.errors.each do |error|
+              nested_key = "#{prop_name}[#{index}].#{error.attribute}"
+              record.errors.add(nested_key.to_sym, error.message)
+            end
+          end
+        end
+      end
+
+      # Validate boolean-specific constraints
+      def apply_boolean_validations
+        # For boolean values, validate inclusion in [true, false]
+        # If not optional, don't allow nil (equivalent to presence validation for booleans)
+        if optional?
+          @klass.validates @property_name, inclusion: { in: [true, false] }, allow_nil: true
+        else
+          @klass.validates @property_name, inclusion: { in: [true, false] }
+          # Add custom validation for nil values that provides the "can't be blank" message
+          apply_boolean_presence_validation
+        end
+
+        # Add type validation to ensure the value is actually a boolean
+        apply_boolean_type_validation
+      end
+
+      # Apply presence validation for boolean (nil check with custom message)
+      def apply_boolean_presence_validation
+        prop_name = @property_name
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          record.errors.add(prop_name, "can't be blank") if value.nil?
+        end
+      end
+
+      # Apply type validation for boolean
+      def apply_boolean_type_validation
+        prop_name = @property_name
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          record.errors.add(prop_name, 'must be a boolean') if value && ![true, false].include?(value)
+        end
+      end
+
+      # Validate object/hash-specific constraints
+      def apply_object_validations
+        # Capture necessary variables outside the validation block's scope
+        prop_name = @property_name
+        expected_type = get_type_class(@type) # Get the raw model class
+
+        @klass.validate do |record|
+          nested_object = record.public_send(prop_name)
+
+          # Only validate if the nested object is present
+          next unless nested_object
+
+          # Check if the object is of the expected type (e.g., an actual Email instance)
+          if nested_object.is_a?(expected_type)
+            # Check if this object appears to be empty (created from an empty hash)
+            # by checking if all defined properties are nil/blank
+            properties = expected_type.schema_definition.schema[:properties] || {}
+            all_properties_blank = properties.keys.all? do |property|
+              value = nested_object.public_send(property)
+              value.nil? || (value.respond_to?(:empty?) && value.empty?)
+            end
+
+            if all_properties_blank
+              # Treat as blank and add a presence error to the parent field
+              record.errors.add(prop_name, "can't be blank")
+            elsif !nested_object.valid?
+              # If it's the correct type and not empty, validate it
+              # Merge errors from the nested object into the parent
+              nested_object.errors.each do |error|
+                # Prefix the attribute name (e.g., 'email.address')
+                nested_key = "#{prop_name}.#{error.attribute}"
+                record.errors.add(nested_key.to_sym, error.message)
+              end
+            end
+          else
+            # If present but not the correct type, add a type error
+            record.errors.add(prop_name, "must be a valid #{expected_type.name}")
+          end
+        end
+      end
+
+      # Apply enum validation for inclusion in a specific list
+      def apply_enum_validation
+        @klass.validates @property_name, inclusion: {
+          in: @constraints[:enum],
+          message: "must be one of: #{@constraints[:enum].join(', ')}",
+          allow_nil: optional?
+        }
+      end
+
+      # Apply const validation for equality with a specific value
+      def apply_const_validation
+        const_value = @constraints[:const]
+        prop_name = @property_name
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          record.errors.add(prop_name, "must be equal to #{const_value}") if !value.nil? && value != const_value
+        end
+      end
+    end
+  end
+end

data/lib/easy_talk/validation_adapters/base.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  module ValidationAdapters
+    # Abstract base class for validation adapters.
+    #
+    # Validation adapters are responsible for converting JSON Schema constraints
+    # into validation rules for the target validation framework (e.g., ActiveModel,
+    # dry-validation, or custom validators).
+    #
+    # To create a custom adapter, subclass this class and implement the
+    # `apply_validations` method.
+    #
+    # @example Creating a custom adapter
+    #   class MyCustomAdapter < EasyTalk::ValidationAdapters::Base
+    #     def apply_validations
+    #       # Apply custom validations to @klass based on @constraints
+    #       @klass.validates @property_name, presence: true unless optional?
+    #     end
+    #   end
+    #
+    # @example Registering and using a custom adapter
+    #   EasyTalk::ValidationAdapters::Registry.register(:custom, MyCustomAdapter)
+    #
+    #   class User
+    #     include EasyTalk::Model
+    #     define_schema(validations: :custom) do
+    #       property :name, String
+    #     end
+    #   end
+    #
+    class Base
+      # Build validations for a property and apply them to the model class.
+      # This is the primary interface that adapters must implement.
+      #
+      # @param klass [Class] The model class to apply validations to
+      # @param property_name [Symbol, String] The name of the property
+      # @param type [Class, Object] The type of the property (Ruby class or Sorbet type)
+      # @param constraints [Hash] The JSON Schema constraints for the property
+      #   Possible keys: :min_length, :max_length, :minimum, :maximum, :pattern,
+      #   :format, :enum, :const, :min_items, :max_items, :unique_items, :optional
+      # @return [void]
+      def self.build_validations(klass, property_name, type, constraints)
+        new(klass, property_name, type, constraints).apply_validations
+      end
+
+      # Initialize a new validation adapter instance.
+      #
+      # @param klass [Class] The model class to apply validations to
+      # @param property_name [Symbol, String] The name of the property
+      # @param type [Class, Object] The type of the property
+      # @param constraints [Hash] The JSON Schema constraints for the property
+      def initialize(klass, property_name, type, constraints)
+        @klass = klass
+        @property_name = property_name.to_sym
+        @type = type
+        @constraints = constraints || {}
+      end
+
+      # Apply validations based on property type and constraints.
+      # Subclasses MUST implement this method.
+      #
+      # @abstract
+      # @return [void]
+      # @raise [NotImplementedError] if the subclass does not implement this method
+      def apply_validations
+        raise NotImplementedError, "#{self.class} must implement #apply_validations"
+      end
+
+      protected
+
+      attr_reader :klass, :property_name, :type, :constraints
+
+      # Check if a property is optional based on constraints and configuration.
+      #
+      # A property is considered optional if:
+      # - The :optional constraint is explicitly set to true
+      # - The type is nilable AND nilable_is_optional configuration is true
+      #
+      # @return [Boolean] true if the property is optional
+      def optional?
+        @constraints[:optional] == true ||
+          (@type.respond_to?(:nilable?) && @type.nilable? && EasyTalk.configuration.nilable_is_optional)
+      end
+
+      # Check if the type is nilable (e.g., T.nilable(String)).
+      #
+      # @param t [Class, Object] The type to check (defaults to @type)
+      # @return [Boolean] true if the type is nilable
+      def nilable_type?(type_to_check = @type)
+        type_to_check.respond_to?(:nilable?) && type_to_check.nilable?
+      end
+
+      # Extract the inner type from a complex type like T.nilable(String) or T.nilable(T::Array[Model]).
+      #
+      # @param type_to_unwrap [Class, Object] The type to unwrap (defaults to @type)
+      # @return [Class, Object] The inner type, or the original type if not wrapped
+      def extract_inner_type(type_to_unwrap = @type)
+        if type_to_unwrap.respond_to?(:unwrap_nilable)
+          unwrapped = type_to_unwrap.unwrap_nilable
+          # Return TypedArray directly (for T.nilable(T::Array[Model]))
+          return unwrapped if unwrapped.is_a?(T::Types::TypedArray)
+          # Return raw_type for simple types (for T.nilable(String))
+          return unwrapped.raw_type if unwrapped.respond_to?(:raw_type)
+        end
+
+        if type_to_unwrap.respond_to?(:types)
+          # For union types, find the non-nil type
+          # Prefer TypedArray if present, otherwise find type with raw_type
+          type_to_unwrap.types.find { |t| t.is_a?(T::Types::TypedArray) } ||
+            type_to_unwrap.types.find { |t| t.respond_to?(:raw_type) && t.raw_type != NilClass }
+        else
+          type_to_unwrap
+        end
+      end
+
+      # Determine the actual class for a type, handling Sorbet types.
+      #
+      # @param type_to_resolve [Class, Object] The type to resolve
+      # @return [Class, Array<Class>] The resolved class or classes
+      def get_type_class(type_to_resolve)
+        if type_to_resolve.is_a?(Class)
+          type_to_resolve
+        elsif type_to_resolve.respond_to?(:raw_type)
+          type_to_resolve.raw_type
+        elsif type_to_resolve.is_a?(T::Types::TypedArray)
+          Array
+        elsif type_to_resolve.is_a?(Symbol) || type_to_resolve.is_a?(String)
+          begin
+            type_to_resolve.to_s.classify.constantize
+          rescue StandardError
+            String
+          end
+        elsif TypeIntrospection.boolean_type?(type_to_resolve)
+          [TrueClass, FalseClass]
+        elsif nilable_type?(type_to_resolve)
+          extract_inner_type(type_to_resolve)
+        else
+          String
+        end
+      end
+    end
+  end
+end

data/lib/easy_talk/validation_adapters/none_adapter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  module ValidationAdapters
+    # No-op validation adapter.
+    #
+    # This adapter does not apply any validations. Use it when you want
+    # schema generation without any validation side effects.
+    #
+    # @example Disabling validations for a model
+    #   class ApiContract
+    #     include EasyTalk::Model
+    #
+    #     define_schema(validations: :none) do
+    #       property :name, String, min_length: 5
+    #     end
+    #   end
+    #
+    #   contract = ApiContract.new(name: 'X')
+    #   contract.valid? # => true (no validations applied)
+    #
+    # @example Using globally
+    #   EasyTalk.configure do |config|
+    #     config.validation_adapter = :none
+    #   end
+    #
+    class NoneAdapter < Base
+      # Apply no validations (no-op).
+      #
+      # @return [void]
+      def apply_validations
+        # Intentionally empty - no validations applied
+      end
+    end
+  end
+end

data/lib/easy_talk/validation_adapters/registry.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  module ValidationAdapters
+    # Registry for validation adapters.
+    #
+    # The registry allows adapters to be registered with symbolic names and
+    # resolved from various input types (symbols, classes, or nil for default).
+    #
+    # @example Registering an adapter
+    #   EasyTalk::ValidationAdapters::Registry.register(:custom, MyCustomAdapter)
+    #
+    # @example Resolving an adapter
+    #   adapter = EasyTalk::ValidationAdapters::Registry.resolve(:active_model)
+    #   adapter.build_validations(klass, :name, String, {})
+    #
+    class Registry
+      class << self
+        # Get the hash of registered adapters.
+        #
+        # @return [Hash{Symbol => Class}] The registered adapters
+        def adapters
+          @adapters ||= {}
+        end
+
+        # Register an adapter with a symbolic name.
+        #
+        # @param name [Symbol, String] The adapter identifier
+        # @param adapter_class [Class] The adapter class (must respond to .build_validations)
+        # @raise [ArgumentError] if the adapter does not respond to .build_validations
+        # @return [void]
+        def register(name, adapter_class)
+          raise ArgumentError, "Adapter must respond to .build_validations" unless adapter_class.respond_to?(:build_validations)
+
+          adapters[name.to_sym] = adapter_class
+        end
+
+        # Resolve an adapter from various input types.
+        #
+        # @param adapter [Symbol, Class, nil] The adapter identifier or class
+        #   - nil: returns the default :active_model adapter
+        #   - Symbol: looks up the adapter by name in the registry
+        #   - Class: returns the class directly (assumes it implements the adapter interface)
+        # @return [Class] The adapter class
+        # @raise [ArgumentError] if the adapter symbol is not registered or type is invalid
+        def resolve(adapter)
+          case adapter
+          when nil
+            adapters[:active_model] || raise(ArgumentError, "No default adapter registered")
+          when Symbol
+            adapters[adapter] || raise(ArgumentError, "Unknown validation adapter: #{adapter.inspect}")
+          when Class
+            adapter
+          else
+            raise ArgumentError, "Invalid adapter type: #{adapter.class}. Expected Symbol, Class, or nil."
+          end
+        end
+
+        # Check if an adapter is registered with the given name.
+        #
+        # @param name [Symbol, String] The adapter name to check
+        # @return [Boolean] true if the adapter is registered
+        def registered?(name)
+          adapters.key?(name.to_sym)
+        end
+
+        # Reset the registry (useful for testing).
+        # Re-registers the default adapters after clearing.
+        #
+        # @return [void]
+        def reset!
+          @adapters = nil
+          register_default_adapters
+        end
+
+        # Register the default validation adapters.
+        # This is called during gem initialization and after reset!
+        #
+        # @return [void]
+        def register_default_adapters
+          register(:active_model, ActiveModelAdapter)
+          register(:none, NoneAdapter)
+        end
+      end
+    end
+  end
+end