如何使用 GraphQL 在 MERN 应用程序中插入 MongoDB 模式中的数组字段？

Question

I am learning how to develop using MongoDB, express, react, node and GraphQL. I have researched a lot and am having issues grasping one concept. My application is basically a recipe app where users are able to CRUD recipes and have an online cookbook collection of them.

With this in mind I created this schema:

const CookbookProfileSchema = mongoose.Schema({
    fName: String,
    lName: String,
    email: {type: String, lowercase: true, unique: true, required: [true, "can't be blank"], match: [/\S+@\S+\.\S+/, 'is invalid'], index: true},
    password: String,
    cookbook: [{
      recipe: {
        rTitle: String,
        rDescription: String,
        rCookTime: String,
        rIngredients: [{
          iName: String,
          iMeasurement: String,
        }],
        rInstructions: [{
          text: String
        }]
    }
  }]    
});

I have only used SQL databases until now, and I have found tutorials showing me how to create 2 different schemas with a relationship but at that point wouldn't I just be better off with a relational database?

These are my type definitions:

const typeDefs = `
  type Query {
    userProfiles: [UserProfile]
    userLookup(id: ID!): [UserProfile]
    userLogin(email: String, password: String): [UserProfile]
  }
  type UserProfile{
    id: ID!
    fName: String
    lName: String
    email: String
    password: String
    cookbook: [Recipe]
  }

  type Recipe{
    rTitle: String
    rDescription: String
    rCookTime: String
    rIngredients: [Ingredient]
    rInstrctions: [Instruction]
  }

  type Ingredient{
    iname: String
    iMeasurement: String
  }

  type Instruction{
    text: String
  }

  type Mutation {
    createUser(fName: String, lName: String, email: String, password: String): UserProfile
    removeUser(id: ID!): Boolean
    updateUser(id: ID!, fName: String, lName: String): Boolean
    updatePassword(id: ID!, password: String): Boolean
  }
` 

And these are my resolvers so far:

const resolvers = {
  Query: {
    userProfiles: () => UserProfile.find(),
    //userLogin: async (_, {id}) => await UserProfile.findById(new ObjectID({id}))
    userLookup: (_, {id}) => UserProfile.find(ObjectId(id)),
    userLogin: (_, email, password) => UserProfile.find(email, password)
  },
  Mutation: {
    //User CRUD Mutations
    createUser: async (_, {fName, lName, email, password }) => {
      const user = new UserProfile({ fName, lName, email, password, cookbook: null});
      await user.save();
      return user;
    },
    removeUser: async (_, {id}) => {
      await UserProfile.findByIdAndRemove(id);
      return true;
    },
    updateUser: async (_,{id, fName, lName}) => {
      //Code in front end to check if the fname or lname is null
      await UserProfile.findByIdAndUpdate(id, {fName , lName });
      return true;
    },
    updatePassword: async (_, {id, password}) => {
      await UserProfile.findByIdAndUpdate(id, { password });
      return true;
    },

  }
}

const server = new GraphQLServer({ typeDefs, resolvers })
mongoose.connection.once('open', function() {
  server.start(() => console.log('Server is running on localhost:4000'))
});

I am intending for a user to have many recipes, a recipe can have many ingredients and many instructions so I can display it in a list type format that they can check off for just that session or state. In a relational database I would have a table for recipes and have them relate the user. Instructions and ingredients would be related to the recipe. Then for the view I would simply query all the recipes belonging to that user to make the cookbook. How could I do something similar here or should I just go the relational route? I really want to experience how to use mongodb to it's fullest though.

Any help or advice would be greatly appreciated!

Answer 1

I guess you already found out you don't have the hasMany , belongTo etc relationship methods in MongoDB. However, it is possible for you to model the relational-type relationships with MongoDB. Check here .

Although, I should stress that "having as many tables as possible to represent the different data entities(data normalization)" like we do for SQL databases might not be a good schema design for NoSQL databases like MongoDB. Most times, you are better off having documents that are related to each other together.