This retries, but the timeout only cancels the outer promise while the inner promise continues again and again.

promise-with-timeout.js

/**
 * Fake createOrder. It fails half of the time and had a random runtime between 0 and 1000 ms.
 */
async function createOrder() {
    return new Promise((resolve, reject) => {
        let action;
        let returns;

        if (Math.random() < 0.01) {
            console.log('action=resolve');
            action = resolve;
            returns = 'success';
        } else {
            console.log('action=reject');
            action = reject;
            returns = 'failure';
        }

        var runtime = Math.random() * 1000;
        runtime = 1000;
        console.log('createOrder runtime: ' + runtime.toFixed(0) + ' ms');
        setTimeout(action, runtime, returns);
    });
}

/**
 *
 * @callback createOrder~callback
 * @param {number} timeout
 */
async function retryOrCancel(promiseGenerator, timeout) {
    return new Promise(async (resolve, reject) => {
        const result = promiseGenerator();
        console.log('right after promiseGenerator');
        const timeoutObj = setTimeout(
            (reject, innerPromise) => {
                console.log('TIMEOUT REJECTION');
                console.log(innerPromise);
                reject('timeout');
            },
            timeout,
            reject,
            result
        );
        return result
            .then(_ => {
                console.log('CLEAR TIMEOUT');
                clearTimeout(timeoutObj);
                resolve(_);
            })
            .catch(err => {
                console.log('BEFORE call to AGAIN');
                again(promiseGenerator);
            });
    });
}

async function again(promiseGenerator) {
    return new Promise(async resolve => {
        return promiseGenerator()
            .then(res => {
                resolve(res);
            })
            .catch(err => {
                console.error('failed because of ' + err);
                console.error('retrying...');
                return again(promiseGenerator);
            });
    });
}

/**
 * Wrap retryOrCancel in a handler with a catch.
 * The createOrder is going to be executed with a 500 ms timeout.
 * The total time createOrder is going to take is between 0 and 1000 ms, so expect timeouts to occur.
 */
(async function() {
    const handler = async promise => {
        return await promise.catch(err => {
            console.log('catched because of: ' + err);
        });
    };
    // await handler(retryOrCancel(createOrder, 500));
    // await handler(retryOrCancel(createOrder, 500));
    await handler(retryOrCancel(createOrder, 5000));
})();