deimos-ruby 1.11.2 → 1.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5424d471910dffc66acead04734420173b69b41dae286fac03edb60825936fe
-  data.tar.gz: fe424e2929984d971cb1f48cd88e6a1d78c83783c0b81fd8b8376571ebcf5634
+  metadata.gz: 755e18a8a926a57147e5702c32e97e4a436855be16d023e7fae55e1cc54e31cc
+  data.tar.gz: 0b13c1f56ae9a384b6beb55e792a5461dad0366c149e11efeee17687b2fc5461
 SHA512:
-  metadata.gz: 9a5f53681cc8fdc79c39c2b42ae11c40f44246ffdf7bcfaeff6dac7b5b1e0cd21de4bc4a931615c1c4c944c0516dcc663a4638ad90d8e8ddf2a4ae9669b4fadc
-  data.tar.gz: fc21c854ebebce35ab5ecf7a113ca24d7ba4c1a0a880dc225d53b3fdf99823f9a1b06a039159a1a0fe0b7acedd45eec29f3b84af09a847efb329b03eef9f46bd
+  metadata.gz: 68d6a5b47a82f32f0a4619f3d915cf63332b17e2c3f1d2f5cf257c18410a8e2628c266b72f9167fd95ce6191cfacbf13dd5fb72b3ee86b4fb6cd98b366fd2d82
+  data.tar.gz: ee4ae15d36fe70bc5fedb9118a926be60918b7108198b9b964fb1a9aa8a92b77d630957b0237ac584b2acf8cace6e454725c2016f75167c13f720d0cbe04a653

data/CHANGELOG.md

@@ -7,10 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## UNRELEASED
 
-## 1.11.2 - 2021-08-27
+# 1.12.3 - 2021-12-13
+
+- Fix bug with previous release
+
+# 1.12.2 - 2021-12-10
+
+### Features :star:
+
+- Added `Deimos.encode` and `Deimos.decode` for non-topic-related encoding and decoding.
+
+# 1.12.1 - 2021-11-02
+
+- ### Fixes :wrench:
+- Fixed issue where Schema Class Consumer/Producer are using `Deimos::` instead of `Schema::` for instances of classes.
+
+# 1.12.0 - 2021-11-01
+
+### Features :star:
+
+- Generate Schema classes from Avro Schemas
+- Use Schema Classes in your consumer and producer 
+
+## 1.11.0 - 2021-08-27
 
 - ### Fixes :wrench:
-- Fixed ActiveRecord batch consumption on MySQL.
+- Fixed issue where ActiveRecord batch consumption could fail when decoding keys.
 
 - ### Roadmap :car:
 - TestHelper does not automatically reset Deimos config before each test. [#120](https://github.com/flipp-oss/deimos/pull/120).

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    deimos-ruby (1.11.2)
+    deimos-ruby (1.12.0)
       avro_turf (~> 0.11)
       fig_tree (~> 0.0.2)
       phobos (>= 1.9, < 3.0)
@@ -88,11 +88,11 @@ GEM
     ddtrace (0.46.0)
       msgpack
     diff-lcs (1.4.4)
-    digest-crc (0.6.3)
+    digest-crc (0.6.4)
       rake (>= 12.0.0, < 14.0.0)
     dogstatsd-ruby (4.8.3)
     erubi (1.10.0)
-    excon (0.81.0)
+    excon (0.85.0)
     exponential-backoff (0.0.4)
     ffi (1.15.0)
     fig_tree (0.0.2)
@@ -153,10 +153,10 @@ GEM
       nenv (~> 0.1)
       shellany (~> 0.0)
     parallel (1.20.1)
-    parser (3.0.0.0)
+    parser (3.0.1.1)
       ast (~> 2.4.1)
     pg (1.2.3)
-    phobos (2.0.2)
+    phobos (2.1.0)
       activesupport (>= 3.0.0)
       concurrent-ruby (>= 1.0.2)
       concurrent-ruby-ext (>= 1.0.2)
@@ -227,7 +227,7 @@ GEM
     rspec-support (3.10.2)
     rspec_junit_formatter (0.4.1)
       rspec-core (>= 2, < 4, != 2.12.0)
-    rubocop (0.88.0)
+    rubocop (0.89.0)
       parallel (~> 1.10)
       parser (>= 2.7.1.1)
       rainbow (>= 2.2.2, < 4.0)
@@ -240,7 +240,7 @@ GEM
       parser (>= 2.7.1.5)
     rubocop-rspec (1.42.0)
       rubocop (>= 0.87.0)
-    ruby-kafka (1.3.0)
+    ruby-kafka (1.4.0)
       digest-crc
     ruby-progressbar (1.11.0)
     shellany (0.0.1)
@@ -284,7 +284,7 @@ DEPENDENCIES
   rspec (~> 3)
   rspec-rails (~> 4)
   rspec_junit_formatter (~> 0.3)
-  rubocop (= 0.88.0)
+  rubocop (= 0.89.0)
   rubocop-rspec (= 1.42.0)
   sqlite3 (~> 1.3)
 

data/README.md

@@ -27,6 +27,7 @@ Built on Phobos and hence Ruby-Kafka.
    * [Database Backend](#database-backend)
    * [Database Poller](#database-poller)
    * [Running Consumers](#running-consumers)
+   * [Generated Schema Classes](#generated-schema-classes)
    * [Metrics](#metrics)
    * [Testing](#testing)
         * [Test Helpers](#test-helpers)
@@ -795,6 +796,101 @@ which can be useful if you want to figure out if you're inside the task
 as opposed to running your Rails server or console. E.g. you could start your 
 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.
+
+Add the following configurations for schema class generation: 
+
+```ruby
+config.schema.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
+
+Add the following configurations to start using generated schema classes in your application's Consumers and Producers:
+
+    config.schema.use_schema_classes true
+
+Additionally, you can enable or disable the usage of schema classes for a particular consumer or producer with the
+`use_schema_classes` config. See [Configuration](./docs/CONFIGURATION.md#defining-producers).
+
+### Consumer
+
+The consumer interface uses the `decode_message` method to turn JSON hash into the Schemas
+generated Class and provides it to the `consume`/`consume_batch` methods for their use.
+
+Examples of consumers would look like this:
+```ruby
+class MyConsumer < Deimos::Consumer
+  def consume(payload, metadata)
+    # Same method as Phobos consumers but payload is now an instance of Deimos::SchemaClass::Record
+    # rather than a hash. metadata is still a hash that contains information like :key and :topic.
+    # You can interact with the schema class instance in the following way: 
+    do_something(payload.test_id, payload.some_int)
+    # The original behaviour was as follows:
+    do_something(payload[:test_id], payload[:some_int])
+  end
+end
+```
+
+```ruby
+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.
+  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}")
+    # The original behaviour was as follows:
+    super.merge(:some_field => "some_value-#{payload[:test_id]}")
+  end
+end
+```
+
+### Producer
+Similarly to the consumer interface, the producer interface for using Schema Classes in your app
+relies on the `publish`/`publish_list` methods to convert a _provided_ instance of a Schema Class
+into a hash that can be used freely by the Kafka client.
+
+Examples of producers would look like this:
+```ruby
+class MyProducer < Deimos::Producer
+  class << self 
+    # @param test_id [String]
+    # @param some_int [Integer]
+    def self.send_a_message(test_id, some_int)
+      # Instead of sending in a Hash object to the publish or publish_list method,      
+      # you can initialize an instance of your schema class and send that in.
+      message = Schemas::MySchema.new(
+        test_id: test_id,
+        some_int: some_int
+      )
+      self.publish(message)
+      self.publish_list([message])
+    end
+  end
+end
+```
+
+```ruby
+class MyActiveRecordProducer < Deimos::ActiveRecordProducer
+  record_class Widget
+  # @param payload [Deimos::SchemaClass::Record]
+  # @param _record [Widget]
+  def self.generate_payload(attributes, _record)
+    # This method converts your ActiveRecord into a Deimos::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}"
+    res
+  end
+end
+```
+
 # Metrics
 
 Deimos includes some metrics reporting out the box. It ships with DataDog support, but you can add custom metric providers as well.
@@ -1068,6 +1164,13 @@ backend.validate(my_payload) # throws an error if not valid
 fields = backend.schema_fields # list of fields defined in the schema
 ```
 
+You can also do an even faster encode/decode:
+
+```ruby
+encoded = Deimos.encode(schema: 'MySchema', namespace: 'com.my-namespace', payload: my_payload)
+decoded = Deimos.decode(schema: 'MySchema', namespace: 'com.my-namespace', payload: my_encoded_payload)
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/flipp-oss/deimos .

data/deimos-ruby.gemspec

@@ -39,7 +39,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency('rspec', '~> 3')
   spec.add_development_dependency('rspec_junit_formatter', '~>0.3')
   spec.add_development_dependency('rspec-rails', '~> 4')
-  spec.add_development_dependency('rubocop', '0.88.0')
+  spec.add_development_dependency('rubocop', '0.89.0')
   spec.add_development_dependency('rubocop-rspec', '1.42.0')
   spec.add_development_dependency('sqlite3', '~> 1.3')
 end

data/docs/CONFIGURATION.md

@@ -44,6 +44,7 @@ topic|nil|Topic to produce to.
 schema|nil|Name of the schema to use to encode data before producing.
 namespace|nil|Namespace of the schema to use when finding it locally.
 key_config|nil|Configuration hash for message keys. See [Kafka Message Keys](../README.md#installation)
+use_schema_classes|nil|Set to true or false to enable or disable using the producers schema classes. See [Generated Schema Classes](../README.md#generated-schema-classes)
 
 ## Defining Consumers
 
@@ -81,6 +82,7 @@ namespace|nil|Namespace of the schema to use when finding it locally.
 key_config|nil|Configuration hash for message keys. See [Kafka Message Keys](../README.md#installation)
 disabled|false|Set to true to skip starting an actual listener for this consumer on startup.
 group_id|nil|ID of the consumer group.
+use_schema_classes|nil|Set to true or false to enable or disable using the consumers schema classes. See [Generated Schema Classes](../README.md#generated-schema-classes)
 max_concurrency|1|Number of threads created for this listener. Each thread will behave as an independent consumer. They don't share any state.
 start_from_beginning|true|Once the consumer group has checkpointed its progress in the topic's partitions, the consumers will always start from the checkpointed offsets, regardless of config. As such, this setting only applies when the consumer initially starts consuming from a topic
 max_bytes_per_partition|512.kilobytes|Maximum amount of data fetched from a single partition at a time.
@@ -176,6 +178,8 @@ Config name|Default|Description
 schema.backend|`:mock`|Backend representing the schema encoder/decoder. You can see a full list [here](../lib/deimos/schema_backends).
 schema.registry_url|`http://localhost:8081`|URL of the Confluent schema registry.
 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_schema_path|`app/lib/schema_classes`|Local path to generated schema classes.
 
 ## Database Producer Configuration
 

data/lib/deimos/active_record_consume/batch_consumption.rb

@@ -15,7 +15,7 @@ module Deimos
       # If two messages in a batch have the same key, we cannot process them
       # in the same operation as they would interfere with each other. Thus
       # they are split
-      # @param payloads [Array<Hash>] Decoded payloads.
+      # @param payloads [Array<Hash|Deimos::SchemaClass::Record>] Decoded payloads
       # @param metadata [Hash] Information about batch, including keys.
       def consume_batch(payloads, metadata)
         messages = payloads.
@@ -44,12 +44,14 @@ module Deimos
       # @param key [String] The encoded key.
       # @return [Hash] The key attributes.
       def record_key(key)
-        if key.nil?
+        decoded_key = decode_key(key)
+
+        if decoded_key.nil?
           {}
-        elsif key.is_a?(Hash)
-          @key_converter.convert(key)
+        elsif decoded_key.is_a?(Hash)
+          @key_converter.convert(decoded_key)
         else
-          { @klass.primary_key => key }
+          { @klass.primary_key => decoded_key }
         end
       end
 
@@ -100,10 +102,6 @@ module Deimos
 
         options = if key_cols.empty?
                     {} # Can't upsert with no key, just do regular insert
-                  elsif ActiveRecord::Base.connection.adapter_name =~ /mysql/i
-                    {
-                      on_duplicate_key_update: :all
-                    }
                   else
                     {
                       on_duplicate_key_update: {

data/lib/deimos/active_record_consume/message_consumption.rb

@@ -9,7 +9,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]
+      # @param _payload [Hash|Deimos::SchemaClass::Record]
       # @param key [Object]
       # @return [ActiveRecord::Base]
       def fetch_record(klass, _payload, key)
@@ -18,13 +18,14 @@ module Deimos
 
       # Assign a key to a new record.
       # @param record [ActiveRecord::Base]
-      # @param _payload [Hash]
+      # @param _payload [Hash|Deimos::SchemaClass::Record]
       # @param key [Object]
       def assign_key(record, _payload, key)
         record[record.class.primary_key] = key
       end
 
-      # :nodoc:
+      # @param payload [Hash|Deimos::SchemaClass::Record] Decoded payloads
+      # @param metadata [Hash] Information about batch, including keys.
       def consume(payload, metadata)
         unless self.process_message?(payload)
           Deimos.config.logger.debug(

data/lib/deimos/active_record_consumer.rb

@@ -50,14 +50,14 @@ 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]
+    # @param payload [Hash|Deimos::SchemaClass::Record]
     # @param _key [String]
     def record_attributes(payload, _key=nil)
       @converter.convert(payload)
     end
 
     # Override this message to conditionally save records
-    # @param payload [Hash] The kafka message as a hash
+    # @param _payload [Hash|Deimos::SchemaClass::Record] The kafka message
     # @return [Boolean] if true, record is created/update.
     #   If false, record processing is skipped but message offset is still committed.
     def process_message?(_payload)

data/lib/deimos/active_record_producer.rb

@@ -58,6 +58,9 @@ module Deimos
         payload.delete_if do |k, _|
           k.to_sym != :payload_key && !fields.map(&:name).include?(k)
         end
+        return payload unless Utils::SchemaClass.use?(config.to_h)
+
+        Utils::SchemaClass.instance(payload, config[:schema])
       end
 
       # Query to use when polling the database with the DbPoller. Add

data/lib/deimos/config/configuration.rb

@@ -18,6 +18,9 @@ module Deimos
   # :nodoc:
   after_configure do
     Phobos.configure(self.config.phobos_config)
+    if self.config.schema.use_schema_classes
+      load_generated_schema_classes
+    end
     self.config.producer_objects.each do |producer|
       configure_producer_or_consumer(producer)
     end
@@ -28,6 +31,17 @@ module Deimos
     validate_db_backend if self.config.producers.backend == :db
   end
 
+  # Loads generated classes
+  def self.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.'
+    end
+
+    Dir["./#{Deimos.config.schema.generated_class_path}/**/*.rb"].sort.each { |f| require f }
+  rescue LoadError
+    raise 'Cannot load schema classes. Please regenerate classes with rake deimos:generate_schema_models.'
+  end
+
   # Ensure everything is set up correctly for the DB backend.
   def self.validate_db_backend
     begin
@@ -68,6 +82,7 @@ module Deimos
       schema(kafka_config.schema) if kafka_config.schema.present?
       namespace(kafka_config.namespace) if kafka_config.namespace.present?
       key_config(**kafka_config.key_config) if kafka_config.key_config.present?
+      schema_class_config(kafka_config.use_schema_classes) if kafka_config.use_schema_classes.present?
     end
   end
 
@@ -260,6 +275,14 @@ module Deimos
       # Local path to look for schemas in.
       # @return [String]
       setting :path
+
+      # Local path for schema classes to be generated in.
+      # @return [String]
+      setting :generated_class_path, 'app/lib/schema_classes'
+
+      # Set to true to use the generated schema classes in your application
+      # @return [Boolean]
+      setting :use_schema_classes, false
     end
 
     # The configured metrics provider.
@@ -301,6 +324,9 @@ module Deimos
       # Key configuration (see docs).
       # @return [Hash]
       setting :key_config
+      # Configure the usage of generated schema classes for this producer
+      # @return [Boolean]
+      setting :use_schema_classes
     end
 
     setting_object :consumer do
@@ -323,6 +349,9 @@ module Deimos
       # listener.
       # @return [Boolean]
       setting :disabled, false
+      # Configure the usage of generated schema classes for this consumer
+      # @return [Boolean]
+      setting :use_schema_classes
 
       # These are the phobos "listener" configs. See CONFIGURATION.md for more
       # info.

data/lib/deimos/consume/batch_consumption.rb

@@ -21,11 +21,11 @@ module Deimos
           metadata[:first_offset] = batch.first&.offset
 
           payloads = batch.map do |message|
-            message.payload ? self.class.decoder.decode(message.payload) : nil
+            decode_message(message.payload)
           end
           _received_batch(payloads, metadata)
           _with_span do
-            yield payloads, metadata
+            yield(payloads, metadata)
           end
         end
         _handle_batch_success(benchmark.real, payloads, metadata)

data/lib/deimos/consume/message_consumption.rb

@@ -15,9 +15,9 @@ module Deimos
         benchmark = Benchmark.measure do
           _with_span do
             new_metadata[:key] = decode_key(metadata[:key]) if self.class.config[:key_configured]
-            decoded_payload = payload ? self.class.decoder.decode(payload) : nil
+            decoded_payload = decode_message(payload)
             _received_message(decoded_payload, new_metadata)
-            yield decoded_payload, new_metadata
+            yield(decoded_payload, new_metadata)
           end
         end
         _handle_success(benchmark.real, decoded_payload, new_metadata)

data/lib/deimos/consumer.rb

@@ -51,6 +51,16 @@ module Deimos
       end
     end
 
+    # Helper method to decode an encoded message.
+    # @param payload [Object]
+    # @return [Object] the decoded message.
+    def decode_message(payload)
+      decoded_payload = payload.nil? ? nil : self.class.decoder.decode(payload)
+      return decoded_payload unless Utils::SchemaClass.use?(self.class.config.to_h)
+
+      Utils::SchemaClass.instance(decoded_payload, self.class.config[:schema])
+    end
+
   private
 
     def _with_span

data/lib/deimos/producer.rb

@@ -57,6 +57,7 @@ module Deimos
     MAX_BATCH_SIZE = 500
 
     class << self
+
       # @return [Hash]
       def config
         @config ||= {
@@ -86,14 +87,14 @@ module Deimos
       end
 
       # Publish the payload to the topic.
-      # @param payload [Hash] with an optional payload_key hash key.
+      # @param payload [Hash|SchemaClass::Record] with an optional payload_key hash key.
       # @param topic [String] if specifying the topic
       def publish(payload, topic: self.topic)
         publish_list([payload], topic: topic)
       end
 
       # Publish a list of messages.
-      # @param payloads [Hash|Array<Hash>] with optional payload_key hash key.
+      # @param payloads [Array<Hash|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
@@ -113,7 +114,7 @@ module Deimos
           topic: topic,
           payloads: payloads
         ) do
-          messages = Array(payloads).map { |p| Deimos::Message.new(p, self) }
+          messages = Array(payloads).map { |p| Deimos::Message.new(p.to_h, self) }
           messages.each { |m| _process_message(m, topic) }
           messages.in_groups_of(MAX_BATCH_SIZE, false) do |batch|
             self.produce_batch(backend_class, batch)

data/lib/deimos/schema_backends/avro_base.rb

@@ -66,7 +66,7 @@ module Deimos
       def schema_fields
         avro_schema.fields.map do |field|
           enum_values = field.type.type == 'enum' ? field.type.symbols : []
-          SchemaField.new(field.name, field.type, enum_values)
+          SchemaField.new(field.name, field.type, enum_values, field.default)
         end
       end
 
@@ -77,6 +77,12 @@ module Deimos
                                         fail_on_extra_fields: true)
       end
 
+      # @override
+      # @return [Avro::Schema]
+      def load_schema
+        avro_schema
+      end
+
       # @override
       def self.mock_backend
         :avro_validation
@@ -87,6 +93,59 @@ module Deimos
         'avro/binary'
       end
 
+      # @param schema [Avro::Schema::NamedSchema] A named schema
+      # @return [String]
+      def self.schema_classname(schema)
+        schema.name.underscore.camelize
+      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
+      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
+      end
+
+      # Returns the base type of this schema. Decodes Arrays, Maps and Unions
+      # @param schema [Avro::Schema::NamedSchema]
+      # @return [Avro::Schema::NamedSchema]
+      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
+      end
+
     private
 
       # @param schema [String]
@@ -135,6 +194,10 @@ module Deimos
       def _key_schema_name(schema)
         "#{schema}_key"
       end
+
+      def _schema_name
+        avro_schema.name
+      end
     end
   end
 end

data/lib/deimos/schema_backends/avro_schema_registry.rb

@@ -10,7 +10,7 @@ module Deimos
     class AvroSchemaRegistry < AvroBase
       # @override
       def decode_payload(payload, schema:)
-        avro_turf_messaging.decode(payload, schema_name: schema)
+        avro_turf_messaging.decode(payload.to_s, schema_name: schema)
       end
 
       # @override

data/lib/deimos/schema_backends/base.rb

@@ -3,15 +3,16 @@
 module Deimos
   # Represents a field in the schema.
   class SchemaField
-    attr_accessor :name, :type, :enum_values
+    attr_accessor :name, :type, :enum_values, :default
 
     # @param name [String]
     # @param type [Object]
     # @param enum_values [Array<String>]
-    def initialize(name, type, enum_values=[])
+    def initialize(name, type, enum_values=[], default=:no_default)
       @name = name
       @type = type
       @enum_values = enum_values
+      @default = default
     end
   end
 
@@ -43,6 +44,7 @@ module Deimos
       # @return [Hash,nil]
       def decode(payload, schema: nil)
         return nil if payload.nil?
+
         decode_payload(payload, schema: schema || @schema)
       end
 
@@ -78,6 +80,14 @@ module Deimos
         raise NotImplementedError
       end
 
+      # Converts your schema to String form for generated YARD docs.
+      # To be defined by subclass.
+      # @param schema [Object]
+      # @return [String] A string representation of the Type
+      def self.field_type(schema)
+        raise NotImplementedError
+      end
+
       # Encode a payload. To be defined by subclass.
       # @param payload [Hash]
       # @param schema [Symbol|String]
@@ -145,6 +155,12 @@ module Deimos
       def decode_key(_payload, _key_id)
         raise NotImplementedError
       end
+
+      # Forcefully loads the schema into memory.
+      # @return [Object] The schema that is of use.
+      def load_schema
+        raise NotImplementedError
+      end
     end
   end
 end