GraphQL और PostgreSQL को कैसे कनेक्ट करें

GraphQL डेटाबेस अज्ञेयवादी है, इसलिए आप डेटाबेस के साथ इंटरैक्ट करने के लिए सामान्य रूप से जो कुछ भी उपयोग करते हैं उसका उपयोग कर सकते हैं, और क्वेरी या म्यूटेशन के resolve का उपयोग कर सकते हैं। किसी फ़ंक्शन को कॉल करने की विधि जिसे आपने परिभाषित किया है जो डेटाबेस में कुछ प्राप्त/जोड़ देगा।

बिना रिले के

यहाँ वादा-आधारित Knex SQL क्वेरी बिल्डर का उपयोग करते हुए एक उत्परिवर्तन का एक उदाहरण दिया गया है, पहले रिले के बिना अवधारणा के लिए एक अनुभव प्राप्त करने के लिए। मुझे लगता है कि आपने अपने ग्राफक्यूएल स्कीमा में एक उपयोगकर्ता प्रकार बनाया है जिसमें तीन फ़ील्ड हैं:id , username , और created :सभी आवश्यक हैं, और यह कि आपके पास एक getUser है फ़ंक्शन पहले से ही परिभाषित है जो डेटाबेस से पूछताछ करता है और उपयोगकर्ता ऑब्जेक्ट देता है। डेटाबेस में मेरे पास एक password भी है कॉलम, लेकिन चूंकि मैं नहीं चाहता कि वह पूछताछ की जाए, इसलिए मैं इसे अपने 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,
        })
      ),
    },
  }),
});

चूंकि Postgres id . बनाता है मेरे लिए और मैं created . की गणना करता हूं टाइमस्टैम्प, मुझे अपनी उत्परिवर्तन क्वेरी में उनकी आवश्यकता नहीं है।

रिले वे

graphql-relay . में हेल्पर्स का उपयोग करना और रिले स्टार्टर किट के काफी करीब रहने से मुझे मदद मिली, क्योंकि इसमें एक साथ बहुत कुछ लेना था। रिले के लिए आवश्यक है कि आप अपना स्कीमा एक विशिष्ट तरीके से सेट करें ताकि यह ठीक से काम कर सके, लेकिन विचार एक ही है:समाधान विधियों में डेटाबेस से लाने या जोड़ने के लिए अपने कार्यों का उपयोग करें।

एक महत्वपूर्ण चेतावनी यह है कि रिले तरीका उम्मीद करता है कि वस्तु getUser . से वापस आ जाएगी एक वर्ग का उदाहरण है User , इसलिए आपको संशोधित करना होगा getUser इसे समायोजित करने के लिए।

रिले का उपयोग करने वाला अंतिम उदाहरण (fromGlobalId , globalIdField , mutationWithClientMutationId , और nodeDefinitions सभी 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),
    },
  }),
});