schema_registry_client 0.0.7 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11e7f32b7a5774218f42c65cb0e23bf078409d3db664e077362cb956c408f612
-  data.tar.gz: a814e18b0ceb5a6794a9953f2c17793ea246e4d021d71cc7b543f784c7223070
+  metadata.gz: d0919f12f0457fbdf7becd62389a7ed72e34afe9d7f3ce5c819f2e0ebf145174
+  data.tar.gz: 4dc5c91669e508e89bc07763bebb6b754403ee72ccbe125ecfc888c48cf974fa
 SHA512:
-  metadata.gz: 47e021f857a27b93e9800ff93c376493e2c408eeba06ca1a0549b8909b4d0e19f5372667b34548171208e610a63f03d9960223bf95cd2c2508fc9f8d167df130
-  data.tar.gz: 55e451acce060a38616a53889973b2640dfde252e1455a1f324789440dda11c6b3860995f188fdea54daa71e4ecf7a7b024964fa665f9e411744418f9f14c457
+  metadata.gz: 07d614eaceb30420a69221399fab2e360f3f3b4089e5271b42fcaca30eb9f643cebcdd59187bdfc6a33d721641b960e2855fefce4703e59f455e459088bbd996
+  data.tar.gz: 65a8cf4a6899e8f32febb2b408ebb20ed379224b7fbd0d716da33c6e0e6c10844559e5d4e1af73c3ee06a1601ecd0dc3853137aa3987837157bbd07c07655a21

data/CHANGELOG.md

@@ -7,6 +7,15 @@ 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.
+* Move schema backend methods from class-level to instance-level and require instantiation.
+
 # 0.0.7 - 2026-01-05
 
 * Switch to using `SchemaRegistry::Client` instead of bare `SchemaRegistry`.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    schema_registry_client (0.0.7)
+    schema_registry_client (0.0.9)
       avro
       excon
       google-protobuf
@@ -22,33 +22,12 @@ GEM
     docile (1.4.1)
     excon (1.3.2)
       logger
-    google-protobuf (4.33.2)
-      bigdecimal
-      rake (>= 13)
-    google-protobuf (4.33.2-aarch64-linux-gnu)
-      bigdecimal
-      rake (>= 13)
-    google-protobuf (4.33.2-aarch64-linux-musl)
-      bigdecimal
-      rake (>= 13)
     google-protobuf (4.33.2-arm64-darwin)
       bigdecimal
       rake (>= 13)
-    google-protobuf (4.33.2-x86-linux-gnu)
-      bigdecimal
-      rake (>= 13)
-    google-protobuf (4.33.2-x86-linux-musl)
-      bigdecimal
-      rake (>= 13)
-    google-protobuf (4.33.2-x86_64-darwin)
-      bigdecimal
-      rake (>= 13)
     google-protobuf (4.33.2-x86_64-linux-gnu)
       bigdecimal
       rake (>= 13)
-    google-protobuf (4.33.2-x86_64-linux-musl)
-      bigdecimal
-      rake (>= 13)
     hashdiff (1.2.1)
     json (2.18.0)
     language_server-protocol (3.17.0.5)
@@ -127,15 +106,8 @@ GEM
       hashdiff (>= 0.4.0, < 2.0.0)
 
 PLATFORMS
-  aarch64-linux-gnu
-  aarch64-linux-musl
   arm64-darwin
-  ruby
-  x86-linux-gnu
-  x86-linux-musl
-  x86_64-darwin
-  x86_64-linux-gnu
-  x86_64-linux-musl
+  x86_64-linux
 
 DEPENDENCIES
   bundler (~> 2.0)

data/LICENSE

@@ -1,3 +1,5 @@
+Copyright (c) 2015 Daniel Schierbeck
+
 MIT License
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.md

@@ -1,6 +1,6 @@
 # schema_registry_client
 
-`schema_registry_client` is a library to interact with the Confluent Schema Registry using Google Protobuf. It is inspired by and based off of [avro_turf](https://github.com/dasch/avro_turf).
+`schema_registry_client` is a library to interact with the Confluent Schema Registry. It is inspired by and based off of [avro_turf](https://github.com/dasch/avro_turf).
 
 ## Installation
 
@@ -24,21 +24,66 @@ SchemaRegistry interacts with the Confluent Schema Registry, and caches all resu
 
 Example usage:
 
+### Avro
+
+Note that unlike AvroTurf, you must concatenate the namespace and schema name together when encoding.
+
 ```ruby
 require 'schema_registry_client'
 
-schema_registry_client = SchemaRegistry::Client.new(registry_url: 'http://localhost:8081', schema_paths: ['path/to/protos'])
-message = MyProto::MyMessage.new(field1: 'value1', field2: 42)
-encoded = schema_registry_client.encode(message, subject: 'my-subject')
+client = SchemaRegistry::Client.new(registry_url: 'http://localhost:8081', schema_type: SchemaRegistry::Schema::Avro.new)
+SchemaRegistry.avro_schema_path = 'path/to/schemas'
+message = {field1: 'value1', field2: 42 }
+encoded = client.encode(message, schema_name: 'com.my-namespace.MySchema', subject: 'my-subject')
+
+# Decoding
+
+decoded_avro_message = client.decode(encoded_string)
+```
+
+### Protobuf
+
+```ruby
+client = SchemaRegistry::Client.new(registry_url: 'http://localhost:8081', schema_type: SchemaRegistry::Schema::Protobuf.new)
+message = MyProtoMessage.new(field1: 'value1', field2: 42)
+encoded = client.encode(message, subject: 'my-proto-subject')
 
 # Decoding
+decoded_proto_message = client.decode(encoded_string)
+```
 
-decoded_proto_message = schema_registry_client.decode(encoded_string)
+### Protobuf JSON Schema
+
+Since Protobuf is [not recommended to use for Kafka keys](https://protobuf.dev/programming-guides/encoding/#implications), it's instead recommended that you use the `ProtoJsonSchema` format. This will transform the Protobuf message into a JSON schema and register that with the registry instead. The encoded message will be the JSON representation of the Protobuf message, with keys sorted alphabetically to ensure consistent encoding.
+
+Note that the algorithm to translate into JSON Schema is currently very naive (e.g. it does not handle nested messages) since keys should usually be very simple. If more complex logic is needed, pull requests are welcome.
+
+```ruby
+client = SchemaRegistry::Client.new(registry_url: 'http://localhost:8081', schema_type: SchemaRegistry::Schema::ProtoJsonSchema)
+message = MyProtoMessage.new(field1: 'value1', field2: 42)
+encoded = client.encode(message, subject: 'my-proto-subject') # will register a JSON Schema subject and encode into JSON
+
+```
+
+You can use JSON Schema with regular Ruby hashes as well by passing `schema_text` into the encode method:
+
+```ruby
+client = SchemaRegistry::Client.new(registry_url: 'http://localhost:8081', schema_type: SchemaRegistry::Schema::ProtoJsonSchema)
+message = { field1: 'value1', field2: 42 }
+schema_text = {
+    "type" => "object",
+    "properties" => {
+        "field1" => { "type" => "string" },
+        "field2" => { "type" => "integer" }
+    },
+    "required" => ["field1", "field2"]
+}.to_json
+encoded = client.encode(message, subject: 'my-proto-subject', schema_text: schema_text)
 ```
 
 ## Notes about usage
 
-* When decoding, this library does *not* attempt to fully parse the Proto definition stored on the schema registry and generate dynamic classes. Instead, it simply parses out the package and message and assumes that the reader has the message available in the descriptor pool. Any compatibility issues should be detected through normal means, i.e. just by instantiating the message and seeing if any errors are raised.
+* When decoding, this library does *not* attempt to fully parse the Protobuf definition stored on the schema registry and generate dynamic classes. Instead, it simply parses out the package and message and assumes that the reader has the message available in the descriptor pool. Any compatibility issues should be detected through normal means, i.e. just by instantiating the message and seeing if any errors are raised.
 
 ### Regenerating test protos
 Run the following to regenerate:

data/lib/schema_registry_client/confluent_schema_registry.rb

@@ -73,10 +73,14 @@ module SchemaRegistry
     # @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")
+      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")
 

data/lib/schema_registry_client/schema/avro.rb

@@ -8,53 +8,57 @@ module SchemaRegistry
     class Avro < Base
       DEFAULT_SCHEMAS_PATH = "./schemas"
 
-      class << self
-        def schema_type
-          "AVRO"
-        end
+      def self.schema_type
+        "AVRO"
+      end
 
-        def schema_store
-          @schema_store ||= SchemaRegistry::AvroSchemaStore.new(
-            path: SchemaRegistry.avro_schema_path || DEFAULT_SCHEMAS_PATH
-          )
-          @schema_store.load_schemas!
-          @schema_store
-        end
+      # @param schema_store [SchemaRegistry::AvroSchemaStore, nil]
+      def initialize(schema_store: nil)
+        @schema_store = schema_store
+      end
 
-        def schema_text(_message, schema_name: nil)
-          schema_store.find_text(schema_name)
-        end
+      # @return [SchemaRegistry::AvroSchemaStore]
+      def schema_store
+        @schema_store ||= SchemaRegistry::AvroSchemaStore.new(
+          path: SchemaRegistry.avro_schema_path || DEFAULT_SCHEMAS_PATH
+        )
+        @schema_store.load_schemas!
+        @schema_store
+      end
 
-        def encode(message, stream, schema_name: nil)
-          validate_options = {recursive: true,
-                              encoded: false,
-                              fail_on_extra_fields: true}
-          schema = schema_store.find(schema_name)
+      def schema_text(_message, schema_name: nil)
+        schema_store.find_text(schema_name)
+      end
 
-          ::Avro::SchemaValidator.validate!(schema, message, **validate_options)
+      def encode(message, stream, schema_name: nil)
+        validate_options = {recursive: true,
+                            encoded: false,
+                            fail_on_extra_fields: true}
+        schema = schema_store.find(schema_name)
 
-          writer = ::Avro::IO::DatumWriter.new(schema)
-          encoder = ::Avro::IO::BinaryEncoder.new(stream)
-          writer.write(message, encoder)
-        end
+        ::Avro::SchemaValidator.validate!(schema, message, **validate_options)
 
-        def decode(stream, schema_text)
-          # Parse the schema text from the registry into an Avro schema object
-          JSON.parse(schema_text)
-          writers_schema = ::Avro::Schema.parse(schema_text)
+        writer = ::Avro::IO::DatumWriter.new(schema)
+        encoder = ::Avro::IO::BinaryEncoder.new(stream)
+        writer.write(message, encoder)
+      end
 
-          decoder = ::Avro::IO::BinaryDecoder.new(stream)
+      def decode(stream, schema_text)
+        # Parse the schema text from the registry into an Avro schema object
+        JSON.parse(schema_text)
+        writers_schema = ::Avro::Schema.parse(schema_text)
 
-          # Try to find the reader schema locally, fall back to writer schema
-          readers_schema = begin
-            schema_store.find(writers_schema.fullname)
-          rescue
-            writers_schema
-          end
+        decoder = ::Avro::IO::BinaryDecoder.new(stream)
 
-          reader = ::Avro::IO::DatumReader.new(writers_schema, readers_schema)
-          reader.read(decoder)
+        # Try to find the reader schema locally, fall back to writer schema
+        readers_schema = begin
+          schema_store.find(writers_schema.fullname)
+        rescue
+          writers_schema
         end
+
+        reader = ::Avro::IO::DatumReader.new(writers_schema, readers_schema)
+        reader.read(decoder)
       end
     end
   end

data/lib/schema_registry_client/schema/base.rb

@@ -5,39 +5,37 @@ module SchemaRegistry
     class MissingImplementationError < StandardError; end
 
     class Base
-      class << self
-        # @param message [Object]
-        # @param schema_name [String]
-        # @return [String]
-        def schema_text(_message, schema_name: nil)
-          raise MissingImplementationError, "Subclasses must implement schema_text"
-        end
+      # @param message [Object]
+      # @param schema_name [String]
+      # @return [String]
+      def schema_text(_message, schema_name: nil)
+        raise MissingImplementationError, "Subclasses must implement schema_text"
+      end
 
-        # @return [String]
-        def schema_type
-          raise MissingImplementationError, "Subclasses must implement schema_type"
-        end
+      # @return [String]
+      def self.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"
-        end
+      # @param message [Object]
+      # @param stream [StringIO]
+      # @param schema_name [String]
+      def encode(_message, _stream, schema_name: nil)
+        raise MissingImplementationError, "Subclasses must implement encode"
+      end
 
-        # @param stream [StringIO]
-        # @param schema_text [String]
-        # @param registry [Object]
-        # @return [Object]
-        def decode(_stream, _schema_text)
-          raise MissingImplementationError, "Subclasses must implement decode"
-        end
+      # @param stream [StringIO]
+      # @param schema_text [String]
+      # @param registry [Object]
+      # @return [Object]
+      def decode(_stream, _schema_text)
+        raise MissingImplementationError, "Subclasses must implement decode"
+      end
 
-        # @param message [Object]
-        # @return [Hash<String, String>]
-        def dependencies(_message)
-          {}
-        end
+      # @param message [Object]
+      # @return [Hash<String, String>]
+      def dependencies(_message)
+        {}
       end
     end
   end

data/lib/schema_registry_client/schema/proto_json_schema.rb

@@ -6,24 +6,22 @@ require "schema_registry_client/output/json_schema"
 module SchemaRegistry
   module Schema
     class ProtoJsonSchema < Base
-      class << self
-        def schema_type
-          "JSON"
-        end
+      def self.schema_type
+        "JSON"
+      end
 
-        def schema_text(message, schema_name: nil)
-          SchemaRegistry::Output::JsonSchema.output(message.class.descriptor.to_proto)
-        end
+      def schema_text(message, schema_name: nil)
+        SchemaRegistry::Output::JsonSchema.output(message.class.descriptor.to_proto)
+      end
 
-        def encode(message, stream, schema_name: nil)
-          json = message.to_h.sort.to_h.to_json
-          stream.write(json)
-        end
+      def encode(message, stream, schema_name: nil)
+        json = message.to_h.sort.to_h.to_json
+        stream.write(json)
+      end
 
-        def decode(stream, _schema_text)
-          json = stream.read
-          JSON.parse(json)
-        end
+      def decode(stream, _schema_text)
+        json = stream.read
+        JSON.parse(json)
       end
     end
   end

data/lib/schema_registry_client/schema/protobuf.rb

@@ -10,121 +10,121 @@ require "schema_registry_client/wire"
 module SchemaRegistry
   module Schema
     class Protobuf < Base
-      class << self
-        def schema_type
-          "PROTOBUF"
-        end
+      def self.schema_type
+        "PROTOBUF"
+      end
 
-        def schema_text(message, schema_name: nil)
-          file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
-            message
-          else
-            message.class.descriptor.file_descriptor
-          end
-          SchemaRegistry::Output::ProtoText.output(file_descriptor.to_proto)
+      def schema_text(message, schema_name: nil)
+        file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
+          message
+        else
+          message.class.descriptor.file_descriptor
         end
+        SchemaRegistry::Output::ProtoText.output(file_descriptor.to_proto)
+      end
 
-        def encode(message, stream, schema_name: nil)
-          _, indexes = find_index(message.class.descriptor.to_proto,
-            message.class.descriptor.file_descriptor.to_proto.message_type)
-
-          if indexes == [0]
-            SchemaRegistry::Wire.write_int(stream, 0)
-          else
-            SchemaRegistry::Wire.write_int(stream, indexes.length)
-            indexes.each { |i| SchemaRegistry::Wire.write_int(stream, i) }
-          end
+      def encode(message, stream, schema_name: nil)
+        _, indexes = find_index(message.class.descriptor.to_proto,
+          message.class.descriptor.file_descriptor.to_proto.message_type)
 
-          # Now we write the actual message.
-          stream.write(message.to_proto)
+        if indexes == [0]
+          SchemaRegistry::Wire.write_int(stream, 0)
+        else
+          SchemaRegistry::Wire.write_int(stream, indexes.length)
+          indexes.each { |i| SchemaRegistry::Wire.write_int(stream, i) }
         end
 
-        def decode(stream, schema_text)
-          # See https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
-          index_length = SchemaRegistry::Wire.read_int(stream)
-          indexes = []
-          if index_length.zero?
-            indexes.push(0)
-          else
-            index_length.times do
-              indexes.push(SchemaRegistry::Wire.read_int(stream))
-            end
-          end
+        # Now we write the actual message.
+        stream.write(message.to_proto)
+      end
 
-          encoded = stream.read
-          decode_protobuf(schema_text, encoded, indexes)
+      def decode(stream, schema_text)
+        # See https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format
+        index_length = SchemaRegistry::Wire.read_int(stream)
+        indexes = []
+        if index_length.zero?
+          indexes.push(0)
+        else
+          index_length.times do
+            indexes.push(SchemaRegistry::Wire.read_int(stream))
+          end
         end
 
-        def load_schemas!
-          @all_schemas = {}
-          all_files = ObjectSpace.each_object(Google::Protobuf::FileDescriptor).to_a
-          all_files.each do |file_desc|
-            file_path = file_desc.name
-            next if file_path.start_with?("google/protobuf/") # skip built-in protos
+        encoded = stream.read
+        decode_protobuf(schema_text, encoded, indexes)
+      end
 
-            @all_schemas[file_path] = file_desc
-          end
+      def load_schemas!
+        @all_schemas = {}
+        all_files = ObjectSpace.each_object(Google::Protobuf::FileDescriptor).to_a
+        all_files.each do |file_desc|
+          file_path = file_desc.name
+          next if file_path.start_with?("google/protobuf/") # skip built-in protos
+
+          @all_schemas[file_path] = file_desc
         end
+      end
 
-        def dependencies(message)
-          load_schemas! unless @all_schemas&.any?
-          file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
-            message
-          else
-            message.class.descriptor.file_descriptor
-          end
+      def dependencies(message)
+        return [] if message.nil?
 
-          deps = file_descriptor.to_proto.dependency.to_a
-            .reject { |d| d.start_with?("google/protobuf/") }
-          deps.to_h do |dep|
-            dependency_schema = @all_schemas[dep]
-            [dependency_schema.name, dependency_schema]
-          end
+        load_schemas! unless @all_schemas&.any?
+        file_descriptor = if message.is_a?(Google::Protobuf::FileDescriptor)
+          message
+        else
+          message.class.descriptor.file_descriptor
         end
 
-        def find_index(descriptor, messages, indexes = [])
-          messages.each_with_index do |sub_descriptor, i|
-            if sub_descriptor == descriptor
-              indexes.push(i)
-              return [true, indexes]
-            else
-              found, found_indexes = find_index(descriptor, sub_descriptor.nested_type, indexes + [i])
-              return [true, found_indexes] if found
-            end
-          end
-          []
+        deps = file_descriptor.to_proto.dependency.to_a
+          .reject { |d| d.start_with?("google/protobuf/") }
+        deps.to_h do |dep|
+          dependency_schema = @all_schemas[dep]
+          [dependency_schema.name, dependency_schema]
         end
+      end
 
-        def find_descriptor(indexes, messages)
-          first_index = indexes.shift
-          message = messages[first_index]
-          path = [message.name]
-          while indexes.length.positive?
-            message = message.nested_type[indexes.shift]
-            path.push(message.name)
+      def find_index(descriptor, messages, indexes = [])
+        messages.each_with_index do |sub_descriptor, i|
+          if sub_descriptor == descriptor
+            indexes.push(i)
+            return [true, indexes]
+          else
+            found, found_indexes = find_index(descriptor, sub_descriptor.nested_type, indexes + [i])
+            return [true, found_indexes] if found
           end
-          path
         end
+        []
+      end
 
-        def decode_protobuf(schema, encoded, indexes)
-          # get the package
-          package = schema.match(/package (\S+);/)[1]
-          # get the first message in the protobuf text
-          # TODO - get the correct message based on schema index
-          message_name = schema.match(/message (\w+) {/)[1]
-          # look up the descriptor
-          full_name = "#{package}.#{message_name}"
-          descriptor = Google::Protobuf::DescriptorPool.generated_pool.lookup(full_name)
-          unless descriptor
-            msg = "Could not find schema for #{full_name}. " \
-                  "Make sure the corresponding .proto file has been compiled and loaded."
-            raise msg
-          end
+      def find_descriptor(indexes, messages)
+        first_index = indexes.shift
+        message = messages[first_index]
+        path = [message.name]
+        while indexes.length.positive?
+          message = message.nested_type[indexes.shift]
+          path.push(message.name)
+        end
+        path
+      end
 
-          path = find_descriptor(indexes, descriptor.file_descriptor.to_proto.message_type)
-          correct_message = Google::Protobuf::DescriptorPool.generated_pool.lookup("#{package}.#{path.join(".")}")
-          correct_message.msgclass.decode(encoded)
+      def decode_protobuf(schema, encoded, indexes)
+        # get the package
+        package = schema.match(/package (\S+);/)[1]
+        # get the first message in the protobuf text
+        # TODO - get the correct message based on schema index
+        message_name = schema.match(/message (\w+) {/)[1]
+        # look up the descriptor
+        full_name = "#{package}.#{message_name}"
+        descriptor = Google::Protobuf::DescriptorPool.generated_pool.lookup(full_name)
+        unless descriptor
+          msg = "Could not find schema for #{full_name}. " \
+                "Make sure the corresponding .proto file has been compiled and loaded."
+          raise msg
         end
+
+        path = find_descriptor(indexes, descriptor.file_descriptor.to_proto.message_type)
+        correct_message = Google::Protobuf::DescriptorPool.generated_pool.lookup("#{package}.#{path.join(".")}")
+        correct_message.msgclass.decode(encoded)
       end
     end
   end

data/lib/schema_registry_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SchemaRegistry
-  VERSION = "0.0.7"
+  VERSION = "0.0.9"
 end

data/lib/schema_registry_client.rb

@@ -66,7 +66,7 @@ module SchemaRegistry
       client_key_data: nil,
       connect_timeout: nil,
       resolv_resolver: nil,
-      schema_type: SchemaRegistry::Schema::Protobuf
+      schema_type: SchemaRegistry::Schema::Protobuf.new
     )
       @logger = logger || Logger.new($stderr)
       @registry = registry || SchemaRegistry::CachedConfluentSchemaRegistry.new(
@@ -152,9 +152,7 @@ module SchemaRegistry
             version: versions[i]
           }
         end,
-        schema_type: @schema.schema_type)
+        schema_type: @schema.class.schema_type)
     end
-
   end
-
 end

data/spec/decoding_spec.rb

@@ -40,7 +40,7 @@ RSpec.describe "decoding" do
     let(:schema_registry_client) do
       SchemaRegistry::Client.new(
         registry_url: "http://localhost:8081",
-        schema_type: SchemaRegistry::Schema::ProtoJsonSchema
+        schema_type: SchemaRegistry::Schema::ProtoJsonSchema.new
       )
     end
 
@@ -64,7 +64,7 @@ RSpec.describe "decoding" do
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
       SchemaRegistry::Client.new(
         registry_url: "http://localhost:8081",
-        schema_type: SchemaRegistry::Schema::Avro
+        schema_type: SchemaRegistry::Schema::Avro.new
       )
     end
 

data/spec/encoding_spec.rb

@@ -61,7 +61,7 @@ RSpec.describe "encoding" do
     let(:schema_registry_client) do
       SchemaRegistry::Client.new(
         registry_url: "http://localhost:8081",
-        schema_type: SchemaRegistry::Schema::ProtoJsonSchema
+        schema_type: SchemaRegistry::Schema::ProtoJsonSchema.new
       )
     end
 
@@ -106,7 +106,7 @@ RSpec.describe "encoding" do
       SchemaRegistry.avro_schema_path = "#{__dir__}/schemas"
       SchemaRegistry::Client.new(
         registry_url: "http://localhost:8081",
-        schema_type: SchemaRegistry::Schema::Avro
+        schema_type: SchemaRegistry::Schema::Avro.new
       )
     end
 
@@ -117,8 +117,7 @@ RSpec.describe "encoding" do
     it "should encode a simple message" do
       schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
       stub = stub_request(:post, "http://localhost:8081/subjects/simple/versions")
-        .with(body: {"schemaType" => "AVRO",
-                     "references" => [],
+        .with(body: {"references" => [],
                      "schema" => schema}).to_return_json(body: {id: 15})
       msg = {"name" => "my name"}
       encoded = schema_registry_client.encode(msg, subject: "simple", schema_name: "simple.v1.SimpleMessage")
@@ -136,8 +135,7 @@ RSpec.describe "encoding" do
     it "should encode a complex message with nested record" do
       schema = File.read("#{__dir__}/schemas/referenced/v1/MessageBA.avsc")
       stub = stub_request(:post, "http://localhost:8081/subjects/referenced/versions")
-        .with(body: {"schemaType" => "AVRO",
-                     "references" => [],
+        .with(body: {"references" => [],
                      "schema" => schema}).to_return_json(body: {id: 20})
       msg = {
         "simple" => {
@@ -172,8 +170,7 @@ RSpec.describe "encoding" do
       File.write("#{multi_schema_path}/MultiFieldMessage.avsc", schema_json)
 
       stub = stub_request(:post, "http://localhost:8081/subjects/multi/versions")
-        .with(body: {"schemaType" => "AVRO",
-                     "references" => [],
+        .with(body: {"references" => [],
                      "schema" => schema_json}).to_return_json(body: {id: 25})
 
       msg = {"name" => "Alice", "age" => 30}
@@ -192,8 +189,7 @@ RSpec.describe "encoding" do
     it "should validate schema before encoding" do
       schema = File.read("#{__dir__}/schemas/simple/v1/SimpleMessage.avsc")
       stub_request(:post, "http://localhost:8081/subjects/simple/versions")
-        .with(body: {"schemaType" => "AVRO",
-                     "references" => [],
+        .with(body: {"references" => [],
                      "schema" => schema}).to_return_json(body: {id: 15})
 
       # Invalid message - missing required field

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_registry_client
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.9
 platform: ruby
 authors:
 - Daniel Orner