错误处理

1
import { ApolloServerErrorCode } from '@apollo/server/errors';
2

3
if (error.extensions?.code === ApolloServerErrorCode.GRAPHQL_PARSE_FAILED) {
4
  // respond to the syntax error
5
} else if (error.extensions?.code === "MY_CUSTOM_CODE") {
6
  // do something else
7
}

1
import { GraphQLError } from 'graphql';
2

3
throw new GraphQLError(message, {
4
  extensions: { code: 'YOUR_ERROR_CODE', myCustomExtensions },
5
});

1
import { GraphQLError } from 'graphql';
2

3
throw new GraphQLError('You are not authorized to perform this action.', {
4
  extensions: {
5
    code: 'FORBIDDEN',
6
  },
7
});

1
import { ApolloServer } from '@apollo/server';
2
import { startStandaloneServer } from '@apollo/server/standalone';
3
import { ApolloServerErrorCode } from '@apollo/server/errors';
4

5
const server = new ApolloServer({
6
  typeDefs,
7
  resolvers,
8
  formatError: (formattedError, error) => {
9
    // Return a different error message
10
    if (
11
      formattedError.extensions.code ===
12
      ApolloServerErrorCode.GRAPHQL_VALIDATION_FAILED
13
    ) {
14
      return {
15
        ...formattedError,
16
        message: "Your query doesn't match the schema. Try double-checking it!",
17
      };
18
    }
19

20
    // Otherwise return the formatted error. This error can also
21
    // be manipulated in other ways, as long as it's returned.
22
    return formattedError;
23
  },
24
});
25

26
const { url } = await startStandaloneServer(server);
27
console.log(`🚀 Server listening at: ${url}`);

1
formatError: (formattedError, error) => {
2
  if (formattedError.message.startsWith('Database Error: ')) {
3
    return { message: 'Internal server error' };
4
  }
5

6
  // Otherwise return the formatted error.
7
  return formattedError;
8
},

1
formatError: (formattedError, error) => {
2
    if (error instanceof CustomDBError) {
3
      // do something specific
4
    }
5
  },

1
import { unwrapResolverError } from '@apollo/server/errors';
2

3
new ApolloServer({
4
  formatError: (formattedError, error) => {
5
    // unwrapResolverError removes the outer GraphQLError wrapping from
6
    // errors thrown in resolvers, enabling us to check the instance of
7
    // the original error
8
    if (unwrapResolverError(error) instanceof CustomDBError) {
9
      return { message: 'Internal server error' };
10
    }
11
  },
12
});

1
new ApolloServer({
2
  // etc.
3
  plugins: [
4
    ApolloServerPluginUsageReporting({
5
      // If you pass unmodified: true to the usage reporting
6
      // plugin, Apollo Studio receives ALL error details
7
      sendErrors: { unmodified: true },
8
    }),
9
  ],
10
});

1
new ApolloServer({
2
  // etc.
3
  plugins: [
4
    ApolloServerPluginUsageReporting({
5
      sendErrors: {
6
        transform: (err) => {
7
          if (err.extensions.code === 'MY_CUSTOM_CODE') {
8
            // returning null will skip reporting this error
9
            return null;
10
          }
11

12
          // All other errors are reported.
13
          return err;
14
        },
15
      },
16
    }),
17
  ],
18
});

1
import { ApolloServer } from '@apollo/server';
2
import { ApolloServerPluginUsageReporting } from '@apollo/server/plugin/usageReporting';
3
const server = new ApolloServer({
4
  typeDefs,
5
  resolvers,
6
  plugins: [
7
    ApolloServerPluginUsageReporting({
8
      sendErrors: {
9
        transform: (err) => {
10
          // Return `null` to avoid reporting `UNAUTHENTICATED` errors
11
          if (err.extensions.code === 'UNAUTHENTICATED') {
12
            return null;
13
          }
14

15
          // All other errors will be reported.
16
          return err;
17
        },
18
      },
19
    }),
20
  ],
21
});

1
import { ApolloServer } from '@apollo/server';
2
import { ApolloServerPluginUsageReporting } from '@apollo/server/plugin/usageReporting';
3

4
const server = new ApolloServer({
5
  typeDefs,
6
  resolvers,
7
  plugins: [
8
    ApolloServerPluginUsageReporting({
9
      sendErrors: {
10
        transform: (err) => {
11
          // Using a more stable, known error extension (e.g. `err.code`) would be
12
          // more defensive, however checking the `message` might serve most needs!
13
          if (err.message && err.message.startsWith('Known error message')) {
14
            return null;
15
          }
16

17
          // All other errors should still be reported!
18
          return err;
19
        },
20
      },
21
    }),
22
  ],
23
});

1
import { GraphQLError } from 'graphql';
2

3
throw new GraphQLError(
4
  "The x-api-key:12345 doesn't have sufficient privileges.",
5
);

1
import { ApolloServer } from '@apollo/server';
2
import { ApolloServerPluginUsageReporting } from '@apollo/server/plugin/usageReporting';
3

4
const server = new ApolloServer({
5
  typeDefs,
6
  resolvers,
7
  plugins: [
8
    ApolloServerPluginUsageReporting({
9
      sendErrors: {
10
        transform: (err) => {
11
          // Make sure that a specific pattern is removed from all error messages.
12
          err.message = err.message.replace(/x-api-key:[A-Z0-9-]+/, 'REDACTED');
13
          return err;
14
        },
15
      },
16
    }),
17
  ],
18
});

1
The REDACTED doesn't have sufficient privileges.

1
const setHttpPlugin = {
2
  async requestDidStart() {
3
    return {
4
      async willSendResponse({ response }) {
5
        response.http.headers.set('custom-header', 'hello');
6
        if (response.body.kind === 'single' &&
7
            response.body.singleResult.errors?.[0]?.extensions?.code === 'TEAPOT') {
8
          response.http.status = 418;
9
        }
10
      },
11
    };
12
  },
13
};
14

15
const server = new ApolloServer({
16
  typeDefs,
17
  resolvers,
18
  plugins: [setHttpPlugin],
19
});