dry-types-json-schema 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 33b4fa74b0afcb773080ea49a615812cb32e2d23fc0a498a5f5f8e3a5d729532
+  data.tar.gz: d3cddcc29c63e0cdbef859ce7259155cc038e40374690b58c9e5eafaa103dd08
+SHA512:
+  metadata.gz: 8b10cc09ab9ff064cf2d1fabaa859e1ca4442e247b368f3aa2c73c8f54f46e2b958898549d91c5bdf0884b97914249646a76280deddec3e0a1d7aa9243961bed
+  data.tar.gz: 380965c43395d6742b673f9926d092fe746a593277b027edf4c90ee3f3995893ce94c838d1257d8e9eaa573dfc26ae78f304075e93d4ad4375c753c1a9397668

data/.gitignore

@@ -0,0 +1 @@
+coverage

data/.rubocop.yml

@@ -0,0 +1,264 @@
+require:
+  - rubocop-minitest
+
+AllCops:
+  TargetRubyVersion: 3.0
+  NewCops: disable
+
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: false
+
+Layout/SpaceInLambdaLiteral:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: true
+  EnforcedStyle: indented
+
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: true
+
+Layout/LineLength:
+  Max: 100
+  Exclude:
+    - "spec/**/*.rb"
+
+Layout/HashAlignment:
+  Enabled: false
+
+Lint/AmbiguousBlockAssociation:
+  Enabled: true
+  # because 'expect { foo }.to change { bar }' is fine
+  Exclude:
+    - "spec/**/*.rb"
+
+Lint/BooleanSymbol:
+  Enabled: false
+
+Lint/ConstantDefinitionInBlock:
+  Exclude:
+    - "spec/**/*.rb"
+
+Lint/RaiseException:
+  Enabled: false
+
+Lint/StructNewOverride:
+  Enabled: false
+
+Lint/SuppressedException:
+  Exclude:
+    - "spec/spec_helper.rb"
+
+Lint/LiteralAsCondition:
+  Exclude:
+    - "spec/**/*.rb"
+
+Naming/PredicateName:
+  Enabled: false
+
+Naming/FileName:
+  Exclude:
+    - "lib/*-*.rb"
+
+Naming/MethodName:
+  Enabled: false
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/CyclomaticComplexity:
+  Enabled: true
+  Max: 12
+
+Style/ExponentialNotation:
+  Enabled: false
+
+Style/HashEachMethods:
+  Enabled: false
+
+Style/HashTransformKeys:
+  Enabled: false
+
+Style/HashTransformValues:
+  Enabled: false
+
+Style/AccessModifierDeclarations:
+  Enabled: false
+
+Style/Alias:
+  Enabled: true
+  EnforcedStyle: prefer_alias_method
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/BlockDelimiters:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Exclude:
+    - "spec/**/*.rb"
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/DateTime:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/EachWithObject:
+  Enabled: false
+
+Style/FormatString:
+  Enabled: false
+
+Style/FormatStringToken:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Style/LambdaCall:
+  Enabled: false
+
+Style/ParallelAssignment:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: false
+
+Style/StabbyLambdaParentheses:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+  ConsistentQuotesInMultiline: false
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/SymbolArray:
+  Exclude:
+    - "spec/**/*.rb"
+
+Style/TrailingUnderscoreVariable:
+  Enabled: false
+
+Style/MultipleComparison:
+  Enabled: false
+
+Style/Next:
+  Enabled: false
+
+Style/AccessorGrouping:
+  Enabled: false
+
+Style/EmptyLiteral:
+  Enabled: false
+
+Style/Semicolon:
+  Exclude:
+    - "spec/**/*.rb"
+
+Style/HashAsLastArrayItem:
+  Exclude:
+    - "spec/**/*.rb"
+
+Style/CaseEquality:
+  Exclude:
+    - "lib/dry/monads/**/*.rb"
+    - "lib/dry/struct/**/*.rb"
+    - "lib/dry/types/**/*.rb"
+    - "spec/**/*.rb"
+
+Style/ExplicitBlockArgument:
+  Exclude:
+    - "lib/dry/types/**/*.rb"
+
+Style/CombinableLoops:
+  Enabled: false
+
+Style/EmptyElse:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/NumberedParametersLimit:
+  Max: 2
+
+Lint/UnusedBlockArgument:
+  Exclude:
+    - "spec/**/*.rb"
+
+Lint/Debugger:
+  Exclude:
+    - "bin/console"
+
+Lint/BinaryOperatorWithIdenticalOperands:
+  Exclude:
+    - "spec/**/*.rb"
+
+Metrics/ParameterLists:
+  Exclude:
+    - "spec/**/*.rb"
+
+Lint/EmptyBlock:
+  Exclude:
+    - "spec/**/*.rb"
+
+Lint/EmptyFile:
+  Exclude:
+    - "spec/**/*.rb"
+
+Lint/UselessMethodDefinition:
+  Exclude:
+    - "spec/**/*.rb"
+
+Lint/SelfAssignment:
+  Enabled: false
+
+Lint/EmptyClass:
+  Enabled: false
+
+Naming/ConstantName:
+  Exclude:
+    - "spec/**/*.rb"
+
+Naming/VariableNumber:
+  Exclude:
+    - "spec/**/*.rb"
+
+Naming/BinaryOperatorParameterName:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,105 @@
+PATH
+  remote: .
+  specs:
+    dry-types-json-schema (0.0.1)
+      dry-types (~> 1.7.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.7)
+    coderay (1.1.3)
+    concurrent-ruby (1.2.3)
+    docile (1.4.0)
+    dry-core (1.0.1)
+      concurrent-ruby (~> 1.0)
+      zeitwerk (~> 2.6)
+    dry-inflector (1.0.0)
+    dry-logic (1.5.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-struct (1.6.0)
+      dry-core (~> 1.0, < 2)
+      dry-types (>= 1.7, < 2)
+      ice_nine (~> 0.11)
+      zeitwerk (~> 2.6)
+    dry-types (1.7.2)
+      bigdecimal (~> 3.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0)
+      dry-inflector (~> 1.0)
+      dry-logic (~> 1.4)
+      zeitwerk (~> 2.6)
+    hana (1.3.7)
+    ice_nine (0.11.2)
+    json (2.7.1)
+    json_schemer (2.2.1)
+      base64
+      bigdecimal
+      hana (~> 1.3)
+      regexp_parser (~> 2.0)
+      simpleidn (~> 0.2)
+    language_server-protocol (3.17.0.3)
+    method_source (1.0.0)
+    minitest (5.22.3)
+    parallel (1.24.0)
+    parser (3.3.0.5)
+      ast (~> 2.4.1)
+      racc
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    racc (1.7.3)
+    rainbow (3.1.1)
+    regexp_parser (2.9.0)
+    rexml (3.2.6)
+    rubocop (1.62.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.31.2)
+      parser (>= 3.3.0.4)
+    rubocop-minitest (0.35.0)
+      rubocop (>= 1.61, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    ruby-progressbar (1.13.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    simpleidn (0.2.1)
+      unf (~> 0.1.4)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.9.1)
+    unicode-display_width (2.5.0)
+    zeitwerk (2.6.13)
+
+PLATFORMS
+  arm64-darwin-22
+  ruby
+
+DEPENDENCIES
+  dry-struct (~> 1.6.0)
+  dry-types-json-schema!
+  json_schemer (~> 2.2.1)
+  minitest (~> 5.22.3)
+  pry (~> 0.14.2)
+  rubocop (~> 1.62.1)
+  rubocop-minitest (~> 0.35.0)
+  simplecov (~> 0.22.0)
+
+BUNDLED WITH
+   2.5.3

data/Makefile

@@ -0,0 +1,16 @@
+.PHONY: *
+
+default: test
+
+build:
+	rm -f *.gem
+	gem build dry-types-json-schema.gemspec
+
+publish: build
+	gem push *.gem
+
+console:
+	irb -Ilib:spec -rspec_helper.rb
+
+test:
+	ruby -Ilib:spec -rpry spec/**/*_spec.rb

data/README.md

@@ -0,0 +1,46 @@
+# Dry::Types::JSONSchema
+
+![](https://images.unsplash.com/photo-1642952469120-eed4b65104be?q=80&w=600&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D)
+
+## Example
+
+```ruby
+Dry::Types.load_extensions(:json_schema)
+
+AnnotatedString = Dry::Types["string"].meta(format: :email, title: "Notes")
+
+AnnotatedString.json_schema
+#=> {:type=>:string, :title=>"Notes", :format=>:email}
+
+module Types
+  include Dry.Types()
+end
+
+class StructTest < Dry::Struct
+  schema schema.meta(title: "Title", description: "description")
+
+  VariableList = Types::Array
+   .of(Types::String | Types::Hash)
+   .constrained(min_size: 1)
+   .meta(description: "Allow an array of strings or multiple hashes")
+
+  attribute  :data,   Types::String | Types::Hash
+  attribute  :string, Types::String.constrained(min_size: 1, max_size: 255)
+  attribute  :list,   VariableList
+end
+
+StructTest.json_schema
+# =>
+# {:type=>:object,
+#    :properties=>
+#     {:data=>{:anyOf=>[{:type=>:string}, {:type=>:object}]},
+#      :string=>{:type=>:string, :minLength=>1, :maxLength=>255},
+#      :list=>
+#       {:type=>:array,
+#        :items=>{:anyOf=>[{:type=>:string}, {:type=>:object}]},
+#        :description=>"Allow an array of strings or multiple hashes",
+#        :minItems=>1}},
+#    :required=>[:data, :string, :list],
+#    :title=>"Title",
+#    :description=>"description"}
+```

data/dry-types-json-schema.gemspec

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.name              = "dry-types-json-schema"
+  s.version           = "0.0.1"
+  s.summary           = "Generate JSON Schema from dry-types"
+  s.authors           = ["elcuervo"]
+  s.licenses          = %w[MIT]
+  s.email             = ["elcuervo@elcuervo.net"]
+  s.homepage          = "http://github.com/elcuervo/dry-types-json-schema"
+  s.files             = `git ls-files`.split("\n")
+  s.test_files        = `git ls-files test`.split("\n")
+
+  s.add_dependency("dry-types", "~> 1.7.2")
+
+  s.add_development_dependency("dry-struct", "~> 1.6.0")
+  s.add_development_dependency("minitest", "~> 5.22.3")
+  s.add_development_dependency("pry", "~> 0.14.2")
+  s.add_development_dependency("json_schemer", "~> 2.2.1")
+  s.add_development_dependency("simplecov", "~> 0.22.0")
+  s.add_development_dependency("rubocop", "~> 1.62.1")
+  s.add_development_dependency("rubocop-minitest", "~> 0.35.0")
+end

data/flake.lock

@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1710146030,
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1710889954,
+        "narHash": "sha256-Pr6F5Pmd7JnNEMHHmspZ0qVqIBVxyZ13ik1pJtm2QXk=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "7872526e9c5332274ea5932a0c3270d6e4724f3b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

data/flake.nix

@@ -0,0 +1,19 @@
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = import nixpkgs { inherit system; };
+      in
+      {
+        devShells.default = pkgs.mkShell {
+          buildInputs = with pkgs; [
+            ruby_3_3
+          ];
+        };
+      });
+}

data/lib/dry/types/extensions/json_schema.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # The `JSONSchema` class is responsible for converting dry-types type definitions into JSON Schema definitions.
+    # This class enables the transformation of complex type constraints into a standardized JSON Schema format,
+    # facilitating interoperability with systems that utilize JSON Schema for validation.
+    #
+    class JSONSchema
+      # Error raised when an unknown predicate is encountered during schema generation.
+      #
+      UnknownPredicateError = Class.new(StandardError)
+
+      # Constant definitions for various lambdas and mappings used throughout the JSON schema conversion process.
+      #
+      EMPTY_HASH = {}.freeze
+      IDENTITY = ->(v, _) { v }.freeze
+      INSPECT = ->(v, _) { v.inspect }.freeze
+      TO_INTEGER = ->(v, _) { v.to_i }.freeze
+      TO_ARRAY = ->(v, _) { v.to_a }.freeze
+      TO_TYPE = ->(v, _) { CLASS_TO_TYPE.fetch(v.to_s.to_sym) }.freeze
+
+      # Metadata annotations and allowed types overrides for schema generation.
+      #
+      ANNOTATIONS = %i[title description].freeze
+      ALLOWED_TYPES_META_OVERRIDES = ANNOTATIONS.dup.concat([:format]).freeze
+
+      # Mapping for array predicate overrides.
+      #
+      ARRAY_PREDICATE_OVERRIDE = {
+        min_size?: :min_items?,
+        max_size?: :max_items?
+      }.freeze
+
+      # Mapping of Ruby classes to their corresponding JSON Schema types.
+      #
+      CLASS_TO_TYPE = {
+        String:     :string,
+        Integer:    :integer,
+        TrueClass:  :boolean,
+        FalseClass: :boolean,
+        NilClass:   :null,
+        BigDecimal: :number,
+        Float:      :number,
+        Hash:       :object,
+        Array:      :array,
+        Date:       :string,
+        DateTime:   :string,
+        Time:       :string
+      }.freeze
+
+      # Additional properties for specific types, such as formatting options.
+      #
+      EXTRA_PROPS_FOR_TYPE = {
+        Date:     { format: :date },
+        Time:     { format: :time },
+        DateTime: { format: :"date-time" }
+      }.freeze
+
+      # Mapping of predicate methods to their corresponding JSON Schema expressions.
+      #
+      PREDICATE_TO_TYPE = {
+        type?:        { type: TO_TYPE },
+        min_size?:    { minLength: TO_INTEGER },
+        min_items?:   { minItems: TO_INTEGER },
+        max_size?:    { maxLength: TO_INTEGER },
+        max_items?:   { maxItems: TO_INTEGER },
+        min?:         { maxLength: TO_INTEGER },
+        gt?:          { exclusiveMinimum: IDENTITY },
+        gteq?:        { minimum: IDENTITY },
+        lt?:          { exclusiveMaximum: IDENTITY },
+        lteq?:        { maximum: IDENTITY },
+        format?:      { format: INSPECT },
+        included_in?: { enum: TO_ARRAY },
+      }.freeze
+
+      # @return [Set] the set of required keys for the JSON Schema.
+      #
+      attr_reader :required
+
+
+      # Initializes a new instance of the JSONSchema class.
+      # @param root [Boolean] whether this schema is the root schema.
+      # @param loose [Boolean] whether to ignore unknown predicates.
+      #
+      def initialize(root: false, loose: false)
+        @keys = EMPTY_HASH.dup
+        @required = Set.new
+        @root = root
+        @loose = loose
+      end
+
+      # Checks if the schema is the root schema.
+      # @return [Boolean] true if this is the root schema; otherwise, false.
+      #
+      def root?  = @root
+
+      # Checks if unknown predicates are ignored.
+      # @return [Boolean] true if ignoring unknown predicates; otherwise, false.
+      #
+      def loose? = @loose
+
+      # Processes the abstract syntax tree (AST) and generates the JSON Schema.
+      # @param ast [Array] the abstract syntax tree representing type definitions.
+      # @return [void]
+      #
+      def call(ast)
+        visit(ast)
+      end
+
+      # Converts the internal schema representation into a hash.
+      # @return [Hash] the JSON Schema as a hash.
+      #
+      def to_hash
+        result = @keys.to_hash
+        result[:$schema] = "http://json-schema.org/draft-06/schema#" if root?
+        result
+      end
+
+      # Visits a node in the abstract syntax tree and processes it according to its type.
+      # @param node [Array] the node to process.
+      # @param opts [Hash] optional parameters for node processing.
+      # @return [void]
+      #
+      def visit(node, opts = EMPTY_HASH)
+        name, rest = node
+        public_send(:"visit_#{name}", rest, opts)
+      end
+
+      def visit_constrained(node, opts = EMPTY_HASH)
+        node.each { |it| visit(it, opts) }
+      end
+
+      def visit_constructor(node, opts = EMPTY_HASH)
+        type, _ = node
+
+        visit(type, opts)
+      end
+
+      def visit_nominal(node, opts = EMPTY_HASH)
+        type, meta = node
+
+        if opts.fetch(:key, false)
+          if meta.any?
+            @keys[opts[:key]] ||= {}
+            @keys[opts[:key]].merge!(meta.slice(*ALLOWED_TYPES_META_OVERRIDES))
+          end
+        else
+          @keys.merge!(type: CLASS_TO_TYPE[type.to_s.to_sym])
+          @keys.merge!(meta.slice(*ALLOWED_TYPES_META_OVERRIDES)) if meta.any?
+        end
+      end
+
+      def visit_predicate(node, opts = EMPTY_HASH)
+        head, ((_, type),) = node
+        ctx = opts[:key]
+
+        head = ARRAY_PREDICATE_OVERRIDE.fetch(head) if opts[:left_type] == ::Array
+
+        definition = PREDICATE_TO_TYPE.fetch(head) do
+          raise UnknownPredicateError, head unless loose?
+
+          EMPTY_HASH
+        end.dup
+
+        definition.transform_values! { |v| v.call(type, ctx) }
+
+        return unless definition.any? && ctx
+
+        if (extra = EXTRA_PROPS_FOR_TYPE[type.to_s.to_sym])
+          definition = definition.merge(extra)
+        end
+
+        @keys[ctx] ||= {}
+        @keys[ctx].merge!(definition)
+      end
+
+      def visit_sum(node, opts = EMPTY_HASH)
+        *types, _ = node
+
+        # FIXME: cleaner way to generate individual types
+        #
+        process = -> (type) do
+          self.class.new
+            .tap { |target| target.visit(type, opts) }
+            .to_hash
+            .values
+            .first
+        end
+
+        result = types.map(&process).uniq
+
+        return @keys[opts[:key]] = result.first if result.count == 1
+
+        return @keys[opts[:key]] = { anyOf: result } unless opts[:array]
+
+        @keys[opts[:key]] = {
+          type: :array,
+          items: { anyOf: result }
+        }
+      end
+
+      def visit_and(node, opts = EMPTY_HASH)
+        left, right = node
+        (_, (_, ((_, left_type),))) = left
+
+        visit(left, opts)
+        visit(right, opts.merge(left_type: left_type))
+      end
+
+      def visit_hash(node, opts = EMPTY_HASH)
+        _part, _meta = node
+
+        @keys[opts[:key]] = { type: :object }
+      end
+
+      def visit_struct(node, opts = EMPTY_HASH)
+        _, schema = node
+        visit(schema, opts)
+      end
+
+      def visit_array(node, opts = EMPTY_HASH)
+        type, meta = node
+
+        visit(type, opts.merge(array: true))
+
+        @keys[opts[:key]].merge!(meta.slice(*ANNOTATIONS)) if meta.any?
+      end
+
+      def visit_schema(node, opts = EMPTY_HASH)
+        keys, _, meta = node
+
+        target = self.class.new
+
+        keys.each { |fragment| target.visit(fragment, opts) }
+
+        definition = { type: :object, properties: target.to_hash }
+
+        definition[:required] = target.required.to_a if target.required.any?
+        definition.merge!(meta.slice(*ANNOTATIONS))  if meta.any?
+
+        @keys.merge!(definition)
+      end
+
+      def visit_enum(node, opts = EMPTY_HASH)
+        enum, _ = node
+        visit(enum, opts)
+      end
+
+      def visit_key(node, opts = EMPTY_HASH)
+        name, required, rest = node
+
+        @required << name if required
+
+        visit(rest, opts.merge(key: name))
+      end
+    end
+
+    # The `Builder` module provides a method to generate a JSON Schema hash from dry-types definitions.
+    #
+    module Builder
+      # @overload json_schema(options = {})
+      #   @param options [Hash] Initialization options passed to `JSONSchema.new`
+      #   @return [Hash] The generated JSON Schema as a hash.
+      #
+      def json_schema(**)
+        compiler = JSONSchema.new(**)
+        compiler.call(to_ast)
+        compiler.to_hash
+      end
+    end
+  end
+end

data/lib/dry/types/extensions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "dry/types"
+
+Dry::Types.register_extension(:json_schema) do
+  require "dry/types/extensions/json_schema"
+end

data/spec/extensions/json_schema_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Dry::Types::JSONSchema do
+  module Types
+    include Dry.Types()
+  end
+
+  describe "basic" do
+    it_conforms_definition do
+      let(:title) { "Title" }
+      let(:type) { Dry::Types["string"].meta(format: :email, title: title) }
+
+      let(:definition) do
+        { type: :string, format: :email, title: title }
+      end
+    end
+  end
+
+  describe "hash" do
+    let(:type) do
+      Dry::Types["hash"]
+        .schema(
+          name: Dry::Types["string"],
+          age: Dry::Types["integer"].constrained(gt: 0, lteq: 99),
+          active: Dry::Types["bool"],
+          migrated: Dry::Types["nil"],
+          views: Dry::Types["decimal"].constrained(gteq: 0, lt: 99_999),
+          created_at: Dry::Types["time"]
+        ).meta(title: "Hash title")
+    end
+
+    it_conforms_definition do
+      let(:definition) do
+        {
+          type: :object,
+          title: type.meta[:title],
+
+          properties: {
+            name: { type: :string },
+            age: { type: :integer, exclusiveMinimum: 0, maximum: 99 },
+            active: { type: :boolean },
+            migrated: { type: :null },
+            views: { type: :number, minimum: 0, exclusiveMaximum: 99_999 },
+            created_at: { type: :string, format: :time }
+          },
+          required: %i[name age active migrated views created_at]
+        }
+      end
+    end
+  end
+
+  describe "struct" do
+    class StructTest < Dry::Struct
+      schema schema.meta(title: "Title", description: "description")
+
+      VariableList = Types::Array
+        .of(Types::String | Types::Hash)
+        .constrained(min_size: 1)
+        .meta(description: "Allow an array of strings or multiple hashes")
+
+      # Validate regexp compatibility during inspect
+      #
+      EmailType = Types::String
+        .constrained(format: /\A[\w+\-.]+@[a-z\d-]+(\.[a-z]+)*\.[a-z]+\z/i)
+        .meta(description: "The internally used pattern")
+
+      attribute  :data,   Types::String | Types::Hash
+      attribute  :string, Types::String.constrained(min_size: 1, max_size: 255)
+      attribute  :list,   VariableList
+      attribute? :email,  EmailType
+      attribute? :super,  Types::Bool
+      attribute? :start,  Types::Date
+      attribute? :end,    Types::DateTime
+      attribute? :epoch,  Types::Time
+      attribute? :meta,   Types::String.meta(format: :email)
+      attribute? :enum,   Types::String.enum(*%w[draft published archived])
+    end
+
+    let(:type) { StructTest }
+
+    it_conforms_definition do
+      let(:definition) do
+        {
+          title: StructTest.schema.meta[:title],
+          description: StructTest.schema.meta[:description],
+
+          type: :object,
+          properties: {
+            data: {
+              anyOf: [
+                { type: :string },
+                { type: :object }
+              ]
+            },
+
+            list: {
+              type: :array,
+              description: StructTest::VariableList.meta[:description],
+              items: {
+                anyOf: [
+                  { type: :string },
+                  { type: :object }
+                ]
+              },
+              minItems: 1
+            },
+
+            string: {
+              type: :string,
+              minLength: 1,
+              maxLength: 255
+            },
+
+            super: {
+              type: :boolean
+            },
+
+            email: {
+              type: :string,
+              format: "/\\A[\\w+\\-.]+@[a-z\\d-]+(\\.[a-z]+)*\\.[a-z]+\\z/i",
+              description: StructTest::EmailType.meta[:description]
+            },
+
+            start: {
+              type: :string,
+              format: :date
+            },
+
+            end: {
+              type: :string,
+              format: :"date-time"
+            },
+
+            epoch: {
+              type: :string,
+              format: :time
+            },
+
+            meta: {
+              type: :string,
+              format: :email
+            },
+
+            enum: {
+              type: :string,
+              enum: %w[draft published archived]
+            }
+          },
+
+          required: %i[data string list]
+        }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "simplecov"
+
+SimpleCov.start
+
+require "minitest/autorun"
+require "json_schemer"
+
+require "dry/struct"
+require "dry/types"
+require "dry/types/extensions"
+
+Dry::Types.load_extensions(:json_schema)
+
+class Minitest::Spec
+  class << self
+    def it_conforms_definition(&block)
+      instance_exec(&block) if block
+
+      describe "conforms the schema definition" do
+        it { assert_equal type.json_schema, definition }
+        it { assert JSONSchemer.schema(type.json_schema.to_json).valid_schema? }
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: dry-types-json-schema
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- elcuervo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.22.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.22.3
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+- !ruby/object:Gem::Dependency
+  name: json_schemer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.62.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.62.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.35.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.35.0
+description:
+email:
+- elcuervo@elcuervo.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- Makefile
+- README.md
+- dry-types-json-schema.gemspec
+- flake.lock
+- flake.nix
+- lib/dry/types/extensions.rb
+- lib/dry/types/extensions/json_schema.rb
+- spec/extensions/json_schema_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/elcuervo/dry-types-json-schema
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.6
+signing_key:
+specification_version: 4
+summary: Generate JSON Schema from dry-types
+test_files: []