Projectable{TQueried,TResult}.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.EntityFrameworkCore;
 
using Tgstation.Server.Api.Models;
 
namespace Tgstation.Server.Host.Authority.Core
{
    public sealed class Projectable<TQueried, TResult>
        where TQueried : EntityId
        where TResult : notnull
    {
        readonly IQueryable<TQueried> query;
 
        readonly Expression<Func<ProjectedPair<TQueried, TResult>, ProjectedPair<object?, TResult>>> selector;
 
        readonly Func<ProjectedPair<object?, TResult>?, AuthorityResponse<TResult>> resultMapper;
 
        readonly CancellationToken cancellationToken;
 
        public static async ValueTask<Dictionary<long, AuthorityResponse<TResult>>> Combine(Func<IQueryable<TQueried>, IQueryable<ProjectedPair<TQueried, TResult>>> projection, params Projectable<TQueried, TResult>[] inputs)
        {
            ArgumentNullException.ThrowIfNull(projection);
            ArgumentNullException.ThrowIfNull(inputs);
 
            if (inputs.Length == 0)
                return new Dictionary<long, AuthorityResponse<TResult>>();
 
            var firstProjectable = inputs[0];
            var workingSet = projection(firstProjectable.query);
            foreach (var projectable in inputs.Skip(1))
            {
                if (firstProjectable.resultMapper != projectable.resultMapper)
                    throw new InvalidOperationException($"Different implementations of {nameof(resultMapper)} in combined {firstProjectable.GetType().Name}.");
                if (firstProjectable.selector != projectable.selector)
                    throw new InvalidOperationException($"Different implementations of {nameof(selector)} in combined {firstProjectable.GetType().Name}.");
 
                workingSet = workingSet.Union(projection(projectable.query));
            }
 
            using var cts = CancellationTokenSource.CreateLinkedTokenSource(inputs.Select(projectable => projectable.cancellationToken).ToArray());
            var finalQueryable = workingSet
                .Select(CombinedProjectionExpression(firstProjectable.selector));
 
            return await finalQueryable
                .ToDictionaryAsync(
                    result => result.Id,
                    result => firstProjectable.resultMapper(result.Projected));
        }
 
        public static Projectable<TQueried, TResult> Create(
            IQueryable<TQueried> query,
            Func<ProjectedPair<object?, TResult>?, AuthorityResponse<TResult>> resultMapper,
            CancellationToken cancellationToken)
            => Create(
                query,
                projected => new ProjectedPair<object?, TResult>
                {
                    Queried = null,
                    Result = projected.Result,
                },
                resultMapper,
                cancellationToken);
 
        public static Projectable<TQueried, TResult> Create<TSelection>(
            IQueryable<TQueried> query,
            Expression<Func<ProjectedPair<TQueried, TResult>, ProjectedPair<TSelection, TResult>>> selector,
            Func<ProjectedPair<TSelection, TResult>?, AuthorityResponse<TResult>> resultMapper,
            CancellationToken cancellationToken)
        {
            Expression<Func<ProjectedPair<TSelection, TResult>, ProjectedPair<object?, TResult>>> makeProjectedGeneric = projected => new ProjectedPair<object?, TResult>
            {
                Queried = projected.Queried,
                Result = projected.Result,
            };
 
            var parameter = Expression.Parameter(typeof(ProjectedPair<TQueried, TResult>), "innerProjectedParam");
            return new(
                query,
                Expression.Lambda<Func<ProjectedPair<TQueried, TResult>, ProjectedPair<object?, TResult>>>(
                    Expression.Invoke(
                        makeProjectedGeneric,
                        Expression.Invoke(
                            selector,
                            parameter)),
                    parameter),
                projected => resultMapper(
                    projected != null
                        ? new ProjectedPair<TSelection, TResult>
                        {
                            Queried = (TSelection)projected.Queried!,
                            Result = projected.Result,
                        }
                        : null),
                cancellationToken);
        }
 
        private static Expression<Func<ProjectedPair<TQueried, TResult>, CombinedProjection>> CombinedProjectionExpression(Expression<Func<ProjectedPair<TQueried, TResult>, ProjectedPair<object?, TResult>>> selector)
        {
            Expression<Func<ProjectedPair<TQueried, TResult>, long>> idSelector = projected => projected.Queried.Id!.Value;
 
            var parameter = Expression.Parameter(typeof(ProjectedPair<TQueried, TResult>), "projectedParamForCombined");
            var selection = Expression.Invoke(selector, parameter);
            var id = Expression.Invoke(idSelector, parameter);
 
            var ourType = typeof(CombinedProjection);
 
            var memberInitExpr = Expression.MemberInit(
                Expression.New(ourType),
                Expression.Bind(
                    ourType.GetProperty(nameof(CombinedProjection.Id))!,
                    id),
                Expression.Bind(
                    ourType.GetProperty(nameof(CombinedProjection.Projected))!,
                    selection));
 
            var finalExpr = Expression.Lambda<Func<ProjectedPair<TQueried, TResult>, CombinedProjection>>(memberInitExpr, parameter);
 
            return finalExpr;
        }
 
        private Projectable(
            IQueryable<TQueried> query,
            Expression<Func<ProjectedPair<TQueried, TResult>, ProjectedPair<object?, TResult>>> selector,
            Func<ProjectedPair<object?, TResult>?, AuthorityResponse<TResult>> resultMapper,
            CancellationToken cancellationToken)
        {
            this.query = query ?? throw new ArgumentNullException(nameof(query));
            this.selector = selector ?? throw new ArgumentNullException(nameof(selector));
            this.resultMapper = resultMapper ?? throw new ArgumentNullException(nameof(resultMapper));
            this.cancellationToken = cancellationToken;
        }
 
        public async ValueTask<AuthorityResponse<TResult>> Resolve(Func<IQueryable<TQueried>, IQueryable<ProjectedPair<TQueried, TResult>>> projection)
        {
            ArgumentNullException.ThrowIfNull(projection);
            var selection = await projection(query)
                .Select(selector)
                .FirstOrDefaultAsync(cancellationToken);
            return resultMapper(selection);
        }
 
        private class CombinedProjection
        {
            public required long Id { get; init; }
 
            public required ProjectedPair<object?, TResult> Projected { get; init; }
        }
    }
}