Only return a promise if send is called without a callback.

Additionally, revert all of the other internal promise conversions.

Author: Dan Perron

lib/sender.js

@@ -21,38 +21,33 @@ function Sender(key, options) {
 }
 
 Sender.prototype.send = function(message, recipient, options, callback) {
+    var rVal;
     if(typeof options == "function") {
         callback = options;
         options = null;
     }
-    options = cleanOptions(options);
-
-    return getRequestBody(message, recipient)
-        .then(function(body) {
-            if(options.retries == 0) {
-                return sendMessage(this.requestOptions, body);
-            }
-            return sendMessageWithRetries(this.requestOptions, body, options);
-        }.bind(this))
-        .then(function(output) {
-            // output is in the form of [response, tokens].
-            if (callback) {
-                // Need to prepend output with a null for the 'err' argument.
-                var cbArgs = Array.from(output);
-                cbArgs.unshift(null);
-                process.nextTick(function() {
-                    callback.apply(this, cbArgs);
-                }.bind(this));
-            }
-            // Just return the response.
-            return output[0];
-        }, function(err) {
-            if (callback) {
-                process.nextTick(callback, err);
-            } else {
-                return Promise.reject(err);
+    else if(!callback) {
+        rVal = new Promise(function(resolve, reject) {
+            callback = function(err, response) {
+                if (err) {
+                    return reject(err);
+                }
+                return resolve(response);
             }
         });
+    }
+    options = cleanOptions(options);
+
+    getRequestBody(message, recipient, function(err, body) {
+        if(err) {
+            return callback(err);
+        }
+        if(options.retries == 0) {
+            return sendMessage(this.requestOptions, body, callback);
+        }
+        sendMessageWithRetries(this.requestOptions, body, options, callback);
+    }.bind(this));
+    return rVal;
 };
 
 function cleanOptions(options) {
@@ -80,23 +75,21 @@ function cleanOptions(options) {
     return options;
 }
 
-function getRequestBody(message, recipient) {
+function getRequestBody(message, recipient, callback) {
     var body = cleanParams(message);
 
     if(typeof recipient == "string") {
         body.to = recipient;
-        return Promise.resolve(body);
+        return nextTick(callback, null, body);
     }
     if(Array.isArray(recipient)) {
         if(recipient.length < 1) {
-            return Promise.reject(new Error('Empty recipient array passed!'));
+            return nextTick(callback, new Error('Empty recipient array passed!'));
         }
         body.registration_ids = recipient;
-        return Promise.resolve(body);
+        return nextTick(callback, null, body);
     }
-    return Promise.reject(
-        new Error('Invalid recipient (' + recipient + ', type ' + typeof recipient +
-                  ') provided (must be array or string)!'));
+    return nextTick(callback, new Error('Invalid recipient (' + recipient + ', type ' + typeof recipient + ') provided (must be array or string)!'));
 }
 
 function cleanParams(raw) {
@@ -114,51 +107,57 @@ function cleanParams(raw) {
     return params;
 }
 
-function sendMessageWithRetries(requestOptions, body, messageOptions) {
-    return sendMessage(requestOptions, body)
-        .then(function(output) {
-            var response = output[0];
-            var attemptedRegTokens = output[1];
-            var badTokenInfo = checkForBadTokens(response.results, attemptedRegTokens);
-            if (badTokenInfo.unsentRegTokens.length == 0) {
-                return [response];
-            }
+function nextTick(func) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    process.nextTick(function() {
+        func.apply(this, args);
+    }.bind(this));
+}
 
-            debug("Retrying " + badTokenInfo.unsentRegTokens.length + " unsent registration tokens");
-
-            body.registration_ids = badTokenInfo.unsentRegTokens;
-            return retry(requestOptions, body, messageOptions)
-                .then(function(output) {
-                    var retriedResponse = output[0];
-                    response = updateResponse(response, retriedResponse, badTokenInfo.regTokenPositionMap, badTokenInfo.unsentRegTokens);
-                    return [response];
-                }, function() {
-                    return [response];
-                });
-        }, function(err) {
+function sendMessageWithRetries(requestOptions, body, messageOptions, callback) {
+    sendMessage(requestOptions, body, function(err, response, attemptedRegTokens) {
+        if (err) {
             if (typeof err === 'number' && err > 399 && err < 500) {
                 debug("Error 4xx -- no use retrying. Something is wrong with the request (probably authentication?)");
-                return Promise.reject(err);
+                return callback(err);
+            }
+            return retry(requestOptions, body, messageOptions, callback);
+        }
+        checkForBadTokens(response.results, attemptedRegTokens, function(err, unsentRegTokens, regTokenPositionMap) {
+            if(err) {
+                return callback(err);
+            }
+            if (unsentRegTokens.length == 0) {
+                return callback(null, response);
             }
-            return retry(requestOptions, body, messageOptions);
+
+            debug("Retrying " + unsentRegTokens.length + " unsent registration tokens");
+
+            body.registration_ids = unsentRegTokens;
+            retry(requestOptions, body, messageOptions, function(err, retriedResponse) {
+                if(err) {
+                    return callback(null, response);
+                }
+                response = updateResponse(response, retriedResponse, regTokenPositionMap, unsentRegTokens);
+                callback(null, response);
+            });
         });
+    });
 }
 
-function retry(requestOptions, body, messageOptions) {
-    return new Promise(function(resolve) {
-        setTimeout(resolve, messageOptions.backoff);
-    }).then(function() {
+function retry(requestOptions, body, messageOptions, callback) {
+    setTimeout(function() {
         if(messageOptions.retries <= 1) {
-            return sendMessage(requestOptions, body);
+            return sendMessage(requestOptions, body, callback);
         }
-        return sendMessageWithRetries(requestOptions, body, {
+        sendMessageWithRetries(requestOptions, body, {
             retries: messageOptions.retries - 1,
             backoff: messageOptions.backoff * 2
-        });
-    });
+        }, callback);
+    }, messageOptions.backoff);
 }
 
-function checkForBadTokens(results, originalRecipients) {
+function checkForBadTokens(results, originalRecipients, callback) {
     var unsentRegTokens = [];
     var regTokenPositionMap = [];
     for (var i = 0; i < results.length; i++) {
@@ -167,7 +166,7 @@ function checkForBadTokens(results, originalRecipients) {
             unsentRegTokens.push(originalRecipients[i]);
         }
     }
-    return {unsentRegTokens: unsentRegTokens, regTokenPositionMap: regTokenPositionMap};
+    nextTick(callback, null, unsentRegTokens, regTokenPositionMap);
 }
 
 function updateResponse(response, retriedResponse, regTokenPositionMap, unsentRegTokens) {
@@ -188,27 +187,25 @@ function updateResponseMetaData(response, retriedResponse, unsentRegTokens) {
     response.failure -= unsentRegTokens.length - retriedResponse.failure;
 }
 
-function sendMessage(requestOptions, body) {
+function sendMessage(requestOptions, body, callback) {
     requestOptions.json = body;
-    return new Promise(function (resolve, reject) {
-        request(requestOptions, function (err, res, resBodyJSON) {
-            if (err) {
-                return reject(err);
-            }
-            if (res.statusCode >= 500) {
-                debug('GCM service is unavailable (500)');
-                return reject(res.statusCode);
-            }
-            if (res.statusCode === 401) {
-                debug('Unauthorized (401). Check that your API token is correct.');
-                return reject(res.statusCode);
-            }
-            if (res.statusCode !== 200) {
-                debug('Invalid request (' + res.statusCode + '): ' + resBodyJSON);
-                return reject(res.statusCode);
-            }
-            resolve([resBodyJSON, body.registration_ids || [ body.to ]]);
-        });
+    request(requestOptions, function (err, res, resBodyJSON) {
+        if (err) {
+            return callback(err);
+        }
+        if (res.statusCode >= 500) {
+            debug('GCM service is unavailable (500)');
+            return callback(res.statusCode);
+        }
+        if (res.statusCode === 401) {
+            debug('Unauthorized (401). Check that your API token is correct.');
+            return callback(res.statusCode);
+        }
+        if (res.statusCode !== 200) {
+            debug('Invalid request (' + res.statusCode + '): ' + resBodyJSON);
+            return callback(res.statusCode);
+        }
+        callback(null, resBodyJSON, body.registration_ids || [ body.to ]);
     });
 }