citeclaw 2.0.0

package/lib/translators/general.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const ut = require( './util/index.js' );
+
+const makeTranslator = ut.makeTranslator;
+const eg = ut.extendGeneral;
+const makeCreatorsTranslator = ut.makeCreatorsTranslator;
+
+/**
+ * General field values : Zotero type field values
+ *
+ * @type {Object}
+ */
+
+exports.general = {
+	canonical: makeTranslator( 'url' ),
+	description: makeTranslator( 'abstractNote' ),
+	publisher: makeTranslator( 'publisher' ),
+	lang: makeTranslator( 'language' ),
+	title: makeTranslator( 'title' )
+};
+
+// Shortcut for extendGeneral utility
+function extendGeneral( creatorName ) {
+	return eg( exports.general, creatorName, 'author' );
+}
+
+// Create a general type with the author in the creator field once since it is used many times.
+exports.generalWithAuthor = extendGeneral( 'author' );
+exports.generalNoPublisher = {
+	author: makeCreatorsTranslator( 'author' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+
+/* Complete list of Zotero types with field translators in the Object */
+exports.artwork = {
+	author: makeCreatorsTranslator( 'artist' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.attachment = {
+	title: makeTranslator( 'title' )
+};
+exports.audioRecording = {
+	author: makeCreatorsTranslator( 'performer' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.bill = {
+	author: makeCreatorsTranslator( 'sponsor' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.blogPost = exports.generalNoPublisher;
+exports.book = exports.generalWithAuthor;
+exports.bookSection = exports.generalWithAuthor;
+exports.case = {
+	author: makeCreatorsTranslator( 'author' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'caseName' )
+};
+exports.computerProgram = { // No language field
+	title: makeTranslator( 'title' ),
+	creator: makeCreatorsTranslator( 'programmer' )
+};
+exports.conferencePaper = exports.generalWithAuthor;
+exports.dictionaryEntry = exports.generalWithAuthor;
+exports.document = exports.generalWithAuthor;
+exports.email = {
+	author: makeCreatorsTranslator( 'author' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'subject' )
+};
+exports.encyclopediaArticle = exports.generalWithAuthor;
+exports.film = {
+	author: makeCreatorsTranslator( 'director' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.forumPost = exports.generalNoPublisher;
+exports.hearing = extendGeneral( 'contributor' );
+exports.instantMessage = exports.generalNoPublisher;
+exports.interview = {
+	author: makeCreatorsTranslator( 'interviewee' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.journalArticle = exports.generalNoPublisher;
+exports.letter = exports.generalNoPublisher;
+exports.magazineArticle = exports.generalNoPublisher;
+exports.manuscript = exports.generalNoPublisher;
+exports.map = extendGeneral( 'cartographer' );
+exports.newspaperArticle = {
+	author: makeCreatorsTranslator( 'author' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.note = {}; // Has no fields
+exports.patent = {
+	author: makeCreatorsTranslator( 'inventor' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.podcast = {
+	author: makeCreatorsTranslator( 'podcaster' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.presentation = {
+	author: makeCreatorsTranslator( 'presenter' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.radioBroadcast = {
+	author: makeCreatorsTranslator( 'director' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'title' )
+};
+exports.report = exports.generalNoPublisher;
+exports.statute = {
+	author: makeCreatorsTranslator( 'author' ),
+	canonical: makeTranslator( 'url' ),
+	lang: makeTranslator( 'language' ),
+	description: makeTranslator( 'abstractNote' ),
+	title: makeTranslator( 'nameOfAct' )
+};
+exports.thesis = exports.generalNoPublisher;
+exports.tvBroadcast = exports.radioBroadcast;
+exports.videoRecording = exports.tvBroadcast;
+exports.webpage = exports.generalNoPublisher;

package/lib/translators/openGraph.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const ex = require( '../Exporter.js' );
+const makeTranslator = require( './util/index.js' ).makeTranslator;
+
+const fixDate = ex.fixDate;
+const fixLang = ex.fixLang;
+const vISBN = ex.validateISBN;
+
+/**
+ * Open graph type field values : Zotero type field values
+ *
+ * @type {Object}
+ */
+exports.types = {
+	website: 'webpage',
+	// Previously blogPost, could also be newspaperArticle or magazineArticle
+	article: 'newspaperArticle',
+	book: 'book',
+	profile: 'webpage', // May be possible to obtain more information from this link a.k.a. names
+	'music.song': 'audioRecording',
+	'music.album': 'audioRecording',
+	'music.playlist': 'webpage',
+	'music.radiostation': 'webpage',
+	'video.movie': 'videoRecording',
+	'video.episode': 'videoRecording',
+	'video.tv_show': 'videoRecording',
+	'video.other': 'videoRecording'
+};
+
+/**
+ * Open graph general properties : Zotero properties
+ *
+ * @type {Object}
+ */
+
+exports.general = {
+	title: makeTranslator( 'title' ), // general OG property, common to all Zotero types
+	url: makeTranslator( 'url' ), // general OG property, common to all Zotero types
+	// general OG property, abstractNote common to all Zotero types
+	description: makeTranslator( 'abstractNote' ),
+	locale: makeTranslator( 'language', fixLang ) // general OG property, common to all Zotero types
+};
+
+// Includes both possible date fields- will overwrite if first if both are present
+exports.generalWithDate = Object.assign( {}, exports.general, {
+	published_time: makeTranslator( 'date', fixDate ),
+	release_date: makeTranslator( 'date', fixDate )
+} );
+
+/**
+ * Translator for Zotero type: webpage
+ * Open graph webpage properties : Zotero properties
+ * webpage has no specific properties other than what is defined in general og properties
+ *
+ * @type {Object}
+ */
+exports.artwork = exports.generalWithDate;
+exports.attachment = {
+	title: makeTranslator( 'title' )
+};
+exports.audioRecording = Object.assign( {}, exports.general, {
+	release_date: makeTranslator( 'date', fixDate ), // only present in music.album
+	isbn: makeTranslator( 'ISBN', vISBN )
+} );
+exports.bill = exports.generalWithDate;
+exports.blogPost = {
+	title: makeTranslator( 'title' ), // general OG property, common to all Zotero types
+	url: makeTranslator( 'url' ), // general OG property, common to all Zotero types
+	// general OG property, abstractNote common to all Zotero types
+	description: makeTranslator( 'abstractNote' ),
+	locale: makeTranslator( 'language', fixLang ), // general OG property, common to all Zotero types
+	published_time: makeTranslator( 'date', fixDate ),
+	site_name: makeTranslator( 'blogTitle' )
+};
+exports.book = Object.assign( {}, exports.general, {
+	release_date: makeTranslator( 'date', fixDate ),
+	isbn: makeTranslator( 'ISBN', vISBN )
+} );
+exports.bookSection = exports.book;
+exports.case = {
+	title: makeTranslator( 'caseName' ),
+	url: makeTranslator( 'url' ),
+	description: makeTranslator( 'abstractNote' ),
+	locale: makeTranslator( 'language', fixLang )
+};
+exports.computerProgram = { // No language field
+	title: makeTranslator( 'title' ),
+	url: makeTranslator( 'url' ),
+	description: makeTranslator( 'abstractNote' ),
+	isbn: makeTranslator( 'ISBN' )
+};
+exports.conferencePaper = Object.assign( {}, exports.general, {
+	isbn: makeTranslator( 'ISBN', vISBN )
+} );
+exports.dictionaryEntry = {
+	title: makeTranslator( 'title' ), // general OG property, common to all Zotero types
+	url: makeTranslator( 'url' ), // general OG property, common to all Zotero types
+	// general OG property, abstractNote common to all Zotero types
+	description: makeTranslator( 'abstractNote' ),
+	locale: makeTranslator( 'language', fixLang ), // general OG property, common to all Zotero types
+	published_time: makeTranslator( 'date', fixDate ),
+	site_name: makeTranslator( 'dictionaryTitle' ),
+	isbn: makeTranslator( 'ISBN', vISBN )
+};
+exports.document = exports.generalWithDate;
+exports.email = {
+	title: makeTranslator( 'subject' ),
+	url: makeTranslator( 'url' ),
+	description: makeTranslator( 'abstractNote' ),
+	locale: makeTranslator( 'language', fixLang ),
+	published_time: makeTranslator( 'date', fixDate ),
+	release_date: makeTranslator( 'date', fixDate )
+};
+exports.encyclopediaArticle = {
+	title: makeTranslator( 'title' ), // general OG property, common to all Zotero types
+	url: makeTranslator( 'url' ), // general OG property, common to all Zotero types
+	// general OG property, abstractNote common to all Zotero types
+	description: makeTranslator( 'abstractNote' ),
+	locale: makeTranslator( 'language', fixLang ), // general OG property, common to all Zotero types
+	published_time: makeTranslator( 'date', fixDate ),
+	site_name: makeTranslator( 'encyclopediaTitle' ),
+	isbn: makeTranslator( 'ISBN', vISBN )
+};
+exports.film = Object.assign( {}, exports.general, {
+	duration: makeTranslator( 'runningTime' ),
+	release_date: makeTranslator( 'date', fixDate )
+} );
+exports.forumPost = {
+	title: makeTranslator( 'title' ), // general OG property, common to all Zotero types
+	url: makeTranslator( 'url' ), // general OG property, common to all Zotero types
+	// general OG property, abstractNote common to all Zotero types
+	description: makeTranslator( 'abstractNote' ),
+	locale: makeTranslator( 'language', fixLang ), // general OG property, common to all Zotero types
+	published_time: makeTranslator( 'date', fixDate ),
+	site_name: makeTranslator( 'forumTitle' )
+};
+exports.hearing = exports.generalWithDate;
+exports.instantMessage = exports.generalWithDate;
+exports.interview = exports.generalWithDate;
+exports.journalArticle = {
+	title: makeTranslator( 'title' ), // general OG property, common to all Zotero types
+	url: makeTranslator( 'url' ), // general OG property, common to all Zotero types
+	// general OG property, abstractNote common to all Zotero types
+	description: makeTranslator( 'abstractNote' ),
+	locale: makeTranslator( 'language', fixLang ), // general OG property, common to all Zotero types
+	published_time: makeTranslator( 'date', fixDate ),
+	site_name: makeTranslator( 'publicationTitle' )
+};
+exports.letter = exports.generalWithDate;
+exports.magazineArticle = exports.journalArticle;
+exports.manuscript = exports.generalWithDate;
+exports.map = Object.assign( {}, exports.general, {
+	isbn: makeTranslator( 'ISBN', vISBN )
+} );
+exports.newspaperArticle = exports.journalArticle;
+exports.note = {}; // Has no fields
+exports.patent = exports.general;
+exports.podcast = exports.general;
+exports.presentation = exports.generalWithDate;
+exports.radioBroadcast = exports.generalWithDate;
+exports.report = exports.generalWithDate;
+exports.statute = {
+	title: makeTranslator( 'nameOfAct' ),
+	url: makeTranslator( 'url' ),
+	description: makeTranslator( 'abstractNote' ),
+	locale: makeTranslator( 'language', fixLang )
+};
+exports.thesis = exports.generalWithDate;
+exports.tvBroadcast = exports.generalWithDate;
+exports.videoRecording = Object.assign( {}, exports.film, {
+	isbn: makeTranslator( 'ISBN', vISBN )
+} );
+exports.webpage = Object.assign( {}, exports.generalWithDate, {
+	// prefix og: general property, but should only be assigned if type webpage is used
+	site_name: makeTranslator( 'websiteTitle' )
+} );

package/lib/translators/util/index.js

@@ -0,0 +1,209 @@
+'use strict';
+
+/* Utility functions used across translators */
+
+const fixPages = require( '../../../lib/Exporter.js' ).fixPages;
+
+/**
+ * Utility function to map the keys directly
+ *
+ * @param  {string}   property Zotero property name to add to citation
+ * @param  {Function} validate Function to run on scraped value
+ * @return {Object}            citation object
+ */
+exports.makeTranslator = function ( property, validate ) {
+	function translateProp( citation, metadata, key ) {
+		let metadataValue = metadata[ key ];
+		citation = citation || {};
+		// Choose the first value of array if first value is string
+		if ( Array.isArray( metadataValue ) ) {
+			if ( typeof metadataValue[ 0 ] === 'string' ) {
+				metadataValue = metadataValue[ 0 ];
+			}
+		}
+		// Clean strings of whitespace
+		if ( typeof metadataValue === 'string' ) {
+			// Replaces nonbreaking spaces with regular spaces
+			metadataValue = metadataValue.replace( /\xA0+/g, ' ' );
+			// Remove line feed characters (except for abstractNote field)
+			if ( property !== 'abstractNote' ) {
+				metadataValue = metadataValue.replace( /[\r\n]+/g, ' ' );
+			}
+			citation[ property ] = metadataValue.trim();
+		}
+		if ( validate ) {
+			return validate( citation, property );
+		} else {
+			return citation;
+		}
+	}
+	return {
+		name: property,
+		translate: translateProp
+	};
+};
+
+/* Adds creators when they're a string or an array */
+exports.addCreators = function ( citation, metadataValue, creatorFieldName ) {
+	let creatorName;
+	let i;
+
+	if ( !citation ) {
+		citation = {};
+	}
+	if ( !metadataValue ) {
+		return citation;
+	}
+	if ( !creatorFieldName ) {
+		creatorFieldName = 'author';
+	}
+
+	if ( !Array.isArray( metadataValue ) ) {
+		// Case: creator is a string, not a list of strings
+		if ( typeof metadataValue === 'string' ) {
+			creatorName = metadataValue.trim();
+			if ( creatorName ) {
+				citation.creators = citation.creators || [];
+				citation.creators.push(
+					exports.generateCreatorObj( creatorName, creatorFieldName )
+				);
+			}
+		}
+		// If neither a string nor a list, return citation unchanged
+		return citation;
+	}
+	// Case: creator is a list of strings
+	for ( i = 0; i < metadataValue.length; i++ ) {
+		creatorName = metadataValue[ i ].trim();
+		if ( !creatorName ) {
+			return;
+		} else {
+			citation.creators = citation.creators || [];
+		}
+		citation.creators.push( exports.generateCreatorObj( creatorName, creatorFieldName ) );
+	}
+	return citation;
+};
+
+/* Generates creator object to add to creators list */
+exports.generateCreatorObj = function ( creatorName, creatorFieldName ) {
+	const creatorObj = { creatorType: creatorFieldName };
+
+	// Chunk authorText for portioning into first and lastnames
+	creatorName = creatorName.trim().split( /\s+/m );
+	// Single name authors are set to last name
+	if ( creatorName.length === 1 ) {
+		creatorObj.firstName = '';
+		creatorObj.lastName = creatorName[ 0 ];
+	}
+	// Two or three named authors are set with last word to last name and all others to first
+	if ( creatorName.length === 2 || creatorName.length === 3 ) {
+		creatorObj.firstName = creatorName.slice( 0, creatorName.length - 1 ).join( ' ' );
+		creatorObj.lastName = creatorName[ creatorName.length - 1 ];
+	}
+	// Weirdly long, might not be just the name, better not to guess
+	if ( creatorName.length > 3 ) {
+		creatorObj.firstName = '';
+		creatorObj.lastName = creatorName.join( ' ' );
+	}
+
+	return creatorObj;
+};
+
+/* Similar to makeTranslator but for the creators field */
+exports.makeCreatorsTranslator = function ( creatorType ) {
+	function translateProp( citation, metadata, key ) {
+		citation = exports.addCreators( citation, metadata[ key ], creatorType );
+		return citation;
+	}
+	return {
+		name: 'creators',
+		subname: creatorType,
+		translate: translateProp
+	};
+};
+
+/* Function to add arbitrary creator function to the exports.general obj */
+exports.extendGeneral = function ( generalObj, creatorType, key ) {
+	if ( !key ) {
+		throw new Error( 'a key is required' );
+	}
+	const extendedType = {};
+	Object.assign( extendedType, generalObj );
+	extendedType[ key ] = exports.makeCreatorsTranslator( creatorType );
+	return extendedType;
+};
+
+/* A translate property function that takes the field names as arguments (not values) */
+exports.makePagesTranslator = function ( property, spage, epage, pages ) {
+	function translateProp( citation, metadata, key ) {
+		citation = citation || {};
+		// Use pages if available
+		if ( metadata[ pages ] && typeof metadata[ pages ] === 'string' ) {
+			citation[ property ] = metadata[ pages ].trim();
+			return fixPages( citation );
+		}
+		// Otherwise use start and end page values
+		if ( !metadata[ spage ] || !metadata[ epage ] ||
+            typeof metadata[ spage ] !== 'string' || typeof metadata[ epage ] !== 'string' ) {
+			return citation;
+		}
+		citation[ property ] = `${ metadata[ spage ].trim() }–${ metadata[ epage ].trim() }`;
+		return citation;
+	}
+	return {
+		name: property,
+		translate: translateProp
+	};
+};
+
+exports.makeListTranslator = function ( property, validate, args ) {
+	/**
+	 * Add parameters in a list to a string
+	 *
+	 * @param {Object}    citation  citation object
+	 * @param {Object}    metadata  object of metadata key/value pairs
+	 * @param {string}    key       citation key name
+	 * @return {Object}             citation
+	 */
+	function listToString( citation, metadata, key ) {
+		const values = metadata[ key ];
+		let valid;
+
+		// Case: single string value
+		if ( typeof values === 'string' ) {
+			valid = validate ? validate( values, args ) : values;
+			if ( valid ) {
+				if ( !citation[ property ] ) { // Empty string
+					citation[ property ] = valid;
+				} else {
+					citation[ property ] += `, ${ valid }`;
+				}
+			}
+			return citation;
+		}
+
+		// Case: Not a string or an array or is empty array
+		if ( !Array.isArray( values ) || !values.length ) {
+			return citation;
+		}
+
+		// Case: Array of values
+		let i;
+		for ( i = 0; i < values.length; i++ ) {
+			valid = validate ? validate( values[ i ], args ) : values[ i ];
+			if ( valid ) {
+				if ( !citation[ property ] ) { // Empty string
+					citation[ property ] = valid;
+				} else {
+					citation[ property ] += `, ${ valid }`;
+				}
+			}
+		}
+		return citation;
+	}
+	return {
+		name: property,
+		translate: listToString
+	};
+};

package/lib/unshorten.js

@@ -0,0 +1,109 @@
+/* eslint-disable no-prototype-builtins,no-use-before-define */
+
+'use strict';
+
+const AddressError = require( './hostIsAllowed' ).AddressError;
+const hostIsAllowed = require( './hostIsAllowed' ).hostIsAllowed;
+
+/**
+ * Follows redirects in a URL. Promise succeeds even if the url does not redirect anywhere;
+ * Fails if any url in the redirect chain is not allowed (via hostIsAllowed)
+ *
+ * @param  {string}  url        url trying to be unshortened
+ * @param  {Object}  cr         CitoidRequest object
+ * @param  {Object}  citation   citation to store the response to head requests in
+ * @return {Object}             BBPromise for url
+ */
+function unshorten( url, cr, citation ) {
+	const request = cr.request;
+	const jar = cr.jar;
+	const conf = cr.conf;
+	request.logger.log( 'debug/unshorten', `Unshortening: ${ url }` );
+
+	// Short circuit cases where unshorten is called multiple times
+	if ( url === citation.resolvedUrl ) {
+		request.logger.log( 'debug/unshorten', `Already unshortened to: ${ citation.resolvedUrl }` );
+		return Promise.resolve( citation );
+	}
+
+	const opts = {
+		followRedirect: false,
+		jar,
+		// Use HEAD to avoid wasting bandwidth in the response. We can't be *sure* a
+		// HEAD request will be handled in the same manner as a GET request; but then
+		// again, we wouldn't be sure any subsequent GET request would be handled in the
+		// same manner as a current one either, so we don't lose anything by using HEAD.
+		method: 'head',
+		uri: url
+	};
+
+	let seenRedirects = 0;
+	const maxRedirects = conf.maxRedirects || 5;
+
+	const detectRedirect = ( response ) => {
+		citation.response = response;
+		request.logger.log( 'debug/unshorten', 'detecting redirect' );
+		if ( response.headers.hasOwnProperty( 'location' ) &&
+				( opts.uri !== response.headers.location ) ) {
+			return followRedirect( response.headers.location, opts.uri );
+		}
+		if ( response.headers.hasOwnProperty( 'content-location' ) &&
+				( opts.uri !== response.headers[ 'content-location' ] ) ) {
+			return followRedirect( response.headers[ 'content-location' ], opts.uri );
+		}
+		request.logger.log( 'debug/unshorten',
+			`No more redirects detected after ${ seenRedirects } redirects, returning: ${ opts.uri }` );
+		citation.resolvedUrl = opts.uri;
+		return citation;
+	};
+
+	const followRedirect = ( redirLocation, prevUrl ) => {
+		request.logger.log( 'debug/unshorten', `Attempting to follow redirect: ${ redirLocation }` );
+		if ( seenRedirects === maxRedirects ) {
+			throw new AddressError( 'Maximum number of allowed redirects reached' );
+		}
+		seenRedirects++;
+
+		// If missing protocol, assume it's a relative path and try to assemble url
+		if ( !/^https?:\/\//i.test( redirLocation ) ) {
+			try {
+				const oldURL = new URL( prevUrl );
+				redirLocation = new URL( redirLocation, oldURL.href );
+				redirLocation = redirLocation.href;
+				request.logger.log( 'debug/unshorten', `Assembled relative redirect: ${ redirLocation }` );
+			} catch ( e ) {
+				request.logger.log( 'debug/unshorten', `Unable to assemble relative redirect: ${ e }` );
+				request.outgoingRequestError = e; // Logs at warn level later if request fails
+				throw e;
+			}
+		}
+
+		return hostIsAllowed( redirLocation, conf, request.logger )
+			.then( ( allowedUrl ) => {
+				opts.uri = allowedUrl;
+				return request.issueRequest( opts ).then( detectRedirect );
+			} ).catch( ( error ) => {
+				request.logger.log( 'debug/unshorten', `Caught at recursion: ${ error }` );
+				request.outgoingRequestError = error; // Logs at warn level later if request fails
+				throw error;
+			} );
+	};
+
+	return hostIsAllowed( url, conf, request.logger )
+		.then( ( allowedUrl ) => {
+			opts.uri = allowedUrl;
+			return request.issueRequest( opts )
+				.then( detectRedirect )
+				.catch( ( error ) => {
+					request.logger.log( 'debug/unshorten', `Caught at recursion: ${ error }` );
+					throw error;
+				} );
+		} )
+		.catch( ( error ) => {
+			request.logger.log( 'debug/unshorten', `Caught at top level${ error }` );
+			request.outgoingRequestError = error; // Log at warn level later if request fails
+			throw error;
+		} );
+}
+
+module.exports = unshorten;