graphql-tools: Something wrong with directives

I tried all kinds of things but could not solve this problem

Related Codes;

LengthDirective.js

const {
  GraphQLNonNull,
  GraphQLString,
  isNonNullType,
  isScalarType
} = require("graphql")
const { SchemaDirectiveVisitor } = require("graphql-tools")
const LimitedLengthType = require("../scalars/LimitedLengthType");
const InvalidScalarTypeError = require("../scalars/InvalidScalarTypeError")

class LengthDirective extends SchemaDirectiveVisitor{

  visitInputFieldDefinition(field, _details) {
    this.wrapType(field)
  }

  visitFieldDefinition(field, _details) {
    this.wrapType(field)
  }

  visitArgumentDefinition(argument, details) {
    this.wrapType(argument)
  }

  wrapType(field){
    if(isNonNullType(field.type) && field.type.ofType === GraphQLString){
      field.type = new GraphQLNonNull(
        new LimitedLengthType(field.astNode.name.value, field.type.ofType, {
          max: this.args.max,
          min: this.args.min
        })
      )
    }else if(isScalarType(field.type) && field.type === GraphQLString){
      field.type = new LimitedLengthType(field.astNode.name.value, field.type, {
        max: this.args.max,
        min: this.args.min
      })
    }else{
      throw new InvalidScalarTypeError(`Not a scalar type: ${field.type}`, field)
    }
  }

}

module.exports = LengthDirective

LimitedLengthType.js

const ScalarType = require("./ScalarType")
const GraphQLValidationError = require("./GraphQLValidationError");

class LimitedLengthType extends ScalarType{

  constructor(name, type, args){
    super({
      name: `LimitedLength`,
      serialize: value => {
        value = type.serialize(value)

        this.validate(name, args, value)

        return value
      },
      parseValue: value => {
        value = type.parseValue(value)

        this.validate(name, args, value)

        return value
      },
      parseLiteral: ast => {
        ast = type.parseLiteral(ast)

        this.validate(name, args, ast)

        return ast
      }
    })
  }

  validate(name, args, value){
    if(args.max && value.length > args.max){
      throw new GraphQLValidationError(name, `Must be no more than ${args.max} characters in length`, [{
        arg: "max",
        value: args.min
      }])
    }

    if(args.min && value.length < args.min){
      throw new GraphQLValidationError(name, `Must be at least ${args.min} characters in length`, [{
        arg: "min",
        value: args.min
      }])
    }
  }
}

module.exports = LimitedLengthType