如何在 GraphQL (Relay) 中查询和改变数组类型？

Question

I am new to GraphQL/Relay and I have a problem with a small project. I have a collection of documents containing a field of type "array". Please tell me which type of GraphQL to use for working with arrays? I tried to use GraphQLList but got some errors like

"Expected GraphQL named type but got: [function GraphQLList]."

and other. Will be very grateful for any help!

Here is the schema:

const mongoose = require('mongoose');
mongoose.set('useFindAndModify', false);
const Schema = mongoose.Schema;

const houseSchema = new Schema({
  name: {
    type: String,
    required: true
  },
  events: {
    type: Array,
    default: []
  }
});

var houseModel = mongoose.model("House", houseSchema);

module.exports = {
  getHouses: () => {
    return houseModel.find({}).limit(10).sort({_id:-1})
      .then(houses => {
        return houses.map(house => {
          return {
            ...house._doc,
            id: house.id
          };
        });
      })
      .catch(err => {
        throw err;
      });
  },
  getHouse: id => {
    return houseModel.findOne({ _id: id });
  },
  createHouse: house => {
    return houseModel(house).save();
  },
  removeHouse: id => {
    return houseModel.findByIdAndRemove(id);
  },
  updateHouse: (id, args) => {
    return houseModel.findByIdAndUpdate(
      id,
      {
        name: args.name,
        events: args.events //-----------------
      },
      { new: true }
    );
  }
};

Type for 'house':

const {
  GraphQLList,
  GraphQLObjectType,
  GraphQLString
} = require('graphql');

const { globalIdField, connectionDefinitions } = require('graphql-relay');
const { nodeInterface } = require('../nodes');

const House = new GraphQLObjectType({
  name: "House",
  description: "lkjlkjlkjlkjlk",
  interfaces: [nodeInterface],
  fields: () => ({
    id: globalIdField(),
    name: {
      type: GraphQLString,
      description: "Name of House"
    },
    events: {
      type: GraphQLList,
      description: "Events list"
    }
  })
});

const { connectionType: HouseConnection } = connectionDefinitions({
  nodeType: House
});

module.exports = { House, HouseConnection };

Mutation:

const {
  GraphQLList,
  GraphQLObjectType,
  GraphQLNonNull,
  GraphQLString,
  GraphQLBoolean
} = require('graphql');

const { fromGlobalId, mutationWithClientMutationId } = require('graphql-relay');
const { House } = require('./types/house');

const houseModel = require('./models/house');

const CreateHouseMutation = mutationWithClientMutationId({
  name: "CreateHouse",
  inputFields: {
    name: { type: new GraphQLNonNull(GraphQLString) },
    events: { type: new GraphQLNonNull(GraphQLList) }
  },
  outputFields: {
    house: {
      type: House
    }
  },
  mutateAndGetPayload: args => {
    return new Promise((resolve, reject) => {
      houseModel.createHouse({
        name: args.name,
        events: args.events
      })
        .then(house => resolve({ house }))
        .catch(reject);
    });
  }
});

const UpdateHouseMutation = mutationWithClientMutationId({
  name: "UpdateHouse",
  inputFields: {
    id: { type: new GraphQLNonNull(GraphQLString) },
    name: { type: new GraphQLNonNull(GraphQLString) },
    events: { type: new GraphQLNonNull(GraphQLList) }
  },
  outputFields: {
    updated: { type: GraphQLBoolean },
    updatedId: { type: GraphQLString }
  },
  mutateAndGetPayload: async (args) => {
    const { id: productId } = fromGlobalId(args.id);
    const result = await houseModel.updateHouse(productId, args);
    return { updatedId: args.id, updated: true };
  }
});

const RemoveHouseMutation = mutationWithClientMutationId({
  name: "RemoveHouse",
  inputFields: {
    id: { type: new GraphQLNonNull(GraphQLString) },
  },
  outputFields: {
    deleted: { type: GraphQLBoolean },
    deletedId: { type: GraphQLString }
  },
  mutateAndGetPayload: async ({ id }, { viewer }) => {
    const { id: productId } = fromGlobalId(id);
    const result = await houseModel.removeHouse(productId);
    return { deletedId: id, deleted: true };
  }
});

const Mutation = new GraphQLObjectType({
  name: "Mutation",
  description: "kjhkjhkjhkjh",
  fields: {
    createHouse: CreateHouseMutation,
    removeHouse: RemoveHouseMutation,
    updateHouse: UpdateHouseMutation
  }
});

module.exports = Mutation;

Answer 1

GraphQLList is a wrapper type just like GraphQLNonNull . It wraps another type. You use it just like GraphQLNonNull -- by invoking the constructor and passing in the type you want to wrap.

new GraphQLList(GraphQLString)

Both wrapper types can wrap each other, so you can do something like this as well:

new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString)))