Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
// gets JSON response from the external API, parameter `brand` is passed to the external API
try {
const response = await axios.get(
`https://vpic.nhtsa.dot.gov/api/vehicles/getmodelsformake/${
args.brand
}`,
{
responseType: 'json',
params: { format: 'json' }
}
)
const { data } = response
return data.Results
} catch (e) {
// do some error handling if necessary here
throw new GraphQLError('Some error occured while calling the external API.')
}
}
}
function proxyResponse(response, args) {
const rootValue = response.data || {};
const globalErrors = [];
for (const error of (response.errors || [])) {
const { message, path, extensions } = error;
const errorObj = new GraphQLError(
message,
undefined,
undefined,
undefined,
path,
undefined,
extensions,
);
if (!path) {
globalErrors.push(errorObj);
continue;
}
// Recreate root value up to a place where original error was thrown
// and place error as field value.
// Return none if the tag already exists (prevent duplicates)
if (await Tag.findOne({name: args.tag})) {
return null;
}
let tag = new Tag({name: args.tag});
if (args.start) tag.start = new Date(args.start);
if (args.end) tag.end = new Date(args.end);
if (tag.start && tag.end && tag.start >= tag.end) {
throw new GraphQLError("Invalid dates: the tag's end date must be after its start date");
}
if (!tag.start && tag.end) {
throw new GraphQLError("If a tag has an end date defined, it must also have a start date defined");
}
if (tag.start && !tag.end) {
throw new GraphQLError("If a tag has a start date defined, it must also have an end date defined");
}
tag.warnOnDuplicates = args.warnOnDuplicates;
await tag.save();
return {
name: args.tag,
start: args.start ? args.start : "",
end: args.end ? args.end : "",
warnOnDuplicates: args.warnOnDuplicates
};
}
},
it('runs a mutation with default errorPolicy equal to "none"', () => {
const errors = [new GraphQLError('foo')];
return mockMutation({
mutation: gql`
mutation makeListPrivate {
makeListPrivate(id: "5")
}
`,
errors,
}).then(
result => {
throw new Error(
'Mutation should not be successful with default errorPolicy',
);
},
error => {
expect(error.graphQLErrors).toEqual(errors);
if (user === null) throw new GraphQLError('User not found')
} else {
throw new GraphQLError('Unauthorized')
}
if ((currentUser.isAdmin && currentUser.id !== user.id) || await bcrypt.compare(args.oldPassword, user.password)) {
return user.updateAttributes({
password: await bcrypt.hash(args.newPassword, 12),
sessionSignature: db.User.generateSessionSignature()
})
.catch(err => {
console.error(err)
throw new GraphQLError('Error while processing')
})
} else {
throw new GraphQLError('Incorrect password')
}
},
changeUserIsAdmin: async (parent, args, { currentUser }) => {
export function getOperationRootType(schema: GraphQLSchema, operation: OperationDefinitionNode) {
switch (operation.operation) {
case 'query':
return schema.getQueryType();
case 'mutation':
const mutationType = schema.getMutationType();
if (!mutationType) {
throw new GraphQLError('Schema is not configured for mutations', [operation]);
}
return mutationType;
case 'subscription':
const subscriptionType = schema.getSubscriptionType();
if (!subscriptionType) {
throw new GraphQLError('Schema is not configured for subscriptions', [operation]);
}
return subscriptionType;
default:
throw new GraphQLError('Can only compile queries, mutations and subscriptions', [operation]);
}
}
const costLimit = (rule: costComplexityOptions): Function => {
if (rule.costLimit <= 0) throw new GraphQLError('Cost limit must be greater than 0');
return (context: ValidationContext): CostComplexityOptions => {
return new CostComplexityOptions((context: ValidationContext), (rule: costComplexityOptions));
};
};
resolve: async (root, { email, password }, ctx) => {
const { db, auth } = ctx;
if (email === '' || password === '') return MISSING_PARAMETERS;
const user = await db.user.findOne({ email });
if (!user) return NOT_FOUND;
const equalPasswords = await user.comparePassword(password);
if (!equalPasswords) return new GraphQLError(Response({ status: 400, message: 'Bad Request' }));
let authToken;
try {
authToken = await auth.generateToken({ identifier: user._id, email: user.email });
} catch (error) {
return new GraphQLError(
Response({
status: 500,
message: `An error ocurred while generating the authentication token for the user.`,
}),
);
}
ctx.response.cookie('token', authToken, {
httpOnly: true,
domain: config.cookieDomain,
maxAge: 1000 * 60 * 60 * 24 * 365,
});
Field(node: FieldDefinitionNode) {
if (node.name.value === '__schema' || node.name.value === '__type') {
context.reportError(
new GraphQLError(
'GraphQL introspection is not allowed by Apollo Server, but the query contained __schema or __type. To enable introspection, pass introspection: true to ApolloServer in production',
[node],
),
);
}
},
});
const username = hasUserSignIn ? sessionUsername : null;
const userId = hasUserSignIn ? sessionUserid : null;
const random = (Math.random() * 10).toFixed();
if (color.length === 27) {
try {
const row = await sqlExecOne(
'INSERT INTO colorpk_color (`like`, color, userid, username, colortype, display, createdate) VALUES (?, ?, ?, ?, NULL, ?, NOW())',
[random, color, userId, username, hasUserSignIn ? 0 : 1]
);
return {
status: 0,
data: row.insertId,
};
} catch (err) {
return new GraphQLError(err.toString());
}
} else {
return new GraphQLError('create error: invalid color input');
}
},