< Summary

Information
Class: Api.Works.Queries.AuthorNode
Assembly: Api
File(s): File 1: /home/runner/work/ProjectRead.ing/ProjectRead.ing/Api/obj/Debug/net10.0/generated/HotChocolate.Types.Analyzers/HotChocolate.Types.Analyzers.GraphQLServerGenerator/AuthorNode.UjLSLReKVUsGE0v90fV4zw.hc.g.cs
File 2: /home/runner/work/ProjectRead.ing/ProjectRead.ing/Api/Works/Queries/Author.cs
Line coverage
94%
Covered lines: 107
Uncovered lines: 6
Coverable lines: 113
Total lines: 265
Line coverage: 94.6%
Branch coverage
64%
Covered branches: 9
Total branches: 14
Branch coverage: 64.2%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
File 1: Initialize(...)100%22100%
File 1: GetWorksByAuthor()100%11100%
File 1: GetWorksByAuthor()58.33%121286.96%
File 2: GetWorksByAuthor()100%11100%
File 2: GetByIdAsync()100%11100%

File(s)

/home/runner/work/ProjectRead.ing/ProjectRead.ing/Api/obj/Debug/net10.0/generated/HotChocolate.Types.Analyzers/HotChocolate.Types.Analyzers.GraphQLServerGenerator/AuthorNode.UjLSLReKVUsGE0v90fV4zw.hc.g.cs

#LineLine coverage
 1// <auto-generated/>
 2
 3#nullable enable
 4#pragma warning disable
 5
 6using System;
 7using System.Runtime.CompilerServices;
 8using HotChocolate;
 9using HotChocolate.Types;
 10using HotChocolate.Execution.Configuration;
 11using Microsoft.Extensions.DependencyInjection;
 12using HotChocolate.Internal;
 13
 14namespace Api.Works.Queries
 15{
 16    public static partial class AuthorNode
 17    {
 18        internal static void Initialize(global::HotChocolate.Types.IObjectTypeDescriptor<global::Api.Works.Queries.Autho
 119        {
 120            var extension = descriptor.Extend();
 121            var configuration = extension.Configuration;
 122            var thisType = typeof(global::Api.Works.Queries.AuthorNode);
 123            var bindingResolver = extension.Context.ParameterBindingResolver;
 124            var resolvers = new __Resolvers();
 25
 126            var naming = descriptor.Extend().Context.Naming;
 27
 128            descriptor
 129                .Field(naming.GetMemberName("Works", global::HotChocolate.Types.MemberKind.ObjectField))
 130                .AddPagingArguments()
 131                .ExtendWith(static (field, context) =>
 132                {
 133                    var configuration = field.Configuration;
 134                    var typeInspector = field.Context.TypeInspector;
 135                    var bindingResolver = field.Context.ParameterBindingResolver;
 136                    var naming = field.Context.Naming;
 137
 138                    configuration.Type = typeInspector.GetTypeRef(typeof(global::HotChocolate.Types.NonNullType<global::
 139                    configuration.ResultType = typeof(global::HotChocolate.Types.Pagination.PageConnection<global::Api.W
 140                    configuration.DeclaringType = context.ThisType;
 141
 142                    configuration.SetSourceGeneratorFlags();
 143                    configuration.SetConnectionFlags();
 144                    var pagingOptions = global::HotChocolate.Types.Pagination.PagingHelper.GetPagingOptions(field.Contex
 145                    configuration.Features.Set(pagingOptions);
 146
 147                    configuration.Member = context.ThisType.GetMethod(
 148                        "GetWorksByAuthor",
 149                        global::HotChocolate.Utilities.ReflectionUtils.StaticMemberFlags,
 150                        new global::System.Type[]
 151                        {
 152                            typeof(global::Api.Works.Queries.Author),
 153                            typeof(global::Api.Database.PGContext),
 154                            typeof(global::Api.Auth.Utils.ICurrentUserId),
 155                            typeof(global::Api.Works.Queries.WorkDataLoaders.IWorkByIdDataLoader),
 156                            typeof(global::GreenDonut.Data.QueryContext<global::Api.Works.Queries.Work>),
 157                            typeof(global::GreenDonut.Data.PagingArguments),
 158                            typeof(global::System.Threading.CancellationToken)
 159                        })!;
 160
 161                    var fieldDescriptor = global::HotChocolate.Types.Descriptors.ObjectFieldDescriptor.From(field.Contex
 162                    HotChocolate.Internal.ConfigurationHelper.ApplyConfiguration(
 163                        field.Context,
 164                        fieldDescriptor,
 165                        configuration.Member,
 166                        new global::HotChocolate.Types.UseConnectionAttribute(),
 167                        new global::Api.Auth.Handlers.PermissionCheckAuthorizeAttribute(global::Api.Auth.Models.UserPerm
 168                        new global::HotChocolate.Data.UseFilteringAttribute(null, 42),
 169                        new global::HotChocolate.Data.UseSortingAttribute(null, 43));
 170                    configuration.ConfigurationsAreApplied = true;
 171                    fieldDescriptor.CreateConfiguration();
 172
 173                    configuration.Resolvers = context.Resolvers.GetWorksByAuthor();
 174                    configuration.ResultPostProcessor = global::HotChocolate.Execution.ListPostProcessor<global::Api.Wor
 175                },
 176                (Resolvers: resolvers, ThisType: thisType));
 77
 78            Configure(descriptor);
 179        }
 80
 81        static partial void Configure(global::HotChocolate.Types.IObjectTypeDescriptor<global::Api.Works.Queries.Author>
 82
 83        private sealed class __Resolvers
 84        {
 85            public HotChocolate.Resolvers.FieldResolverDelegates GetWorksByAuthor()
 186                => new global::HotChocolate.Resolvers.FieldResolverDelegates(resolver: GetWorksByAuthor);
 87
 88            private async global::System.Threading.Tasks.ValueTask<global::System.Object?> GetWorksByAuthor(global::HotC
 189            {
 190                var args0 = context.Parent<global::Api.Works.Queries.Author>();
 191                var args1 = context.Service<global::Api.Database.PGContext>();
 192                var args2 = context.Service<global::Api.Auth.Utils.ICurrentUserId>();
 193                var args3 = context.Service<global::Api.Works.Queries.WorkDataLoaders.IWorkByIdDataLoader>();
 194                var args4_selection = context.Selection;
 195                var args4_filter = global::HotChocolate.Data.Filters.FilterContextResolverContextExtensions.GetFilterCon
 196                var args4_sorting = global::HotChocolate.Data.Sorting.SortingContextResolverContextExtensions.GetSorting
 197                var args4 = new global::GreenDonut.Data.QueryContext<global::Api.Works.Queries.Work>(
 198                    global::HotChocolate.Execution.Processing.HotChocolateExecutionSelectionExtensions.AsSelector<global
 199                    args4_filter?.AsPredicate<global::Api.Works.Queries.Work>(),
 1100                    args4_sorting?.AsSortDefinition<global::Api.Works.Queries.Work>());
 1101                var args5_options = global::HotChocolate.Types.Pagination.PagingHelper.GetPagingOptions(context.Schema, 
 1102                var args5_flags = global::HotChocolate.Types.Pagination.ConnectionFlagsHelper.GetConnectionFlags(context
 1103                var args5_first = context.ArgumentValue<int?>("first");
 1104                var args5_after = context.ArgumentValue<string?>("after");
 1105                int? args5_last = null;
 1106                string? args5_before = null;
 1107                bool args5_includeTotalCount = false;
 108
 1109                if(args5_options.AllowBackwardPagination ?? global::HotChocolate.Types.Pagination.PagingDefaults.AllowBa
 1110                {
 1111                    args5_last = context.ArgumentValue<int?>("last");
 1112                    args5_before = context.ArgumentValue<string?>("before");
 1113                }
 114
 1115                if(args5_first is null && args5_last is null)
 0116                {
 0117                    args5_first = args5_options.DefaultPageSize ?? global::HotChocolate.Types.Pagination.PagingDefaults.
 0118                }
 119
 1120                if(args5_options.IncludeTotalCount ?? global::HotChocolate.Types.Pagination.PagingDefaults.IncludeTotalC
 0121                {
 0122                    args5_includeTotalCount = args5_flags.HasFlag(global::HotChocolate.Types.Pagination.ConnectionFlags.
 0123                }
 124
 1125                var args5 = new global::GreenDonut.Data.PagingArguments(
 1126                    args5_first,
 1127                    args5_after,
 1128                    args5_last,
 1129                    args5_before,
 1130                    args5_includeTotalCount)
 1131                    {
 1132                        EnableRelativeCursors = args5_flags.HasFlag(global::HotChocolate.Types.Pagination.ConnectionFlag
 1133                        NullOrdering = args5_options.NullOrdering
 1134                    };
 1135                var args6 = context.RequestAborted;
 1136                var result = await global::Api.Works.Queries.AuthorNode.GetWorksByAuthor(args0, args1, args2, args3, arg
 1137                return result;
 1138            }
 139        }
 140    }
 141}
 142

/home/runner/work/ProjectRead.ing/ProjectRead.ing/Api/Works/Queries/Author.cs

#LineLine coverage
 1// SPDX-FileCopyrightText: 2026 Alper Çelik <alper@alper-celik.dev>
 2//
 3// SPDX-License-Identifier: AGPL-3.0-or-later
 4
 5using Api.Auth.Handlers;
 6using Api.Auth.Utils;
 7using Api.Database;
 8using GreenDonut.Data;
 9using HotChocolate.Types.Pagination;
 10using Microsoft.EntityFrameworkCore;
 11using Riok.Mapperly.Abstractions;
 12using static Api.Works.Queries.AuthorDataLoaders;
 13using static Api.Works.Queries.WorkDataLoaders;
 14
 15namespace Api.Works.Queries;
 16
 17[QueryType]
 18public static partial class AuthorQuery
 19{
 20    [PermissionCheckAuthorize(Auth.Models.UserPermissionBits.AuthorRead)]
 21    [UseFiltering]
 22    [UseSorting]
 23    public static async Task<PageConnection<Author>> GetAuthors(
 24        [Service] PGContext db,
 25        [Service] ICurrentUserId userId,
 26        [Service] IAuthorByIdDataLoader authorById,
 27        QueryContext<Author> qc,
 28        PagingArguments pg,
 29        CancellationToken ct
 30    ) =>
 31        await db
 32            .Authors.Where(a => a.OwnerId == userId.Id)
 33            .ProjectToDto()
 34            .WithQueryContext(qc)
 35            .ToPageWithDataLoaderAsync(pg, authorById, ct);
 36}
 37
 38[ObjectType<Author>]
 39public static partial class AuthorNode
 40{
 41    [PermissionCheckAuthorize(Auth.Models.UserPermissionBits.WorkRead)]
 42    [UseFiltering]
 43    [UseSorting]
 44    [GraphQLName("Works")]
 45    public static async Task<PageConnection<Work>> GetWorksByAuthor(
 46        [Parent] Author author,
 47        [Service] PGContext db,
 48        [Service] ICurrentUserId userId,
 49        [Service] IWorkByIdDataLoader workById,
 50        QueryContext<Work> qc,
 51        PagingArguments pagingArguments,
 52        CancellationToken ct
 53    )
 154    {
 155        return await db
 156            .Works.Where(w => w.OwnerId == userId.Id)
 157            .Where(w => w.Authors.Select(a => a.Id).Contains(author.Id))
 158            .ProjectToDto()
 159            .WithQueryContext(qc)
 160            .ToPageWithDataLoaderAsync(pagingArguments, workById, ct);
 161    }
 62
 63    [PermissionCheckAuthorize(Auth.Models.UserPermissionBits.AuthorRead)]
 64    [GraphQLIgnore]
 65    public static async Task<Author?> GetByIdAsync(
 66        IAuthorByIdDataLoader authorById,
 67        Guid id,
 68        CancellationToken ct
 169    ) => await authorById.LoadAsync(id, ct);
 70}
 71
 72public static class AuthorDataLoaders
 73{
 74    public interface IAuthorByIdDataLoader : IBatchDataLoader<Guid, Author>;
 75
 76    [GraphQLIgnore]
 77    [DataLoader<IAuthorByIdDataLoader>]
 78    public static async Task<IDictionary<Guid, Author>> GetAuthorByIdAsync(
 79        IReadOnlyList<Guid> ids,
 80        [Service] PGContext db,
 81        [Service] ICurrentUserId userId,
 82        CancellationToken ct
 83    )
 84    {
 85        return await db
 86            .Authors.Where(a => a.OwnerId == userId.Id)
 87            .Where(a => ids.Contains(a.Id))
 88            .ProjectToDto()
 89            .ToDictionaryAsync(a => a.Id, cancellationToken: ct);
 90    }
 91}
 92
 93[Node(
 94    NodeResolverType = typeof(AuthorNode),
 95    NodeResolver = nameof(AuthorNode.GetByIdAsync)
 96)]
 97public class Author : IEntityMetadata, INode
 98{
 99    public static byte IdPostfix => Models.Author.IdPostfix;
 100
 101    public Guid Id { get; set; }
 102    public int RowVersion { get; set; }
 103    public NodaTime.Instant MetadataAddedAt { get; set; }
 104    public NodaTime.Instant MetadataUpdatedAt { get; set; }
 105
 106    public string? FirstName { get; set; }
 107
 108    public string? LastName { get; set; }
 109
 110    public required string DisplayName { get; set; }
 111
 112    public required List<string> PenNames { get; set; }
 113}
 114
 115[Mapper]
 116public static partial class AuthorMapper
 117{
 118    public static partial IQueryable<Author> ProjectToDto(
 119        this IQueryable<Models.Author> q
 120    );
 121
 122    public static partial Author ToDto(Models.Author a);
 123}
Generated by: ReportGenerator 5.5.11.0
10/02/2026 - 09:20:22
GitHub | reportgenerator.io

Methods/Properties

Initialize(HotChocolate.Types.IObjectTypeDescriptor<Api.Works.Queries.Author>)
GetWorksByAuthor()
GetWorksByAuthor()
GetWorksByAuthor()
GetByIdAsync()