datacaster 4.2.1 → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 351d202f9afcb51c391c23e852f4d9d289a60df1a4f890473f532aac47ca668c
-  data.tar.gz: '031040811b8f5a2c319c5c48295c44d347f76dcb52fbfaeadd37f586f0d06582'
+  metadata.gz: 0072ba53600fb794462c13dba4fe31c9134aac67e5a7687f0e91e17483cf10b1
+  data.tar.gz: b35c2f8b667d884bcf641be2d79747c65a68b97a7da20abc718776b3fe532af6
 SHA512:
-  metadata.gz: c53e86295d1f47bc80d0d5e1805b5076e85f8ded528f14039ebcbd88a810bd4e8e4897b16a41b30422c8b18556049a54256ce60fa5fecc04c176cda3de363890
-  data.tar.gz: 67111b7dfa26fcfc844ca33336f884738a961c9629e01486ad4cef5423406f33ec030d92746e32c66739c624a0d0b0c6b9a89c8609dc40d0509cdf85298767ec
+  metadata.gz: 16903213c77a60b38d8a034ac88b39deaddf926474fcc9eeb575c7633d4742a3aab51c1a6e56b094bcbbc6dff5ae5ed5911a9c4e17bd12cc14df51f1f230e790
+  data.tar.gz: 5f3da501cb763c39f330cc8406bbd9a4e6db76db255612884c92fbb89a5fca0f8d8f81f72295941bc078b969bf5a3f1e2cfd1552eccda9cff30930c244398961

data/.github/workflows/rspec.yml

@@ -6,7 +6,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['3.1', '3.2', '3.3']
+        ruby-version: ['3.2', '3.3', '3.4']
     steps:
     - uses: actions/checkout@v3
     - name: Set up Ruby

data/README.md

@@ -332,7 +332,7 @@ Notice that OR operator, if left-hand validation fails, passes the original valu
 
 #### *IF... THEN... ELSE operator*
 
-Let's support we want to run different validations depending on some value, e.g.:
+Let's suppose we want to run different validations depending on some value, e.g.:
 
 * if 'salary' is more than 100_000, check for the additional key, 'passport'
 * otherwise, ensure 'passport' key is absent
@@ -373,7 +373,7 @@ Formally, with `a.then(b).else(c)`:
 
 Note: this construct is *not* an equivalent of `a & b | c`.
 
-With `a.then(b).else(c)` if `a` and `b` fails, then `b`'s error is returned. With `a & b | c`, instead, `c`'s result would be returned.
+With `a.then(b).else(c)` if `a` passes and `b` fails, then `b`'s error is returned. With `a & b | c`, instead, `c`'s result would be returned.
 
 #### *SWITCH... ON... ELSE operator*
 
@@ -1128,13 +1128,13 @@ To define compound data type, array of 'something', use `array_schema(something)
 salaries = Datacaster.schema { array_of(integer) }
 
 salaries.([1000, 2000, 3000]) # Datacaster::ValidResult([1000, 2000, 3000])
+salaries.([])                 # Datacaster::ValidResult([])
 
 salaries.(["one thousand"])   # Datacaster::ErrorResult({0=>["is not an integer"]})
 salaries.(:not_an_array)      # Datacaster::ErrorResult(["should be an array"])
-salaries.([])                 # Datacaster::ErrorResult(["should not be empty"])
 ```
 
-To allow empty array use the following construct: `compare([]) | array_of(...)`.
+To disallow empty array use the following construct: `array_of(..., allow_empty: false)`.
 
 If you want to define an array of hashes, [shortcut definition](#shortcut-nested-definitions) could be used: instead of `array_of(hash_schema({...}))` use `array_of({...})`:
 
@@ -1371,11 +1371,11 @@ Had we used `schema` everywhere, `CommonFieldsValidator` would return failure fo
 
 As a rule of thumb, use `partial_schema` in any "intermediary" validators (extracted for the sake of clarity of code and reusability) and use `schema` in any "end" validators (ones which receive full record as input and use intermediary validators behind the scenes).
 
-Lastly, if you want to just delete extra unvalidated keys without returning a error, use `choosy_schema`.
+Lastly, if you want to just delete extra unvalidated keys without returning an error, use `choosy_schema`.
 
 #### AND with error aggregation (`*`)
 
-Often it is useful to run validator which are "further down the conveyor" (i.e. placed at the right-hand side of AND operator `&`) even if current (i.e. left-hand side) validator has failed.
+Often it is useful to run validators which are "further down the conveyor" (i.e. placed at the right-hand side of AND operator `&`) even if current (i.e. left-hand side) validator has failed.
 
 Let's say we have extracted some "common validations" and have some concrete validators, which utilize these reusable common validations (more or less repeating the motif of the previous example, shortening non-essential for this section parts for clarity):
 
@@ -1793,7 +1793,7 @@ All keyword arguments of `#i18n_key`, `#i18n_scope` and designed for that sole p
 
 It is possible to add i18n variables at the runtime (e.g. inside `check { ... }` block) by calling `i18n_vars!(variable: 'value')` or `i18n_var!(:variable, 'value')`.
 
-Outer calls of `#i18n_key` (`#i18n_scope`, `#i18n_vars`) have presedence before the inner if variable names collide. However, runtime calls of `#i18n_vars!` and `#i18n_var!` overwrite compile-time variables from the next nearest key, scope or vars on collision.
+Outer calls of `#i18n_key` (`#i18n_scope`, `#i18n_vars`) have precedence before the inner if variable names collide. However, runtime calls of `#i18n_vars!` and `#i18n_var!` overwrite compile-time variables from the next nearest key, scope or vars on collision.
 
 ## Registering custom 'predefined' types
 

data/config/locales/en.yml

@@ -27,6 +27,7 @@ en:
       relate: "%{left} should be %{op} %{right}"
       responds_to: "does not respond to %{reference}"
       string: is not a string
+      boolean: is not a boolean
       to_boolean: does not look like a boolean
       to_float: does not look like a float
       to_integer: does not look like an integer

data/lib/datacaster/and_node.rb

@@ -14,6 +14,33 @@ module Datacaster
       )
     end
 
+    def to_json_schema
+      result =
+        @casters.reduce(JsonSchemaResult.new) do |result, caster|
+          result.apply(caster.to_json_schema, caster.to_json_schema_attributes)
+        end
+
+      mapping =
+        @casters.reduce({}) do |result, caster|
+          result.merge(caster.to_json_schema_attributes[:remaped])
+        end
+
+      result.remap(mapping)
+    end
+
+    def to_json_schema_attributes
+      super.merge(
+        required:
+          @casters.any? { |caster| caster.to_json_schema_attributes[:required] },
+        picked:
+          @casters.flat_map { |caster| caster.to_json_schema_attributes[:picked] },
+        remaped:
+          @casters.reduce({}) do |result, caster|
+            result.merge(caster.to_json_schema_attributes[:remaped])
+          end
+      )
+    end
+
     def inspect
       "#<Datacaster::AndNode casters: #{@casters.inspect}>"
     end

data/lib/datacaster/and_with_error_aggregation_node.rb

@@ -22,6 +22,20 @@ module Datacaster
       end
     end
 
+
+    def to_json_schema
+      [@left, @right].reduce(JsonSchemaResult.new) do |result, caster|
+        result.apply(caster.to_json_schema)
+      end
+    end
+
+    def to_json_schema_attributes
+      super.merge(
+        required:
+          [@left, @right].any? { |caster| caster.to_json_schema_attributes[:required] }
+      )
+    end
+
     def inspect
       "#<Datacaster::AndWithErrorAggregationNode L: #{@left.inspect} R: #{@right.inspect}>"
     end

data/lib/datacaster/array_schema.rb

@@ -1,7 +1,8 @@
 module Datacaster
   class ArraySchema < Base
-    def initialize(element_caster, error_keys = {})
+    def initialize(element_caster, error_keys = {}, allow_empty: true)
       @element_caster = element_caster
+      @allow_empty = allow_empty
 
       @not_array_error_keys = ['.array', 'datacaster.errors.array']
       @not_array_error_keys.unshift(error_keys[:array]) if error_keys[:array]
@@ -12,7 +13,7 @@ module Datacaster
 
     def cast(array, runtime:)
       return Datacaster.ErrorResult(I18nValues::Key.new(@not_array_error_keys, value: array)) if !array.respond_to?(:map) || !array.respond_to?(:zip)
-      return Datacaster.ErrorResult(I18nValues::Key.new(@empty_error_keys, value: array)) if array.empty?
+      return Datacaster.ErrorResult(I18nValues::Key.new(@empty_error_keys, value: array)) if array.empty? && !@allow_empty
 
       runtime.will_check!
 
@@ -30,6 +31,13 @@ module Datacaster
       end
     end
 
+    def to_json_schema
+      JsonSchemaResult.new({
+        'type' => 'array',
+        'items' => @element_caster.to_json_schema
+      })
+    end
+
     def inspect
       "#<Datacaster::ArraySchema [#{@element_caster.inspect}]>"
     end

data/lib/datacaster/context_node.rb

@@ -10,6 +10,14 @@ module Datacaster
       transform_result(result)
     end
 
+    def to_json_schema
+      @base.to_json_schema
+    end
+
+    def to_json_schema_attributes
+      @base.to_json_schema_attributes
+    end
+
     def inspect
       "#<#{self.class.name} base: #{@base.inspect}>"
     end

data/lib/datacaster/hash_mapper.rb

@@ -72,6 +72,28 @@ module Datacaster
       end
     end
 
+    def to_json_schema
+      result = @fields.values.reduce(JsonSchemaResult.new) do |result, caster|
+        result.apply(caster.to_json_schema)
+      end
+
+      result.without_focus
+    end
+
+    def to_json_schema_attributes
+      super.merge(
+        remaped: @fields.flat_map do |key, caster|
+          picked = caster.to_json_schema_attributes[:picked]
+
+          if picked.any?
+            picked.map { |picked| { picked.to_s => key.to_s } }
+          else
+            { nil => key.to_s }
+          end
+        end.reduce(&:merge)
+      )
+    end
+
     def inspect
       field_descriptions =
         @fields.map do |k, v|

data/lib/datacaster/hash_schema.rb

@@ -42,6 +42,16 @@ module Datacaster
       end
     end
 
+    def to_json_schema
+      not_hidden_fields = @fields.reject { |_k ,v| v.to_json_schema_attributes[:hidden] }
+
+      JsonSchemaResult.new({
+        "type" => "object",
+        "properties" => not_hidden_fields.map { |k, v| [k.to_s, v.to_json_schema] }.to_h,
+        "required" => not_hidden_fields.select { |_k ,v| v.to_json_schema_attributes[:required] }.keys.map(&:to_s),
+      })
+    end
+
     def inspect
       field_descriptions =
         @fields.map do |k, v|

data/lib/datacaster/json_schema_attributes.rb

@@ -0,0 +1,28 @@
+module Datacaster
+  class JsonSchemaAttributes < Base
+    def initialize(base, schema_attributes = {}, &block)
+      @base = base
+      @schema_attributes = schema_attributes
+      @block = block
+    end
+
+    def cast(object, runtime:)
+      @base.cast(object, runtime: runtime)
+    end
+
+    def to_json_schema_attributes
+      result = @base.to_json_schema_attributes
+      result = result.merge(@schema_attributes)
+      result = @block.(result) if @block
+      result
+    end
+
+    def to_json_schema
+      @base.to_json_schema
+    end
+
+    def inspect
+      "#<#{self.class.name} base: #{@base.inspect}>"
+    end
+  end
+end

data/lib/datacaster/json_schema_node.rb

@@ -0,0 +1,28 @@
+module Datacaster
+  class JsonSchemaNode < Base
+    def initialize(base, schema_attributes = {}, &block)
+      @base = base
+      @schema_attributes = schema_attributes.transform_keys(&:to_s)
+      @block = block
+    end
+
+    def cast(object, runtime:)
+      @base.cast(object, runtime: runtime)
+    end
+
+    def to_json_schema
+      result = @base.to_json_schema
+      result = result.apply(@schema_attributes)
+      result = @block.(result) if @block
+      result
+    end
+
+    def to_json_schema_attributes
+      @base.to_json_schema_attributes
+    end
+
+    def inspect
+      "#<#{self.class.name} base: #{@base.inspect}>"
+    end
+  end
+end

data/lib/datacaster/json_schema_result.rb

@@ -0,0 +1,239 @@
+module Datacaster
+  class JsonSchemaResult < Hash
+    def initialize(from = {}, focus = nil)
+      merge!(from)
+
+      if from.is_a?(self.class)
+        @focus = from.focus
+      else
+        @focus = []
+      end
+
+      if focus == false || @focus == false
+        @focus = false
+        return
+      end
+
+      @focus << focus if focus
+      @target = self
+      @focus.each { |k| @target = @target['properties'][k] }
+    end
+
+    def with_focus_key(key)
+      result = apply(
+        "type" => "object",
+        "properties" => key ? { key => {} } : {}
+      )
+      self.class.new(result, key)
+    end
+
+    def without_focus
+      self.class.new(self).reset_focus
+    end
+
+    def remap(mapping)
+      return self if mapping.empty?
+
+      if self['oneOf'] || self['anyOf']
+        type = self.keys.first
+
+        self[type] = self[type].map { |props| object_remap(props, mapping) }
+      else
+        object_remap(self, mapping)
+      end
+
+      self
+    end
+
+    def object_remap(value, mapping)
+      return value unless value['type'] == 'object'
+
+      mapping.each do |from, to|
+        from_props = value['properties'][from] || {}
+        to_props = value['properties'][to] || {}
+
+        one_to_one_remap = mapping.values.count { _1 == to } == 1
+
+        properties_from = value['properties'].delete(from)
+        properties_to = value['properties'].delete(to)
+
+        if from && (properties_to || properties_from)
+          value['properties'][from] =
+            if one_to_one_remap
+              Datacaster::Utils.deep_merge(to_props, from_props)
+            else
+              self.class.new(properties_from || {})
+            end
+        end
+
+        required_from = value['required']&.delete(from)
+        required_to = value['required']&.delete(to)
+
+        if from && one_to_one_remap && (required_from || required_to)
+          value['required'] << from
+        end
+      end
+
+      value
+    end
+
+    def apply(other, schema_attributes = {})
+      return self if other.nil? || other.empty?
+      return JsonSchemaResult.new(other) if empty?
+
+      if @focus && !@focus.empty?
+        return with_updated_target(JsonSchemaResult.new(@target).apply(other))
+      end
+
+      # validations after pick(a, b) & transform
+      self_type = self['type']
+      other_type = other['type']
+
+      if (self_type == 'object' || self_type == 'array') && (other_type != 'object' && other_type != 'array')
+        return JsonSchemaResult.new(self)
+      end
+
+      result = self.class.new({})
+
+      if self['required'] || other['required']
+        result['required'] = (
+          (self['required'] || []).to_set | (other['required'] || []).to_set
+        ).to_a
+      end
+
+      nested =
+        if self['properties'] && (other['items'] || self['items']) ||
+          self['items'] && (self['properties'] || other['properties']) ||
+          other['items'] && other['properties']
+          raise RuntimeError, "can't merge json schemas due to wrong items/properties combination " \
+            "for #{self.inspect} and #{other.inspect}", caller
+        elsif self['properties'] || other['properties']
+          'properties'
+        elsif self['items'] || other['items']
+          'items'
+        else
+          nil
+        end
+
+      if nested
+        result[nested] = {}
+
+        keys = (self[nested] || {}).keys + (other[nested] || {}).keys
+        keys = keys.to_set
+
+        keys.each do |k|
+          one_k = self[nested] && self[nested][k] || {}
+          two_k = other[nested] && other[nested][k] || {}
+
+          if !one_k.is_a?(Hash) || !two_k.is_a?(Hash)
+            if one_k.empty? && !two_k.is_a?(Hash)
+              result[nested][k] = two_k
+            elsif two_k.empty? && !one_k.is_a?(Hash)
+              result[nested][k] = one_k
+            elsif one_k == two_k
+              result[nested][k] = one_k
+            else
+              raise RuntimeError, "can't merge json schemas due to wrong items/properties combination " \
+                "for #{self.inspect} and #{other.inspect}", caller
+            end
+          elsif one_k.is_a?(Hash) && two_k.is_a?(Hash)
+            result[nested][k] = self.class.new(one_k).apply(two_k)
+          else
+            raise RuntimeError, "can't merge json schemas due to wrong items/properties combination " \
+              "for #{self.inspect} and #{other.inspect}", caller
+          end
+
+        end
+      end
+
+      if self['description'] || other['description']
+        result['description'] = other['description'] || self['description']
+      end
+
+      (self.keys + other.keys - %w(required properties items description)).to_set.each do |k|
+        # used to merge switch schemas
+        # TODO: подумать как сделать в обратную сторону
+        #     FULL_DETAILS_SCHEMA = Datacaster.partial_schema do
+            #   LoanTransferMethods::InitiatorTransferDetailsStruct.schema & switch(
+            #     :kind,
+            #     product: hash_schema(
+            #       currency: string,
+            #       us_only: boolean,
+            #       name: string,
+            #       values: array_of(integer),
+            #       official_provider_name: string,
+            #     )
+            #   ).else(pass)
+            # end
+
+        if schema_attributes[:extendable]
+          case k
+          in 'oneOf'
+            self_one_of = self[k]
+            other_one_of = other[k]
+
+            result_objects = other_one_of.map do |other_obj|
+              other_obj_properties = other_obj['properties'].to_a
+
+              max_same = -1
+
+              # basicly is guessing here, but must be ok in most cases
+              merge_candidate = self_one_of.max_by do |self_obj|
+                next -1 if self_obj.empty?
+
+                self_obj_properties = self_obj['properties'].to_a
+
+                max_same = (self_obj_properties & other_obj_properties).size
+
+                max_same
+              end
+
+              next other_obj if max_same < 1
+
+              Datacaster::Utils.deep_merge(other_obj, merge_candidate)
+            end
+
+            next result[k] = result_objects
+          else
+            raise RuntimeError, "can't merge json schemas due to conflicting field #{k} for " \
+              "#{inspect} and #{other.inspect}", caller
+          end
+        else
+          if self[k] && other[k] && self[k] != other[k]
+            raise RuntimeError, "can't merge json schemas due to conflicting field #{k} for " \
+              "#{inspect} and #{other.inspect}", caller
+          end
+        end
+
+        result[k] = other[k] || self[k]
+      end
+
+      result
+    end
+
+    protected
+
+    def focus
+      @focus
+    end
+
+    def reset_focus
+      @focus = []
+      @target = self
+      self
+    end
+
+    private
+
+    def with_updated_target(target)
+      result = self.class.new(self)
+      nested =
+        @focus[0..-2].reduce(result) do |result, k|
+          result['properties'][k] = result['properties'][k].dup
+          result['properties'][k]
+        end
+      nested['properties'][@focus[-1]] = target
+      result
+    end
+  end
+end

data/lib/datacaster/mixin.rb

@@ -81,5 +81,27 @@ module Datacaster
     def inspect
       "#<Datacaster::Base>"
     end
+
+    def json_schema(schema_attributes = {}, &block)
+      JsonSchemaNode.new(self, schema_attributes, &block)
+    end
+
+    def json_schema_attributes(schema_attributes = {}, &block)
+      JsonSchemaAttributes.new(self, schema_attributes, &block)
+    end
+
+    def to_json_schema_attributes
+      {
+        required: true,
+        extendable: false,
+        remaped: {},
+        picked: [],
+        hidden: false
+      }
+    end
+
+    def to_json_schema
+      JsonSchemaResult.new
+    end
   end
 end

data/lib/datacaster/or_node.rb

@@ -13,6 +13,20 @@ module Datacaster
       @right.with_runtime(runtime).(object)
     end
 
+    def to_json_schema
+      JsonSchemaResult.new({
+        "anyOf" => [@left, @right].map(&:to_json_schema)
+      })
+    end
+
+    def to_json_schema_attributes
+      super.merge(
+        required:
+          @left.to_json_schema_attributes[:required] &&
+            @right.to_json_schema_attributes[:required]
+      )
+    end
+
     def inspect
       "#<Datacaster::OrNode L: #{@left.inspect} R: #{@right.inspect}>"
     end

data/lib/datacaster/predefined.rb

@@ -13,7 +13,13 @@ module Datacaster
     end
 
     def compare(value, error_key = nil)
-      Comparator.new(value, error_key)
+      comparator = Comparator.new(value, error_key)
+
+      if value.nil?
+        comparator.json_schema(type: 'null')
+      else
+        comparator.json_schema(enum: [value])
+      end
     end
 
     def run(&block)
@@ -34,8 +40,8 @@ module Datacaster
       Trier.new(catched_exception, error_key, &block)
     end
 
-    def array_schema(element_caster, error_keys = {})
-      ArraySchema.new(DefinitionDSL.expand(element_caster), error_keys)
+    def array_schema(element_caster, error_keys = {}, allow_empty: true)
+      ArraySchema.new(DefinitionDSL.expand(element_caster), error_keys, allow_empty:)
     end
     alias_method :array_of, :array_schema
 
@@ -98,7 +104,7 @@ module Datacaster
             I18nValues::Key.new(error_keys, value: x)
           )
         end
-      end
+      end.json_schema_attributes(required: false)
     end
 
     def any(error_key = nil)
@@ -135,7 +141,7 @@ module Datacaster
         else
           x
         end
-      end
+      end.json_schema_attributes(required: false)
     end
 
     def merge_message_keys(*keys)
@@ -149,8 +155,11 @@ module Datacaster
     end
 
     def optional(base, on: nil)
-      return absent | base if on == nil
-      cast do |x|
+      if on == nil
+        return (absent | base).json_schema { base.to_json_schema }.json_schema_attributes(required: false)
+      end
+
+      caster = cast do |x|
         if x == Datacaster.absent ||
           (!on.nil? && x.respond_to?(on) && x.public_send(on))
           Datacaster.ValidResult(Datacaster.absent)
@@ -158,10 +167,15 @@ module Datacaster
           base.(x)
         end
       end
+
+      caster
+        .json_schema(base.to_json_schema)
+        .json_schema_attributes(required: false)
     end
 
     def pass
       cast { |v| Datacaster::ValidResult(v) }
+        .json_schema_attributes(required: false)
     end
 
     def pass_if(base)
@@ -189,6 +203,19 @@ module Datacaster
         end
       end
 
+      json_schema = -> (previous) do
+        previous = previous.apply({
+          'type' => 'object',
+          'properties' => keys.map { |k, v| [k.to_s, JsonSchemaResult.new] }.to_h
+        })
+
+        if keys.length == 1
+          previous.with_focus_key(keys[0].to_s)
+        else
+          previous.with_focus_key(false)
+        end
+      end
+
       must_be(Enumerable) & cast { |input|
         result =
           keys.map do |key|
@@ -200,7 +227,7 @@ module Datacaster
           end
         result = keys.length == 1 ? result.first : result
         Datacaster::ValidResult(result)
-      }
+      }.json_schema(&json_schema).json_schema_attributes(picked: keys)
     end
 
     def relate(left, op, right, error_key: nil)
@@ -277,7 +304,8 @@ module Datacaster
     end
 
     def transform_to_value(value)
-      transform { Datacaster::Utils.deep_freeze(value) }
+      value = Datacaster::Utils.deep_freeze(value)
+      transform { value }
     end
 
     def with(keys, caster)
@@ -299,7 +327,9 @@ module Datacaster
     def numeric(error_key = nil)
       error_keys = ['.numeric', 'datacaster.errors.numeric']
       error_keys.unshift(error_key) if error_key
-      check { |x| x.is_a?(Numeric) }.i18n_key(*error_keys)
+      check { |x| x.is_a?(Numeric) }.
+        i18n_key(*error_keys).
+        json_schema(oneOf: [{ 'type' => 'string' }, { 'type' => 'number' }])
     end
 
     def decimal(digits = 8, error_key = nil)
@@ -311,32 +341,39 @@ module Datacaster
         Float(x)
 
         BigDecimal(x, digits)
-      end.i18n_key(*error_keys)
+      end.i18n_key(*error_keys).json_schema(type: 'string')
     end
 
     def array(error_key = nil)
       error_keys = ['.array', 'datacaster.errors.array']
       error_keys.unshift(error_key) if error_key
-      check { |x| x.is_a?(Array) }.i18n_key(*error_keys)
+
+      check { |x| x.is_a?(Array) }.
+        i18n_key(*error_keys).
+        json_schema(type: 'array')
     end
 
     def float(error_key = nil)
       error_keys = ['.float', 'datacaster.errors.float']
       error_keys.unshift(error_key) if error_key
-      check { |x| x.is_a?(Float) }.i18n_key(*error_keys)
+      check { |x| x.is_a?(Float) }.i18n_key(*error_keys).
+        json_schema(type: 'number', format: 'float')
     end
 
     def pattern(regexp, error_key = nil)
       error_keys = ['.pattern', 'datacaster.errors.pattern']
       error_keys.unshift(error_key) if error_key
-      string(error_key) & check { |x| x.match?(regexp) }.i18n_key(*error_keys, reference: regexp.inspect)
+      string(error_key) & check { |x| x.match?(regexp) }.i18n_key(*error_keys, reference: regexp.inspect).
+        json_schema(pattern: regexp.inspect)
     end
 
     # 'hash' would be a bad method name, because it would override built in Object#hash
     def hash_value(error_key = nil)
       error_keys = ['.hash_value', 'datacaster.errors.hash_value']
       error_keys.unshift(error_key) if error_key
-      check { |x| x.is_a?(Hash) }.i18n_key(*error_keys)
+      check { |x| x.is_a?(Hash) }.
+        i18n_key(*error_keys).
+        json_schema(type: 'object', additionalProperties: true)
     end
 
     def hash_with_symbolized_keys(error_key = nil)
@@ -346,19 +383,23 @@ module Datacaster
     def included_in(values, error_key: nil)
       error_keys = ['.included_in', 'datacaster.errors.included_in']
       error_keys.unshift(error_key) if error_key
-      check { |x| values.include?(x) }.i18n_key(*error_keys, reference: values.map(&:to_s).join(', '))
+      check { |x| values.include?(x) }.
+        i18n_key(*error_keys, reference: values.map(&:to_s).join(', ')).
+        json_schema(enum: values)
     end
 
     def integer(error_key = nil)
       error_keys = ['.integer', 'datacaster.errors.integer']
       error_keys.unshift(error_key) if error_key
-      check { |x| x.is_a?(Integer) }.i18n_key(*error_keys)
+      check { |x| x.is_a?(Integer) }.i18n_key(*error_keys).
+        json_schema(type: 'integer')
     end
 
     def integer32(error_key = nil)
       error_keys = ['.integer32', 'datacaster.errors.integer32']
       error_keys.unshift(error_key) if error_key
-      integer(error_key) & check { |x| x.abs <= 2_147_483_647 }.i18n_key(*error_keys)
+      integer(error_key) & check { |x| x.abs <= 2_147_483_647 }.i18n_key(*error_keys).
+        json_schema(format: 'int32')
     end
 
     def maximum(max, error_key = nil, inclusive: true)
@@ -400,7 +441,8 @@ module Datacaster
     def string(error_key = nil)
       error_keys = ['.string', 'datacaster.errors.string']
       error_keys.unshift(error_key) if error_key
-      check { |x| x.is_a?(String) }.i18n_key(*error_keys)
+      check { |x| x.is_a?(String) }.i18n_key(*error_keys).
+        json_schema(type: 'string')
     end
 
     def non_empty_string(error_key = nil)
@@ -412,7 +454,7 @@ module Datacaster
     def uuid(error_key = nil)
       error_keys = ['.uuid', 'datacaster.errors.uuid']
       error_keys.unshift(error_key) if error_key
-      string(error_key) & pattern(/\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/).i18n_key(*error_keys)
+      pattern(/\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/, error_key).i18n_key(*error_keys)
     end
 
     # Form request types
@@ -423,7 +465,8 @@ module Datacaster
 
       string(error_key) &
         try(catched_exception: [ArgumentError, TypeError]) { |x| DateTime.iso8601(x) }.
-          i18n_key(*error_keys)
+          i18n_key(*error_keys).
+          json_schema(type: 'string', format: 'date-time')
     end
 
     def to_boolean(error_key = nil)
@@ -438,7 +481,23 @@ module Datacaster
         else
           Datacaster.ErrorResult(I18nValues::Key.new(error_keys, value: x))
         end
-      end
+      end.json_schema(oneOf: [
+        { 'type' => 'string', 'enum' => ['true', 'false', '1', '0'] },
+        { 'type' => 'boolean' },
+      ])
+    end
+
+    def boolean(error_key = nil)
+      error_keys = ['.boolean', 'datacaster.errors.boolean']
+      error_keys.unshift(error_key) if error_key
+
+      cast do |x|
+        if [false, true].include?(x)
+          Datacaster.ValidResult(x)
+        else
+          Datacaster.ErrorResult(I18nValues::Key.new(error_keys, value: x))
+        end
+      end.json_schema(type:'boolean')
     end
 
     def to_float(error_key = nil)
@@ -447,7 +506,7 @@ module Datacaster
 
       Trier.new([ArgumentError, TypeError]) do |x|
         Float(x)
-      end.i18n_key(*error_keys)
+      end.i18n_key(*error_keys).json_schema(type: 'number', format: 'float')
     end
 
     def to_integer(error_key = nil)
@@ -456,7 +515,7 @@ module Datacaster
 
       Trier.new([ArgumentError, TypeError]) do |x|
         Integer(x)
-      end.i18n_key(*error_keys)
+      end.i18n_key(*error_keys).json_schema(oneOf: [{ 'type' => 'string' }, { 'type' => 'number' }])
     end
 
     def optional_param(base)

data/lib/datacaster/switch_node.rb

@@ -27,10 +27,12 @@ module Datacaster
           caster_or_value
         when String, Symbol
           if strict
-            Datacaster::Predefined.compare(caster_or_value)
+            Datacaster::Predefined.compare(caster_or_value).json_schema { {"type" => "string", "enum" => [caster_or_value.to_s]} }
           else
-            Datacaster::Predefined.compare(caster_or_value.to_s) |
-              Datacaster::Predefined.compare(caster_or_value.to_sym)
+            (
+              Datacaster::Predefined.compare(caster_or_value.to_s) |
+                Datacaster::Predefined.compare(caster_or_value.to_sym)
+            ).json_schema { {"type" => "string", "enum" => [caster_or_value.to_s]} }
           end
         else
           Datacaster::Predefined.compare(caster_or_value)
@@ -43,6 +45,7 @@ module Datacaster
 
     def else(else_caster)
       raise ArgumentError, "Datacaster: double else clause is not permitted", caller if @else
+      else_caster = DefinitionDSL.expand(else_caster)
       self.class.new(@base, on_casters: @ons, else_caster: else_caster, pick_key: @pick_key)
     end
 
@@ -75,6 +78,34 @@ module Datacaster
       )
     end
 
+    def to_json_schema
+      if @ons.empty?
+        raise RuntimeError, "switch caster requires at least one 'on' statement: switch(...).on(condition, cast)", caller
+      end
+
+      base = @base.to_json_schema
+
+      schema_result = @ons.map { |on|
+        base.apply(on[0].to_json_schema).without_focus.apply(on[1].to_json_schema)
+      }
+
+      if @else
+        schema_result << @else.to_json_schema
+      end
+
+      JsonSchemaResult.new( "oneOf" => schema_result )
+    end
+
+    def to_json_schema_attributes
+      super.merge(
+        extendable: true,
+        remaped:
+          [@base, @else, *@ons.map(&:last)].compact.reduce({}) do |result, caster|
+            result.merge(caster.to_json_schema_attributes[:remaped])
+          end
+      )
+    end
+
     def inspect
       "#<Datacaster::SwitchNode base: #{@base.inspect} on: #{@ons.inspect} else: #{@else.inspect} pick_key: #{@pick_key.inspect}>"
     end

data/lib/datacaster/then_node.rb

@@ -26,6 +26,29 @@ module Datacaster
       end
     end
 
+    def to_json_schema
+      unless @else
+        raise ArgumentError.new('Datacaster: use "a & b" instead of "a.then(b)" when there is no else-clause')
+      end
+
+      left = @left.to_json_schema
+
+      JsonSchemaResult.new(
+        "oneOf" => [
+          (@left & @then).to_json_schema,
+          JsonSchemaResult.new("not" => left).apply(@else.to_json_schema)
+        ]
+      )
+    end
+
+    def to_json_schema_attributes
+      super.merge(
+        required:
+          @left.to_json_schema_attributes[:required] &&
+            @else.to_json_schema_attributes[:required]
+      )
+    end
+
     def inspect
       "#<Datacaster::ThenNode Then: #{@then.inspect} Else: #{@else.inspect}>"
     end

data/lib/datacaster/transformer.rb

@@ -14,6 +14,10 @@ module Datacaster
       Datacaster::ValidResult(result)
     end
 
+    def to_json_schema_attributes
+      super.merge(required: false)
+    end
+
     def inspect
       "#<Datacaster::Transformer>"
     end

data/lib/datacaster/utils.rb

@@ -1,7 +1,14 @@
+require 'set'
+
 module Datacaster
   module Utils
     extend self
 
+    def deep_merge(first, second)
+      merger = proc { |_, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
+      first.merge(second.to_h, &merger)
+    end
+
     def deep_freeze(value, copy: true)
       Ractor.make_shareable(value, copy:)
     end

data/lib/datacaster/version.rb

@@ -1,3 +1,3 @@
 module Datacaster
-  VERSION = "4.2.1"
+  VERSION = "6.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datacaster
 version: !ruby/object:Gem::Version
-  version: 4.2.1
+  version: 6.0.1
 platform: ruby
 authors:
 - Eugene Zolotarev
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 2025-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -106,7 +106,7 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
-description:
+description: 
 email:
 - eugzol@gmail.com
 executables: []
@@ -152,6 +152,9 @@ files:
 - lib/datacaster/i18n_values/base.rb
 - lib/datacaster/i18n_values/key.rb
 - lib/datacaster/i18n_values/scope.rb
+- lib/datacaster/json_schema_attributes.rb
+- lib/datacaster/json_schema_node.rb
+- lib/datacaster/json_schema_result.rb
 - lib/datacaster/message_keys_merger.rb
 - lib/datacaster/mixin.rb
 - lib/datacaster/or_node.rb
@@ -178,7 +181,7 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/EugZol/datacaster
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -193,8 +196,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.20
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: Run-time type checker and transformer for Ruby
 test_files: []