在线时间:8:00-16:00
迪恩网络APP
随时随地掌握行业动态
扫描二维码
关注迪恩网络微信公众号
开源软件名称(OpenSource Name):thebigredgeek/apollo-resolvers开源软件地址(OpenSource Url):https://github.com/thebigredgeek/apollo-resolvers开源编程语言(OpenSource Language):JavaScript 73.5%开源软件介绍(OpenSource Introduction):apollo-resolversExpressive and composable resolvers for Apollostack's GraphQL server OverviewWhen standing up a GraphQL backend, one of the first design decisions you will undoubtedly need to make is how you will handle authentication, authorization, and errors. GraphQL resolvers present an entirely new paradigm that existing patterns for RESTful APIs fail to adequately address. Many developers end up writing duplicitous authorization checks in a vast majority of their resolver functions, as well as error handling logic to shield the client from encountering exposed internal errors. The goal of
With In addition to the design pattern that Example from Apollo DayQuick startInstall the package: npm install apollo-resolvers Create a base resolver for last-resort error masking: import { createResolver } from 'apollo-resolvers';
import { createError, isInstance } from 'apollo-errors';
const UnknownError = createError('UnknownError', {
message: 'An unknown error has occurred! Please try again later'
});
export const baseResolver = createResolver(
//incoming requests will pass through this resolver like a no-op
null,
/*
Only mask outgoing errors that aren't already apollo-errors,
such as ORM errors etc
*/
(root, args, context, error) => isInstance(error) ? error : new UnknownError()
); Create a few child resolvers for access control: import { createError } from 'apollo-errors';
import { baseResolver } from './baseResolver';
const ForbiddenError = createError('ForbiddenError', {
message: 'You are not allowed to do this'
});
const AuthenticationRequiredError = createError('AuthenticationRequiredError', {
message: 'You must be logged in to do this'
});
export const isAuthenticatedResolver = baseResolver.createResolver(
// Extract the user from context (undefined if non-existent)
(root, args, { user }, info) => {
if (!user) throw new AuthenticationRequiredError();
}
);
export const isAdminResolver = isAuthenticatedResolver.createResolver(
// Extract the user and make sure they are an admin
(root, args, { user }, info) => {
/*
If thrown, this error will bubble up to baseResolver's
error callback (if present). If unhandled, the error is returned to
the client within the `errors` array in the response.
*/
if (!user.isAdmin) throw new ForbiddenError();
/*
Since we aren't returning anything from the
request resolver, the request will continue on
to the next child resolver or the response will
return undefined if no child exists.
*/
}
) Create a profile update resolver for our user type: import { isAuthenticatedResolver } from './acl';
import { createError } from 'apollo-errors';
const NotYourUserError = createError('NotYourUserError', {
message: 'You cannot update the profile for other users'
});
const updateMyProfile = isAuthenticatedResolver.createResolver(
(root, { input }, { user, models: { UserModel } }, info) => {
/*
If thrown, this error will bubble up to isAuthenticatedResolver's error callback
(if present) and then to baseResolver's error callback. If unhandled, the error
is returned to the client within the `errors` array in the response.
*/
if (!user.isAdmin && input.id !== user.id) throw new NotYourUserError();
return UserModel.update(input);
}
);
export default {
Mutation: {
updateMyProfile
}
}; Create an admin resolver: import { createError, isInstance } from 'apollo-errors';
import { isAuthenticatedResolver, isAdminResolver } from './acl';
const ExposedError = createError('ExposedError', {
message: 'An unknown error has occurred'
});
const banUser = isAdminResolver.createResolver(
(root, { input }, { models: { UserModel } }, info) => UserModel.ban(input),
(root, args, context, error) => {
/*
For admin users, let's tell the user what actually broke
in the case of an unhandled exception
*/
if (!isInstance(error)) throw new ExposedError({
// overload the message
message: error.message
});
}
);
export default {
Mutation: {
banUser
}
}; Combine your resolvers into a single definition ready for use by import { combineResolvers } from 'apollo-resolvers';
import User from './user';
import Admin from './admin';
/*
This combines our multiple resolver definition
objects into a single definition object
*/
const resolvers = combineResolvers([
User,
Admin
]);
export default resolvers; Conditional resolvers: import { and, or } from 'apollo-resolvers';
import isFooResolver from './foo';
import isBarResolver from './bar';
const banResolver = (root, { input }, { models: { UserModel } }, info)=> UserModel.ban(input);
// Will execute banResolver if either isFooResolver or isBarResolver successfully resolve
// If none of the resolvers succeed, the error from the last conditional resolver will
// be returned
const orBanResolver = or(isFooResolver, isBarResolver)(banResolver);
// Will execute banResolver if both isFooResolver and isBarResolver successfully resolve
// If one of the condition resolvers throws an error, it will stop the execution and
// return the error
const andBanResolver = and(isFooResolver, isBarResolver)(banResolver);
// In both cases, conditions are evaluated from left to right Resolver contextResolvers are provided a mutable context object that is shared between all resolvers for a given request. A common pattern with GraphQL is inject request-specific model instances into the resolver context for each request. Models frequently reference one another, and unbinding circular references can be a pain. import express from 'express';
import bodyParser from 'body-parser';
import { GraphQLError } from 'graphql';
import { graphqlExpress } from 'apollo-server-express';
import { createExpressContext } from 'apollo-resolvers';
import { formatError as apolloFormatError, createError } from 'apollo-errors';
import { UserModel } from './models/user';
import schema from './schema';
const UnknownError = createError('UnknownError', {
message: 'An unknown error has occurred. Please try again later'
});
const formatError = error => {
let e = apolloFormatError(error);
if (e instanceof GraphQLError) {
e = apolloFormatError(new UnknownError({
data: {
originalMessage: e.message,
originalError: e.name
}
}));
}
return e;
};
const app = express();
app.use(bodyParser.json());
app.use((req, res, next) => {
req.user = null; // fetch the user making the request if desired
next();
});
app.post('/graphql', graphqlExpress((req, res) => {
const user = req.user;
const models = {
User: new UserModel(user)
};
const context = createExpressContext({
models,
user
}, res);
return {
schema,
formatError, // error formatting via apollo-errors
context // our resolver context
};
}));
export default app; |
2023-10-27
2022-08-15
2022-08-17
2022-09-23
2022-08-13
请发表评论