walnut.js/lib/com.daplie.walnut.current/daplie-scripts/oauth3.new/oauth3.js

739 lines
23 KiB
JavaScript
Raw Permalink Normal View History

(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));