style: DependentType, PrincipalType --> RightType, LeftType

maurei · maurei · commit ce08b4fc81e2 · 2019-10-22T12:31:15.000+02:00
diff --git a/src/JsonApiDotNetCore/Builders/ResourceGraphBuilder.cs b/src/JsonApiDotNetCore/Builders/ResourceGraphBuilder.cs
@@ -125,8 +125,8 @@ protected virtual List<RelationshipAttribute> GetRelationships(Type entityType)
 
                 attribute.PublicRelationshipName = attribute.PublicRelationshipName ?? _resourceNameFormatter.FormatPropertyName(prop);
                 attribute.InternalRelationshipName = prop.Name;
-                attribute.DependentType = GetRelationshipType(attribute, prop);
-                attribute.PrincipalType = entityType;
+                attribute.RightType = GetRelationshipType(attribute, prop);
+                attribute.LeftType = entityType;
                 attributes.Add(attribute);
 
                 if (attribute is HasManyThroughAttribute hasManyThroughAttribute)
@@ -160,13 +160,13 @@ protected virtual List<RelationshipAttribute> GetRelationships(Type entityType)
                         ?? throw new JsonApiSetupException($"{hasManyThroughAttribute.ThroughType} does not contain a relationship id property to type {entityType} with name {leftIdPropertyName}");
 
                     // Article → ArticleTag.Tag
-                    hasManyThroughAttribute.RightProperty = throughProperties.SingleOrDefault(x => x.PropertyType == hasManyThroughAttribute.DependentType)
-                        ?? throw new JsonApiSetupException($"{hasManyThroughAttribute.ThroughType} does not contain a navigation property to type {hasManyThroughAttribute.DependentType}");
+                    hasManyThroughAttribute.RightProperty = throughProperties.SingleOrDefault(x => x.PropertyType == hasManyThroughAttribute.RightType)
+                        ?? throw new JsonApiSetupException($"{hasManyThroughAttribute.ThroughType} does not contain a navigation property to type {hasManyThroughAttribute.RightType}");
 
                     // ArticleTag.TagId
                     var rightIdPropertyName = JsonApiOptions.RelatedIdMapper.GetRelatedIdPropertyName(hasManyThroughAttribute.RightProperty.Name);
                     hasManyThroughAttribute.RightIdProperty = throughProperties.SingleOrDefault(x => x.Name == rightIdPropertyName)
-                        ?? throw new JsonApiSetupException($"{hasManyThroughAttribute.ThroughType} does not contain a relationship id property to type {hasManyThroughAttribute.DependentType} with name {rightIdPropertyName}");
+                        ?? throw new JsonApiSetupException($"{hasManyThroughAttribute.ThroughType} does not contain a relationship id property to type {hasManyThroughAttribute.RightType} with name {rightIdPropertyName}");
                 }
             }
 
diff --git a/src/JsonApiDotNetCore/Extensions/IQueryableExtensions.cs b/src/JsonApiDotNetCore/Extensions/IQueryableExtensions.cs
@@ -124,7 +124,7 @@ private static IOrderedQueryable<TSource> CallGenericOrderMethod<TSource>(IQuery
             return (IOrderedQueryable<TSource>)result;
         }
 
-        private static Expression GetFilterExpressionLambda(Expression left, Expression right, FilterOperation  operation)
+        private static Expression GetFilterExpressionLambda(Expression left, Expression right, FilterOperation operation)
         {
             Expression body;
             switch (operation)
@@ -259,7 +259,7 @@ private static IQueryable<TSource> CallGenericWhereMethod<TSource>(IQueryable<TS
                 if (relationProperty == null)
                     throw new ArgumentException($"'{filter.Relationship.InternalRelationshipName}' is not a valid relationship of '{concreteType}'");
 
-                var relatedType = filter.Relationship.DependentType;
+                var relatedType = filter.Relationship.RightType;
                 property = relatedType.GetProperty(filter.Attribute.InternalAttributeName);
                 if (property == null)
                     throw new ArgumentException($"'{filter.Attribute.InternalAttributeName}' is not a valid attribute of '{filter.Relationship.InternalRelationshipName}'");
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/HookExecutorHelper.cs b/src/JsonApiDotNetCore/Hooks/Execution/HookExecutorHelper.cs
@@ -71,9 +71,9 @@ public IResourceHookContainer GetResourceHookContainer(DependentType dependentTy
         }
 
         /// <inheritdoc/>
-        public IResourceHookContainer<TEntity> GetResourceHookContainer<TEntity>(ResourceHook hook = ResourceHook.None) where TEntity : class, IIdentifiable
+        public IResourceHookContainer<TResource> GetResourceHookContainer<TResource>(ResourceHook hook = ResourceHook.None) where TResource : class, IIdentifiable
         {
-            return (IResourceHookContainer<TEntity>)GetResourceHookContainer(typeof(TEntity), hook);
+            return (IResourceHookContainer<TResource>)GetResourceHookContainer(typeof(TResource), hook);
         }
 
         public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipAttribute[] inclusionChain)
@@ -89,12 +89,12 @@ public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerab
             return (IEnumerable)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(entityTypeForRepository), values.Cast(entityTypeForRepository));
         }
 
-        public HashSet<TEntity> LoadDbValues<TEntity>(IEnumerable<TEntity> entities, ResourceHook hook, params RelationshipAttribute[] relationships) where TEntity : class, IIdentifiable
+        public HashSet<TResource> LoadDbValues<TResource>(IEnumerable<TResource> entities, ResourceHook hook, params RelationshipAttribute[] relationships) where TResource : class, IIdentifiable
         {
-            var entityType = typeof(TEntity);
-            var dbValues = LoadDbValues(entityType, entities, hook, relationships)?.Cast<TEntity>();
+            var entityType = typeof(TResource);
+            var dbValues = LoadDbValues(entityType, entities, hook, relationships)?.Cast<TResource>();
             if (dbValues == null) return null;
-            return new HashSet<TEntity>(dbValues);
+            return new HashSet<TResource>(dbValues);
         }
 
         public bool ShouldLoadDbValues(Type entityType, ResourceHook hook)
@@ -131,16 +131,16 @@ IHooksDiscovery GetHookDiscovery(Type entityType)
             return discovery;
         }
 
-        IEnumerable<TEntity> GetWhereAndInclude<TEntity, TId>(IEnumerable<TId> ids, RelationshipAttribute[] inclusionChain) where TEntity : class, IIdentifiable<TId>
+        IEnumerable<TResource> GetWhereAndInclude<TResource, TId>(IEnumerable<TId> ids, RelationshipAttribute[] inclusionChain) where TResource : class, IIdentifiable<TId>
         {
-            var repo = GetRepository<TEntity, TId>();
+            var repo = GetRepository<TResource, TId>();
             var query = repo.Get().Where(e => ids.Contains(e.Id));
             return repo.Include(query, inclusionChain).ToList();
         }
 
-        IResourceReadRepository<TEntity, TId> GetRepository<TEntity, TId>() where TEntity : class, IIdentifiable<TId>
+        IResourceReadRepository<TResource, TId> GetRepository<TResource, TId>() where TResource : class, IIdentifiable<TId>
         {
-            return _genericProcessorFactory.GetProcessor<IResourceReadRepository<TEntity, TId>>(typeof(IResourceReadRepository<,>), typeof(TEntity), typeof(TId));
+            return _genericProcessorFactory.GetProcessor<IResourceReadRepository<TResource, TId>>(typeof(IResourceReadRepository<,>), typeof(TResource), typeof(TId));
         }
 
 
diff --git a/src/JsonApiDotNetCore/Hooks/Execution/RelationshipsDictionary.cs b/src/JsonApiDotNetCore/Hooks/Execution/RelationshipsDictionary.cs
@@ -87,7 +87,7 @@ public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<T
         /// <inheritdoc />
         public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship(Type relatedType)
         {
-            return this.Where(p => p.Key.DependentType == relatedType).ToDictionary(p => p.Key, p => p.Value);
+            return this.Where(p => p.Key.RightType == relatedType).ToDictionary(p => p.Key, p => p.Value);
         }
 
         /// <inheritdoc />
diff --git a/src/JsonApiDotNetCore/Hooks/ResourceHookExecutor.cs b/src/JsonApiDotNetCore/Hooks/ResourceHookExecutor.cs
@@ -215,10 +215,10 @@ void Traverse(NodeLayer currentLayer, ResourceHook target, Action<IResourceHookC
         void RecursiveBeforeRead(List<RelationshipAttribute> relationshipChain, ResourcePipeline pipeline, List<PrincipalType> calledContainers)
         {
             var relationship = relationshipChain.First();
-            if (!calledContainers.Contains(relationship.DependentType))
+            if (!calledContainers.Contains(relationship.RightType))
             {
-                calledContainers.Add(relationship.DependentType);
-                var container = _executorHelper.GetResourceHookContainer(relationship.DependentType, ResourceHook.BeforeRead);
+                calledContainers.Add(relationship.RightType);
+                var container = _executorHelper.GetResourceHookContainer(relationship.RightType, ResourceHook.BeforeRead);
                 if (container != null)
                     CallHook(container, ResourceHook.BeforeRead, new object[] { pipeline, true, null });
             }
@@ -306,7 +306,7 @@ void FireNestedBeforeUpdateHooks(ResourcePipeline pipeline, NodeLayer layer)
                     /// the root layer is ALWAYS homogenous, so we safely assume 
                     /// that for every relationship to the previous layer, the 
                     /// principal type is the same.
-                    PrincipalType principalEntityType = currenEntitiesGrouped.First().Key.PrincipalType;
+                    PrincipalType principalEntityType = currenEntitiesGrouped.First().Key.LeftType;
                     FireForAffectedImplicits(principalEntityType, currentEntitiesGroupedInverse, pipeline);
                 }
             }
@@ -403,8 +403,8 @@ Dictionary<RelationshipAttribute, IEnumerable> ReplaceWithDbValues(Dictionary<Re
         {
             foreach (var key in prevLayerRelationships.Keys.ToList())
             {
-                var replaced = prevLayerRelationships[key].Cast<IIdentifiable>().Select(entity => dbValues.Single(dbEntity => dbEntity.StringId == entity.StringId)).Cast(key.PrincipalType);
-                prevLayerRelationships[key] = TypeHelper.CreateHashSetFor(key.PrincipalType, replaced);
+                var replaced = prevLayerRelationships[key].Cast<IIdentifiable>().Select(entity => dbValues.Single(dbEntity => dbEntity.StringId == entity.StringId)).Cast(key.LeftType);
+                prevLayerRelationships[key] = TypeHelper.CreateHashSetFor(key.LeftType, replaced);
             }
             return prevLayerRelationships;
         }
diff --git a/src/JsonApiDotNetCore/Hooks/Traversal/RelationshipProxy.cs b/src/JsonApiDotNetCore/Hooks/Traversal/RelationshipProxy.cs
@@ -31,7 +31,7 @@ public class RelationshipProxy
         /// Identifiable) or it is the righthand side (when the jointable is not identifiable)
         /// </summary>
         public Type DependentType { get; private set; }
-        public Type PrincipalType { get { return Attribute.PrincipalType; } }
+        public Type PrincipalType { get { return Attribute.LeftType; } }
         public bool IsContextRelation { get; private set; }
 
         public RelationshipAttribute Attribute { get; set; }
diff --git a/src/JsonApiDotNetCore/Hooks/Traversal/TraversalHelper.cs b/src/JsonApiDotNetCore/Hooks/Traversal/TraversalHelper.cs
@@ -270,7 +270,7 @@ DependentType GetDependentTypeFromRelationship(RelationshipAttribute attr)
             {
                 return throughAttr.ThroughType;
             }
-            return attr.DependentType;
+            return attr.RightType;
         }
 
         void AddToRelationshipGroup(Dictionary<RelationshipProxy, List<IIdentifiable>> target, RelationshipProxy proxy, IEnumerable<IIdentifiable> newEntities)
diff --git a/src/JsonApiDotNetCore/Models/Annotation/HasManyThroughAttribute.cs b/src/JsonApiDotNetCore/Models/Annotation/HasManyThroughAttribute.cs
@@ -85,14 +85,14 @@ public override object GetValue(object entity)
 
             if (throughEntities == null)
                 // return an empty list for the right-type of the property.
-                return TypeHelper.CreateListFor(DependentType);
+                return TypeHelper.CreateListFor(RightType);
 
             // the right entities are included on the navigation/through entities. Extract and return them.
             var rightEntities = new List<IIdentifiable>();
             foreach (var rightEntity in (IList)throughEntities)
                 rightEntities.Add((IIdentifiable)RightProperty.GetValue(rightEntity));
 
-            return rightEntities.Cast(DependentType);
+            return rightEntities.Cast(RightType);
         }
 
 
diff --git a/src/JsonApiDotNetCore/Models/Annotation/RelationshipAttribute.cs b/src/JsonApiDotNetCore/Models/Annotation/RelationshipAttribute.cs
@@ -23,19 +23,6 @@ protected RelationshipAttribute(string publicName, Link relationshipLinks, bool
         public string InternalRelationshipName { get; internal set; }
         public string InverseNavigation { get; internal set; }
 
-        /// <summary>
-        /// The related entity type. This does not necessarily match the navigation property type.
-        /// In the case of a HasMany relationship, this value will be the generic argument type.
-        /// </summary>
-        /// 
-        /// <example>
-        /// <code>
-        /// public List&lt;Tag&gt; Tags { get; sit; } // Type => Tag
-        /// </code>
-        /// </example>
-        [Obsolete("Use property DependentType")]
-        public Type Type { get { return DependentType; } internal set { DependentType = value; } }
-
         /// <summary>
         /// The related entity type. This does not necessarily match the navigation property type.
         /// In the case of a HasMany relationship, this value will be the generic argument type.
@@ -48,12 +35,12 @@ protected RelationshipAttribute(string publicName, Link relationshipLinks, bool
         /// public List&lt;Tag&gt; Tags { get; set; } // Type => Tag
         /// </code>
         /// </example>
-        public Type DependentType { get; internal set; }
+        public Type RightType { get; internal set; }
 
         /// <summary>
         /// The parent entity type. The technical language as used in EF Core is used here (dependent vs principal).
         /// </summary>
-        public Type PrincipalType { get; internal set; }
+        public Type LeftType { get; internal set; }
 
         public bool IsHasMany => GetType() == typeof(HasManyAttribute) || GetType().Inherits(typeof(HasManyAttribute));
         public bool IsHasOne => GetType() == typeof(HasOneAttribute);
@@ -84,9 +71,9 @@ public override bool Equals(object obj)
             bool equalRelationshipName = PublicRelationshipName.Equals(attr.PublicRelationshipName);
 
             bool equalPrincipalType = true;
-            if (PrincipalType != null)
+            if (LeftType != null)
             {
-                equalPrincipalType = PrincipalType.Equals(attr.PrincipalType);
+                equalPrincipalType = LeftType.Equals(attr.LeftType);
             }
             return IsHasMany == attr.IsHasMany && equalRelationshipName && equalPrincipalType;
         }
diff --git a/src/JsonApiDotNetCore/QueryParameterServices/Common/QueryParameterService.cs b/src/JsonApiDotNetCore/QueryParameterServices/Common/QueryParameterService.cs
@@ -48,7 +48,7 @@ protected AttrAttribute GetAttribute(string target, RelationshipAttribute relati
         {
             AttrAttribute attribute;
             if (relationship != null)
-                attribute = _resourceGraph.GetAttributes(relationship.DependentType).FirstOrDefault(a => a.Is(target));
+                attribute = _resourceGraph.GetAttributes(relationship.RightType).FirstOrDefault(a => a.Is(target));
             else
                 attribute = _requestResource.Attributes.FirstOrDefault(attr => attr.Is(target));
 
diff --git a/src/JsonApiDotNetCore/QueryParameterServices/IncludeService.cs b/src/JsonApiDotNetCore/QueryParameterServices/IncludeService.cs
@@ -52,7 +52,7 @@ private void ParseChain(string chain)
                     throw CannotIncludeError(resourceContext, relationshipName);
 
                 parsedChain.Add(relationship);
-                resourceContext = _resourceGraph.GetResourceContext(relationship.DependentType);
+                resourceContext = _resourceGraph.GetResourceContext(relationship.RightType);
             }
             _includedChains.Add(parsedChain);
         }
diff --git a/src/JsonApiDotNetCore/QueryParameterServices/SparseFieldsService.cs b/src/JsonApiDotNetCore/QueryParameterServices/SparseFieldsService.cs
@@ -39,7 +39,7 @@ public List<AttrAttribute> Get(RelationshipAttribute relationship = null)
             _selectedRelationshipFields.TryGetValue(relationship, out var fields);
             return fields;
         }
-        
+
         /// <inheritdoc/>
         public virtual void Parse(KeyValuePair<string, StringValues> queryParameter)
         {   // expected: articles?fields=prop1,prop2
@@ -83,10 +83,10 @@ public virtual void Parse(KeyValuePair<string, StringValues> queryParameter)
         /// </summary>
         private void RegisterRelatedResourceField(string field, RelationshipAttribute relationship)
         {
-            var relationProperty = _resourceGraph.GetResourceContext(relationship.DependentType);
+            var relationProperty = _resourceGraph.GetResourceContext(relationship.RightType);
             var attr = relationProperty.Attributes.SingleOrDefault(a => a.Is(field));
             if (attr == null)
-                throw new JsonApiException(400, $"'{relationship.DependentType.Name}' does not contain '{field}'.");
+                throw new JsonApiException(400, $"'{relationship.RightType.Name}' does not contain '{field}'.");
 
             if (!_selectedRelationshipFields.TryGetValue(relationship, out var registeredFields))
                 _selectedRelationshipFields.Add(relationship, registeredFields = new List<AttrAttribute>());
diff --git a/src/JsonApiDotNetCore/Serialization/Client/ResponseDeserializer.cs b/src/JsonApiDotNetCore/Serialization/Client/ResponseDeserializer.cs
@@ -71,7 +71,7 @@ protected override void AfterProcessField(IIdentifiable entity, IResourceField f
             }
             else if (field is HasManyAttribute hasManyAttr)
             {  // add attributes and relationships of a parsed HasMany relationship
-                var values = TypeHelper.CreateListFor(hasManyAttr.DependentType);
+                var values = TypeHelper.CreateListFor(hasManyAttr.RightType);
                 foreach (var rio in data.ManyData)
                     values.Add(ParseIncludedRelationship(hasManyAttr, rio));
 
@@ -84,7 +84,7 @@ protected override void AfterProcessField(IIdentifiable entity, IResourceField f
         /// </summary>
         private IIdentifiable ParseIncludedRelationship(RelationshipAttribute relationshipAttr, ResourceIdentifierObject relatedResourceIdentifier)
         {
-            var relatedInstance = relationshipAttr.DependentType.New<IIdentifiable>();
+            var relatedInstance = relationshipAttr.RightType.New<IIdentifiable>();
             relatedInstance.StringId = relatedResourceIdentifier.Id;
 
             var includedResource = GetLinkedResource(relatedResourceIdentifier);
@@ -93,7 +93,7 @@ private IIdentifiable ParseIncludedRelationship(RelationshipAttribute relationsh
 
             var contextEntity = _provider.GetResourceContext(relatedResourceIdentifier.Type);
             if (contextEntity == null)
-                throw new InvalidOperationException($"Included type '{relationshipAttr.DependentType}' is not a registered json:api resource.");
+                throw new InvalidOperationException($"Included type '{relationshipAttr.RightType}' is not a registered json:api resource.");
 
             SetAttributes(relatedInstance, includedResource.Attributes, contextEntity.Attributes);
             SetRelationships(relatedInstance, includedResource.Relationships, contextEntity.Relationships);
diff --git a/src/JsonApiDotNetCore/Serialization/Common/BaseDocumentParser.cs b/src/JsonApiDotNetCore/Serialization/Common/BaseDocumentParser.cs
@@ -213,7 +213,7 @@ private void SetNavigation(IIdentifiable entity, HasOneAttribute attr, string re
             }
             else
             {
-                var relatedInstance = attr.DependentType.New<IIdentifiable>();
+                var relatedInstance = attr.RightType.New<IIdentifiable>();
                 relatedInstance.StringId = relatedId;
                 attr.SetValue(entity, relatedInstance);
             }
@@ -230,11 +230,11 @@ private object SetHasManyRelationship(IIdentifiable entity,
             {   // if the relationship is set to null, no need to set the navigation property to null: this is the default value.
                 var relatedResources = relationshipData.ManyData.Select(rio =>
                 {
-                    var relatedInstance = attr.DependentType.New<IIdentifiable>();
+                    var relatedInstance = attr.RightType.New<IIdentifiable>();
                     relatedInstance.StringId = rio.Id;
                     return relatedInstance;
                 });
-                var convertedCollection = TypeHelper.ConvertCollection(relatedResources, attr.DependentType);
+                var convertedCollection = TypeHelper.ConvertCollection(relatedResources, attr.RightType);
                 attr.SetValue(entity, convertedCollection);
             }
 
diff --git a/src/JsonApiDotNetCore/Serialization/Server/ResponseSerializerFactory.cs b/src/JsonApiDotNetCore/Serialization/Server/ResponseSerializerFactory.cs
@@ -44,7 +44,7 @@ public IJsonApiSerializer GetSerializer()
         private Type GetDocumentPrimaryType()
         {
             if (_currentRequest.RequestRelationship != null && !_currentRequest.IsRelationshipPath)
-                return _currentRequest.RequestRelationship.DependentType;
+                return _currentRequest.RequestRelationship.RightType;
 
             return _currentRequest.GetRequestResource()?.ResourceType;
         }
diff --git a/test/UnitTests/Builders/LinkBuilderTests.cs b/test/UnitTests/Builders/LinkBuilderTests.cs
diff --git a/test/UnitTests/ResourceHooks/AffectedEntitiesHelperTests.cs b/test/UnitTests/ResourceHooks/AffectedEntitiesHelperTests.cs
diff --git a/test/UnitTests/ResourceHooks/ResourceHooksTestsSetup.cs b/test/UnitTests/ResourceHooks/ResourceHooksTestsSetup.cs
diff --git a/test/UnitTests/Serialization/Server/IncludedResourceObjectBuilderTests.cs b/test/UnitTests/Serialization/Server/IncludedResourceObjectBuilderTests.cs

Original file line number	Diff line number	Diff line change
`@@ -71,9 +71,9 @@ public IResourceHookContainer GetResourceHookContainer(DependentType dependentTy`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`/// <inheritdoc/>`
`74`		`- public IResourceHookContainer<TEntity> GetResourceHookContainer<TEntity>(ResourceHook hook = ResourceHook.None) where TEntity : class, IIdentifiable`
	`74`	`+ public IResourceHookContainer<TResource> GetResourceHookContainer<TResource>(ResourceHook hook = ResourceHook.None) where TResource : class, IIdentifiable`
`75`	`75`	`{`
`76`		`- return (IResourceHookContainer<TEntity>)GetResourceHookContainer(typeof(TEntity), hook);`
	`76`	`+ return (IResourceHookContainer<TResource>)GetResourceHookContainer(typeof(TResource), hook);`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerable entities, ResourceHook hook, params RelationshipAttribute[] inclusionChain)`
`@@ -89,12 +89,12 @@ public IEnumerable LoadDbValues(PrincipalType entityTypeForRepository, IEnumerab`
`89`	`89`	`return (IEnumerable)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(entityTypeForRepository), values.Cast(entityTypeForRepository));`
`90`	`90`	`}`
`91`	`91`
`92`		`- public HashSet<TEntity> LoadDbValues<TEntity>(IEnumerable<TEntity> entities, ResourceHook hook, params RelationshipAttribute[] relationships) where TEntity : class, IIdentifiable`
	`92`	`+ public HashSet<TResource> LoadDbValues<TResource>(IEnumerable<TResource> entities, ResourceHook hook, params RelationshipAttribute[] relationships) where TResource : class, IIdentifiable`
`93`	`93`	`{`
`94`		`- var entityType = typeof(TEntity);`
`95`		`- var dbValues = LoadDbValues(entityType, entities, hook, relationships)?.Cast<TEntity>();`
	`94`	`+ var entityType = typeof(TResource);`
	`95`	`+ var dbValues = LoadDbValues(entityType, entities, hook, relationships)?.Cast<TResource>();`
`96`	`96`	`if (dbValues == null) return null;`
`97`		`- return new HashSet<TEntity>(dbValues);`
	`97`	`+ return new HashSet<TResource>(dbValues);`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`public bool ShouldLoadDbValues(Type entityType, ResourceHook hook)`
`@@ -131,16 +131,16 @@ IHooksDiscovery GetHookDiscovery(Type entityType)`
`131`	`131`	`return discovery;`
`132`	`132`	`}`
`133`	`133`
`134`		`- IEnumerable<TEntity> GetWhereAndInclude<TEntity, TId>(IEnumerable<TId> ids, RelationshipAttribute[] inclusionChain) where TEntity : class, IIdentifiable<TId>`
	`134`	`+ IEnumerable<TResource> GetWhereAndInclude<TResource, TId>(IEnumerable<TId> ids, RelationshipAttribute[] inclusionChain) where TResource : class, IIdentifiable<TId>`
`135`	`135`	`{`
`136`		`- var repo = GetRepository<TEntity, TId>();`
	`136`	`+ var repo = GetRepository<TResource, TId>();`
`137`	`137`	`var query = repo.Get().Where(e => ids.Contains(e.Id));`
`138`	`138`	`return repo.Include(query, inclusionChain).ToList();`
`139`	`139`	`}`
`140`	`140`
`141`		`- IResourceReadRepository<TEntity, TId> GetRepository<TEntity, TId>() where TEntity : class, IIdentifiable<TId>`
	`141`	`+ IResourceReadRepository<TResource, TId> GetRepository<TResource, TId>() where TResource : class, IIdentifiable<TId>`
`142`	`142`	`{`
`143`		`- return _genericProcessorFactory.GetProcessor<IResourceReadRepository<TEntity, TId>>(typeof(IResourceReadRepository<,>), typeof(TEntity), typeof(TId));`
	`143`	`+ return _genericProcessorFactory.GetProcessor<IResourceReadRepository<TResource, TId>>(typeof(IResourceReadRepository<,>), typeof(TResource), typeof(TId));`
`144`	`144`	`}`
`145`	`145`
`146`	`146`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship<T`
`87`	`87`	`/// <inheritdoc />`
`88`	`88`	`public Dictionary<RelationshipAttribute, HashSet<TResource>> GetByRelationship(Type relatedType)`
`89`	`89`	`{`
`90`		`- return this.Where(p => p.Key.DependentType == relatedType).ToDictionary(p => p.Key, p => p.Value);`
	`90`	`+ return this.Where(p => p.Key.RightType == relatedType).ToDictionary(p => p.Key, p => p.Value);`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`/// <inheritdoc />`
Original file line number	Diff line number	Diff line change
`@@ -215,10 +215,10 @@ void Traverse(NodeLayer currentLayer, ResourceHook target, Action<IResourceHookC`
`215`	`215`	`void RecursiveBeforeRead(List<RelationshipAttribute> relationshipChain, ResourcePipeline pipeline, List<PrincipalType> calledContainers)`
`216`	`216`	`{`
`217`	`217`	`var relationship = relationshipChain.First();`
`218`		`- if (!calledContainers.Contains(relationship.DependentType))`
	`218`	`+ if (!calledContainers.Contains(relationship.RightType))`
`219`	`219`	`{`
`220`		`- calledContainers.Add(relationship.DependentType);`
`221`		`- var container = _executorHelper.GetResourceHookContainer(relationship.DependentType, ResourceHook.BeforeRead);`
	`220`	`+ calledContainers.Add(relationship.RightType);`
	`221`	`+ var container = _executorHelper.GetResourceHookContainer(relationship.RightType, ResourceHook.BeforeRead);`
`222`	`222`	`if (container != null)`
`223`	`223`	`CallHook(container, ResourceHook.BeforeRead, new object[] { pipeline, true, null });`
`224`	`224`	`}`
`@@ -306,7 +306,7 @@ void FireNestedBeforeUpdateHooks(ResourcePipeline pipeline, NodeLayer layer)`
`306`	`306`	`/// the root layer is ALWAYS homogenous, so we safely assume`
`307`	`307`	`/// that for every relationship to the previous layer, the`
`308`	`308`	`/// principal type is the same.`
`309`		`- PrincipalType principalEntityType = currenEntitiesGrouped.First().Key.PrincipalType;`
	`309`	`+ PrincipalType principalEntityType = currenEntitiesGrouped.First().Key.LeftType;`
`310`	`310`	`FireForAffectedImplicits(principalEntityType, currentEntitiesGroupedInverse, pipeline);`
`311`	`311`	`}`
`312`	`312`	`}`
`@@ -403,8 +403,8 @@ Dictionary<RelationshipAttribute, IEnumerable> ReplaceWithDbValues(Dictionary<Re`
`403`	`403`	`{`
`404`	`404`	`foreach (var key in prevLayerRelationships.Keys.ToList())`
`405`	`405`	`{`
`406`		`- var replaced = prevLayerRelationships[key].Cast<IIdentifiable>().Select(entity => dbValues.Single(dbEntity => dbEntity.StringId == entity.StringId)).Cast(key.PrincipalType);`
`407`		`- prevLayerRelationships[key] = TypeHelper.CreateHashSetFor(key.PrincipalType, replaced);`
	`406`	`+ var replaced = prevLayerRelationships[key].Cast<IIdentifiable>().Select(entity => dbValues.Single(dbEntity => dbEntity.StringId == entity.StringId)).Cast(key.LeftType);`
	`407`	`+ prevLayerRelationships[key] = TypeHelper.CreateHashSetFor(key.LeftType, replaced);`
`408`	`408`	`}`
`409`	`409`	`return prevLayerRelationships;`
`410`	`410`	`}`
Original file line number	Diff line number	Diff line change
`@@ -270,7 +270,7 @@ DependentType GetDependentTypeFromRelationship(RelationshipAttribute attr)`
`270`	`270`	`{`
`271`	`271`	`return throughAttr.ThroughType;`
`272`	`272`	`}`
`273`		`- return attr.DependentType;`
	`273`	`+ return attr.RightType;`
`274`	`274`	`}`
`275`	`275`
`276`	`276`	`void AddToRelationshipGroup(Dictionary<RelationshipProxy, List<IIdentifiable>> target, RelationshipProxy proxy, IEnumerable<IIdentifiable> newEntities)`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ protected AttrAttribute GetAttribute(string target, RelationshipAttribute relati`
`48`	`48`	`{`
`49`	`49`	`AttrAttribute attribute;`
`50`	`50`	`if (relationship != null)`
`51`		`- attribute = _resourceGraph.GetAttributes(relationship.DependentType).FirstOrDefault(a => a.Is(target));`
	`51`	`+ attribute = _resourceGraph.GetAttributes(relationship.RightType).FirstOrDefault(a => a.Is(target));`
`52`	`52`	`else`
`53`	`53`	`attribute = _requestResource.Attributes.FirstOrDefault(attr => attr.Is(target));`
`54`	`54`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ private void ParseChain(string chain)`
`52`	`52`	`throw CannotIncludeError(resourceContext, relationshipName);`
`53`	`53`
`54`	`54`	`parsedChain.Add(relationship);`
`55`		`- resourceContext = _resourceGraph.GetResourceContext(relationship.DependentType);`
	`55`	`+ resourceContext = _resourceGraph.GetResourceContext(relationship.RightType);`
`56`	`56`	`}`
`57`	`57`	`_includedChains.Add(parsedChain);`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -213,7 +213,7 @@ private void SetNavigation(IIdentifiable entity, HasOneAttribute attr, string re`
`213`	`213`	`}`
`214`	`214`	`else`
`215`	`215`	`{`
`216`		`- var relatedInstance = attr.DependentType.New<IIdentifiable>();`
	`216`	`+ var relatedInstance = attr.RightType.New<IIdentifiable>();`
`217`	`217`	`relatedInstance.StringId = relatedId;`
`218`	`218`	`attr.SetValue(entity, relatedInstance);`
`219`	`219`	`}`
`@@ -230,11 +230,11 @@ private object SetHasManyRelationship(IIdentifiable entity,`
`230`	`230`	`{ // if the relationship is set to null, no need to set the navigation property to null: this is the default value.`
`231`	`231`	`var relatedResources = relationshipData.ManyData.Select(rio =>`
`232`	`232`	`{`
`233`		`- var relatedInstance = attr.DependentType.New<IIdentifiable>();`
	`233`	`+ var relatedInstance = attr.RightType.New<IIdentifiable>();`
`234`	`234`	`relatedInstance.StringId = rio.Id;`
`235`	`235`	`return relatedInstance;`
`236`	`236`	`});`
`237`		`- var convertedCollection = TypeHelper.ConvertCollection(relatedResources, attr.DependentType);`
	`237`	`+ var convertedCollection = TypeHelper.ConvertCollection(relatedResources, attr.RightType);`
`238`	`238`	`attr.SetValue(entity, convertedCollection);`
`239`	`239`	`}`
`240`	`240`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public IJsonApiSerializer GetSerializer()`
`44`	`44`	`private Type GetDocumentPrimaryType()`
`45`	`45`	`{`
`46`	`46`	`if (_currentRequest.RequestRelationship != null && !_currentRequest.IsRelationshipPath)`
`47`		`- return _currentRequest.RequestRelationship.DependentType;`
	`47`	`+ return _currentRequest.RequestRelationship.RightType;`
`48`	`48`
`49`	`49`	`return _currentRequest.GetRequestResource()?.ResourceType;`
`50`	`50`	`}`