DEV Community: Anupam Maiti

Preforming CRUD Operations Using GraphQL In ASP.NET Core

Anupam Maiti — Sat, 08 Aug 2020 05:39:28 +0000

Introduction

Like REST, GraphQL also allows the client to make changes to data that’s currently stored in the backend. In GraphQL, these changes are made using mutations which is nothing but a type of operation that allows creating, updating, and deleting data. For the read operation, we used GraphQL query type (explained in the article “Build an API in .NET Core with GraphQL”), which is completely flexible, and based on the requirement that the user/client decides what data is actually needed.

As we know, GraphQL specifies three types that are used to perform operations of a GraphQL server.

Query - Used for retrieving data based on needs.
Mutation – Used for making changes to the data/entity.
Subscription – Used for real-time updates on important events.

Implementing GraphQL Mutation with ASP.NET Core

In this article, we will be going to add a mutation type that allows users to modify a tech event entity into the DB. This article is a continuation of the previous one which is mentioned in related reads.

First, we're going to make some changes to model and repositories which will allow inserting, updating, and deleting on tech event entity. Next, we're going to create new GraphQL types that we need in order to enable the mutation. And then we will update the schema so that mutation will be available to the client/user and then create a mutation and test is though GraphiQL UI as well as Postman.

Create models and add methods to the repository

Add a folder called Models into the project (which we build earlier here) and add a new model called NewTechEventRequest.cs into it which basically contains properties that are required to create a new tech event and save into DB.

NewTechEventRequest.cs

using System;   
namespace GraphQL.API.Models  
{  
    public class NewTechEventRequest  
    {  
        public string EventName { get; set; }  
        public string Speaker { get; set; }  
        public DateTime EventDate { get; set; }  
    }  
}

Now we are going to add the below 3 methods to our repository interface.

ITechEventRepository.cs

Task<TechEventInfo> AddTechEventAsync(NewTechEventRequest techEvent);  
Task<TechEventInfo> UpdateTechEventAsync(TechEventInfo techEvent);  
Task<bool> DeleteTechEventByIdAsync(TechEventInfo techEvent);

And implement those methods into TechEventRepository.cs.

public async Task<TechEventInfo> AddTechEventAsync(NewTechEventRequest techEvent)  
{  
    var newEvent = new TechEventInfo { EventName = techEvent.EventName, Speaker = techEvent.Speaker, EventDate = techEvent.EventDate };  
    var savedEvent = (await _context.TechEventInfo.AddAsync(newEvent)).Entity;  
    await _context.SaveChangesAsync();  
    return savedEvent;  
}  

public async Task<bool> DeleteTechEventByIdAsync(TechEventInfo techEvent)  
{  
    _context.TechEventInfo.Remove(techEvent);  
    await _context.SaveChangesAsync();  
    return true;  
}  

public async Task<TechEventInfo> UpdateTechEventAsync(TechEventInfo techEvent)  
{  
    var updatedEvent = (_context.TechEventInfo.Update(techEvent)).Entity;  
    await _context.SaveChangesAsync();  
    return updatedEvent;  
}

Create GraphQL input type

Next, we're going to update the schema. To do this, create a GraphQL input type which will correspond with the NewTechEventRequest model that we just created. This is the type that we are going to send from a client as an argument to mutation.

Right click on GraphqlCore folder, then add a new class called TechEventInputType.cs and add below-mentioned code.

TechEventInputType.cs

using GraphQL.Types;   
namespace GraphQL.API.GraphqlCore  
{  
    public class TechEventInputType : InputObjectGraphType  
    {  
        public TechEventInputType()  
        {  
            Name = "AddEventInput";  
            Field<NonNullGraphType<StringGraphType>>("eventName");  
            Field<StringGraphType>("speaker");  
            Field<NonNullGraphType<DateGraphType>>("eventDate");  
        }  
    }  
}

The TechEventInputType class derives from the InputObjectGraphType class and in the constructor, we just populate the Name property and added three fields.

Here:

InputObjectGraphType – used to define an input type and this is going to tell GraphQL that this is an input type.
NonNullGraphType – used to require a non-null values.
StringGraphType – used to define a string field.
DateGraphType – used to define a date field.

Create Mutation

Create the TechEventMutation class inside the GraphqlCore folder.
TechEventMutation.cs

using GraphQL.API.Infrastructure.Repositories;  
using GraphQL.Types;  
using GraphQL.API.Models;  
using GraphQL.API.Infrastructure.DBContext;  

namespace GraphQL.API.GraphqlCore  
{  
    public class TechEventMutation : ObjectGraphType<object>  
    {  
        public TechEventMutation(ITechEventRepository repository)  
        {  
            Name = "TechEventMutation";  

            FieldAsync<TechEventInfoType>(  
                "createTechEvent",  
                arguments: new QueryArguments(  
                    new QueryArgument<NonNullGraphType<TechEventInputType>> { Name = "techEventInput" }  
                ),  
                resolve: async context =>  
                {  
                    var techEventInput = context.GetArgument<NewTechEventRequest>("techEventInput");  
                    return await repository.AddTechEventAsync(techEventInput);  
                });  
        }  
    }  
}

Inside the constructor, the name is the name of the mutation and field with the name createTechEvent, which will return the TechEventInfoType object.

When we create a tech event, we are going to pass an instance of an argument of type TechEventInputType, with a variable name “techEventInput” that we provide in GraphQL. The resolve action is going to execute the AddTechEventAsync method from our repository to add data into DB.

TechEventSchema.cs

Mutation = resolver.Resolve<TechEventMutation>();

Update startup.cs class and register these types into ConfigureServices that we created so far.

services.AddSingleton<TechEventInputType>();  
services.AddSingleton<TechEventMutation>();

Excellent, now we are done with adding Mutation into our project. Let’s start the project, and create a tech event from GraphiQL. We will see newly added schema details once it’s loaded to the browser.

Now it’s time to test it.

The syntactical structure of Mutations is similar to queries, but always starts with the mutation keyword. Below is the example to create a tech event.

mutation ($techEvent : AddEventInput!){  
  createTechEvent(techEventInput : $techEvent){  
    eventId,  
    eventName,  
    eventDate,  
    participants{  
      phone  
    }  
  }  
}

Add the below variable to the Query Variables window:

{  
  "techEvent": {  
    "eventName": "Azure Devops CI/CD Demo",  
    "speaker": "Anupam M",  
    "eventDate": "2020-12-12"  
  }  
}

Here, we create a tech event with an argument called techEventInput and return the eventId, eventName, eventDate, participants of that newly added event. We used a variable called “techEvent” to pass in the techEventInput argument via the Query Variables window. On the right side of GraphiQL, we can see that event creation is successful and got the newly created tech event as a response.

Let’s test the same using Postman. We will use the below output as an example.

Update Mutation

Whatever we did for Create tech event, we can similarly do for an update tech event.pasting. Add an additional field into TechEventMutation.cs with the name “updateTechEvent”.

FieldAsync<TechEventInfoType>(  
    "updateTechEvent",  
    arguments: new QueryArguments(  
        new QueryArgument<NonNullGraphType<TechEventInputType>> { Name = "techEventInput" },  
        new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "techEventId" }),  
    resolve: async context =>  
    {  
        var techEventInput = context.GetArgument<TechEventInfo>("techEventInput");  
        var techEventId = context.GetArgument<int>("techEventId");  

        var eventInfoRetrived = await repository.GetTechEventById(techEventId);  
        if (eventInfoRetrived == null)  
        {  
            context.Errors.Add(new ExecutionError("Couldn't find Tech event info."));  
            return null;  
        }  
        eventInfoRetrived.EventName = techEventInput.EventName;  
        eventInfoRetrived.EventDate = techEventInput.EventDate;  

        return await repository.UpdateTechEventAsync(eventInfoRetrived);  
    }  
);

Now run the project again and test it.

When we pass a non-existing event during an update operation, we receive an error message which is expected as we defined it.

Delete Mutation

Similarly, add a new field for deleting an operation in the TechEventMutation.cs class and name it as “deleteTechEvent”.

FieldAsync<StringGraphType>(  
    "deleteTechEvent",  
    arguments: new QueryArguments(new QueryArgument<NonNullGraphType<IdGraphType>> { Name = "techEventId" }),  
    resolve: async context =>  
    {  
        var techEventId = context.GetArgument<int>("techEventId");  

        var eventInfoRetrived = await repository.GetTechEventById(techEventId);  
        if (eventInfoRetrived == null)  
        {  
            context.Errors.Add(new ExecutionError("Couldn't find Tech event info."));  
            return null;  
        }  
        await repository.DeleteTechEventByIdAsync(eventInfoRetrived);  
        return $"Tech Event ID {techEventId} with Name {eventInfoRetrived.EventName} has been deleted succesfully.";  
    }  
);

Let’s run the project again and test it with the below mutation request:

mutation ($techEventId:ID!){  
  deleteTechEvent(techEventId : $techEventId)  
}

Query variable:

{  
  "techEventId": 5  
}

Awesome, isn’t it!

We are done with basic CRUD operations using GraphQL in ASP.NET Core.

All the source code described here can be found on GitHub.

Conclusion

In this article, we discussed the input type for the mutations, created different mutation actions, and performed CRUD operations on an entity by modifying mutation requests and testing it from GraphiQL as well as Postman. I hope you learned GraphQL API implementation with .NET Core using mutation and query type so far. Happy learning!

Build an API in .NET Core with GraphQL

Anupam Maiti — Fri, 24 Jul 2020 07:53:56 +0000

GraphQL is a query language for APIs which provides a more efficient and flexible alternative to REST. It was originally built by Facebook but now it’s open-sourced.

To designing web APIs, Restful architecture has become the standard over couple of years. However, REST APIs have shown to be too inflexible to keep up with the rapidly changing requirements of the clients that access them.

To solve many of the shortcomings and inefficiencies that developers experience when interacting with REST APIs, GraphQL was developed to cope with the need for more flexibility and efficiency. So, GraphQL is nothing but a better REST.

In REST, we generally have multiple endpoints to perform CRUD operations on an entity and also there are over fetching and under fetching problems and it’s return fixed data structures which is little inflexible in nature.

Overfetching means endpoints return additional information that’s not needed in the UI.

Underfetching means that a specific endpoint doesn’t provide enough of the required information. The client will have to make additional call to fetch everything it need.

Let’s consider Tech Event as an entity - A tech event can have multiple participants and similarly a participant can enroll to multiple tech events.
Here you need to call 3 endpoints to fetch the required data in REST.

GET/api/techEvents => To get all tech events
GET/api/techEvent/{id} => To get single tech event info by id
GET/api/techEvent/{id}/participants => To get participants details for an event

But using GraphQL, a single endpoint POST/graphql will be sufficient to archive this data requirement instead of 3 different endpoints and we can do it by just modifying the query as like below.

{   
 "query":  
  "query{  
     event(eventId:1){  
       eventId   
       speaker  
     }  
   }"  
}

{   
 "query":  
  "query{  
     events{  
       eventId  
       eventName  
       participants{  
            participantName  
            phone  
        }  
     }  
   }"  
}

Below Illustration on Rest API vs GraphQL with respect to endpoints:

Implementation of GraphQL with ASP.NET Core:

In this post, we're going to build a GraphQL server from scratch. The server will expose TechEvent management graphQL endpoint which will allow querying on data.

For demo purpose, let’s create a local DB called “TechEventDB” in MS SQL server (or you can use UseInMemoryDatabase) and add below tables with some dummy data:

Table - TechEventInfo: This table consists of technical event information like event id , name , speaker etc.
Table - Participant: This table consists of participant information like name, phone email etc.
Table - EventParticipants: This is a mapping table b/w event and participants with many to many relationships.

CREATE TABLE dbo.TechEventInfo(    
    EventId int IDENTITY(1,1) NOT NULL,    
    EventName varchar(100) NOT NULL,    
    Speaker varchar(100) NOT NULL,    
    EventDate Date NULL  
 CONSTRAINT [PK_TechEventInfo] PRIMARY KEY CLUSTERED     
(    
    EventId ASC    
)  
WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]    
) ON [PRIMARY]

CREATE TABLE dbo.Participant(    
    ParticipantId int IDENTITY(1,1) NOT NULL,    
    ParticipantName varchar(100) NOT NULL,    
    Email varchar(100) NOT NULL,    
    Phone varchar(20) NULL,  
 CONSTRAINT [PK_Participant] PRIMARY KEY CLUSTERED     
(    
    ParticipantId ASC    
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]    
) ON [PRIMARY]

CREATE TABLE [dbo].EventParticipants  
(  
    EventParticipantId INT NOT NULL IDENTITY(1,1) ,  
        EventId INT NOT NULL,  
    ParticipantId INT NULL,  
    CONSTRAINT [PK_EventParticipants] PRIMARY KEY CLUSTERED  
    (  
        EventParticipantId ASC  
    )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON)   
    ON [PRIMARY]  
,CONSTRAINT [FK_EventParticipants_TechEventInfo_EventId] FOREIGN KEY (EventId) REFERENCES [TechEventInfo] (EventId)   
,CONSTRAINT [FK_EventParticipants_Participant_ParticipantId] FOREIGN KEY ([ParticipantId]) REFERENCES [Participant] ([ParticipantId])   
) ON [PRIMARY]

Now we have to insert some sample data into all the tables.
Once we done with this steps, let's create ASP.NET core WebAPI project called “GraphQL.API” and add DB connection string in appsettings.json.

"ConnectionStrings": {  
    "GraphQLDBConnection": "Server=Local-PC\\SQLEXPRESS;Database=TechEventDB;Trusted_Connection=True;MultipleActiveResultSets=true"  
  }

Add the DbContext under ConfigureServices in Startup.cs

services.AddDbContext<TechEventDBContext>  
                (options => options.UseSqlServer(Configuration.GetConnectionString("GraphQLDBConnection")));

To generate entity context class, now we need to run scaffold command from package manager console (Tools => Nuget Package Manager => Package Manager Console) to generate dbContext class using Entity Framework Core. Create folder called Infrastructure and sub folder called DBContext into the project.
Scaffold-DbContext “Server=Local-PC\SQLEXPRESS;Database=TechEventDB;Trusted_Connection=True;” Microsoft.EntityFrameworkCore.SqlServer -OutputDir Infrastructure\DBContext
After successful execution of Scaffold command, entity and context will be added as like below.

Now create Repositories folder where we can handle CRUD operation on tech event entity.

ITechEventRepository.cs

using GraphQL.API.Infrastructure.DBContext;  
using System.Collections.Generic;  
using System.Threading.Tasks;  

namespace GraphQL.API.Infrastructure.Repositories  
{  
    public interface ITechEventRepository  
    {  
        Task<TechEventInfo[]> GetTechEvents();  
        Task<TechEventInfo> GetTechEventById(int id);  
        Task<List<Participant>> GetParticipantInfoByEventId(int id);  
    }  
}

TechEventRepository.cs

using GraphQL.API.Infrastructure.DBContext;  
using Microsoft.EntityFrameworkCore;  
using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Threading.Tasks;  
using GraphQL.API.Domain;  


namespace GraphQL.API.Infrastructure.Repositories  
{  
    /// <summary>  
    /// TechEventRepository.  
    /// </summary>  
    public class TechEventRepository : ITechEventRepository  
    {  

        /// <summary>  
        /// The _context.  
        /// </summary>  
        private readonly TechEventDBContext _context;  

        public TechEventRepository(TechEventDBContext context)  
        {  
            this._context = context;  
        }  

        public async Task<List<Participant>> GetParticipantInfoByEventId(int id)  
        {  
            return await(from ep in this._context.EventParticipants  
                                 join p in this._context.Participant on ep.ParticipantId equals p.ParticipantId  
                                 where ep.EventId == id  
                                 select p).ToListAsync();  
        }  

        public async Task<TechEventInfo> GetTechEventById(int id)  
        {  
            return await Task.FromResult( _context.TechEventInfo.FirstOrDefault(i => i.EventId == id));  
        }  

        public async Task<TechEventInfo[]> GetTechEvents()  
        {  
            return _context.TechEventInfo.ToArray();  
        }  
    }  
}

services.AddTransient<ITechEventRepository, TechEventRepository>();

So far, we've created our db context and repository. It's time to start using GraphQL integration in our project, so that we can get our GraphQL server running.

Add below Nuget packages into API project:

<PackageReference Include="GraphQL" Version="2.4.0" />  
<PackageReference Include="graphiql" Version="1.2.0" />  
<PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />

First we're going to configure the GraphQL schema step by step as mention below:

Step 1: Create GraphQL types - To admit through our endpoint to our GraphQL clients.

Step 2: Create a GraphQL query object - To allow us to define the queries that will then surface to the clients which they can then issue against our endpoint.

Step 3: Create schema object to expose the query - To allow tools like graphical to inspect and see what types are available. It's also necessary to enable GraphQL clients.

Step 4: Register all types in Startup.cs - To register all of those types with our asp.net core IOC container.

Add a folder into project called “GraphqlCore” – where we will keep GraphQL related Type , Schema , Query files etc.

Create GraphQL types

Create TechEventInfoType.cs which inherits from ObjectGraphType and set all the fields into the constructor.

ObjectGraphType : Used to expose GraphQL types in our schema, “T” here is model.
ListGraphType : Used to define GraphQL Collection.

TechEventInfoType.cs

using GraphQL.API.Infrastructure.DBContext;  
using GraphQL.API.Infrastructure.Repositories;  
using GraphQL.Types;  

namespace GraphQL.API.GraphqlCore  
{  
    public class TechEventInfoType : ObjectGraphType<TechEventInfo>  
    {  
        public TechEventInfoType(ITechEventRepository repository)  
        {  
            Field(x => x.EventId).Description("Event id.");  
            Field(x => x.EventName).Description("Event name.");  
            Field(x => x.Speaker).Description("Speaker name.");  
            Field(x => x.EventDate).Description("Event date.");  

            Field<ListGraphType<ParticipantType>>(  
              "participants",  
              arguments: new QueryArguments(new QueryArgument<IntGraphType> { Name = "eventId" }),  
              resolve: context => repository.GetParticipantInfoByEventId(context.Source.EventId)  
           );  
        }  
    }
}

Here, Field() is nothing but used to expose to client If you have any specific domain property and that you don’t want to expose – don’t need to add into constructor. Also, we can set description of each field. Those descriptions will actually populate back to the client when they use graphical and they view the schema.

In this TechEventInfoType, we added Field called “participants” as we want to expose participants along with events and Field will be like Field> (Name, Arguments, Resolve Func)

Name (i.e. “participants”) is basically name of the field. Arguments (e.g. “eventId”) is nothing but used as input to resolver function. Resolve function is going to get invoked in GetParticipantInfoByEventId() to retrieve participants from repository.

Similarly, for Participants we need to create ParticipantType.cs.

using GraphQL.API.Infrastructure.DBContext;  
using GraphQL.Types;  

namespace GraphQL.API.GraphqlCore  
{  
    public class ParticipantType : ObjectGraphType<Participant>  
    {  
        public ParticipantType()  
        {  
            Field(x => x.ParticipantId).Description("Participant id.");  
            Field(x => x.ParticipantName).Description("Participant name.");  
            Field(x => x.Email).Description("Participant Email address.");  
            Field(x => x.Phone).Description("Participant phone number.");  
        }  
    }  
}

Create a GraphQL query object

Now we're going to create our query which will be exposed to client.

Return a TechEventInfo based on Id.
Return a list of TechEventInfo.

Here, ObjectGraphType we're just going to put object and that's because we don't have an existing class that we're mapping to.

TechEventQuery.cs

using GraphQL.API.Infrastructure.Repositories;  
using GraphQL.Types;  

namespace GraphQL.API.GraphqlCore  
{  
    public class TechEventQuery : ObjectGraphType<object>  
    {  
        public TechEventQuery(ITechEventRepository repository)  
        {  
            Name = "TechEventQuery";  

            Field<TechEventInfoType>(  
               "event",  
               arguments: new QueryArguments(new QueryArgument<IntGraphType> { Name = "eventId" }),  
               resolve: context => repository.GetTechEventById(context.GetArgument<int>("eventId"))  
            );  

            Field<ListGraphType<TechEventInfoType>>(  
             "events",  
             resolve: context => repository.GetTechEvents()  
          );  
        }  
    }  
}

Create schema object to expose the query

Schema will be used to resolve the query. We will resolve the previously created query; i.e., TechEventQuery.cs and dependency resolver is going to be necessary in order for dependency injection to work.

TechEventSchema.cs

using GraphQL.Types;  
using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Threading.Tasks;  

namespace GraphQL.API.GraphqlCore  
{  
    public class TechEventSchema : Schema  
    {  
        public TechEventSchema(IDependencyResolver resolver)  
        {  
            Query = resolver.Resolve<TechEventQuery>();  
            DependencyResolver = resolver;  
        }  

    }  
}

Register all types in Startup.cs

Now start registering the types, query and Schema that we created so far. To do this, Add the below code snippet under configureservices in startup.cs.

services.AddSingleton<TechEventInfoType>();  
services.AddSingleton<ParticipantType>();  
services.AddSingleton<TechEventQuery>();  
var sp = services.BuildServiceProvider();  
services.AddSingleton<ISchema>(new TechEventSchema(new FuncDependencyResolver(type => sp.GetService(type))));

Then before the app.UseMvc(); add the following line in configure method :

app.UseGraphiQl("/graphql");

Web API Controller

You can now create a GraphQLController with a single action method/endpoint that handles every incoming query that our schema supports. The client will always be sending the POST request which will contain the query name, operation name, and the variables. You can create a new class called GraphqlQuery.cs that will serve as a model for all queries from the client.

GraphqlQuery.cs

using Newtonsoft.Json.Linq;  

namespace GraphQL.API.GraphqlCore  
{  
  public class GraphqlQuery  
    {  
    public string OperationName { get; set; }  
    public string NamedQuery { get; set; }  
    public string Query { get; set; }  
    public JObject Variables { get; set; }  
  }  
}

GraphQLController.cs

using System.Threading.Tasks;  
using GraphQL.API.GraphqlCore;  
using GraphQL.Types;  
using Microsoft.AspNetCore.Mvc;  


namespace GraphQL.API.Controllers  
{  
    [Route("[controller]")]  
    [ApiController]  
    public class GraphQLController : ControllerBase  
    {  
        private readonly IDocumentExecuter _documentExecuter;  
        private readonly ISchema _schema;  
        public GraphQLController(ISchema schema, IDocumentExecuter documentExecuter)  
        {  
            _schema = schema;  
            _documentExecuter = documentExecuter;  
        }  

        [HttpPost]  
        public async Task<IActionResult> PostAsync([FromBody] GraphqlQuery query)  
        {  
            if (query == null) { throw new ArgumentNullException(nameof(query)); }  
            var inputs = query.Variables.ToInputs();  
            var executionOptions = new ExecutionOptions  
            {  
                Schema = _schema,  
                Query = query.Query,  
                Inputs = inputs  
            };  

            var result = await _documentExecuter.ExecuteAsync(executionOptions);  

            if (result.Errors?.Count > 0)  
            {  
                return BadRequest(result);  
            }  

            return Ok(result);  
        }  
    }  
}

Add below in startup.cs

services.AddSingleton<IDocumentExecuter, DocumentExecuter>();

In REST, as a rule, we use the HTTP GET verb to fetch data. In GraphQL we can certainly still use GET requests for fetching data however that means we must store our "query" in the query string of the URL ie. api/graphql?query=.... A cleaner approach is to send the query in the JSON-encoded body of a POST request.

At the starting stage, we added a NuGet package called GraphiQL which will provide the UI where we can write our GraphQL queries and at the same time, we can see the result. For that, we need to browse the graphql path. We can configure the same at the launch of the browser.

Now we are done with demo project, let’s see overall folder and file structure of it:

Now we are ready to run our demo application and test GraphQL query. Once it’s loaded in browser, you will see below GraphiQL screen. On the left side, we have a query input section and at the right side, the result section. You can see query schema on Document Explorer section. On left top section, you will play button to execute your query.

GraphiQL an in-browser IDE for exploring GraphQL. GraphiQL features include: Syntax highlighting Intelligent type ahead of fields, arguments, types, and more. Real-time error highlighting and reporting. Automatic query completion.

Test GraphQL Query:

To get event details with participants by event id , you can write below query.

Similarly, to get participant name for each event:

Whatever data you need from Techevent entity, you can easily get it without modifying any code or adding addition endpoints - which resolved over fetching and under fetching problem in REST.
We can test the same GraphQL API using postman tool. Below screenshot for your reference.

Till now we discussed on GraphQL query, in next post we will talk about Mutation which is nothing but modifying the data.

Conclusion:

I hope this post has helped you gain some insight into GraphQL. It’s too flexible, isn’t it? It can provide developer to building and delivering data-rich APIs over REST. Last but not the least, there is a misconception around GraphQL is that being a database technology. GraphQL is a query language for APIs - not databases.

Finally , all the code demonstrated here can be found in the GitHub.