如何在现有GraphQL Server上添加root和viewer查询以获得中继支持

我已经使用GraphQL了一段时间，并且能够成功启动一个简单的GraphQL Server . 现在我试图让它支持Relay，我的最终目标，并且我在添加对根节点查询和查看器查询的支持时遇到了麻烦 .

我理解节点和查看器的概念，但我没有按照我构建代码的方式工作 . 这是我的代码，组织成单独的文件：

./graphql/User/types.js

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

 import { GraphQLLong } from '../scalars';

 import { NodeInterface } from '../interfaces';

const fields = {
        _id: {
            type: new GraphQLNonNull(GraphQLID)
        },
        email: {
            type: GraphQLString
        },
        firstName: {
            type: GraphQLString
        },
        lastName: {
            type: GraphQLString
        },
        jobTitle: {
            type: GraphQLString
        },
        phone: {
            type: GraphQLString
        }
    };


export const UserType = new GraphQLObjectType({
    name: 'User',
    description: 'User',
    interface: NodeInterface,
    fields: fields
})

./graphql/User/queries.js

import { GraphQLNonNull, GraphQLID, GraphQLList } from 'graphql';

import { UserType, UserInputType } from './types';
import UserModel from '../../models/User';

const User = {
    type: UserType,
    description: 'Get single user',
    args: {
        id: {
            name: 'id',
            type: new GraphQLNonNull(GraphQLID)
        }
    },
    resolve(root, params) {

        params.deleted = false;

        return UserModel.find(params).exec();
    }
}


const Users = {
    type: new GraphQLList(UserType),
    description: 'Get all users',
    resolve(root) {
        const companies = UserModel.find({ deleted: false }).exec();
        if (!companies) {
            throw new Error('Error getting users.')
        }
        return companies;   
    }
}

export default {
    User,
    Users
}

./graphql/Company/types.js

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

 import { GraphQLLong } from '../scalars';

 import { UserType } from '../User/types';

 import { NodeInterface } from '../interfaces';

 import UserModel from '../../models/User';

 const fields = {
    _id: {
        type: new GraphQLNonNull(GraphQLID)
    },
    name: {
        type: GraphQLString
    },
    ein: {
        type: GraphQLString
    },
    users: {
        type: new GraphQLList(UserType),
        resolve(company) {
            const { _id } = company;
            return UserModel.find({ companyId: _id }).exec();
        }
    }
 };

 export const CompanyType = new GraphQLObjectType({
    name: 'Company',
    description: 'Company',
    interface: NodeInterface,
    fields: fields
 })

./graphql/Company/queries.js

import { GraphQLNonNull, GraphQLID, GraphQLList } from 'graphql';

import { CompanyType, CompanyInputType } from './types';
import CompanyModel from '../../models/Company';

const Company = {
    type: CompanyType,
    description: 'Get single company',
    args: {
        id: {
            name: 'id',
            type: new GraphQLNonNull(GraphQLID)
        }
    },
    resolve(root, params) {

        params.deleted = false;

        return CompanyModel.find(params).exec();
    }
}


const Companies = {
    type: new GraphQLList(CompanyType),
    description: 'Get all companies',
    resolve(root) {
        const companies = CompanyModel.find({ deleted: false }).exec();
        if (!companies) {
            throw new Error('Error getting companies.')
        }
        return companies;   
    }
}

export default {
    Company,
    Companies
}

./graphql/interfaces.js

import { 
    GraphQLInterfaceType,
    GraphQLNonNull, 
    GraphQLID 
} from 'graphql';


const NodeInterface = new GraphQLInterfaceType({
    name: 'Node',
    fields: {
        id: {
            type: new GraphQLNonNull(GraphQLID)
        }
    },
    resolveType: (source) => {

        return source.__type;
    }
});

export default NodeInterface;

./graphql/schema.js

import { GraphQLObjectType, GraphQLSchema } from 'graphql';
import queries from './queries';
import mutations from './mutations';


export default new GraphQLSchema({
    query: new GraphQLObjectType({
        name: 'Query',
        fields: queries
    }),
    mutation: new GraphQLObjectType({
        name: 'Mutation',
        fields: mutations
    })
});

./graphql/queries.js

import {
    GraphQLObjectType,
    GraphQLNonNull,
    GraphQLID
} from 'graphql';

import { NodeInterface } from './interfaces';
import CompanyQueries from './Company/queries';
import UserQueries from './User/queries';

const RootQuery = new GraphQLObjectType({

    name: 'RootQuery',
    description: 'The root query',
    fields: {
        viewer: {
            type: NodeInterface,
            resolve(source, args, context) {
                return { result: "VIEWER!" };
            }
        },
        node: {
            type: NodeInterface,
            args: {
                id: {
                    type: new GraphQLNonNull(GraphQLID)
                }
            },
            resolve(source, args, context, info) {
                return { result: "NODE QUERY" };
            }
        }
    }
});

export default {
    RootQuery,
    ...CompanyQueries,
    ...UserQueries
}

./server.js

import express from 'express';
import bodyParser from 'body-parser';
import mongoose from 'mongoose';
import morgan from 'morgan';
import graphqlHTTP from 'express-graphql';

import schema from './graphql/schema';

// set up example server
const app = express();
app.set('port', (process.env.API_PORT || 3001));


// logger
app.use(morgan('dev')); 

// parse body
app.use(bodyParser.json());

app.use('/graphql', graphqlHTTP({
    schema: schema,
    graphiql: true,
    pretty: true
}));

const mongoUri = process.env.MONGO_URI || 'mongodb://localhost/testdb';

mongoose.set('debug', true);

mongoose.connect(mongoUri, {
    useMongoClient: true,
});

export default app;

RootQuery没有添加到Schema . 实际上我收到了这个错误：

Error: Query.RootQuery field type must be Output Type but got: undefined.

从概念上讲，我不知道如何修复此代码：

a）我不知道如何将RootQuery添加到我的查询中，我不知道是否需要将其他查询保存到我的服务器（因为Relay基本上依赖于节点查询） .

b）我还不能看到我的RootQuery如何发现对象类型并将其返回到 return source.__type . 我已经添加了那段代码，但我不知道给定类型将填充此字段的方式或位置 .

虽然我理解一点GraphQL，但我还没有关于如何构建Relay的基础知识需要root查询（不是谈论分页器，但是一旦我解决了这一点，这是我的下一步） .

帮助赞赏 .