GraphQL constraint directive ^+^

Allows using @constraint directive to validate GraphQL resolver input data.

Inspired by Constraints Directives RFC and OpenAPI

This library is an extension of graphql-constraint-directive

This library by default uses validator for string validation.

We include a test suite that covers using all constraint directives (See running tests), except for the List constraint validator (WIP).

If you add support for validating additional string formats (or other validations), please make sure to add tests to cover success/failure cases before making a PR.

Install

npm install graphql-constraint-directive-plus

Usage

1const ConstraintDirective = require("graphql-constraint-directive-plus");
2const express = require("express");
3const bodyParser = require("body-parser");
4const { graphqlExpress } = require("apollo-server-express");
5const { makeExecutableSchema } = require("graphql-tools");
6const typeDefs = `
7  type Query {
8    books: [Book]
9  }
10  type Book {
11    title: String
12  }
13  type Mutation {
14    createBook(input: BookInput): Book
15  }
16  input BookInput {
17    title: String! @constraint(minLength: 5, format: "email")
18  }`;
19const schema = makeExecutableSchema({
20  typeDefs,
21  schemaDirectives: { constraint: ConstraintDirective }
22});
23const app = express();
24
25app.use("/graphql", bodyParser.json(), graphqlExpress({ schema }));

Integrations

Syncing validation for:

• entity models (on mutation save)
• forms (on field change or submit)

You can use the constraints of this library with graphql-typeorm-validation to generate decorators for [class-validator] that can be used on any entity model, such as a TypeOrm entity

1@Entity
2class Person extends BaseEntity {
3  @MinLength(2)
4  @MaxLength(60)
5  name: string;
6}

Use this with a typeorm connection to build an entity class map, where each map entry is a model class with matching class-validator validation decorators applied.

The validation constraints are extracted via graphGenTypeorm from a GraphQL type definition

1import { buildEntityClassMap } from "graphql-typeorm-validation";
2
3const entityClassMap = buildEntityClassMap(connection);
4const { Post } = entityClassMap;
5// ...

First your createPost mutation resolver applies directive constraints on input object. It can then call createPostModel to create an in-memory Post model, validate it and then save it to the typeorm storage repository.

1const createPostModel = async ({title, text}) {
2  try {
3    let postRepository = connection.getRepository("Post");
4    let post = new Post();
5    post.title = title;
6    post.text = text;
7    await validate(post, {
8      // ... optional validation options
9    });
10    await postRepository.save(post);
11    return post
12  } catch (err) {
13    handleError(`createPostModel failure: ${err.message}`, err)
14  }
15}

Mapping to general entity models

graphGenTypeorm uses graphSchemaToJson to first convert GraphQL type definitions (schema) to a Javascript object (JSON).

You could feed this schema object directly to the mapper.

This can be done using the decorate class API which lets you decorate any entity class with class-validator decorators.

Syncing validations with forms

You can further use the schema object to generate Yup form validations, using custom models in json-schema-to-yup.

Yup goes hand-in-glove with Formik, the amazing form builder. Ideally you would then also generate the form, mapping model/type fields to form fields...

We then need to use Yup addMethod to create additional Yup validators to match those available for the @constraint directive

1const validator = require("validator");
2
3Yup.addMethod(Yup.string, "isHexColor", function(args) {
4  const { message } = args;
5  return this.test("hex-color", message, function(value) {
6    const { path, createError } = this;
7    // [value] - value of the property being tested
8    // [path]  - property name,
9    // ...
10    return validator.isHexColor(value) || createError({ path, message });
11  });
12});

With a little "trickery", you can sync your validations across:

• models
• mutation resolvers
• forms

Would love to see your contributions to make this dream into reality. Almost there!

API

String

minLength

@constraint(minLength: 5) Restrict to a minimum length

maxLength

@constraint(maxLength: 5) Restrict to a maximum length

startsWith

@constraint(startsWith: "foo") Ensure value starts with foo

endsWith

@constraint(endsWith: "foo") Ensure value ends with foo

contains

@constraint(contains: "foo") Ensure value contains foo

notContains

@constraint(notContains: "foo") Ensure value does not contain foo

pattern

@constraint(pattern: "^[0-9a-zA-Z]*$") Ensure value matches regex, e.g. alphanumeric

format

@constraint(format: "email") Ensure value is in a particular format

Supported formats:

• alpha-numeric
• alpha
• ascii
• byte
• credit-card
• currency-amount
• data-uri
• date-time
• date
• domain-name
• email
• hash
• hex-color
• ipv4
• ipv6
• isbn
• magnet-uri
• mime-type
• mobile-phone
• mongo-id
• postal-code
• uri
• uuid

Format validator options can be set as additional directive arguments:

1@constraint(format: 'alpha-numeric', locale: 'en-US')

Format options available (with default values):

• alphaLocale (string)
• postalLocale (string)
• phoneLocale (string)
• hashAlgo (string)
• domainName (object)
• email (object)
• currency (object)

1{
2  locale: "en-US", // used by alpha, alphanumeric, postalCode and mobilePhone
3  hashAlgo: "md5",
4  domainName: {
5    require_tld: true,
6    allow_underscores: false,
7    allow_trailing_dot: false
8  },
9  email: {
10    allow_display_name: false,
11    require_display_name: false,
12    allow_utf8_local_part: true,
13    require_tld: true,
14    allow_ip_domain: false,
15    domain_specific_validation: false
16  },
17  currency: {
18    symbol: "$",
19    require_symbol: false,
20    allow_space_after_symbol: false,
21    symbol_after_digits: false,
22    allow_negatives: true,
23    parens_for_negatives: false,
24    negative_sign_before_digits: false,
25    negative_sign_after_digits: false,
26    allow_negative_sign_placeholder: false,
27    thousands_separator: ",",
28    decimal_separator: ".",
29    allow_decimal: true,
30    require_decimal: false,
31    digits_after_decimal: [2],
32    allow_space_after_digits: false
33  }
34}

Int/Float

min

@constraint(min: 3) Ensure value is greater than or equal to

max

@constraint(max: 3) Ensure value is less than or equal to

exclusiveMin

@constraint(exclusiveMin: 3) Ensure value is greater than

exclusiveMax

@constraint(exclusiveMax: 3) Ensure value is less than

multipleOf

@constraint(multipleOf: 10) Ensure value is a multiple

ConstraintDirectiveError

Each validation error throws a ConstraintDirectiveError. Combined with a formatError function, this can be used to customise error messages.

1{
2  code: 'ERR_GRAPHQL_CONSTRAINT_VALIDATION',
3  fieldName: 'theFieldName',
4  context: [ { arg: 'argument name which failed', value: 'value of argument' } ]
5}

1const formatError = function(error) {
2  if (
3    error.originalError &&
4    error.originalError.code === "ERR_GRAPHQL_CONSTRAINT_VALIDATION"
5  ) {
6    // return a custom object
7  }
8
9  return error;
10};
11
12app.use("/graphql", bodyParser.json(), graphqlExpress({ schema, formatError }));

Customization

By default, the constraint directive uses validator.js

You can pass your own validator in the GraphQL context object, conforming to this API:

• isLength(value)
• contains(value)
• isAlphanumeric(value, locale)
• isAlpha(value, locale)
• isAscii(value)
• isByte(value)
• isCreditCard(value)
• isCurrency(value)
• isDataUri(value)
• isDateTime(value)
• isDate(value)
• isDomainName(value)
• isEmail(value)
• isHash(value)
• isHexColor(value)
• isIPv6(value)
• isIPv4(value)
• isIsbn(value)
• isMagnetUri(value)
• isMimeType(value)
• isMobilePhone(value, locale)
• isMongoId(value)
• `isPostalCode(value, countryCode)
• isUri(value)
• isUUID(value)

Note: All the above methods expect value to be a string.

The default validator is wrapped as follows:

1const wrappedValidator = {
2  // wrap your own validator using the same API
3  isLength: validator.isLength,
4  contains: validator.contains,
5
6  isAlpha: validator.isAlpha,
7  isAlphanumeric: validator.isAlphanumeric,
8  isAscii: validator.isAscii,
9
10  isByte: validator.isBase64,
11
12  isCreditCard: validator.isCreditCard,
13  isCurrency: validator.isCurrency,
14
15  isDataUri: validator.isDataURI,
16  isDateTime: validator.isRFC3339,
17  isDate: validator.isISO8601,
18  isDomainName: validator.isFQDN,
19
20  isEmail: validator.isEmail,
21
22  isHash: validator.isHash,
23  isHexColor: validator.isHexColor,
24
25  isIPv6: value => validator.isIP(value, 6),
26  isIPv4: value => validator.isIP(value, 4),
27  isIsbn: validator.isISBN,
28
29  isMagnetUri: validator.isMagnetURI,
30  isMobilePhone: validator.isMobilePhone,
31  isMongoId: validator.isMongoId,
32  isMimeType: validator.isMimeType,
33
34  isPostalCode: validator.isPostalCode,
35
36  isUri: validator.isURL,
37  isUUID: validator.isUUID
38};

Validation messages

You can set a validationError function map on the GraphQL context object to provide your own validator error handlers.

• format(key, value)
• `string(name, msg, args[])
• `number(name, msg, args[])

The format validators will call: validationError.format('date', value)

The string and number validators will call the error handler like this:

1validationError.string(name, `Must match ${args.pattern}`, [
2  { arg: "pattern", value: args.pattern }
3]);

Note that the third argument contains a list where each object has an arg entry that indicates the constraint that failed. You can use this as a key to lookup in your own validation error message map to return or output a localized error message as you see fit.

Reusing validators

You can re-use the core validators as follows:

1import {
2  string,
3  number,
4  list
5} from "graphql-constraint-directive/scalars/validate";
6import { validationError } from "graphql-constraint-directive/scalars/error";
7import { validator } from "graphql-constraint-directive/validator";
8
9const field = "name";
10const args = { minLength: 4, maxLength: 40 };
11value = "John Smith";
12
13string.validate(name, args, value, { validator, validationError });

Complex types

See Complex types

Development

Tests

Run npm run test:nolint to run all tests without linting

Resources

• GraphQL List - How to use arrays in GraphQL schema (GraphQL Modifiers)
• Deep dive into GraphQL type system
• Life of a GraphQL Query — Validation
• Graphql validated types

License

See License