Custom directive to check list length for input types

I tried my best to write a custom directive in apollo server express to validate if an input type field of type [Int] does not have more than max length but do not know if its the right way to do. Appreciate if somebody could help me correct any mistakes in the code below.

// schema.js
directive @listLength(max: Int) on INPUT_FIELD_DEFINITION

  input FiltersInput {
    filters: Filters
  }

  input Filters {
    keys: [Int] @listLength(max: 10000)
  }

// Custom directive
const { SchemaDirectiveVisitor } = require('apollo-server-express');
import {
  GraphQLList,
  GraphQLScalarType,
  GraphQLInt,
  Kind,
  DirectiveLocation,
  GraphQLDirective
} from "graphql";

export class ListLengthDirective extends SchemaDirectiveVisitor {
  static getDirectiveDeclaration(directiveName) {
    return new GraphQLDirective({
      name: directiveName,
      locations: [DirectiveLocation.INPUT_FIELD_DEFINITION],
      args: {
        max: { type: GraphQLInt },
      }
    });
  }
  // Replace field.type with a custom GraphQLScalarType that enforces the
  // length restriction.
  wrapType(field) {
    const fieldName = field.astNode.name.value;
    const { type } = field;
    if (field.type instanceof GraphQLList) {
      field.type = new LimitedLengthType(fieldName, type, this.args.max);
    } else {
      throw new Error(`Not a scalar type: ${field.type}`);
    }
  }

  visitInputFieldDefinition(field) {
    this.wrapType(field);
  }
}

class LimitedLengthType extends GraphQLScalarType {
  constructor(name, type, maxLength) {
  super({
      name,

      serialize(value) {
        return type.serialize(value);
      },

      parseValue(value) {
        value = type.serialize(value);

        return type.parseValue(value);
      },

      parseLiteral(ast) {
        switch (ast.kind) {
          case Kind.LIST:
            if (ast.values.length > maxLength) {
              throw {
                code: 400,
                message: `'${name}' parameter cannot extend ${maxLength} values`,
              };
            }
            const arrayOfInts = ast.values.map(valueObj => parseInt(valueObj['value']));
            return arrayOfInts;
        }
        throw new Error('ast kind should be Int of ListValue')
      },
    });
  }
}

Does this look right?

Thanks