forked from coolaj86/walnut.js
739 lines
23 KiB
JavaScript
739 lines
23 KiB
JavaScript
(function (exports) {
|
|
'use strict';
|
|
|
|
var oauth3 = {};
|
|
var logins = {};
|
|
oauth3.requests = logins;
|
|
|
|
if ('undefined' !== typeof Promise) {
|
|
oauth3.PromiseA = Promise;
|
|
} else {
|
|
console.warn("[oauth3.js] Remember to call oauth3.providePromise(Promise) with a proper Promise implementation");
|
|
}
|
|
|
|
// TODO move to a test / lint suite?
|
|
oauth3._testPromise = function (PromiseA) {
|
|
var promise;
|
|
var x = 1;
|
|
|
|
// tests that this promise has all of the necessary api
|
|
promise = new PromiseA(function (resolve, reject) {
|
|
if (x === 1) {
|
|
throw new Error("bad promise, create not asynchronous");
|
|
}
|
|
|
|
PromiseA.resolve().then(function () {
|
|
var promise2;
|
|
|
|
if (x === 1 || x === 2) {
|
|
throw new Error("bad promise, resolve not asynchronous");
|
|
}
|
|
|
|
promise2 = PromiseA.reject().then(reject, function () {
|
|
if (x === 1 || x === 2 || x === 3) {
|
|
throw new Error("bad promise, reject not asynchronous");
|
|
}
|
|
|
|
if ('undefined' === typeof angular) {
|
|
throw new Error("[NOT AN ERROR] Dear angular users: ignore this error-handling test");
|
|
} else {
|
|
return PromiseA.reject(new Error("[NOT AN ERROR] ignore this error-handling test"));
|
|
}
|
|
});
|
|
|
|
x = 4;
|
|
|
|
return promise2;
|
|
}).catch(function (e) {
|
|
if (e.message.match('NOT AN ERROR')) {
|
|
resolve({ success: true });
|
|
} else {
|
|
reject(e);
|
|
}
|
|
});
|
|
|
|
x = 3;
|
|
});
|
|
|
|
x = 2;
|
|
return promise;
|
|
};
|
|
|
|
oauth3.providePromise = function (PromiseA) {
|
|
oauth3.PromiseA = PromiseA;
|
|
return oauth3._testPromise(PromiseA).then(function () {
|
|
oauth3.PromiseA = PromiseA;
|
|
});
|
|
};
|
|
|
|
oauth3.provideRequest = function (request, opts) {
|
|
opts = opts || {};
|
|
var Recase = exports.Recase || require('recase');
|
|
// TODO make insensitive to providing exceptions
|
|
var recase = Recase.create({ exceptions: {} });
|
|
|
|
if (opts.rawCase) {
|
|
oauth3.request = request;
|
|
return;
|
|
}
|
|
|
|
// Wrap oauth3 api calls in snake_case / camelCase conversion
|
|
oauth3.request = function (req, opts) {
|
|
//console.log('[D] [oauth3 req.url]', req.url);
|
|
opts = opts || {};
|
|
|
|
if (opts.rawCase) {
|
|
return request(req);
|
|
}
|
|
|
|
// convert JavaScript camelCase to oauth3 snake_case
|
|
if (req.data && 'object' === typeof req.data) {
|
|
req.originalData = req.data;
|
|
req.data = recase.snakeCopy(req.data);
|
|
}
|
|
|
|
//console.log('[F] [oauth3 req.url]', req.url);
|
|
return request(req).then(function (resp) {
|
|
// convert oauth3 snake_case to JavaScript camelCase
|
|
if (resp.data && 'object' === typeof resp.data) {
|
|
resp.originalData = resp.data;
|
|
resp.data = recase.camelCopy(resp.data);
|
|
}
|
|
return resp;
|
|
});
|
|
};
|
|
|
|
/*
|
|
return oauth3._testRequest(request).then(function () {
|
|
oauth3.request = request;
|
|
});
|
|
*/
|
|
};
|
|
|
|
logins.authorizationRedirect = function (providerUri, opts) {
|
|
// TODO get own directives
|
|
return oauth3.authorizationRedirect(
|
|
providerUri
|
|
, opts.authorizationRedirect
|
|
, opts
|
|
).then(function (prequest) {
|
|
if (!prequest.state) {
|
|
throw new Error("[Devolper Error] [authorization redirect] prequest.state is empty");
|
|
}
|
|
|
|
return oauth3.frameRequest(prequest.url, prequest.state, opts);
|
|
});
|
|
};
|
|
|
|
logins.implicitGrant = function (providerUri, opts) {
|
|
// TODO OAuth3 provider should use the redirect URI as the appId?
|
|
return oauth3.implicitGrant(
|
|
providerUri
|
|
// TODO OAuth3 provider should referer / origin as the appId?
|
|
, opts
|
|
).then(function (prequest) {
|
|
// console.log('[debug] prequest', prequest);
|
|
if (!prequest.state) {
|
|
throw new Error("[Devolper Error] [implicit grant] prequest.state is empty");
|
|
}
|
|
|
|
return oauth3.frameRequest(prequest.url, prequest.state, opts);
|
|
});
|
|
};
|
|
|
|
logins.resourceOwnerPassword = function (providerUri, username, passphrase, opts) {
|
|
console.log('DEBUG logins.resourceOwnerPassword opts', opts);
|
|
//var scope = opts.scope;
|
|
//var appId = opts.appId;
|
|
return oauth3.resourceOwnerPassword(
|
|
providerUri
|
|
, username
|
|
, passphrase
|
|
, opts
|
|
//, scope
|
|
//, appId
|
|
).then(function (request) {
|
|
console.log('DEBUG oauth3.resourceOwnerPassword', request);
|
|
return oauth3.request({
|
|
url: request.url
|
|
, method: request.method
|
|
, data: request.data
|
|
});
|
|
});
|
|
};
|
|
|
|
oauth3.frameRequest = function (url, state, opts) {
|
|
var promise;
|
|
|
|
if ('background' === opts.type) {
|
|
promise = oauth3.insertIframe(url, state, opts);
|
|
} else if ('popup' === opts.type) {
|
|
promise = oauth3.openWindow(url, state, opts);
|
|
} else {
|
|
throw new Error("login framing method not specified or not type yet implemented");
|
|
}
|
|
|
|
return promise.then(function (params) {
|
|
var err;
|
|
|
|
if (params.error || params.error_description) {
|
|
err = new Error(params.error_description || "Unknown response error");
|
|
err.code = params.error || "E_UKNOWN_ERROR";
|
|
err.params = params;
|
|
return oauth3.PromiseA.reject(err);
|
|
}
|
|
|
|
return params;
|
|
});
|
|
};
|
|
|
|
oauth3.login = function (providerUri, opts) {
|
|
console.log('##### DEBUG oauth3.login providerUri, opts');
|
|
console.log(providerUri);
|
|
console.log(opts);
|
|
// Four styles of login:
|
|
// * background (hidden iframe)
|
|
// * iframe (visible iframe, needs border color and width x height params)
|
|
// * popup (needs width x height and positioning? params)
|
|
// * window (params?)
|
|
|
|
// Two strategies
|
|
// * authorization_redirect (to server authorization code)
|
|
// * implicit_grant (default, browser-only)
|
|
// If both are selected, implicit happens first and then the other happens in background
|
|
|
|
var promise;
|
|
|
|
if (opts.username || opts.password) {
|
|
/* jshint ignore:start */
|
|
// ingore "confusing use of !"
|
|
if (!opts.username !== !opts.password) {
|
|
throw new Error("you did not specify both username and password");
|
|
}
|
|
/* jshint ignore:end */
|
|
|
|
var username = opts.username;
|
|
var password = opts.password;
|
|
delete opts.username;
|
|
delete opts.password;
|
|
|
|
return logins.resourceOwnerPassword(providerUri, username, password, opts).then(function (resp) {
|
|
if (!resp || !resp.data) {
|
|
var err = new Error("bad response");
|
|
err.response = resp;
|
|
err.data = resp && resp.data || undefined;
|
|
return oauth3.PromiseA.reject(err);
|
|
}
|
|
return resp.data;
|
|
});
|
|
}
|
|
|
|
// TODO support dual-strategy login
|
|
// by default, always get implicitGrant (for client)
|
|
// and optionally do authorizationCode (for server session)
|
|
if ('background' === opts.type || opts.background) {
|
|
opts.type = 'background';
|
|
opts.background = true;
|
|
}
|
|
else {
|
|
opts.type = 'popup';
|
|
opts.popup = true;
|
|
}
|
|
if (opts.authorizationRedirect) {
|
|
promise = logins.authorizationRedirect(providerUri, opts);
|
|
}
|
|
else {
|
|
promise = logins.implicitGrant(providerUri, opts);
|
|
}
|
|
|
|
return promise;
|
|
};
|
|
|
|
oauth3.backgroundLogin = function (providerUri, opts) {
|
|
opts = opts || {};
|
|
opts.type = 'background';
|
|
return oauth3.login(providerUri, opts);
|
|
};
|
|
|
|
oauth3.insertIframe = function (url, state, opts) {
|
|
opts = opts || {};
|
|
var promise = new oauth3.PromiseA(function (resolve, reject) {
|
|
var tok;
|
|
var $iframe;
|
|
|
|
function cleanup() {
|
|
delete window['__oauth3_' + state];
|
|
$iframe.remove();
|
|
clearTimeout(tok);
|
|
tok = null;
|
|
}
|
|
|
|
window['__oauth3_' + state] = function (params) {
|
|
//console.info('[iframe] complete', params);
|
|
resolve(params);
|
|
cleanup();
|
|
};
|
|
|
|
tok = setTimeout(function () {
|
|
var err = new Error("the iframe request did not complete within 15 seconds");
|
|
err.code = "E_TIMEOUT";
|
|
reject(err);
|
|
cleanup();
|
|
}, opts.timeout || 15000);
|
|
|
|
// TODO hidden / non-hidden (via directive even)
|
|
$iframe = $(
|
|
'<iframe src="' + url
|
|
//+ '" width="800px" height="800px" style="opacity: 0.8;" frameborder="1"></iframe>'
|
|
+ '" width="1px" height="1px" frameborder="0"></iframe>'
|
|
);
|
|
|
|
$('body').append($iframe);
|
|
});
|
|
|
|
// TODO periodically garbage collect expired handlers from window object
|
|
return promise;
|
|
};
|
|
|
|
oauth3.openWindow = function (url, state, opts) {
|
|
var promise = new oauth3.PromiseA(function (resolve, reject) {
|
|
var winref;
|
|
var tok;
|
|
|
|
function cleanup() {
|
|
delete window['__oauth3_' + state];
|
|
clearTimeout(tok);
|
|
tok = null;
|
|
// this is last in case the window self-closes synchronously
|
|
// (should never happen, but that's a negotiable implementation detail)
|
|
//winref.close();
|
|
}
|
|
|
|
window['__oauth3_' + state] = function (params) {
|
|
//console.info('[popup] (or window) complete', params);
|
|
resolve(params);
|
|
cleanup();
|
|
};
|
|
|
|
tok = setTimeout(function () {
|
|
var err = new Error("the windowed request did not complete within 3 minutes");
|
|
err.code = "E_TIMEOUT";
|
|
reject(err);
|
|
cleanup();
|
|
}, opts.timeout || 3 * 60 * 1000);
|
|
|
|
// TODO allow size changes (via directive even)
|
|
winref = window.open(url, 'oauth3-login-' + state, 'height=720,width=620');
|
|
if (!winref) {
|
|
reject("TODO: open the iframe first and discover oauth3 directives before popup");
|
|
cleanup();
|
|
}
|
|
});
|
|
|
|
// TODO periodically garbage collect expired handlers from window object
|
|
return promise;
|
|
};
|
|
|
|
oauth3.logout = function (providerUri, opts) {
|
|
opts = opts || {};
|
|
|
|
// Oauth3.init({ logout: function () {} });
|
|
//return Oauth3.logout();
|
|
|
|
var state = parseInt(Math.random().toString().replace('0.', ''), 10).toString('36');
|
|
var url = providerUri.replace(/\/$/, '') + (opts.providerOauth3Html || '/oauth3.html');
|
|
var redirectUri = opts.redirectUri
|
|
|| (window.location.protocol + '//' + (window.location.host + window.location.pathname) + 'oauth3.html')
|
|
;
|
|
var params = {
|
|
// logout=true for all logins/accounts
|
|
// logout=app-scoped-login-id for a single login
|
|
action: 'logout'
|
|
// TODO specify specific accounts / logins to delete from session
|
|
, accounts: true
|
|
, logins: true
|
|
, redirect_uri: redirectUri
|
|
, state: state
|
|
};
|
|
|
|
//console.log('DEBUG oauth3.logout NIX insertIframe');
|
|
//console.log(url, params.redirect_uri);
|
|
//console.log(state);
|
|
//console.log(params); // redirect_uri
|
|
//console.log(opts);
|
|
|
|
if (url === params.redirect_uri) {
|
|
return oauth3.PromiseA.resolve();
|
|
}
|
|
|
|
url += '#' + oauth3.querystringify(params);
|
|
|
|
return oauth3.insertIframe(url, state, opts);
|
|
};
|
|
|
|
oauth3.stringifyscope = function (scope) {
|
|
if (Array.isArray(scope)) {
|
|
scope = scope.join(' ');
|
|
}
|
|
return scope;
|
|
};
|
|
|
|
oauth3.querystringify = function (params) {
|
|
var qs = [];
|
|
|
|
Object.keys(params).forEach(function (key) {
|
|
if ('scope' === key) {
|
|
params[key] = oauth3.stringifyscope(params[key]);
|
|
}
|
|
qs.push(encodeURIComponent(key) + '=' + encodeURIComponent(params[key]));
|
|
});
|
|
|
|
return qs.join('&');
|
|
};
|
|
|
|
oauth3.createState = function () {
|
|
// TODO mo' betta' random function
|
|
// maybe gather some entropy from mouse / keyboard events?
|
|
// (probably not, just use webCrypto or be sucky)
|
|
return parseInt(Math.random().toString().replace('0.', ''), 10).toString('36');
|
|
};
|
|
|
|
oauth3.normalizeProviderUri = function (providerUri) {
|
|
// tested with
|
|
// example.com
|
|
// example.com/
|
|
// http://example.com
|
|
// https://example.com/
|
|
providerUri = providerUri
|
|
.replace(/^(https?:\/\/)?/, 'https://')
|
|
.replace(/\/?$/, '')
|
|
;
|
|
|
|
return providerUri;
|
|
};
|
|
|
|
oauth3._discoverHelper = function (providerUri, opts) {
|
|
opts = opts || {};
|
|
var state = oauth3.createState();
|
|
var params;
|
|
var url;
|
|
|
|
params = {
|
|
action: 'directives'
|
|
, state: state
|
|
// TODO this should be configurable (i.e. I want a dev vs production oauth3.html)
|
|
, redirect_uri: window.location.protocol + '//' + window.location.host
|
|
+ window.location.pathname + 'oauth3.html'
|
|
};
|
|
|
|
url = providerUri + '/oauth3.html#' + oauth3.querystringify(params);
|
|
|
|
return oauth3.insertIframe(url, state, opts).then(function (directives) {
|
|
return directives;
|
|
}, function (err) {
|
|
return oauth3.PromiseA.reject(err);
|
|
});
|
|
};
|
|
|
|
oauth3.discover = function (providerUri, opts) {
|
|
opts = opts || {};
|
|
|
|
console.log('DEBUG oauth3.discover', providerUri);
|
|
console.log(opts);
|
|
if (opts.directives) {
|
|
return oauth3.PromiseA.resolve(opts.directives);
|
|
}
|
|
|
|
var promise;
|
|
var promise2;
|
|
var directives;
|
|
var updatedAt;
|
|
var fresh;
|
|
|
|
providerUri = oauth3.normalizeProviderUri(providerUri);
|
|
try {
|
|
directives = JSON.parse(localStorage.getItem('oauth3.' + providerUri + '.directives'));
|
|
console.log('DEBUG oauth3.discover cache', directives);
|
|
updatedAt = localStorage.getItem('oauth3.' + providerUri + '.directives.updated_at');
|
|
console.log('DEBUG oauth3.discover updatedAt', updatedAt);
|
|
updatedAt = new Date(updatedAt).valueOf();
|
|
console.log('DEBUG oauth3.discover updatedAt', updatedAt);
|
|
} catch(e) {
|
|
// ignore
|
|
}
|
|
|
|
fresh = (Date.now() - updatedAt) < (24 * 60 * 60 * 1000);
|
|
|
|
if (directives) {
|
|
promise = oauth3.PromiseA.resolve(directives);
|
|
|
|
if (fresh) {
|
|
//console.log('[local] [fresh directives]', directives);
|
|
return promise;
|
|
}
|
|
}
|
|
|
|
promise2 = oauth3._discoverHelper(providerUri, opts).then(function (params) {
|
|
console.log('DEBUG oauth3._discoverHelper', params);
|
|
var err;
|
|
|
|
if (!params.directives) {
|
|
err = new Error(params.error_description || "Unknown error when discoving provider '" + providerUri + "'");
|
|
err.code = params.error || "E_UNKNOWN_ERROR";
|
|
return oauth3.PromiseA.reject(err);
|
|
}
|
|
|
|
try {
|
|
directives = JSON.parse(atob(params.directives));
|
|
console.log('DEBUG oauth3._discoverHelper directives', directives);
|
|
} catch(e) {
|
|
err = new Error(params.error_description || "could not parse directives for provider '" + providerUri + "'");
|
|
err.code = params.error || "E_PARSE_DIRECTIVE";
|
|
return oauth3.PromiseA.reject(err);
|
|
}
|
|
|
|
if (
|
|
(directives.authorization_dialog && directives.authorization_dialog.url)
|
|
|| (directives.access_token && directives.access_token.url)
|
|
) {
|
|
// TODO lint directives
|
|
localStorage.setItem('oauth3.' + providerUri + '.directives', JSON.stringify(directives));
|
|
localStorage.setItem('oauth3.' + providerUri + '.directives.updated_at', new Date().toISOString());
|
|
|
|
return oauth3.PromiseA.resolve(directives);
|
|
} else {
|
|
// ignore
|
|
console.error("the directives provided by '" + providerUri + "' were invalid.");
|
|
params.error = params.error || "E_INVALID_DIRECTIVE";
|
|
params.error_description = params.error_description
|
|
|| "directives did not include authorization_dialog.url";
|
|
err = new Error(params.error_description || "Unknown error when discoving provider '" + providerUri + "'");
|
|
err.code = params.error;
|
|
return oauth3.PromiseA.reject(err);
|
|
}
|
|
});
|
|
|
|
return promise || promise2;
|
|
};
|
|
|
|
oauth3.authorizationRedirect = function (providerUri, authorizationRedirect, opts) {
|
|
//console.log('[authorizationRedirect]');
|
|
//
|
|
// Example Authorization Redirect - from Browser to Consumer API
|
|
// (for generating a session securely on your own server)
|
|
//
|
|
// i.e. GET https://<<CONSUMER>>.com/api/org.oauth3.consumer/authorization_redirect/<<PROVIDER>>.com
|
|
//
|
|
// GET https://myapp.com/api/org.oauth3.consumer/authorization_redirect/`encodeURIComponent('example.com')`
|
|
// &scope=`encodeURIComponent('profile.login profile.email')`
|
|
//
|
|
// (optional)
|
|
// &state=`Math.random()`
|
|
// &redirect_uri=`encodeURIComponent('https://myapp.com/oauth3.html')`
|
|
//
|
|
// NOTE: This is not a request sent to the provider, but rather a request sent to the
|
|
// consumer (your own API) which then sets some state and redirects.
|
|
// This will initiate the `authorization_code` request on your server
|
|
//
|
|
opts = opts || {};
|
|
|
|
return oauth3.discover(providerUri, opts).then(function (directive) {
|
|
if (!directive) {
|
|
throw new Error("Developer Error: directive should exist when discovery is successful");
|
|
}
|
|
|
|
var scope = opts.scope || directive.authn_scope;
|
|
|
|
var state = Math.random().toString().replace(/^0\./, '');
|
|
var params = {};
|
|
var slimProviderUri = encodeURIComponent(providerUri.replace(/^(https?|spdy):\/\//, ''));
|
|
|
|
params.state = state;
|
|
if (scope) {
|
|
params.scope = scope;
|
|
}
|
|
if (opts.redirectUri) {
|
|
// this is really only for debugging
|
|
params.redirect_uri = opts.redirectUri;
|
|
}
|
|
// Note: the type check is necessary because we allow 'true'
|
|
// as an automatic mechanism when it isn't necessary to specify
|
|
if ('string' !== typeof authorizationRedirect) {
|
|
// TODO oauth3.json for self?
|
|
authorizationRedirect = 'https://' + window.location.host
|
|
+ '/api/org.oauth3.consumer/authorization_redirect/:provider_uri';
|
|
}
|
|
authorizationRedirect = authorizationRedirect
|
|
.replace(/!(provider_uri)/, slimProviderUri)
|
|
.replace(/:provider_uri/, slimProviderUri)
|
|
.replace(/#{provider_uri}/, slimProviderUri)
|
|
.replace(/{{provider_uri}}/, slimProviderUri)
|
|
;
|
|
|
|
return oauth3.PromiseA.resolve({
|
|
url: authorizationRedirect + '?' + oauth3.querystringify(params)
|
|
, method: 'GET'
|
|
, state: state // this becomes browser_state
|
|
, params: params // includes scope, final redirect_uri?
|
|
});
|
|
});
|
|
};
|
|
|
|
oauth3.authorizationCode = function (/*providerUri, scope, redirectUri, clientId*/) {
|
|
//
|
|
// Example Authorization Code Request
|
|
// (not for use in the browser)
|
|
//
|
|
// GET https://example.com/api/org.oauth3.provider/authorization_dialog
|
|
// ?response_type=code
|
|
// &scope=`encodeURIComponent('profile.login profile.email')`
|
|
// &state=`Math.random()`
|
|
// &client_id=xxxxxxxxxxx
|
|
// &redirect_uri=`encodeURIComponent('https://myapp.com/oauth3.html')`
|
|
//
|
|
// NOTE: `redirect_uri` itself may also contain URI-encoded components
|
|
//
|
|
// NOTE: This probably shouldn't be done in the browser because the server
|
|
// needs to initiate the state. If it is done in a browser, the browser
|
|
// should probably request 'state' from the server beforehand
|
|
//
|
|
|
|
throw new Error("not implemented");
|
|
};
|
|
|
|
oauth3.implicitGrant = function (providerUri, opts) {
|
|
//console.log('[implicitGrant]');
|
|
//
|
|
// Example Implicit Grant Request
|
|
// (for generating a browser-only session, not a session on your server)
|
|
//
|
|
// GET https://example.com/api/org.oauth3.provider/authorization_dialog
|
|
// ?response_type=token
|
|
// &scope=`encodeURIComponent('profile.login profile.email')`
|
|
// &state=`Math.random()`
|
|
// &client_id=xxxxxxxxxxx
|
|
// &redirect_uri=`encodeURIComponent('https://myapp.com/oauth3.html')`
|
|
//
|
|
// NOTE: `redirect_uri` itself may also contain URI-encoded components
|
|
//
|
|
|
|
opts = opts || {};
|
|
var type = 'authorization_dialog';
|
|
var responseType = 'token';
|
|
|
|
return oauth3.discover(providerUri, opts).then(function (directive) {
|
|
var redirectUri = opts.redirectUri;
|
|
var scope = opts.scope || directive.authn_scope;
|
|
var clientId = opts.appId;
|
|
var args = directive[type];
|
|
var uri = args.url;
|
|
var state = Math.random().toString().replace(/^0\./, '');
|
|
var params = {};
|
|
var loc;
|
|
var result;
|
|
|
|
params.state = state;
|
|
params.response_type = responseType;
|
|
if (scope) {
|
|
if (Array.isArray(scope)) {
|
|
scope = scope.join(' ');
|
|
}
|
|
params.scope = scope;
|
|
}
|
|
if (clientId) {
|
|
// In OAuth3 client_id is optional for implicit grant
|
|
params.client_id = clientId;
|
|
}
|
|
if (!redirectUri) {
|
|
loc = window.location;
|
|
redirectUri = loc.protocol + '//' + loc.host + loc.pathname;
|
|
if ('/' !== redirectUri[redirectUri.length - 1]) {
|
|
redirectUri += '/';
|
|
}
|
|
redirectUri += 'oauth3.html';
|
|
}
|
|
params.redirect_uri = redirectUri;
|
|
|
|
uri += '?' + oauth3.querystringify(params);
|
|
|
|
result = {
|
|
url: uri
|
|
, state: state
|
|
, method: args.method
|
|
, query: params
|
|
};
|
|
return oauth3.PromiseA.resolve(result);
|
|
});
|
|
};
|
|
|
|
oauth3.resourceOwnerPassword = function (providerUri, username, passphrase, opts) {
|
|
//
|
|
// Example Resource Owner Password Request
|
|
// (generally for 1st party and direct-partner mobile apps, and webapps)
|
|
//
|
|
// POST https://example.com/api/org.oauth3.provider/access_token
|
|
// { "grant_type": "password", "client_id": "<<id>>", "scope": "<<scope>>"
|
|
// , "username": "<<username>>", "password": "password" }
|
|
//
|
|
opts = opts || {};
|
|
var type = 'access_token';
|
|
var grantType = 'password';
|
|
|
|
return oauth3.discover(providerUri, opts).then(function (directive) {
|
|
var scope = opts.scope || directive.authn_scope;
|
|
var clientId = opts.appId;
|
|
var clientAgreeTos = opts.clientAgreeTos;
|
|
var clientUri = opts.clientUri;
|
|
var args = directive[type];
|
|
var params = {
|
|
"grant_type": grantType
|
|
, "username": username
|
|
, "password": passphrase
|
|
//, "totp": opts.totp
|
|
};
|
|
var uri = args.url;
|
|
var body;
|
|
if (opts.totp) {
|
|
params.totp = opts.totp;
|
|
}
|
|
|
|
if (clientId) {
|
|
params.clientId = clientId;
|
|
}
|
|
if (clientUri) {
|
|
params.clientUri = clientUri;
|
|
params.clientAgreeTos = clientAgreeTos;
|
|
if (!clientAgreeTos) {
|
|
throw new Error('Developer Error: missing clientAgreeTos uri');
|
|
}
|
|
}
|
|
|
|
if (scope) {
|
|
if (Array.isArray(scope)) {
|
|
scope = scope.join(' ');
|
|
}
|
|
params.scope = scope;
|
|
}
|
|
|
|
if ('GET' === args.method.toUpperCase()) {
|
|
uri += '?' + oauth3.querystringify(params);
|
|
} else {
|
|
body = params;
|
|
}
|
|
|
|
return {
|
|
url: uri
|
|
, method: args.method
|
|
, data: body
|
|
};
|
|
});
|
|
};
|
|
|
|
exports.OAUTH3 = oauth3.oauth3 = oauth3.OAUTH3 = oauth3;
|
|
exports.oauth3 = exports.OAUTH3;
|
|
|
|
if ('undefined' !== typeof module) {
|
|
module.exports = oauth3;
|
|
}
|
|
}('undefined' !== typeof exports ? exports : window));
|