Graphql錯誤undefined添加關係

Question

我有以下結構。每個帳戶可以有一個安全類型。
所以它是從SecurityType到Account的一對多。 一切正常使用的代碼

File: AccountSchema.js 

const SecurityType = require('./LookupSchema').SecurityType; 
console.log(Account); 

const Account = new GraphQLObjectType({ 
    name: 'Account', 
    description: 'Account access', 
    fields:() => 
    ({ 
     id: { 
      type: GraphQLString 
     }, 
     security_type: 
     { 
      type: SecurityType, 
      resolve(parent, args, ast){ 
       return new Promise((resolve, reject) => { 

        const db = ast.db; 
        const parameters = [parent.security_type_id]; 
        db.query(db.connection, `SELECT * FROM lookups.security_type WHERE id = $1`, parameters) 
        .then(result => 
        { 
         resolve(result.entrys.rows[0]); 
        }) 
        .catch(err => 
        { 
         reject(err.message); 
        }); 
       }); 
      } 
     } 
    }) 
}); 

module.exports = { 
    Account : Account 
} 


File: LookupSchema.js 

const Account = require('./AccountSchema').Account; 
console.log(Account); 


const SecurityType = new GraphQLObjectType({ 
    name: 'SecurityType', 
    description: 'Used to for specifying security type', 
    fields:() => 
    ({ 
     id: { 
      type: GraphQLString 
     } 
    }) 
}); 

module.exports = { 
    SecurityType: SecurityType 
} 


File: Query.js 
const Query = new GraphQLObjectType({ 
    name: 'Query', 
    description: 'Root query object', 
    fields:() => ({ 
     accounts: { 
      type: new GraphQLList(Account), 
      resolve(root, args, ast) { 

       return new Promise((resolve, reject) => { 
        const db = ast.db; 
        const parameters = []; 
        db.query(db.connection, `SELECT * FROM accounts.account`, parameters) 
        .then(result => 
        { 
         console.log(result); 
         resolve(result.entrys.rows); 
        }) 
        .catch(err => 
        { 
         console.log(err); 
         reject(err.message); 
        }); 
       }); 

      } 
     }, 
     securityTypes: { 
      type: new GraphQLList(SecurityType), 
      resolve(root){ 
       return new Promise((resolve, reject) => { 
        const db = ast.db; 
        const parameters = []; 
        db.query(db.connection, `SELECT * FROM lookups.security_type`, parameters) 
        .then(result => 
        { 
         resolve(result.entrys.rows); 
        }) 
        .catch(err => 
        { 
         reject(err.message); 
        }); 
       }); 
      } 
     } 
    }) 
}); 

我的問題是，當我添加到文件LookupSchema.js賬戶

const SecurityType = new GraphQLObjectType({ 
    name: 'SecurityType', 
    description: 'Used to for specifying security type', 
    fields:() => 
    ({ 
     id: { 
      type: GraphQLString 
     }, 
     accounts: { 
      type: new GraphQLList(Account), 
      resolve(parent, args, ast){ 
       return new Promise((resolve, reject) => { 

        const db = ast.db; 
        const parameters = [parent.id]; 
        db.query(db.connection, `SELECT * FROM accounts.account WHERE security_type_id = $1`, parameters) 
        .then(result => 
        { 
         resolve(result.entrys.rows); 
        }) 
        .catch(err => 
        { 
         reject(err.message); 
        }); 
       }); 
      } 
     } 
    }) 
}); 

我收到以下錯誤，當我啓動服務

錯誤：只能創建GraphQLType的列表，但得到：未定義。

我把console.log爲每個帳戶和SecurityType檢查導入，我注意到在LookupSchema中，帳戶是未定義的。我做了一些研究，這可能是一個循環問題，但不太確定它的解決方案。

任何建議，將不勝感激

Answer 1

要avoide的循環問題，你可以使用fields()函數內需要的功能。

因此，內部AccountSchema.jsfields:()功能將首先import的SecurityType那麼只有我們將使用其他字段與return {}，同樣爲其他文件。

AccountSchema.js

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

const Account = new GraphQLObjectType({ 
    name: 'Account', 
    description: 'Account access', 
    fields:() => { 
     const SecurityType = require('./LookUpSchema'); 
     return { 
      id: { 
       type: GraphQLString, 
      }, 
      security_type: 
      { 
       type: SecurityType, 
       resolve(parent, args, ast) { 
        return new Promise((resolve, reject) => { 
         const db = ast.db; 
         const parameters = [parent.security_type_id]; 
         db.query(db.connection, 'SELECT * FROM lookups.security_type WHERE id = $1', parameters) 
          .then((result) => { 
           resolve(result.entrys.rows[0]); 
          }) 
          .catch((err) => { 
           reject(err.message); 
          }); 
        }); 
       }, 
      }, 
     }; 
    }, 

}); 

module.exports = Account; 

LookUpSchema.js

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

const SecurityType = new GraphQLObjectType({ 
    name: 'SecurityType', 
    description: 'Used to for specifying security type', 
    fields:() => { 
     const Account = require('./AccountSchema'); 
     return { 
      id: { 
       type: GraphQLString, 
      }, 
      accounts: { 
       type: new GraphQLList(Account), 
       resolve(parent, args, ast) { 
        return new Promise((resolve, reject) => { 
         const db = ast.db; 
         const parameters = [parent.id]; 
         db.query(db.connection, 'SELECT * FROM accounts.account WHERE security_type_id = $1', parameters) 
          .then((result) => { 
           resolve(result.entrys.rows); 
          }) 
          .catch((err) => { 
           reject(err.message); 
          }); 
        }); 
       }, 
      }, 
     }; 
    }, 
}); 

module.exports = SecurityType; 

Query.js

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

const Account = require('./AccountSchema'); 
const SecurityType = require('./LookUpSchema'); 

console.log('Account', Account); 

const Query = new GraphQLObjectType({ 
    name: 'Query', 
    description: 'Root query object', 
    fields:() => ({ 
     accounts: { 
      type: new GraphQLList(Account), 
      resolve(root, args, ast) { 
       return new Promise((resolve, reject) => { 
        const db = ast.db; 
        const parameters = []; 
        db.query(db.connection, 'SELECT * FROM accounts.account', parameters) 
         .then((result) => { 
          console.log(result); 
          resolve(result.entrys.rows); 
         }) 
         .catch((err) => { 
          console.log(err); 
          reject(err.message); 
         }); 
       }); 
      }, 
     }, 
     securityTypes: { 
      type: new GraphQLList(SecurityType), 
      resolve(root) { 
       return new Promise((resolve, reject) => { 
        const db = ast.db; 
        const parameters = []; 
        db.query(db.connection, 'SELECT * FROM lookups.security_type', parameters) 
         .then((result) => { 
          resolve(result.entrys.rows); 
         }) 
         .catch((err) => { 
          reject(err.message); 
         }); 
       }); 
      }, 
     }, 
    }), 
}); 


const schema = new GraphQLSchema({ 
    query: Query, 
    // mutation: MutationType, 
}); 

module.exports = schema; 

GraphiQL