How to use the generic-pool.createPool function in generic-pool

const opts = {
    max: 10,
    min: 2,
    maxWaitingClients: 2,
    testOnBorrow: true,
    acquireTimeoutMillis: 100,
    fifo: true,
    priorityRange: 5,
    autostart: false,
    evictionRunIntervalMillis: 200,
    numTestsPerRun: 3,
    softIdleTimeoutMillis: 100,
    idleTimeoutMillis: 5000
};

const pool = genericPool.createPool(factory, opts);

pool.start();

pool.use((conn: Connection) => 'test')
    .then((result: string) => { });

pool.acquire()
    .then((conn: Connection) => {
        console.log(pool.isBorrowedResource(conn));  // => true
        return pool.release(conn);
    }).then(() => {
        return pool.acquire(5);
    }).then((conn: Connection) => {
        return pool.destroy(conn);
    }).then(() => {
        return pool.clear();

//
    // The pool should be used for WATCH/MULTI/EXEC transactions
    //
    const factory = {
      create() {
        return Promise.resolve(createClient());
      },
      destroy(client) {
        client.quit();
        return Promise.resolve();
      }
    };

    const opts = { min: 1, max: 10 };

    this.pool = genericPool.createPool(factory, opts);
  }
}

return function Actor(configStr) {
        // if we can't create a new actor, throw early rather than in the actor pool
        new Valhalla(configStr);

        const actorPool = genericPool.createPool(actorFactory, opts);

        function actorMethodFactory(methodName) {
            return function(request, cb) {
                if (!request || !cb) throw new Error('method must be called with string and callback');

                actorPool.acquire().then(function(actor) {
                    actorPool.on('factoryCreateError', function(err) {
                        return cb(err);
                    });

                    actor[methodName](request, function(err, result) {
                        actorPool.release(actor);
                        return cb(err, result);
                    });
                });
            }

function mongo(options) {
  options = Object.assign({}, defaultOptions, options);
  let mongoUrl = options.uri || options.url;
  if (!mongoUrl) {
    if (options.user && options.pass) {
      mongoUrl = `mongodb://${options.user}:${options.pass}@${options.host}:${options.port}/${options.db}`;
    } else {
      mongoUrl = `mongodb://${options.host}:${options.port}/${options.db}`;
    }
  }

  const mongoPool = genericPool.createPool({
    create: () => MongoClient.connect(mongoUrl),
    destroy: client => client.close()
  }, options);

  async function release(resource) {
    await mongoPool.release(resource);
    debug('Release one connection (min: %s, max: %s, poolSize: %s)', options.min, options.max, mongoPool.size);
  }

  return async function koaMongo(ctx, next) {
    return mongoPool.acquire()
      .then(async mongo => {
        ctx.mongo = mongo;
        debug('Acquire one connection (min: %s, max: %s, poolSize: %s)', options.min, options.max, mongoPool.size);
        return next();
      })

makePool() {
		log.debug("make a pool")
		this.pool = genericPool.createPool(isoFactory, this.options)
	}

this.config = {
      dbType: process.env.CUBEJS_DB_TYPE,
      url: process.env.CUBEJS_JDBC_URL || dbTypeDescription && dbTypeDescription.jdbcUrl(),
      drivername: process.env.CUBEJS_JDBC_DRIVER || dbTypeDescription && dbTypeDescription.driverClass,
      properties: dbTypeDescription && dbTypeDescription.properties,
      ...config
    };

    if (!this.config.drivername) {
      throw new Error('drivername is required property');
    }
    if (!this.config.url) {
      throw new Error('url is required property');
    }

    this.pool = genericPool.createPool({
      create: async () => {
        await initMvn(config.customClassPath);
        if (!this.jdbcProps) {
          this.jdbcProps = this.getJdbcProperties();
        }
        const getConnection = promisify(DriverManager.getConnection.bind(DriverManager));
        return new Connection(await getConnection(this.config.url, this.jdbcProps));
      },
      destroy: async (connection) => {
        return promisify(connection.close.bind(connection));
      },
      validate: (connection) => {
        const isValid = promisify(connection.isValid.bind(connection));
        try {
          return isValid(this.testConnectionTimeout() / 1000);
        } catch (e) {

function drain(next) {
      debug('Draining %s channel pool. %o', mode, stats());
      pool.drain().then(function() {
        return pool.clear().then(function() {
          debug('Drained %s channel pool. %o', mode, stats());
          setImmediate(next);
        });
      }).catch(function(err) {
        debug('Error draining %s channel pool. %s', mode, err.message);
        setImmediate(next);
      });
    }

    debug('Creating %s channel pool %o', mode, options.pool);
    pool = genericPool.createPool(factory, options.pool);

    poolQueue = async.queue(function(__, next) {
      pool.acquire().then(function(channel) {
        setImmediate(function() {
          next(null, channel);
        });
      }).catch(next);
    }, 1);

    return {
      stats: stats,
      borrow: borrow,
      return: release,
      drain: drain,
      pause: poolQueue.pause.bind(poolQueue),
      resume: poolQueue.resume.bind(poolQueue),

module.exports = function createForkPool( childPath ) {
	const forkPoolFactory = {
		create() {
			return new Promise( resolve => {
				resolve( childProcess.fork( childPath ) );
			} );
		},

		destroy( child ) {
			child.kill();
		}
	};

	const pool = genericPool.createPool( forkPoolFactory, {
		max: 4,
		min: 2
	} );

	return {
		get isDone() {
			return !pool.pending && !pool.borrowed;
		},

		enqueue( data ) {
			return new Promise( ( resolve, reject ) => {
				pool.acquire()
					.then( child => {
						child.once( 'message', returnedData => {
							pool.release( child );