recursive function with a promise to iterative

I have a function emailIterator which reads messages from a stack and sends them one by one using an emailer

I'm currently handling it recursively by calling emailIterator back with the same messages but only with one less message each time since it already got sent.

import { emailer } from 'pigeon';
 
interface MessageObject {
  email: string;
  recipientName: string;
  message: string;
}
 
interface  {
  error: any;
  messageAtError: MessageObject;
}
 
const data: MessageObject[] = [

  {
    email: 'bob@domain.com',
    recipientName: 'Bob',
    message: 'Lorem ipsum dolor sit amet mattis.',
  },
  {
    email: 'jim@domain.com',
    recipientName: 'Jim',
    message: 'Lorem ipsum dolor sit amet mattis.',
  },
];
 
const emailIterator = (messages: MessageObject[], cb: any): void => {
  if (messages.length === 0) {
    return cb(undefined, 'All messages sent');
  } else {
    const toSend = messages.pop();
 
    emailer(toSend)
      .then(() => {
        return emailIterator(messages, cb);
      })
      .catch((e) => {
        return cb({
          error: e,
          messageAtError: toSend,
        });
      });
  }
};



 
emailIterator(data, (err?: ErrorFormat, msg?: string) => {
  if (err) {
    console.log('There was an error with a message:', err.messageAtError);
    console.error(err.error);
    return;
  }
  console.log(msg);
});

I need help to transform this into an iterative solution.

here's what I came up with so far, is this right? does it handle errors efficiently? can it be done in a better way ?

const emailIterator2 = (messages: MessageObject[], cb: any): void => {
	for(let i = messages.length - 1; i >= 0; i--) {

    let toSend = messages[i]; 
    try {
      const result = await emailer(toSend); 
    } catch (e: ErrorFormat) {
      return cb({
        error: e, 
        messageAtError: toSend
      })
    }
    if(i === 0) {
      return cb(undefined, 'All messages sent')
    }
  }
}

Use async..await inside a for..of loop -

const emailIterator = async (messages: MessageObject[], cb: any): void => {
  let toSend
  try {
    for (const m of messages) {
      toSend = m
      await emailer(m)
    }
    cb(undefined, "All messages sent")
  }
  catch (e) {
    cb({ error: e, messageAtError: toSend })
  }
}

Mixing callbacks with promises has bad ergonomics. How about making emailIterator a promise-based function?

const emailIterator = async (messages: MessageObject[]): Promise<string> => {
  let toSend
  try {
    for (const m of messages) {
      toSend = m
      await emailer(m)
    }
    return "All messages sent"
  }
  catch (e) {
    e.messageAtError = toSend
    throw e
  }
}

Notice the odd toSend assignment so it can be used in the catch block? Better yet is to have emailer throw the proper error -

async function emailer(message): Promise<void> {
  try {
    // ...
  }
  catch (e) {
    e.messageAtError(message)
    throw e
  }
}

emailIterator doesn't have to worry about it now. Behaviour is the same, no try..catch is needed and errors bubble up as expected. Oh and TypeScript can easily infer the Promise<string> return type too -

async function emailIterator(messages: MessageObject[]) {
  for (const m of messages)
    await emailer(m)
  return "All messages sent"
}