Get the names of the parameters of the wrapped function

Question

I want to use the methods of the Minio class without specifying all their parameters, but substituting some of the parameters automatically. How do I do it...

1. I get all the class methods from the prototype of the Minio class and dynamically create wrappers for them in my class.
2. For each wrapper method, I get the parameter names from the original method of the Test class.
3. If there is one in the list of parameters that I want to omit when calling my wrapper method, then I add it to the list of arguments and call originalMethod.apply(this.minioClient, args).

Everything was fine until there were methods that were already wrapped. I need to get the parameter list of the bucketExists method from outside the Minio class. Any idea how to get parameter names from such a wrapped method?

// minio/dist/main/helpers.js
exports function promisify(fn){
  return function(){
    const args = [...arguments];
    fn.apply(this, args);
  }
}

// minio/dist/main/minio.js
class Minio{
  bucketExists(bucketName){
    return bucketName;
  }
  methodThatNotWrappedByPromisifyAndWorksFine(bucketName){
    return bucketName;
  }
}

module.exports = Minio;
Minio.prototype.bucketExists = (0,helpers.promisify)(Minio.prototype.bucketExists)

I want to give an instance of my class with methods wrapped from the original class link the ability to work with only one bucket, that was passed to the my class constructor, without the ability to specify some other one after initialize.

My wrapper

    const proxyHandler = () => {
      return {
        apply: (target, thisArg, argumentsList) => {
          const funcParams = getMethodParamNames(target.source ? target.source.functionForWrap : target);
          const bucketNameIndex = funcParams.indexOf("bucketName");
          const regionNameIndex = funcParams.indexOf("region");

          if (bucketNameIndex >= 0) {
            argumentsList.splice(bucketNameIndex, 0, this.bucket.name);
          }
          if (regionNameIndex >= 0) {
            argumentsList.splice(regionNameIndex, 0, this.bucket.region);
          }
          try {
            return target.apply(this.minioClient, argumentsList);
          } catch (error) {
            logger.engine.error(`S3 '${this.bucket.name}' ${target} error: ${error.message}`, error.stack);
          }
        },
      }
    }

    getMethods(this.minioClient).forEach(func => {
      this[func] = new Proxy(this.minioClient[func], proxyHandler());
    })

Solved the problem by overriding the method wrapper like this.

const MinioHelpers = require('minio/dist/main/helpers');

const origMinioPromisify = MinioHelpers.promisify;

MinioHelpers.promisify = (functionForWrap) => {
    console.log("PATCHED!", functionForWrap);
    var fn = origMinioPromisify(functionForWrap);
    //from this i'll get all need information about wrapped function
    fn.source = {
        functionForWrap,
        promisify: origMinioPromisify,
    } 
    return fn
}

var Minio = require('minio');