jsonapi-resources 0.4.4 → 0.5.0

data/lib/jsonapi/link_builder.rb

@@ -0,0 +1,141 @@
+module JSONAPI
+  class LinkBuilder
+    attr_reader :base_url,
+                :primary_resource_klass,
+                :route_formatter
+
+    def initialize(config = {})
+      @base_url               = config[:base_url]
+      @primary_resource_klass = config[:primary_resource_klass]
+      @route_formatter        = config[:route_formatter]
+      @is_engine              = !!engine_name
+    end
+
+    def engine?
+      @is_engine
+    end
+
+    def engine_name
+      @engine_name ||= build_engine_name
+    end
+
+    def primary_resources_url
+      if engine?
+        engine_primary_resources_url
+      else
+        regular_primary_resources_url
+      end
+    end
+
+    def query_link(query_params)
+      "#{ primary_resources_url }?#{ query_params.to_query }"
+    end
+
+    def relationships_related_link(source, relationship)
+      "#{ self_link(source) }/#{ route_for_relationship(relationship) }"
+    end
+
+    def relationships_self_link(source, relationship)
+      "#{ self_link(source) }/relationships/#{ route_for_relationship(relationship) }"
+    end
+
+    def self_link(source)
+      if engine?
+        engine_resource_url(source)
+      else
+        regular_resource_url(source)
+      end
+    end
+
+    private
+
+    def build_engine_name
+      scopes = module_scopes_from_class(primary_resource_klass)
+
+      unless scopes.empty?
+        "#{ scopes.first.to_s.camelize }::Engine".safe_constantize
+      end
+    end
+
+    def engine_path_from_resource_class(klass)
+      path_name = engine_resources_path_name_from_class(klass)
+      engine_name.routes.url_helpers.public_send(path_name)
+    end
+
+    def engine_primary_resources_path
+      engine_path_from_resource_class(primary_resource_klass)
+    end
+
+    def engine_primary_resources_url
+      "#{ base_url }#{ engine_primary_resources_path }"
+    end
+
+    def engine_resource_path(source)
+      resource_path_name = engine_resource_path_name_from_source(source)
+      engine_name.routes.url_helpers.public_send(resource_path_name, source.id)
+    end
+
+    def engine_resource_path_name_from_source(source)
+      scopes         = module_scopes_from_class(source.class)[1..-1]
+      base_path_name = scopes.map { |scope| scope.downcase }.join("_")
+      end_path_name  = source.class._type.to_s.singularize
+      "#{ base_path_name }_#{ end_path_name }_path"
+    end
+
+    def engine_resource_url(source)
+      "#{ base_url }#{ engine_resource_path(source) }"
+    end
+
+    def engine_resources_path_name_from_class(klass)
+      scopes         = module_scopes_from_class(klass)[1..-1]
+      base_path_name = scopes.map { |scope| scope.downcase }.join("_")
+      end_path_name  = klass._type.to_s
+      "#{ base_path_name }_#{ end_path_name }_path"
+    end
+
+    def format_route(route)
+      route_formatter.format(route.to_s)
+    end
+
+    def formatted_module_path_from_class(klass)
+      scopes = module_scopes_from_class(klass)
+
+      unless scopes.empty?
+        "/#{ scopes.map(&:downcase).join('/') }/"
+      else
+        "/"
+      end
+    end
+
+    def module_scopes_from_class(klass)
+      klass.name.to_s.split("::")[0...-1]
+    end
+
+    def regular_primary_resources_path
+      [
+        formatted_module_path_from_class(primary_resource_klass),
+        route_formatter.format(primary_resource_klass._type.to_s),
+      ].join
+    end
+
+    def regular_primary_resources_url
+      "#{ base_url }#{ regular_primary_resources_path }"
+    end
+
+    def regular_resource_path(source)
+      [
+        formatted_module_path_from_class(source.class),
+        route_formatter.format(source.class._type.to_s),
+        "/#{ source.id }",
+      ].join
+    end
+
+    def regular_resource_url(source)
+      "#{ base_url }#{ regular_resource_path(source) }"
+    end
+
+    def route_for_relationship(relationship)
+      format_route(relationship.name)
+    end
+  end
+end

data/lib/jsonapi/operation.rb

@@ -90,12 +90,12 @@ module JSONAPI
     end
   end
 
-  class ShowAssociationOperation < Operation
-    attr_reader :parent_key, :association_type
+  class ShowRelationshipOperation < Operation
+    attr_reader :parent_key, :relationship_type
 
     def initialize(resource_klass, options = {})
       @parent_key = options.fetch(:parent_key)
-      @association_type = options.fetch(:association_type)
+      @relationship_type = options.fetch(:relationship_type)
       @transactional = false
       super(resource_klass, options)
     end
@@ -105,7 +105,7 @@ module JSONAPI
 
       return JSONAPI::LinksObjectOperationResult.new(:ok,
                                                      parent_resource,
-                                                     resource_klass._association(@association_type))
+                                                     resource_klass._relationship(@relationship_type))
 
     rescue JSONAPI::Exceptions::Error => e
       return JSONAPI::ErrorsOperationResult.new(e.errors[0].code, e.errors)
@@ -113,12 +113,12 @@ module JSONAPI
   end
 
   class ShowRelatedResourceOperation < Operation
-    attr_reader :source_klass, :source_id, :association_type
+    attr_reader :source_klass, :source_id, :relationship_type
 
     def initialize(resource_klass, options = {})
       @source_klass = options.fetch(:source_klass)
       @source_id = options.fetch(:source_id)
-      @association_type = options.fetch(:association_type)
+      @relationship_type = options.fetch(:relationship_type)
       @transactional = false
       super(resource_klass, options)
     end
@@ -126,7 +126,7 @@ module JSONAPI
     def apply
       source_resource = @source_klass.find_by_key(@source_id, context: @context)
 
-      related_resource = source_resource.send(@association_type)
+      related_resource = source_resource.public_send(@relationship_type)
 
       return JSONAPI::ResourceOperationResult.new(:ok, related_resource)
 
@@ -136,12 +136,12 @@ module JSONAPI
   end
 
   class ShowRelatedResourcesOperation < Operation
-    attr_reader :source_klass, :source_id, :association_type, :filters, :sort_criteria, :paginator
+    attr_reader :source_klass, :source_id, :relationship_type, :filters, :sort_criteria, :paginator
 
     def initialize(resource_klass, options = {})
       @source_klass = options.fetch(:source_klass)
       @source_id = options.fetch(:source_id)
-      @association_type = options.fetch(:association_type)
+      @relationship_type = options.fetch(:relationship_type)
       @filters = options[:filters]
       @sort_criteria = options[:sort_criteria]
       @paginator = options[:paginator]
@@ -152,7 +152,7 @@ module JSONAPI
     def apply
       source_resource = @source_klass.find_by_key(@source_id, context: @context)
 
-      related_resource = source_resource.send(@association_type,
+      related_resource = source_resource.public_send(@relationship_type,
                                               filters:  @filters,
                                               sort_criteria: @sort_criteria,
                                               paginator: @paginator)
@@ -218,109 +218,109 @@ module JSONAPI
     end
   end
 
-  class ReplaceHasOneAssociationOperation < Operation
-    attr_reader :resource_id, :association_type, :key_value
+  class ReplaceToOneRelationshipOperation < Operation
+    attr_reader :resource_id, :relationship_type, :key_value
 
     def initialize(resource_klass, options = {})
       @resource_id = options.fetch(:resource_id)
       @key_value = options.fetch(:key_value)
-      @association_type = options.fetch(:association_type).to_sym
+      @relationship_type = options.fetch(:relationship_type).to_sym
       super(resource_klass, options)
     end
 
     def apply
       resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.replace_has_one_link(@association_type, @key_value)
+      result = resource.replace_to_one_link(@relationship_type, @key_value)
 
       return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 
-  class ReplacePolymorphicHasOneAssociationOperation < Operation
-    attr_reader :resource_id, :association_type, :key_value, :key_type
+  class ReplacePolymorphicToOneRelationshipOperation < Operation
+    attr_reader :resource_id, :relationship_type, :key_value, :key_type
 
     def initialize(resource_klass, options = {})
       @resource_id = options.fetch(:resource_id)
       @key_value = options.fetch(:key_value)
       @key_type = options.fetch(:key_type)
-      @association_type = options.fetch(:association_type).to_sym
+      @relationship_type = options.fetch(:relationship_type).to_sym
       super(resource_klass, options)
     end
 
     def apply
       resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.replace_polymorphic_has_one_link(@association_type, @key_value, @key_type)
+      result = resource.replace_polymorphic_to_one_link(@relationship_type, @key_value, @key_type)
 
       return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 
-  class CreateHasManyAssociationOperation < Operation
-    attr_reader :resource_id, :association_type, :data
+  class CreateToManyRelationshipOperation < Operation
+    attr_reader :resource_id, :relationship_type, :data
 
     def initialize(resource_klass, options)
       @resource_id = options.fetch(:resource_id)
       @data = options.fetch(:data)
-      @association_type = options.fetch(:association_type).to_sym
+      @relationship_type = options.fetch(:relationship_type).to_sym
       super(resource_klass, options)
     end
 
     def apply
       resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.create_has_many_links(@association_type, @data)
+      result = resource.create_to_many_links(@relationship_type, @data)
 
       return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 
-  class ReplaceHasManyAssociationOperation < Operation
-    attr_reader :resource_id, :association_type, :data
+  class ReplaceToManyRelationshipOperation < Operation
+    attr_reader :resource_id, :relationship_type, :data
 
     def initialize(resource_klass, options)
       @resource_id = options.fetch(:resource_id)
       @data = options.fetch(:data)
-      @association_type = options.fetch(:association_type).to_sym
+      @relationship_type = options.fetch(:relationship_type).to_sym
       super(resource_klass, options)
     end
 
     def apply
       resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.replace_has_many_links(@association_type, @data)
+      result = resource.replace_to_many_links(@relationship_type, @data)
 
       return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 
-  class RemoveHasManyAssociationOperation < Operation
-    attr_reader :resource_id, :association_type, :associated_key
+  class RemoveToManyRelationshipOperation < Operation
+    attr_reader :resource_id, :relationship_type, :associated_key
 
     def initialize(resource_klass, options)
       @resource_id = options.fetch(:resource_id)
       @associated_key = options.fetch(:associated_key)
-      @association_type = options.fetch(:association_type).to_sym
+      @relationship_type = options.fetch(:relationship_type).to_sym
       super(resource_klass, options)
     end
 
     def apply
       resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.remove_has_many_link(@association_type, @associated_key)
+      result = resource.remove_to_many_link(@relationship_type, @associated_key)
 
       return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end
   end
 
-  class RemoveHasOneAssociationOperation < Operation
-    attr_reader :resource_id, :association_type
+  class RemoveToOneRelationshipOperation < Operation
+    attr_reader :resource_id, :relationship_type
 
     def initialize(resource_klass, options)
       @resource_id = options.fetch(:resource_id)
-      @association_type = options.fetch(:association_type).to_sym
+      @relationship_type = options.fetch(:relationship_type).to_sym
       super(resource_klass, options)
     end
 
     def apply
       resource = @resource_klass.find_by_key(@resource_id, context: @context)
-      result = resource.remove_has_one_link(@association_type)
+      result = resource.remove_to_one_link(@relationship_type)
 
       return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted)
     end

data/lib/jsonapi/operation_result.rb

@@ -43,11 +43,11 @@ module JSONAPI
   end
 
   class LinksObjectOperationResult < OperationResult
-    attr_accessor :parent_resource, :association
+    attr_accessor :parent_resource, :relationship
 
-    def initialize(code, parent_resource, association, options = {})
+    def initialize(code, parent_resource, relationship, options = {})
       @parent_resource = parent_resource
-      @association = association
+      @relationship = relationship
       super(code, options)
     end
   end

data/lib/jsonapi/operations_processor.rb

@@ -5,18 +5,18 @@ module JSONAPI
                                        :operations,
                                        :find_operation,
                                        :show_operation,
-                                       :show_association_operation,
+                                       :show_relationship_operation,
                                        :show_related_resource_operation,
                                        :show_related_resources_operation,
                                        :create_resource_operation,
                                        :remove_resource_operation,
                                        :replace_fields_operation,
-                                       :replace_has_one_association_operation,
-                                       :replace_polymorphic_has_one_association_operation,
-                                       :create_has_many_association_operation,
-                                       :replace_has_many_association_operation,
-                                       :remove_has_many_association_operation,
-                                       :remove_has_one_association_operation
+                                       :replace_to_one_relationship_operation,
+                                       :replace_polymorphic_to_one_relationship_operation,
+                                       :create_to_many_relationship_operation,
+                                       :replace_to_many_relationship_operation,
+                                       :remove_to_many_relationship_operation,
+                                       :remove_to_one_relationship_operation
 
     class << self
       def operations_processor_for(operations_processor)

data/lib/jsonapi/{association.rb → relationship.rb}

@@ -1,7 +1,7 @@
 module JSONAPI
-  class Association
+  class Relationship
     attr_reader :acts_as_set, :foreign_key, :type, :options, :name,
-                :class_name, :polymorphic
+                :class_name, :polymorphic, :always_include_linkage_data
 
     def initialize(name, options = {})
       @name = name.to_s
@@ -11,6 +11,7 @@ module JSONAPI
       @module_path = options[:module_path] || ''
       @relation_name = options.fetch(:relation_name, @name)
       @polymorphic = options.fetch(:polymorphic, false) == true
+      @always_include_linkage_data = options.fetch(:always_include_linkage_data, false) == true
     end
 
     alias_method :polymorphic?, :polymorphic
@@ -45,12 +46,19 @@ module JSONAPI
       end
     end
 
-    class HasOne < Association
+    class ToOne < Relationship
+      attr_reader :foreign_key_on
+
       def initialize(name, options = {})
         super
         @class_name = options.fetch(:class_name, name.to_s.camelize)
         @type = class_name.underscore.pluralize.to_sym
         @foreign_key ||= "#{name}_id".to_sym
+        @foreign_key_on = options.fetch(:foreign_key_on, :self)
+      end
+
+      def belongs_to?
+        foreign_key_on == :self
       end
 
       def polymorphic_type
@@ -58,7 +66,7 @@ module JSONAPI
       end
     end
 
-    class HasMany < Association
+    class ToMany < Relationship
       def initialize(name, options = {})
         super
         @class_name = options.fetch(:class_name, name.to_s.camelize.singularize)

data/lib/jsonapi/request.rb

@@ -58,7 +58,7 @@ module JSONAPI
       parse_filters(params[:filter])
       parse_sort_criteria(params[:sort])
       parse_pagination(params[:page])
-      add_show_related_resource_operation(params[:association])
+      add_show_related_resource_operation(params[:relationship])
     end
 
     def setup_get_related_resources_action(params)
@@ -69,7 +69,7 @@ module JSONAPI
       parse_filters(params[:filter])
       parse_sort_criteria(params[:sort])
       parse_pagination(params[:page])
-      add_show_related_resources_operation(params[:association])
+      add_show_related_resources_operation(params[:relationship])
     end
 
     def setup_show_action(params)
@@ -79,8 +79,8 @@ module JSONAPI
       add_show_operation
     end
 
-    def setup_show_association_action(params)
-      add_show_association_operation(params[:association], params.require(@resource_klass._as_parent_key))
+    def setup_show_relationship_action(params)
+      add_show_relationship_operation(params[:relationship], params.require(@resource_klass._as_parent_key))
     end
 
     def setup_create_action(params)
@@ -89,15 +89,15 @@ module JSONAPI
       parse_add_operation(params.require(:data))
     end
 
-    def setup_create_association_action(params)
-      parse_add_association_operation(params.require(:data),
-                                      params.require(:association),
+    def setup_create_relationship_action(params)
+      parse_add_relationship_operation(params.require(:data),
+                                      params.require(:relationship),
                                       params.require(@resource_klass._as_parent_key))
     end
 
-    def setup_update_association_action(params)
-      parse_update_association_operation(params.fetch(:data),
-                                         params.require(:association),
+    def setup_update_relationship_action(params)
+      parse_update_relationship_operation(params.fetch(:data),
+                                         params.require(:relationship),
                                          params.require(@resource_klass._as_parent_key))
     end
 
@@ -111,8 +111,8 @@ module JSONAPI
       parse_remove_operation(params)
     end
 
-    def setup_destroy_association_action(params)
-      parse_remove_association_operation(params)
+    def setup_destroy_relationship_action(params)
+      parse_remove_relationship_operation(params)
     end
 
     def initialize_source(params)
@@ -158,7 +158,7 @@ module JSONAPI
         end
 
         if type_resource.nil? || !(@resource_klass._type == underscored_type ||
-          @resource_klass._has_association?(underscored_type))
+          @resource_klass._has_relationship?(underscored_type))
           @errors.concat(JSONAPI::Exceptions::InvalidResource.new(type).errors)
         else
           unless values.nil?
@@ -180,12 +180,12 @@ module JSONAPI
     end
 
     def check_include(resource_klass, include_parts)
-      association_name = unformat_key(include_parts.first)
+      relationship_name = unformat_key(include_parts.first)
 
-      association = resource_klass._association(association_name)
-      if association && format_key(association_name) == include_parts.first
+      relationship = resource_klass._relationship(relationship_name)
+      if relationship && format_key(relationship_name) == include_parts.first
         unless include_parts.last.empty?
-          check_include(Resource.resource_for(@resource_klass.module_path + association.class_name.to_s.underscore), include_parts.last.partition('.'))
+          check_include(Resource.resource_for(@resource_klass.module_path + relationship.class_name.to_s.underscore), include_parts.last.partition('.'))
         end
       else
         @errors.concat(JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type),
@@ -280,30 +280,30 @@ module JSONAPI
       )
     end
 
-    def add_show_association_operation(association_type, parent_key)
-      @operations.push JSONAPI::ShowAssociationOperation.new(
+    def add_show_relationship_operation(relationship_type, parent_key)
+      @operations.push JSONAPI::ShowRelationshipOperation.new(
         @resource_klass,
         context: @context,
-        association_type: association_type,
+        relationship_type: relationship_type,
         parent_key: @resource_klass.verify_key(parent_key)
       )
     end
 
-    def add_show_related_resource_operation(association_type)
+    def add_show_related_resource_operation(relationship_type)
       @operations.push JSONAPI::ShowRelatedResourceOperation.new(
         @resource_klass,
         context: @context,
-        association_type: association_type,
+        relationship_type: relationship_type,
         source_klass: @source_klass,
         source_id: @source_id
       )
     end
 
-    def add_show_related_resources_operation(association_type)
+    def add_show_related_resources_operation(relationship_type)
       @operations.push JSONAPI::ShowRelatedResourcesOperation.new(
         @resource_klass,
         context: @context,
-        association_type: association_type,
+        relationship_type: relationship_type,
         source_klass: @source_klass,
         source_id: @source_id,
         filters: @source_klass.verify_filters(@filters, @context),
@@ -346,7 +346,7 @@ module JSONAPI
       end
     end
 
-    def parse_has_one_links_object(raw)
+    def parse_to_one_links_object(raw)
       if raw.nil?
         return {
           type: nil,
@@ -364,13 +364,13 @@ module JSONAPI
       }
     end
 
-    def parse_has_many_links_object(raw)
+    def parse_to_many_links_object(raw)
       fail JSONAPI::Exceptions::InvalidLinksObject.new if raw.nil?
 
       links_object = {}
       if raw.is_a?(Array)
         raw.each do |link|
-          link_object = parse_has_one_links_object(link)
+          link_object = parse_to_one_links_object(link)
           links_object[link_object[:type]] ||= []
           links_object[link_object[:type]].push(link_object[:id])
         end
@@ -384,39 +384,39 @@ module JSONAPI
       verify_permitted_params(params, allowed_fields)
 
       checked_attributes = {}
-      checked_has_one_associations = {}
-      checked_has_many_associations = {}
+      checked_to_one_relationships = {}
+      checked_to_many_relationships = {}
 
       params.each do |key, value|
         case key.to_s
         when 'relationships'
           value.each do |link_key, link_value|
             param = unformat_key(link_key)
-            association = @resource_klass._association(param)
-            if association.is_a?(JSONAPI::Association::HasOne)
+            relationship = @resource_klass._relationship(param)
+            if relationship.is_a?(JSONAPI::Relationship::ToOne)
               if link_value.nil?
                 linkage = nil
               else
                 linkage = link_value[:data]
               end
 
-              links_object = parse_has_one_links_object(linkage)
-              if !association.polymorphic? && links_object[:type] && (links_object[:type].to_s != association.type.to_s)
+              links_object = parse_to_one_links_object(linkage)
+              if !relationship.polymorphic? && links_object[:type] && (links_object[:type].to_s != relationship.type.to_s)
                 fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
               end
 
               unless links_object[:id].nil?
-                association_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(links_object[:type]).to_s)
-                association_id = association_resource.verify_key(links_object[:id], @context)
-                if association.polymorphic?
-                  checked_has_one_associations[param] = { id: association_id, type: unformat_key(links_object[:type].to_s) }
+                relationship_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(links_object[:type]).to_s)
+                relationship_id = relationship_resource.verify_key(links_object[:id], @context)
+                if relationship.polymorphic?
+                  checked_to_one_relationships[param] = { id: relationship_id, type: unformat_key(links_object[:type].to_s) }
                 else
-                  checked_has_one_associations[param] = association_id
+                  checked_to_one_relationships[param] = relationship_id
                 end
               else
-                checked_has_one_associations[param] = nil
+                checked_to_one_relationships[param] = nil
               end
-            elsif association.is_a?(JSONAPI::Association::HasMany)
+            elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
               if link_value.is_a?(Array) && link_value.length == 0
                 linkage = []
               elsif link_value.is_a?(Hash)
@@ -425,22 +425,22 @@ module JSONAPI
                 fail JSONAPI::Exceptions::InvalidLinksObject.new
               end
 
-              links_object = parse_has_many_links_object(linkage)
+              links_object = parse_to_many_links_object(linkage)
 
-              # Since we do not yet support polymorphic associations we will raise an error if the type does not match the
-              # association's type.
-              # ToDo: Support Polymorphic associations
+              # Since we do not yet support polymorphic relationships we will raise an error if the type does not match the
+              # relationship's type.
+              # ToDo: Support Polymorphic relationships
 
               if links_object.length == 0
-                checked_has_many_associations[param] = []
+                checked_to_many_relationships[param] = []
               else
-                if links_object.length > 1 || !links_object.has_key?(unformat_key(association.type).to_s)
+                if links_object.length > 1 || !links_object.has_key?(unformat_key(relationship.type).to_s)
                   fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
                 end
 
                 links_object.each_pair do |type, keys|
-                  association_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(type).to_s)
-                  checked_has_many_associations[param] = association_resource.verify_keys(keys, @context)
+                  relationship_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(type).to_s)
+                  checked_to_many_relationships[param] = relationship_resource.verify_keys(keys, @context)
                 end
               end
             end
@@ -457,8 +457,8 @@ module JSONAPI
 
       return {
         'attributes' => checked_attributes,
-        'has_one' => checked_has_one_associations,
-        'has_many' => checked_has_many_associations
+        'to_one' => checked_to_one_relationships,
+        'to_many' => checked_to_many_relationships
       }.deep_transform_keys { |key| unformat_key(key) }
     end
 
@@ -501,64 +501,64 @@ module JSONAPI
     end
     # :nocov:
 
-    def parse_add_association_operation(data, association_type, parent_key)
-      association = resource_klass._association(association_type)
+    def parse_add_relationship_operation(data, relationship_type, parent_key)
+      relationship = resource_klass._relationship(relationship_type)
 
-      if association.is_a?(JSONAPI::Association::HasMany)
-        object_params = { relationships: { format_key(association.name) => { data: data } } }
+      if relationship.is_a?(JSONAPI::Relationship::ToMany)
+        object_params = { relationships: { format_key(relationship.name) => { data: data } } }
         verified_param_set = parse_params(object_params, updatable_fields)
 
-        @operations.push JSONAPI::CreateHasManyAssociationOperation.new(
+        @operations.push JSONAPI::CreateToManyRelationshipOperation.new(
           resource_klass,
           context: @context,
           resource_id: parent_key,
-          association_type: association_type,
-          data: verified_param_set[:has_many].values[0]
+          relationship_type: relationship_type,
+          data: verified_param_set[:to_many].values[0]
         )
       end
     end
 
-    def parse_update_association_operation(data, association_type, parent_key)
-      association = resource_klass._association(association_type)
-      if association.is_a?(JSONAPI::Association::HasOne)
-        if association.polymorphic?
-          object_params = { relationships: { format_key(association.name) => { data: data } } }
+    def parse_update_relationship_operation(data, relationship_type, parent_key)
+      relationship = resource_klass._relationship(relationship_type)
+      if relationship.is_a?(JSONAPI::Relationship::ToOne)
+        if relationship.polymorphic?
+          object_params = { relationships: { format_key(relationship.name) => { data: data } } }
           verified_param_set = parse_params(object_params, updatable_fields)
 
-          @operations.push JSONAPI::ReplacePolymorphicHasOneAssociationOperation.new(
+          @operations.push JSONAPI::ReplacePolymorphicToOneRelationshipOperation.new(
                              resource_klass,
                              context: @context,
                              resource_id: parent_key,
-                             association_type: association_type,
-                             key_value: verified_param_set[:has_one].values[0][:id],
-                             key_type: verified_param_set[:has_one].values[0][:type]
+                             relationship_type: relationship_type,
+                             key_value: verified_param_set[:to_one].values[0][:id],
+                             key_type: verified_param_set[:to_one].values[0][:type]
                            )
         else
-          object_params = { relationships: { format_key(association.name) => { data: data } } }
+          object_params = { relationships: { format_key(relationship.name) => { data: data } } }
           verified_param_set = parse_params(object_params, updatable_fields)
 
-          @operations.push JSONAPI::ReplaceHasOneAssociationOperation.new(
+          @operations.push JSONAPI::ReplaceToOneRelationshipOperation.new(
                              resource_klass,
                              context: @context,
                              resource_id: parent_key,
-                             association_type: association_type,
-                             key_value: verified_param_set[:has_one].values[0]
+                             relationship_type: relationship_type,
+                             key_value: verified_param_set[:to_one].values[0]
                            )
         end
-      elsif association.is_a?(JSONAPI::Association::HasMany)
-        unless association.acts_as_set
-          fail JSONAPI::Exceptions::HasManySetReplacementForbidden.new
+      elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
+        unless relationship.acts_as_set
+          fail JSONAPI::Exceptions::ToManySetReplacementForbidden.new
         end
 
-        object_params = { relationships: { format_key(association.name) => { data: data } } }
+        object_params = { relationships: { format_key(relationship.name) => { data: data } } }
         verified_param_set = parse_params(object_params, updatable_fields)
 
-        @operations.push JSONAPI::ReplaceHasManyAssociationOperation.new(
+        @operations.push JSONAPI::ReplaceToManyRelationshipOperation.new(
                            resource_klass,
                            context: @context,
                            resource_id: parent_key,
-                           association_type: association_type,
-                           data: verified_param_set[:has_many].values[0]
+                           relationship_type: relationship_type,
+                           data: verified_param_set[:to_many].values[0]
                          )
       end
     end
@@ -619,29 +619,29 @@ module JSONAPI
       @errors.concat(e.errors)
     end
 
-    def parse_remove_association_operation(params)
-      association_type = params[:association]
+    def parse_remove_relationship_operation(params)
+      relationship_type = params[:relationship]
 
       parent_key = params[resource_klass._as_parent_key]
 
-      association = resource_klass._association(association_type)
-      if association.is_a?(JSONAPI::Association::HasMany)
+      relationship = resource_klass._relationship(relationship_type)
+      if relationship.is_a?(JSONAPI::Relationship::ToMany)
         keys = parse_key_array(params[:keys])
         keys.each do |key|
-          @operations.push JSONAPI::RemoveHasManyAssociationOperation.new(
+          @operations.push JSONAPI::RemoveToManyRelationshipOperation.new(
             resource_klass,
             context: @context,
             resource_id: parent_key,
-            association_type: association_type,
+            relationship_type: relationship_type,
             associated_key: key
           )
         end
       else
-        @operations.push JSONAPI::RemoveHasOneAssociationOperation.new(
+        @operations.push JSONAPI::RemoveToOneRelationshipOperation.new(
           resource_klass,
           context: @context,
           resource_id: parent_key,
-          association_type: association_type
+          relationship_type: relationship_type
         )
       end
     end