datacaster 4.2.1 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 351d202f9afcb51c391c23e852f4d9d289a60df1a4f890473f532aac47ca668c
-  data.tar.gz: '031040811b8f5a2c319c5c48295c44d347f76dcb52fbfaeadd37f586f0d06582'
+  metadata.gz: a0e209179b85f6f4ca1b63face9260b3d8c03e7c09796e124c4606e9f8ff0431
+  data.tar.gz: 15b4b5228319b5ff7d670dfd8f23883e714b1017ccc85dc0a3df920a142a0627
 SHA512:
-  metadata.gz: c53e86295d1f47bc80d0d5e1805b5076e85f8ded528f14039ebcbd88a810bd4e8e4897b16a41b30422c8b18556049a54256ce60fa5fecc04c176cda3de363890
-  data.tar.gz: 67111b7dfa26fcfc844ca33336f884738a961c9629e01486ad4cef5423406f33ec030d92746e32c66739c624a0d0b0c6b9a89c8609dc40d0509cdf85298767ec
+  metadata.gz: 966d31dc9b9b397ced3bece4e3a74f0c885e5b95dfebe3a35374a85c50afb4bd183222e56095730fbca3c52b079a277f8f43106c14d69192f95032d771a67a18
+  data.tar.gz: 12043768c2e341338af7f1178aca2dead9ffd43c8189f4a2df44ca1114768aaa8fbc465e3d23c4a8e2a41162c8f73c35d789b091e18cbe67e1b5afe90214f2bc

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/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: false)
       @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: false)
+      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 = "5.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datacaster
 version: !ruby/object:Gem::Version
-  version: 4.2.1
+  version: 5.0.1
 platform: ruby
 authors:
 - Eugene Zolotarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 2025-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -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