Numéro de référence circulaire de type graphql

Question

J'ai deux ressources: Purchase et Category où l'achat appartient à une catégorie et la catégorie a de nombreux achats. Je suis en train de permettre l'interrogation telles que:

query { 
    purchases { 
     description, 
     amount, 
     category { 
      name 
     } 
    } 
} 

ou

query { 
    categories { 
     name, 
     purchases { 
      description, 
      amount 
     } 
    } 
} 

Lors de la configuration de mes types, je reçois l'erreur suivante:

Schema must contain unique named types but contains multiple types named "Category". 

Je suis sûr que ce est un problème de référence circulaire, mais j'ai utilisé des thunks comme je l'ai vu d'autres réponses suggèrent:

// Category/type.js 
const {GraphQLObjectType, GraphQLInt, GraphQLString, GraphQLList} = require('graphql/type'); 
const {purchaseType} = require('../Purchase'); 

const categoryType = new GraphQLObjectType({ 
    name: 'Category', 
    description: 'a purchasing category', 
    fields:() => ({ 
     id: { 
      type: GraphQLInt 
     }, 
     name: { 
      type: GraphQLString 
     }, 
     purchases: { 
      type: new GraphQLList(purchaseType), 
      resolve (category) { 
       return category.getPurchases(); 
      } 
     } 
    }) 
}); 

module.exports = categoryType; 

// Category/index.js 
const categoryType = require('./type'); 
const categoryQuery = require('./query'); 

module.exports = { 
    categoryType, 
    categoryQuery 
}; 

// Purchase/type.js 
const {GraphQLObjectType, GraphQLInt, GraphQLString, GraphQLFloat} = require('graphql/type'); 
const {categoryType} = require('../Category'); 

const purchaseType = new GraphQLObjectType({ 
    name: 'Purchase', 
    description: 'a specific purchase', 
    fields:() => ({ 
     id: { 
      type: GraphQLInt, 
     }, 
     description: { 
      type: GraphQLString, 
     }, 
     amount: { 
      type: GraphQLFloat, 
     }, 
     category: { 
      type: categoryType, 
      resolve (purchase) { 
       return purchase.getCategory(); 
      } 
     } 
    }) 
}); 

module.exports = purchaseType; 

// Purchase/index.js 
const purchaseType = require('./type'); 
const purchaseQuery = require('./query'); 

module.exports = { 
    purchaseType, 
    purchaseQuery 
}; 

Ai-je dérangé quelque chose ici ou ce que j'essaie de faire n'est pas possible?

Edit # 1 Ce qui me porte à croire que c'est un problème de référence circulaire, est si je change le champ category sur le purchaseType à ce qui suit:

category: { 
     // type: categoryType, 
     // resolve (purchase) { 
     //  return purchase.getCategory(); 
     // } 
     type: GraphQLInt, 
     resolve (purchase) { 
      return 10; 
     } 
    } 

et faire quelque chose de similaire à la categoryTypepurchases domaine, cela fonctionne correctement.

Answer 1

Schema must contain unique named types but contains multiple types named "Category".

Cette erreur est clairement ce qui signifie que les différents GraphQLObjectType que vous avez déclaré contient le nom Category plusieurs fois, s'il vous plaît vérifier vos tous les noms de GraphQLObjectType, et le changer, ne devrait pas être le même ou s'il vous plaît mettre à jour tous vos Type dans la question.

REMARQUE: tous les noms de GraphQLType doivent être uniques, il ne doit pas correspondre eachother

const categoryType = new GraphQLObjectType({ 
    name: 'Category', -------> others GraphQLObjectType may have same name Category 
    description: 'a purchasing category', 
    fields:() => ({ 
     ..... 
    }) 
}); 

Answer 2

Mon problème a fini par être un problème de capitalisation.

Dans mon schema.js je faisais:

const {purchaseType, purchaseQuery} = require('./resources/purchase/'); 

En Category/type.js je faisais:

const {purchaseType} = require('../Purchase'); 

modules met en cache nœud de manière sensible à la casse, il chargeait deux fois le module purchaseTyp.