Kann nicht Eigentum 'nach' undefinierten lesen bei der Umsetzung reagiert Relais

Question

In meiner NodeJS Anwendung

hier ist mein schema.js

import { 
    GraphQLBoolean, 
    GraphQLID, 
    GraphQLInt, 
    GraphQLList, 
    GraphQLNonNull, 
    GraphQLObjectType, 
    GraphQLSchema, 
    GraphQLString, 
} from 'graphql'; 

import { 
    connectionArgs, 
    connectionDefinitions, 
    connectionFromArray, 
    connectionFromPromisedArray, 
    cursorForObjectInConnection, 
    fromGlobalId, 
    globalIdField, 
    mutationWithClientMutationId, 
    nodeDefinitions, 
    toGlobalId, 
} from 'graphql-relay'; 

import { 
    User, 
    getUser, 
    getPosts, 
    createpost, 
} from '../data/database.js'; 

var { nodeInterface, nodeField } = nodeDefinitions(
    (globalId) => { 
    var { type, id } = fromGlobalId(globalId); 
    if (type === 'User') { 
     return getUser(id); 
    }else if (type === 'Post') { 
     return getPosts(id); 
    } 
    return null; 
    }, 
    (obj) => { 
    if (obj instanceof User) { 
     return userType; 
    }else if (obj instanceof Post) { 
     return postType; 
    } 
    return null; 
    } 
); 

var userProfileImageType = new GraphQLObjectType({ 
    name: 'ProfileImage', 
    fields: { 
    full: { 
     type: GraphQLString 
    } 
    } 
}); 

var userLocalAccountType = new GraphQLObjectType({ 
    name: 'Local', 
    fields: { 
    email: { 
     type: GraphQLString 
    } 
    } 
}); 

var userFacebookAccountType = new GraphQLObjectType({ 
    name: 'Facebook', 
    fields: { 
    id: { 
     type: GraphQLString 
    }, 
    displayName: { 
     type: GraphQLString 
    } 
    } 
}); 

var userGoogleAccountType = new GraphQLObjectType({ 
    name: 'Google', 
    fields: { 
    id: { 
     type: GraphQLString 
    }, 
    displayName: { 
     type: GraphQLString 
    } 
    } 
}); 

var postType = new GraphQLObjectType({ 
    name: 'Post', 
    fields: { 
    id: globalIdField('Post'), 
    title: { 
     type: GraphQLString 
    }, 
    userId: globalIdField('User'), 
    content: { 
     type: GraphQLString 
    } 
    }, 
    interfaces: [nodeInterface] 
}); 

/** 
* Define your own connection types here 
*/ 

const { 
    connectionType: postConnection, 
    edgeType: postEdge, 
} = connectionDefinitions({name: 'Post', nodeType: postType}); 

let createPostMutation = mutationWithClientMutationId({ 
    name: 'CreatePost', 

    inputFields: { 
     title: { type: new GraphQLNonNull(GraphQLString) }, 
     content: { type: new GraphQLNonNull(GraphQLString) }, 
     userId: { type: new GraphQLNonNull(GraphQLString) }, 
    }, 

    outputFields: { 
     postEdge: { 
     type: postConnection, 
     resolve: (obj) => ({ node: obj, cursor: obj.insertedId }) 
     }, 
    }, 

    mutateAndGetPayload: ({title, content,userId}) => { 
     console.log({title, content,userId}) 
     return createpost({title, content,userId}) 
    } 
    }); 

var userType = new GraphQLObjectType({ 
    name: 'User', 
    fields: { 
    id: globalIdField('User'), 
    fullName: { 
     type: GraphQLString, 
     description: "Users' Full Name" 
    }, 
    isPremium: { 
     type: GraphQLBoolean, 
     description: "Does the user have premium subscription?" 
    }, 
    currentPostCount: { 
     type: GraphQLInt, 
     description: "User's current total post" 
    }, 
    images: { 
     type: userProfileImageType, 
     description: "User's profile image links" 
    }, 
    local: { 
     type: userLocalAccountType, 
     description: "User's local account info" 
    }, 
    facebook: { 
     type: userFacebookAccountType, 
     description: "User's Facebook account info" 
    }, 
    google: { 
     type: userGoogleAccountType, 
     description: "User's Google Plus account info" 
    }, 
    posts: { 
     type: postConnection, 
     args: { 
     ...connectionArgs, 
     query: { type: GraphQLString } 
     }, 
     resolve: (rootValue) => { 
     return connectionFromPromisedArray(getPosts(rootValue)) 
     } 
    }, 
    }, 
    interfaces: [nodeInterface] 
}); 

var Root = new GraphQLObjectType({ 
    name: 'Root', 
    fields:() => ({ 
    user: { 
     type: userType, 
     resolve: (rootValue, _) => { 
     return getUser(rootValue) 
     } 
    }, 
    }) 
}) 

export var schema = new GraphQLSchema({ 
    query: Root, 
    mutation: new GraphQLObjectType({ 
    name: 'Mutation', 
    fields:() => ({ 
     createPost: createPostMutation 
    }) 
    }) 
}); 

Datei und unten ist mein database.js

import User from './models/userModel' 
import Post from './models/postModel' 

export { User } 
export { Post } 

export function getUser(user) { 
    let validUser = false 
    if (user.local || user.facebook || user.google) { 
    validUser = true 
    } 
    return new Promise((resolve, reject) => { 
    if (validUser) { 
     let localEmail = user.local.email || "" 
     let googleID = user.google.id || "" 
     let facebookID = user.facebook.id || "" 
     User.findOne({ 
     $or: [ 
      { "local.email": localEmail }, 
      { "facebook.id": facebookID }, 
      { "google.id": googleID } 
     ] 
     }, function(err, existingUser) { 
     if (err || !existingUser) { 
      resolve({}) 
     } else { 
      resolve(existingUser) 
     } 
     }); 
    } else { 
     resolve({}) 
    } 
    }) 
} 

export function getPosts(user) { 
    return new Promise((resolve, reject) => { 
    Post.find({}).exec({}, function(err, posts) { 
     resolve(posts) 
     }); 

    }) 
} 

export function createpost({title, content,userId}){ 
    return new Promise((resolve, reject) => { 
     const blogPostModel = new Post({title, content,userId}); 
     const newBlogPost = blogPostModel.save(); 
     if (!newBlogPost) { 
     throw new Error('Error adding new blog post'); 
     } 
     resolve({}) 
    }) 
} 

ich erhalte Benutzer von

Relay.QL `query { user}` 

Ich möchte alle Beiträge holen zusammen mit Benutzer

Relay.QL 'query{ 
    user { 
    id, 
    posts(first: 3) { 
     edges { 
     node { 
      id, 
      title 
     } 
     } 
    } 
    } 
}' 

aber ich in Terminal

unten Störung erhalte

Failed to execute query `UserQueries` for the following reasons: 

1. Cannot read property 'after' of undefined 
    le {id,displayName},_posts3KBCho:posts(first:3) {edges {node 

Bitte helfen. Vielen Dank im Voraus.

Answer 1

Update # 1:

Das Problem ist bei der Umsetzung der posts Feld in userType Definition.

posts: { 
    type: postConnection, 
    args: { 
    ...connectionArgs, 
    query: { type: GraphQLString } 
    }, 
    resolve: (rootValue) => { 
    return connectionFromPromisedArray(getPosts(rootValue)) 
    } 
}, 

Während args Destrukturierung, die Rest parameterconnectionArgs sollte am Ende kommen. query sollte zuerst kommen. Wegen der falschen Verwendung der Ruheparameter wird connectionArgsundefined gefunden.

Übrigens, Sie übergeben query nicht für Beiträge. Wenn Sie kein query Argument angeben, sollten Sie einfach args: {...connectionArgs}, verwenden.

---

Sieht aus wie Sie Mongoose Bibliothek verwendet haben. Wenn das der Fall ist, ist ein offensichtliches Problem in der Implementierung der getPosts Funktion. exec selbst returns a promise. Es muss also nicht in ein Versprechen eingeschlossen werden. Ersetzen Sie diese

export function getPosts(user) { 
    return new Promise((resolve, reject) => { 
    Post.find({}).exec({}, function(err, posts) { 
     resolve(posts) 
     }); 

    }) 
} 

mit diesem

export function getPosts(user) { 
    return Post.find({user_id: user._id}).exec(); 
} 

Bitte lassen Sie mich wissen, wenn Sie weitere Probleme haben, nachdem diese Fixierung.

Answer 2

Habe heute den gleichen Fehler gemacht und es hat ein bisschen gedauert, die richtige Lösung zu finden. Ich habe Ihre Frage mit demselben Problem betrachtet, aber mein Problem nicht gelöst. Nach einiger Zeit habe ich festgestellt, dass ich args in meinem connectionFromPromisedArray Anruf verpasse. So, um Ihr Problem zu beheben, versuchen Sie Folgendes zu ändern:

posts: { 
     type: postConnection, 
     args: { 
     ...connectionArgs, 
     query: { type: GraphQLString } 
     }, 
     resolve: (rootValue, args) => { // <== here is added args attribute 
     return connectionFromPromisedArray(getPosts(rootValue), args) // <== here is added args attribute 
     } 
    },