Like Promise.all but executed in chunks, so you can have some async concurrency control.

asyncChunkedMap.js

const chunks = (arr, chunkSize) => {
  let results = [];
  while (arr.length) results.push(arr.splice(0, chunkSize));
  return results;
};

module.exports = (xs, f, concurrency) => {
  if (xs.length == 0) return Promise.resolve();
  return Promise.all(chunks(xs, concurrency).reduce(
    (acc, chunk) => acc.then(() => Promise.all(chunk.map(f))),
    Promise.resolve()
  ));
};

Hi guys! I know is an old thread but just run into it, amazing work! learning a lot about perf conditions you mention. My approach (saving the differences) were to stablish SNS publish and making use of bluebird library (maybe avoidable) with ramda.

const Promise = require('bluebird');
const PASSENGERS_SPLIT = 10;

async function notificationsSNSPublisher(snsPublish, payload) {
  const { passengers } = payload;
  const snsPayload = dissoc('passengers', payload);

  return await Promise.map(splitEvery(PASSENGERS_SPLIT, passengers), async passengersChunk => {
    const messagePayload = {
      ...snsPayload,
      passengers: passengersChunk
    };
    const { MessageId } = await snsPublish(messagePayload, { messageAttributes: {} });

    return MessageId;
  });
}

Is possible to add a delay() function of course. I’m going to gather parts of the code you posted and improve this

Here is my typescript version:

const throttledConcurrencyPromiseAll = async <T>(
  arr: Array<any>,
  f: (v: any) => Promise<T>,
  n = Infinity,
): Promise<T[]> => {
  const results = Array(arr.length);
  const entries = arr.entries();
  const worker = async () => {
    for (const [key, val] of entries) results[key] = await f(val);
  };
  await Promise.all(Array.from({ length: Math.min(arr.length, n) }, worker));
  return results;
};

Thank you for all comments, i used one of them:

export async function promiseBatch<T>(
    items: Promise<T>[],
    limit: number
): Promise<T[]> {
    let currentChunk = items.slice(0, limit);
    const left = items.slice(limit);
    const result: { value: T; index: number }[] = [];
    let index = 0;
    while (currentChunk.length > 0) {
        await Promise.race(
            currentChunk.map((p, i) => p.then((value) => {
                const newChunk = currentChunk.filter(pi => pi !== p);
                if (newChunk.length !== currentChunk.length) {
                    result.push({ index: i + index, value });
                    const f = left.shift();
                    index++;
                    currentChunk = [...newChunk, ...(f ? [ f ] : [])];
                }
            }))
        );
    }
    return result.sort((a, b) => a.index - b.index).map(v => v.value);
}