/// <summary>
        /// Executes the query.
        /// </summary>
        /// <param name="queryText">The query text.</param>
        /// <param name="jsonText">The json text.</param>
        /// <returns>Task.</returns>
        private async Task ExecuteQuery(string queryText, string jsonText = "{}")
        {
            // top level services to execute the query
            var queryPipeline = _serviceProvider.GetService <ISchemaPipeline <GraphSchema, GraphQueryExecutionContext> >();
            var writer        = _serviceProvider.GetService <IGraphResponseWriter <GraphSchema> >();

            // parse the json doc, simulating a request recieved to the QueryController
            var inputVars = InputVariableCollection.FromJsonDocument(jsonText);

            var query = new GraphQueryData()
            {
                Query     = queryText,
                Variables = inputVars ?? InputVariableCollection.Empty,
            };

            var request = new GraphOperationRequest(query);
            var context = new GraphQueryExecutionContext(request, _serviceProvider, null);

            // execute
            await queryPipeline.InvokeAsync(context, default);

            var response = context.Result;

            if (response.Messages.Count > 0)
            {
                throw new InvalidOperationException("Query failed: " + response.Messages[0].Message);
            }

            // simulate writing hte result to an output stream
            string result = null;

            using (var memStream = new MemoryStream())
            {
                await writer.WriteAsync(memStream, response);

                memStream.Seek(0, SeekOrigin.Begin);
                using (var streamReader = new StreamReader(memStream))
                    result = streamReader.ReadToEnd();
            }

            if (result == null)
            {
                throw new InvalidOperationException("Query failed: No Response was serialized");
            }
        }
Ejemplo n.º 2
0
        private async Task <bool> RegisterSubscriptionOrRespond(ISubscription <TSchema> subscription)
        {
            var registrationComplete = false;

            if (!subscription.IsValid)
            {
                if (subscription.Messages.Count == 1)
                {
                    await subscription.Client.SendMessage(
                        new ApolloServerErrorMessage(
                            subscription.Messages[0],
                            clientProvidedId : subscription.Id))
                    .ConfigureAwait(false);
                }
                else
                {
                    var response = GraphOperationRequest.FromMessages(subscription.Messages, subscription.QueryData);
                    await subscription.Client
                    .SendMessage(new ApolloServerDataMessage(subscription.Id, response))
                    .ConfigureAwait(false);
                }

                await subscription.Client
                .SendMessage(new ApolloServerCompleteMessage(subscription.Id))
                .ConfigureAwait(false);
            }
            else
            {
                var totalTracked = _subscriptions.Add(subscription);
                if (totalTracked == 1)
                {
                    this.SubscriptionRouteAdded?.Invoke(this, new ApolloSubscriptionFieldEventArgs(subscription.Field));
                }

                _logger?.SubscriptionCreated(subscription);
                registrationComplete = true;
            }

            return(registrationComplete);
        }