É um antipadrão usar async / await dentro de um novo construtor Promise ()?

Estou usando a async.eachLimitfunção para controlar o número máximo de operações por vez.

const { eachLimit } = require("async");

function myFunction() {
 return new Promise(async (resolve, reject) => {
   eachLimit((await getAsyncArray), 500, (item, callback) => {
     // do other things that use native promises.
   }, (error) => {
     if (error) return reject(error);
     // resolve here passing the next value.
   });
 });
}

Como você pode ver, não posso declarar a myFunctionfunção como assíncrona porque não tenho acesso ao valor dentro do segundo retorno de chamada da eachLimitfunção.

Você está efetivamente usando promessas dentro da função do executor do construtor de promessa, então este é o antipadrão do construtor de Promise .

Seu código é um bom exemplo do principal risco: não propagar todos os erros com segurança. Leia porque lá .

Além disso, o uso de async/ awaitpode tornar as mesmas armadilhas ainda mais surpreendentes. Comparar:

let p = new Promise(resolve => {
  ""(); // TypeError
  resolve();
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e)); // Catches it.

com um asyncequivalente ingênuo (errado) :

let p = new Promise(async resolve => {
  ""(); // TypeError
  resolve();
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e)); // Doesn't catch it!

Procure o último no console da web do seu navegador.

O primeiro funciona porque qualquer exceção imediata em uma função executora do construtor Promise convenientemente rejeita a promessa recém-construída (mas dentro de qualquer .thenvocê está por conta própria).

O segundo não funciona porque qualquer exceção imediata em uma asyncfunção rejeita a promessa implícita retornada pela asyncprópria função .

Como o valor de retorno de uma função executora do construtor de promessa não é usado, isso é uma má notícia!

Seu código

Não há nenhuma razão que você não possa definir myFunctioncomo async:

async function myFunction() {
  let array = await getAsyncArray();
  return new Promise((resolve, reject) => {
    eachLimit(array, 500, (item, callback) => {
      // do other things that use native promises.
    }, error => {
      if (error) return reject(error);
      // resolve here passing the next value.
    });
  });
}

Porém, por que usar bibliotecas de controle de simultaneidade desatualizadas quando você tem await?

Eu concordo com as respostas dadas acima e ainda assim, às vezes é mais legal ter assíncrono dentro de sua promessa, especialmente se você quiser encadear várias operações retornando promessas e evitar o then().then()inferno. Eu consideraria usar algo assim nessa situação:

const operation1 = Promise.resolve(5)
const operation2 = Promise.resolve(15)
const publishResult = () => Promise.reject(`Can't publish`)

let p = new Promise((resolve, reject) => {
  (async () => {
    try {
      const op1 = await operation1;
      const op2 = await operation2;

      if (op2 == null) {
         throw new Error('Validation error');
      }

      const res = op1 + op2;
      const result = await publishResult(res);
      resolve(result)
    } catch (err) {
      reject(err)
    }
  })()
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e));

1. A função passada ao Promiseconstrutor não é assíncrona, portanto, os linters não mostram erros.
2. Todas as funções assíncronas podem ser chamadas em ordem sequencial usando await.
3. Erros personalizados podem ser adicionados para validar os resultados das operações assíncronas
4. O erro é detectado bem eventualmente.

Uma desvantagem, porém, é que você deve se lembrar de colocá try/catch-lo e prendê-lo reject.

static getPosts(){
    return new Promise( (resolve, reject) =>{
        try {
            const res =  axios.get(url);
            const data = res.data;
            resolve(
                data.map(post => ({
                    ...post,
                    createdAt: new Date(post.createdAt)
                }))
            )
        } catch (err) {
            reject(err);                
        }
    })
}

remove await e async resolverá esse problema. porque você aplicou o objeto Promise, isso é o suficiente.