style: DependentType, PrincipalType --> RightType, LeftType

Author: maurei

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}");
                 }
             }
 

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}'");

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));
         }
 
 

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 />

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;
         }

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; }

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)

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);
         }
 
 

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;
         }

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));
 

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);
         }

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>());

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);

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);
             }
 

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;
         }