buffer-calls.js

'use strict';

const util = require('util');
const setTimeoutPromise = util.promisify(setTimeout);

const X = 5000; // ms

function createCallBuffer(functionToCallForEachBuffer) {
	const callBuffer = [];
	let timeout;

	function callAllBuffers() {
		callBuffer.forEach(args => {
			functionToCallForEachBuffer.apply(null, args);
		});
	}

	return function bufferCalls(...args) {
		console.log(`buffering ${JSON.stringify(args)}`);
		callBuffer.push(args);
		if (timeout) {
			clearTimeout(timeout);
		}
		timeout = setTimeout(() => {
			callAllBuffers();
		}, X);
	};
}

function createPromiseCallBuffer(functionReturningPromise) {
	const callbackified = util.callbackify(functionReturningPromise);

	const callBatched = createCallBuffer(callbackified);

	return function bufferPromises(...args) {
		return new Promise((resolve, reject) => {
			callBatched(args, (err, result) => {
				if (err) {
					reject(err);
				}
				return resolve(result);
			});
		});
	};
}

(async function() {
	const callBatched = createCallBuffer(console.log);

	callBatched('a');
	await setTimeoutPromise(1000);
	callBatched('b');
	await setTimeoutPromise(1000);
	callBatched('c');
	await setTimeoutPromise(1000);
	callBatched('d');
	await setTimeoutPromise(1000);

	function iReturnAPromise(arg) {
		return new Promise(resolve => {
			console.log('invoking promise for ' + arg);
			setTimeoutPromise(500);
			resolve('result for ' + arg);
		});
	}

	const callBatchedReturnPromise = createPromiseCallBuffer(iReturnAPromise);

	const prom1 = callBatchedReturnPromise('promise 1 arg');
	await setTimeoutPromise(1000);
	const prom2 = callBatchedReturnPromise('promise 2 arg');
	await setTimeoutPromise(1000);
	const prom3 = callBatchedReturnPromise('promise 3 arg');
	await setTimeoutPromise(1000);
	const prom4 = callBatchedReturnPromise('promise 4 arg');

	const [ret1, ret2, ret3, ret4] = await Promise.all([prom1, prom2, prom3, prom4]);

	console.log(ret1);
	console.log(ret2);
	console.log(ret3);
	console.log(ret4);
})();