schema_registry_client 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11e7f32b7a5774218f42c65cb0e23bf078409d3db664e077362cb956c408f612
-  data.tar.gz: a814e18b0ceb5a6794a9953f2c17793ea246e4d021d71cc7b543f784c7223070
+  metadata.gz: 8c4fb0ad39418dd0eb14e803f4c0652e47e64950b8684f564221a95b024177c1
+  data.tar.gz: c04a0a44298ff123a0a63cf530fe2c2ae56b7230cc740e2d02577f712d045e41
 SHA512:
-  metadata.gz: 47e021f857a27b93e9800ff93c376493e2c408eeba06ca1a0549b8909b4d0e19f5372667b34548171208e610a63f03d9960223bf95cd2c2508fc9f8d167df130
-  data.tar.gz: 55e451acce060a38616a53889973b2640dfde252e1455a1f324789440dda11c6b3860995f188fdea54daa71e4ecf7a7b024964fa665f9e411744418f9f14c457
+  metadata.gz: c68cf8a284acdaad830acbbc76ea49b2cb1431b69e3c2961218f5c8af399b89d64f8b5eb1e25536e415f5720080152853f885d9984b47790ffd02d01cad73709
+  data.tar.gz: 7fb3f61b7159bf9f461f3fc9b6f8d0f145592f18a35b1e02d284a6f2ed62c95d30a6d8ff1082b2607976f134e6a74e1416e00483e61f8db2ecf27f601112bd84

data/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## UNRELEASED
 
+# 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

@@ -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.7)
+    schema_registry_client (0.0.8)
       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/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,13 @@ 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')
       data = post("/subjects/#{@schema_context_prefix}#{CGI.escapeURIComponent(subject)}/versions",
-        body: {schemaType: schema_type,
-               references: references,
-               schema: schema.to_s}.to_json)
+                  body: { schemaType: schema_type,
+                          references: references,
+                          schema: schema.to_s }.to_json)
 
-      id = data.fetch("id")
+      id = data.fetch('id')
 
       @logger.info "Registered schema for subject `#{@schema_context_prefix}#{subject}`; id = #{id}"
 
@@ -106,7 +106,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