dry-schema 1.9.3 → 1.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2dead9a036c0d9322c68b50938417ebe12a4b62ed2f99a8ae6d4f49f894dabd
-  data.tar.gz: ac3b386e3266e8498aa62549cddfbaece9414281beee5710c1930b062eaacde8
+  metadata.gz: 3a3fdab16834d270d9cdfd3788fffb0899b711fc946e6aa3f4bc98115983acb7
+  data.tar.gz: c8349be888a2d957ba67137a7877828031d385e1452793730654cee3a9994e68
 SHA512:
-  metadata.gz: '0831055ac93da2898c55b6194703e87bda1c27040ac23965c5f261c2e59387888f679b9dcd967a4a0665cef220b7c97db823670067267b34b40ed09a3c315b81'
-  data.tar.gz: d82ee10469742e83ee412ebe6c06593a86c44c1e0f01fd29067700d9a37ecc461dc3e4ad6e2a09bfe4694d1e95b6c28132810bf243d27338257f66e0c50cc98e
+  metadata.gz: 23d0a177d1b2bfe8ba70ca0de182785ef9016d271e28ae36dd5590aae7f0b30d6a9ae1336948d3a862bf6b04afcc75cb2a115c3de589509cf46bd4a471c5e054
+  data.tar.gz: 478dc03869f1913f736db5ec2c69ff17c68440463f4cf23f337ef5d3b41cc944242075ce0bc36c1971765563566eb2d86e15f54ff7e1d762f6dbd6ccb3217947

data/CHANGELOG.md

@@ -1,5 +1,64 @@
 <!--- DO NOT EDIT THIS FILE - IT'S AUTOMATICALLY GENERATED VIA DEVTOOLS --->
 
+## 1.10.4 2022-10-13
+
+
+### Fixed
+
+- Once again reverting zeitwerk related changes that were included in 1.10.3 by an accident :( (@solnic)
+
+
+[Compare v1.10.3...v1.10.4](https://github.com/dry-rb/dry-schema/compare/v1.10.3...v1.10.4)
+
+## 1.10.3 2022-10-10
+
+
+### Fixed
+
+- Addressed regressions causing issues with handling sum types (see #419 and #423 fixed via #425) (@robhanlon22)
+
+
+[Compare v1.10.2...v1.10.3](https://github.com/dry-rb/dry-schema/compare/v1.10.2...v1.10.3)
+
+## 1.10.2 2022-08-23
+
+
+### Fixed
+
+- Fix value coercion for composed schemas (via #421) (@robhanlon22)
+
+
+[Compare v1.10.1...v1.10.2](https://github.com/dry-rb/dry-schema/compare/v1.10.1...v1.10.2)
+
+## 1.10.1 2022-08-22
+
+
+### Changed
+
+- Reverted zeitwerk-related changes that were included in 1.10.0 by an accident (@solnic)
+
+[Compare v1.10.0...v1.10.1](https://github.com/dry-rb/dry-schema/compare/v1.10.0...v1.10.1)
+
+## 1.10.0 2022-08-16
+
+
+### Added
+
+- Allow nested `filled` and `value` macro usage (via #412) (@robhanlon22)
+- Support for more complex scenarios when composing schemas (via #420) (@robhanlon22)
+
+### Fixed
+
+- Fix `or` messages for complex schemas (via #413) (@robhanlon22)
+- Using `filled` with a constrained constructor type works as expected (via #416) (@robhanlon22)
+- Fix types and key maps for composed schemas (via #415) (@robhanlon22)
+
+### Changed
+
+- Freeze message hash (fixes #417 via #418) (@solnic)
+
+[Compare v1.9.3...v1.10.0](https://github.com/dry-rb/dry-schema/compare/v1.9.3...v1.10.0)
+
 ## 1.9.3 2022-06-23
 
 
@@ -165,7 +224,7 @@ This release ships with a bunch of internal refactorings that should improve per
 
 [Compare v1.5.4...v1.5.5](https://github.com/dry-rb/dry-schema/compare/v1.5.4...v1.5.5)
 
-## 1.5.4 
+## 1.5.4
 
 2020-09-03
 

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2021 dry-rb team
+Copyright (c) 2015-2022 dry-rb team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/dry-schema.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "dry-configurable", "~> 0.13", ">= 0.13.0"
   spec.add_runtime_dependency "dry-core", "~> 0.5", ">= 0.5"
   spec.add_runtime_dependency "dry-initializer", "~> 3.0"
-  spec.add_runtime_dependency "dry-logic", "~> 1.0"
+  spec.add_runtime_dependency "dry-logic", "~> 1.2"
   spec.add_runtime_dependency "dry-types", "~> 1.5"
 
   spec.add_development_dependency "bundler"

data/lib/dry/schema/dsl.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "dry/initializer"
+require "dry/logic"
 
 require "dry/schema/constants"
 require "dry/schema/path"
@@ -16,6 +17,7 @@ require "dry/schema/key_coercer"
 require "dry/schema/key_validator"
 require "dry/schema/value_coercer"
 require "dry/schema/rule_applier"
+require "dry/schema/types_merger"
 
 module Dry
   module Schema
@@ -286,13 +288,20 @@ module Dry
 
       # Return type schema used by the value coercer
       #
-      # @return [Dry::Types::Safe]
+      # @return [Dry::Types::Lax]
       #
       # @api private
       def type_schema
-        our_schema = type_registry["hash"].schema(types).lax
-        schemas = [*parents.map(&:type_schema), our_schema]
-        schemas.inject { |result, schema| result.schema(schema.to_a) }
+        strict_type_schema.lax
+      end
+
+      # Return type schema used when composing subschemas
+      #
+      # @return [Dry::Types::Schema]
+      #
+      # @api private
+      def strict_type_schema
+        type_registry["hash"].schema(types)
       end
 
       # Return a new DSL instance using the same processor type
@@ -314,9 +323,9 @@ module Dry
       # @api private
       def set_type(name, spec)
         type = resolve_type(spec)
-        meta = {required: false, maybe: type.optional?}
+        meta = {required: true, maybe: type.optional?}
 
-        types[name] = type.meta(meta)
+        @types[name] = type.meta(meta)
       end
 
       # Check if a custom type was set under provided key name
@@ -369,6 +378,18 @@ module Dry
         parents.any?(&:filter_rules?)
       end
 
+      # This DSL's type map merged with any parent type maps
+      #
+      # @api private
+      def types
+        [*parents.map(&:types), @types].reduce(:merge)
+      end
+
+      # @api private
+      def merge_types(op_class, lhs, rhs)
+        types_merger.(op_class, lhs, rhs)
+      end
+
       protected
 
       # Build a rule applier
@@ -495,6 +516,10 @@ module Dry
 
         (parent || Schema).config.dup
       end
+
+      def types_merger
+        @types_merger ||= TypesMerger.new(type_registry)
+      end
     end
   end
 end

data/lib/dry/schema/macros/array.rb

@@ -15,7 +15,7 @@ module Dry
         def value(*args, **opts, &block)
           type(:array)
 
-          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:, type_rule:|
+          extract_type_spec(args, set_type: false) do |*predicates, type_spec:, type_rule:|
             type(schema_dsl.array[type_spec]) if type_spec
 
             is_hash_block = type_spec.equal?(:hash)

data/lib/dry/schema/macros/dsl.rb

@@ -58,12 +58,13 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def value(...)
-          append_macro(Macros::Value) do |macro|
-            macro.call(...)
+        def value(*args, **opts, &block)
+          extract_type_spec(args) do |*predicates, type_spec:, type_rule:|
+            append_macro(Macros::Value) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
           end
         end
-        ruby2_keywords :value if respond_to?(:ruby2_keywords, true)
 
         # Prepends `:filled?` predicate
         #
@@ -76,12 +77,31 @@ module Dry
         # @return [Macros::Core]
         #
         # @api public
-        def filled(...)
-          append_macro(Macros::Filled) do |macro|
-            macro.call(...)
+        def filled(*args, **opts, &block)
+          extract_type_spec(args) do |*predicates, type_spec:, type_rule:|
+            append_macro(Macros::Filled) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
+          end
+        end
+
+        # Set type specification and predicates for a maybe value
+        #
+        # @example
+        #   required(:name).maybe(:string)
+        #
+        # @see Macros::Key#value
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def maybe(*args, **opts, &block)
+          extract_type_spec(args, nullable: true) do |*predicates, type_spec:, type_rule:|
+            append_macro(Macros::Maybe) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
           end
         end
-        ruby2_keywords :filled if respond_to?(:ruby2_keywords, true)
 
         # Specify a nested hash without enforced `hash?` type-check
         #
@@ -201,7 +221,7 @@ module Dry
 
         # @api private
         # rubocop: disable Metrics/PerceivedComplexity
-        def extract_type_spec(*args, nullable: false, set_type: true)
+        def extract_type_spec(args, nullable: false, set_type: true)
           type_spec = args[0] unless schema_or_predicate?(args[0])
 
           predicates = Array(type_spec ? args[1..] : args)

data/lib/dry/schema/macros/each.rb

@@ -11,13 +11,15 @@ module Dry
       # @api private
       class Each < DSL
         # @api private
-        def value(*args, **opts)
-          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:, type_rule:|
+        def value(*args, **opts, &block)
+          extract_type_spec(args, set_type: false) do |*predicates, type_spec:, type_rule:|
             if type_spec && !type_spec.is_a?(Dry::Types::Type)
               type(schema_dsl.array[type_spec])
             end
 
-            super(*predicates, type_spec: type_spec, type_rule: type_rule, **opts)
+            append_macro(Macros::Value) do |macro|
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
+            end
           end
         end
 

data/lib/dry/schema/macros/filled.rb

@@ -13,12 +13,15 @@ module Dry
         def call(*predicates, **opts, &block)
           ensure_valid_predicates(predicates)
 
-          if opts[:type_spec] && !filter_empty_string?
-            value(predicates[0], :filled?, *predicates[1..predicates.size - 1], **opts, &block)
-          elsif opts[:type_rule]
-            value(:filled?).value(*predicates, **opts, &block)
-          else
-            value(:filled?, *predicates, **opts, &block)
+          append_macro(Macros::Value) do |macro|
+            if opts[:type_spec] && !filter_empty_string?
+              macro.call(predicates[0], :filled?, *predicates[1..predicates.size - 1], **opts,
+                         &block)
+            elsif opts[:type_rule]
+              macro.call(:filled?).value(*predicates, **opts, &block)
+            else
+              macro.call(:filled?, *predicates, **opts, &block)
+            end
           end
         end
 

data/lib/dry/schema/macros/key.rb

@@ -32,67 +32,6 @@ module Dry
         end
         ruby2_keywords(:filter) if respond_to?(:ruby2_keywords, true)
 
-        # @overload value(type_spec, *predicates, **predicate_opts)
-        #   Set type specification and predicates
-        #
-        #   @param [Symbol,Types::Type,Array] type_spec
-        #   @param [Array<Symbol>] predicates
-        #   @param [Hash] predicate_opts
-        #
-        #   @example with a predicate
-        #     required(:name).value(:string, :filled?)
-        #
-        #   @example with a predicate with arguments
-        #     required(:name).value(:string, min_size?: 2)
-        #
-        #   @example with a block
-        #     required(:name).value(:string) { filled? & min_size?(2) }
-        #
-        # @return [Macros::Key]
-        #
-        # @see Macros::DSL#value
-        #
-        # @api public
-        def value(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates, type_spec:, type_rule:|
-            super(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
-          end
-        end
-
-        # Set type specification and predicates for a filled value
-        #
-        # @example
-        #   required(:name).filled(:string)
-        #
-        # @see Macros::Key#value
-        #
-        # @return [Macros::Key]
-        #
-        # @api public
-        def filled(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates, type_spec:, type_rule:|
-            super(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
-          end
-        end
-
-        # Set type specification and predicates for a maybe value
-        #
-        # @example
-        #   required(:name).maybe(:string)
-        #
-        # @see Macros::Key#value
-        #
-        # @return [Macros::Key]
-        #
-        # @api public
-        def maybe(*args, **opts, &block)
-          extract_type_spec(*args, nullable: true) do |*predicates, type_spec:, type_rule:|
-            append_macro(Macros::Maybe) do |macro|
-              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
-            end
-          end
-        end
-
         # Coerce macro to a rule
         #
         # @return [Dry::Logic::Rule]

data/lib/dry/schema/macros/maybe.rb

@@ -19,7 +19,9 @@ module Dry
             raise ::Dry::Schema::InvalidSchemaError, "Using maybe with nil? predicate is redundant"
           end
 
-          value(*args, **opts, &block)
+          append_macro(Macros::Value) do |macro|
+            macro.call(*args, **opts, &block)
+          end
 
           self
         end

data/lib/dry/schema/macros/schema.rb

@@ -30,13 +30,7 @@ module Dry
 
         # @api private
         def process_operation(op)
-          schemas = op.rules.select { |rule| rule.is_a?(Processor) }
-
-          hash_schema = hash_type.schema(
-            schemas.map(&:schema_dsl).map(&:types).reduce(:merge)
-          )
-
-          type(hash_schema)
+          type(hash_type.schema(merge_operation_types(op)))
         end
 
         # @api private
@@ -44,6 +38,23 @@ module Dry
           schema_dsl.resolve_type(:hash)
         end
 
+        # @api private
+        def merge_operation_types(op)
+          op.rules.reduce({}) do |acc, rule|
+            types =
+              case rule
+              when Dry::Logic::Operations::Abstract
+                merge_operation_types(rule)
+              when Processor
+                rule.types
+              else
+                EMPTY_HASH.dup
+              end
+
+            schema_dsl.merge_types(op.class, acc, types)
+          end
+        end
+
         # @api private
         # rubocop: disable Metrics/AbcSize
         def define(*args, &block)
@@ -51,11 +62,11 @@ module Dry
           schema = definition.call
           type_schema =
             if array_type?(parent_type)
-              build_array_type(parent_type, definition.type_schema)
+              build_array_type(parent_type, definition.strict_type_schema)
             elsif redefined_schema?(args)
               parent_type.schema(definition.types)
             else
-              definition.type_schema
+              definition.strict_type_schema
             end
           final_type = optional? ? type_schema.optional : type_schema
 

data/lib/dry/schema/macros/value.rb

@@ -30,9 +30,9 @@ module Dry
 
             updated_type =
               if array_type?(current_type)
-                build_array_type(current_type, schema.type_schema)
+                build_array_type(current_type, schema.strict_type_schema)
               else
-                schema.type_schema
+                schema.strict_type_schema
               end
 
             import_steps(schema)

data/lib/dry/schema/message/or/multi_path.rb

@@ -34,17 +34,16 @@ module Dry
             end
           end
 
-          # @api private
-          def self.handler(message)
-            handlers.find { |k,| message.is_a?(k) }&.last
-          end
+          MESSAGE_ARRAY_HANDLER = -> { MessageArray.new(_1) }
 
           # @api private
-          private_class_method def self.handlers
-            @handlers ||= {
-              self => -> { _1 },
-              Array => -> { MessageArray.new(_1) }
-            }.freeze
+          def self.handler(message)
+            case message
+            when self
+              IDENTITY
+            when Array
+              MESSAGE_ARRAY_HANDLER
+            end
           end
 
           # @api public
@@ -59,7 +58,7 @@ module Dry
 
           # @api private
           def root
-            @root ||= _messages.flat_map(&:_paths).reduce(:&)
+            @root ||= _paths.reduce(:&)
           end
 
           # @api private
@@ -67,9 +66,14 @@ module Dry
             root
           end
 
+          # @api private
+          def _path
+            @_path ||= Path[root]
+          end
+
           # @api private
           def _paths
-            @paths ||= [Path[root]]
+            @paths ||= _messages.flat_map(&:_paths)
           end
 
           # @api private

data/lib/dry/schema/message/or/single_path.rb

@@ -21,10 +21,11 @@ module Dry
 
           # @api private
           def initialize(*args, messages)
-            super(*args)
+            super(*args.map { [_1].flatten })
             @messages = messages
-            @path = left.path
-            @_path = left._path
+            message = left.first
+            @path = message.path
+            @_path = message._path
           end
 
           # Dump a message into a string
@@ -38,7 +39,7 @@ module Dry
           #
           # @api public
           def dump
-            @dump ||= "#{left.dump} #{messages[:or]} #{right.dump}"
+            @dump ||= [*left, *right].map(&:dump).join(" #{messages[:or]} ")
           end
           alias_method :to_s, :dump
 
@@ -55,7 +56,16 @@ module Dry
 
           # @api private
           def to_a
-            @to_a ||= [left, right]
+            @to_a ||= [*left, *right]
+          end
+
+          # @api private
+          def to_or(root)
+            to_ored = [left, right].map do |msgs|
+              msgs.map { _1.to_or(root) }
+            end
+
+            self.class.new(*to_ored, messages)
           end
         end
       end

data/lib/dry/schema/message_set.rb

@@ -105,7 +105,7 @@ module Dry
 
       # @api private
       def messages_map(messages = self.messages)
-        combine_message_hashes(messages.map(&:to_h))
+        combine_message_hashes(messages.map(&:to_h)).freeze
       end
 
       # @api private

data/lib/dry/schema/processor.rb

@@ -138,13 +138,22 @@ module Dry
 
       # Return the type schema
       #
-      # @return [Dry::Types::Safe]
+      # @return [Dry::Types::Lax]
       #
       # @api private
       def type_schema
         steps.type_schema
       end
 
+      # Return type schema used when composing subschemas
+      #
+      # @return [Dry::Types::Schema]
+      #
+      # @api private
+      def strict_type_schema
+        schema_dsl.strict_type_schema
+      end
+
       # Return the rule applier
       #
       # @api private
@@ -188,6 +197,13 @@ module Dry
         rule_applier.rules
       end
 
+      # Return the types from the schema DSL
+      #
+      # @api private
+      def types
+        schema_dsl.types
+      end
+
       # Check if there are filter rules
       #
       # @api private

data/lib/dry/schema/types_merger.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Dry
+  module Schema
+    # Combines multiple logical operations into a single type, taking into
+    # account the type of logical operation (or, and, implication) and the
+    # underlying types (schemas, nominals, etc.)
+    #
+    # @api private
+    class TypesMerger
+      attr_reader :type_registry
+
+      # @api private
+      class ValueMerger
+        attr_reader :types_merger
+        attr_reader :op_class
+        attr_reader :old
+        attr_reader :new
+
+        # @api private
+        def initialize(types_merger, op_class, old, new)
+          @types_merger = types_merger
+          @op_class = op_class
+          @old = old
+          @new = new
+        end
+
+        # @api private
+        def call
+          if op_class <= Dry::Logic::Operations::Or
+            merge_or
+          elsif op_class <= Dry::Logic::Operations::And
+            merge_and
+          elsif op_class <= Dry::Logic::Operations::Implication
+            merge_implication
+          else
+            raise ArgumentError, <<~MESSAGE
+              Can't merge operations, op_class=#{op_class}
+            MESSAGE
+          end
+        end
+
+        private
+
+        # @api private
+        def merge_or
+          old | new
+        end
+
+        # @api private
+        def merge_ordered
+          return old if old == new
+
+          unwrapped_old, old_rule = unwrap_type(old)
+          unwrapped_new, new_rule = unwrap_type(new)
+
+          type = merge_unwrapped_types(unwrapped_old, unwrapped_new)
+
+          rule = [old_rule, new_rule].compact.reduce { op_class.new(_1, _2) }
+
+          type = Dry::Types::Constrained.new(type, rule: rule) if rule
+
+          type
+        end
+
+        alias_method :merge_and, :merge_ordered
+        alias_method :merge_implication, :merge_ordered
+
+        # @api private
+        def merge_unwrapped_types(unwrapped_old, unwrapped_new)
+          case [unwrapped_old, unwrapped_new]
+          in Dry::Types::Schema, Dry::Types::Schema
+            merge_schemas(unwrapped_old, unwrapped_new)
+          in [Dry::Types::AnyClass, _] | [Dry::Types::Hash, Dry::Types::Schema]
+            unwrapped_new
+          in [Dry::Types::Schema, Dry::Types::Hash] | [_, Dry::Types::AnyClass]
+            unwrapped_old
+          else
+            merge_equivalent_types(unwrapped_old, unwrapped_new)
+          end
+        end
+
+        # @api private
+        def merge_schemas(unwrapped_old, unwrapped_new)
+          types_merger.type_registry["hash"].schema(
+            types_merger.call(
+              op_class,
+              unwrapped_old.name_key_map,
+              unwrapped_new.name_key_map
+            )
+          )
+        end
+
+        # @api private
+        def merge_equivalent_types(unwrapped_old, unwrapped_new)
+          if unwrapped_old.primitive <= unwrapped_new.primitive
+            unwrapped_new
+          elsif unwrapped_new.primitive <= unwrapped_old.primitive
+            unwrapped_old
+          else
+            raise ArgumentError, <<~MESSAGE
+              Can't merge types, unwrapped_old=#{unwrapped_old.inspect}, unwrapped_new=#{unwrapped_new.inspect}
+            MESSAGE
+          end
+        end
+
+        # @api private
+        def unwrap_type(type)
+          rules = []
+
+          loop do
+            rules << type.rule if type.respond_to?(:rule)
+
+            if type.optional?
+              type = type.left.primitive?(nil) ? type.right : type.left
+            elsif type.is_a?(Dry::Types::Decorator)
+              type = type.type
+            else
+              break
+            end
+          end
+
+          [type, rules.reduce(:&)]
+        end
+      end
+
+      def initialize(type_registry = TypeRegistry.new)
+        @type_registry = type_registry
+      end
+
+      # @api private
+      def call(op_class, lhs, rhs)
+        lhs.merge(rhs) do |_k, old, new|
+          ValueMerger.new(self, op_class, old, new).call
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Schema
-    VERSION = "1.9.3"
+    VERSION = "1.10.4"
   end
 end

data/lib/dry/schema.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "dry/core/extensions"
+require "dry/configurable"
+require "dry/logic"
 
 require "dry/schema/config"
 require "dry/schema/constants"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-schema
 version: !ruby/object:Gem::Version
-  version: 1.9.3
+  version: 1.10.4
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-23 00:00:00.000000000 Z
+date: 2022-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -84,14 +84,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: dry-types
   requirement: !ruby/object:Gem::Requirement
@@ -230,6 +230,7 @@ files:
 - lib/dry/schema/type_container.rb
 - lib/dry/schema/type_registry.rb
 - lib/dry/schema/types.rb
+- lib/dry/schema/types_merger.rb
 - lib/dry/schema/value_coercer.rb
 - lib/dry/schema/version.rb
 homepage: https://dry-rb.org/gems/dry-schema