@carecard/validate 3.18.0 → 3.19.0

package/lib/validate.js

@@ -1,279 +1,352 @@
 const isImageUrl = imageUrl => {
-    if (imageUrl === undefined || typeof imageUrl !== 'string' || imageUrl.length === 0 || imageUrl.length > 2048) return false;
+  if (
+    imageUrl === undefined ||
+    typeof imageUrl !== 'string' ||
+    imageUrl.length === 0 ||
+    imageUrl.length > 2048
+  ) {
+    return false;
+  }
 
-    const imageUrlRegex = /^[a-zA-Z0-9-_./]+$/;
-    return imageUrlRegex.test(imageUrl);
+  const imageUrlRegex = /^[a-zA-Z0-9-_./]+$/;
+  return imageUrlRegex.test(imageUrl);
 };
 
 const isInteger = number => {
-    return Number.isInteger(number);
+  return Number.isInteger(number);
 };
 
+// Pattern: Predicate - reports whether a bounded string contains a JSON object or array.
 const isValidJsonString = str => {
-    if (str === undefined || typeof str !== 'string' || str.length === 0 || str.length > 10000) return false;
+  if (str === undefined || typeof str !== 'string' || str.length === 0 || str.length > 10000) {
+    return false;
+  }
 
-    try {
-        const json = JSON.parse(str);
-        return typeof json === 'object' && json !== null;
-    } catch (error) {
-        if (!(error instanceof SyntaxError)) throw error;
-        return false;
-    }
+  try {
+    const json = JSON.parse(str);
+    return typeof json === 'object' && json !== null;
+  } catch {
+    return false;
+  }
 };
 
 const isValidIntegerString = str => {
-    if (str === undefined || typeof str !== 'string' || str.length === 0 || str.length > 20) return false;
-    return /^\d+$/.test(str);
+  if (str === undefined || typeof str !== 'string' || str.length === 0 || str.length > 20) {
+    return false;
+  }
+  return /^\d+$/.test(str);
 };
 
 const isValidUuidString = str => {
-    if (str === undefined || typeof str !== 'string' || str.length === 0) return false;
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    return uuidRegex.test(str);
+  if (str === undefined || typeof str !== 'string' || str.length === 0) {
+    return false;
+  }
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(str);
 };
 
 const isCcIdString = str => {
-    if (typeof str !== 'string') return false;
-    return /^[a-z0-9]{8}$/.test(str);
+  if (typeof str !== 'string') {
+    return false;
+  }
+  return /^[a-z0-9]{8}$/.test(str);
 };
 
 const isCharactersString = str => {
-    if (str === undefined || typeof str !== 'string' || str.length === 0 || str.length > 1000) return false;
-    return /^[\da-zA-Z _-]+$/.test(str);
+  if (str === undefined || typeof str !== 'string' || str.length === 0 || str.length > 1000) {
+    return false;
+  }
+  return /^[\da-zA-Z _-]+$/.test(str);
 };
 
 const isStreetString = str => {
-    if (typeof str !== 'string' || str.trim().length === 0 || str.length > 1000) {
-        return false;
-    }
-    const value = str.trim();
-    const streetRegex = /^(?![,_-])[0-9a-zA-Z\s,./#-]+$/;
-    return streetRegex.test(value);
+  if (typeof str !== 'string' || str.trim().length === 0 || str.length > 1000) {
+    return false;
+  }
+  const value = str.trim();
+  const streetRegex = /^(?![,_-])[0-9a-zA-Z\s,./#-]+$/;
+  return streetRegex.test(value);
 };
 
 const isNameString = str => {
-    if (typeof str !== 'string' || str.length === 0 || str.length > 1000) {
-        return false;
-    }
-    return /^[A-Za-z][0-9a-zA-Z-_.,'() ]+$/.test(str.trim());
+  if (typeof str !== 'string' || str.length === 0 || str.length > 1000) {
+    return false;
+  }
+  return /^[A-Za-z][0-9a-zA-Z-_.,'() ]+$/.test(str.trim());
 };
 
 const isSafeSearchString = str => {
-    if (typeof str !== 'string' || str.length === 0) return false;
-    return /^[A-Za-z][0-9a-zA-Z\-_.,'()@ ]{1,100}$/.test(str.trim());
+  if (typeof str !== 'string' || str.length === 0) {
+    return false;
+  }
+  return /^[A-Za-z][0-9a-zA-Z\-_.,'()@ ]{1,100}$/.test(str.trim());
 };
 
 const isEmailString = email => {
-    if (typeof email !== 'string' || email.length === 0 || email.length > 320) {
-        return false;
-    }
-    // Simplified safe email regex
-    const regExpEmail =
-        /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-zA-Z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/;
-    return regExpEmail.test(email);
+  if (typeof email !== 'string' || email.length === 0 || email.length > 320) {
+    return false;
+  }
+  // Simplified safe email regex
+  const regExpEmail =
+    /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-zA-Z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/;
+  return regExpEmail.test(email);
 };
 
 const isJwtString = jwt => {
-    if (typeof jwt !== 'string' || jwt.length === 0 || jwt.length > 8192 || jwt.trim() === '') return false;
-    const jwtRegex = /^eyJ[a-zA-Z0-9-_.]+$/;
-    return jwtRegex.test(jwt);
+  if (typeof jwt !== 'string' || jwt.length === 0 || jwt.length > 8192 || jwt.trim() === '') {
+    return false;
+  }
+  const jwtRegex = /^eyJ[a-zA-Z0-9-_.]+$/;
+  return jwtRegex.test(jwt);
 };
 
 const isPasswordString = password => {
-    if (typeof password !== 'string' || password.length === 0 || password.length > 128) return false;
-    const regExPassword = /^(?=.*[a-zA-Z0-9])(?=.*[!@#$%^&*_-])[a-zA-Z0-9!@#$%^&*_-]{6,32}$/;
-    return regExPassword.test(String(password));
+  if (typeof password !== 'string' || password.length === 0 || password.length > 128) {
+    return false;
+  }
+  const regExPassword = /^(?=.*[a-zA-Z0-9])(?=.*[!@#$%^&*_-])[a-zA-Z0-9!@#$%^&*_-]{6,32}$/;
+  return regExPassword.test(String(password));
 };
 
 const isSimplePasswordString = password => {
-    if (typeof password !== 'string' || password.length === 0 || password.length > 128) return false;
-    const regExPassword = /^[a-zA-Z0-9!@#$%^&*_-]{6,32}$/;
-    return regExPassword.test(String(password));
+  if (typeof password !== 'string' || password.length === 0 || password.length > 128) {
+    return false;
+  }
+  const regExPassword = /^[a-zA-Z0-9!@#$%^&*_-]{6,32}$/;
+  return regExPassword.test(String(password));
 };
 
 const isPasswordStringFailureMessage = password => {
-    if (!isPasswordString(password)) {
-        return 'Total 6 to 32 characters, numbers and one of !@#$%^&*_-';
-    } else {
-        return null;
-    }
+  if (!isPasswordString(password)) {
+    return 'Total 6 to 32 characters, numbers and one of !@#$%^&*_-';
+  } else {
+    return null;
+  }
 };
 
 const isSimplePasswordStringFailureMessage = password => {
-    if (!isSimplePasswordString(password)) {
-        return 'Total 6 to 32 characters, numbers or !@#$%^&*_-';
-    } else {
-        return null;
-    }
+  if (!isSimplePasswordString(password)) {
+    return 'Total 6 to 32 characters, numbers or !@#$%^&*_-';
+  } else {
+    return null;
+  }
 };
 
 const isUsernameString = str => {
-    if (typeof str !== 'string' || str.length === 0 || str.length > 200) return false;
-    return /^[0-9a-zA-Z]+$/.test(str);
+  if (typeof str !== 'string' || str.length === 0 || str.length > 200) {
+    return false;
+  }
+  return /^[0-9a-zA-Z]+$/.test(str);
 };
 
 function isPhoneNumber(str) {
-    if (typeof str !== 'string' || str.length === 0 || str.length > 20) return false;
-    return /^\(?([0-9]{3})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/.test(str);
+  if (typeof str !== 'string' || str.length === 0 || str.length > 20) {
+    return false;
+  }
+  return /^\(?([0-9]{3})\)?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$/.test(str);
 }
 
 const isUrlSafeString = inputString => {
-    if (typeof inputString !== 'string' || inputString.length === 0 || inputString.length > 2048 || inputString.trim() === '') return false;
-    const urlSafeRegex = /^[a-zA-Z0-9-_.]+$/;
-    return urlSafeRegex.test(inputString);
+  if (
+    typeof inputString !== 'string' ||
+    inputString.length === 0 ||
+    inputString.length > 2048 ||
+    inputString.trim() === ''
+  ) {
+    return false;
+  }
+  const urlSafeRegex = /^[a-zA-Z0-9-_.]+$/;
+  return urlSafeRegex.test(inputString);
 };
 
 const isString6To24CharacterLong = password => {
-    if (typeof password !== 'string' || password.length === 0) return false;
-    return 6 <= password.length && password.length <= 24;
+  if (typeof password !== 'string' || password.length === 0) {
+    return false;
+  }
+  return 6 <= password.length && password.length <= 24;
 };
 
 const isString6To16CharacterLong = password => {
-    if (typeof password !== 'string' || password.length === 0) return false;
-    return 6 <= password.length && password.length <= 16;
+  if (typeof password !== 'string' || password.length === 0) {
+    return false;
+  }
+  return 6 <= password.length && password.length <= 16;
 };
 
 const isProvinceString = inputString => {
-    const provinces = ['on', 'qc'];
+  const provinces = ['on', 'qc'];
 
-    if (isNameString(inputString)) {
-        return provinces.includes(inputString.toLowerCase().trim());
-    }
+  if (isNameString(inputString)) {
+    return provinces.includes(inputString.toLowerCase().trim());
+  }
 
-    return false;
+  return false;
 };
 
 const isBoolValue = inputValue => {
-    return typeof inputValue === 'boolean' || inputValue === 'true' || inputValue === 'false';
+  return typeof inputValue === 'boolean' || inputValue === 'true' || inputValue === 'false';
 };
 
 const isPostalCodeString = inputString => {
-    const postalCodeRegex = /^(?!.*[DFIOQU])[A-VXY][0-9][A-Z] ?[0-9][A-Z][0-9]$/i;
+  const postalCodeRegex = /^(?!.*[DFIOQU])[A-VXY][0-9][A-Z] ?[0-9][A-Z][0-9]$/i;
 
-    if (isNameString(inputString)) {
-        return postalCodeRegex.test(inputString.trim());
-    }
+  if (isNameString(inputString)) {
+    return postalCodeRegex.test(inputString.trim());
+  }
 
-    return false;
+  return false;
 };
 
 const isSafeString = str => {
-    if (typeof str !== 'string' || str.length === 0 || str.length > 10000) return false;
-    return /^[\da-zA-Z-_.,#*'()[\]: ]+$/.test(str);
+  if (typeof str !== 'string' || str.length === 0 || str.length > 10000) {
+    return false;
+  }
+  return /^[\da-zA-Z-_.,#*'()[\]: ]+$/.test(str);
 };
 
 const isTextString = str => {
-    return typeof str === 'string' && str.length > 0 && str.length <= 10000;
+  return typeof str === 'string' && str.length > 0 && str.length <= 10000;
 };
 
 const isInStringArray = (StringArray, inputString) => {
-    if (isNameString(inputString)) {
-        return StringArray.includes(inputString.toLowerCase().trim());
-    }
+  if (isNameString(inputString)) {
+    return StringArray.includes(inputString.toLowerCase().trim());
+  }
 
-    return false;
+  return false;
 };
 
 const isUserRoleRequestStatusString = inputString => {
-    const statuses = ['pending', 'approved', 'rejected', 'cancelled', 'expired', 'hidden', 'on_hold', 'in_progress', 'info_needed'];
-    return isInStringArray(statuses, inputString);
+  const statuses = [
+    'pending',
+    'approved',
+    'rejected',
+    'cancelled',
+    'expired',
+    'hidden',
+    'on_hold',
+    'in_progress',
+    'info_needed',
+  ];
+  return isInStringArray(statuses, inputString);
 };
 
 const isUserRoleRequestRoleString = inputString => {
-    const roles = ['student', 'intern', 'volunteer'];
-    return typeof inputString === 'string' && roles.includes(inputString.trim().toLowerCase());
+  const roles = ['student', 'intern', 'volunteer'];
+  return typeof inputString === 'string' && roles.includes(inputString.trim().toLowerCase());
 };
 
 const isCountryCodeString = str => {
-    if (typeof str !== 'string' || str.length === 0 || str.length > 4) return false;
+  if (typeof str !== 'string' || str.length === 0 || str.length > 4) {
+    return false;
+  }
 
-    const countryCodeRegex = /^\+[1-9][0-9]{0,2}$/;
+  const countryCodeRegex = /^\+[1-9][0-9]{0,2}$/;
 
-    return countryCodeRegex.test(str);
+  return countryCodeRegex.test(str);
 };
 
 const isValidDomainName = domain => {
-    if (typeof domain !== 'string' || domain.length === 0 || domain.length > 253) return false;
+  if (typeof domain !== 'string' || domain.length === 0 || domain.length > 253) {
+    return false;
+  }
 
-    const domainRegex = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i;
-    return domainRegex.test(domain);
+  const domainRegex =
+    /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i;
+  return domainRegex.test(domain);
 };
 
 const isValidTimestampzString = str => {
-    if (typeof str !== 'string' || str.length === 0 || str.length > 64) return false;
-    // ISO 8601 for UTC or with Offset: 2023-10-27T10:00:00Z or 2023-10-27T10:00:00+02:00
-    const timestampzRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
-    return timestampzRegex.test(str) && !isNaN(Date.parse(str));
+  if (typeof str !== 'string' || str.length === 0 || str.length > 64) {
+    return false;
+  }
+  // ISO 8601 for UTC or with Offset: 2023-10-27T10:00:00Z or 2023-10-27T10:00:00+02:00
+  const timestampzRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+  return timestampzRegex.test(str) && !isNaN(Date.parse(str));
 };
 
 const isValidTimestampString = str => {
-    if (typeof str !== 'string' || str.length === 0 || str.length > 64) return false;
-    // ISO 8601 without time zone: 2023-10-27T10:00:00 or 2023-10-27T10:00:00.123
-    const timestampRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?$/;
-    return timestampRegex.test(str) && !isNaN(Date.parse(str));
+  if (typeof str !== 'string' || str.length === 0 || str.length > 64) {
+    return false;
+  }
+  // ISO 8601 without time zone: 2023-10-27T10:00:00 or 2023-10-27T10:00:00.123
+  const timestampRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?$/;
+  return timestampRegex.test(str) && !isNaN(Date.parse(str));
 };
 
 const isValidDateString = str => {
-    if (typeof str !== 'string' || str.length === 0 || str.length > 10) return false;
+  if (typeof str !== 'string' || str.length === 0 || str.length > 10) {
+    return false;
+  }
 
-    const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
-    const match = str.match(dateRegex);
-    if (!match) return false;
+  const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
+  const match = str.match(dateRegex);
+  if (!match) {
+    return false;
+  }
 
-    const year = Number(match[1]);
-    const month = Number(match[2]);
-    const day = Number(match[3]);
-    const date = new Date(Date.UTC(year, month - 1, day));
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const date = new Date(Date.UTC(year, month - 1, day));
 
-    return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+  return (
+    date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day
+  );
 };
 
 const isValidUrl = url => {
-    if (typeof url !== 'string' || url.length === 0 || url.length > 2048) return false;
-    if (!URL.canParse(url)) return false;
+  if (typeof url !== 'string' || url.length === 0 || url.length > 2048) {
+    return false;
+  }
+  if (!URL.canParse(url)) {
+    return false;
+  }
 
-    const parsedUrl = new URL(url);
-    return parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:';
+  const parsedUrl = new URL(url);
+  return parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:';
 };
 const isValidArrayOfStrings = arr => {
-    if (!Array.isArray(arr)) return false;
-    return arr.every(isSafeString);
+  if (!Array.isArray(arr)) {
+    return false;
+  }
+  return arr.every(isSafeString);
 };
 module.exports = {
-    isImageUrl,
-    isInteger,
-    isValidJsonString,
-    isValidIntegerString,
-    isValidUuidString,
-    isCcIdString,
-    isCharactersString,
-    isStreetString,
-    isNameString,
-    isSafeSearchString,
-    isEmailString,
-    isJwtString,
-    isPasswordString,
-    isSimplePasswordString,
-    isPasswordStringFailureMessage,
-    isSimplePasswordStringFailureMessage,
-    isUsernameString,
-    isPhoneNumber,
-    isUrlSafeString,
-    isString6To24CharacterLong,
-    isString6To16CharacterLong,
-    isProvinceString,
-    isBoolValue,
-    isPostalCodeString,
-    isSafeString,
-    isTextString,
-    isInStringArray,
-    isUserRoleRequestStatusString,
-    isUserRoleRequestRoleString,
-    isCountryCodeString,
-    isValidDomainName,
-    isValidTimestampzString,
-    isValidTimestampString,
-    isValidDateString,
-    isValidUrl,
-    isValidArrayOfStrings,
+  isImageUrl,
+  isInteger,
+  isValidJsonString,
+  isValidIntegerString,
+  isValidUuidString,
+  isCcIdString,
+  isCharactersString,
+  isStreetString,
+  isNameString,
+  isSafeSearchString,
+  isEmailString,
+  isJwtString,
+  isPasswordString,
+  isSimplePasswordString,
+  isPasswordStringFailureMessage,
+  isSimplePasswordStringFailureMessage,
+  isUsernameString,
+  isPhoneNumber,
+  isUrlSafeString,
+  isString6To24CharacterLong,
+  isString6To16CharacterLong,
+  isProvinceString,
+  isBoolValue,
+  isPostalCodeString,
+  isSafeString,
+  isTextString,
+  isInStringArray,
+  isUserRoleRequestStatusString,
+  isUserRoleRequestRoleString,
+  isCountryCodeString,
+  isValidDomainName,
+  isValidTimestampzString,
+  isValidTimestampString,
+  isValidDateString,
+  isValidUrl,
+  isValidArrayOfStrings,
 };

package/lib/validateNewUserRoleRequest.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-    error: { throwBadInputError },
+  error: { throwBadInputError },
 } = require('@carecard/common-util');
 const { isUserRoleRequestRoleString } = require('./validate');
 
@@ -9,79 +9,87 @@ const DEFAULT_USER_ROLE_REQUEST_ROLE = 'student';
 const REQUIRE_SCOPE_WHEN_ROLE_OR_SCOPE_PRESENT = 'whenRoleOrScopePresent';
 
 function validateNewUserRoleRequestObject(roleRequest = {}, options = {}) {
-    const normalized = normalizeNewUserRoleRequestObject(roleRequest);
-    const defaultRole = Object.prototype.hasOwnProperty.call(options, 'defaultRole') ? options.defaultRole : DEFAULT_USER_ROLE_REQUEST_ROLE;
-    const requireScope = Object.prototype.hasOwnProperty.call(options, 'requireScope') ? options.requireScope : true;
-
-    if (normalized.role_name === undefined && defaultRole !== undefined) {
-        normalized.role_name = defaultRole;
-    }
-
-    if (normalized.role_name !== undefined && !isUserRoleRequestRoleString(normalized.role_name)) {
-        throwBadInputError({
-            userMessage: 'Invalid property: role.role',
-            details: { role: 'Role requests are limited to student, intern, or volunteer' },
-        });
-    }
-
-    if (shouldRequireScope(normalized, requireScope)) {
-        requireNewUserRoleRequestScope(normalized);
-    }
-
-    return normalized;
+  const normalized = normalizeNewUserRoleRequestObject(roleRequest);
+  const defaultRole = Object.prototype.hasOwnProperty.call(options, 'defaultRole')
+    ? options.defaultRole
+    : DEFAULT_USER_ROLE_REQUEST_ROLE;
+  const requireScope = Object.prototype.hasOwnProperty.call(options, 'requireScope')
+    ? options.requireScope
+    : true;
+
+  if (normalized.role_name === undefined && defaultRole !== undefined) {
+    normalized.role_name = defaultRole;
+  }
+
+  if (normalized.role_name !== undefined && !isUserRoleRequestRoleString(normalized.role_name)) {
+    throwBadInputError({
+      userMessage: 'Invalid property: role.role',
+      details: { role: 'Role requests are limited to student, intern, or volunteer' },
+    });
+  }
+
+  if (shouldRequireScope(normalized, requireScope)) {
+    requireNewUserRoleRequestScope(normalized);
+  }
+
+  return normalized;
 }
 
 function normalizeNewUserRoleRequestObject(roleRequest) {
-    const normalized = { ...roleRequest };
-
-    assignAlias(normalized, 'role_name', 'roleName');
-    assignAlias(normalized, 'role_name', 'role');
-    assignAlias(normalized, 'institution_id', 'institutionId');
-    assignAlias(normalized, 'campus_id', 'campusId');
-    assignAlias(normalized, 'program_id', 'programId');
-    assignAlias(normalized, 'program_term_id', 'programTermId');
-
-    delete normalized.roleName;
-    delete normalized.role;
-    delete normalized.institutionId;
-    delete normalized.campusId;
-    delete normalized.programId;
-    delete normalized.programTermId;
-
-    return normalized;
+  const normalized = { ...roleRequest };
+
+  assignAlias(normalized, 'role_name', 'roleName');
+  assignAlias(normalized, 'role_name', 'role');
+  assignAlias(normalized, 'institution_id', 'institutionId');
+  assignAlias(normalized, 'campus_id', 'campusId');
+  assignAlias(normalized, 'program_id', 'programId');
+  assignAlias(normalized, 'program_term_id', 'programTermId');
+
+  delete normalized.roleName;
+  delete normalized.role;
+  delete normalized.institutionId;
+  delete normalized.campusId;
+  delete normalized.programId;
+  delete normalized.programTermId;
+
+  return normalized;
 }
 
 function assignAlias(target, canonicalKey, aliasKey) {
-    if (target[canonicalKey] === undefined && target[aliasKey] !== undefined) {
-        target[canonicalKey] = target[aliasKey];
-    }
+  if (target[canonicalKey] === undefined && target[aliasKey] !== undefined) {
+    target[canonicalKey] = target[aliasKey];
+  }
 }
 
 function shouldRequireScope(roleRequest, requireScope) {
-    if (requireScope === true) return true;
-    if (requireScope !== REQUIRE_SCOPE_WHEN_ROLE_OR_SCOPE_PRESENT) return false;
-
-    return (
-        roleRequest.role_name !== undefined ||
-        roleRequest.institution_id !== undefined ||
-        roleRequest.campus_id !== undefined ||
-        roleRequest.program_id !== undefined ||
-        roleRequest.program_term_id !== undefined
-    );
+  if (requireScope === true) {
+    return true;
+  }
+  if (requireScope !== REQUIRE_SCOPE_WHEN_ROLE_OR_SCOPE_PRESENT) {
+    return false;
+  }
+
+  return (
+    roleRequest.role_name !== undefined ||
+    roleRequest.institution_id !== undefined ||
+    roleRequest.campus_id !== undefined ||
+    roleRequest.program_id !== undefined ||
+    roleRequest.program_term_id !== undefined
+  );
 }
 
 function requireNewUserRoleRequestScope(roleRequest) {
-    if (!roleRequest.institution_id) {
-        throwBadInputError({ userMessage: 'Missing property: role.institutionId' });
-    }
+  if (!roleRequest.institution_id) {
+    throwBadInputError({ userMessage: 'Missing property: role.institutionId' });
+  }
 
-    if (!roleRequest.campus_id) {
-        throwBadInputError({ userMessage: 'Missing property: role.campusId' });
-    }
+  if (!roleRequest.campus_id) {
+    throwBadInputError({ userMessage: 'Missing property: role.campusId' });
+  }
 }
 
 module.exports = {
-    DEFAULT_USER_ROLE_REQUEST_ROLE,
-    REQUIRE_SCOPE_WHEN_ROLE_OR_SCOPE_PRESENT,
-    validateNewUserRoleRequestObject,
+  DEFAULT_USER_ROLE_REQUEST_ROLE,
+  REQUIRE_SCOPE_WHEN_ROLE_OR_SCOPE_PRESENT,
+  validateNewUserRoleRequestObject,
 };