public Client(HttpClient httpClient)
{
var options = new GraphQLHttpClientOptions
{
EndPoint = new Uri("https://graphql.anilist.co")
};
_graphQlClient = new GraphQLHttpClient(options, new SystemTextJsonSerializer(), httpClient);
}
public async Task ExampleGraphQL()
{
// TODO: Use dependency injection (services.AddGraphQLClient()) (IServiceCollection)
var client = GraphQLHttpClient.Default();
var response = await client.Query <Query>("https://mpjk0plp9.lp.gql.zone/graphql");
Assert.Equal("R2-D2", response.Hero.Name);
}
public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
{
this.webSocketUri = webSocketUri;
this.client = client;
buffer = new ArraySegment <byte>(new byte[8192]);
ResponseStream = _createResponseStream();
requestSubscription = requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
}
public OpenWeatherClient(OpenWeatherConfiguration openWeatherConfiguration)
{
weatherLocationsSemaphore = new SemaphoreSlim(1);
graphQLHttpClient = new GraphQLHttpClient(
new GraphQLHttpClientOptions {
EndPoint = new Uri(openWeatherConfiguration.GraphQLApiUrl)
});
cancellationTokenSource = new CancellationTokenSource();
}
public async Task Test_Recieve_Multiple_Messages()
{
// Arrange
var tokenSource = new CancellationTokenSource();
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Create websocket GraphQL client
var wsClient = _factory.Server.CreateWebSocketClient();
wsClient.ConfigureRequest = request => request.Headers.Add("Sec-WebSocket-Protocol", "graphql-ws");
var wsUri = new UriBuilder(_factory.Server.BaseAddress)
{
Scheme = "wss",
Path = "graphql"
}.Uri;
var websocket = await wsClient.ConnectAsync(wsUri, tokenSource.Token);
var graphQLSubscriptionClient = new GraphQLSubscriptionClient(websocket, tokenSource.Token, new GraphQLFieldBuilder(), new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization());
await graphQLSubscriptionClient.Initilize();
// Act
// Registrer operation
var operation = await graphQLSubscriptionClient.ExecuteOperation <MessageAddedSubscription>();
List <GraphQLDataResult <MessageAddedSubscription> > recievedData = new List <GraphQLDataResult <MessageAddedSubscription> >();
operation.DataRecieved += (sender, e) =>
{
recievedData.Add(e.ReceivedData);
};
await Task.Delay(TimeSpan.FromSeconds(1));
// Send 2 messages
await graphQLClient.CreateMutation <SendMessageMutation>("http://localhost/graphql", arguments : new GraphQLQueryArgument("message", new MessageInputType
{
content = "Message 1",
fromId = "SAHB",
sentAt = DateTime.Now.AddDays(-1)
})).Execute();
await graphQLClient.CreateMutation <SendMessageMutation>("http://localhost/graphql", arguments : new GraphQLQueryArgument("message", new MessageInputType
{
content = "Message 1",
fromId = "SAHB",
sentAt = DateTime.Now.AddDays(-1)
})).Execute();
await Task.Delay(TimeSpan.FromSeconds(2));
// Assert
Assert.Equal(2, recievedData.Count);
}
public PolicyExampleGraphQLClient(HttpClient httpClient, string?endpoint = null)
{
var options = new GraphQLHttpClientOptions {
EndPoint = new Uri(endpoint ?? "https://localhost:5001/graphql")
};
Client = new GraphQLHttpClient(options,
new NewtonsoftJsonSerializer(),
httpClient);
}
public AppSyncService()
{
var options = new GraphQLHttpClientOptions
{
EndPoint = new Uri(ApiKey.AppSyncApiUrl),
};
this.GraphQLHttpClient = new GraphQLHttpClient(options, new NewtonsoftJsonSerializer());
this.GraphQLHttpClient.HttpClient.DefaultRequestHeaders.Add("x-api-key", ApiKey.AppSyncApiKey);
}
public void Initialize()
{
var options = new GraphQLHttpClientOptions()
{
EndPoint = new Uri("http://www.example.com/graph/api/graphql"),
HttpMessageHandler = new MockHttpHandler()
};
_client = new GraphQLHttpClient(options, new NewtonsoftJsonSerializer());
}
public void Initialize()
{
GraphQLHttpClientOptions options = new GraphQLHttpClientOptions()
{
EndPoint = new System.Uri("http://www.example.com/graph/api/graphql"),
HttpMessageHandler = new MockHttpHandler()
};
_client = new GraphQLHttpClient(options);
}
public async Task <IViewComponentResult> InvokeAsync()
{
using var graphQLClient = new GraphQLHttpClient(Baseurl, new NewtonsoftJsonSerializer());
var graphQLResponse = await graphQLClient.SendQueryAsync <COPC_Wiki.Models.WikiPages>(query.getWikiPages());
//Console.WriteLine("raw response:");
//Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true }));
return(View("Navigation", graphQLResponse.Data));
}
public async Task Test_GraphQL_Builder_Returns_Exception_When_Error_Occurs()
{
// Arrange
var expected =
"{\"query\":\"query{field}\"}";
var httpClientMock = A.Fake <IGraphQLHttpExecutor>(x => x.Strict());
A.CallTo(() => httpClientMock.ExecuteQuery(expected,
A <string> .Ignored,
A <HttpMethod> .Ignored,
A <string> .Ignored,
A <string> .Ignored,
A <IDictionary <string, string> > .Ignored,
A <CancellationToken> .Ignored))
.Returns(new GraphQLExecutorResponse
{
Response = JsonConvert.SerializeObject(new
{
Data = new
{
Field = "FieldValue"
},
Errors = new[]
{
new
{
message = "This is not a valid query!",
locations = new []
{
new
{
line = 1,
column = 0
},
new
{
line = 1,
column = 1
}
}
}
}
})
});
var client = new GraphQLHttpClient(httpClientMock, new GraphQLFieldBuilder(),
new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization(), new QueryGeneratorFilter());
// Act
var query = client.CreateQuery(builder =>
builder.Field("field"), "randomurl");
// Assert
await Assert.ThrowsAsync <GraphQLErrorException>(() => query.Execute());
}
public async Task <PostListViewModel> SearchPosts(string searchTerm)
{
using var graphQLClient = new GraphQLHttpClient("http://hitsrvwp1.becom.at/graphql", new SystemTextJsonSerializer());
_logger.LogInformation($"Searching posts with {searchTerm}...");
var request = new GraphQLRequest
{
Query = @"
query SEARCH_POSTS {
posts(where: {search: ""{search}""}) {
edges {
cursor
node {
author {
node {
firstName
lastName
email
}
}
categories {
nodes {
name
}
}
id
date
title
excerpt
}
}
pageInfo {
hasNextPage
hasPreviousPage
startCursor
endCursor
}
}
}
".Replace("{search}", searchTerm)
};
var graphQLResponse = await graphQLClient.SendQueryAsync <PostsData <PostsNode> >(request);
if (graphQLResponse.Errors != null && graphQLResponse.Errors.Length > 0)
{
foreach (var e in graphQLResponse.Errors)
{
_logger.LogError($"Error searching posts with {searchTerm}: {e.Message}");
}
return(null);
}
_logger.LogInformation($"Posts loaded!");
return(graphQLResponse.Data.ToOverview());
}
internal static Task <GraphQLResponse <TResponse> > SendRequest <TResponse>(
this GraphQLHttpWebSocket graphQlHttpWebSocket,
GraphQLRequest request,
GraphQLHttpClient client,
CancellationToken cancellationToken = default)
{
return(Observable.Create <GraphQLResponse <TResponse> >(async observer => {
await client.Options.PreprocessRequest(request, client);
var websocketRequest = new GraphQLWebSocketRequest {
Id = Guid.NewGuid().ToString("N"),
Type = GraphQLWebSocketMessageType.GQL_START,
Payload = request
};
var observable = graphQlHttpWebSocket.ResponseStream
.Where(response => response != null && response.Id == websocketRequest.Id)
.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
.Select(response => {
Debug.WriteLine($"received response for request {websocketRequest.Id}");
var typedResponse =
client.Options.JsonSerializer.DeserializeToWebsocketResponse <TResponse>(
response.MessageBytes);
return typedResponse.Payload;
});
try {
// intialize websocket (completes immediately if socket is already open)
await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
}
catch (Exception e) {
// subscribe observer to failed observable
return Observable.Throw <GraphQLResponse <TResponse> >(e).Subscribe(observer);
}
var disposable = new CompositeDisposable(
observable.Subscribe(observer)
);
Debug.WriteLine($"submitting request {websocketRequest.Id}");
// send request
try {
await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);
}
catch (Exception e) {
Console.WriteLine(e);
throw;
}
return disposable;
})
// complete sequence on OperationCanceledException, this is triggered by the cancellation token
.Catch <GraphQLResponse <TResponse>, OperationCanceledException>(exception =>
Observable.Empty <GraphQLResponse <TResponse> >())
.FirstOrDefaultAsync()
.ToTask(cancellationToken));
}
public static CallbackMonitor <GraphQLHttpClient> ConfigureMonitorForOnWebsocketConnected(
this GraphQLHttpClient client)
{
var tester = new CallbackMonitor <GraphQLHttpClient>();
client.Options.OnWebsocketConnected = c => {
tester.Invoke(c);
return(Task.CompletedTask);
};
return(tester);
}
public GraphQLHttpClient GetClient()
{
AddToken();
var graphQlHttpClient = new GraphQLHttpClient(
new GraphQLHttpClientOptions {
EndPoint = new Uri($"/graphql")
},
new NewtonsoftJsonSerializer(), m_httpClient);;
return(graphQlHttpClient);
}
public LoggiPrestoClient(string apiToken, string email, string apiUrl = "https://staging.loggi.com/graphql", bool logado = true)
{
_client = new GraphQLHttpClient(apiUrl, new NewtonsoftJsonSerializer());
_apiToken = apiToken;
_email = email;
IsLogged = logado;
_client.HttpClient.DefaultRequestHeaders.Add("Authorization", String.Format("ApiKey {0}:{1}", _email, _apiToken));
}
static Query()
{
var uri = new Uri("https://api.spacex.land/graphql");
var graphQLOptions = new GraphQLHttpClientOptions
{
EndPoint = uri,
HttpMessageHandler = new NativeMessageHandler(),
};
graphQLHttpClient = new GraphQLHttpClient(graphQLOptions, new NewtonsoftJsonSerializer());
}
static Mutation()
{
var uri = new Uri("https://localhost:44303/graphql");
var graphQLOptions = new GraphQLHttpClientOptions
{
EndPoint = uri,
HttpMessageHandler = new NativeMessageHandler(),
};
graphQLHttpClient = new GraphQLHttpClient(graphQLOptions, new NewtonsoftJsonSerializer());
}
public GraphQLService(string apiBaseAddress, bool autoRedirectRequests, Func <DelegatingHandler> delegatingHandler, IDictionary <string, string> defaultHeaders)
{
if (string.IsNullOrEmpty(apiBaseAddress))
{
throw new ArgumentNullException(nameof(apiBaseAddress));
}
Debug.WriteLine($"GraphQL base url set to: {apiBaseAddress}, autoRedirects: {autoRedirectRequests} and delegatingHandler: {delegatingHandler != null}");
BaseUrl = apiBaseAddress;
Func <HttpMessageHandler, GraphQLHttpClient> createClient = messageHandler =>
{
HttpMessageHandler handler;
if (delegatingHandler != null)
{
var delegatingHandlerInstance = delegatingHandler.Invoke();
delegatingHandlerInstance.InnerHandler = messageHandler;
handler = delegatingHandlerInstance;
}
else
{
handler = messageHandler;
}
if (!autoRedirectRequests)
{
DisableAutoRedirects(messageHandler);
}
var client = new GraphQLHttpClient(new GraphQLHttpClientOptions
{
HttpMessageHandler = handler,
EndPoint = new Uri(apiBaseAddress)
}, new NewtonsoftJsonSerializer());
if (defaultHeaders != default)
{
foreach (var header in defaultHeaders)
{
client.HttpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
return(client);
};
_background = new Lazy <GraphQLHttpClient>(() => createClient(new RateLimitedHttpMessageHandler(new NativeHttpClientHandler(), Priority.Background)));
_userInitiated = new Lazy <GraphQLHttpClient>(() => createClient(new RateLimitedHttpMessageHandler(new NativeHttpClientHandler(), Priority.UserInitiated)));
_speculative = new Lazy <GraphQLHttpClient>(() => createClient(new RateLimitedHttpMessageHandler(new NativeHttpClientHandler(), Priority.Speculative)));
}
static void Main(string[] args)
{
GraphQLHttpClient graphQLHttpClient;
var httpClientOption = new GraphQLHttpClientOptions
{
EndPoint = new Uri("https://moviesg.azurewebsites.net/api")
};
graphQLHttpClient = new GraphQLHttpClient(httpClientOption, new NewtonsoftJsonSerializer());
GetAllMovies(graphQLHttpClient).Wait();
}
public async Task <ICollection <T> > GetAll(string query, string name)
{
var req = new GraphQLRequest
{
Query = query
};
var client = new GraphQLHttpClient($"{Environment.GetEnvironmentVariable("ASPNETCORE_API_URL")}");
var res = await client.SendQueryAsync(req);
return(res.GetDataFieldAs <ConnectionGraphQl <T> >(name).Nodes);
}
public GraphCmsClient(GraphCmsOptions options)
{
options.ThrowsIfInvalid();
_client = new GraphQLHttpClient(options.Endpoint, new SystemTextJsonSerializer());
if (!string.IsNullOrEmpty(options.ApiToken))
{
_client.HttpClient.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", options.ApiToken);
}
}
public async Task TestSimpleMutation()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var result = await graphQLClient.CreateMutation <TestHelloMutation>("http://localhost/graphql").Execute();
// Assert
Assert.Equal("mutation", result.Hello);
}
public OrganizationsRepository(
IConfiguration configuration,
IAdminBearerTokenClient adminBearerTokenClient,
ILogger logger)
{
string endpoint = $"{configuration["AdminApi:Endpoint"]}/api/appadmin";
logger.LogInformation($"Admin endpoint: {endpoint}");
_client = new GraphQLHttpClient(endpoint, new NewtonsoftJsonSerializer());
_adminBearerTokenClient = adminBearerTokenClient;
_logger = logger;
}
public async Task Test_IntrospectionResult_Does_Not_Contain_Errors()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var result = await graphQLClient.CreateQuery <GraphQLIntrospectionQuery>("http://localhost/graphql").ExecuteDetailed();
// Assert
Assert.False(result.ContainsErrors);
}
public async Task TestSimpleQuery()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var result = await graphQLClient.Execute <TestHelloQuery>(GraphQLOperationType.Query, "http://localhost/graphql");
// Assert
Assert.Equal("query", result.Hello);
}
private static async Task <GraphQLResponse <FileReferencesResponse> > GetFileReferencesResponse(string searchTerm, int pageSize)
{
using var client = new GraphQLHttpClient("http://localhost:5002/api/v1/graphql", new NewtonsoftJsonSerializer());
var request = CreateFileReferencesRequest(new SearchOptions {
SearchTerm = searchTerm
}, new PagingOptions {
PageSize = pageSize
});
var response = await client.SendQueryAsync <FileReferencesResponse>(request);
return(response);
}
public async Task <T> QueryAsync <T>(string query)
{
var graphQLClient = new GraphQLHttpClient(_grapqhlEndpoint, new NewtonsoftJsonSerializer());
var request = new GraphQLRequest
{
Query = query
};
var graphQLResponse = await graphQLClient.SendQueryAsync <T>(request);
return(graphQLResponse.Data);
}
public static GraphQLHttpClient CreateGraphQLClient()
{
var gitHubAccessToken = CommonHelper.GetGitHubAuthToken();
var graphQLHttpClient = new GraphQLHttpClient("https://api.github.com/graphql", new NewtonsoftJsonSerializer());
graphQLHttpClient.HttpClient.DefaultRequestHeaders.Authorization =
new System.Net.Http.Headers.AuthenticationHeaderValue(
scheme: "bearer",
parameter: gitHubAccessToken);
return(graphQLHttpClient);
}
public async Task Can_Get_Result_With_Enummember()
{
// Arrange
var client = _factory.CreateClient();
var graphQLClient = GraphQLHttpClient.Default(client);
// Act
var query = await graphQLClient.CreateQuery <EmQuery>("http://localhost/graphql", arguments : new GraphQLQueryArgument("fromSrc", RdSrcWithEnumMember.correctValue)).Execute();
// Assert
Assert.Single(query.QryRdByEm);
}
