public IFieldResolver AsConnection()

in src/Epam.GraphQL/Configuration/Implementations/FieldResolvers/QueryableFuncResolver.cs [166:230]
55 lines of code
5 McCabe index (conditional complexity)

        public IFieldResolver AsConnection()
        {
            var resolver = new QueryableFuncResolver<TReturnType, TTransformedReturnType, TExecutionContext>(_proxyAccessor, _resolver, _transform, _sorters, GetConnectionQueriedFields);

            if (_proxyAccessor.HasHooks)
            {
                return new FuncResolver<
                    Connection<IDataLoaderResult<IEnumerable<TTransformedReturnType>>, IDataLoaderResult<global::GraphQL.Types.Relay.DataObjects.Edge<TTransformedReturnType>[]>>,
                    Connection<IDataLoaderResult<IEnumerable<TTransformedReturnType>>, IDataLoaderResult<global::GraphQL.Types.Relay.DataObjects.Edge<TTransformedReturnType>[]>>,
                    TExecutionContext>(
                    IdentityProxyAccessor<Connection<IDataLoaderResult<IEnumerable<TTransformedReturnType>>, IDataLoaderResult<global::GraphQL.Types.Relay.DataObjects.Edge<TTransformedReturnType>[]>>, TExecutionContext>.Instance,
                    context =>
                    {
                        var resolved = resolver.Resolver(context).Select(resolver.Transform(context));
                        var selected = Resolvers.Resolve(context, resolved);

                        var connection = new Connection<IDataLoaderResult<IEnumerable<TTransformedReturnType>>, IDataLoaderResult<global::GraphQL.Types.Relay.DataObjects.Edge<TTransformedReturnType>[]>>
                        {
                            PageInfo = selected.PageInfo,
                            TotalCount = selected.TotalCount,
                        };

                        if (selected.Edges != null)
                        {
                            var hooksExecuter = _proxyAccessor.CreateHooksExecuter(context);
                            connection.Edges = hooksExecuter!
                                .Execute<global::GraphQL.Types.Relay.DataObjects.Edge<TTransformedReturnType>>(edge => edge.Node!)
                                .LoadAsync(selected.Edges);

                            if (selected.Items != null)
                            {
                                connection.Items = connection.Edges.Then(edges => edges.Select(edge => edge.Node!));
                            }

                            return connection;
                        }

                        if (selected.Items != null)
                        {
                            var hooksExecuter = _proxyAccessor.CreateHooksExecuter(context);
                            connection.Items = hooksExecuter!
                                .Execute(FuncConstants<TTransformedReturnType>.Identity)
                                .LoadAsync(selected.Items)
                                .Then(items => items.AsEnumerable());
                        }

                        return connection;
                    });
            }

            return new FuncResolver<Connection<TTransformedReturnType>, Connection<TTransformedReturnType>, TExecutionContext>(
                IdentityProxyAccessor<Connection<TTransformedReturnType>, TExecutionContext>.Instance,
                ctx =>
                {
                    var resolved = resolver.Resolver(ctx).Select(resolver.Transform(ctx));
                    var selected = Resolvers.Resolve(ctx, resolved);

                    return selected;
                });

            static IEnumerable<string> GetConnectionQueriedFields(IResolveFieldContext context)
            {
                return context.GetConnectionQueriedFields();
            }
        }