Meu código:

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

E quando tento executar algo assim:

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

Estou entendendo:

Promise { <pending> }

Mas por que?

Meu principal objetivo é obter um token do google.login(data.username, data.password)qual retorna uma promessa, em uma variável. E só então realizar algumas ações.

A promessa sempre será registrada pendente, desde que seus resultados ainda não sejam resolvidos. Você deve invocar .thena promessa para capturar os resultados, independentemente do estado da promessa (resolvida ou ainda pendente):

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"
})

Por que é que?

As promessas são direcionadas apenas para a frente; Você só pode resolvê-los uma vez. O valor resolvido de a Promiseé passado para seus métodos .thenou .catch.

Detalhes

De acordo com a especificação Promises / A +:

O procedimento de resolução de promessa é uma operação abstrata tomando como entrada uma promessa e um valor, que denotamos como [[Resolver]] (promessa, x). Se x for um então, ele tenta fazer a promessa adotar o estado de x, sob a suposição de que x se comporta pelo menos um pouco como uma promessa. Caso contrário, cumpre a promessa com o valor x.

Esse tratamento dos objetos permite que implementações promissoras interoperem, contanto que exponham um método then compatível com Promises / A +. Também permite que as implementações do Promises / A + “assimilem” implementações não conformes com métodos then razoáveis.

Esta especificação é um pouco difícil de analisar, então vamos decompô-la. A regra é:

Se a função no .thenmanipulador retornar um valor, o será Promiseresolvido com esse valor. Se o manipulador retornar outro Promise, o original será Promiseresolvido com o valor resolvido do encadeado Promise. O próximo .thenmanipulador sempre conterá o valor resolvido da promessa encadeada retornada na anterior .then.

A maneira como realmente funciona é descrita abaixo com mais detalhes:

1. O retorno da .thenfunção será o valor resolvido da promessa.

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. Se a .thenfunção retornar a Promise, o valor resolvido dessa promessa encadeada será passado para o seguinte .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"
  });

Sei que essa pergunta foi feita há 2 anos, mas me deparei com o mesmo problema e a resposta para o problema é desde ES6, que você pode simplesmente awaitas funções retornar 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

O thenmétodo retorna uma promessa pendente que pode ser resolvida de forma assíncrona pelo valor de retorno de um manipulador de resultados registrado na chamada para then, ou rejeitado lançando um erro dentro do manipulador chamado.

Portanto, a chamada AuthUsernão logará repentinamente o usuário de forma síncrona, mas retornará uma promessa cujos manipuladores registrados serão chamados depois que o login for bem-sucedido (ou falhar). Eu sugeriria acionar todo o processamento de login por uma thencláusula da promessa de login. EG usando funções nomeadas para destacar a sequência de fluxo:

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 a seção MDN sobre Promessas. Em particular, observe o tipo de retorno de then ().

Para efetuar login, o agente do usuário deve enviar uma solicitação ao servidor e aguardar o recebimento de uma resposta. Já que fazer seu aplicativo parar totalmente a execução durante uma viagem de ida e volta de solicitação geralmente causa uma experiência ruim para o usuário, praticamente todas as funções JS que conectam você (ou realizam qualquer outra forma de interação do servidor) usarão uma promessa ou algo muito parecido , para entregar resultados de forma assíncrona.

Agora, observe também que as returninstruções são sempre avaliadas no contexto da função em que aparecem. Então, quando você escreveu:

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

a instrução return token;significava que a função anônima sendo passada then()deveria retornar o token, não que a AuthUserfunção deveria. O que AuthUserretorna é o resultado do chamado google.login(username, password).then(callback);, que passa a ser uma promessa.

Em última análise, seu retorno de chamada token => { return token; }não faz nada; em vez disso, sua entrada para then()precisa ser uma função que realmente lida com o token de alguma forma.

Sua promessa está pendente, conclua-a até

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

após o código restante. Tudo o que esse código faz é .then()completar sua promessa e capturar o resultado final na variável de resultado e imprimir o resultado no console. Lembre-se de que você não pode armazenar o resultado em uma variável global. Espero que essa explicação possa ajudá-lo.