jsonapi-deserializable 0.1.1.beta2 → 0.1.1.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93ceb39a5f3d032a99748170ac818e096e691d05
-  data.tar.gz: adfdd698f25de948e225c87087f850376d900f09
+  metadata.gz: f3004871b4ea0f17caaeab2c1f000c632337c486
+  data.tar.gz: 4eb06414674e45c45fc3d276ffa966bc97313ae7
 SHA512:
-  metadata.gz: 52f05a26b475cf2afa912ab7e3e207f4d925c32e58c5ba99edfc8a52685c5c536ecdc8d8e0e7e2d06d44916be0b1af383ba035339c87754824a0988cf93ce48c
-  data.tar.gz: aa7bfa1f75f1ec8bd00dc69025dffbc7127874b86f946dd1489798837727630df4a15a9410cb8047a26c195b6b6082e185bb3d9770cc586668d9b52f274c5769
+  metadata.gz: fdf14b9d40b30ea331a01b10212be3b5582785e45634ab7e49e2d81957a4408af6ce838d05dc27e9d86828a704cef1a2eb23e5331d2c13d4fa131829c6a4c03e
+  data.tar.gz: ee5342f0d5444e68773e504353000090dc71117fba3eee3a0af21399c32836085eab9f8076dd70a2cfe54385a85f9140c692007199f12b70ef60315ca76cad64

data/README.md

@@ -1,8 +1,11 @@
 # jsonapi-deserializable
-Ruby gem for validating and deserializing [JSON API](http://jsonapi.org)
-payloads into custom hashes.
-Built upon the [jsonapi-validations](https://github.com/beauby/jsonapi/tree/master/validations)
-gem.
+Ruby gem for deserializing [JSON API](http://jsonapi.org) payloads into custom
+hashes.
+
+## Status
+
+[![Gem Version](https://badge.fury.io/rb/jsonapi-deserializable.svg)](https://badge.fury.io/rb/jsonapi-deserializable)
+[![Build Status](https://secure.travis-ci.org/beauby/jsonapi-deserializable.svg?branch=master)](http://travis-ci.org/beauby/jsonapi-deserializable?branch=master)
 
 ## Installation
 ```ruby
@@ -26,54 +29,23 @@ require 'jsonapi/deserializable'
 ```
 
 Then, define some resource/relationship classes:
-```ruby
-class DeserializableUser < JSONAPI::Deserializable::Resource
-  # List of required attributes / has_many/has_one relationships.
-  #   This directive is not mandatory. If not declared, no field
-  #   will be required.
-  required do
-    id # Optional, require an id for the primary resource.
-
-    type :users # Optional, force a type for the primary resource.
-    # or, still optional, force a set of allowed types for the primary resource:
-    types [:users, :superusers] # Optional,
-
-    attribute :name
-    has_one :sponsor
-    # or, optionally, spcecify a type for the relationship target:
-    has_one :sponsor, :users
-  end
-
-  # List of optional attributes / has_many/has_one relationships.
-  #   This directive is not mandatory. If not declared, all fields
-  #   will be allowed. If declared, all fields that are not within
-  #   eitheroptional or required will be rejected.
-  optional do
-    attribute :address
-    has_many :posts
-    # or, optionally, specify a set of allowed types for the primary resource:
-    has_many :posts, [:posts, :blogs]
-  end
-
-  ## The actual fields of the generated hash.
-  # `attribute` is a shorthand for `field(key) { @attributes.send(key) }`.
-  attribute :address
-
-  field :id do
-    @data.id
-  end
 
-  # `field` is the standard method for defining a key on the result hash.
-  field :username do
-    @document.data.attributes.name
-  end
+### Resources
 
-  field :post_ids do
-    @relationships.posts.data.map(&:id)
+```ruby
+class DeserializableCreatePost < JSONAPI::Deserializable::Resource
+  type
+  attribute :title
+  attribute :date { |date| field date: DateTime.parse(date) }
+  has_one :author do |rel, id, type|
+    field author_id: id
+    field author_type: type
   end
-
-  field :sponsor_id do
-    @relationships.sponsor.data && @relationships.sponsor.data.id
+  has_many :comments do |rel, ids, types|
+    field comment_ids: ids
+    field comment_types: types.map do |type|
+      camelize(singularize(type))
+    end
   end
 end
 ```
@@ -82,35 +54,52 @@ Finally, build your hash from the deserializable resource:
 payload = {
   'data' => {
     'id' => '1',
-    'type' => 'users',
+    'type' => 'posts',
     'attributes' => {
-      'name' => 'Name',
-      'address' => 'Address'
+      'title' => 'Title',
+      'date' => '2016-01-10 02:30:00'
     },
     'relationships' => {
-      'sponsor' => {
+      'author' => {
         'data' => { 'type' => 'users', 'id' => '1337' }
       },
-      'posts' => {
+      'comments' => {
         'data' => [
-          { 'type' => 'posts', 'id' => '123' },
-          { 'type' => 'posts', 'id' => '234' },
-          { 'type' => 'posts', 'id' => '345' }
+          { 'type' => 'comments', 'id' => '123' },
+          { 'type' => 'comments', 'id' => '234' },
+          { 'type' => 'comments', 'id' => '345' }
         ]
       }
     }
   }
 }
 
-DeserializableUser.new(payload).to_h
+DeserializableCreateUser.(payload)
 # => {
-#      username: 'Name',
-#      address: 'Address',
-#      sponsor_id: '1337',
-#      post_ids: ['123', '234', '345']
+#      id: '1',
+#      title: 'Title',
+#      date: #<DateTime: 2016-01-10T02:30:00+00:00 ((2457398j,9000s,0n),+0s,2299161j)>,
+#      author_id: '1337',
+#      author_type: 'users',
+#      comment_ids: ['123', '234', '345']
+#      comment_types: ['Comment', 'Comment', 'Comment']
 #    }
 ```
 
+### Relationships
+
+```
+class DeserializablePostComments < JSONAPI::Deserializable::Relationship
+  has_many do |rel, ids, types|
+    field comment_ids: ids
+    field comment_types: types.map do |ri|
+      camelize(singularize(type))
+    end
+    field comments_meta: rel['meta']
+  end
+end
+```
+
 ## License
 
 jsonapi-deserializable is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/lib/jsonapi/deserializable.rb

@@ -1,3 +1,2 @@
-require 'jsonapi/deserializable/exceptions'
 require 'jsonapi/deserializable/relationship'
 require 'jsonapi/deserializable/resource'

data/lib/jsonapi/deserializable/relationship.rb

@@ -1,4 +1,3 @@
-require 'jsonapi/deserializable/exceptions'
 require 'jsonapi/deserializable/relationship_dsl'
 
 module JSONAPI
@@ -7,31 +6,45 @@ module JSONAPI
       include RelationshipDSL
 
       class << self
-        attr_accessor :field_blocks, :validations
+        attr_accessor :has_one_block, :has_many_block
       end
 
-      self.field_blocks = {}
-      self.validations = {}
-
       def self.inherited(klass)
-        klass.field_blocks = field_blocks.dup
-        klass.validations = Marshal.load(Marshal.dump(validations))
+        klass.has_one_block  = has_one_block
+        klass.has_many_block = has_many_block
+      end
+
+      def self.call(payload)
+        new(payload).to_h
       end
 
       def initialize(payload)
-        JSONAPI.validate_relationship!(payload, validations)
         @document = payload
         @data = payload['data']
+        deserialize!
       end
 
       def to_h
-        return nil if @data.nil?
-        return @_hash if @_hash
-        @_hash = {}
-        self.class.field_blocks.each do |key, block|
-          @_hash[key] = instance_eval(&block)
+        @hash
+      end
+
+      private
+
+      def deserialize!
+        @hash = {}
+        if @data.is_a?(Array)
+          ids = @data.map { |ri| ri['id'] }
+          types = @data.map { |ri| ri['type'] }
+          instance_exec(@document, ids, types, &self.class.has_many_block)
+        else
+          id = @data && @data['id']
+          type = @data && @data['type']
+          instance_exec(@document, id, type, &self.class.has_one_block)
         end
-        @_hash
+      end
+
+      def field(hash)
+        @hash.merge!(hash)
       end
     end
   end

data/lib/jsonapi/deserializable/relationship_dsl.rb

@@ -6,24 +6,14 @@ module JSONAPI
       end
 
       module ClassMethods
-        def has_one
-          validations[:kind] = :has_one
+        def has_one(&block)
+          block ||= proc { |rel| field key.to_sym => rel }
+          self.has_one_block = block
         end
 
-        def has_many
-          validations[:kind] = :has_many
-        end
-
-        def type(value)
-          (validations[:types] ||= []) << value
-        end
-
-        def types(values)
-          (validations[:types] ||= []).concat(values)
-        end
-
-        def field(key, &block)
-          field_blocks[key] = block
+        def has_many(&block)
+          block ||= proc { |rel| field key.to_sym => rel }
+          self.has_many_block = block
         end
       end
     end

data/lib/jsonapi/deserializable/resource.rb

@@ -1,5 +1,3 @@
-require 'jsonapi/validations'
-require 'jsonapi/deserializable/exceptions'
 require 'jsonapi/deserializable/resource_dsl'
 
 module JSONAPI
@@ -8,36 +6,104 @@ module JSONAPI
       include ResourceDSL
 
       class << self
-        attr_accessor :field_blocks, :validations
+        attr_accessor :type_block, :id_block
+        attr_accessor :attr_blocks
+        attr_accessor :has_one_rel_blocks, :has_many_rel_blocks
       end
 
-      self.field_blocks = {}
-      self.validations = {}
+      self.attr_blocks = {}
+      self.has_one_rel_blocks = {}
+      self.has_many_rel_blocks = {}
 
       def self.inherited(klass)
         super
-        klass.field_blocks = field_blocks.dup
-        klass.validations = Marshal.load(Marshal.dump(validations))
+        klass.type_block  = type_block
+        klass.id_block    = id_block
+        klass.attr_blocks = attr_blocks.dup
+        klass.has_one_rel_blocks  = has_one_rel_blocks.dup
+        klass.has_many_rel_blocks = has_many_rel_blocks.dup
+      end
+
+      def self.call(payload)
+        new(payload).to_h
       end
 
       def initialize(payload)
-        JSONAPI.validate_resource!(payload, self.class.validations)
         @document = payload
         @data = @document['data']
-        @attributes = @data['attributes']
-        @relationships = @data['relationships']
+        @type = @data['type']
+        @id   = @data['id']
+        @attributes    = @data['attributes'] || {}
+        @relationships = @data['relationships'] || {}
+        deserialize!
       end
 
       def to_h
-        return @_hash if @_hash
+        @hash
+      end
+
+      private
+
+      def deserialize!
+        @hash = {}
+        deserialize_type!
+        deserialize_id!
+        deserialize_attrs!
+        deserialize_rels!
+      end
 
-        @_hash = {}
-        @_hash[:_payload] = @document
-        self.class.field_blocks.map do |k, v|
-          @_hash[k] = instance_eval(&v)
+      def deserialize_type!
+        return unless @type && self.class.type_block
+        instance_exec(@type, &self.class.type_block)
+      end
+
+      def deserialize_id!
+        return unless @id && self.class.id_block
+        instance_exec(@id, &self.class.id_block)
+      end
+
+      def deserialize_attrs!
+        self.class.attr_blocks.each do |attr, block|
+          next unless @attributes.key?(attr)
+          instance_exec(@attributes[attr], &block)
         end
+      end
+
+      def deserialize_rels!
+        deserialize_has_one_rels!
+        deserialize_has_many_rels!
+      end
+
+      def deserialize_has_one_rels!
+        self.class.has_one_rel_blocks.each do |key, block|
+          rel = @relationships[key]
+          next unless rel && (rel['data'].nil? || rel['data'].is_a?(Hash))
+          deserialize_has_one_rel!(rel, &block)
+        end
+      end
+
+      def deserialize_has_one_rel!(rel, &block)
+        id = rel['data'] && rel['data']['id']
+        type = rel['data'] && rel['data']['type']
+        instance_exec(rel, id, type, &block)
+      end
+
+      def deserialize_has_many_rels!
+        self.class.has_many_rel_blocks.each do |key, block|
+          rel = @relationships[key]
+          next unless rel && rel['data'].is_a?(Array)
+          deserialize_has_many_rel!(rel, &block)
+        end
+      end
+
+      def deserialize_has_many_rel!(rel, &block)
+        ids = rel['data'].map { |ri| ri['id'] }
+        types = rel['data'].map { |ri| ri['type'] }
+        instance_exec(rel, ids, types, &block)
+      end
 
-        @_hash
+      def field(hash)
+        @hash.merge!(hash)
       end
     end
   end

data/lib/jsonapi/deserializable/resource_dsl.rb

@@ -1,5 +1,3 @@
-require 'jsonapi/deserializable/validations'
-
 module JSONAPI
   module Deserializable
     module ResourceDSL
@@ -8,65 +6,32 @@ module JSONAPI
       end
 
       module ClassMethods
-        def required(&block)
-          add_validations!(Validations.new(:required, &block).to_h)
-        end
-
-        def optional(&block)
-          add_validations!(Validations.new(:optional, &block).to_h)
-        end
-
-        def field(key, &block)
-          field_blocks[key] = block
-        end
-
-        def id
-          field(:id) { @data['id'] }
+        def type(&block)
+          block ||= proc { |type| field type: type }
+          self.type_block = block
         end
 
-        def attribute(key, opts = {})
-          hash_key = (opts[:key] || key).to_s
-          field(key) { @attributes[hash_key] }
+        def id(&block)
+          block ||= proc { |id| field id: id }
+          self.id_block = block
         end
 
-        def has_many_ids(key, opts = {})
-          hash_key = (opts[:key] || key).to_s
-          field(key) do
-            @relationships[hash_key]['data'].map { |ri| ri['id'] }
+        def attribute(key, options = {}, &block)
+          unless block
+            options[:key] ||= key.to_sym
+            block = proc { |attr| field key => attr }
           end
+          attr_blocks[key.to_s] = block
         end
 
-        def has_many_types(key, opts = {})
-          hash_key = (opts[:key] || key).to_s
-          field(key) do
-            @relationships[hash_key]['data'].map { |ri| ri['type'] }
-          end
-        end
-
-        def has_one_id(key, opts = {})
-          hash_key = (opts[:key] || key).to_s
-          field(key) { @relationships[hash_key]['data']['id'] }
+        def has_one(key, &block)
+          block ||= proc { |rel| field key.to_sym => rel }
+          has_one_rel_blocks[key.to_s] = block
         end
 
-        def has_one_type(key, opts = {})
-          hash_key = (opts[:key] || key).to_s
-          field(key) { @relationships[hash_key]['data']['type'] }
-        end
-
-        private
-
-        def add_validations!(hash)
-          validations[:permitted] = hash[:permitted] if hash[:permitted]
-          validations[:required] = hash[:required] if hash[:required]
-          return unless hash[:types]
-          validations[:types] ||= {}
-          if hash[:types][:primary]
-            validations[:types][:primary] = hash[:types][:primary]
-          end
-          return unless hash[:types][:relationships]
-          validations[:types][:relationships] ||= {}
-          validations[:types][:relationships]
-            .merge!(hash[:types][:relationships])
+        def has_many(key, &block)
+          block ||= proc { |rel| field key.to_sym => rel }
+          has_many_rel_blocks[key.to_s] = block
         end
       end
     end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-deserializable
 version: !ruby/object:Gem::Version
-  version: 0.1.1.beta2
+  version: 0.1.1.beta3
 platform: ruby
 authors:
 - Lucas Hosseini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-02 00:00:00.000000000 Z
+date: 2016-10-25 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: jsonapi-validations
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -61,14 +47,11 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/jsonapi/deserializable.rb
-- lib/jsonapi/deserializable/document_validator.rb
-- lib/jsonapi/deserializable/exceptions.rb
 - lib/jsonapi/deserializable/relationship.rb
 - lib/jsonapi/deserializable/relationship_dsl.rb
 - lib/jsonapi/deserializable/resource.rb
 - lib/jsonapi/deserializable/resource/dsl.rb
 - lib/jsonapi/deserializable/resource_dsl.rb
-- lib/jsonapi/deserializable/validations.rb
 homepage: https://github.com/beauby/jsonapi-deserializable
 licenses:
 - MIT

data/lib/jsonapi/deserializable/document_validator.rb

@@ -1,200 +0,0 @@
-require 'jsonapi/deserializable/field_list'
-
-module JSONAPI
-  module Deserializable
-    class DocumentValidator
-      def self.validate!(payload, required_list, optional_list)
-        new(payload, required_list, optional_list).validate!
-      end
-
-      def initialize(document, required, optional)
-        whitelist = {
-          id: :optional,
-          types: [],
-          attributes: {
-            foo: :required,
-            bar: :optional
-          },
-          relationships: {
-            foobar: :required,
-            barfoo: {
-              required: true,
-              types: [:baz],
-              arity: :to_many
-            }
-          }
-        }
-
-
-        arities = {
-          foobar: :to_many,
-          barfoo: :to_one
-        }
-        types = {
-          primary: [],
-          relationships: {
-            foobar: [:baz],
-            barfoo: [:bazbaz]
-          }
-        }
-              required: true,
-              types: [:baz],
-              arity: :to_many
-            }
-          }
-        }
-        @document = document
-        @required = required || {}
-        @optional = optional
-        @fields = {}
-        @fields[:primary_id] = true if @required[:primary_id]
-        primary_types = @required[:primary_types]
-        @fields[:primary_types] = primary_types if primary_types
-        @fields[:attributes] = @required[:attributes].dup
-        @fields[:relationships] = @required[:relationships].dup
-        if @optional
-          @fields[:primary_id] = true if @optional[:primary_id]
-          primary_types = @optional[:primary_types]
-          @fields[:primary_types] = primary_types if primary_types
-          @fields[:attributes].merge
-        end
-      end
-
-      def validate!
-        raise INVALID_DOCUMENT unless @document.data
-        @data = @document.data
-        if @data.respond_to?(:each)
-          raise INVALID_DOCUMENT, 'The request MUST include a single resource' \
-                                  ' object as primary data'
-        end
-        @attributes = @data.attributes
-        @relationships = @data.relationships
-        validate_primary!
-        validate_fields!
-      end
-
-      def validate_primary!
-        validate_id!
-        validate_type!
-      end
-
-      def id_required?
-        @required[:primary_id]
-      end
-
-      def id_permitted?
-        @fields[:primary_id]
-      end
-
-      def validate_id!
-        if @data.id.nil?
-          raise INVALID_DOCUMENT,
-                'Expected id for primary resource' if id_required?
-        else
-          raise INVALID_DOCUMENT,
-                'Unexpected id for primary resource' unless id_permitted?
-        end
-      end
-
-      def type_valid?
-        return false if @required &&
-                        @required[:primary_types] &&
-                        !@required[:primary_types].include?(@data.type.to_sym)
-        return false if @optional &&
-                        @optional[:primary_types] &&
-                        !@optional[:primary_types].include?(@data.type.to_sym)
-        true
-      end
-
-      def validate_type!
-        return if type_valid?
-        raise INVALID_DOCUMENT,
-              "Unexpected type #{@data.type} for primary resource"
-      end
-
-      def validate_fields!
-        validate_attributes!
-        validate_relationships!
-      end
-
-      def attr_permitted?(attr_key)
-        return true unless @optional
-        return true if @optional[:attributes].include?(attr_key.to_sym)
-        @required && @required[:attributes].include?(attr_key.to_sym)
-      end
-
-      def validate_attributes!
-        @attributes.keys.each do |attr_key|
-          next if attr_permitted?(attr_key)
-          raise INVALID_DOCUMENT, "Unexpected attribute #{attr_key}"
-        end
-        return unless @required
-        @required[:attributes].each do |attr_key|
-          next if @attributes.defined?(attr_key)
-          raise INVALID_DOCUMENT, "Expected attribute #{attr_key}"
-        end
-      end
-
-      def rel_permitted?(rel_key)
-        return true unless @optional
-        return true if @optional[:relationships].key?(rel_key.to_sym)
-        @required && @required[:relationships].key?(rel_key.to_sym)
-      end
-
-      def validate_relationships!
-        @relationships.keys.each do |rel_key|
-          next if rel_permitted?(rel_key)
-          raise INVALID_DOCUMENT, "Unexpected relationship #{rel_key}"
-        end
-        return unless @required
-        @required[:relationships].keys.each do |rel_key|
-          next if @relationships.defined?(rel_key)
-          raise INVALID_DOCUMENT, "Expected relationship #{rel_key}"
-        end
-        validate_relationship_types!
-      end
-
-      def validate_relationship_types!
-        rels = {}
-        rels.merge!(@required.relationships) if @required
-        rels.merge(@optional.relationships) if @optional
-        rels.each do |key, hash|
-          rel = @relationships[key.to_s]
-          unless rel.data
-            raise INVALID_DOCUMENT, "Expected data for relationship #{key}"
-          end
-
-          if hash[:arity] == :to_one
-            validate_to_one_relationship_type!(rel, hash[:types])
-          else
-            validate_to_many_relationship_type!(rel, hash[:types])
-          end
-        end
-      end
-
-      def validate_to_one_relationship_type!(rel, types)
-        if rel.collection?
-          raise INVALID_DOCUMENT,
-                "Expected relationship #{key} to be has_one"
-        end
-        return unless types && !types.include?(rel.data.type.to_sym)
-        raise INVALID_DOCUMENT, "Unexpected type: #{rel.data.type} for " \
-                                "relationship #{key}"
-      end
-
-      def validate_to_many_relationship_type!(rel, types)
-        unless rel.collection?
-          raise INVALID_DOCUMENT,
-                "Expected relationship #{key} to be has_many"
-        end
-        return unless types
-        rel.data.each do |ri|
-          unless types.include?(ri.type.to_sym)
-            raise INVALID_DOCUMENT, "Unexpected type: #{ri.type} for " \
-                                    "relationship #{key}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/jsonapi/deserializable/exceptions.rb

@@ -1,7 +0,0 @@
-require 'jsonapi/parser/exceptions'
-
-module JSONAPI
-  module Deserializable
-    INVALID_DOCUMENT = JSONAPI::Parser::InvalidDocument
-  end
-end

data/lib/jsonapi/deserializable/validations.rb

@@ -1,101 +0,0 @@
-module JSONAPI
-  module Deserializable
-    class Validations
-      def initialize(validation_type, &block)
-        @validation_type = validation_type
-        @hash = {
-          @validation_type => {
-            attributes: [],
-            relationships: []
-          },
-          types: {
-            relationships: {}
-          }
-        }
-        instance_eval(&block)
-      end
-
-      def to_h
-        @hash
-      end
-
-      private
-
-      # Define whether the +id+ of the primary resource should be part of
-      #   this list.
-      def id
-        validations_hash[:id] = true
-      end
-
-      # Define the allowed type for the primary resource.
-      # @param [Symbol] value The value of the type.
-      def type(value)
-        types_hash[:primary] = Array(value)
-      end
-
-      # Define the allowed type for the primary resource.
-      # @param [Array<Symbol>] values List of allowed values of the type.
-      def types(values)
-        types_hash[:primary] = values
-      end
-
-      # Define an attribute with given key.
-      # @param [Symbol] key The key of the attribute in the payload.
-      def attribute(key)
-        validations_hash[:attributes] << key
-      end
-
-      # TODO(beauby): Decide whether type: 'users' / types: [...] is better.
-      #
-      # @overload has_one(key)
-      #   Define a has_one relationship with given key.
-      #   @param [Symbol] key The key of the relationship in the payload.
-      #
-      # @overload has_one(key, type)
-      #   Define a has_one relationship with given key.
-      #   @param [Symbol] key The key of the relationship in the payload.
-      #   @param [Symbol] type The expected type of the relationship value.
-      #
-      # @overload has_one(key, types)
-      #   Define a has_one relationship with given key.
-      #   @param [Symbol] key The key of the relationship in the payload.
-      #   @param [Array<Symbol>] type List of acceptable types for the
-      #     relationship value.
-      def has_many(key, types = nil)
-        validations_hash[:relationships] << key
-        types_hash[:relationships][key] = { kind: :has_many }
-        return unless types
-        types_hash[:relationships][key][:types] = Array(types)
-      end
-
-      # @overload has_one(key)
-      #   Define a has_one relationship with given key.
-      #   @param [Symbol] key The key of the relationship in the payload.
-      #
-      # @overload has_one(key, type)
-      #   Define a has_one relationship with given key.
-      #   @param [Symbol] key The key of the relationship in the payload.
-      #   @param [Symbol] type The expected type of the relationship value.
-      #
-      # @overload has_one(key, types)
-      #   Define a has_one relationship with given key.
-      #   @param [Symbol] key The key of the relationship in the payload.
-      #   @param [Array<Symbol>] type List of acceptable types for the
-      #     relationship value.
-      def has_one(key, types = nil)
-        validations_hash[:relationships] << key
-        types_hash[:relationships][key] = { kind: :has_one }
-        return unless types
-        types_hash[:relationships][key][:types] = Array(types)
-      end
-
-      def validations_hash
-        @hash[@validation_type]
-      end
-
-      def types_hash
-        @hash[:types]
-      end
-    end
-  end
-end