中继风味graphql突变验证错误

我做了一个简单的接力式突变，效果很好。我有一个简单的客户端组件，用所需的数据提交变异

我的问题是如何将多个错误发送回客户端？目前，我可以简单地在mutateAndGetPayload中抛出一个错误（或拒绝一个承诺），并且我将在客户端收到一个错误，但这目前只适用于字符串消息。我是否应该简单地用错误数组的JSON字符串拒绝承诺？还是有更好的办法

const createCashAccountMutation = mutationWithClientMutationId({
    name: 'CreateCashAccount',
    inputFields: {
        name: {
            type: new GraphQLNonNull(GraphQLString),
            description: 'Cash account name'
        },
        code: {
            type: GraphQLString,
            description: 'Optional code'
        },
        businessId: {
            type: new GraphQLNonNull(GraphQLString),
                description: 'Business ID'
        },
        currencyId: {
            type: new GraphQLNonNull(GraphQLString),
            description: 'Currency ID'
        },
        isActive: {
            type: new GraphQLNonNull(GraphQLInt)
        }
    },
    outputFields: {
        name: {
            type: GraphQLString,
            resolve: (payload) => payload.name
        },
        code: {
            type: GraphQLString,
            resolve: (payload) => payload.code
        },
        businessId: {
            type: GraphQLString,
            resolve: (payload) => payload.businessId
        },
        currencyId: {
            type: GraphQLString,
            resolve: (payload) => payload.currencyId
        },
        isActive: {
            type: GraphQLString,
            resolve: (payload) => payload.isActive
        }
    },
    mutateAndGetPayload: async (options) => {
        throw 'wtf';
        return options;
    }
});

更新1。 我提出了以下示例：

const graphQLCashAccount = new GraphQLObjectType({
    name: 'cashAccount',
    fields: {
        name: {
            type: GraphQLString,
            resolve: (payload) => payload.name
        },
        code: {
            type: GraphQLString,
            resolve: (payload) => payload.code
        },
        businessId: {
            type: GraphQLString,
            resolve: (payload) => payload.businessId
        },
        currencyId: {
            type: GraphQLString,
            resolve: (payload) => payload.currencyId
        },
        isActive: {
            type: GraphQLString,
            resolve: (payload) => payload.isActive
        }
    }
});

const graphQLErrors = new GraphQLList(new GraphQLObjectType({
    name: 'errors',
    fields: {
        key: {
            type: GraphQLString,
            resolve: (payload) => payload.key
        },
        message: {
            type: GraphQLString,
            resolve: (payload) => payload.message
        }
    }
}));

const graphQlInput = new GraphQLInputObjectType({
    name: 'data',
    fields: {
        name: {
            type: new GraphQLNonNull(GraphQLString),
            description: 'Cash account name'
        },
        code: {
            type: GraphQLString,
            description: 'Optional code'
        },
        businessId: {
            type: new GraphQLNonNull(GraphQLString),
            description: 'Business ID'
        },
        currencyId: {
            type: new GraphQLNonNull(GraphQLString),
            description: 'Currency ID'
        },
        isActive: {
            type: new GraphQLNonNull(GraphQLInt)
        }
    }
});

const createCashAccountMutation = mutationWithClientMutationId({
    name: 'CreateCashAccount',
    inputFields: {
        data: {
            type: graphQlInput
        }
    },
    outputFields: {
        data: {
            type: graphQLCashAccount,
            resolve: (payload) => payload.data
        },
        errors: {
            type: graphQLErrors,
            resolve: (payload) => payload.errors
        }
    },
    mutateAndGetPayload: async (options) => {
        const payload = {
            errors: [{ key: 'asd', message: 'asd failed' }],
            data: options
        };
        return payload;
    }
});

这将实际解决事务，只返回两个字段，一个数据字段和一个错误字段。其中一个将被填充

这是更好的方法吗？不过，我很难理解应该如何在查询中应用更新

更新2。 中继变异客户端示例

export class NewCashAccountMutation extends Relay.Mutation {

    getMutation () {
        return Relay.QL`mutation { 
            createCashAccount
        }`;
    }

    getVariables() {
        return { data: this.props.cashAccount };
    }

    getFatQuery() {
        return Relay.QL`
            fragment on CreateCashAccountPayload {
                data, errors
            }
        `;
    }
    getConfigs() {
        return [{
            type: 'FIELDS_CHANGE',
            fieldIDs: {
                data: this.props.cashAccount.id,
            },
        }];
    }
}

---

为什么需要发送多个错误？这些是验证错误吗？是的，例如验证表单在这种情况下，您可以在

outputFields

中包含一个附加字段

errors

。请参阅中的用户级错误（例如验证错误）示例。回答中提到的文章也很有帮助。我看到过类似的关于返回错误的帖子，这就是我在更新1中得到的结果。但是，我对更新中继存储感到困惑。我返回变异成功运行，但它实际上包含一个错误对象。这如何影响突变类的fatQuery部分？此外，当变异只返回clienId时，我应该如何访问客户端的errors对象？我已将客户端中继变异类添加到问题中。首先，在变异的

getConfigs（）

中，使用

字段\u CHANGE

是错误的。如果您接收到不需要存储在中继存储中的数据，请使用

REQUIRED\u CHILDREN

。如果要存储，请使用

字段\u CHANGE

但要修复id的分配（此

数据从何而来？）。其次，在
getFatQuery
中，展开数据片段和错误片段，其中包含要使用的字段。