{"id":464,"date":"2025-04-12T12:10:34","date_gmt":"2025-04-12T12:10:34","guid":{"rendered":"https:\/\/imcodinggenius.com\/?p=464"},"modified":"2025-04-12T12:10:34","modified_gmt":"2025-04-12T12:10:34","slug":"spring-for-graphql-with-kotlin-coroutines","status":"publish","type":"post","link":"https:\/\/imcodinggenius.com\/?p=464","title":{"rendered":"Spring for GraphQL with Kotlin Coroutines"},"content":{"rendered":"

At the end of this article, you will know precisely how to create a Spring Boot GraphQL<\/strong> application that exposes queries<\/strong> and mutations<\/strong> with the help of Kotlin suspended functions<\/strong> and Flows<\/strong>. <\/p>\n

Long story short, we will see: <\/p>\n

how to prepare a GraphQL schema,<\/p>\n

what imports are necessary to utilize suspended functions,<\/p>\n

how to expose queries, mutations, and map schema with annotated controllers,<\/p>\n

exception handling with GraphQlExceptionHandler <\/p>\n

Create Project <\/h2>\n

As the first step, let\u2019s prepare a brand new project. <\/p>\n

To do so, let\u2019s navigate to the Spring Initializr<\/a> page and select the following imports: <\/p>\n

The project metadata<\/strong> are totally up to you, but when it comes to the dependencies<\/strong>, we must select the Spring Reactive Web<\/em> and Spring for GraphQL<\/em>.<\/p>\n

Thanks to the first one, Spring Boot configures a reactive web stack<\/strong> based on Project Reactor<\/strong> and Netty<\/strong> instead of Tomcat. And given we want to work with GraphQL and <\/strong>Kotlin coroutines, then this is a must-have for us. <\/p>\n

The second provides support for Spring applications built on GraphQL Java. Moreover, it is the successor<\/strong> of the GraphQL Java Spring project from the GraphQL Java team.<\/p>\n

Lastly, let\u2019s download the zip package, extract and import it to our IDE. <\/p>\n

Define GraphQL Schema<\/h2>\n

schema.graphql in Spring <\/h3>\n

As the first step, let\u2019s head to the resources > graphql directory in our project, and let\u2019s insert the schema.graphql file:<\/p>\n

type Query {
\n article(id: ID!): Article
\n articles: [Article!]!
\n}<\/p>\n

type Mutation {
\n createArticle(input: CreateArticleInput!): Article!
\n addComment(articleId: ID!, input: AddCommentInput!): Comment
\n}<\/p>\n

input CreateArticleInput {
\n title: String!
\n content: String!
\n userId: ID!
\n}<\/p>\n

input AddCommentInput {
\n userId: String!
\n content: String!
\n}<\/p>\n

type User {
\n id: ID!
\n name: String!
\n}<\/p>\n

type Article {
\n id: ID!
\n title: String!
\n content: String!
\n author: User!
\n comments: [Comment!]!
\n createdAt: String!
\n}<\/p>\n

type Comment {
\n id: ID!
\n content: String!
\n author: User
\n}<\/p>\n

In Spring Boot, this file is registered automatically as our schema definition. <\/p>\n

And as we can see, we defined 5 things: <\/p>\n

queries<\/strong>\u2013 how a client reads data. Every GraphQL schema must <\/strong>support them,<\/p>\n

mutations<\/strong>\u2013 how a client modifies data, <\/p>\n

inputs<\/strong>\u2013 used to pass structured arguments to our mutations and queries,<\/p>\n

types<\/strong>\u2013 establishing the structure of data we return,<\/p>\n

scalars<\/strong>\u2013 like String, or ID (but also Int, Float, Boolean), describing returned fields.<\/p>\n

Moreover, we can see the exclamation mark- !. In contrast to Kotlin, in GraphQL, we must explicitly define non-nullable types.<\/strong> Meaning, that [Comment] describes a nullable array of nullable Comment type (Array<Comment?>?), whereas [Comment!]! is a not null array with not null items.<\/p>\n

Spring GraphQL Schema Inspection<\/h3>\n

Following, let\u2019s rerun our application. <\/p>\n

As a result, we should get the following in logs: <\/p>\n

o.s.b.a.g.GraphQlAutoConfiguration: GraphQL schema inspection:
\nUnmapped fields: {Query=[article, articles], Mutation=[createArticle, addComment]}
\nUnmapped registrations: {}
\nUnmapped arguments: {}
\nSkipped types: []<\/p>\n

As we can see, Spring Boot verifies the schema we defined every time we start the application. And the above message simply says that we do not have handler methods for our definition.<\/strong><\/p>\n

Let\u2019s fix that then <\/p>\n

Create Models <\/h2>\n

As the next step, let\u2019s add Kotlin data classes to our Spring Boot project. They will be later used to serialize and deserialize data defined in our GraphQL schema.<\/p>\n

To do so, let\u2019s add the Models.kt:<\/p>\n

data class User(
\n val id: String,
\n val name: String,
\n)<\/p>\n

data class Article(
\n val id: String,
\n val title: String,
\n val content: String,
\n val authorId: String,
\n val createdAt: String,
\n)<\/p>\n

data class Comment(
\n val id: String,
\n val content: String,
\n val articleId: String,
\n val userId: String,
\n)<\/p>\n

data class CreateArticleInput(
\n val title: String,
\n val content: String,
\n val userId: String,
\n)<\/p>\n

data class AddCommentInput(
\n val content: String,
\n val userId: String,
\n)<\/p>\n

As we can see, nothing spectacular here. The only interesting fact is that the ID is serialized in the same way as a String.<\/p>\n

QueryMapping as suspend fun<\/h2>\n

Following, let\u2019s learn how the Spring for GraphQL works with Kotlin coroutines. <\/p>\n

According to the documentation:<\/p>\n

Kotlin coroutine and Flow are adapted to Mono and Flux.<\/p>\n

Which means that whenever we use the Spring WebFlux, Spring automatically converts our suspended functions Mono and functions that return Flow to Flux<\/strong> .<\/p>\n

Implement Article Service<\/h3>\n

Before we head to the GraphQL part, let\u2019s make some small preparations.<\/p>\n

Let\u2019s insert the ArticleService:<\/p>\n

@Component
\nobject ArticleService {<\/p>\n

private val articles = mutableListOf(
\n Article(
\n id = «article-id-1»,
\n title = «article-title-1»,
\n content = «article-content-1»,
\n authorId = «user-id-2»,
\n createdAt = LocalDateTime.now().toString()
\n ),
\n Article(
\n id = «article-id-2»,
\n title = «article-title-2»,
\n content = «article-content-2»,
\n authorId = «user-id-2»,
\n createdAt = LocalDateTime.now().toString()
\n ),
\n Article(
\n id = «article-id-3»,
\n title = «article-title-3»,
\n content = «article-content-3»,
\n authorId = «user-id-3»,
\n createdAt = LocalDateTime.now().toString()
\n ),
\n )<\/p>\n

suspend fun findArticleById(id: String): Article? {
\n delay(100)
\n return articles.firstOrNull { it.id == id }
\n }<\/p>\n

}<\/p>\n

As we can see, we use my favorite, in-memory database called mutable list<\/strong> () and expose findArticleById \u2013 a suspended function.<\/p>\n

This function will either find the desired article by ID or return a null value.<\/p>\n

Add ArticleController<\/h3>\n

With that done, let\u2019s add the ArticleController:<\/p>\n

@Controller
\nclass ArticleController(
\n private val articleService: ArticleService,
\n) {<\/p>\n

@QueryMapping
\n suspend fun article(@Argument id: String): Article? =
\n articleService.findArticleById(id)<\/p>\n

}<\/p>\n

As we can see, thanks to the Spring GraphQL, we can leverage the annotation-based approach.<\/p>\n

Firstly, we must annotate our class with the @Controller <\/strong>annotation. Then, all the methods inside it annotated with @SchemaMapping<\/strong> annotation will become handlers. <\/p>\n

And @QueryMapping, @MutationMapping, <\/strong>or @SubscriptionMapping<\/strong> are nothing else than meta annotations (annotated with @SchemaMapping). This way, we achieve a more readable code. <\/p>\n

Additionally, in Spring, we use the @Argument<\/strong> annotation to bind GraphQL input arguments to our Kotlin instances. <\/p>\n

Enable GraphiQL & Test<\/h3>\n

Nextly, let\u2019s turn on the GraphiQL<\/strong>\u2013 the IDE for testing GraphQL APIs (like Postman, Bruno, or Insomnia).<\/p>\n

To do so, let\u2019s navigate to the resources directory and change the application.properties into the application.yaml file:<\/p>\n

spring:
\n application:
\n name: graphsandbox
\n graphql:
\n graphiql:
\n enabled: true<\/p>\n

Then, let\u2019s open up the browser, go to http:\/\/localhost:8080\/graphiql, and put the following: <\/p>\n

query SomeRandomQuery {
\n article(id: «article-id-1») {
\n id
\n title
\n }
\n}<\/p>\n

As we can see, the query<\/strong> name is up to us, but inside it, we must define which of the \u201cexposed\u201d queries we would like to use. As the input parameter, we pass the String value- article-id-1\u2013 and lastly, we define what fields we would like to get in response (that\u2019s what the whole GraphQL is a about, right?).<\/p>\n

So, as the next step, let\u2019s run the query and check out the result: <\/p>\n

{
\n «errors»: [
\n {
\n «message»: «INTERNAL_ERROR for f337f3f3-5»,
\n «locations»: [
\n {
\n «line»: 2,
\n «column»: 3
\n }
\n ],
\n «path»: [
\n «article»
\n ],
\n «extensions»: {
\n «classification»: «INTERNAL_ERROR»
\n }
\n }
\n ],
\n «data»: {
\n «article»: null
\n }
\n}<\/p>\n

Unfortunately, that is not what we expected. <\/p>\n

Moreover, when we check out logs, we should see this:<\/p>\n

s.g.e.ExceptionResolversExceptionHandler : Unresolved NoClassDefFoundError for executionId f337f3f3-5
\njava.lang.NoClassDefFoundError: org\/springframework\/data\/util\/KotlinReflectionUtils
\n\tat org.springframework.graphql.data.method.InvocableHandlerMethodSupport.invokeSuspendingFunction(InvocableHandlerMethodSupport.java:141) ~[spring-graphql-1.3.4.jar:1.3.4]
\n\tat org.springframework.graphql.data.method.InvocableHandlerMethodSupport.doInvoke(InvocableHandlerMethodSupport.java:108) ~[spring-graphql-1.3.4.jar:1.3.4]<\/p>\n

Fix Spring GraphQL Coroutines Issue<\/h3>\n

As we could see, the issue is caused by the missing dependency, and we can easily fix that.<\/p>\n

To do so, let\u2019s open up the build.gradle.kts and add the following dependency:<\/p>\n

implementation(«org.springframework.data:spring-data-commons»)<\/p>\n

Then, let\u2019s sync the gradle project and rerun the application.<\/p>\n

After we run the test again, we should see the following:<\/p>\n

{
\n «data»: {
\n «article»: {
\n «id»: «article-id-1»,
\n «title»: «article-title-1»
\n }
\n }
\n}<\/p>\n

Splendid! Everything works perfectly fine<\/p>\n

Spring GraphQL with Kotlin Flow <\/h2>\n

With that done, let\u2019s learn how to work with Kotlin Flow and Spring GraphQL.<\/p>\n

As the first step, let\u2019s insert a new function to our ArticleService:<\/p>\n

fun findAllArticles(): Flow<Article> = articles.asFlow()<\/p>\n

This way, we produce a cold flow<\/strong> from our list of articles.<\/p>\n

Then, let\u2019s add a new handler:<\/p>\n

@QueryMapping
\nfun articles(): Flow<Article> =
\n articleService.findAllArticles()<\/p>\n

Nothing new this time. Just like previously, we add a new function marked with @QueryMapping<\/strong>.<\/p>\n

When we run the following query in GraphiQL: <\/p>\n

query AnotherOne {
\n articles {
\n id
\n title
\n createdAt
\n }
\n}<\/p>\n

We should see the exact result: <\/p>\n

{
\n «data»: {
\n «articles»: [
\n {
\n «id»: «article-id-1»,
\n «title»: «article-title-1»,
\n «createdAt»: «2025-04-12T13:06:29.142469200»
\n },
\n {
\n «id»: «article-id-2»,
\n «title»: «article-title-2»,
\n «createdAt»: «2025-04-12T13:06:29.142469200»
\n },
\n {
\n «id»: «article-id-3»,
\n «title»: «article-title-3»,
\n «createdAt»: «2025-04-12T13:06:29.142469200»
\n }
\n ]
\n }
\n}<\/p>\n

@SchemaMapping<\/h2>\n

One of the greatest thing in GraphQL is the possibility to return the related data in one, single query. And if you remember our schema definition, our API should allow us to do that.<\/p>\n

To be more specific, each article can have the author<\/strong>, multiple comments<\/strong>, and each comment also has its author<\/strong>.<\/p>\n

But when we test that functionality right now:<\/p>\n

query AnotherOne {
\n articles {
\n id
\n title
\n createdAt
\n author {
\n id
\n name
\n }<\/p>\n

comments {
\n id
\n content
\n author {
\n name
\n }
\n }
\n }
\n}<\/p>\n

The only thing we will get in response will be a looooong list of errors:<\/p>\n

{
\n «errors»: [
\n {
\n «message»: «The field at path ‘\/articles[0]\/author’ was declared as a non null type, but the code involved in retrieving data has wrongly returned a null value. The graphql specification requires that the parent field be set to null, or if that is non nullable that it bubble up null to its parent and so on. The non-nullable type is ‘User’ within parent type ‘Article'»,
\n «path»: [
\n «articles»,
\n 0,
\n «author»
\n ],
\n «extensions»: {
\n «classification»: «NullValueInNonNullableField»
\n }
\n }<\/p>\n

… other errors<\/p>\n

Of course, with Spring we can easily fix it, but we will need small preparation first.<\/p>\n

Update Service<\/h3>\n

Firstly, let\u2019s get back to our service and update it: <\/p>\n

@Component
\nobject ArticleService {<\/p>\n

private val articles = mutableListOf(
\n Article(
\n id = «article-id-1»,
\n title = «article-title-1»,
\n content = «article-content-1»,
\n authorId = «user-id-2»,
\n createdAt = LocalDateTime.now().toString()
\n ),
\n Article(
\n id = «article-id-2»,
\n title = «article-title-2»,
\n content = «article-content-2»,
\n authorId = «user-id-2»,
\n createdAt = LocalDateTime.now().toString()
\n ),
\n Article(
\n id = «article-id-3»,
\n title = «article-title-3»,
\n content = «article-content-3»,
\n authorId = «user-id-3»,
\n createdAt = LocalDateTime.now().toString()
\n ),
\n )<\/p>\n

private val users = mutableListOf(
\n User(id = «user-id-1», name = «user-name-1»),
\n User(id = «user-id-2», name = «user-name-2»),
\n User(id = «user-id-3», name = «user-name-3»),
\n )<\/p>\n

private val comments = mutableListOf(
\n Comment(id = «comment-id-1», content = «comment-content-1», articleId = «article-id-1», userId = «user-id-3»),
\n Comment(id = «comment-id-2», content = «comment-content-2», articleId = «article-id-2», userId = «user-id-3»),
\n Comment(id = «comment-id-3», content = «comment-content-3», articleId = «article-id-2», userId = «user-id-2»),
\n Comment(id = «comment-id-4», content = «comment-content-4», articleId = «article-id-3», userId = «user-id-3»),
\n )<\/p>\n

suspend fun findArticleById(id: String): Article? {
\n delay(100)
\n return articles.firstOrNull { it.id == id }
\n }<\/p>\n

fun findAllArticles(): Flow<Article> = articles.asFlow()<\/p>\n

suspend fun findUserById(id: String): User? {
\n delay(100)
\n return users.firstOrNull { it.id == id }
\n }<\/p>\n

fun findCommentsByArticleId(id: String): Flow<Comment> =
\n comments.filter { it.articleId == id }.asFlow()
\n}<\/p>\n

As we can see, we added two more \u201ctables\u201d along with simple functions to obtain data from them. <\/p>\n

Update @Controller<\/h3>\n

Then, let\u2019s update our controller class:<\/p>\n

@SchemaMapping
\nsuspend fun author(article: Article): User =
\n articleService.findUserById(article.authorId)!!<\/p>\n

@SchemaMapping
\nsuspend fun author(comment: Comment): User =
\n articleService.findUserById(comment.userId)!!<\/p>\n

@SchemaMapping
\nfun comments(article: Article): Flow<Comment> =
\n articleService.findCommentsByArticleId(article.id)<\/p>\n

As we can see, this time we leverage the @SchemaMapping<\/strong> annotation for our handlers. Pretty similar to what we did already.<\/p>\n

The interesting part here is the parameters<\/strong>. Every handler takes the parent type as an argument<\/strong>. Meaning, that for the article -> author parent-child relationship, we define the function that takes the article instance as an argument. And that\u2019s it!<\/p>\n

Of course, please the double exclamation (!!) should not land in the real, production-ready code<\/p>\n

Anyway, when we rerun our test now, we will see the following: <\/p>\n

{
\n «data»: {
\n «articles»: [
\n {
\n «id»: «article-id-1»,
\n «title»: «article-title-1»,
\n «createdAt»: «2025-04-12T13:21:17.584507600»,
\n «author»: {
\n «id»: «user-id-2»,
\n «name»: «user-name-2»
\n },
\n «comments»: [
\n {
\n «id»: «comment-id-1»,
\n «content»: «comment-content-1»,
\n «author»: {
\n «name»: «user-name-3»
\n }
\n }
\n ]
\n }<\/p>\n

… more thingies <\/p>\n

And that\u2019s what we expected. Awesome!<\/p>\n

GraphQL Mutations <\/h2>\n

When we run the application right now, we see that we still miss two things that we defined- mutations<\/strong>.<\/p>\n

So, before we add a new handler, let\u2019s implement the following function in our service:<\/p>\n

suspend fun createArticle(input: CreateArticleInput): Article {
\n delay(100)<\/p>\n

return Article(
\n id = UUID.randomUUID().toString(),
\n title = input.title,
\n content = input.content,
\n authorId = input.userId,
\n createdAt = LocalDateTime.now().toString(),
\n ).also { articles.add(it) }
\n}<\/p>\n

As can be seen, we take the input, create a new Article instance, and insert that to the list.<\/p>\n

With Kotlin also ,we can return at the same time the created instance and achieve a slightly cleaner code. To be even fancier, we could use a reference here: .also(articles::add) <\/p>\n

Then, let\u2019s add the appropriate handler to our controller:<\/p>\n

@MutationMapping
\nsuspend fun createArticle(@Argument input: CreateArticleInput): Article =
\n articleService.createArticle(input)<\/p>\n

As we can see, just like with @QueryMapping, this time, we mark the handler with @MutationMapping<\/strong> and our argument with @Argument<\/strong>. Nothing else is necessary to make our mutation work. <\/p>\n

So, given that, let\u2019s rerun the app and test our functionality:<\/p>\n

mutation someMutation {
\n createArticle(
\n input: {
\n title: «Awesome codersee Kotlin article»,
\n content: «Some content»,
\n userId: «user-id-3»
\n }
\n ) {
\n id
\n title
\n content
\n author {
\n id
\n name
\n }
\n }
\n}<\/p>\n

As a result, we should get the following:<\/p>\n

{
\n «data»: {
\n «createArticle»: {
\n «id»: «0e51a902-835b-4e55-9b4a-f2dccd242ea7»,
\n «title»: «Awesome codersee Kotlin article»,
\n «content»: «Some content»,
\n «author»: {
\n «id»: «user-id-3»,
\n «name»: «user-name-3»
\n }
\n }
\n }
\n}<\/p>\n

Wonderful! We can see that with GraphQL mutations, we can not only create\/modify things on our server. With this one query, we can also retrieve the data and the dependent objects<\/p>\n

Error Handling in Spring GraphQL<\/h2>\n

As the last step, let\u2019s add one more mutation to learn more about error handling<\/strong>.<\/p>\n

First, let\u2019s add the new custom exception ot our codebase in Models.kt:<\/p>\n

data class GenericNotFound(val msg: String) : RuntimeException(msg)<\/p>\n

Then, let\u2019s implement the following function in ArticleService:<\/p>\n

suspend fun addComment(id: String, input: AddCommentInput): Comment {
\n delay(100)<\/p>\n

users.firstOrNull { it.id == input.userId }
\n ?: throw GenericNotFound(«User not found»)<\/p>\n

return articles.firstOrNull { it.id == id }
\n ?.let {
\n Comment(
\n id = UUID.randomUUID().toString(),
\n articleId = id,
\n content = input.content,
\n userId = input.userId,
\n ).also { comments.add(it) }
\n }
\n ?: throw GenericNotFound(«Article not found»)<\/p>\n

}<\/p>\n

This time, we can see a more production-ready code.<\/p>\n

If we want to add a comment to the article, we must first check if both the desired author and article exist, right?<\/p>\n

If that is not the case, then we throw our custom exception.<\/p>\n

Following, let\u2019s add a new mutation handler: <\/p>\n

@MutationMapping
\nsuspend fun addComment(
\n @Argument id: String,
\n @Argument input: AddCommentInput,
\n): Comment =
\n articleService.addComment(id, input)<\/p>\n

Now, when we rerun the app and execute the following test: <\/p>\n

mutation anotherMutation {
\n addComment(
\n articleId: «non-existing»
\n input: {userId: «user-id-1», content: «My comment»}
\n ) {
\n id
\n content
\n }
\n}<\/p>\n

We will see the following error: <\/p>\n

{
\n «errors»: [
\n {
\n «message»: «INTERNAL_ERROR for f62a4c7e-1»,
\n «locations»: [
\n {
\n «line»: 52,
\n «column»: 3
\n }
\n ],
\n «path»: [
\n «addComment»
\n ],
\n «extensions»: {
\n «classification»: «INTERNAL_ERROR»
\n }
\n }
\n ],
\n «data»: {
\n «addComment»: null
\n }
\n}<\/p>\n

And this is not what we wanted, right? <\/p>\n

GraphQlExceptionHandler and ControllerAdvice<\/h3>\n

One of the solutions we can have in such a situation is a combination of ControllerAdvice and GraphQlExceptionHandler.<\/p>\n

If you would like to learn more about ControllerAdvice and RestControllerAdvice, then check out my other article<\/a>.<\/p>\n

So, as the next step, let\u2019s add the GlobalExceptionHandler class to the project:<\/p>\n

@ControllerAdvice
\nclass GlobalExceptionHandler {<\/p>\n

@GraphQlExceptionHandler
\n fun handleGenericNotFound(ex: GenericNotFound): GraphQLError =
\n GraphQLError.newError()
\n .errorType(ErrorType.DataFetchingException)
\n .message(ex.msg)
\n .build()
\n}<\/p>\n

As we can see, inside it, we implement a function that takes the GenericNotFound<\/strong> as an argument. This way, whenever our custom exception is thrown, Spring will return the GraphQLError<\/strong> instance with our config instead.<\/p>\n

As a result, when we retest the application, we should get the following JSON:<\/p>\n

{
\n «errors»: [
\n {
\n «message»: «Article not found»,
\n «locations»: [],
\n «extensions»: {
\n «classification»: «DataFetchingException»
\n }
\n }
\n ],
\n «data»: {
\n «addComment»: null
\n }
\n}<\/p>\n

Spring GraphQL with Kotlin Coroutines Summary<\/h2>\n

And that\u2019s all for this article on how to work with Kotlin coroutines and Flows in the Spring Boot GraphQL project.<\/p>\n

As always, you can find the source code in my GitHub repostory<\/a>.<\/p>\n

The post Spring for GraphQL with Kotlin Coroutines<\/a> appeared first on Codersee — Kotlin on the backend<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"

At the end of this article, you will know precisely how to create a Spring Boot GraphQL application that exposes queries and mutations with the help of Kotlin suspended functions and Flows. Long story short, we will see: how to prepare a GraphQL schema, what imports are necessary to utilize … <\/p>\n

Read More<\/a><\/div>\n","protected":false},"author":0,"featured_media":465,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-464","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-news"],"_links":{"self":[{"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/posts\/464"}],"collection":[{"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=464"}],"version-history":[{"count":0,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/posts\/464\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=\/wp\/v2\/media\/465"}],"wp:attachment":[{"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=464"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=464"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/imcodinggenius.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=464"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}

What is GraphQL Schema?<\/h3>\n

If you have ever worked with GraphQL before, then you know that compared to the REST, everything starts with schema definition<\/strong>.<\/p>\n

If you haven\u2019t, then GraphQL schema<\/strong> is a file typically written with Schema Definition Language (SDL)<\/strong> that describes how our API clients can interact with our server. To be more specific, inside it, we define the structure of returned data, as well as how consumers can fetch or send us the payloads. <\/p>\n

And even though it may sound like a GraphQL substitute for OpenAPI specs, it is something more. In REST, OpenAPI docs are a nice addition to our project. In GraphQL, our services continuously utilize the schema definition to validate and execute requests against it. <\/p>\n

And if you would like to learn more about GraphQL schema, then check out the official documentation<\/a> later. But for now, let\u2019s focus on the Spring \/ GraphQL \/ Kotlin combination <\/p>\n