GraphQL and mongoose relationship

GraphQl and mongosoe each perform their tasks and my question is about retrieving data from database by mongoose and relationship system with graphQl .

in graphQl if there is no scaler types means i have custom types like object or array of objects, so for this type i have to write relation between parent and custom type. i personally think this approach for retrieve a lot of data with async await tasks can be slowly.

i wrote a nodejs server with some data and related relationships as simple as possible. is this the best approach to retreve a lot of data from database?

graphQl schema and relationship:

  type User {
    _id: ID!
    name: String!
    email: String!
    posts: [Post!]!
    comments: [Comment!]!
  }

  type Post {
    _id: ID!
    title: String!
    body: String!
    user: User!
    comments: [Comment!]!
  }

  type Comment {
    _id: ID!
    text: String!
    post: Post!
    user: User!
  }

  type Mutation {
    createUser(name: String!, email: String!): User!
    createPost(title: String!, body: String!, user: String!): Post!
    createComment(text: String!, post: String!, user: String!): Comment!
  }

  type Query {
    getUsers: [User!]!
    getPosts: [Post!]!
    getComments: [Comment!]!
  }

mongoose schema and relationship:

user, post and commnet:

const User = mongoose.model(
  "User",

  new Schema({
    name: {
      type: String,
      required: true
    },

    email: {
      type: String,
      required: true
    },

    posts: [
      {
        type: mongoose.Types.ObjectId,
        ref: "Post"
      }
    ],

    comments: [
      {
        type: mongoose.Types.ObjectId,
        ref: "Comment"
      }
    ]
  })
);

const Post = mongoose.model(
  "Post",

  new Schema({
    title: {
      type: String,
      required: true
    },

    body: {
      type: String,
      required: true
    },

    user: {
      type: mongoose.Types.ObjectId,
      ref: "User"
    },

    comments: [
      {
        type: mongoose.Types.ObjectId,
        ref: "Comment"
      }
    ]
  })
);

const Comment = mongoose.model(
  "Comment",

  new Schema({
    text: {
      type: String,
      required: true
    },

    post: {
      type: mongoose.Types.ObjectId,
      ref: "Post"
    },

    user: {
      type: mongoose.Types.ObjectId,
      ref: "User"
    }
  })
);

resolvers:

const resolvers = {
  Query: {
    async getUsers() {
      const users = await User.find({});

      return users;
    },

    async getPosts() {
      const posts = await Post.find({});

      return posts;
    },

    async getComments() {
      const comments = await Comment.find({});

      return comments;
    }
  },

  Mutation: {
    async createUser(_, { name, email }) {
      const newUser = new User({ name, email });
      const createdUser = await newUser.save();

      return createdUser;
    },

    async createPost(_, { title, body, user: userId }) {
      const newPost = new Post({ title, body, user: userId });
      const createdPost = await newPost.save();
      const user = await User.findById(mongoose.Types.ObjectId(userId));
      user.posts.push(createdPost._id);
      await user.save();

      return createdPost;
    },

    async createComment(_, { text, post: postId, user: userId }) {
      const newComment = new Comment({ text, post: postId, user: userId });
      const createdComment = await newComment.save();
      const user = await User.findById(mongoose.Types.ObjectId(userId));
      const post = await Post.findById(mongoose.Types.ObjectId(postId));
      user.comments.push(createdComment._id);
      post.comments.push(createdComment._id);
      await user.save();
      await post.save();

      return createdComment;
    }
  },

  User: {
    async posts(parent) {
      return await Post.find({ user: parent._id });
    },

    async comments(parent) {
      return await Comment.find({ user: parent._id });
    }
  },

  Post: {
    async user(parent) {
      return await User.findById(parent.user);
    },

    async comments(parent) {
      return await Comment.find({ post: parent._id });
    }
  },

  Comment: {
    async post(parent) {
      return await Post.findById(parent.post);
    },

    async user(parent) {
      return await User.findById(parent.user);
    }
  }
};