Graphql Postgresql Versprechen wird ausgeführt, nachdem die Ergebnisse zurückgegeben werden

Question

Ich versuche Graphql. Ich ziehe meine Daten von postgresql und alles scheint zu funktionieren, außer für ein Problem, bei dem die Lösung abgeschlossen ist, bevor die Abfrage abgeschlossen ist. Ich hatte zwar mein Anfrageversprechen richtig funktioniert. Hier ist meine Klasse, die ich zum Abfragen der Datenbank erstellt:

class PgPoolClient { 

    constructor(options) { 
     this.connection = options.connection; 
    } 

    query(sql, data = []) { 

     return new Promise((resolve, reject) => { 
      var pool = new pg.Pool(this.connection); 
      pool.connect((err, client, done) => { 
       if (err) { 
        reject({ 
         code: 505, 
         message: err.message, 
         entrys: [] 
        }); 
       } else { 
        client.query(sql, data, (err, results) => { 
         done(); 
         if (err) { 
          reject({ 
           code: 404, 
           message: err.message, 
           entrys: [] 
          }); 
         } else { 
          resolve({ 
           code: 200, 
           message: "ok", 
           entrys: results 
          }); 
         } 
        }); 
       } 
      }); 

      pool.on("error", (err, client) => { 
       reject({ 
        code: 505, 
        message: err.message, 
        entrys: {} 
       }); 
      }); 

     }); 
    } 
} 

Hier ist meine graphql Abfrage:

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

       const parameters = []; 
       pg.query(`SELECT 
id, token, user_identifier as userIdentifier, hash_password as hashPassword, 
is_enabled as isEnabled, security_type_id as securityTypeID, 
is_admin as isAdmin, ad_path as adPath, date_created as dateCreated, 
date_modified as dateModified, modified_by as modifiedBy 
FROM accounts.account`, parameters) 
       .then((result) => 
       { 
        console.log(result.entrys.rows); 
        //return result.entrys.rows; 
        return [ 
         { 
         id: '33333', 
         token: '111', 
         userIdentifier: 'test' 
         } 
        ] 

       }) 
       .catch((err) => 
       { 
        console.log(err); 
        return err.message; 
       }); 

       console.log('finished'); 
     } 
    }) 
}); 

ich mal meine Ergebnisse kommentiert und wollte nur über die Rückkehr statische Inhalte sehen und es scheint, dass, wenn innerhalb von then() werden die Ergebnisse nicht an graphisql zurückgegeben (was bedeutet, dass die Lösung abgeschlossen ist, bevor dann()). mit Ausgang:

{ 
    "data": { 
    "accounts": null 
} 

}

Ich konnte dies überprüfen, indem die statische Rückkehr Array unter dem console.log (‚fertig‘) setzen und es gibt die Daten richtig.

console.log('finished'); 
return [ 
    { 
    id: '33333', 
    token: '111', 
    userIdentifier: 'test' 
    } 
]     

, die in graphiql zeigt sich:

{ 
    "data": { 
    "accounts": [ 
     { 
     "id": "33333", 
     "token": "111", 
     "userIdentifier": "test" 
     } 
    ] 
    } 
} 

So scheint es, dass mein Versprechen gewartet auf nicht werden. Gibt es etwas, das mir in meiner Abfragefunktion fehlt, die dazu führt, dass ich nicht auf meine Ergebnisse warten muss? Jede Hilfe wäre willkommen.

Update 1

Es scheint, wenn ich die Abfrage in einem Versprechen Wrapp es funktioniert:

return new Promise((resolve, reject) => { 

pg.query(`SELECT 
id, token, user_identifier as userIdentifier, hash_password as hashPassword, 
is_enabled as isEnabled, security_type_id as securityTypeID, 
is_admin as isAdmin, ad_path as adPath, date_created as dateCreated, 
date_modified as dateModified, modified_by as modifiedBy 
FROM accounts.account`, parameters) 
.then((result) => 
{ 
    console.log(result.entrys.rows); 
    //return result.entrys.rows; 
    resolve([ 
     { 
     id: '33333', 
     token: '111', 
     userIdentifier: 'test' 
     } 
    ]); 

}) 
.catch((err) => 
{ 
    console.log(err); 
    reject(err.message); 
}); 

ich meine Frage erraten ist schon, wenn meine Abfrage-Funktion in einem Versprechen eingewickelt ist, warum tun Ich muss es nochmal machen?

Answer 1

Ihre resolve Funktion muss das Versprechen zurückgeben. Wenn Sie es explizit in ein Versprechen eingeschlossen haben, hat es funktioniert, weil Sie es zurückgegeben haben. Es sollte ohne das funktionieren, wenn Sie das Ergebnis des Aufrufs pg.query zurückgeben.

const Query = new GraphQLObjectType({ 
name: 'Query', 
description: 'Root query object', 
fields:() => ({ 
    accounts: { 
     type: new GraphQLList(Account), 
     resolve(root, args) { 
      const parameters = []; 
      return pg.query(`query`, parameters) 
      .then((result) => 
      { 
       console.log(result.entrys.rows); 
       //return result.entrys.rows; 
       return [ 
        { 
        id: '33333', 
        token: '111', 
        userIdentifier: 'test' 
        } 
       ] 
      }) 
      .catch((err) => 
      { 
       console.log(err); 
       return err.message; 
      }); 
      console.log('finished'); 
     } 
    }) 
});