schema_registry_client 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c4fb0ad39418dd0eb14e803f4c0652e47e64950b8684f564221a95b024177c1
-  data.tar.gz: c04a0a44298ff123a0a63cf530fe2c2ae56b7230cc740e2d02577f712d045e41
+  metadata.gz: d0919f12f0457fbdf7becd62389a7ed72e34afe9d7f3ce5c819f2e0ebf145174
+  data.tar.gz: 4dc5c91669e508e89bc07763bebb6b754403ee72ccbe125ecfc888c48cf974fa
 SHA512:
-  metadata.gz: c68cf8a284acdaad830acbbc76ea49b2cb1431b69e3c2961218f5c8af399b89d64f8b5eb1e25536e415f5720080152853f885d9984b47790ffd02d01cad73709
-  data.tar.gz: 7fb3f61b7159bf9f461f3fc9b6f8d0f145592f18a35b1e02d284a6f2ed62c95d30a6d8ff1082b2607976f134e6a74e1416e00483e61f8db2ecf27f601112bd84
+  metadata.gz: 07d614eaceb30420a69221399fab2e360f3f3b4089e5271b42fcaca30eb9f643cebcdd59187bdfc6a33d721641b960e2855fefce4703e59f455e459088bbd996
+  data.tar.gz: 65a8cf4a6899e8f32febb2b408ebb20ed379224b7fbd0d716da33c6e0e6c10844559e5d4e1af73c3ee06a1601ecd0dc3853137aa3987837157bbd07c07655a21

data/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## UNRELEASED
 
+# 0.0.9 - 2026-02-11
+
+* Fix: Do not send `schemaType` if schema type is `AVRO`, for backwards compatibility with older schema registries.
+
 # 0.0.8 - 2026-02-04
 
 * Support passing a `schema_store` into the `Avro` schema backend.

data/Gemfile

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    schema_registry_client (0.0.8)
+    schema_registry_client (0.0.9)
       avro
       excon
       google-protobuf

data/Rakefile

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"

data/lib/schema_registry_client/avro_schema_store.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'avro'
+require "avro"
 
 module SchemaRegistry
   class AvroSchemaStore
     def initialize(path: nil)
-      @path = path or raise 'Please specify a schema path'
+      @path = path or raise "Please specify a schema path"
       @schemas = {}
       @schema_text = {}
       @mutex = Mutex.new
@@ -38,14 +38,14 @@ module SchemaRegistry
 
     # Loads all schema definition files in the `schemas_dir`.
     def load_schemas!
-      pattern = [@path, '**', '*.avsc'].join('/')
+      pattern = [@path, "**", "*.avsc"].join("/")
 
       Dir.glob(pattern) do |schema_path|
         # Remove the path prefix.
-        schema_path.sub!(%r{^/?#{@path}/}, '')
+        schema_path.sub!(%r{^/?#{@path}/}, "")
 
         # Replace `/` with `.` and chop off the file extension.
-        schema_name = File.basename(schema_path.tr('/', '.'), '.avsc')
+        schema_name = File.basename(schema_path.tr("/", "."), ".avsc")
 
         # Load and cache the schema.
         find(schema_name)
@@ -54,8 +54,8 @@ module SchemaRegistry
 
     # @param schema_hash [Hash]
     def add_schema(schema_hash)
-      name = schema_hash['name']
-      namespace = schema_hash['namespace']
+      name = schema_hash["name"]
+      namespace = schema_hash["namespace"]
       full_name = Avro::Name.make_fullname(name, namespace)
       return if @schemas.key?(full_name)
 
@@ -120,7 +120,7 @@ module SchemaRegistry
     end
 
     def build_schema_path(fullname)
-      *namespace, schema_name = fullname.split('.')
+      *namespace, schema_name = fullname.split(".")
       File.join(@path, *namespace, "#{schema_name}.avsc")
     end
   end

data/lib/schema_registry_client/cached_confluent_schema_registry.rb

@@ -31,7 +31,7 @@ module SchemaRegistry
       return @versions_by_subject_and_id[key] if @versions_by_subject_and_id[key]
 
       results = @upstream.schema_subject_versions(id)
-      @versions_by_subject_and_id[key] = results&.find { |r| r['subject'] == subject }&.dig('version')
+      @versions_by_subject_and_id[key] = results&.find { |r| r["subject"] == subject }&.dig("version")
     end
 
     # @param subject [String] the subject to check
@@ -45,13 +45,13 @@ module SchemaRegistry
     # @param schema [String] the schema text to register
     # @param references [Array<Hash>] optional references to other schemas
     # @param schema_type [String]
-    def register(subject, schema, references: [], schema_type: 'PROTOBUF')
+    def register(subject, schema, references: [], schema_type: "PROTOBUF")
       key = [subject, schema]
 
       @ids_by_schema[key] ||= @upstream.register(subject,
-                                                 schema,
-                                                 references: references,
-                                                 schema_type: schema_type)
+        schema,
+        references: references,
+        schema_type: schema_type)
     end
   end
 end

data/lib/schema_registry_client/confluent_schema_registry.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'excon'
+require "excon"
 
 module SchemaRegistry
   class ConfluentSchemaRegistry
-    CONTENT_TYPE = 'application/vnd.schemaregistry.v1+json'
+    CONTENT_TYPE = "application/vnd.schemaregistry.v1+json"
 
     def initialize( # rubocop:disable Metrics/ParameterLists
       url,
@@ -25,11 +25,11 @@ module SchemaRegistry
       retry_limit: nil
     )
       @path_prefix = path_prefix
-      @schema_context_prefix = schema_context.nil? ? '' : ":.#{schema_context}:"
-      @schema_context_options = schema_context.nil? ? {} : { query: { subject: @schema_context_prefix } }
+      @schema_context_prefix = schema_context.nil? ? "" : ":.#{schema_context}:"
+      @schema_context_options = schema_context.nil? ? {} : {query: {subject: @schema_context_prefix}}
       @logger = logger
       headers = Excon.defaults[:headers].merge(
-        'Content-Type' => CONTENT_TYPE
+        "Content-Type" => CONTENT_TYPE
       )
       params = {
         headers: headers,
@@ -59,7 +59,7 @@ module SchemaRegistry
     def fetch(id)
       @logger.info "Fetching schema with id #{id}"
       data = get("/schemas/ids/#{id}", idempotent: true, **@schema_context_options)
-      data.fetch('schema')
+      data.fetch("schema")
     end
 
     # @param schema_id [Integer] the schema ID to fetch versions for
@@ -72,13 +72,17 @@ module SchemaRegistry
     # @param schema [String] the schema text to check
     # @param references [Array<Hash>] optional references to other schemas
     # @return [Integer] the ID of the registered schema
-    def register(subject, schema, references: [], schema_type: 'PROTOBUF')
+    def register(subject, schema, references: [], schema_type: "PROTOBUF")
+      body = {references: references,
+              schema: schema.to_s}
+      # Not all schema registry versions support schemaType
+      if schema_type != "AVRO"
+        body[:schemaType] = schema_type
+      end
       data = post("/subjects/#{@schema_context_prefix}#{CGI.escapeURIComponent(subject)}/versions",
-                  body: { schemaType: schema_type,
-                          references: references,
-                          schema: schema.to_s }.to_json)
+        body: body.to_json)
 
-      id = data.fetch('id')
+      id = data.fetch("id")
 
       @logger.info "Registered schema for subject `#{@schema_context_prefix}#{subject}`; id = #{id}"
 
@@ -106,7 +110,7 @@ module SchemaRegistry
     end
 
     def request(path, **options)
-      options = { expects: 200 }.merge!(options)
+      options = {expects: 200}.merge!(options)
       path = File.join(@path_prefix, path) unless @path_prefix.nil?
       response = @connection.request(path: path, **options)
       JSON.parse(response.body)

data/lib/schema_registry_client/output/json_schema.rb

@@ -5,20 +5,20 @@ module SchemaRegistry
     module JsonSchema
       class << self
         def fetch(message_name)
-          name = message_name.start_with?('.') ? message_name[1..] : message_name
+          name = message_name.start_with?(".") ? message_name[1..] : message_name
           Google::Protobuf::DescriptorPool.generated_pool.lookup(name)
         end
 
         def output(descriptor, path: nil)
           properties = {}
           result = {
-            "$schema": 'https://json-schema.org/draft/2020-12/schema',
-            type: 'object',
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            type: "object",
             properties: properties
           }
           if path
             # follow path down
-            parts = path.split('.')
+            parts = path.split(".")
             field_name = parts.last
             parts[...-1].each do |part|
               field = descriptor.field.find { |f| f.name == part }
@@ -42,12 +42,12 @@ module SchemaRegistry
           if field.label == :LABEL_REPEATED && !ignore_repeated
             if klass&.options.respond_to?(:map_entry) && klass.options.map_entry
               return {
-                type: 'object',
+                type: "object",
                 additionalProperties: field_object(klass.field[1])
               }
             end
             return {
-              type: 'array',
+              type: "array",
               items: field_object(field, ignore_repeated: true)
             }
           end
@@ -57,18 +57,18 @@ module SchemaRegistry
         def field_type(field, klass)
           case field.type
           when :TYPE_INT32, :TYPE_UINT32, :TYPE_SINT32, :TYPE_FIXED32, :TYPE_SFIXED32
-            { type: 'integer' }
+            {type: "integer"}
           when :TYPE_FLOAT, :TYPE_DOUBLE
-            { type: 'number' }
+            {type: "number"}
           when :TYPE_INT64, :TYPE_UINT64, :TYPE_SINT64, :TYPE_FIXED64, :TYPE_SFIXED64, :TYPE_STRING, :TYPE_BYTES
-            { type: 'string' }
+            {type: "string"}
           when :TYPE_BOOL
-            { type: 'boolean' }
+            {type: "boolean"}
           else
             if klass.is_a?(Google::Protobuf::EnumDescriptorProto)
-              { enum: klass.to_h[:value].map { |h| h[:name] } }
+              {enum: klass.to_h[:value].map { |h| h[:name] }}
             else
-              { type: 'object' }
+              {type: "object"}
             end
           end
         end

data/lib/schema_registry_client/output/proto_text.rb

@@ -18,7 +18,7 @@ module SchemaRegistry
         end
 
         def write_indent(str)
-          @indent.times { write(' ') }
+          @indent.times { write(" ") }
           write(str)
         end
 
@@ -42,7 +42,7 @@ module SchemaRegistry
 
       class << self
         def fetch(message_name)
-          name = message_name.start_with?('.') ? message_name[1..] : message_name
+          name = message_name.start_with?(".") ? message_name[1..] : message_name
           Google::Protobuf::DescriptorPool.generated_pool.lookup(name)
         end
 
@@ -87,23 +87,23 @@ module SchemaRegistry
             info.indent
             write_field(info, extension)
             info.dedent
-            info.write_line('}')
+            info.write_line("}")
           end
           descriptor.extension.any?
         end
 
         def write_reserved(writer, descriptor)
           reserved = descriptor.reserved_range.map do |range|
-            range.start == range.end - 1 ? range.start.to_s : "#{range.start} to #{range.end - 1}"
+            (range.start == range.end - 1) ? range.start.to_s : "#{range.start} to #{range.end - 1}"
           end
           found = false
           if reserved.any?
             found = true
-            writer.write_line("reserved #{reserved.join(', ')};")
+            writer.write_line("reserved #{reserved.join(", ")};")
           end
           if descriptor.reserved_name.any?
             found = true
-            writer.write_line("reserved #{descriptor.reserved_name.map(&:to_json).join(', ')};")
+            writer.write_line("reserved #{descriptor.reserved_name.map(&:to_json).join(", ")};")
           end
           writer.writenl if found
         end
@@ -124,7 +124,7 @@ module SchemaRegistry
 
         def write_message(info, message_type)
           info.message = message_type
-          info.write_indent('message ')
+          info.write_indent("message ")
           info.write("#{message_type.name} {")
           info.writenl
           info.indent
@@ -150,61 +150,61 @@ module SchemaRegistry
             write_message(info, subtype)
           end
           info.dedent
-          info.write_line('}')
+          info.write_line("}")
         end
 
         def field_type(info, field_type)
           case field_type.type
           when :TYPE_INT32
-            'int32'
+            "int32"
           when :TYPE_INT64
-            'int64'
+            "int64"
           when :TYPE_UINT32
-            'uint32'
+            "uint32"
           when :TYPE_UINT64
-            'uint64'
+            "uint64"
           when :TYPE_SINT32
-            'sint32'
+            "sint32"
           when :TYPE_SINT64
-            'sint64'
+            "sint64"
           when :TYPE_FIXED32
-            'fixed32'
+            "fixed32"
           when :TYPE_FIXED64
-            'fixed64'
+            "fixed64"
           when :TYPE_SFIXED32
-            'sfixed32'
+            "sfixed32"
           when :TYPE_SFIXED64
-            'sfixed64'
+            "sfixed64"
           when :TYPE_FLOAT
-            'float'
+            "float"
           when :TYPE_DOUBLE
-            'double'
+            "double"
           when :TYPE_BOOL
-            'bool'
+            "bool"
           when :TYPE_STRING
-            'string'
+            "string"
           when :TYPE_BYTES
-            'bytes'
+            "bytes"
           when :TYPE_ENUM, :TYPE_MESSAGE
             # remove leading .
             type = fetch(field_type.type_name[1..])
-            name = type.name.sub("#{info.package}.#{info.message.name}.", '')
-            name.sub("#{info.package}.", '')
+            name = type.name.sub("#{info.package}.#{info.message.name}.", "")
+            name.sub("#{info.package}.", "")
           end
         end
 
         def write_field(info, field, oneof: false)
           return if !oneof && field.has_oneof_index?
 
-          info.write_indent('')
+          info.write_indent("")
 
           klass = nil
-          klass = fetch(field.type_name).to_proto if field.type_name && field.type_name != ''
+          klass = fetch(field.type_name).to_proto if field.type_name && field.type_name != ""
 
           if field.proto3_optional
-            info.write('optional ')
+            info.write("optional ")
           elsif field.label == :LABEL_REPEATED && !klass&.options&.map_entry
-            info.write('repeated ')
+            info.write("repeated ")
           end
 
           if klass&.options&.map_entry
@@ -215,24 +215,24 @@ module SchemaRegistry
           info.write(" #{field.name} = #{field.number}")
 
           write_field_options(info, field)
-          info.write(';')
+          info.write(";")
           info.writenl
         end
 
         def write_field_options(info, field)
           return unless field.options
 
-          info.write(' [')
-          info.write(field.options.to_h.map { |name, value| "#{name} = #{value}" }.join(', '))
+          info.write(" [")
+          info.write(field.options.to_h.map { |name, value| "#{name} = #{value}" }.join(", "))
           write_options(info, field, include_option_label: false)
-          info.write(']')
+          info.write("]")
         end
 
         def write_oneofs(info, message)
           message.oneof_decl.each_with_index do |oneof, i|
             # synthetic oneof for proto3 optional fields
-            next if oneof.name.start_with?('_') &&
-                    message.field.any? { |f| f.proto3_optional && f.name == oneof.name[1..] }
+            next if oneof.name.start_with?("_") &&
+              message.field.any? { |f| f.proto3_optional && f.name == oneof.name[1..] }
 
             info.write_line("oneof #{oneof.name} {")
             info.indent
@@ -240,12 +240,12 @@ module SchemaRegistry
               write_field(info, field, oneof: true)
             end
             info.dedent
-            info.write_line('}')
+            info.write_line("}")
           end
         end
 
         def write_enum(info, enum_type)
-          info.write('enum ')
+          info.write("enum ")
           info.write("#{enum_type.name} {")
           info.writenl
           info.indent
@@ -254,30 +254,30 @@ module SchemaRegistry
             info.write_line("#{value.name} = #{value.number};")
           end
           info.dedent
-          info.write_line('}')
+          info.write_line("}")
           info.writenl
         end
 
         def method_type(package, name)
-          output = name.sub("#{package}.", '')
-          output = output[1..] if output.start_with?('.')
+          output = name.sub("#{package}.", "")
+          output = output[1..] if output.start_with?(".")
           output
         end
 
         def write_service(info, service)
           info.write_line("service #{service.name} {")
           info.indent
-          service['method'].each do |method|
+          service["method"].each do |method|
             info.write_indent("rpc #{method.name}(#{method_type(info.package, method.input_type)}) ")
             info.write("returns (#{method_type(info.package, method.output_type)}) {")
             info.writenl
             info.indent
             write_options(info, method) if method.options
             info.dedent
-            info.write_line('};')
+            info.write_line("};")
           end
           info.dedent
-          info.write_line('}')
+          info.write_line("}")
         end
 
         # @return [Boolean] true if any options were written
@@ -289,7 +289,7 @@ module SchemaRegistry
 
           found = false
           json.each_key do |name|
-            option_name = name.tr('[]', '')
+            option_name = name.tr("[]", "")
             ext = fetch(option_name)
             next if ext.nil?
 
@@ -306,7 +306,7 @@ module SchemaRegistry
                 info.write_indent(line)
                 info.writenl if i < lines.length - 1
               end
-              info.write(';')
+              info.write(";")
             else
               info.write(options.to_json)
             end

data/lib/schema_registry_client/schema/avro.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'schema_registry_client/schema/base'
-require 'schema_registry_client/avro_schema_store'
+require "schema_registry_client/schema/base"
+require "schema_registry_client/avro_schema_store"
 
 module SchemaRegistry
   module Schema
     class Avro < Base
-      DEFAULT_SCHEMAS_PATH = './schemas'
+      DEFAULT_SCHEMAS_PATH = "./schemas"
 
       def self.schema_type
-        'AVRO'
+        "AVRO"
       end
 
       # @param schema_store [SchemaRegistry::AvroSchemaStore, nil]
@@ -31,9 +31,9 @@ module SchemaRegistry
       end
 
       def encode(message, stream, schema_name: nil)
-        validate_options = { recursive: true,
-                             encoded: false,
-                             fail_on_extra_fields: true }
+        validate_options = {recursive: true,
+                            encoded: false,
+                            fail_on_extra_fields: true}
         schema = schema_store.find(schema_name)
 
         ::Avro::SchemaValidator.validate!(schema, message, **validate_options)
@@ -53,7 +53,7 @@ module SchemaRegistry
         # Try to find the reader schema locally, fall back to writer schema
         readers_schema = begin
           schema_store.find(writers_schema.fullname)
-        rescue StandardError
+        rescue
           writers_schema
         end
 

data/lib/schema_registry_client/schema/base.rb

@@ -9,19 +9,19 @@ module SchemaRegistry
       # @param schema_name [String]
       # @return [String]
       def schema_text(_message, schema_name: nil)
-        raise MissingImplementationError, 'Subclasses must implement schema_text'
+        raise MissingImplementationError, "Subclasses must implement schema_text"
       end
 
       # @return [String]
       def self.schema_type
-        raise MissingImplementationError, 'Subclasses must implement schema_type'
+        raise MissingImplementationError, "Subclasses must implement schema_type"
       end
 
       # @param message [Object]
       # @param stream [StringIO]
       # @param schema_name [String]
       def encode(_message, _stream, schema_name: nil)
-        raise MissingImplementationError, 'Subclasses must implement encode'
+        raise MissingImplementationError, "Subclasses must implement encode"
       end
 
       # @param stream [StringIO]
@@ -29,7 +29,7 @@ module SchemaRegistry
       # @param registry [Object]
       # @return [Object]
       def decode(_stream, _schema_text)
-        raise MissingImplementationError, 'Subclasses must implement decode'
+        raise MissingImplementationError, "Subclasses must implement decode"
       end
 
       # @param message [Object]

data/lib/schema_registry_client/schema/proto_json_schema.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'schema_registry_client/schema/base'
-require 'schema_registry_client/output/json_schema'
+require "schema_registry_client/schema/base"
+require "schema_registry_client/output/json_schema"
 
 module SchemaRegistry
   module Schema
     class ProtoJsonSchema < Base
       def self.schema_type
-        'JSON'
+        "JSON"
       end
 
       def schema_text(message, schema_name: nil)