Дмитрий Беляев

Как я понимаю, этот .catch должен перехватить реджект главного
промиса, но эта часть в принципе не выполняется и выходит
ошибка UnhandledPromiseRejection

Не должен, он с ним никак не связан.

Код на then ждет промис из wait, а код на await нет
await wait(2);

const addingOptions = arr => Promise.all(arr.map(
    item => Promise.all([
        fetchOptions(item.id),
        item.children.length ? addingOptions(item.children) : []
    ]).then(([options, children]) => ({
        ...item,
        options,
        children
    }))
));

Что-бы понять асинхронность полностью придется постепенно опустится на самый низкий уровень, вплоть до железа. Но начать стоит с самого верха - с уровня нашего приложения.

Итак, мы пишем на нашем высокоуровневом любимом языке, неважно JS/Rust/C#/Scala/Python или любой другой. В современном мире у нас скорее всего есть какая либо абстракция для работы с асинхронными апи, предоставляемая или стандартной библиотекой языка или сторонними библиотеками. Она может быть примитивной и основанной на колбэках или более продвинутой, вроде Future/Promise/Task или чем-то подобным. Иногда наш язык предоставляет синтаксис наподобие async/await для более простой работы с этими абстракциями, а иногда асинхронная работа может вообще быть скрыта от нас в рантайме языка, например как с горутинами в Go. Но в любом случае где-то под капотом у нас будет event-loop, а иногда и не один, так как никто не запрещает нам писать многопоточку в то же время используя асинхронные вызовы.

Сам event-loop - это не более чем обычный while(true) или любой другой бесконечный цикл. И внутри этого цикла наша программа имеет доступ на извлечение к некоторой очереди (если не знаете, что это за структура данных, то погуглите), которая содержит в себе результаты уже обработанных задач. Программа берет очередной результат, находит ожидающий ее колбэк/Promise/Future/Task и запускает выполнение ожидающего кода. Очередей опять же может быть несколько и обрабатываться они могут по разному, но это не важно. Важно то, что наш основной поток (или потоки) ничего не знают, о том как выполняются асинхронные задачи. Он лишь смотрит, есть ли в очереди результат, и если есть - обрабатывает его, а если нет, то принимает решение или выйти из цикла (и завершить поток, а иногда и весь процесс) или уснуть пока новых результатов не появится.

Но откуда же в очереди берутся результаты? Надо понимать, что асинхронная программа почти всегда многопоточная и результат операций попадает в очередь из фоновых потоков, которые просто блокируются в ожидании нужного ресурса (или сразу многих ресурсов, если используют системные апи вроде epoll или kqueue). Как правило такие фоновые потоки большую часть времени находятся в состоянии ожидания, а значит не потребляют ресурсы CPU и не попадают в планировщик ОС. Такая простая модель действительно позволяет сильно экономить ресурсы по сравнению с моделью, где множество потоков выполняют по 1 задаче и самостоятельно ожидают свои запросы.

Важно отметить, что в современном мире даже на среднеуровневых языках, вроде C или C++, не говоря уже о высокоуровневых, не реализуют асинхронность сами. Во-первых, на разных ОС для этого используются разные апи. Во-вторых, эти апи на разных ОС умеют обрабатывать разные типы ресурсов (с сетью вроде как умеют работать все основные ОС, но помимо сети асинхронно можно работать с пользовательским вводом, диском и периферийными устройствами, вроде сканеров, вебкамер и прочего цепляемого в usb). Наибольшую популярность (ИМХО) имеет кроссплатформенная библиотека libuv, хотя в Rust принято использовать mio (или даже абстракции над ней, вроде tokio), в C# подобные механизмы есть в .NET Core, а в Go оно уже зашито

Ок. С прикладным кодом вроде разобрались. А что же происходит в ядре ОС? Ведь, как писалось выше, у нас даже есть апи, чтоб ждать запросы пачкой. Все просто. Ядра ОС стали асинхронными еще до того, как это стало мейнстримом, если мы конечно имеем дело не с ОС реального времени (но у нас же винда/линь/мак/фряха, а не ОС для бортового компа боинга, где это критично). Смотрите, когда что-то происходит на внешней периферии (ну например диск запрошенные данные прочитал или по сети данные пришли, или юзер мышкой дернул), то формируется прерывание. CPU реально прерывает свою текущую работу и бежит смотреть что случилось, точнее вызывает обработчик предоставленный ОС. Но у ОС то есть основная работа, поэтому она скорее старается освободить обработчик и просто скидывает все данные в оперативку, а разбираться будет потом, когда очередь дойдет. Ничего не напоминает? Очень похоже, на то что происходило в event-loop, только вместо фоновых потоков "результаты" попадают в очередь из прерываний. А уже когда-то потом ОС отдаст данные в драйвер устройства, ну и т.д., пока они не дойдут до нашего прикладного приложения. Вот и все, никакой магии.

function recursiveRequest(requestData) {
  return fetch(
    //здесь формируем запрос из requestData
  ).then(response => response.json()).then(result => {
    if(result.isFinal) return result; // тут условие
    return recursiveRequest(result.nextRequest); //вызываем следующий запрос
  });
}

recursiveRequest({}).then(finalResult => {
  //работаем с последним результатом
});

new Promise((resolve, reject) => {
  fs.readFile("config.json", (err, data) => {
    if(err) {
      return reject(err);
    }
    resolve(JSON.Parse(data));
  });
}).then(obj => {
  console.log(obj);
  // your code
}).catch(console.error);

node v7.6+ или транспайлим бабелем async2generators

function requestAsync(params) {
  return new Promise((resolve, reject) => {
    request(params, (err, response, body) => {
      if(err) { return reject(err); }
      resolve({response, body});
    });
  });
}

async function getURL(_url) {
  var data, url = _url;
  do {
    const {body} = await requestAsync({url});
    data = JSON.parse(body);
    url = _url + '&pageToken=' + data.nextPageToken;
  } while(data.nextPageToken !== undefined);
  return data;
}

Если в основе фреймворка под генераторами лежат промисы, то есть идет имитация async/await, то должно помочь так:

* tasks() {
    let tasks = yield Task.findBy('status', 1)

    let promises = []
    for(let task of tasks) {
      promises.push(this.task(task))
    }
    yield Promise.all(promises)
  }

Вынесите someObject в замыкание и внутреннюю цепочку промисов перенесите во внешнюю

someObject = null //не знаю можно ли писать в cs var поэтому так
Promise.resolve()
.then(@getObjectDescription.bind(@))
.then(
  (so) ->
    someObject = so
)
.then(@getSomeSpecialFieldValue.bind(@))
.then(
        (value) ->
          someObject.special_field = value
          return someObject
)
.then(
  (someObject) ->
    data = new FormData()

    data.append('field', someObject.field)
    data.append('special_field', someObject.special_field)

    options =
      method: 'post'
      body: data

    return options
)
.then(@execute.bind(@, 'rest.api.method'))