Assume you have a GraphQL type and it includes many fields.
How to query all the fields without writing down a long query that includes the names of all the fields?
    
For example, If I have these fields :

     public function fields()
        {
            return [
                &#39;id&#39; =&gt; [
                    &#39;type&#39; =&gt; Type::nonNull(Type::string()),
                    &#39;description&#39; =&gt; &#39;The id of the user&#39;
                ],
                &#39;username&#39; =&gt; [
                    &#39;type&#39; =&gt; Type::string(),
                    &#39;description&#39; =&gt; &#39;The email of user&#39;
                ], 
                 &#39;count&#39; =&gt; [
                    &#39;type&#39; =&gt; Type::int(),
                    &#39;description&#39; =&gt; &#39;login count for the user&#39;
                ]
                
            ];
        }

To query all the fields usually the query is something like this: 

    FetchUsers{users(id:&quot;2&quot;){id,username,count}}
But I want a way to have the same results without writing all the fields, something like this:

    FetchUsers{users(id:&quot;2&quot;){*}}
    //or
    FetchUsers{users(id:&quot;2&quot;)}

Is there a way to do this in GraphQL ??

I&#39;m using *Folkloreatelier/laravel-graphql* library.

How to query all the GraphQL type fields without writing a long query?

I&#39;m trying to understand where GraphQL is most suitable to use within a microservice architecture. 

There is some debate about having only 1 GraphQL schema that works as API Gateway proxying the request to the targeted microservices and coercing their response. Microservices still would use REST / Thrift protocol for communication though.

Another approach is instead to have multiple GraphQL schemas one per microservice. Having a smaller API Gateway server that route the request to the targeted microservice with all the information of the request + the GraphQL query.

**1st Approach**

Having 1 GraphQL Schema as an API Gateway will have a downside where every time you change your microservice contract input/output, we have to change the GraphQL Schema accordingly on the API Gateway Side.

**2nd Approach**

If using Multiple GraphQL Schema per microservices, make sense in a way because GraphQL enforces a schema definition, and the consumer will need to respect input/output given from the microservice.

**Questions**

- Where do you find GraphQL the right fit for designing microservice architecture? 

- How would you design an API Gateway with a possible GraphQL implementation?

When and How to use GraphQL with microservice architecture

I&#39;m learning `graphql` and using `prisma-binding` for graphql operations. I&#39;m facing this `nodemon` error while I&#39;m starting my node server and its giving me the path of schema file which is auto generated by a `graphql-cli`. Can anyone tell me what this error is all about? 

Error: 

    Internal watch failed: ENOSPC: System limit for number of file watchers reached, watch &#39;/media/rehan-sattar/Development/All projects/GrpahQl/graph-ql-course/graphql-prisma/src/generated

Nodemon Error: System limit for number of file watchers reached

&gt; GraphQL consists of a type system, query language and execution
&gt; semantics, static validation, and type introspection, each outlined
&gt; below. To guide you through each of these components, we&#39;ve written an
&gt; example designed to illustrate the various pieces of GraphQL.

 \- https://github.com/facebook/graphql

&gt; Falcor lets you represent all your remote data sources as a single
&gt; domain model via a virtual JSON graph. You code the same way no matter
&gt; where the data is, whether in memory on the client or over the network
&gt; on the server.

 \- http://netflix.github.io/falcor/

What is the difference between Falcor and GraphQL (in the context of Relay)?

What is the difference between Falcor and GraphQL?

I am consuming a GraphQL endpoint and I get results that contain `edges` and `node` tags. I am supplying a clean JSON structure for my query, so this doesn&#39;t make sense to me.

It seems as if the GraphQL server is polluting my data with no obvious benefit. Why are these terms included in the GraphQL endpoint&#39;s response and is it possible to get rid of those for faster/simpler parsing of data?

In GraphQL what&#39;s the meaning of &quot;edges&quot; and &quot;node&quot;?

Could you please explain why if input argument of mutation is object it should be **input type**? I think much simpler just reuse **type** without providing id.

For example:

    type Sample {
      id: String
      name: String
    }

    input SampleInput {
      name: String
    }

    type RootMutation {
      addSample(sample: Sample): Sample  # &lt;-- instead of it should be
      addSample(sample: SampleInput): Sample
    }

It&#39;s okay for small object, but when you have plenty of objects with 10+ properties in schema that&#39;ll become a burden.

What&#39;s the point of input type in GraphQL?

I&#39;m testing my GraphQL api using Jest.

I&#39;m using a separate test suit for each query/mutation

I have 2 tests (each one in a separate test suit) where I mock one function (namely, Meteor&#39;s `callMethod`) that is used in mutations.


      it(&#39;should throw error if email not found&#39;, async () =&gt; {
        callMethod
          .mockReturnValue(new Error(&#39;User not found [403]&#39;))
          .mockName(&#39;callMethod&#39;);
    
        const query = FORGOT_PASSWORD_MUTATION;
        const params = { email: &#39;user@example.com&#39; };
    
        const result = await simulateQuery({ query, params });
    
        console.log(result);
    
        // test logic
        expect(callMethod).toBeCalledWith({}, &#39;forgotPassword&#39;, {
          email: &#39;user@example.com&#39;,
        });
    
        // test resolvers
      });

When I `console.log(result)` I get       

    { data: { forgotPassword: true } }

This behaviour is not what I want because in `.mockReturnValue` I throw an Error and therefore expect `result` to have an error object

Before this test, however, another is ran

     it(&#39;should throw an error if wrong credentials were provided&#39;, async () =&gt; {
        callMethod
          .mockReturnValue(new Error(&#39;cannot login&#39;))
          .mockName(&#39;callMethod&#39;);

And it works fine, the error is thrown

I guess the problem is that mock doesn&#39;t get reset after the test finishes.
In my `jest.conf.js` I have   `clearMocks: true`


Each test suit is in a separate file, and I mock functions before tests like this:

    import simulateQuery from &#39;../../../helpers/simulate-query&#39;;
    
    import callMethod from &#39;../../../../imports/api/users/functions/auth/helpers/call-accounts-method&#39;;
    
    import LOGIN_WITH_PASSWORD_MUTATION from &#39;./mutations/login-with-password&#39;;
    
    jest.mock(
      &#39;../../../../imports/api/users/functions/auth/helpers/call-accounts-method&#39;
    );
    
    describe(&#39;loginWithPassword mutation&#39;, function() {
    ...



**UPDATE**

When I substituted `.mockReturnValue` with `.mockImplementation` everything worked out as expected:

    callMethod.mockImplementation(() =&gt; {
      throw new Error(&#39;User not found&#39;);
    });

But that doesn&#39;t explain why in another test `.mockReturnValue` works fine...

How to properly make mock throw an error in Jest?

All the articles about GraphQL will tell you how wonderful it is, but are there any disadvantages or shortcomings to it? Thank you.

Are there any disadvantages to GraphQL?

In a schema file that I have I noticed there are exclamation marks after some types, like

```graphql
# Information on an account relationship
type AccountEdge {
  cursor: String!
  node: Account!
}
```

What do these mean? I can&#39;t find anything about it in the documentation or through googling &#128517;

What is an exclamation point in GraphQL?

I want to get the schema from the server.
I can get all entities with the types but I&#39;m unable to get the properties.

Getting all types:

    query {
      __schema {
        queryType {
          fields {
            name
            type {
              kind
              ofType {
                kind
                name
              }
            }
          }
        }
      }
    }

How to get the properties for type:

    __type(name: &quot;Person&quot;) {
        kind
        name
        fields {
          name
          type {
            kind
            name
            description
          }
        }
      }

How can I get all types with the properties in only 1 request? Or ever better: How can I get the whole schema with the mutators, enums, types ...

Get GraphQL whole schema query

I use 

    POST type
    URL http://######/graphql
    Body: 
    query: &quot;query: &quot;{&#39;noteTypes&#39;:  {&#39;name&#39;, &#39;label&#39;, &#39;labelColor&#39;, &#39;groupName&#39;, &#39;groupLabel&#39;, &#39;imageUrl&#39;}}&quot;

But it return 
**&quot;message&quot;: &quot;Must provide query string.&quot;**


How to send graphql query by postman?

I&#39;m currently trying GraphQL with NodeJS and I don&#39;t know, why this error occurs with the following query:

    {
      library{
        name,
        user {
          name
          email
        }
      }
    }

I am not sure if the `type` of my `resolveLibrary` is right, because at any example I had a look at they used `new GraphQL.GraphQLList()`, but in my case I really want to return a single user object, not an array of users.

My code:

    const GraphQL = require(&#39;graphql&#39;);
    const DB = require(&#39;../database/db&#39;);
    const user = require(&#39;./user&#39;).type;

    const library = new GraphQL.GraphQLObjectType({
        name: &#39;library&#39;,
        description: `This represents a user&#39;s library`,
        fields: () =&gt; {
            return {
                name: {
                    type: GraphQL.GraphQLString,
                    resolve(library) {
                        return library.name;
                    }
                },
                user: {
                    type: user,
                    resolve(library) {
                        console.log(library.user);
                        return library.user
                    }
                }
            }
        }
    });

    const resolveLibrary = {
        type: library,
        resolve(root) {
            return {
                name: &#39;My fancy library&#39;,
                user: {
                    name: &#39;User name&#39;,
                    email: {
                        email: &#39;test@123.de&#39;
                    }
               }
            }
        }
    }

    module.exports = resolveLibrary;

Error:

    Error: Expected Iterable, but did not find one for field library.user.

So my `library` schema provides a `user` field which returns the right data (the console.log is called).

GraphQL Expected Iterable, but did not find one for field xxx.yyy

Does anyone have any experience with GraphQL and Firebase?
I figure one would place the firebase calls in the resolver of the relevant field, passing some variable from the props of the component into the arguments of the query.

How can we insert new data in Firebase using GraphQL?

Firebase &amp; GraphQL

Looking through the GraphQL documentation for custom scalar types (I&#39;m trying to create my own date type) I&#39;m not sure what the difference between `parseValue` and `parseLiteral` are. 

http://graphql.org/graphql-js/type/#graphqlscalartype

The documentation doesn&#39;t seem to include any descriptions of what the functions are supposed to do.

Can someone let me know what the requirements are?  I&#39;m assuming that `serialize` must serialize the scalar to a string.  Is that correct?  I&#39;m assuming that parseLiteral is a deserialization of that string to the type?  In my case a Date type.  However, in the examples - serialize and parseValue are the same function - which suggests it&#39;s not a simple deserialization method.

what&#39;s the difference between parseValue and parseLiteral in GraphQLScalarType

I have a graphql schema, a fragment of which looks like this:

    type User {
        username: String!
        password: String!
    }

In graphiql, there is a description field, but it always says &quot;self-descriptive&quot;. How do I add descriptions to the schema? 

How do I add a description to a field in &quot;GraphQL schema language&quot;

Graphql is great and I&#39;ve started using it in my app. I have a page that displays summary information and I need graphql to return aggregate counts? Can this be done?

Can graphql return aggregate counts?

In the [tutorial](https://www.howtographql.com/graphql-js/6-authentication/) on GraphQL authentication, the `login` is a **Mutation**:

    type Mutation {
      post(url: String!, description: String!): Link!
      signup(email: String!, password: String!, name: String!): AuthPayload
      login(email: String!, password: String!): AuthPayload
    }

Shouldn&#39;t the login be a ***Query*** since:

1. The operation has no side-effects on the server.
2. The goal is to *query* a token.

Am I missing something here ?

Shouldn&#39;t the login be a Query in GraphQL?

In the Apollo React docs http://dev.apollodata.com/react/queries.html#basics there are examples of fetching automatically when the component is shown, but I&#39;d like to run a query when a button is clicked. I see an example to &quot;re&quot;fetch a query when a button is clicked, but I don&#39;t want it to query initially. I see there is a way to call mutations, but how do you call queries?

Apollo GraphQL React - how to query on click?

With REST we can use Swagger, RAML or other technologies to document our API and generate an HTML documentation that our consumers can read without any need of interaction with the servers.

Does something similar exist for GraphQL? Is there any way to generate a documentation of resources and properties?

Document a GraphQL API

Is there a good comparison of GraphQL &amp; OData in terms of performance, developers usability, community, etc.. All articles that I find in the Internet are very bias.

What would be the best way to return a big bulky JSON or binary data?



OData vs GraphQL

Pardon the naive question, but I&#39;ve looked all over for the answer and all I&#39;ve found is either vague or makes no sense to me. Take this example from the GraphQL spec:

    query getZuckProfile($devicePicSize: Int) {
      user(id: 4) {
        id
        name
        profilePic(size: $devicePicSize)
      }
    }

What is the point of naming this query `getZuckProfile`? I&#39;ve seen something about GraphQL documents containing multiple operations. Does naming queries affect the returned data somehow? I&#39;d test this out myself, but I don&#39;t have a server and dataset I can easily play with to experiment. But it would be good if something in some document somewhere could clarify this--thus far all of the examples are super simple single queries, or are queries that are named but that don&#39;t explain why they are (other than &quot;here&#39;s a cool thing you can do.&quot;) What benefits do I get from naming queries that I don&#39;t have when I send a single, anonymous query per request?

Also, regarding mutations, I see in the spec:

    mutation setName {
      setName(name: &quot;Zuck&quot;) {
        newName
      }
    }

In this case, you&#39;re specifying `setName` twice. Why? I get that one of these is the field name of the mutation and is needed to match it to the back-end schema, but why not:

    mutation {
      setName(name: &quot;Zuck&quot;) {
    ...

What benefit do I get specifying the same name twice? I get that the first is likely arbitrary, but why isn&#39;t it noise? I have to be missing something obvious, but nothing I&#39;ve found thus far has cleared it up for me.

What is the point of naming queries and mutations in GraphQL?

I have several GraphQL queries and mutations, now I&#39;m trying to implement a _delete_ mutation without returning any data:

```
    type Mutation{
        addElement(element: ElementData): ID
        removeElement(id: ID): &#191;?
    }
```

However, it seems to be required to have a return value for the delete operation. Is there a way to perform an &quot;empty&quot; response in GraphQL? I would like to avoid things like returning a boolean or status flag if possible. 

I&#39;m not sure on what are the best practices for GraphQL delete operations.

Is it possible to not return any data when using a GraphQL mutation?

Is it possible to use inheritance with GraphQL input types?

Something like that (this, of course, doesn&#39;t work with input types):

    interface UserInputInterface {
      firstName: String
      lastName: String
    }
    
    input UserInput implements UserInputInterface {
      password: String!
    }
    
    input UserChangesInput implements UserInputInterface {
      id: ID!
      password: String
    }



Can a GraphQL input type inherit from another type or interface?

I&#39;m attempting to set up Apollo GraphQL support in a new React project, but when I try to compile a query using `gql` I keep receiving the error:

&gt; Syntax Error: Expected Name, found }

This is generated by the following code:

    import gql from &#39;graphql-tag&#39;
  
    const query = gql`
        {
          user(id: 5) {
            firstName
            lastName
          }
        }
      `
    
    console.log(query)

I&#39;m basing this code off the example code found here: https://github.com/apollographql/graphql-tag

What is the `Name` referred to in the error message? Does anyone know what I&#39;m doing wrong here?

GraphQL gql Syntax Error: Expected Name, found }

I have been trying to get my head around this problem but haven&#39;t found a strong answer to it. I am trying to execute a login mutation using the `useMutation` hook. 

***TLDR; I want to know what exactly is the difference between the `onError` passed in `options` and `error` given to me by the `useMutation`***

Here&#39;s my code snippet

````
const [login, { data, loading, error }] = useMutation(LOGIN_QUERY, {
  variables: {
    email,
    password
  },
  onError(err) {
    console.log(err);
  },
});

````

On the server-side, I have a preset/hardcoded email used for login and I am not using Apollo or any other client. In the resolver of this Login Mutation, I simply throw an error if the email is not same using
````
throw new Error(&#39;Invalid Email&#39;);
````

Now I want to handle this error on the client-side (React). But my concern is that if I use the &#39;error&#39; returned from the `useMutation` hook and try to show the error in this way

````
render() {
  ...
  {error &amp;&amp; &lt;div&gt; Error occurred &lt;/div&gt;}
  ...
}
````

the error is updated in the UI but then immediately React shows me a screen with:

```
Unhandled Rejection (Error): Graphql error: My-custom-error-message
```

But, if I use `onError` passed in `options` to `useMutate` function, then it doesn&#39;t show me this screen and I can do whatever I want with the error.

I want to know what exactly is the difference between the `onError` passed in `options` and `error` given to me by the `useMutation` and why does React show me that error screen when `onError` is **not** used.

Thanks!

Handling errors with react-apollo useMutation hook

Here is my simple graphql express app

    const express = require(&#39;express&#39;);
    const graphqlHTTP = require(&#39;express-graphql&#39;);
    
    const app = express();
    app.use(
        &#39;/graphql&#39;,
        graphqlHTTP({
          graphiql: true,
        })
      );
    
    app.listen(4000, () =&gt; {
        console.log(&quot;listening for request!&quot;);
    });

I&#39;m getting the following errors when I run it:

     graphqlHTTP({
        ^
    
    TypeError: graphqlHTTP is not a function
        at Object.&lt;anonymous&gt; (D:\PersonalProjects\GraphQL\server\app.js:7:5)
        at Module._compile (internal/modules/cjs/loader.js:1138:30)
        at Object.Module._extensions..js (internal/modules/cjs/loader.js:1158:10)
        at Module.load (internal/modules/cjs/loader.js:986:32)
        at Function.Module._load (internal/modules/cjs/loader.js:879:14)
        at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:71:12)  
        at internal/main/run_main_module.js:17:47

How can I fix it? Thanks in advance!

graphqlHTTP is not a function

How do you prevent a nested attack against an Apollo server with a query such as:


    {
      authors {
        firstName
        posts {
          title
          author {
            firstName
            posts{
              title
              author {
                firstName
                posts {
                  title
                  [n author]
                    [n post]
                }
              }
            }
          }
        }
      }
    }

    
In other words, how can you limit the number of recursions being submitted in a query? This could be a potential server vulnerability. 

How do you prevent nested attack on GraphQL/Apollo server?

When using AWS AppSync with lambda data sources you can encounter N+1 query problem. 

Basically when you have individual field resolver on your type and your query returns an array of those types you field resolver lambda will be called N times.

AWS introduces BatchInvoking lambdas in resolvers to combat this problem. Here you can read more about the problem and their solution: https://docs.aws.amazon.com/appsync/latest/devguide/tutorial-lambda-resolvers.html#advanced-use-case-batching

However, their solution is not working. BatchInvoking lambdas are limited to only 5 events (this is not stated in documentation). It is a slight improvement to the N+1 problem (it makes it N/5+1), but I think it is not enough as more complex queries tend to execute for a very long time and require more lambda invocations.

So my question is how do you deal with this problem? Is there any better solution to this?

N+1 queries in AWS AppSync

Here is the mutation:

    const createNotebook = mutationWithClientMutationId ({
        name: &#39;CreateNotebook&#39;,
        inputFields: {
            token: {
                type: GraphQLString,
            },
    
            details: {
                type: NotebookDetails,
            },
        },
        outputFields: {
    
        },
        async mutateCRNotebook(input, context) {
            const data = getJSONFromRelativeURL(input.token);
    
        },
    });

Here is the schema used in the details field of the mutation: 

    const NotebookDetails = new GraphQLObjectType({
        name: &#39;NotebookDetails&#39;,
        interfaces: [nodeInterface],
    
        fields: () =&gt; ({
    		id: globalIdField(&#39;NotebookDetails&#39;),
    
    		description: {
    			type: GraphQLString,
    			description: &#39;...&#39;,
    			resolve(obj) {
    				return obj.description;
    			},
    		},
    
    		language: {
    			type: GraphQLString,
    			description: &#39;...&#39;,
    			resolve(obj) {
    				return obj.language;
    			},
    		},
    
    	}),
    
    });

Error I am getting on running this code is : 

    api_1    | Error: CreateNotebookInput.details field type must be Input Type but got: NotebookDetails.
    api_1    |     at invariant (/usr/src/app/node_modules/graphql/jsutils/invariant.js:19:11)
    api_1    |     at /usr/src/app/node_modules/graphql/type/definition.js:698:58
    api_1    |     at Array.forEach (native)
    api_1    |     at GraphQLInputObjectType._defineFieldMap (/usr/src/app/node_modules/graphql/type/definition.js:693:16)
    api_1    |     at GraphQLInputObjectType.getFields (/usr/src/app/node_modules/graphql/type/definition.js:682:49)
    api_1    |     at typeMapReducer (/usr/src/app/node_modules/graphql/type/schema.js:224:26)
    api_1    |     at typeMapReducer (/usr/src/app/node_modules/graphql/type/schema.js:190:12)
    api_1    |     at Array.reduce (native)
    api_1    |     at /usr/src/app/node_modules/graphql/type/schema.js:217:36
    api_1    |     at Array.forEach (native)
    api_1    |     at typeMapReducer (/usr/src/app/node_modules/graphql/type/schema.js:210:27)
    api_1    |     at Array.reduce (native)
    api_1    |     at new GraphQLSchema (/usr/src/app/node_modules/graphql/type/schema.js:98:34)
    api_1    |     at Object.&lt;anonymous&gt; (/usr/src/app/src/schema/index.js:39:16)
    api_1    |     at Module._compile (module.js:569:30)
    api_1    |     at Object.Module._extensions..js (module.js:580:10)

I have used this syntax with queries and they worked correctly. But, they are returning error with a mutation.
What is incorrect in my code and how do I correct it?


GraphQL Error field type must be Input Type but got:

Hi I am trying to learn `GraphQL` language. I have below snippet of code.

    // Welcome to Launchpad!
    // Log in to edit and save pads, run queries in GraphiQL on the right.
    // Click &quot;Download&quot; above to get a zip with a standalone Node.js server.
    // See docs and examples at https://github.com/apollographql/awesome-launchpad
    
    // graphql-tools combines a schema string with resolvers.
    import { makeExecutableSchema } from &#39;graphql-tools&#39;;
    
    // Construct a schema, using GraphQL schema language
    const typeDefs = `
    	type User {
    		name: String!
    		age: Int!
    	}
    
     	type Query {
            me: User
    	}
    `;
    
    const user = { name: &#39;Williams&#39;, age: 26};
    
    // Provide resolver functions for your schema fields
    const resolvers = {
      Query: {
        me: (root, args, context) =&gt; {
          return user;
        },
      },
    };
    
    // Required: Export the GraphQL.js schema object as &quot;schema&quot;
    export const schema = makeExecutableSchema({
      typeDefs,
      resolvers,
    });
    
    // Optional: Export a function to get context from the request. It accepts two
    // parameters - headers (lowercased http headers) and secrets (secrets defined
    // in secrets section). It must return an object (or a promise resolving to it).
    export function context(headers, secrets) {
      return {
        headers,
        secrets,
      };
    };
    
    // Optional: Export a root value to be passed during execution
    // export const rootValue = {};
    
    // Optional: Export a root function, that returns root to be passed
    // during execution, accepting headers and secrets. It can return a
    // promise. rootFunction takes precedence over rootValue.
    // export function rootFunction(headers, secrets) {
    //   return {
    //     headers,
    //     secrets,
    //   };
    // };

Request:

    {
      me
    }

Response:

    {
      &quot;errors&quot;: [
        {
          &quot;message&quot;: &quot;Field \&quot;me\&quot; of type \&quot;User\&quot; must have a selection of subfields. Did you mean \&quot;me { ... }\&quot;?&quot;,
          &quot;locations&quot;: [
            {
              &quot;line&quot;: 4,
              &quot;column&quot;: 3
            }
          ]
        }
      ]
    }

Does anyone know what I am doing wrong ? How to fix it ?


Field \&quot;me\&quot; of type \&quot;User\&quot; must have a selection of subfields

For example, a `Pet` is an `Animal` with an `owner` and `name`.

    type Animal {
      species: String
    }
    
    type Pet extends Animal {
      owner: Owner
      name: String
    }



How do you extend types in GraphQL?

I have this input type and I would like to add a default Value to one of the fields. I want to add 0 to the value field inside the ExampleInput.

    type ExampleType {
      value: Int
      another: String
    }

    type Mutation {
      example(input: ExampleInput): ExampleType
    }

    input ExampleInput {
      value: Int
      another: String
    }

Any ideas?





How to add default values to input arguments in graphql

I&#39;m learning GraphQL now and while walking through tutorial I met behavior that I can&#39;t understand.
Let&#39;s say we have defined type in schema: 

    type Link {
      id: ID!
      url: String!
      description: String!
      postedBy: User
      votes: [Vote!]!
    }

Due to docs `votes: [Vote!]!` means that that field should be a non-nullable and array itself should be non-nullable too. But just after that author of tutorial shows example of query and for some of links it returns empty array for `votes` field. Like this: 

    {
     &quot;url&quot;: &quot;youtube.com&quot;,
     &quot;votes&quot;: []
    },
    {
     &quot;url&quot;: &quot;agar.io&quot;,
     &quot;votes&quot;: []
    }

So my question is: Doesn&#39;t &quot;non-nullable&quot; means &quot;empty&quot; in graphQL schema or it&#39;s just some kind of wrong behavior of graphQL server (I mean it returns array of nothing without warning that there should be something due to schema).

Thanks!

GraphQL: Non-nullable array/list

In Relay GraphQL, connections and lists are both array-like, but they have different features. When should I use each?

When should I use a Relay GraphQL connection and when a plain list?

Is it possible to have a define a field as Date or JSON in my graphql schema ?

    type Individual {
		id: Int
		name: String
		birthDate: Date
		token: JSON
	}

actually the server is returning me an error saying : 

    Type &quot;Date&quot; not found in document.
    at ASTDefinitionBuilder._resolveType (****node_modules\graphql\utilities\buildASTSchema.js:134:11)
    
And same error for JSON...

Any idea ?

Date and Json in type definition for graphql

I am using Apollo Client to make an application to query my server using Graphql. I have a python server on which I execute my graphql queries which fetches data from the database and then returns it back to the client. 

I have created a custom NetworkInterface for the client that helps me to make make customized server request (by default ApolloClient makes a POST call to the URL we specify). The network interface only has to have a query() method wherein we return the promise for the result of form `Promise&lt;ExecutionResult&gt;`. 

I am able to make the server call and fetch the requested data but still getting the following error.

    Error: Network error: Error writing result to store for query 
    {
       query something{
          row{
             data
          }
       }
    }
    Cannot read property &#39;row&#39; of undefined
        at new ApolloError (ApolloError.js:32)
        at ObservableQuery.currentResult (ObservableQuery.js:76)
        at GraphQL.dataForChild (react-apollo.browser.umd.js:410)
        at GraphQL.render (react-apollo.browser.umd.js:448)
        at ReactCompositeComponent.js:796
        at measureLifeCyclePerf (ReactCompositeComponent.js:75)
        at ReactCompositeComponentWrapper._renderValidatedComponentWithoutOwnerOrContext (ReactCompositeComponent.js:795)
        at ReactCompositeComponentWrapper._renderValidatedComponent (ReactCompositeComponent.js:822)
        at ReactCompositeComponentWrapper._updateRenderedComponent (ReactCompositeComponent.js:746)
        at ReactCompositeComponentWrapper._performComponentUpdate (ReactCompositeComponent.js:724)
        at ReactCompositeComponentWrapper.updateComponent (ReactCompositeComponent.js:645)
        at ReactCompositeComponentWrapper.performUpdateIfNecessary (ReactCompositeComponent.js:561)
        at Object.performUpdateIfNecessary (ReactReconciler.js:157)
        at runBatchedUpdates (ReactUpdates.js:150)
        at ReactReconcileTransaction.perform (Transaction.js:140)
        at ReactUpdatesFlushTransaction.perform (Transaction.js:140)
        at ReactUpdatesFlushTransaction.perform (ReactUpdates.js:89)
        at Object.flushBatchedUpdates (ReactUpdates.js:172)
        at ReactDefaultBatchingStrategyTransaction.closeAll (Transaction.js:206)
        at ReactDefaultBatchingStrategyTransaction.perform (Transaction.js:153)
        at Object.batchedUpdates (ReactDefaultBatchingStrategy.js:62)
        at Object.enqueueUpdate (ReactUpdates.js:200)

I want to know the possible cause of the error and solution if possible.

Error: Network error: Error writing result to store for query (Apollo Client)

I started out with the `relay-starter-kit` and also worked my way through the Relay and GraphQL documentation. But there are quite a few areas that are unexplained and mysterious.

Seriously I read a lot of documentations everywhere about all these things but couldn&#39;t find any satisfying explanations for the following questions:

What is this for? I put logging but it never even gets called at all:

&lt;!-- language: lang-js --&gt; 

    var {nodeInterface, nodeField} = nodeDefinitions(
      (globalId) =&gt; {
        var {type, id} = fromGlobalId(globalId);
        if (type === &#39;User&#39;) {
          return getUser(id);
        } else if (type === &#39;Widget&#39;) {
          return getWidget(id);
        } else {
          return null;
        }
      },
      (obj) =&gt; {
        if (obj instanceof User) {
          return userType;
        } else if (obj instanceof Widget) {
          return widgetType;
        } else {
          return null;
        }
      }
    );

And what is the actual effect of this:

&lt;!-- language: lang-js --&gt; 

    interfaces: [nodeInterface],

Maybe related to that, what does the `node` field here do:

&lt;!-- language: lang-js --&gt; 

    var queryType = new GraphQLObjectType({
      name: &#39;Query&#39;,
      fields: () =&gt; ({
        node: nodeField,
        // Add your own root fields here
        viewer: {
          type: userType,
          resolve: () =&gt; getViewer(),
        },
      }),
    });

And what is the magic around the `id` field? What is `globalIdField` for?

I have an `id` in my database and thought I could use it in my GraphQL objects:

Instead of:

&lt;!-- language: lang-js --&gt; 

    id: globalIdField(&#39;User&#39;),

I want to use my database id:

&lt;!-- language: lang-js --&gt; 

    id: {
      type: GraphQLID,
      description: &#39;The identifier&#39;
    },

But if I do that I get an error in the browser saying `RelayQueryWriter: Could not find a type name for record &#39;1&#39;`.

I can get rid of that error by adding `__typename` to my component containers Relay Query but that seems all wrong.

It would be great if you could give some deeper insides and a better explanation here and enhance the official documentation.

Thank you

In Relay, what role do the node interface and the global ID spec play?

The [relay docs][1] contain this fragment:

    query RebelsRefetchQuery {
      node(id: &quot;RmFjdGlvbjox&quot;) {
        id
        ... on Faction {
          name
        }
      }
    }

What does this `... on Faction` on syntax mean?

  [1]: https://facebook.github.io/relay/docs/graphql-object-identification.html#content

What do 3 dots/periods/ellipsis in a relay/graphql query mean?

I am trying to start my nestJs server and It keeps giving me this error:

UnhandledPromiseRejectionWarning: Error: You must `await server.start()` before calling `server.applyMiddleware()`
    at ApolloServer

I&#39;m not even sure where to debug from as I am still very new at NestJs and GraphQL.

UnhandledPromiseRejectionWarning: Error: You must `await server.start()` before calling `server.applyMiddleware()` at ApolloServer

I use Express-graphql middleware.
I send the following request in the body line:

    POST /graphql HTTP/1.1
    Host: local:8083
    Content-Type: application/graphql
    Cache-Control: no-cache
    Postman-Token: d71a7ea9-5502-d5fe-2e36-0ae49c635a29
    
    {
       testing {
          pass(id: 1) {
            idn
          }
        }
    }

and have error 

    {
      &quot;errors&quot;: [
        {
          &quot;message&quot;: &quot;Must provide query string.&quot;
        }
      ]
    }

in graphql i can send update in URL.

URL string is too short. i must send update model like

    mutation {
      update(id: 2, x1: &quot;zazaza&quot;, x2: &quot;zazaza&quot;, x3: &quot;zazaza&quot; ...(more more fields)...) {
        idn
      }
    }

i think its must be in request body. How can i send &#39;update&#39; query or that i&#39;m doing wrong?

Graphql post body &quot;Must provide query string.&quot;

I&#39;m trying to query a list of objects having array of IDs. Something similar to following SQL query:

    SELECT name FROM events WHERE id IN(1,2,3,...);

How do I achieve this in GraphQL?

All Graphql Solutions on Gang of Coders

Total of 41 Graphql Solutions