GraphQL - how to specify maximum String lengths in schema

You can use directives:

directive @length(max: Int!) on FIELD_DEFINITION

input Payload {
  name: String! @length(max: 50)
}

There is no place for this type of specification in graphql (types) definitions.

You can use directives but they are not supported (and not standarized) by all graphql servers - it's left to specific implementation details - check your server docs.

For single fields you can simply apply this logic inside mutation resolver - just throw an error if conditions (input string length between 1 and 20) not met.

This is possible to implement using GraphQL custom types. You can define a type for each maximum length you want:

StringMaxLenTypes.js:

const logToConsoleToHelpMeUnderstand = false;
const { GraphQLScalarType, Kind } = require('graphql');
const parseStringMaxLenType = (value,maxLength) => {
  logToConsoleToHelpMeUnderstand && console.log('Checking variable passed to a query is a string and max ' + maxLength + 'chars',value)
  if (typeof value === 'string') {
    if (value.length <= maxLength) {
      return value;
    } else {
      throw new Error('parseCi' + maxLength + 'Type: String must not be more that ' + maxLength + ' characters. It is ' + value.length + ' characters');
    }
  } else {
    throw new Error('parseCi' + maxLength + 'Type: value must be of type String. It is of type \'' + typeof value + '\'');
  }
}
const parseStringMaxLen20Type = value => { return parseStringMaxLenType(value, 20) };
const parseStringMaxLen25Type = value => { return parseStringMaxLenType(value, 25) };
const parseStringMaxLen50Type = value => { return parseStringMaxLentype(value, 50) };
const parseStringMaxLen255Type = value => { return parseStringMaxLentype(value, 255) };
const parseStringMaxLen500Type = value => { return parseStringMaxLentype(value, 500) };


const serializeStringMaxLenType = (value, maxLength) => {
  /** the serialize methods are called when data is going to be sent to the client. This can return anything
   * of any type, as it will end up as JSON, but we check what is coming back from the database is a string 
   * and not too long.
   */
  logToConsoleToHelpMeUnderstand && console.log(`Checking value '${value}' is at most ${maxLength} chars before serialising for output from graphQL to a client (the OCCP gateway is the client)`);
  if (typeof value === 'string') {
    if (value.length <= maxLength) {
      return value;
    } else {
      throw new Error('serializeCi' + maxLength + 'Type: String must not be more that ' + maxLength + ' characters. It is ' + value.length + ' characters');
    }
  } else {
    throw new Error('serializeCi' + maxLength + 'Type: value must be of type String. It is of type \'' + typeof value + '\'');
  }
};
const serializeStringMaxLen20Type = (value) => { return serializeStringMaxLenType(value,20) };
const serializeStringMaxLen25Type = (value) => { return serializeStringMaxLenType(value,25) };
const serializeStringMaxLen50Type = (value) => { return serializeStringMaxLenType(value,50) };
const serializeStringMaxLen255Type = (value) => { return serializeStringMaxLenType(value,255) };
const serializeStringMaxLen500Type = (value) => { return serializeStringMaxLenType(value,500) };

const parseLiteralStringMaxLenType = (ast, maxLength) => {
  logToConsoleToHelpMeUnderstand && console.log('checking Abstract Syntax Tree value (these come from parameters in GraphQL queries) is not more than ' + maxLength + ' chars long',ast);
  // For input payload i.e. for mutation. ast stands for abstract syntax tree, which is the type of 
  if (ast.kind === Kind.STRING) {
  // Note the parseStringMaxLenType function throws errors, or returns a valid value, so there is no need to throw errors here.
    return parseStringMaxLenType(ast.value, maxLength)
  } else {
    throw new Error()
  }
};

const parseLiteralStringMaxLen20Type = (ast) => { return parseLiteralStringMaxLenType(ast, 20) }
const parseLiteralStringMaxLen25Type = (ast) => { return parseLiteralStringMaxLenType(ast, 25) }
const parseLiteralStringMaxLen50Type = (ast) => { return parseLiteralStringMaxLenType(ast, 50) }
const parseLiteralStringMaxLen255Type = (ast) => { return parseLiteralStringMaxLenType(ast, 255) }
const parseLiteralStringMaxLen500Type = (ast) => { return parseLiteralStringMaxLenType(ast, 500) }

const StringMaxLen20Type = new GraphQLScalarType({
  name: 'StringMaxLen20Type',
  description: 'String up to 20 Chars',
  serialize: serializeStringMaxLen20Type,
  parseValue: parseStringMaxLen20Type,
  parseLiteral: parseLiteralStringMaxLen20Type,
});

const StringMaxLen25Type = new GraphQLScalarType({
  name: 'StringMaxLen25Type',
  description: 'String up to 25 Chars',
  serialize: serializeStringMaxLen25Type,
  parseValue: parseStringMaxLen25Type,
  parseLiteral: parseLiteralStringMaxLen25Type,
});

const StringMaxLen50Type = new GraphQLScalarType({
  name: 'StringMaxLen50Type',
  description: 'String up to 50 Chars',
  serialize: serializeStringMaxLen50Type,
  parseValue: parseStringMaxLen50Type,
  parseLiteral: parseLiteralStringMaxLen50Type,
});

const StringMaxLen255Type = new GraphQLScalarType({
  name: 'StringMaxLen255Type',
  description: 'String up to 255 Chars',
  serialize: serializeStringMaxLen255Type,
  parseValue: parseStringMaxLen255Type,
  parseLiteral: parseLiteralStringMaxLen255Type,
});

const StringMaxLen500Type = new GraphQLScalarType({
  name: 'StringMaxLen500Type',
  description: 'String up to 500 Chars',
  serialize: serializeStringMaxLen500Type,
  parseValue: parseStringMaxLen500Type,
  parseLiteral: parseLiteralStringMaxLen500Type,
});

module.exports = {StringMaxLen20Type, StringMaxLen25Type, StringMaxLen50Type, StringMaxLen255Type, StringMaxLen500Type };

Then you need to define each of these types in your grapql.shema schema.graphql:

scalar StringMaxLen20Type
scalar StringMaxLen25Type
scalar StringMaxLen50Type
scalar StringMaxLen255Type
scalar StringMaxLen500Type
type YourOtherTypes {
  id: ID!
  canUseAboveTypesLikeThis: StringMaxLen50Type
}

And import them into your resolvers.js, and define them in the resolver object passed to your graphQL server : resolvers.js:

...
...
const {StringMaxLen20Type, StringMaxLen25Type, StringMaxLen50Type, StringMaxLen255Type, StringMaxLen500Type } = require('StringMaxLenTypes.js');```
...
module.exports = {
Query: {...},
Mutation: {...},
StringMaxLen20Type,
StringMaxLen25Type,
StringMaxLen50Type,
StringMaxLen255Type,
StringMaxLen500Type

This will then apply the same strict checking that GraphQL does all its data types to the maximum lengths.