Mi código:

let AuthUser = data => {
  return google.login(data.username, data.password).then(token => { return token } )
}

Y cuando intento ejecutar algo como esto:

let userToken = AuthUser(data)
console.log(userToken)

Me estoy poniendo:

Promise { <pending> }

¿Pero por qué?

Mi objetivo principal es obtener un token del google.login(data.username, data.password)que devuelve una promesa, en una variable. Y solo entonces realizar algunas acciones.

La promesa siempre se registrará como pendiente siempre que sus resultados aún no se hayan resuelto. Debe recurrir .thena la promesa para capturar los resultados independientemente del estado de la promesa (resuelto o aún pendiente):

let AuthUser = function(data) {
  return google.login(data.username, data.password).then(token => { return token } )
}

let userToken = AuthUser(data)
console.log(userToken) // Promise { <pending> }

userToken.then(function(result) {
   console.log(result) // "Some User token"
})

¿Porqué es eso?

Las promesas son solo una dirección hacia adelante; Solo puede resolverlos una vez. El valor resuelto de a Promisese pasa a sus métodos .theno .catch.

Detalles

De acuerdo con la especificación Promises / A +:

El procedimiento de resolución de promesas es una operación abstracta que toma como entrada una promesa y un valor, que denotamos como [[Resolver]] (promesa, x). Si x es un thenable, intenta hacer que la promesa adopte el estado de x, bajo el supuesto de que x se comporta al menos de alguna manera como una promesa. De lo contrario, cumple la promesa con el valor x.

Este tratamiento de las posibilidades permite que las implementaciones de las promesas interoperen, siempre que expongan un método que cumpla con las promesas / A +. También permite que las implementaciones de Promises / A + "asimilen" las implementaciones no conformes con métodos razonables.

Esta especificación es un poco difícil de analizar, así que analicémosla. La regla es:

Si la función en el .thencontrolador devuelve un valor, entonces se Promiseresuelve con ese valor. Si el manejador devuelve otro Promise, entonces el original se Promiseresuelve con el valor resuelto del encadenado Promise. El siguiente .thencontrolador siempre contendrá el valor resuelto de la promesa encadenada devuelta en el anterior .then.

La forma en que realmente funciona se describe a continuación con más detalle:

1. La devolución de la .thenfunción será el valor resuelto de la promesa.

function initPromise() {
  return new Promise(function(res, rej) {
    res("initResolve");
  })
}

initPromise()
  .then(function(result) {
    console.log(result); // "initResolve"
    return "normalReturn";
  })
  .then(function(result) {
    console.log(result); // "normalReturn"
  });

2. Si la .thenfunción devuelve un Promise, entonces el valor resuelto de esa promesa encadenada se pasa a lo siguiente .then.

function initPromise() {
  return new Promise(function(res, rej) {
    res("initResolve");
  })
}

initPromise()
  .then(function(result) {
    console.log(result); // "initResolve"
    return new Promise(function(resolve, reject) {
       setTimeout(function() {
          resolve("secondPromise");
       }, 1000)
    })
  })
  .then(function(result) {
    console.log(result); // "secondPromise"
  });

Sé que esta pregunta se hizo hace 2 años, pero me encontré con el mismo problema y la respuesta al problema es que desde ES6, simplemente puede que awaitlas funciones devuelvan valor, como:

let AuthUser = function(data) {
  return google.login(data.username, data.password).then(token => { return token } )
}

let userToken = await AuthUser(data)
console.log(userToken) // your data

El thenmétodo devuelve una promesa pendiente que puede resolverse de forma asincrónica mediante el valor de retorno de un controlador de resultados registrado en la llamada a then, o rechazada arrojando un error dentro del controlador llamado.

Por lo tanto, las llamadas AuthUserno registrarán repentinamente al usuario de forma síncrona, sino que devolverán una promesa cuyos controladores registrados en ese momento serán llamados después de que el inicio de sesión sea exitoso (o no). Sugeriría activar todo el procesamiento de inicio de sesión mediante una thencláusula de la promesa de inicio de sesión. EG usando funciones nombradas para resaltar la secuencia de flujo:

let AuthUser = data => {   // just the login promise
  return google.login(data.username, data.password);
};

AuthUser(data).then( processLogin).catch(loginFail);

function processLogin( token) {
      // do logged in stuff:
      // enable, initiate, or do things after login
}
function loginFail( err) {
      console.log("login failed: " + err);
}

Consulte la sección MDN sobre promesas. En particular, observe el tipo de devolución de then ().

Para iniciar sesión, el agente de usuario debe enviar una solicitud al servidor y esperar a recibir una respuesta. Dado que hacer que su aplicación detenga por completo la ejecución durante un viaje de ida y vuelta de solicitud generalmente genera una mala experiencia de usuario, prácticamente todas las funciones de JS que lo inician (o realizan cualquier otra forma de interacción con el servidor) usarán una Promesa, o algo muy parecido , para entregar resultados de forma asincrónica.

Ahora, observe también que las returndeclaraciones siempre se evalúan en el contexto de la función en la que aparecen. Entonces, cuando escribió:

let AuthUser = data => {
  return google
    .login(data.username, data.password)
    .then( token => {
      return token;
    });
};

la declaración return token;significaba que la función anónima a la que se pasa then()debería devolver el token, no que la AuthUserfunción debería. Lo que AuthUserregresa es el resultado de llamar google.login(username, password).then(callback);, que resulta ser una Promesa.

En última instancia, su devolución de llamada token => { return token; }no hace nada; en cambio, su entrada a then()debe ser una función que realmente maneje el token de alguna manera.

Tu promesa está pendiente, complétala antes de

userToken.then(function(result){
console.log(result)
})

después de su código restante. Todo lo que hace este código es que .then()completa su promesa y captura el resultado final en la variable de resultado y el resultado de impresión en la consola. Tenga en cuenta que no puede almacenar el resultado en una variable global. Espero que esa explicación te ayude.