Query.products is defined in resolvers but not in

问题:

Hi I defined rootQuery in Customer schema and then in Product schema I extended query. I wrote resolvers for product schema but then I got following error: Error: Query.products defined in resolvers, but not in schema.

When I move product queries to customer query definition it works.

I dont understand why I'm getting this error. Do I need implement some rootQuery and insert it into typeDefs array and then extend queries in Customer and Product ?

Customer schema

  import CustomerPhoto from "./customerPhoto";

    const Customer = `
         type Customer {
          customerID: ID!
          firstname: String
          lastname: String
          phone: String
          email: String
          CustomerPhoto: CustomerPhoto
         } 
         input CustomerInput {
          firstname: String!
          lastname: String!
          phone: String!
          email: String!
          } 
          type Query {
          customers(cursor: Int!):[Customer]
          customer(id: Int!): Customer
          }
         type Mutation {
          createCustomer(photo: String!, input: CustomerInput): Customer
          updateCustomer(customerID: ID!, photo: String, input: CustomerInput): Customer
          deleteCustomer(customerID: ID!): Customer
          }
        `;

export default [Customer, CustomerPhoto];

Product Schema

  import ProductPhoto from "./productPhoto";
    const Product = ` 
     type Product {
      productID: ID!
      name: String!
      description: String!
      pricewithoutdph: Float!
      pricewithdph: Float!
      barcode: Int!
      ProductPhoto: ProductPhoto
     }
     extend type Query {
      products: [Product]
      product(productID: ID!): Product
     }
    `;
    export default [Product, ProductPhoto]

Here Im importing both schemas. Is there something missing ?

const schema = makeExecutableSchema({
  typeDefs: [...Customer,...Product],
  resolvers: merge(CustomerResolvers, ProductResolvers),
  logger: {
    log: e => {
      console.log("schemaError", e);
    }
  },
  resolverValidationOptions: {
    requireResolversForNonScalar: true
  }
});

Product Resolvers

const ProductResolvers = {
  Query: {
    products: (_, { cursor }) => {
      return models.Product.findAndCountAll({
        include: {
          model: models.ProductPhoto,
          attributes: ["productPhotoID", "photo"],
          required: true
        },
        offset: cursor,
        limit: 10,
        attributes: ["productID", "name", "description", "pricewithoutdph", "pricewithdph", "barcode"]
      }).then(response => {
        return response.rows;
      });
    }
};

export default ProductResolvers;

Customer Resolvers

const CustomerResolvers = {
      Query: {
        customers: (_, {cursor}) => {
         return models.Customer.findAndCountAll({
            include: {
              model: models.CustomerPhoto,
              attributes: ["customerPhotoID", "photo"],
              required: true
            },
            offset: cursor,
            limit: 10,
            attributes: ["customerID", "firstname", "lastname", "phone", "email"]
          }).then(response => {
            return response.rows;
          });
        }
    ......
    }
};