Bagaimana menghubungkan GraphQL dan PostgreSQL

GraphQL adalah agnostik basis data, jadi Anda dapat menggunakan apa pun yang biasa Anda gunakan untuk berinteraksi dengan basis data, dan menggunakan resolve kueri atau mutasi metode untuk memanggil fungsi yang telah Anda tetapkan yang akan mendapatkan/menambahkan sesuatu ke database.

Tanpa Relay

Berikut adalah contoh mutasi menggunakan pembuat kueri Knex SQL berbasis janji, pertama tanpa Relay untuk merasakan konsepnya. Saya akan berasumsi bahwa Anda telah membuat userType dalam skema GraphQL Anda yang memiliki tiga bidang:id , username , dan created :semua diperlukan, dan Anda memiliki getUser fungsi yang sudah ditentukan yang menanyakan database dan mengembalikan objek pengguna. Di database saya juga punya password kolom, tetapi karena saya tidak ingin pertanyaan itu, saya meninggalkannya dari userType . saya .

// 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,
        })
      ),
    },
  }),
});

Sejak Postgres membuat id untuk saya dan saya menghitung created stempel waktu, saya tidak membutuhkannya dalam kueri mutasi saya.

Jalan Relay

Menggunakan pembantu di graphql-relay dan menempel cukup dekat dengan Relay Starter Kit membantu saya, karena banyak hal yang harus dilakukan sekaligus. Relay mengharuskan Anda menyiapkan skema dengan cara tertentu agar dapat berfungsi dengan baik, tetapi idenya sama:gunakan fungsi Anda untuk mengambil atau menambahkan ke database dalam metode penyelesaian.

Satu peringatan penting adalah bahwa cara Relay mengharapkan objek dikembalikan dari getUser adalah turunan dari kelas User , jadi Anda harus mengubah getUser untuk mengakomodasi itu.

Contoh terakhir menggunakan Relay (fromGlobalId , globalIdField , mutationWithClientMutationId , dan nodeDefinitions semuanya dari 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),
    },
  }),
});