@pradyumn-el/pollycli/src/auth.js

pollycli lets users access the functionalities of Polly over a command line interface

const chalk = require("chalk");
const inquirer = require("inquirer");

global.fetch = require("node-fetch");
const AmazonCognitoIdentity = require('amazon-cognito-identity-js');
const axios = require('axios');
const pollyEnv = require('./env.json');
const pollymsg = require('./message');
const pollyHeaders = require("./pollyheaders");
const { pollyApi } = require("./api-client");


async function getPollyUser(email) {
  let requestPoolData = {}
  try {
    const config = {
      headers:{
        'accept': '*/*',
        'content-type': 'application/vnd.api+json'
      }
    }
    const response = await axios.get(`${pollyEnv.baseV2Api}/userpool`, config);
    requestPoolData = response.data.data.attributes;
  } catch(err) {
    pollymsg.pollyError('Not able to login to Polly. Please check the internet connectivity.')
  }
  // Setting the pool
  const poolData = {
    UserPoolId: requestPoolData.cognito_user_pool,
    ClientId: requestPoolData.cognito_client_id
  };

  const userPool = new AmazonCognitoIdentity.CognitoUserPool(poolData);

  // Setting the userDataCredentials
  const userData = {
    Username: email,
    Pool: userPool,
  };
  const cognitoUser = new AmazonCognitoIdentity.CognitoUser(userData);
  return cognitoUser;
}

export async function login(email, password, count = 0) {
  const cognitoUser = await getPollyUser(email);
  const authenticationData = {
    Username: email,
    Password: password,
  };
  const authenticationDetails = new AmazonCognitoIdentity.AuthenticationDetails(authenticationData);

  // Authenticating the user on auth server
  return new Promise( async (resolve, reject) => {

    if (pollyAuto) {
      const apiKey = process.env.POLLY_API_KEY;
      email = process.env.POLLY_USER;

      if (!(apiKey && email)) {
        pollymsg.pollyError("Not enough information's are there to auto login to Polly");
      }

      const meUrl = `/users/me`;
      try {
        pollyApi.defaults.headers.common["x-api-key"] = apiKey;
        await pollyApi.get(meUrl);
      } catch (error) {
        console.log(error)
        pollymsg.pollyError("Session have expired have to pass valid environment to login correctly")
      }

      pollystore.set('pollyUser', {pollyemail: email})
      pollystore.set({[email.toString()]: {
          "pollyApiKey": apiKey,
        }
      });
      pollymsg.pollySuccess(`Logged in to Polly as ${email}`)
      process.exit(0);
    }

    cognitoUser.authenticateUser(authenticationDetails, {
      onSuccess: async (result) => {
        pollystore.set('pollyUser', {pollyemail: result.idToken.payload.email})
        pollystore.set({[result.idToken.payload.email.toString()]: {
            pollyAccessToken: result.accessToken.jwtToken,
            pollyExp: result.accessToken.payload.exp.toString(10),
            pollySub: result.accessToken.payload.sub,
            pollyAud: result.accessToken.payload.aud,
            pollyrefreshToken: result.refreshToken.token
          }
        });
        pollyApi.get("/users/me");
        pollymsg.pollySuccess(`Logged in to Polly as ${result.idToken.payload.email}`)
        resolve(true);
      },
      onFailure: async (err) => {
        if (err.code == 'UserNotFoundException') {
          pollymsg.pollyError('Not able to login to Polly. User not found!')
        }

        if (err.code == 'NotAuthorizedException') {
          if (count < 2) {
            const questions = [{
              type: 'password',
              name: 'pollypassword',
              message: 'Enter Polly password:',
            }]
            const answers = await inquirer.prompt(questions);
            await login(email, answers.pollypassword, count + 1);
          } else {
            pollymsg.pollyError('Not able to login to Polly. Please check the credentials!')
            reject(false);
          }
        } else {
          pollymsg.pollyError('Not able to login to Polly. Please contact the customer support at polly@elucidata.io!')
          reject(false);
        }
      }
    });
  });
}

export async function isAlreadyLoggedIn(loginParam = false) {
  let email
  try {
    if (pollystore.get('pollyUser') && pollystore.get('pollyUser').pollyemail) {
      email = pollystore.get('pollyUser').pollyemail;
    }
    if (!email) {
      if (loginParam) {
        return false;
      } else {
        pollymsg.pollyMessage(chalk.white(`\nIt seems like you are not logged into Polly.\nLogin to Polly using: ${chalk.green.italic('polly login')}`))
        process.exit(0);
      }
    } 
  } catch (error) {
    if (loginParam) {
      return false;
    } else {
      pollymsg.pollyMessage(`\nIt seems like you are not logged into Polly.\nLogin to Polly using: ${chalk.italic('polly login')}`)
      process.exit(0);
    }
  }

  if(pollystore.get(`${email}`).pollyApiKey) {
    return true;
  }
  
  const exp = parseInt(pollystore.get(`${email}`).pollyExp);
  const refreshToken = pollystore.get(`${email}`).pollyrefreshToken;
  const now = new Date().getTime();
  const expTime = new Date(exp * 1000).getTime();
  if (now < expTime) {
    return true;
  } else {
    const prom =  new Promise(async (resolve, reject) => {
      pollymsg.pollyMessage("Refreshing session...")
      const token = new AmazonCognitoIdentity.CognitoRefreshToken({ RefreshToken: refreshToken })
      const cognitoUser = await getPollyUser(email);
      cognitoUser.refreshSession(token, async (err, result) => { 
        if (err) {
          pollymsg.pollyError('Not able to refresh session login to Polly')
          reject(false);
        }
        pollystore.set('pollyUser', {pollyemail: result.idToken.payload.email});
        pollystore.set({[result.idToken.payload.email.toString()]: {
            pollyAccessToken: result.accessToken.jwtToken,
            pollyExp: result.accessToken.payload.exp.toString(10),
            pollySub: result.accessToken.payload.sub,
            pollyAud: result.accessToken.payload.aud,
            pollyrefreshToken: result.refreshToken.token
          }
        });
        pollymsg.pollyMessage("Session refreshed!")
        resolve(true);
      }); 
    });
    return await prom;
  }
}

export async function logout() {
  try {
    let email;
    try {
      email = pollystore.get('pollyUser').pollyemail;
      if (!email) {
        return true;
      } 
    } catch (error) {
      return true;
    }
    pollystore.del(`${email}`);
    pollystore.del('pollyUser');
  } catch (error) {
    pollymsg.pollyError("Not able to logout");  
  }
  return true
}

export async function whoami() {
  let email;
  try {
    email = pollystore.get('pollyUser').pollyemail;
    if (!email) {
      pollymsg.pollyMessage(chalk.white(`\nIt seems like you are not logged into Polly.\nLogin to Polly using: ${chalk.green.italic('polly login')}`))
      process.exit(0);
    } 
  } catch (error) {
    pollymsg.pollyMessage(chalk.white(`\nIt seems like you are not logged into Polly.\nLogin to Polly using: ${chalk.green.italic('polly login')}`))
    process.exit(0);
  }
  pollymsg.pollyMessage(`Hello ${chalk.italic(email)}`);
  process.exit(0);
}