open_api_json_schema_converter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0f976564809e17e5acb3fa09fe0d1bb74ca8a659834bf007104a5ab84ef51fa5
+  data.tar.gz: 38c192bb08fcc043aa43de492b6f85502e596366afc4b0f95a21093ff39e878f
+SHA512:
+  metadata.gz: d3a7bcc5350eba543f560d3230834a4c2426d2021dd0548b29b2a11d2820609a62fc2373173705a33bced862e520f03df844ad98929b7f76c9f5fe850846ce31
+  data.tar.gz: af72d54b5fb4d73b5df58912b6b22f3553f9f8bc49ebfc441b1a9eff3a0d00a44e9b85320b0252ae8b0fe8ef61afdcbb3a505dd8cdbf6234040ce2b9cc97ee20

data/.rspec

@@ -0,0 +1,3 @@
+--format progress
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,37 @@
+AllCops:
+  TargetRubyVersion: 2.7
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Style/SafeNavigation:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Style/HashTransformValues:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# [0.1.0] - 2025-08-23
+
+- Release!

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.13.1"
+gem "super_diff"
+
+gem "rubocop", "~> 1.76.1"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 hieuk09
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,87 @@
+# OpenAPI JSON Schema Converter
+
+A Ruby gem for converting OpenAPI specifications to JSON Schema format.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'open_api_json_schema_converter'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install open_api_json_schema_converter
+```
+
+## Usage
+
+### Examples:
+
+```ruby
+require 'open_api_json_schema_converter'
+
+json_schema = {
+  'type' => 'object',
+  'properties' => {
+    'name' => { 'type' => 'string' },
+    'email' => { 'type' => ['string', 'null'] }
+  }
+}
+
+result = OpenApiJsonSchemaConverter.convert(json_schema)
+
+# Result:
+# {
+#   'type' => 'object',
+#   'properties' => {
+#     'name' => { 'type' => 'string' },
+#     'email' => { 'type' => 'string', 'nullable' => true }
+#   }
+# }
+```
+
+```ruby
+require 'open_api_json_schema_converter'
+
+json_schema = {
+  'type' => 'object',
+  'properties' => {
+    'status' => {
+      'const' => 'active',
+      'description' => 'Account status'
+    },
+    'version' => {
+      'const' => '1.0'
+    }
+  }
+}
+
+result = OpenApiJsonSchemaConverter.convert(json_schema)
+
+# Result:
+# {
+#   'type' => 'object',
+#   'properties' => {
+#     'status' => {
+#       'enum' => ['active'],
+#       'description' => 'Account status'
+#     },
+#     'version' => {
+#       'enum' => ['1.0']
+#     }
+#   }
+# }
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "open_api_json_schema_converter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/open_api_json_schema_converter/constants.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module OpenApiJsonSchemaConverter
+  ALLOWED_KEYWORDS = %w[
+    $ref
+    definitions
+    title
+    multipleOf
+    maximum
+    exclusiveMaximum
+    minimum
+    exclusiveMinimum
+    maxLength
+    minLength
+    pattern
+    maxItems
+    minItems
+    uniqueItems
+    maxProperties
+    minProperties
+    required
+    enum
+    type
+    not
+    allOf
+    oneOf
+    anyOf
+    items
+    properties
+    additionalProperties
+    description
+    format
+    default
+    nullable
+    discriminator
+    readOnly
+    writeOnly
+    example
+    externalDocs
+    deprecated
+    xml
+  ].freeze
+
+  VALID_TYPES = %w[
+    null
+    boolean
+    object
+    array
+    number
+    string
+    integer
+  ].freeze
+
+  OAS_EXTENSION_PREFIX = "x-"
+end

data/lib/open_api_json_schema_converter/converter.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+
+module OpenApiJsonSchemaConverter
+  class InvalidTypeError < StandardError; end
+
+  class Converter
+    def convert(schema)
+      # Always clone to avoid modifying the input
+      cloned_schema = deep_clone(schema)
+
+      converted_schema = convert_schema(cloned_schema)
+
+      # Convert unreferenced definitions
+      if converted_schema["definitions"]
+        converted_schema["definitions"].each do |def_name, definition|
+          converted_schema["definitions"][def_name] = handle_definition(definition)
+        end
+      end
+
+      converted_schema
+    end
+
+    private
+
+    def handle_definition(definition)
+      return definition unless definition.is_a?(Hash)
+
+      if definition["type"]
+        convert_schema(deep_clone(definition))
+      elsif definition.is_a?(Array)
+        # Handle array types with null
+        type_arr = definition
+        has_null = type_arr.include?("null")
+        if has_null
+          actual_types = type_arr.reject { |t| t == "null" }
+          {
+            "type" => actual_types.length == 1 ? actual_types.first : actual_types,
+            "nullable" => true
+          }
+        else
+          definition
+        end
+      else
+        definition
+      end
+    end
+
+    def convert_schema(schema)
+      return schema unless schema
+      return schema unless schema.is_a?(Hash)
+
+      # First process the current level
+      schema = strip_illegal_keywords(schema)
+      schema = convert_types(schema)
+      schema = rewrite_const(schema)
+      schema = convert_dependencies(schema)
+      schema = convert_nullable(schema)
+      schema = rewrite_if_then_else(schema)
+      schema = rewrite_exclusive_min_max(schema)
+      schema = convert_examples(schema)
+
+      schema = convert_pattern_properties(schema) if schema["patternProperties"].is_a?(Hash)
+
+      # Arrays must have items property in OpenAPI
+      schema["items"] = {} if schema["type"] == "array" && !schema.key?("items")
+
+      # Recursively process nested schemas
+      schema = process_nested_schemas(schema)
+
+      # Should be called last
+      convert_illegal_keywords_as_extensions(schema)
+    end
+
+    def process_nested_schemas(schema)
+      return schema unless schema.is_a?(Hash)
+
+      # Process properties
+      if schema["properties"].is_a?(Hash)
+        schema["properties"].each do |key, value|
+          schema["properties"][key] = convert_schema(value)
+        end
+      end
+
+      # Process items
+      if schema["items"]
+        schema["items"] = if schema["items"].is_a?(Array)
+                            schema["items"].map { |item| convert_schema(item) }
+                          else
+                            convert_schema(schema["items"])
+                          end
+      end
+
+      # Process additionalProperties
+      if schema["additionalProperties"].is_a?(Hash)
+        schema["additionalProperties"] = convert_schema(schema["additionalProperties"])
+      end
+
+      # Process allOf, anyOf, oneOf
+      %w[allOf anyOf oneOf].each do |key|
+        schema[key] = schema[key].map { |item| convert_schema(item) } if schema[key].is_a?(Array)
+      end
+
+      # Process not
+      schema["not"] = convert_schema(schema["not"]) if schema["not"].is_a?(Hash)
+
+      # Process definitions
+      if schema["definitions"].is_a?(Hash)
+        schema["definitions"].each do |key, value|
+          schema["definitions"][key] = convert_schema(value)
+        end
+      end
+
+      # Process patternProperties (before it's converted to x-patternProperties)
+      if schema["patternProperties"].is_a?(Hash)
+        schema["patternProperties"].each do |key, value|
+          schema["patternProperties"][key] = convert_schema(value)
+        end
+      end
+
+      schema
+    end
+
+    def strip_illegal_keywords(schema)
+      return schema unless schema.is_a?(Hash)
+
+      schema.delete("$schema")
+      schema.delete("$id")
+      schema.delete("id")
+
+      schema
+    end
+
+    def convert_types(schema)
+      return schema unless schema.is_a?(Hash)
+      return schema unless schema.key?("type")
+
+      validate_type(schema["type"])
+
+      if schema["type"].is_a?(Array)
+        schema["nullable"] = true if schema["type"].include?("null")
+
+        types_without_null = schema["type"].reject { |t| t == "null" }
+
+        if types_without_null.empty?
+          schema.delete("type")
+        elsif types_without_null.length == 1
+          schema["type"] = types_without_null.first
+        else
+          schema.delete("type")
+          schema["anyOf"] = types_without_null.map { |type| { "type" => type } }
+        end
+      elsif schema["type"] == "null"
+        schema.delete("type")
+        schema["nullable"] = true
+      end
+
+      schema
+    end
+
+    def validate_type(type)
+      return if type.is_a?(Hash) && type["$ref"] # Refs are allowed
+      return if type.is_a?(Hash) && type["properties"] # De-referenced circular ref
+
+      types = type.is_a?(Array) ? type : [type]
+      types.each do |t|
+        next unless t
+        unless OpenApiJsonSchemaConverter::VALID_TYPES.include?(t)
+          raise InvalidTypeError, "Type \"#{t}\" is not a valid type"
+        end
+      end
+    end
+
+    def rewrite_const(schema)
+      return schema unless schema.is_a?(Hash)
+
+      if schema.key?("const")
+        schema["enum"] = [schema["const"]]
+        schema.delete("const")
+      end
+
+      schema
+    end
+
+    def convert_dependencies(schema)
+      return schema unless schema.is_a?(Hash)
+
+      deps = schema["dependencies"]
+      return schema unless deps.is_a?(Hash)
+
+      schema.delete("dependencies")
+      schema["allOf"] ||= []
+
+      deps.each do |key, value|
+        one_of = {
+          "oneOf" => [
+            { "not" => { "required" => [key] } },
+            { "required" => [key, *Array(value)].flatten }
+          ]
+        }
+        schema["allOf"] << one_of
+      end
+
+      schema
+    end
+
+    def convert_nullable(schema)
+      return schema unless schema.is_a?(Hash)
+
+      %w[oneOf anyOf].each do |key|
+        schemas = schema[key]
+        next unless schemas.is_a?(Array)
+
+        has_nullable = schemas.any? { |item| item.is_a?(Hash) && item["type"] == "null" }
+        next unless has_nullable
+
+        filtered = schemas.reject { |item| item.is_a?(Hash) && item["type"] == "null" }
+        filtered.each do |schema_entry|
+          schema_entry["nullable"] = true if schema_entry.is_a?(Hash)
+        end
+
+        schema[key] = filtered
+      end
+
+      schema
+    end
+
+    def rewrite_if_then_else(schema)
+      return schema unless schema.is_a?(Hash)
+      return schema unless schema["if"] && schema["then"]
+
+      schema["oneOf"] = [
+        { "allOf" => [schema["if"], schema["then"]].compact },
+        { "allOf" => [{ "not" => schema["if"] }, schema["else"]].compact }
+      ]
+
+      schema.delete("if")
+      schema.delete("then")
+      schema.delete("else")
+
+      schema
+    end
+
+    def rewrite_exclusive_min_max(schema)
+      return schema unless schema.is_a?(Hash)
+
+      if schema["exclusiveMaximum"].is_a?(Numeric)
+        schema["maximum"] = schema["exclusiveMaximum"]
+        schema["exclusiveMaximum"] = true
+      end
+
+      if schema["exclusiveMinimum"].is_a?(Numeric)
+        schema["minimum"] = schema["exclusiveMinimum"]
+        schema["exclusiveMinimum"] = true
+      end
+
+      schema
+    end
+
+    def convert_examples(schema)
+      return schema unless schema.is_a?(Hash)
+
+      if schema["examples"].is_a?(Array) && !schema["examples"].empty?
+        schema["example"] = schema["examples"].first
+        schema.delete("examples")
+      end
+
+      schema
+    end
+
+    def convert_pattern_properties(schema)
+      return schema unless schema.is_a?(Hash)
+
+      schema["x-patternProperties"] = schema["patternProperties"]
+      schema.delete("patternProperties")
+      schema["additionalProperties"] = true unless schema.key?("additionalProperties")
+
+      schema
+    end
+
+    def convert_illegal_keywords_as_extensions(schema)
+      return schema unless schema.is_a?(Hash)
+
+      schema.keys.each do |keyword|
+        next if keyword.start_with?(OpenApiJsonSchemaConverter::OAS_EXTENSION_PREFIX)
+        next if OpenApiJsonSchemaConverter::ALLOWED_KEYWORDS.include?(keyword)
+
+        extension_key = "#{OpenApiJsonSchemaConverter::OAS_EXTENSION_PREFIX}#{keyword}"
+        schema[extension_key] = schema[keyword]
+        schema.delete(keyword)
+      end
+
+      schema
+    end
+
+    def deep_clone(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) do |(k, v), h|
+          h[k] = deep_clone(v)
+        end
+      when Array
+        obj.map { |item| deep_clone(item) }
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/open_api_json_schema_converter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OpenApiJsonSchemaConverter
+  VERSION = "0.1.0"
+end

data/lib/open_api_json_schema_converter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "open_api_json_schema_converter/constants"
+require_relative "open_api_json_schema_converter/converter"
+require_relative "open_api_json_schema_converter/version"
+
+module OpenApiJsonSchemaConverter
+  module_function
+
+  def convert(schema)
+    Converter.new.convert(schema)
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: open_api_json_schema_converter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dmitry Ishkov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-08-22 00:00:00.000000000 Z
+dependencies: []
+description: This project was written to help convert structured outputs required
+  for OpenAI to Gemini format.
+email:
+- dmitry@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/open_api_json_schema_converter.rb
+- lib/open_api_json_schema_converter/constants.rb
+- lib/open_api_json_schema_converter/converter.rb
+- lib/open_api_json_schema_converter/version.rb
+homepage: https://github.com/therusskiy/open_api_json_schema_converter
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/therusskiy/open_api_json_schema_converter
+  source_code_uri: https://github.com/therusskiy/open_api_json_schema_converter
+  changelog_uri: https://github.com/therusskiy/open_api_json_schema_converter/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: OpenAPI v3.0 schema to JSON Schema converter
+test_files: []