> For the complete documentation index, see [llms.txt](https://docs.code.store/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.code.store/getting-started/fundamentals/services/graphql.md).

# GraphQL

## Overview

code.store platform supports GraphQL and allows you to set up your GraphQL API in the quickest way. To make a developer's life easier code.store platform:

* by default runs GraphQL [Apollo Server](https://www.apollographql.com/docs/apollo-server/)
* provides an opportunity to generate database entities based on `graphql.schema`
* generate resolvers for your queries and mutations
* secure your GraphQL API from massive complex requests and DDoS attacks, and allows you to configure GraphQL query costs

Basic information about GraphQL can be found in [Recipes - GraphQL](/getting-started/recipes/graphql-schemas.md) section.

## Endpoint

By default, code.store platform runs [Apollo Server](https://www.apollographql.com/docs/apollo-server/) and GraphQL playground available via `/graphql` endpoint.

Local development: 

```graphql
http://localhost:3000/graphql
```

Remote address:

```graphql
  https://api.code.store/{service_url_hash}/graphql
```

### Schema

When you create a new service, we code.store platform generating it with default `schema.graphql` file, which contains services GraphQL schema. You can find it in `src` directory of the generated project. Generated file contains a simple `helloWorld` query:

```graphql
type Query {
    helloWorld: String!
}
```

It's a very basic schema of an API that has a single `Query` called `helloWorld` (which doesn't accept arguments) and which returns a single output of type `string`. You can query it using GraphQL playground, which available on `/graphql` endpoint or execute next command using CLI:

```graphql
curl \
  -X POST \
  -H "Content-Type: application/json" \
  --data '{ "query": "{ helloWorld }" }' \
  https://api.code.store/{service_url_hash}/graphql
```

Please, replace `service_url_hash` on your service URL hash, which can be found after cs service:info command execution. After `helloWorld` query execution we should get "Hello, World!" response in our terminal:

```graphql
{"data":{"helloWorld":"Hello, World!"}}
```

## Resolvers

Each field, query or mutation, which we specify in `schema.graphql` require resolver. A resolver is a function that's responsible for populating the data for a single field in your schema.

Handler for all queries and mutations, which described in `schema.graphql` file should be placed to `src/resolvers` directory. Each resolver file of your query or mutation should be named the same, as it declared in `graphql.schema` and placed the appropriate directory `src/resolvers/queries` for queries and  `src/resolvers/mutations` for mutations.

For example, in generated service template you can find, that query `helloWorld` in `schema.graphql` have resolver `src/resolvers/queries/helloWorld.ts`

```graphql
import { logger, Resolver } from 'codestore-utils';

const resolver: Resolver = async (parent, args, context, info) => {
  logger.log('This is a helloWorld resolver!', 'helloWorld');
  return 'Hello, World!';
};

export default resolver;

```

{% hint style="info" %}
code.store platform simplifies the process of creating GraphQL resolvers and their handlers using flexible configuration and provides an ability to generate it using **cs generate:resolver** command. 
{% endhint %}

### Context

Each resolver can optionally accept four positional arguments:

`parent` returns value of the previous resolver in the resolver chain for this field's parent

`args` an object that contains all GraphQL arguments provided for this field. For example, when executing a query: `query{ user(id: "4") }`, the args object passed to the user resolver is `{ "id": "4" }`.

`context` an object shared across all resolvers that are executing for a particular operation and has `ResolverContext` type. 

```graphql
export interface ResolverContext {
    db: {
        connection: Connection;
    };
    request: Request;
    [key: string]: any;
}
```

As you can see, context allows receiving database `connection` and provide access to `request` object, which includes such objects as `headers`, `method`, `url`...

`info` contains information about the operation's execution state, including the field name, the path to the field from the root, and more.

##


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.code.store/getting-started/fundamentals/services/graphql.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.