Finding Permutations of Numbers
I'm not entirely sure what this code does, but it certainly seems too long for the problem. First some general review:


      let numString = n.toString();



This is a matter where opinions will certainly differ, but I would prefer to instead assign n = n.toString(); as n is never used again, and the real purpose of this line is to coerce the input to the type which you want to receive.


      let permutations = []



This is a bit surprising: you only need to generate one permutation, so why do you need an array with many? A comment explaining the purpose would be nice.


      let smallest = numString[0];



This is also surprising. "Smallest" in what sense? It's unlikely that the smallest digit will coincidentally be the first one.


      if(descending || same){
        return -1;
      } 



Is there any reason for using two variables here? I think it could be simplified by having one variable which tracks whether there's any increase over the previous digit (although the complete rewrite will eliminate this anyway).


      const permute = (prefix, str) =&gt; {



What does this function do? Comment!


        let index = String(str).length;



Earlier the code used toString(); here it uses String(...) to do the same thing. Be consistent.


        if(index == 1){



Although index will always be a number, consistently using === reduces the cognitive load in working out whether == should really have been ===.


      let nextBiggest = Infinity;



WTF? This method was working with strings: where does Infinity come into it?


      return -1



This should be unreachable, so why not throw an exception to alert you to the fact that if it's reached you have a bug?



Now, the part you're really interested in. The algorithm.

The question of finding the next permutation in lexicographic order is a classical one (going back 7 centuries) and well documented in the literature. E.g. Wikipedia gives the following algorithm:


  
  Find the largest index k such that a[k] &lt; a[k + 1]. If no such index exists, the permutation is the last permutation.
  Find the largest index l greater than k such that a[k] &lt; a[l].
  Swap the value of a[k] with that of a[l].
  Reverse the sequence from a[k + 1] up to and including the final element a[n].