FG
💻 Software🔌 APIs & SDKs

Should I use GraphQL for fine-grained validation?

Fresh3 days ago
Mar 14, 20260 views
Confidence Score55%
55%

Problem

For example, I want to validate an `email` field. Should I define my own `email scalar type` or just use `GraphQLString` and validate the value in the `resolve` function? [code block] Similar question for checking the `length` of a string. If I have a field that map to a `VARCHAR(100)` in a MySQL database, should I create a specific scalar that check for a valid length? Not sure if it's belongs to GraphQL... or if it is a good practise. Any thoughts? Thanks

Unverified for your environment

Select your OS to check compatibility.

1 Fix

Canonical Fix
Unverified Fix
New Fix – Awaiting Verification

Implement Custom Scalars for Fine-Grained Validation in GraphQL

Medium Risk

GraphQL does not provide built-in validation for specific data formats or constraints like email format or string length. Using `GraphQLString` without validation can lead to invalid data being processed. Custom scalars allow for more precise control over data validation at the schema level.

Awaiting Verification

Be the first to verify this fix

  1. 1

    Define Custom Email Scalar

    Create a custom scalar type for validating email addresses. This will ensure that only valid email formats are accepted at the schema level.

    javascript
    const { GraphQLScalarType, Kind } = require('graphql');

const EmailScalar = new GraphQLScalarType({
  name: 'Email',
  description: 'A valid email address',
  serialize(value) {
    return value;
  },
  parseValue(value) {
    if (typeof value !== 'string' || !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(value)) {
      throw new Error('Invalid email format');
    }
    return value;
  },
  parseLiteral(ast) {
    if (ast.kind === Kind.STRING && /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(ast.value)) {
      return ast.value;
    }
    throw new Error('Invalid email format');
  }
});
  2. 2

    Use Custom Email Scalar in Schema

    Integrate the custom email scalar into your GraphQL schema to replace the standard `GraphQLString` for email fields.

    graphql
    const typeDefs = gql`
  scalar Email

  type User {
    id: ID!
    email: Email!
  }
`;
  3. 3

    Define Custom Length Scalar

    Create a custom scalar type for validating string lengths, specifically for fields that map to a VARCHAR(100) in MySQL. This will enforce length constraints at the schema level.

    javascript
    const LengthScalar = new GraphQLScalarType({
  name: 'Length',
  description: 'A string with a maximum length of 100 characters',
  serialize(value) {
    return value;
  },
  parseValue(value) {
    if (typeof value !== 'string' || value.length > 100) {
      throw new Error('String length exceeds 100 characters');
    }
    return value;
  },
  parseLiteral(ast) {
    if (ast.kind === Kind.STRING && ast.value.length <= 100) {
      return ast.value;
    }
    throw new Error('String length exceeds 100 characters');
  }
});
  4. 4

    Use Custom Length Scalar in Schema

    Integrate the custom length scalar into your GraphQL schema for fields that require length validation.

    graphql
    const typeDefs = gql`
  scalar Length

  type Product {
    id: ID!
    name: Length!
  }
`;
  5. 5

    Test the Scalars

    Write unit tests to ensure that the custom scalars validate inputs correctly. Test both valid and invalid cases to confirm the implementation works as expected.

    javascript
    const { graphql } = require('graphql');

const query = '{ user { email } }';

graphql(schema, query, null, null, {}).then(response => {
  console.log(response);
});

Validation

Confirm that the custom scalars are correctly validating inputs by running GraphQL queries with both valid and invalid email and string length values. Ensure that invalid inputs return appropriate error messages.

Sign in to verify this fix

Environment

Submitted by

AC

Alex Chen

2450 rep

Tags

graphqlapischema