@logto/connector-github 1.2.0 → 1.3.0

package/lib/index.js

@@ -27,19 +27,15 @@ const notFalsy = (value) => Boolean(value);
  */
 const conditional = (exp) => (notFalsy(exp) ? exp : undefined);
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var token = '%[a-f0-9]{2}';
-var singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');
-var multiMatcher = new RegExp('(' + token + ')+', 'gi');
+const token = '%[a-f0-9]{2}';
+const singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');
+const multiMatcher = new RegExp('(' + token + ')+', 'gi');
 
 function decodeComponents(components, split) {
 	try {
 		// Try to decode the entire string first
 		return [decodeURIComponent(components.join(''))];
-	} catch (err) {
+	} catch {
 		// Do nothing
 	}
 
@@ -50,8 +46,8 @@ function decodeComponents(components, split) {
 	split = split || 1;
 
 	// Split the array in 2 parts
-	var left = components.slice(0, split);
-	var right = components.slice(split);
+	const left = components.slice(0, split);
+	const right = components.slice(split);
 
 	return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
 }
@@ -59,10 +55,10 @@ function decodeComponents(components, split) {
 function decode$1(input) {
 	try {
 		return decodeURIComponent(input);
-	} catch (err) {
-		var tokens = input.match(singleMatcher) || [];
+	} catch {
+		let tokens = input.match(singleMatcher) || [];
 
-		for (var i = 1; i < tokens.length; i++) {
+		for (let i = 1; i < tokens.length; i++) {
 			input = decodeComponents(tokens, i).join('');
 
 			tokens = input.match(singleMatcher) || [];
@@ -74,18 +70,18 @@ function decode$1(input) {
 
 function customDecodeURIComponent(input) {
 	// Keep track of all the replacements and prefill the map with the `BOM`
-	var replaceMap = {
+	const replaceMap = {
 		'%FE%FF': '\uFFFD\uFFFD',
-		'%FF%FE': '\uFFFD\uFFFD'
+		'%FF%FE': '\uFFFD\uFFFD',
 	};
 
-	var match = multiMatcher.exec(input);
+	let match = multiMatcher.exec(input);
 	while (match) {
 		try {
 			// Decode as big chunks as possible
 			replaceMap[match[0]] = decodeURIComponent(match[0]);
-		} catch (err) {
-			var result = decode$1(match[0]);
+		} catch {
+			const result = decode$1(match[0]);
 
 			if (result !== match[0]) {
 				replaceMap[match[0]] = result;
@@ -98,57 +94,211 @@ function customDecodeURIComponent(input) {
 	// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
 	replaceMap['%C2'] = '\uFFFD';
 
-	var entries = Object.keys(replaceMap);
+	const entries = Object.keys(replaceMap);
 
-	for (var i = 0; i < entries.length; i++) {
+	for (const key of entries) {
 		// Replace all decoded components
-		var key = entries[i];
 		input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
 	}
 
 	return input;
 }
 
-var decodeUriComponent = function (encodedURI) {
+function decodeUriComponent(encodedURI) {
 	if (typeof encodedURI !== 'string') {
 		throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
 	}
 
 	try {
-		encodedURI = encodedURI.replace(/\+/g, ' ');
-
 		// Try the built in decoder first
 		return decodeURIComponent(encodedURI);
-	} catch (err) {
+	} catch {
 		// Fallback to a more advanced decoder
 		return customDecodeURIComponent(encodedURI);
 	}
-};
-
-var decodeComponent = /*@__PURE__*/getDefaultExportFromCjs(decodeUriComponent);
+}
 
-var splitOnFirst = (string, separator) => {
+function splitOnFirst(string, separator) {
 	if (!(typeof string === 'string' && typeof separator === 'string')) {
 		throw new TypeError('Expected the arguments to be of type `string`');
 	}
 
-	if (separator === '') {
-		return [string];
+	if (string === '' || separator === '') {
+		return [];
 	}
 
 	const separatorIndex = string.indexOf(separator);
 
 	if (separatorIndex === -1) {
-		return [string];
+		return [];
 	}
 
 	return [
 		string.slice(0, separatorIndex),
 		string.slice(separatorIndex + separator.length)
 	];
-};
+}
+
+function includeKeys(object, predicate) {
+	const result = {};
+
+	if (Array.isArray(predicate)) {
+		for (const key of predicate) {
+			const descriptor = Object.getOwnPropertyDescriptor(object, key);
+			if (descriptor?.enumerable) {
+				Object.defineProperty(result, key, descriptor);
+			}
+		}
+	} else {
+		// `Reflect.ownKeys()` is required to retrieve symbol properties
+		for (const key of Reflect.ownKeys(object)) {
+			const descriptor = Object.getOwnPropertyDescriptor(object, key);
+			if (descriptor.enumerable) {
+				const value = object[key];
+				if (predicate(key, value, object)) {
+					Object.defineProperty(result, key, descriptor);
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+const isNullOrUndefined = value => value === null || value === undefined;
+
+// eslint-disable-next-line unicorn/prefer-code-point
+const strictUriEncode = string => encodeURIComponent(string).replaceAll(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
 
-var splitOnFirst$1 = /*@__PURE__*/getDefaultExportFromCjs(splitOnFirst);
+const encodeFragmentIdentifier = Symbol('encodeFragmentIdentifier');
+
+function encoderForArrayFormat(options) {
+	switch (options.arrayFormat) {
+		case 'index': {
+			return key => (result, value) => {
+				const index = result.length;
+
+				if (
+					value === undefined
+					|| (options.skipNull && value === null)
+					|| (options.skipEmptyString && value === '')
+				) {
+					return result;
+				}
+
+				if (value === null) {
+					return [
+						...result, [encode(key, options), '[', index, ']'].join(''),
+					];
+				}
+
+				return [
+					...result,
+					[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join(''),
+				];
+			};
+		}
+
+		case 'bracket': {
+			return key => (result, value) => {
+				if (
+					value === undefined
+					|| (options.skipNull && value === null)
+					|| (options.skipEmptyString && value === '')
+				) {
+					return result;
+				}
+
+				if (value === null) {
+					return [
+						...result,
+						[encode(key, options), '[]'].join(''),
+					];
+				}
+
+				return [
+					...result,
+					[encode(key, options), '[]=', encode(value, options)].join(''),
+				];
+			};
+		}
+
+		case 'colon-list-separator': {
+			return key => (result, value) => {
+				if (
+					value === undefined
+					|| (options.skipNull && value === null)
+					|| (options.skipEmptyString && value === '')
+				) {
+					return result;
+				}
+
+				if (value === null) {
+					return [
+						...result,
+						[encode(key, options), ':list='].join(''),
+					];
+				}
+
+				return [
+					...result,
+					[encode(key, options), ':list=', encode(value, options)].join(''),
+				];
+			};
+		}
+
+		case 'comma':
+		case 'separator':
+		case 'bracket-separator': {
+			const keyValueSeparator = options.arrayFormat === 'bracket-separator'
+				? '[]='
+				: '=';
+
+			return key => (result, value) => {
+				if (
+					value === undefined
+					|| (options.skipNull && value === null)
+					|| (options.skipEmptyString && value === '')
+				) {
+					return result;
+				}
+
+				// Translate null to an empty string so that it doesn't serialize as 'null'
+				value = value === null ? '' : value;
+
+				if (result.length === 0) {
+					return [[encode(key, options), keyValueSeparator, encode(value, options)].join('')];
+				}
+
+				return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+			};
+		}
+
+		default: {
+			return key => (result, value) => {
+				if (
+					value === undefined
+					|| (options.skipNull && value === null)
+					|| (options.skipEmptyString && value === '')
+				) {
+					return result;
+				}
+
+				if (value === null) {
+					return [
+						...result,
+						encode(key, options),
+					];
+				}
+
+				return [
+					...result,
+					[encode(key, options), '=', encode(value, options)].join(''),
+				];
+			};
+		}
+	}
+}
 
 function parserForArrayFormat(options) {
 	let result;
@@ -264,9 +414,17 @@ function validateArrayFormatSeparator(value) {
 	}
 }
 
+function encode(value, options) {
+	if (options.encode) {
+		return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
+	}
+
+	return value;
+}
+
 function decode(value, options) {
 	if (options.decode) {
-		return decodeComponent(value);
+		return decodeUriComponent(value);
 	}
 
 	return value;
@@ -286,6 +444,25 @@ function keysSorter(input) {
 	return input;
 }
 
+function removeHash(input) {
+	const hashStart = input.indexOf('#');
+	if (hashStart !== -1) {
+		input = input.slice(0, hashStart);
+	}
+
+	return input;
+}
+
+function getHash(url) {
+	let hash = '';
+	const hashStart = url.indexOf('#');
+	if (hashStart !== -1) {
+		hash = url.slice(hashStart);
+	}
+
+	return hash;
+}
+
 function parseValue(value, options) {
 	if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {
 		value = Number(value);
@@ -296,6 +473,16 @@ function parseValue(value, options) {
 	return value;
 }
 
+function extract(input) {
+	input = removeHash(input);
+	const queryStart = input.indexOf('?');
+	if (queryStart === -1) {
+		return '';
+	}
+
+	return input.slice(queryStart + 1);
+}
+
 function parse(query, options) {
 	options = {
 		decode: true,
@@ -329,7 +516,13 @@ function parse(query, options) {
 			continue;
 		}
 
-		let [key, value] = splitOnFirst$1(options.decode ? parameter.replace(/\+/g, ' ') : parameter, '=');
+		const parameter_ = options.decode ? parameter.replaceAll('+', ' ') : parameter;
+
+		let [key, value] = splitOnFirst(parameter_, '=');
+
+		if (key === undefined) {
+			key = parameter_;
+		}
 
 		// Missing `=` should be `null`:
 		// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
@@ -355,17 +548,153 @@ function parse(query, options) {
 	// eslint-disable-next-line unicorn/no-array-reduce
 	return (options.sort === true ? Object.keys(returnValue).sort() : Object.keys(returnValue).sort(options.sort)).reduce((result, key) => {
 		const value = returnValue[key];
-		if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
-			// Sort object keys, not values
-			result[key] = keysSorter(value);
-		} else {
-			result[key] = value;
-		}
-
+		result[key] = Boolean(value) && typeof value === 'object' && !Array.isArray(value) ? keysSorter(value) : value;
 		return result;
 	}, Object.create(null));
 }
 
+function stringify(object, options) {
+	if (!object) {
+		return '';
+	}
+
+	options = {
+		encode: true,
+		strict: true,
+		arrayFormat: 'none',
+		arrayFormatSeparator: ',',
+		...options,
+	};
+
+	validateArrayFormatSeparator(options.arrayFormatSeparator);
+
+	const shouldFilter = key => (
+		(options.skipNull && isNullOrUndefined(object[key]))
+		|| (options.skipEmptyString && object[key] === '')
+	);
+
+	const formatter = encoderForArrayFormat(options);
+
+	const objectCopy = {};
+
+	for (const [key, value] of Object.entries(object)) {
+		if (!shouldFilter(key)) {
+			objectCopy[key] = value;
+		}
+	}
+
+	const keys = Object.keys(objectCopy);
+
+	if (options.sort !== false) {
+		keys.sort(options.sort);
+	}
+
+	return keys.map(key => {
+		const value = object[key];
+
+		if (value === undefined) {
+			return '';
+		}
+
+		if (value === null) {
+			return encode(key, options);
+		}
+
+		if (Array.isArray(value)) {
+			if (value.length === 0 && options.arrayFormat === 'bracket-separator') {
+				return encode(key, options) + '[]';
+			}
+
+			return value
+				.reduce(formatter(key), [])
+				.join('&');
+		}
+
+		return encode(key, options) + '=' + encode(value, options);
+	}).filter(x => x.length > 0).join('&');
+}
+
+function parseUrl(url, options) {
+	options = {
+		decode: true,
+		...options,
+	};
+
+	let [url_, hash] = splitOnFirst(url, '#');
+
+	if (url_ === undefined) {
+		url_ = url;
+	}
+
+	return {
+		url: url_?.split('?')?.[0] ?? '',
+		query: parse(extract(url), options),
+		...(options && options.parseFragmentIdentifier && hash ? {fragmentIdentifier: decode(hash, options)} : {}),
+	};
+}
+
+function stringifyUrl(object, options) {
+	options = {
+		encode: true,
+		strict: true,
+		[encodeFragmentIdentifier]: true,
+		...options,
+	};
+
+	const url = removeHash(object.url).split('?')[0] || '';
+	const queryFromUrl = extract(object.url);
+
+	const query = {
+		...parse(queryFromUrl, {sort: false}),
+		...object.query,
+	};
+
+	let queryString = stringify(query, options);
+	queryString &&= `?${queryString}`;
+
+	let hash = getHash(object.url);
+	if (typeof object.fragmentIdentifier === 'string') {
+		const urlObjectForFragmentEncode = new URL(url);
+		urlObjectForFragmentEncode.hash = object.fragmentIdentifier;
+		hash = options[encodeFragmentIdentifier] ? urlObjectForFragmentEncode.hash : `#${object.fragmentIdentifier}`;
+	}
+
+	return `${url}${queryString}${hash}`;
+}
+
+function pick(input, filter, options) {
+	options = {
+		parseFragmentIdentifier: true,
+		[encodeFragmentIdentifier]: false,
+		...options,
+	};
+
+	const {url, query, fragmentIdentifier} = parseUrl(input, options);
+
+	return stringifyUrl({
+		url,
+		query: includeKeys(query, filter),
+		fragmentIdentifier,
+	}, options);
+}
+
+function exclude(input, filter, options) {
+	const exclusionFilter = Array.isArray(filter) ? key => !filter.includes(key) : (key, value) => !filter(key, value);
+
+	return pick(input, exclusionFilter, options);
+}
+
+var queryString = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    exclude: exclude,
+    extract: extract,
+    parse: parse,
+    parseUrl: parseUrl,
+    pick: pick,
+    stringify: stringify,
+    stringifyUrl: stringifyUrl
+});
+
 const authorizationEndpoint = 'https://github.com/login/oauth/authorize';
 const scope = 'read:user';
 const accessTokenEndpoint = 'https://github.com/login/oauth/access_token';
@@ -481,7 +810,7 @@ const getAccessToken = async (config, codeObject) => {
         },
         timeout: { request: defaultTimeout },
     });
-    const result = accessTokenResponseGuard.safeParse(parse(httpResponse.body));
+    const result = accessTokenResponseGuard.safeParse(queryString.parse(httpResponse.body));
     if (!result.success) {
         throw new ConnectorError(ConnectorErrorCodes.InvalidResponse, result.error);
     }
@@ -501,7 +830,8 @@ const getUserInfo = (getConfig) => async (data) => {
             },
             timeout: { request: defaultTimeout },
         });
-        const result = userInfoResponseGuard.safeParse(parseJson(httpResponse.body));
+        const rawData = parseJson(httpResponse.body);
+        const result = userInfoResponseGuard.safeParse(rawData);
         if (!result.success) {
             throw new ConnectorError(ConnectorErrorCodes.InvalidResponse, result.error);
         }
@@ -511,6 +841,7 @@ const getUserInfo = (getConfig) => async (data) => {
             avatar: conditional(avatar),
             email: conditional(email),
             name: conditional(name),
+            rawData,
         };
     }
     catch (error) {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@logto/connector-github",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Github web connector implementation.",
   "author": "Silverhand Inc. <contact@silverhand.io>",
   "dependencies": {
-    "@logto/connector-kit": "^2.1.0",
-    "query-string": "^8.0.0"
+    "@logto/connector-kit": "^3.0.0",
+    "query-string": "^9.0.0"
   },
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -44,8 +44,7 @@
     "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput --incremental",
     "lint": "eslint --ext .ts src",
     "lint:report": "pnpm lint --format json --output-file report.json",
-    "test:only": "NODE_OPTIONS=--experimental-vm-modules jest",
-    "test": "pnpm build:test && pnpm test:only",
-    "test:ci": "pnpm test:only --silent --coverage"
+    "test": "vitest src",
+    "test:ci": "pnpm run test --silent --coverage"
   }
 }