schema_registry_client 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bd3f6c9d59bc29bfbcc32577761bd90b17282dc63b7423a1d74978235b316c8
-  data.tar.gz: fde47855e0974f734724d0c9fbe36b80644be5ed2f42215cbfa389e4951affdb
+  metadata.gz: 11e7f32b7a5774218f42c65cb0e23bf078409d3db664e077362cb956c408f612
+  data.tar.gz: a814e18b0ceb5a6794a9953f2c17793ea246e4d021d71cc7b543f784c7223070
 SHA512:
-  metadata.gz: dd97621d317f2f951c960b2f928832004c8d38b8c4f0ebdf291bbdb68ed7d873f83f4a789426479ead787f77f1dc00c2a5c1898407373a1fdc27b448c6ed1f97
-  data.tar.gz: fe7f21af487e6e8294977e5b50e77bd2a77648df7eb1b9bd4cb56a709fe09e0401ecba9e44ba35854b6383d35fcb2baf3530cf485963f7887a4e1fa8c0fc6dc4
+  metadata.gz: 47e021f857a27b93e9800ff93c376493e2c408eeba06ca1a0549b8909b4d0e19f5372667b34548171208e610a63f03d9960223bf95cd2c2508fc9f8d167df130
+  data.tar.gz: 55e451acce060a38616a53889973b2640dfde252e1455a1f324789440dda11c6b3860995f188fdea54daa71e4ecf7a7b024964fa665f9e411744418f9f14c457

data/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## UNRELEASED
 
+# 0.0.7 - 2026-01-05
+
+* Switch to using `SchemaRegistry::Client` instead of bare `SchemaRegistry`.
+* Throw correct error when Avro schema is not found.
+
 # 0.0.6 - 2026-01-02
 
 * Initial release.

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.6)
+    schema_registry_client (0.0.7)
       avro
       excon
       google-protobuf

data/README.md

@@ -27,7 +27,7 @@ Example usage:
 ```ruby
 require 'schema_registry_client'
 
-schema_registry_client = SchemaRegistry.new(registry_url: 'http://localhost:8081', schema_paths: ['path/to/protos'])
+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')
 

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"
 
-class SchemaRegistry
+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 @@ class 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 @@ class 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)
 
@@ -116,11 +116,11 @@ class SchemaRegistry
       end
       load_schema!(fullname, @schemas.dup)
     rescue Errno::ENOENT, Errno::ENAMETOOLONG
-      raise "could not find Avro schema at `#{schema_path}'"
+      raise SchemaRegistry::SchemaNotFoundError, "could not find Avro schema at `#{schema_path}'"
     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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   class CachedConfluentSchemaRegistry
     # @param upstream [SchemaRegistry::ConfluentSchemaRegistry]
     def initialize(upstream)
@@ -31,7 +31,7 @@ class 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 @@ class 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"
 
-class SchemaRegistry
+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 @@ class 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 @@ class 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 @@ class 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 @@ class 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

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   module Output
     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 @@ class 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 @@ class 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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   module Output
     module ProtoText
       ParseInfo = Struct.new(:writer, :package, :message) do
@@ -18,7 +18,7 @@ class SchemaRegistry
         end
 
         def write_indent(str)
-          @indent.times { write(' ') }
+          @indent.times { write(" ") }
           write(str)
         end
 
@@ -42,7 +42,7 @@ class 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 @@ class 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 @@ class 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 @@ class 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 @@ class 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 @@ class 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 @@ class 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 @@ class 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 @@ class 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,16 +1,16 @@
 # 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"
 
-class SchemaRegistry
+module SchemaRegistry
   module Schema
     class Avro < Base
-      DEFAULT_SCHEMAS_PATH = './schemas'
+      DEFAULT_SCHEMAS_PATH = "./schemas"
 
       class << self
         def schema_type
-          'AVRO'
+          "AVRO"
         end
 
         def schema_store
@@ -26,9 +26,9 @@ class 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)
@@ -48,7 +48,7 @@ class 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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class SchemaRegistry
+module SchemaRegistry
   module Schema
     class MissingImplementationError < StandardError; end
 
@@ -10,19 +10,19 @@ class 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 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]
@@ -30,7 +30,7 @@ class 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,14 +1,14 @@
 # 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"
 
-class SchemaRegistry
+module SchemaRegistry
   module Schema
     class ProtoJsonSchema < Base
       class << self
         def schema_type
-          'JSON'
+          "JSON"
         end
 
         def schema_text(message, schema_name: nil)