How to use simple-oauth2 - 10 common examples

app.get('/oauth2/refresh', function(req, res) {
  oauth2
    .create(req.session.credentials)
    .accessToken.create(req.session.oauth2_flow.token)
    .refresh()
    .then(token => {
      req.session.oauth2_flow = token; // refresh returns {token:{access_token}} because why not...
      res.send({ result: 'success', token: token.token });
    })
    .catch(err => {
      res.send(JSON.stringify({ error: err.toString() }));
    });
});

credential: admin.credential.cert(serviceAccount),
  databaseURL: `https://${serviceAccount.project_id}.firebaseio.com`
});

// Instagram OAuth 2 setup
const credentials = {
  client: {
    id: config.instagram.clientId,
    secret: config.instagram.clientSecret
  },
  auth: {
    tokenHost: 'https://api.instagram.com',
    tokenPath: '/oauth/access_token'
  }
};
const oauth2 = require('simple-oauth2').create(credentials);

// Path to the OAuth handlers.
const OAUTH_REDIRECT_PATH = '/redirect';
const OAUTH_CALLBACK_PATH = '/instagram-callback';
const OAUTH_MOBILE_REDIRECT_PATH = '/instagram-mobile-redirect';
const OAUTH_MOBILE_CALLBACK_PATH = '/instagram-mobile-callback';
const OAUTH_CODE_EXCHANGE_PATH = '/instagram-mobile-exchange-code';

// Custom URI scheme for Android and iOS apps.
const APP_CUSTOM_SCHEME = 'instagram-sign-in-demo';

// Instagram scopes requested.
const OAUTH_SCOPES = 'basic';

// ExpressJS setup
const app = express();

app.get('/launch', async (req, res) => {
  const { iss, scope } = req.query;
  const fhirClient = new Client({ baseUrl: iss });
  const { authorizeUrl, tokenUrl } = await fhirClient.smartAuthMetadata();

  req.session.iss = iss;

  // Create a new oAuth2 object using the Client capability statement:
  const oauth2 = simpleOauthModule.create({
    client: {
      id: CLIENT_ID,
      secret: CLIENT_SECRET,
    },
    auth: {
      tokenHost: `${tokenUrl.protocol}//${tokenUrl.host}`,
      tokenPath: tokenUrl.pathname,
      authorizeHost: `${authorizeUrl.protocol}//${authorizeUrl.host}`,
      authorizePath: authorizeUrl.pathname,
    },
    options: {
      authorizationMethod: 'body',
    },
  });

  // Authorization uri definition

// Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE.txt in the project root for license information.
var credentials = {
  client: {
    id: 'YOUR APP ID HERE',
    secret: 'YOUR APP PASSWORD HERE',
  },
  auth: {
    tokenHost: 'https://login.microsoftonline.com',
    authorizePath: 'common/oauth2/v2.0/authorize',
    tokenPath: 'common/oauth2/v2.0/token'
  }
};
var oauth2 = require('simple-oauth2').create(credentials);

var redirectUri = 'http://localhost:8000/authorize';

// The scopes the app requires
var scopes = [ 'openid',
               'offline_access',
               'User.Read',
               'Mail.Read',
               'Calendars.Read',
               'Contacts.Read' ];

function getAuthUrl() {
  var returnVal = oauth2.authorizationCode.authorizeURL({
    redirect_uri: redirectUri,
    scope: scopes.join(' ')
  });

this.redirectUri = options.redirectUri;

    this.api = new APICall(
      options.baseURL,
      options.httpsAgent,
      options.httpAgent
    );

    if (typeof options.permanentToken === "string") {
      this.api.permanentToken = options.permanentToken;
      return;
    }

    const oauthBaseUrl = url.resolve(options.baseURL, "/v6/authentication/");

    this.oauth2 = simpleOAuth2.create({
      client: {
        id: options.clientId,
        secret: options.clientSecret
      },
      auth: {
        tokenHost: oauthBaseUrl,
        tokenPath: "oauth2/token",
        revokePath: "oauth2/revoke",
        authorizeHost: oauthBaseUrl,
        authorizePath: "oauth2/auth"
      }
    });

    if (options.token) {
      if (typeof options.token.access_token !== "string") {
        throw new Error(

const credentials = {
    client: {
      id: isDev
        ? functions.config().twitch.client_id_dev
        : functions.config().twitch.client_id,
      secret: isDev
        ? functions.config().twitch.client_secret_dev
        : functions.config().twitch.client_secret
    },
    auth: {
      tokenHost: 'https://api.twitch.tv',
      tokenPath: '/kraken/oauth2/token',
      authorizePath: '/kraken/oauth2/authorize'
    }
  };
  return require('simple-oauth2').create(credentials);
}

import * as cookieParser from 'cookie-parser';
import {randomBytes} from 'crypto';
import * as express from 'express';
import * as admin from 'firebase-admin';
import * as functions from 'firebase-functions';
import {create} from 'simple-oauth2';
import {ENV_CONFIG} from '../consts/env-config.const';
import {HttpStatus} from '../enums/http-status.enum';

const oauth2 = create({
  client: {
    id: ENV_CONFIG.instagram.clientid,
    secret: ENV_CONFIG.instagram.clientsecret
  },
  auth: {
    tokenHost: 'https://api.instagram.com',
    tokenPath: '/oauth/access_token'
  }
});

const app = express();
app.enable('trust proxy');
app.use(cookieParser());

app.get('/redirect', (req, res) => {
  const state = req.cookies.state || randomBytes(20).toString('hex');

buildOAuthClientForProvider(provider) {
        return simpleOauthModule.create({
            client: provider.client,
            auth: provider.auth,
            options: {
                authorizationMethod: "body"
            }
        });
    }

async function install_openshift_auth() {
    var server = 'https://' + kubernetes_service_host + ':' + kubernetes_service_port;

    var client_id = service_account_name(oauth_service_account);
    var client_secret = service_account_token();

    var metadata = await get_oauth_metadata(server);

    logger.info('OAuth server metadata', {metadata:metadata});

    var credentials = setup_oauth_credentials(metadata, client_id,
        client_secret);

    logger.info('OAuth server credentials', {credentials:credentials});

    var oauth2 = require('simple-oauth2').create(credentials);

    var same_origin = false;

    register_oauth_callback(oauth2, function(access_token) {
        return verify_openshift_user(server, access_token); }, same_origin);
    register_oauth_handshake(oauth2, same_origin);
}

function refreshToken(rawToken) {
    const oauth2Client = oauth2.create(getCredentials());
    const token = oauth2Client.accessToken.create(rawToken);
    return token.refresh();
}