Add NoSqlResourceService

This commit adds the NoSqlResourceService and related classes and interfaces:

- NoSqlServiceCollectionExtensions: Used in Startup to add injectables
- INoSqlQueryLayerComposer: Defines the NoSQL QueryLayer composer contract
- NoSqlQueryLayerComposer: Implements the NoSQL QueryLayer composer
- NoSqlHasForeignKeyAttribute: Adds foreign key information to navigation properties
- NoSqlOwnsManyAttribute: Identifies relationships as owned
- NoSqlResourceAttribute: Identifies NoSQL resources (as opposed to owned entities)

Author: ThomasBarnekow

src/JsonApiDotNetCore/Configuration/NoSqlServiceCollectionExtensions.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Queries;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JsonApiDotNetCore.Configuration
+{
+    /// <summary>
+    /// Provides extension methods for the registration of services and other injectables
+    /// with the service container.
+    /// </summary>
+    [PublicAPI]
+    public static class NoSqlServiceCollectionExtensions
+    {
+        /// <summary>
+        /// For each resource annotated with the <see cref="NoSqlResourceAttribute" />, adds a
+        /// scoped service with a service type of <see cref="IResourceService{TResource, TId}" />
+        /// and an implementation type of <see cref="NoSqlResourceService{TResource,TId}" />.
+        /// </summary>
+        /// <param name="services">The <see cref="IServiceCollection" />.</param>
+        /// <returns>The <see cref="IServiceCollection" />.</returns>
+        public static IServiceCollection AddNoSqlResourceServices(this IServiceCollection services)
+        {
+            return services.AddNoSqlResourceServices(Assembly.GetCallingAssembly());
+        }
+
+        /// <summary>
+        /// For each resource annotated with the <see cref="NoSqlResourceAttribute" />, adds a
+        /// scoped service with a service type of <see cref="IResourceService{TResource, TId}" />
+        /// and an implementation type of <see cref="NoSqlResourceService{TResource,TId}" />.
+        /// </summary>
+        /// <param name="services">The <see cref="IServiceCollection" />.</param>
+        /// <param name="assembly">The <see cref="Assembly" /> containing the annotated resources.</param>
+        /// <returns>The <see cref="IServiceCollection" />.</returns>
+        public static IServiceCollection AddNoSqlResourceServices(this IServiceCollection services, Assembly assembly)
+        {
+            services.AddScoped<INoSqlQueryLayerComposer, NoSqlQueryLayerComposer>();
+
+            foreach (Type resourceType in assembly.ExportedTypes.Where(IsNoSqlResource))
+            {
+                if (TryGetIdType(resourceType, out Type? idType))
+                {
+                    services.AddScoped(
+                        typeof(IResourceService<,>).MakeGenericType(resourceType, idType),
+                        typeof(NoSqlResourceService<,>).MakeGenericType(resourceType, idType));
+                }
+            }
+
+            return services;
+        }
+
+        private static bool IsNoSqlResource(Type type)
+        {
+            return Attribute.GetCustomAttribute(type, typeof(NoSqlResourceAttribute)) is not null &&
+                   type.GetInterfaces().Any(IsGenericIIdentifiable);
+        }
+
+        private static bool IsGenericIIdentifiable(Type type)
+        {
+            return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IIdentifiable<>);
+        }
+
+        private static bool TryGetIdType(Type resourceType, [NotNullWhen(true)] out Type? idType)
+        {
+            Type? identifiableInterface = resourceType.GetInterfaces().FirstOrDefault(IsGenericIIdentifiable);
+            idType = identifiableInterface?.GetGenericArguments()[0];
+            return idType is not null;
+        }
+    }
+}

src/JsonApiDotNetCore/Queries/INoSqlQueryLayerComposer.cs

@@ -0,0 +1,69 @@
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Queries.Expressions;
+
+namespace JsonApiDotNetCore.Queries
+{
+    /// <summary>
+    /// Takes scoped expressions from <see cref="IQueryConstraintProvider" />s and transforms them.
+    /// Additionally provides specific transformations for NoSQL databases without support for joins.
+    /// </summary>
+    [PublicAPI]
+    public interface INoSqlQueryLayerComposer
+    {
+        /// <summary>
+        /// Builds a filter from constraints, used to determine total resource count on a primary
+        /// collection endpoint.
+        /// </summary>
+        FilterExpression? GetPrimaryFilterFromConstraintsForNoSql(ResourceType primaryResourceType);
+
+        /// <summary>
+        /// Composes a <see cref="QueryLayer" /> and an <see cref="IncludeExpression" /> from the
+        /// constraints specified by the request. Used for primary resources.
+        /// </summary>
+        (QueryLayer QueryLayer, IncludeExpression Include) ComposeFromConstraintsForNoSql(ResourceType requestResourceType);
+
+        /// <summary>
+        /// Composes a <see cref="QueryLayer" /> and an <see cref="IncludeExpression" /> from the
+        /// constraints specified by the request. Used for primary resources.
+        /// </summary>
+        (QueryLayer QueryLayer, IncludeExpression Include) ComposeForGetByIdWithConstraintsForNoSql<TId>(
+            TId id,
+            ResourceType primaryResourceType,
+            TopFieldSelection fieldSelection)
+            where TId : notnull;
+
+
+        /// <summary>
+        /// Composes a <see cref="QueryLayer" /> with a filter expression in the form "equals(id,'{stringId}')".
+        /// </summary>
+        QueryLayer ComposeForGetByIdForNoSql<TId>(TId id, ResourceType primaryResourceType)
+            where TId : notnull;
+
+        /// <summary>
+        /// Composes a <see cref="QueryLayer" /> from the constraints specified by the request
+        /// and a filter expression in the form "equals({propertyName},'{propertyValue}')".
+        /// Used for secondary or included resources.
+        /// </summary>
+        /// <param name="requestResourceType">The <see cref="ResourceType" /> of the secondary or included resource.</param>
+        /// <param name="propertyName">The name of the property of the secondary or included resource used for filtering.</param>
+        /// <param name="propertyValue">The value of the property of the secondary or included resource used for filtering.</param>
+        /// <param name="isIncluded">
+        /// <see langword="true" />, if the resource is included by the request (e.g., "{url}?include={relationshipName}");
+        /// <see langword="false" />, if the resource is a secondary resource (e.g., "/{primary}/{id}/{relationshipName}").
+        /// </param>
+        /// <returns>A tuple with a <see cref="QueryLayer" /> and an <see cref="IncludeExpression" />.</returns>
+        (QueryLayer QueryLayer, IncludeExpression Include) ComposeFromConstraintsAndFilterForNoSql(
+            ResourceType requestResourceType,
+            string propertyName,
+            string propertyValue,
+            bool isIncluded);
+
+        /// <summary>
+        /// Builds a query that retrieves the primary resource, including all of its attributes
+        /// and all targeted relationships, during a create/update/delete request.
+        /// </summary>
+        (QueryLayer QueryLayer, IncludeExpression Include) ComposeForUpdateForNoSql<TId>(TId id, ResourceType primaryResourceType)
+            where TId : notnull;
+    }
+}

src/JsonApiDotNetCore/Queries/NoSqlQueryLayerComposer.cs

@@ -0,0 +1,199 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using JetBrains.Annotations;
+using JsonApiDotNetCore.Configuration;
+using JsonApiDotNetCore.Queries.Expressions;
+using JsonApiDotNetCore.Queries.Internal;
+using JsonApiDotNetCore.Resources;
+using JsonApiDotNetCore.Resources.Annotations;
+
+namespace JsonApiDotNetCore.Queries
+{
+    /// <summary>
+    /// Default implementation of the <see cref="INoSqlQueryLayerComposer" />.
+    /// </summary>
+    /// <remarks>
+    /// Register <see cref="NoSqlQueryLayerComposer"/> with the service container as
+    /// shown in the following example.
+    /// </remarks>
+    /// <example>
+    /// <code><![CDATA[
+    /// public class Startup
+    /// {
+    ///     public void ConfigureServices(IServiceCollection services)
+    ///     {
+    ///         services.AddNoSqlResourceServices();
+    ///     }
+    /// }
+    /// ]]></code>
+    /// </example>
+    [PublicAPI]
+    public class NoSqlQueryLayerComposer : QueryLayerComposer, INoSqlQueryLayerComposer
+    {
+        private readonly IEnumerable<IQueryConstraintProvider> _constraintProviders;
+        private readonly ITargetedFields _targetedFields;
+
+        public NoSqlQueryLayerComposer(
+            IEnumerable<IQueryConstraintProvider> constraintProviders,
+            IResourceDefinitionAccessor resourceDefinitionAccessor,
+            IJsonApiOptions options,
+            IPaginationContext paginationContext,
+            ITargetedFields targetedFields,
+            IEvaluatedIncludeCache evaluatedIncludeCache,
+            ISparseFieldSetCache sparseFieldSetCache) : base(constraintProviders, resourceDefinitionAccessor, options, paginationContext, targetedFields, evaluatedIncludeCache, sparseFieldSetCache)
+        {
+            _constraintProviders = constraintProviders;
+            _targetedFields = targetedFields;
+        }
+
+        /// <inheritdoc />
+        public FilterExpression? GetPrimaryFilterFromConstraintsForNoSql(ResourceType primaryResourceType)
+        {
+            return GetPrimaryFilterFromConstraints(primaryResourceType);
+        }
+
+        /// <inheritdoc />
+        public (QueryLayer QueryLayer, IncludeExpression Include) ComposeFromConstraintsForNoSql(ResourceType requestResourceType)
+        {
+            QueryLayer queryLayer = ComposeFromConstraints(requestResourceType);
+            IncludeExpression include = queryLayer.Include ?? IncludeExpression.Empty;
+
+            queryLayer.Include = IncludeExpression.Empty;
+            queryLayer.Projection = null;
+
+            return (queryLayer, include);
+        }
+
+        /// <inheritdoc />
+        public (QueryLayer QueryLayer, IncludeExpression Include) ComposeForGetByIdWithConstraintsForNoSql<TId>(
+            TId id,
+            ResourceType primaryResourceType,
+            TopFieldSelection fieldSelection)
+            where TId : notnull
+        {
+            QueryLayer queryLayer = ComposeForGetById(id, primaryResourceType, fieldSelection);
+            IncludeExpression include = queryLayer.Include ?? IncludeExpression.Empty;
+
+            queryLayer.Include = IncludeExpression.Empty;
+            queryLayer.Projection = null;
+
+            return (queryLayer, include);
+        }
+
+        /// <inheritdoc />
+        public QueryLayer ComposeForGetByIdForNoSql<TId>(TId id, ResourceType primaryResourceType)
+            where TId : notnull
+        {
+            return new QueryLayer(primaryResourceType)
+            {
+                Filter = new ComparisonExpression(
+                    ComparisonOperator.Equals,
+                    new ResourceFieldChainExpression(
+                        primaryResourceType.Fields.Single(f => f.Property.Name == nameof(IIdentifiable<TId>.Id))),
+                    new LiteralConstantExpression(id.ToString()!)),
+                Include = IncludeExpression.Empty,
+            };
+        }
+
+        /// <inheritdoc />
+        public (QueryLayer QueryLayer, IncludeExpression Include) ComposeFromConstraintsAndFilterForNoSql(
+            ResourceType requestResourceType,
+            string propertyName,
+            string propertyValue,
+            bool isIncluded)
+        {
+            // Compose a secondary resource filter in the form "equals({propertyName},'{propertyValue}')".
+            FilterExpression[] secondaryResourceFilterExpressions =
+            {
+                ComposeSecondaryResourceFilter(requestResourceType, propertyName, propertyValue),
+            };
+
+            // Get the query expressions from the request.
+            ExpressionInScope[] constraints = _constraintProviders
+                .SelectMany(provider => provider.GetConstraints())
+                .ToArray();
+
+            bool IsQueryLayerConstraint(ExpressionInScope constraint)
+            {
+                return constraint.Expression is not IncludeExpression &&
+                    (!isIncluded || (constraint.Scope is not null &&
+                                     constraint.Scope.Fields.Any(field => field.PublicName == requestResourceType.PublicName)));
+            }
+
+            IEnumerable<QueryExpression> requestQueryExpressions = constraints
+                .Where(IsQueryLayerConstraint)
+                .Select(constraint => constraint.Expression);
+
+            // Combine the secondary resource filter and request query expressions and
+            // create the query layer from the combined query expressions.
+            QueryExpression[] queryExpressions = secondaryResourceFilterExpressions
+                .Concat(requestQueryExpressions)
+                .ToArray();
+
+            var queryLayer = new QueryLayer(requestResourceType)
+            {
+                Include = IncludeExpression.Empty,
+                Filter = GetFilter(queryExpressions, requestResourceType),
+                Sort = GetSort(queryExpressions, requestResourceType),
+                Pagination = GetPagination(queryExpressions, requestResourceType),
+            };
+
+            // Retrieve the IncludeExpression from the constraints collection.
+            // There will be zero or one IncludeExpression, even if multiple include query
+            // parameters were specified in the request. JsonApiDotNetCore combines those
+            // into a single expression.
+            IncludeExpression include = isIncluded
+                ? IncludeExpression.Empty
+                : constraints
+                    .Select(constraint => constraint.Expression)
+                    .OfType<IncludeExpression>()
+                    .DefaultIfEmpty(IncludeExpression.Empty)
+                    .Single();
+
+            return (queryLayer, include);
+        }
+
+        private static FilterExpression ComposeSecondaryResourceFilter(
+            ResourceType resourceType,
+            string propertyName,
+            string properyValue)
+        {
+            return new ComparisonExpression(
+                ComparisonOperator.Equals,
+                new ResourceFieldChainExpression(resourceType.Fields.Single(f => f.Property.Name == propertyName)),
+                new LiteralConstantExpression(properyValue));
+        }
+
+        public (QueryLayer QueryLayer, IncludeExpression Include) ComposeForUpdateForNoSql<TId>(
+            TId id,
+            ResourceType primaryResourceType)
+            where TId : notnull
+        {
+            // Create primary layer without an include expression.
+            AttrAttribute primaryIdAttribute = GetIdAttribute(primaryResourceType);
+            QueryLayer primaryLayer = new(primaryResourceType)
+            {
+                Include = IncludeExpression.Empty,
+                Filter = new ComparisonExpression(
+                    ComparisonOperator.Equals,
+                    new ResourceFieldChainExpression(primaryIdAttribute),
+                    new LiteralConstantExpression(id.ToString()!)),
+            };
+
+            // Create a separate include expression.
+            ImmutableHashSet<IncludeElementExpression> includeElements = _targetedFields.Relationships
+                .Select(relationship => new IncludeElementExpression(relationship))
+                .ToImmutableHashSet();
+
+            IncludeExpression include = includeElements.Any() ? new IncludeExpression(includeElements) : IncludeExpression.Empty;
+
+            return (primaryLayer, include);
+        }
+
+        private static AttrAttribute GetIdAttribute(ResourceType resourceType)
+        {
+            return resourceType.GetAttributeByPropertyName(nameof(Identifiable<object>.Id));
+        }
+    }
+}

src/JsonApiDotNetCore/Resources/Annotations/NoSqlHasForeignKeyAttribute.cs

@@ -0,0 +1,51 @@
+using System;
+using JetBrains.Annotations;
+
+namespace JsonApiDotNetCore.Resources.Annotations
+{
+    /// <summary>
+    /// Used to provide additional information for a JSON:API relationship with a foreign key
+    /// (https://jsonapi.org/format/#document-resource-object-relationships).
+    /// </summary>
+    /// <example>
+    /// <code><![CDATA[
+    /// public class Author : Identifiable<Guid>
+    /// {
+    ///     [HasMany]
+    ///     [NoSqlHasForeignKey(nameof(Article.AuthorId))]
+    ///     public ICollection<Article> Articles { get; set; }
+    /// }
+    ///
+    /// public class Article : Identifiable<Guid>
+    /// {
+    ///     public Guid AuthorId { get; set; }
+    ///
+    ///     [HasOne]
+    ///     [NoSqlHasForeignKey(nameof(AuthorId))]
+    ///     public Author Author { get; set; }
+    /// }
+    /// ]]></code>
+    /// </example>
+    [PublicAPI]
+    [AttributeUsage(AttributeTargets.Property)]
+    public class NoSqlHasForeignKeyAttribute : Attribute
+    {
+        public NoSqlHasForeignKeyAttribute(string propertyName)
+        {
+            PropertyName = propertyName;
+        }
+
+        /// <summary>
+        /// Gets the name of the foreign key property corresponding to the annotated
+        /// navigation property.
+        /// </summary>
+        public string PropertyName { get; private set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the navigation property is on
+        /// the dependent side of the foreign key relationship. The default is
+        /// <see langword="true" />.
+        /// </summary>
+        public bool IsDependent { get; set; } = true;
+    }
+}