deimos-ruby 2.5.3 → 2.6.0.pre.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 634ebcbb254c467794eae6a3971200e2647472769eb59b6e8e89ed9453c3b203
-  data.tar.gz: a72e4063b395f3a5388bc2988b3780e8fb9a8aa9052152f7c08b1f3469fc63f3
+  metadata.gz: ba96f4ae17cd71ddcda0499103bfaedc88d2757e5e6eb6034b3cffb9e9898034
+  data.tar.gz: f707d6ae52803d9e2cdca87b03c409ba5f47bc1ceaad243fb80b8bd91a2b4dff
 SHA512:
-  metadata.gz: 1205344ccc7c9f97b5b0496e950d5a5e385654c0e1192ba8d6e1fa6f6c01fdd2a84c88f1980c587f2623717ca5eafd6562fc3fb713f3cd04b0d54d3382645385
-  data.tar.gz: 15589b978f07ce93acfda561f8e8cb75f6a9ad1be25efd77942b5c04b9404237112c9668a1b6f295c94983848fcb18916b0c32a134daa208b8d7343ef845ee5b
+  metadata.gz: 6151699039457db7eecc81f33bdae4ab921f68220ba75db0b6ce935555a112903b280f942c35cd459bb298128cc4e3f4240f26c6538bbe94b0c0924ad0bd8958
+  data.tar.gz: d1882baeffc9e69998fd704559b7c21f83e966e365c4e96b60f073412b40c2b242a8749e0e9890379cdfc88d96e2687dcf5d9293015f3e8ee15608c78c5bc3fb

data/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+- Major change: Extract Avro schema class generation out of Deimos and into `avro-gen-ruby`.
+
 ## 2.5.3 - 2026-04-28
 
 - Fix: `setup_karafka` applies the merged kafka config to `Karafka.producer`, so kafka overrides set in later `Karafka::App.setup` calls take effect on `Karafka.producer` callers (Karafka::Web, DLQ, ActiveJob).

data/README.md

@@ -840,19 +840,23 @@ DB backend only when your rake task is running.
 
 # Generated Schema Classes
 
-Deimos offers a way to generate classes from Avro schemas. These classes are documented
-with YARD to aid in IDE auto-complete, and will help to move errors closer to the code.
+Deimos generates classes from Avro schemas using the
+[avro-gen-ruby](https://github.com/flipp-oss/avro-gen-ruby) gem (namespace `AvroGen`).
+These classes are documented with YARD to aid in IDE auto-complete, and will help to move
+errors closer to the code.
 
-Add the following configurations for schema class generation: 
+Add the following configurations for schema class generation:
 
 ```ruby
-config.schema.generated_class_path 'path/to/generated/classes' # Defaults to 'app/lib/schema_classes'
+config.avrogen.generated_class_path 'path/to/generated/classes' # Defaults to 'app/lib/schema_classes'
 ```
 
 Run the following command to generate schema classes in your application. It will generate classes for every configured consumer or producer by `Deimos.configure`:
 
     bundle exec rake deimos:generate_schema_classes
 
+(The standalone `bundle exec rake avro:generate` task generates classes for every schema on disk, without the Kafka-aware key/tombstone handling.)
+
 Add the following configurations to start using generated schema classes in your application's Consumers and Producers:
 
     config.schema.use_schema_classes true
@@ -864,7 +868,14 @@ Note that if you have a schema in your repo but have not configured a producer o
 
 One additional configuration option indicates whether nested records should be generated as top-level classes or would remain nested inside the generated class for its parent schema. The default is to nest them, as a flattened structure can have one sub-schema clobber another sub-schema defined in a different top-level schema.
 
-    config.schema.nest_child_schemas = false # Flatten all classes into one directory
+    config.avrogen.nest_child_schemas = false # Flatten all classes into one directory
+
+> **Note:** The schema-class generation settings moved from `config.schema.*` to
+> `config.avrogen.*`. The old `config.schema.generated_class_path` /
+> `nest_child_schemas` / `use_full_namespace` / `schema_namespace_map` settings still
+> work but are deprecated. Generated classes now inherit from
+> `AvroGen::SchemaClass::Record`/`Enum`; previously-generated files referencing
+> `Deimos::SchemaClass::*` still load, and `bundle exec rake avro:upgrade` rewrites them.
 
 You can generate a tombstone message (with only a key and no value) by calling the `YourSchemaClass.tombstone(key)` method. If you're using a `:field` key config, you can pass in just the key scalar value. If using a key schema, you can pass it in as a hash or as another schema class.
 
@@ -877,7 +888,7 @@ Examples of consumers would look like this:
 ```ruby
 class MyConsumer < Deimos::Consumer
   def consume_message(message)
-    # Same method as before but message.payload is now an instance of Deimos::SchemaClass::Record
+    # Same method as before but message.payload is now an instance of AvroGen::SchemaClass::Record
     # rather than a hash. 
     # You can interact with the schema class instance in the following way: 
     do_something(message.payload.test_id, message.payload.some_int)
@@ -891,7 +902,7 @@ end
 class MyActiveRecordConsumer < Deimos::ActiveRecordConsumer
   record_class Widget
   # Any method that expects a message payload as a hash will instead
-  # receive an instance of Deimos::SchemaClass::Record.
+  # receive an instance of AvroGen::SchemaClass::Record.
   def record_attributes(payload, key)
     # You can interact with the schema class instance in the following way:
     super.merge(:some_field => "some_value-#{payload.test_id}")
@@ -931,9 +942,9 @@ class MyActiveRecordProducer < Deimos::ActiveRecordProducer
   record_class Widget
   # @param attributes [Hash]
   # @param _record [Widget]
-  # @return [Deimos::SchemaClass::Record]
+  # @return [AvroGen::SchemaClass::Record]
   def self.generate_payload(attributes, _record)
-    # This method converts your ActiveRecord into a Deimos::SchemaClass::Record. You will be able to use super
+    # This method converts your ActiveRecord into a AvroGen::SchemaClass::Record. You will be able to use super
     # as an instance of Schemas::MySchema and set values that are not on your ActiveRecord schema.
     res = super
     res.some_value = "some_value-#{res.test_id}"

data/deimos-ruby.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_dependency('avro-gen-ruby')
   spec.add_dependency('benchmark', '~> 0.5')
   spec.add_dependency('fig_tree', '~> 0.2.0')
   spec.add_dependency('karafka', '~> 2.0')

data/docs/CONFIGURATION.md

@@ -60,10 +60,17 @@ things you need to reference into local variables before calling `configure`.
 | schema.password             | nil                      | Basic auth password.                                                                                                                                       |
 | schema.path                 | nil                      | Local path to find your schemas.                                                                                                                           |
 | schema.use_schema_classes   | false                    | Set this to true to use generated schema classes in your application.                                                                                      |
-| schema.generated_class_path | `app/lib/schema_classes` | Local path to generated schema classes.                                                                                                                    |
-| schema.nest_child_schemas   | false                    | Set to true to nest subschemas within the generated class for the parent schema.                                                                           |
-| schema.use_full_namespace   | false                    | Set to true to generate folders for schemas matching the full namespace.                                                                                   |
-| schema.schema_namespace_map | {}                       | A map of namespace prefixes to base module name(s). Example: { 'com.mycompany.suborg' => ['SchemaClasses'] }. Requires `use_full_namespace` to be true.    |
+
+#### Schema Class Generation (`avrogen`)
+
+Schema class generation is provided by the [avro-gen-ruby](https://github.com/flipp-oss/avro-gen-ruby) gem (namespace `AvroGen`). These settings are forwarded to `AvroGen.config`. The equivalent `schema.*` settings still work but are deprecated — using one prints a warning pointing to the `avrogen.*` setting, and you can migrate generated files with `rake avro:upgrade`.
+
+| Config name                   | Default                  | Description                                                                                                                                              |
+|-------------------------------|--------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| avrogen.generated_class_path  | `app/lib/schema_classes` | Local path to generated schema classes. (was `schema.generated_class_path`)                                                                              |
+| avrogen.nest_child_schemas    | true                     | Set to true to nest subschemas within the generated class for the parent schema. (was `schema.nest_child_schemas`)                                       |
+| avrogen.use_full_namespace    | false                    | Set to true to generate folders for schemas matching the full namespace. (was `schema.use_full_namespace`)                                               |
+| avrogen.schema_namespace_map  | {}                       | A map of namespace prefixes to base module name(s). Example: { 'com.mycompany.suborg' => ['SchemaClasses'] }. Requires `use_full_namespace` to be true. (was `schema.schema_namespace_map`) |
 
 ### Outbox Configuration
 

data/lib/deimos/active_record_consume/batch_consumption.rb

@@ -76,7 +76,7 @@ module Deimos
       def record_key(key)
         if key.nil?
           {}
-        elsif key.is_a?(Hash) || key.is_a?(SchemaClass::Record)
+        elsif key.is_a?(Hash) || key.is_a?(AvroGen::SchemaClass::Record)
           self.key_converter.convert(key)
         elsif self.topic.key_config[:field].nil?
           { @klass.primary_key => key }

data/lib/deimos/active_record_consume/message_consumption.rb

@@ -13,7 +13,7 @@ module Deimos
       # Default is to use the primary key column and the value of the first
       # field in the key.
       # @param klass [Class<ActiveRecord::Base>]
-      # @param _payload [Hash,Deimos::SchemaClass::Record]
+      # @param _payload [Hash,AvroGen::SchemaClass::Record]
       # @param key [Object]
       # @return [ActiveRecord::Base]
       def fetch_record(klass, _payload, key)
@@ -23,7 +23,7 @@ module Deimos
 
       # Assign a key to a new record.
       # @param record [ActiveRecord::Base]
-      # @param _payload [Hash,Deimos::SchemaClass::Record]
+      # @param _payload [Hash,AvroGen::SchemaClass::Record]
       # @param key [Object]
       # @return [void]
       def assign_key(record, _payload, key)

data/lib/deimos/active_record_consumer.rb

@@ -90,7 +90,7 @@ module Deimos
 
     # Override this method (with `super`) if you want to add/change the default
     # attributes set to the new/existing record.
-    # @param payload [Hash,Deimos::SchemaClass::Record]
+    # @param payload [Hash,AvroGen::SchemaClass::Record]
     # @param _key [String]
     # @return [Hash]
     def record_attributes(payload, _key=nil)

data/lib/deimos/active_record_producer.rb

@@ -81,7 +81,7 @@ module Deimos
         return payload if self.karafka_config.use_schema_classes.nil? &&
                           !Deimos.config.schema.use_schema_classes
 
-        Utils::SchemaClass.instance(payload, encoder.schema, encoder.namespace)
+        AvroGen::SchemaClass.instance(payload, encoder.schema, encoder.namespace)
       end
 
       # Deletion payload for a record by default, delegate to the

data/lib/deimos/config/configuration.rb

@@ -15,6 +15,7 @@ module Deimos
       config.deserializers[:payload].try(:reset_backend)
       config.deserializers[:key].try(:reset_backend)
     end
+    Deimos::SchemaClass.sync_config!
     if self.config.schema.use_schema_classes
       load_generated_schema_classes
     end
@@ -42,16 +43,16 @@ module Deimos
     # Loads generated classes
     # @return [void]
     def load_generated_schema_classes
-      if Deimos.config.schema.generated_class_path.nil?
-        raise 'Cannot use schema classes without schema.generated_class_path. ' \
-              'Please provide a directory.'
+      path = AvroGen.config.generated_class_path
+      if path.nil?
+        raise 'Cannot use schema classes without a generated class path. ' \
+              'Please set AvroGen.config.generated_class_path.'
       end
 
-      Dir["./#{Deimos.config.schema.generated_class_path}/**/*.rb"].
+      Dir["./#{path}/**/*.rb"].
         each { |f| require f }
     rescue LoadError
-      raise 'Cannot load schema classes. Please regenerate classes with' \
-            'rake deimos:generate_schema_models.'
+      raise 'Cannot load schema classes. Please regenerate classes with rake avro:generate.'
     end
 
     # Ensure everything is set up correctly for the DB backend.
@@ -173,7 +174,7 @@ module Deimos
       # @return [String]
       setting :path
 
-      # Local path for schema classes to be generated in.
+      # @deprecated Use config.avrogen.generated_class_path instead.
       # @return [String]
       setting :generated_class_path, 'app/lib/schema_classes'
 
@@ -181,6 +182,31 @@ module Deimos
       # @return [Boolean]
       setting :use_schema_classes
 
+      # @deprecated Use config.avrogen.nest_child_schemas instead.
+      # @return [Boolean]
+      setting :nest_child_schemas, true
+
+      # @deprecated Use config.avrogen.use_full_namespace instead.
+      # @return [Boolean]
+      setting :use_full_namespace, false
+
+      # @deprecated Use config.avrogen.schema_namespace_map instead.
+      # @return [Hash]
+      setting :schema_namespace_map, {}
+
+      # The base directory for generated protobuf key schemas.
+      setting :proto_schema_key_path, 'protos'
+    end
+
+    # Schema class generation settings, forwarded to the avro-gen-ruby gem
+    # (AvroGen.config). These previously lived under `schema` (still supported,
+    # but deprecated).
+    setting :avrogen do
+
+      # Local path for schema classes to be generated in.
+      # @return [String]
+      setting :generated_class_path, 'app/lib/schema_classes'
+
       # Set to false to generate child schemas as their own files.
       # @return [Boolean]
       setting :nest_child_schemas, true
@@ -191,12 +217,9 @@ module Deimos
 
       # Use this option to reduce nesting when using use_full_namespace.
       # For example: { 'com.mycompany.suborg' => 'SchemaClasses' }
-      # would replace a prefixed with the given key with the module name SchemaClasses.
+      # would replace a prefix matching the given key with the module name SchemaClasses.
       # @return [Hash]
       setting :schema_namespace_map, {}
-
-      # The base directory for generated protobuf key schemas.
-      setting :proto_schema_key_path, 'protos'
     end
 
     # The configured metrics provider.

data/lib/deimos/ext/producer_middleware.rb

@@ -5,7 +5,7 @@ module Deimos
     class << self
 
       def allowed_classes
-        arr = [Hash, SchemaClass::Record]
+        arr = [Hash, AvroGen::SchemaClass::Record]
         if defined?(Google::Protobuf)
           arr.push(Google::Protobuf.const_get(:AbstractMessage))
         end
@@ -26,7 +26,7 @@ module Deimos
                     self.allowed_classes.none? { |k| message[:payload].is_a?(k) }
 
           payload = message[:payload]
-          payload = payload.to_h if payload.nil? || payload.is_a?(SchemaClass::Record)
+          payload = payload.to_h if payload.nil? || payload.is_a?(AvroGen::SchemaClass::Record)
           m = Deimos::Message.new(payload,
                                   headers: message[:headers],
                                   partition_key: message[:partition_key])

data/lib/deimos/logging.rb

@@ -30,6 +30,15 @@ module Deimos
         log_add(:warn, *args)
       end
 
+      # Emit a deprecation warning at most once per unique message.
+      # @param msg [String]
+      def deprecate(msg)
+        @deprecations ||= Set.new
+        return unless @deprecations.add?(msg)
+
+        warn("DEPRECATION WARNING: #{msg}")
+      end
+
       def metadata_log_text(metadata)
         metadata.to_h.slice(:timestamp, :offset, :first_offset, :last_offset, :partition, :topic, :size)
       end

data/lib/deimos/producer.rb

@@ -75,7 +75,7 @@ module Deimos
       end
 
       # Publish the payload to the topic.
-      # @param payload [Hash, SchemaClass::Record] with an optional payload_key hash key.
+      # @param payload [Hash, AvroGen::SchemaClass::Record] with an optional payload_key hash key.
       # @param topic [String] if specifying the topic
       # @param headers [Hash] if specifying headers
       # @return [void]
@@ -99,7 +99,7 @@ module Deimos
       end
 
       # Publish a list of messages.
-      # @param payloads [Array<Hash, SchemaClass::Record>] with optional payload_key hash key.
+      # @param payloads [Array<Hash, AvroGen::SchemaClass::Record>] with optional payload_key hash key.
       # @param sync [Boolean] if given, override the default setting of
       # whether to publish synchronously.
       # @param force_send [Boolean] if true, ignore the configured backend
@@ -112,7 +112,7 @@ module Deimos
 
         messages = Array(payloads).map do |p|
           payload = p
-          payload = payload.to_h if p.is_a?(SchemaClass::Record)
+          payload = payload.to_h if p.is_a?(AvroGen::SchemaClass::Record)
           m = {
             payload: payload,
             headers: headers,
@@ -121,10 +121,10 @@ module Deimos
           }
           if payload.is_a?(Hash) && payload.key?(:key) && payload.key?(:message)
             m[:key] = payload[:key]
-            m[:key] = m[:key].to_h if m[:key].nil? || m[:key].is_a?(SchemaClass::Record)
+            m[:key] = m[:key].to_h if m[:key].nil? || m[:key].is_a?(AvroGen::SchemaClass::Record)
             m[:payload] = payload[:message]
             m[:payload] = m[:payload].to_h if m[:payload].nil? ||
-                                              m[:payload].is_a?(SchemaClass::Record)
+                                              m[:payload].is_a?(AvroGen::SchemaClass::Record)
           end
           m
         end

data/lib/deimos/schema_backends/avro_base.rb

@@ -2,6 +2,7 @@
 
 require_relative 'base'
 require 'schema_registry_client'
+require 'avro_gen/avro_parser'
 require_relative 'avro_schema_coercer'
 
 module Deimos
@@ -106,55 +107,25 @@ module Deimos
 
       # @param schema [Avro::Schema::NamedSchema] A named schema
       # @return [String]
+      # @deprecated Use AvroGen::AvroParser.schema_classname instead.
       def self.schema_classname(schema)
-        schema.name.underscore.camelize.singularize
+        AvroGen::AvroParser.schema_classname(schema)
       end
 
       # Converts Avro::Schema::NamedSchema's to String form for generated YARD docs.
-      # Recursively handles the typing for Arrays, Maps and Unions.
       # @param avro_schema [Avro::Schema::NamedSchema]
       # @return [String] A string representation of the Type of this SchemaField
+      # @deprecated Use AvroGen::AvroParser.field_type instead.
       def self.field_type(avro_schema)
-        case avro_schema.type_sym
-        when :string, :boolean
-          avro_schema.type_sym.to_s.titleize
-        when :int, :long
-          'Integer'
-        when :float, :double
-          'Float'
-        when :record, :enum
-          schema_classname(avro_schema)
-        when :array
-          arr_t = field_type(Deimos::SchemaField.new('n/a', avro_schema.items).type)
-          "Array<#{arr_t}>"
-        when :map
-          map_t = field_type(Deimos::SchemaField.new('n/a', avro_schema.values).type)
-          "Hash<String, #{map_t}>"
-        when :union
-          types = avro_schema.schemas.map do |t|
-            field_type(Deimos::SchemaField.new('n/a', t).type)
-          end
-          types.join(', ')
-        when :null
-          'nil'
-        end
+        AvroGen::AvroParser.field_type(avro_schema)
       end
 
       # Returns the base type of this schema. Decodes Arrays, Maps and Unions
       # @param schema [Avro::Schema::NamedSchema]
       # @return [Avro::Schema::NamedSchema]
+      # @deprecated Use AvroGen::AvroParser.schema_base_class instead.
       def self.schema_base_class(schema)
-        case schema.type_sym
-        when :array
-          schema_base_class(schema.items)
-        when :map
-          schema_base_class(schema.values)
-        when :union
-          schema.schemas.map(&method(:schema_base_class)).
-            reject { |s| s.type_sym == :null }.first
-        else
-          schema
-        end
+        AvroGen::AvroParser.schema_base_class(schema)
       end
 
       def generate_key_schema(field_name)

data/lib/deimos/schema_class.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'avro_gen'
+
+module Deimos
+  # Backwards-compatible shim. Schema class generation moved to the avro-gen-ruby
+  # gem (namespace AvroGen). Previously-generated classes that reference
+  # `Deimos::SchemaClass::Record` / `Enum` / `Base` still resolve here, with a
+  # one-time deprecation warning, via const_missing.
+  module SchemaClass
+    DEPRECATED_CONSTANTS = {
+      Base: AvroGen::SchemaClass::Base,
+      Record: AvroGen::SchemaClass::Record,
+      Enum: AvroGen::SchemaClass::Enum
+    }.freeze
+
+    # The generation settings that live under Deimos.config.avrogen and are
+    # forwarded to AvroGen.config (same names on both sides).
+    GENERATION_SETTINGS = %i(
+      generated_class_path
+      nest_child_schemas
+      use_full_namespace
+      schema_namespace_map
+    ).freeze
+
+    # @param name [Symbol]
+    def self.const_missing(name)
+      klass = DEPRECATED_CONSTANTS[name]
+      return super unless klass
+
+      Deimos::Logging.deprecate(
+        "Deimos::SchemaClass::#{name} is deprecated; use AvroGen::SchemaClass::#{name} instead. " \
+        'Run `rake avro:upgrade` to update generated classes.'
+      )
+      # Define the constant so the warning is only emitted once.
+      const_set(name, klass)
+      klass
+    end
+
+    # Mirror the Deimos generation settings onto AvroGen.config. Deimos.config is
+    # the source of truth within Deimos, so this runs on every configure (keeping
+    # a reset in sync). The settings live under Deimos.config.avrogen; the legacy
+    # Deimos.config.schema.* equivalents still work but emit a deprecation warning.
+    # Standalone AvroGen users never trigger this and set AvroGen.config directly.
+    # @!visibility private
+    def self.sync_config!
+      # schema.path is shared with the Avro backends, so it stays under `schema`.
+      AvroGen.config.schema_path = Deimos.config.schema.path
+      # Refresh AvroGen's cached schema stores on (re)configuration so they don't
+      # serve stale schemas after the schema path or files change.
+      AvroGen::SchemaValidator.clear_store_cache!
+
+      GENERATION_SETTINGS.each do |key|
+        AvroGen.config.send("#{key}=", generation_setting(key))
+      end
+    end
+
+    # Resolve a generation setting, preferring the legacy (deprecated)
+    # Deimos.config.schema.* location when it was explicitly set.
+    # @!visibility private
+    def self.generation_setting(key)
+      if Deimos.config.schema.default_value?(key)
+        Deimos.config.avrogen.send(key)
+      else
+        Deimos::Logging.deprecate(
+          "Deimos.config.schema.#{key} is deprecated; use Deimos.config.avrogen.#{key} instead."
+        )
+        Deimos.config.schema.send(key)
+      end
+    end
+  end
+end

data/lib/deimos/transcoder.rb

@@ -58,9 +58,9 @@ module Deimos
 
       schema_key = decoded_key.is_a?(Hash) ? decoded_key : { self.key_field => decoded_key }
 
-      Utils::SchemaClass.instance(schema_key,
-                                  "#{@schema}_key",
-                                  @namespace)
+      AvroGen::SchemaClass.instance(schema_key,
+                                    "#{@schema}_key",
+                                    @namespace)
     end
 
     # @param payload [String]
@@ -71,9 +71,9 @@ module Deimos
       decoded_payload = self.backend.decode(payload)
       return decoded_payload if !@use_schema_classes || !decoded_payload.is_a?(Hash)
 
-      Utils::SchemaClass.instance(decoded_payload,
-                                  @schema,
-                                  @namespace)
+      AvroGen::SchemaClass.instance(decoded_payload,
+                                    @schema,
+                                    @namespace)
     end
 
     # @param payload [Object]

data/lib/deimos/utils/schema_class.rb

@@ -1,60 +1,27 @@
 # frozen_string_literal: true
 
+require 'avro_gen'
+
 module Deimos
   module Utils
-    # Class used by SchemaClassGenerator and Consumer/Producer interfaces
+    # Backwards-compatible shim. The schema class helpers moved to
+    # AvroGen::SchemaClass. This delegates with a deprecation warning.
     module SchemaClass
       class << self
-
-        # @param namespace [String]
-        # @return [Array<String>]
-        def modules_for(namespace)
-          modules = ['Schemas']
-          namespace_override = nil
-          module_namespace = namespace
-
-          if Deimos.config.schema.use_full_namespace
-            if Deimos.config.schema.schema_namespace_map.present?
-              namespace_keys = Deimos.config.schema.schema_namespace_map.keys.sort_by { |k| -k.length }
-              namespace_override = namespace_keys.find { |k| module_namespace.include?(k) }
-            end
-
-            if namespace_override.present?
-              # override default module
-              modules = Array(Deimos.config.schema.schema_namespace_map[namespace_override])
-              module_namespace = module_namespace.gsub(/#{namespace_override}\.?/, '')
-            end
-
-            namespace_folders = module_namespace.split('.').map { |f| f.underscore.camelize }
-            modules.concat(namespace_folders) if namespace_folders.any?
+        def method_missing(name, ...)
+          if AvroGen::SchemaClass.respond_to?(name)
+            Deimos::Logging.deprecate(
+              "Deimos::Utils::SchemaClass.#{name} is deprecated; use AvroGen::SchemaClass.#{name} instead."
+            )
+            AvroGen::SchemaClass.send(name, ...)
+          else
+            super
           end
-
-          modules
         end
 
-        # Converts a raw payload into an instance of the Schema Class
-        # @param payload [Hash, Deimos::SchemaClass::Base]
-        # @param schema [String]
-        # @param namespace [String]
-        # @return [Deimos::SchemaClass::Record]
-        def instance(payload, schema, namespace='')
-          return payload if payload.is_a?(Deimos::SchemaClass::Base)
-
-          klass = klass(schema, namespace)
-          return payload if klass.nil? || payload.nil?
-
-          klass.new_from_message(**payload.symbolize_keys)
+        def respond_to_missing?(name, include_private=false)
+          AvroGen::SchemaClass.respond_to?(name, include_private) || super
         end
-
-        # Determine and return the SchemaClass with the provided schema and namespace
-        # @param schema [String]
-        # @param namespace [String]
-        # @return [Deimos::SchemaClass]
-        def klass(schema, namespace)
-          constants = modules_for(namespace) + [schema.underscore.camelize.singularize]
-          constants.join('::').safe_constantize
-        end
-
       end
     end
   end

data/lib/deimos/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deimos
-  VERSION = '2.5.3'
+  VERSION = '2.6.0-beta1'
 end

data/lib/deimos.rb

@@ -17,9 +17,9 @@ require 'deimos/backends/kafka_async'
 require 'deimos/backends/test'
 
 require 'deimos/schema_backends/base'
+require 'avro_gen'
+require 'deimos/schema_class'
 require 'deimos/utils/schema_class'
-require 'deimos/schema_class/enum'
-require 'deimos/schema_class/record'
 
 require 'deimos/ext/schema_route'
 require 'deimos/ext/consumer_route'
@@ -102,7 +102,7 @@ module Deimos
         # Initialize an instance of the provided schema
         # in the event the schema class is an override, the inherited
         # schema and namespace will be applied
-        schema_class = Utils::SchemaClass.klass(schema, namespace)
+        schema_class = AvroGen::SchemaClass.klass(schema, namespace)
         if schema_class.nil?
           schema_backend_class(backend: backend).
             new(

data/lib/tasks/deimos.rake

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'generators/deimos/schema_class_generator'
+require 'avro_gen/generator'
 require 'optparse'
 require 'deimos/schema_backends/proto_schema_registry'
 
@@ -32,10 +32,22 @@ namespace :deimos do
     Deimos::Utils::DbPoller.start!
   end
 
-  desc 'Run Schema Model Generator'
+  desc 'Run Schema Model Generator (deprecated: use rake avro:generate)'
   task generate_schema_classes: :environment do
-    Rails.logger.info("Running deimos:generate_schema_classes")
-    Deimos::Generators::SchemaClassGenerator.start
+    Deimos::Logging.deprecate(
+      'rake deimos:generate_schema_classes is deprecated; use rake avro:generate instead.'
+    )
+    Rails.logger.info('Running deimos:generate_schema_classes')
+    # Derive AvroGen configs from the configured Kafka topics so keyed records
+    # still get their tombstone/payload_key helpers, then delegate to AvroGen.
+    configs = Deimos.karafka_configs.filter_map do |config|
+      next if config.schema.nil?
+
+      { schema: config.schema,
+        namespace: config.namespace,
+        key_config: config.key_config }
+    end
+    AvroGen::Generator.new.generate_from_configs(configs)
   end
 
   desc 'Output Protobuf key schemas'