value: function wrap(fn, metadata, metadataStyles, callback) {
var _fnType3 = t.function();
var _metadataType26 = t.union(t.nullable(t.object()), t.function());
var _metadataStylesType25 = t.union(t.nullable(t.object()), t.function());
var _callbackType = t.function();
t.param('fn', _fnType3).assert(fn);
t.param('metadata', _metadataType26).assert(metadata);
t.param('metadataStyles', _metadataStylesType25).assert(metadataStyles);
t.param('callback', _callbackType).assert(callback);
if (typeof metadata === 'function') {
callback = _callbackType.assert(metadata);
metadata = _metadataType26.assert(undefined);
} else if (typeof metadataStyles === 'function') {
callback = _callbackType.assert(metadataStyles);
metadataStyles = _metadataStylesType25.assert(undefined);
}
this.enter(fn, metadata, metadataStyles);
callback();
this.exit(fn);
}
getTokens(strategy, options = {}) {
let _strategyType2 = t.string();
t.param('strategy', _strategyType2).assert(strategy);
t.param('options', GetTokensOptionsType).assert(options);
logger$1.debug('getTokens', { strategy, options });
const strategyInstance = this.strategies[strategy];
switch (strategyInstance.type) {
case 'oauth2':
return strategyInstance.oauth2.authorizationCode.getToken({
code: options.code,
redirect_uri: options.redirectUri
}).then(result => result && {
accessToken: result.access_token,
refreshToken: result.refresh_token,
tokenType: result.token_type,
expiresIn: result.expires_in,
expireDate: (() => {
const d = new Date();
d.setTime(d.getTime() + result.expires_in * 1000);
return d;
})(),
idToken: result.id_token
}
// return strategyInstance.accessToken.create(result);
);
}
}
app.context.setConnected = async function (connected, user) {
let _connectedType = t.union(t.number(), t.string());
let _userType = t.object();
t.param('connected', _connectedType).assert(connected);
t.param('user', _userType).assert(user);
logger$2.debug('setConnected', { connected });
if (!connected) {
throw new Error('Illegal value for setConnected');
}
this.state.connected = connected;
this.state.user = user;
const token = await signPromisified({ connected, time: Date.now() }, this.config.get('authentication').get('secretKey'), {
algorithm: 'HS512',
audience: this.request.headers['user-agent'],
expiresIn: '30 days'
});
this.cookies.set(COOKIE_NAME, token, {
httpOnly: true,
secure: this.config.get('allowHttps')
});
};
export default function SlackHandler(slackConfig, minLevel) {
let _minLevelType = t.number();
t.param('slackConfig', SlackConfigType).assert(slackConfig);
t.param('minLevel', _minLevelType).assert(minLevel);
this.minLevel = minLevel;
this.handle = createHandler(slackConfig);
}
value: function child(childSuffixKey, childDisplayName) {
var _childSuffixKeyType = t.string();
var _childDisplayNameType = t.nullable(t.string());
var _returnType6 = t.return(t.ref(Logger));
t.param('childSuffixKey', _childSuffixKeyType).assert(childSuffixKey);
t.param('childDisplayName', _childDisplayNameType).assert(childDisplayName);
return _returnType6.assert(new Logger(this.key + ':' + childSuffixKey, childDisplayName));
}
/** @private */
function getConfigForLoggerRecord(key, recordLevel) {
var _keyType2 = t.nullable(t.string());
var _recordLevelType = t.number();
var _returnType3 = t.return(ConfigForLoggerType);
t.param('key', _keyType2).assert(key);
t.param('recordLevel', _recordLevelType).assert(recordLevel);
return _returnType3.assert(global.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD(key, recordLevel));
}
value: function fail(message, metadata, metadataStyles) {
var _messageType14 = t.string();
var _metadataType16 = t.nullable(t.object());
var _metadataStylesType15 = t.nullable(t.object());
t.param('message', _messageType14).assert(message);
t.param('metadata', _metadataType16).assert(metadata);
t.param('metadataStyles', _metadataStylesType15).assert(metadataStyles);
this.infoFail(message, metadata, metadataStyles);
}
constructor(config, strategies, userAccountsService) {
let _strategiesType = t.object();
let _userAccountsServiceType = t.ref(UserAccountsService);
t.param('strategies', _strategiesType).assert(strategies);
t.param('userAccountsService', _userAccountsServiceType).assert(userAccountsService);
super();
this.config = config;
this.strategies = strategies;
this.userAccountsService = userAccountsService;
}
value: function inspectValue(value, metadata, metadataStyles) {
var _valueType = t.any();
var _metadataType11 = t.nullable(t.object());
var _metadataStylesType10 = t.nullable(t.object());
t.param('value', _valueType).assert(value);
t.param('metadata', _metadataType11).assert(metadata);
t.param('metadataStyles', _metadataStylesType10).assert(metadataStyles);
throw new Error('Not supported for the browser. Prefer `debugger;`');
}
value: function alert(message, metadata, metadataStyles) {
var _messageType10 = t.string();
var _metadataType10 = t.nullable(t.object());
var _metadataStylesType9 = t.nullable(t.object());
t.param('message', _messageType10).assert(message);
t.param('metadata', _metadataType10).assert(metadata);
t.param('metadataStyles', _metadataStylesType9).assert(metadataStyles);
this.log(message, metadata, levels.ALERT, { metadataStyles: metadataStyles });
}
value: function critical(message, metadata, metadataStyles) {
var _messageType8 = t.string();
var _metadataType8 = t.nullable(t.object());
var _metadataStylesType7 = t.nullable(t.object());
t.param('message', _messageType8).assert(message);
t.param('metadata', _metadataType8).assert(metadata);
t.param('metadataStyles', _metadataStylesType7).assert(metadataStyles);
this.log(message, metadata, levels.CRITICAL, { metadataStyles: metadataStyles });
}
value: function warn(message, metadata, metadataStyles) {
var _messageType6 = t.string();
var _metadataType6 = t.nullable(t.object());
var _metadataStylesType5 = t.nullable(t.object());
t.param('message', _messageType6).assert(message);
t.param('metadata', _metadataType6).assert(metadata);
t.param('metadataStyles', _metadataStylesType5).assert(metadataStyles);
this.log(message, metadata, levels.WARN, { metadataStyles: metadataStyles });
}
value: function notice(message, metadata, metadataStyles) {
var _messageType4 = t.string();
var _metadataType4 = t.nullable(t.object());
var _metadataStylesType3 = t.nullable(t.object());
t.param('message', _messageType4).assert(message);
t.param('metadata', _metadataType4).assert(metadata);
t.param('metadataStyles', _metadataStylesType3).assert(metadataStyles);
this.log(message, metadata, levels.NOTICE, { metadataStyles: metadataStyles });
}
value: function debug(message, metadata, metadataStyles) {
var _messageType3 = t.string();
var _metadataType3 = t.nullable(t.object());
var _metadataStylesType2 = t.nullable(t.object());
t.param('message', _messageType3).assert(message);
t.param('metadata', _metadataType3).assert(metadata);
t.param('metadataStyles', _metadataStylesType2).assert(metadataStyles);
this.log(message, metadata, levels.DEBUG, { metadataStyles: metadataStyles });
}
value: function success(message, metadata, metadataStyles) {
var _messageType11 = t.string();
var _metadataType13 = t.nullable(t.object());
var _metadataStylesType12 = t.nullable(t.object());
t.param('message', _messageType11).assert(message);
t.param('metadata', _metadataType13).assert(metadata);
t.param('metadataStyles', _metadataStylesType12).assert(metadataStyles);
this.infoSuccess(message, metadata, metadataStyles);
}
/**
* @param {Koa.Context} ctx
* @param {string} strategy
* @param {boolean} isConnected
* @returns {*}
*/
async accessResponse(ctx, strategy, isConnected) {
let _strategyType6 = t.string();
let _isConnectedType = t.nullable(t.boolean());
t.param('strategy', _strategyType6).assert(strategy);
t.param('isConnected', _isConnectedType).assert(isConnected);
if (ctx.query.error) {
const error = new Error(ctx.query.error);
error.status = 403;
error.expose = true;
throw error;
}
const code = ctx.query.code;
const state = ctx.query.state;
const cookieName = `auth_${strategy}_${state}`;
let cookie = ctx.cookies.get(cookieName);
ctx.cookies.set(cookieName, '', { expires: new Date(1) });
if (!cookie) {
throw new Error('No cookie for this state');
}
cookie = JSON.parse(cookie);
if (!cookie || !cookie.scope) {
throw new Error('Unexpected cookie value');
}
if (!cookie.isLoginAccess) {
if (!isConnected) {
throw new Error('You are not connected');
}
}
const tokens = await this.getTokens(strategy, {
code,
redirectUri: this.redirectUri(ctx, strategy)
});
if (cookie.isLoginAccess) {
const user = await this.userAccountsService.findOrCreateFromGoogle(strategy, tokens, cookie.scope, cookie.scopeKey);
return user;
}
ctx.cookies.set(cookieName, '', { expires: new Date(1) });
const connectedUser = ctx.state.connected;
await this.userAccountsService.update(connectedUser, strategy, tokens, cookie.scope, cookie.scopeKey);
return connectedUser;
}
value: function infoTime(message, metadata, metadataStyles) {
var _messageType18 = t.nullable(t.string());
var _metadataType20 = t.nullable(t.object());
var _metadataStylesType19 = t.nullable(t.object());
var _returnType9 = t.return(t.number());
t.param('message', _messageType18).assert(message);
t.param('metadata', _metadataType20).assert(metadata);
t.param('metadataStyles', _metadataStylesType19).assert(metadataStyles);
return _returnType9.assert(this.time(message, metadata, metadataStyles, levels.INFO));
}
value: function setContext(context) {
var _contextType2 = t.object();
t.param('context', _contextType2).assert(context);
this._context = context;
}
value: function infoTimeEnd(time, message, metadata, metadataStyles) {
var _timeType = t.number();
var _messageType20 = t.string();
var _metadataType22 = t.nullable(t.object());
var _metadataStylesType21 = t.nullable(t.object());
t.param('time', _timeType).assert(time);
t.param('message', _messageType20).assert(message);
t.param('metadata', _metadataType22).assert(metadata);
t.param('metadataStyles', _metadataStylesType21).assert(metadataStyles);
this.timeEnd(time, message, metadata, metadataStyles, levels.INFO);
}
value: function exit(fn, metadata, metadataStyles) {
var _fnType2 = t.function();
var _metadataType25 = t.nullable(t.object());
var _metadataStylesType24 = t.nullable(t.object());
t.param('fn', _fnType2).assert(fn);
t.param('metadata', _metadataType25).assert(metadata);
t.param('metadataStyles', _metadataStylesType24).assert(metadataStyles);
metadata = _metadataType25.assert(Object.assign({
functionName: fn.name
}, metadata));
this.log('exit', metadata, levels.TRACE, { metadataStyles: metadataStyles });
}
value: function addRecord(record) {
var _recordType = t.object();
t.param('record', _recordType).assert(record);
var _getHandlersAndProces = this.getHandlersAndProcessors(record.level),
handlers = _getHandlersAndProces.handlers,
processors = _getHandlersAndProces.processors;
if (handlers.length === 0) {
if (record.level > levels.ERROR) {
// eslint-disable-next-line no-console
console.log('[nightingale] no logger for > error level.', {
key: record.key,
message: record.message
});
}
return;
}
if (processors) {
processors.forEach(function (process) {
return process(record, record.context);
});
}
handlers.some(function (handler) {
return handler.handle(record) === false;
});
}
value: function extendsContext(extendedContext) {
var _extendedContextType = t.object();
t.param('extendedContext', _extendedContextType).assert(extendedContext);
Object.assign(this._context, extendedContext);
}
refreshToken(strategy, tokens) {
let _strategyType3 = t.string();
t.param('strategy', _strategyType3).assert(strategy);
logger$1.debug('refreshToken', { strategy });
if (!tokens.refreshToken) {
throw new Error('Missing refresh token');
}
const strategyInstance = this.strategies[strategy];
switch (strategyInstance.type) {
case 'oauth2':
{
const token = strategyInstance.oauth2.accessToken.create({
refresh_token: tokens.refreshToken
});
return token.refresh().then(result => {
const tokens = result.token;
return result && {
accessToken: tokens.access_token,
tokenType: tokens.token_type,
expiresIn: tokens.expires_in,
expireDate: (() => {
const d = new Date();
d.setTime(d.getTime() + tokens.expires_in * 1000);
return d;
})(),
idToken: tokens.id_token
};
});
}
}
}
value: function debugFail(message, metadata, metadataStyles) {
var _messageType16 = t.string();
var _metadataType18 = t.nullable(t.object());
var _metadataStylesType17 = t.nullable(t.object());
t.param('message', _messageType16).assert(message);
t.param('metadata', _metadataType18).assert(metadata);
t.param('metadataStyles', _metadataStylesType17).assert(metadataStyles);
this.log(message, metadata, levels.DEBUG, {
metadataStyles: metadataStyles,
symbol: '✖',
styles: ['red']
});
}
value: function debugSuccess(message, metadata, metadataStyles) {
var _messageType13 = t.string();
var _metadataType15 = t.nullable(t.object());
var _metadataStylesType14 = t.nullable(t.object());
t.param('message', _messageType13).assert(message);
t.param('metadata', _metadataType15).assert(metadata);
t.param('metadataStyles', _metadataStylesType14).assert(metadataStyles);
this.log(message, metadata, levels.DEBUG, {
metadataStyles: metadataStyles,
symbol: '✔',
styles: ['green']
});
}
redirectUri(ctx, strategy) {
let _strategyType4 = t.string();
t.param('strategy', _strategyType4).assert(strategy);
const host = `http${this.config.get('allowHttps') ? 's' : ''}://${ctx.request.host}`;
return `${host}${ctx.urlGenerator('loginResponse', { strategy })}`;
}
export function addConfig(config, unshift = false) {
let _configType2 = Config;
t.param('config', _configType2).assert(config);
config = _configType2.assert(handleConfig(config));
global.__NIGHTINGALE_CONFIG[unshift ? 'unshift' : 'push'](config);
clearCache();
}
/**
* Create a new Logger
*
* @param {string} key
* @param {string} [displayName]
*/
function Logger(key, displayName) {
classCallCheck(this, Logger);
var _keyType3 = t.string();
var _displayNameType = t.nullable(t.string());
t.param('key', _keyType3).assert(key);
t.param('displayName', _displayNameType).assert(displayName);
this.key = key;
this.displayName = displayName;
if (key.includes('.')) {
this.warn('nightingale: `.` in key is deprecated, replace with `:`', { key: key, displayName: displayName });
this.key = key.replace(/\./g, ':');
}
}
function randomHex(size) {
let _sizeType2 = t.number();
const _returnType2 = t.return(t.string());
t.param('size', _sizeType2).assert(size);
return randomBytesPromisified(size).then(buffer => buffer.toString('hex')).then(_arg2 => _returnType2.assert(_arg2));
}
export default function ConsoleHandler(minLevel) {
let _minLevelType = t.number();
t.param('minLevel', _minLevelType).assert(minLevel);
this.minLevel = 0;
this.handle = handle;
this.isHandling = (level, key) => level >= findDebugLevel(minLevel, key);
}