时间戳

首页 > 解决方案 > 无法将已处理的 GraphQL 错误从一个 Apollo-server API 传递到另一个 API

error-handling - 无法将已处理的 GraphQL 错误从一个 Apollo-server API 传递到另一个 API

问题描述

我正在尝试通过 Apollo Server Express 和 Passport JWT 使用 GraphQL 构建一个微服务 Web 应用程序示例，以进行令牌身份验证。

Blog.author到目前为止，我有 4 个微服务（用户、博客、项目、配置文件）和一个网关 API，我将它们与关系片段（例如或User.projects等）拼接在一起。一切运行良好，我可以全面执行完整的 CRUD。

然后，当我尝试实现身份验证时，一切都陷入了困境（那里令人大吃一惊），虽然奇怪的是没有实现身份验证本身，但这不是问题。

问题在于错误处理，更具体地说，是将 GraphQL 错误从远程 API 传递到网关进行拼接。网关发现有一个错误，但实际的细节（例如{password: 'password incorrect'}）被网关 API 吞没了。

用户 API 错误

{
  "errors": [
    {
      "message": "The request is invalid.",
      "type": "ValidationError",
      "state": {
        "password": [
          "password incorrect"
        ]
      },
      "path": [
        "loginUser"
      ],
      "stack": [
        ...
      ]
    }
  ],
  "data": {
    "loginUser": null
  }
}

网关 API 错误

{
  "errors": [
    {
      "message": "The request is invalid.",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "path": [
        "loginUser"
      ],
      "extensions": {
        "code": "INTERNAL_SERVER_ERROR",
        "exception": {
          "errors": [
            {
              "message": "The request is invalid.",
              "locations": [],
              "path": [
                "loginUser"
              ]
            }
          ],
          "stacktrace": [
            "Error: The request is invalid.",
            ... // stacktrace refers to node_modules/graphql- 
            tools/src/stitching
  ],
  "data": {
    "loginUser": null
  }
}

GATEWAY src/index.js 导入 express from 'expres

s';
import { ApolloServer } from 'apollo-server-express';
// ...
import errorHandler from '../error-handling/errorHandler';

// ... app setup

const startGateway = async () => {
    const schema = await makeSchema(); // stitches schema
    const app = express();

    app.use('/graphql', (req, res, next) => {
        // passport
        // ...
    });

    const server = new ApolloServer({
        schema,
        context: ({ req }) =>  ({ authScope: req.headers.authorization }),
        // custom error handler that tries to unravel, clean and return error
        formatError: (err) => errorHandler(true)(err)
    });

    server.applyMiddleware({ app });
    app.listen({ port: PORT }, () => console.log(`\n Gateway Server ready at http://localhost:${PORT}${server.graphqlPath} \n`));
};

startGateway().catch(err => console.log(err));

GATEWAY src/remoteSchema/index.js （拼接发生的地方）

import { makeRemoteExecutableSchema, introspectSchema } from 'graphql-tools';
import { ApolloLink } from 'apollo-link';
import { setContext } from 'apollo-link-context';
import { introspectionLink, stitchingLink } from './link';


// graphql API metadata
const graphqlApis = [
    { uri: config.USER_DEV_API },
    { uri: config.BLOG_DEV_API },
    { uri: config.PROJECT_DEV_API },
    { uri: config.PROFILE_DEV_API }
];

// create executable schemas from remote GraphQL APIs
export default async () => {
    const schemas = [];

    for (const api of graphqlApis) {

        const contextLink = setContext((request, previousContext) => {
            const { authScope } = previousContext.graphqlContext;
            return {
                headers: {
                    authorization: authScope
                }
            };
        });

        // INTROSPECTION LINK
        const apiIntroSpectionLink = await introspectionLink(api.uri);

        // INTROSPECT SCHEMA
        const remoteSchema = await introspectSchema(apiIntroSpectionLink);

        // STITCHING LINK
        const apiSticthingLink = stitchingLink(api.uri);

        // MAKE REMOTE SCHEMA
        const remoteExecutableSchema = makeRemoteExecutableSchema({
            schema: remoteSchema,
            link: ApolloLink.from([contextLink, apiSticthingLink])
        });

        schemas.push(remoteExecutableSchema);
    }

    return schemas;
};

缝合还有更多，但这里太多了。但它缝合成功。

用户 API 源/解析器

const resolvers = {
    Query: {/*...*/},
    Mutation: {
        loginUser: async (parent, user) => {
            const errorArray = [];

            // ...get the data...

            const valid = await bcrypt.compare(user.password, ifUser.password);

            if (!valid) {
                errorArray.push(validationError('password', 'password incorrect'));
                // throws a formatted error in USER API but not handled in GATEWAY
                throw new GraphQlValidationError(errorArray);
            }

            // ... return json web token if valid

        }
    }
}

用户错误.js

export class GraphQlValidationError extends GraphQLError {
    constructor(errors) {
        super('The request is invalid.');
        this.state = errors.reduce((result, error) => {
            if (Object.prototype.hasOwnProperty.call(result, error.key)) {
                result[error.key].push(error.message);
            } else {
                result[error.key] = [error.message];
            }
            return result;
        }, {});
        this.type = errorTypes.VALIDATION_ERROR;
    }
}

export const validationError = (key, message) => ({ key, message });

网关和用户 errorHandler.js

import formatError from './formatError';

export default includeStack => (error) => {
    const formattedError = formatError(includeStack)(error);

    return formattedError;
};

格式错误.js

import errorTypes from './errorTypes';
import unwrapErrors from './unwrapErrors';

export default shouldIncludeStack => (error) => {
    const unwrappedError = unwrapErrors(error);

    const formattedError = {
        message: unwrappedError.message || error.message,
        type: unwrappedError.type || error.type || errorTypes.ERROR,
        state: unwrappedError.state || error.state,
        detail: unwrappedError.detail || error.detail,
        path: unwrappedError.path || error.path,
    };

    if (shouldIncludeStack) {
        formattedError.stack = unwrappedError.stack || error.extensions.exception.stacktrace;
    }

    return formattedError;
};

unwrapErrors.js

export default function unwrapErrors(err) {
    if (err.extensions) {
        return unwrapErrors(err.extensions);
    }

    if (err.exception) {
        return unwrapErrors(err.exception);
    }

    if (err.errors) {
        return unwrapErrors(err.errors);
    }


    return err;
}

如果代码片段不是我们需要的，我提前道歉。我很乐意回答任何问题。

提前致谢！

标签： error-handlinggraphqlmicroservicesapollo-server

解决方案

好的似乎已经在指向这个要点的讨论的帮助下修复了它。这是一个拼接错误，带有一些不必要的错误格式。我从两者中删除了 formatError并将我的./src/remoteSchema/index.js重新格式化为：ApolloServer({})

import { makeRemoteExecutableSchema, introspectSchema } from 'graphql-tools';
import { ApolloLink } from 'apollo-link';
import { HttpLink } from 'apollo-link-http';
import { setContext } from 'apollo-link-context';
import { onError } from 'apollo-link-error';
import fetch from 'node-fetch';
import config from '../../config/config';


// graphql API metadata
const graphqlApis = [
    { uri: config.USER_DEV_API },
    { uri: config.BLOG_DEV_API },
    { uri: config.PROJECT_DEV_API },
    { uri: config.PROFILE_DEV_API }
];

// create executable schemas from remote GraphQL APIs
export default async () => {
    const schemas = [];

    /*eslint-disable*/
    for (const api of graphqlApis) {

        let remoteLink = new HttpLink({ uri : api.uri, fetch });
        let remoteContext = setContext((req, previous) => {
            // if the authorization token doesn't exist, or is malformed, do not pass it upstream
            if (
                !previous.graphqlContext.authorization
                ||
                !previous.graphqlContext.authorization.match(/^Bearer /)
            ) {
                return;
            }

            return {
                headers: {
                    'Authorization': previous.graphqlContext.authorization,
                }
            }
        });

        let remoteError = onError(({ networkError, graphQLErrors }) => {
            if (graphQLErrors) {
                graphQLErrors.forEach((val) => {
                    Object.setPrototypeOf(val, Error.prototype);
                });
            }
        });
        let remoteSchema  = await introspectSchema(remoteLink);
        let remoteExecutableSchema = makeRemoteExecutableSchema({
            schema : remoteSchema,
            link : ApolloLink.from([
                remoteContext,
                remoteError,
                remoteLink
            ])
        });

        schemas.push(remoteExecutableSchema);
    }

    return schemas;
};

这是痛苦的一周，但从我所见，他们的问题有望在 graphql-tools 5.0 中得到解决

推荐阅读