Node.js：Braintree方法为何用错误响应解析Promise？

Great question—let’s break down exactly why this happens and how Braintree’s SDK handles error responses when using Promises:

1. Braintree’s Promise Design Follows Standard Failure Patterns #

When you skip the callback and use Promises with Braintree’s Node.js SDK, the team intentionally designed it to align with typical Promise behavior:

• If the API call achieves its goal (like creating a new customer successfully), the Promise resolves with the full response object (where response.success is true).
• If the API returns a business-level failure (like trying to create a customer with a duplicate ID), the SDK treats this as a Promise rejection instead of resolving the Promise with a success: false response.

This isn’t a bug—it’s a choice to make Promise-based code cleaner. Instead of having to check response.success in every then() block, you can handle all failures (both network/SDK errors and business validation errors) in a single catch().

2. Let’s Walk Through Your Scenario #

First Execution (Success) #

Your initial call works as expected:

gateway.customer.create({ 
  firstName: "First", 
  lastName: "Last", 
  email: "test@abc.com", 
  id: "123123" 
})
.then((response) => {
  console.log(response); // Promise resolves here—response.success is true
})
.catch((err) => {
  console.error(err); // Never triggered for this successful call
});

Second Execution (Duplicate ID) #

When you run the same code again, Braintree’s API returns a success: false response (since the customer ID already exists). The SDK converts this into a Promise rejection, so your code jumps straight to the catch() block:

gateway.customer.create({ 
  firstName: "First", 
  lastName: "Last", 
  email: "test@abc.com", 
  id: "123123" 
})
.then((response) => {
  console.log(response); // This code won’t run at all
})
.catch((err) => {
  console.error(err); // Here you’ll see the duplicate ID error details
});

3. What’s in the Rejected Error? #

The error object in your catch() block will include all the details from Braintree’s API response, such as:

• A human-readable message (e.g., "Customer ID already exists")
• A specific Braintree error code (like 91608 for duplicate customer IDs)
• Additional details about the failure context

Logging the full error object will show you all these specifics, which is helpful for debugging or displaying user-friendly messages.

4. How This Differs From Callback Mode #

Just to provide context, if you were using the callback pattern instead of Promises, you’d get the response object regardless of success or failure, and you’d have to manually check response.success:

gateway.customer.create({ /* customer data */ }, (err, response) => {
  if (err) {
    // Handle SDK/network-level errors
    console.error(err);
    return;
  }

  if (!response.success) {
    // Handle business errors like duplicate IDs
    console.error(response.message);
  } else {
    // Handle successful customer creation
    console.log(response.customer);
  }
});

The Promise-based approach simplifies this workflow by collapsing both error types into the catch() block, which fits how most developers expect Promises to behave.

内容的提问来源于stack exchange，提问作者wdetac