title: What is the difference in using these two methods when building GraphQL queries and mutations?
body: <p>I've been taught two different methods when using GraphQL,</p>
  
  <p>the first method included building out the schema:</p>
  
  <pre><code>    module.exports = buildSchema(`
          type Event {
              _id: ID!
              title: String!
              description: String!
              price: Float!
              date: String!
              creator: User!
           }
      `)
  </code></pre>
  
  <p>then creating the resolver in a separate file: </p>
  
  <pre><code>    module.exports = {
      events: async () =&gt; {
        try {
          const events = await Event.find();
          return events
        } catch (err) {
          throw err;
        }
      }}
  </code></pre>
  
  <p>the second method looks like this:</p>
  
  <pre><code>    const PostType = new GraphQLObjectType({
          name: 'Post',
              fields: () =&gt; ({
              id: { type: GraphQLID },
              title: { type: GraphQLString },
              content: { type: GraphQLString },
              score: { type: GraphQLInt }
              })
          });
  </code></pre>
  
  <pre><code>    const RootQuery = new GraphQLObjectType({
          name: 'RootQuery',
          fields: {
              posts: {
              type: new GraphQLList(PostType),
              resolve(parent, args) {
                  return Post.find();
              }   
          }
      });
  </code></pre>
  
  <p>i've worked with both ways and they both work, but i'm not really sure which methods I should be using, the first method seems simpler, but the second method seems to enforce graphQL types.</p>