Hoe GraphQL en PostgreSQL te verbinden

GraphQL is database-agnostisch, dus u kunt alles gebruiken wat u normaal gesproken gebruikt om met de database te communiceren, en de resolve van de query of mutatie gebruiken methode om een ​​functie aan te roepen die je hebt gedefinieerd en die iets zal ophalen/toevoegen aan de database.

Zonder relais

Hier is een voorbeeld van een mutatie met behulp van de op beloften gebaseerde Knex SQL-querybuilder, eerst zonder Relay om een ​​idee te krijgen van het concept. Ik ga ervan uit dat je een userType in je GraphQL-schema hebt gemaakt met drie velden:id , username , en created :alles vereist, en dat je een getUser . hebt functie al gedefinieerd die de database doorzoekt en een gebruikersobject retourneert. In de database heb ik ook een password kolom, maar aangezien ik niet wil dat die opgevraagd wordt, laat ik het uit mijn userType .

// db.js
// take a user object and use knex to add it to the database, then return the newly
// created user from the db.
const addUser = (user) => (
  knex('users')
  .returning('id') // returns [id]
  .insert({
    username: user.username,
    password: yourPasswordHashFunction(user.password),
    created: Math.floor(Date.now() / 1000), // Unix time in seconds
  })
  .then((id) => (getUser(id[0])))
  .catch((error) => (
    console.log(error)
  ))
);

// schema.js
// the resolve function receives the query inputs as args, then you can call
// your addUser function using them
const mutationType = new GraphQLObjectType({
  name: 'Mutation',
  description: 'Functions to add things to the database.',
  fields: () => ({
    addUser: {
      type: userType,
      args: {
        username: {
          type: new GraphQLNonNull(GraphQLString),
        },
        password: {
          type: new GraphQLNonNull(GraphQLString),
        },
      },
      resolve: (_, args) => (
        addUser({
          username: args.username,
          password: args.password,
        })
      ),
    },
  }),
});

Aangezien Postgres de id . aanmaakt voor mij en ik bereken de created tijdstempel, ik heb ze niet nodig in mijn mutatiequery.

De estafettemanier

De helpers gebruiken in graphql-relay en vrij dicht bij de Relay Starter Kit blijven hielp me, omdat het veel was om in één keer in je op te nemen. Relay vereist dat je je schema op een specifieke manier instelt, zodat het goed kan werken, maar het idee is hetzelfde:gebruik je functies om op te halen uit of toe te voegen aan de database in de oplossingsmethoden.

Een belangrijk voorbehoud is dat de Relay-manier verwacht dat het object wordt geretourneerd door getUser is een instantie van een klasse User , dus u moet getUser . aanpassen om daaraan tegemoet te komen.

Het laatste voorbeeld met Relay (fromGlobalId , globalIdField , mutationWithClientMutationId , en nodeDefinitions zijn allemaal van graphql-relay ):

/**
 * We get the node interface and field from the Relay library.
 *
 * The first method defines the way we resolve an ID to its object.
 * The second defines the way we resolve an object to its GraphQL type.
 *
 * All your types will implement this nodeInterface
 */
const { nodeInterface, nodeField } = nodeDefinitions(
  (globalId) => {
    const { type, id } = fromGlobalId(globalId);
    if (type === 'User') {
      return getUser(id);
    }
    return null;
  },
  (obj) => {
    if (obj instanceof User) {
      return userType;
    }
    return null;
  }
);

// a globalId is just a base64 encoding of the database id and the type
const userType = new GraphQLObjectType({
  name: 'User',
  description: 'A user.',
  fields: () => ({
    id: globalIdField('User'),
    username: {
      type: new GraphQLNonNull(GraphQLString),
      description: 'The username the user has selected.',
    },
    created: {
      type: GraphQLInt,
      description: 'The Unix timestamp in seconds of when the user was created.',
    },
  }),
  interfaces: [nodeInterface],
});

// The "payload" is the data that will be returned from the mutation
const userMutation = mutationWithClientMutationId({
  name: 'AddUser',
  inputFields: {
    username: {
      type: GraphQLString,
    },
    password: {
      type: new GraphQLNonNull(GraphQLString),
    },
  },
  outputFields: {
    user: {
      type: userType,
      resolve: (payload) => getUser(payload.userId),
    },
  },
  mutateAndGetPayload: ({ username, password }) =>
    addUser(
      { username, password }
    ).then((user) => ({ userId: user.id })), // passed to resolve in outputFields
});

const mutationType = new GraphQLObjectType({
  name: 'Mutation',
  description: 'Functions to add things to the database.',
  fields: () => ({
    addUser: userMutation,
  }),
});

const queryType = new GraphQLObjectType({
  name: 'Query',
  fields: () => ({
    node: nodeField,
    user: {
      type: userType,
      args: {
        id: {
          description: 'ID number of the user.',
          type: new GraphQLNonNull(GraphQLID),
        },
      },
      resolve: (root, args) => getUser(args.id),
    },
  }),
});