如何在Node.js中使用Promise或同步调用处理if语句

Question

I'm building a checkout flow using Stripe and running a series of functions for handling a payment event. In many cases the necessary customer information will be stored on my end (as customerToken ) and I'm able to just pass that information to the code that charges the customer and everything works well.

However, I'm not exactly sure how to deal with the event in which the user does not already have customerToken and one must be creating without repeating a bunch of code as stuff fires before I get something returned from the Stripe API.

I tried setting up a promise on the function that creates the customerToken but - assuming I'm not totally misunderstanding promises - that promise wouldn't be fulfilled if that information already existed and the code would never execute.

I've also seen there are node modules that force calls to wait (like this https://github.com/yortus/asyncawait ) but I'm new to Node and wondering if there is a more true-to-node way of handling things.

What I have now can be simplified to look like this:

// If the user doesn't already have Stripe issued customer information 
if (customerToken === null){

    function() {

        // Asynchronous call to Stripe to get the data that will be stored as customerToken
        Stripe.customers.create({
            source: stripeToken,
            email: customerEmail,
        }).then(function(customer){
            // store customerToken on my end
            request({
                url:'[anAPI]',
                method: 'POST',
                json: {customerToken: customer}
            });
        });
    }
}

function() {
    // Charge the client based on customerId
    Stripe.charges.create({
        amount: price
        currency: 'usd',
        customer: customerToken.id,
        description: description
    });
}

// a bunch of other code that similarly needs a customerToken to function

I have no idea if I'm asking for something that just can't exist or if I'm missing a basic concept and I haven't been able to find a clear answer searching up until now. Sorry if this is obvious!

Answer 1

You can use a structure that always returns a promise fulfilled with the customerToken like this:

function getToken() {
    if (customerToken) {
        return Promise.resolve(customerToken);
    } else {
        // Asynchronous call to Stripe to get the data that will be stored as customerToken
        return Stripe.customers.create({
            source: stripeToken,
            email: customerEmail,
        }).then(function(customer){
            // Note: this request() is sent asynchronously and
            // this promise does not wait for it's response
            // You could make it wait by returning a promise here
            // store customerToken on my end
            request({
                url:'[anAPI]',
                method: 'POST',
                json: {customerToken: customer}
            });
            return customer;
        });    
    }
}

getToken().then(function(token) {
    // use the token here
});

The idea is that this function always returns a promise that, when resolved, will have its resolved value be the customer token. In some cases, the promise is immediately resolved, in others it takes longer to resolve.

So, if the token is already available, you just return a resolved promise with that token as the promise value. If the token is not available, you return a promise that will be resolved with the token when it is available. Then, the caller can just use the promise without having to know which path was taken.