graphql-js | A reference implementation of GraphQL for JavaScript | GraphQL library

Try to use require(“module”) or if that's the way you doing it, you sould try import("module"). Maybe this will help.

To fix issue there was 2 steps to do:

1. In React I should fetch from endpoint with port fetch('http://localhost:3333/graphql',(...))
2. In Node.js there is need to use cors library

I found the answer

Firstly note, apollo-server's gql is actually a re-export from graphql-tag. graphql-tag is a ~150 line package who's default and pretty much only useful export is gql.

Quick bit of background: the graphql-js package provides an official reference implementation of GraphQL in Javascript. It provides two important things basically:

1. The graphql function, which will process any GraphQL query against a GraphQLSchema object (the GraphQLSchema object is how graphql-js represents your parsed schema).
2. A bunch of utility functions and types for building and validating the GraphQLSchema objects used by the graphql function from strings.

Now, this is the part that ultimately confused me: in graphql-js, taking a string and turning it into a GraphQLSchema object is a two step process:

• Step 1: String -> AST (done by the parse function).
• Step 2: AST -> GraphQLSchema (done by the buildASTSchema function).

It is like this is because the AST (Abstract Syntax Tree) is useful to a bunch of other tools which aren't even necessarily aware of GraphQL (for example see https://astexplorer.net/), where as the GraphQLSchema is only meaningful to graphql-js and related softwares.

graphql-js exposes the functions for doing both steps and these are reused by downstream implementors (like Apollo). buildSchema is just a convenience wrapper to combine these two steps. It's literally this:

The first thing you should do is read up on Promises. Promises are a way in JavaScript to encapsulate computations that are still ongoing. This is usually the case when you talk to an external service like a database or the operating system. They have been replacing callback style APIs.

In GraphQL a resolver can either return a value or a Promise that resolves to a value. This means, you can freely choose returning a value or a Promise, but if you call a database function like Prisma, you will get a Promise back, so you are kind of forced to stay "in Promise land", as there is no way to turn a Promise into a value. You can only chain functions, that should be executed with the value "in the future" (with then).

The last concept to understand is async/await. These async syntax is an addition to JavaScript syntax, that makes working with Promises easier. With await, you can stop the execution of a function until a value in a Promise arrives. Now, this looks like you are turning a Promise back into a value, but in reality, you function implicitly returns a Promise. For the VM to know about this, you have to state, that a function might use async by adding the keyword await in front of the function.

So when do you use async for a resolver? You could do it all the time, and the code would be correct. But doing it, even when you don't need to (e.g. you are not talking to a service) might have some performance implications. So it's better to only do it, if you really want to use the await keyword somewhere. I hope this can get you started with the concepts above, there is really a lot to learn. Maybe just go with your intuition and TypeScript errors until you deeply understand what is going on.

This part is not strictly related to auth [reasons] ... creating post mutation will work without that. But:

• post mutation creates an [Link] entry with a relation (to User in prisma schema meaning docs );
• postedBy is a virtual field - 'Relation fields define connections between models at the Prisma level and do not exist in the database. ';
• post mutation returns a Post type - then 'asked' return object can contain postedBy field (and its User object/type subfield[-s]);
• when postedBy field is queried (as part of mutation result tree), it (related User object/type - graphql context) must be resolved using function postedBy(parent, args, context);

In resolver body we're using/working with "Prisma client" - ORM lib, then:

I think it depends on your use cases. Says you only maintain 1-way pointer that keeps books array in author document, if you have a use case that requires searching for author by a certain book, you will need to do a full collection scan of author collection to find all matches. So without much knowledge of your actual scenario, it could be hard for us to comment on the necessity of 2 way pointer in your database.

This document is a good piece for your reading.

Since you have mentioned about using neo4j-graphql-js library. You can do something like this:

I was accidentally running