@getjones/test-infra 1.2.4 → 1.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getjones/test-infra",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "Providing internal and openapi interface",
   "main": "src/index.js",
   "scripts": {

package/src/common/requests/apiKeyAuth/requests.js

@@ -0,0 +1,38 @@
+const requestHandler = require('./../requestHandlers');
+
+const getRequestHandler = (url, apiKey, params = {}, headers = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.getRequestHandler(url, headers, params);
+};
+
+const postRequestHandler = (url, apiKey, body, headers = {}, params = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.postRequestHandler(url, body, headers, params);
+};
+
+const putRequestHandler = (url, apiKey, body, headers = {}, params = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.putRequestHandler(url, body, headers, params);
+};
+
+const patchRequestHandler = (url, apiKey, body, headers = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.patchRequestHandler(url, body, headers);
+};
+
+const deleteRequestHandler = (url, apiKey, headers = {}, params = {}, data = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.deleteRequestHandler(url, headers, params, data);
+};
+
+const enrichApiKey = (headers, apiKey) => {
+	headers['x-api-key'] = apiKey;
+};
+
+module.exports = {
+	getRequestHandler,
+	postRequestHandler,
+	putRequestHandler,
+	patchRequestHandler,
+	deleteRequestHandler
+};

package/src/common/requests/cookieAuth/requests.js

@@ -0,0 +1,40 @@
+const requestHandler = require('./../requestHandlers');
+
+const getRequestHandler = (url, params = {}, context = null, headers = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.getRequestHandler(url, headers, params);
+};
+
+const postRequestHandler = (url, body, context = null, headers = {}, params = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.postRequestHandler(url, body, headers, params);
+};
+
+const putRequestHandler = (url, body, context = null, headers = {}, params = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.putRequestHandler(url, body, headers, params);
+};
+
+const patchRequestHandler = (url, context, body, headers = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.patchRequestHandler(url, body, headers);
+};
+
+const deleteRequestHandler = (url, context = null, headers = {}, params = {}, data = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.deleteRequestHandler(url, headers, params, data);
+};
+
+const enrichCookie = (headers, context) => {
+	if (context) {
+		headers.Cookie = context;
+	}
+};
+
+module.exports = {
+	getRequestHandler,
+	postRequestHandler,
+	putRequestHandler,
+	patchRequestHandler,
+	deleteRequestHandler
+};

package/src/common/requests/requestHandlers.js

@@ -0,0 +1,60 @@
+const axios = require('axios');
+const errorValidation = require('../validations/errorValidation');
+
+const getRequestHandler = async (url, headers = {}, params = {}) => {
+	try {
+		const response = await axios.get(url, { params, headers });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+const postRequestHandler = async (url, body, headers = {}, params = {}) => {
+	try {
+		const response = await axios.post(url, body, { headers, params });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+const putRequestHandler = async (url, body, headers = {}, params = {}) => {
+	try {
+		const response = await axios.put(url, body, { headers, params });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+const patchRequestHandler = async (url, body, headers = {}) => {
+	try {
+		const response = await axios.patch(url, body, { headers });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+const deleteRequestHandler = async (url, headers = {}, params = {}, data = {}) => {
+	try {
+		const response = await axios.delete(url, { params, headers, data });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+module.exports = {
+	getRequestHandler,
+	postRequestHandler,
+	putRequestHandler,
+	patchRequestHandler,
+	deleteRequestHandler
+};

package/src/common/validations/errorValidation.js

@@ -1,16 +1,16 @@
-const responseStatusCodes = require('../httpResponseStatusCodes.json');
+const httpResponseStatusCodes = require('../httpResponseStatusCodes.json');
 
-const validateError = error => {
-    if (!error.response || !isClientErrorCode(error.response.status)) {
-        throw error;
-    }
+const validateClientErrorResponseStatus = error => {
+	if (!error.response || !isResponseStatusClientErrorCode(error.response.status)) {
+		throw error;
+	}
 };
 
-const isClientErrorCode = httpStatusCode => {
-    const minClientErrorCode = responseStatusCodes.BAD_REQUEST;
-    const maxClientErrorCode = responseStatusCodes.CLIENT_CLOSED_REQUEST;
+const isResponseStatusClientErrorCode = httpResponseStatusCode => {
+	const minClientErrorCode = httpResponseStatusCodes.BAD_REQUEST;
+	const maxClientErrorCode = httpResponseStatusCodes.CLIENT_CLOSED_REQUEST;
 
-    return httpStatusCode >= minClientErrorCode && httpStatusCode <= maxClientErrorCode;
+	return httpResponseStatusCode >= minClientErrorCode && httpResponseStatusCode <= maxClientErrorCode;
 };
 
-module.exports = { validateError };
+module.exports = { validateClientErrorResponseStatus };

package/src/common/validations/typeValidations.js

@@ -1,7 +1,7 @@
 const validateType = (input, expectedType) => {
-    if (!(input instanceof expectedType)) {
-        throw TypeError(`Type should be: ${expectedType}`);
-    }
+	if (!(input instanceof expectedType)) {
+		throw TypeError(`Type should be: ${expectedType}`);
+	}
 };
 
-module.exports = { validateType };
+module.exports = { validateType };

package/src/index.js

@@ -4,28 +4,32 @@ const init = conf => {
 	env.init(conf);
 	const internalAPI = getInternalAPI();
 	const openAPI = getOpenAPI();
-	const threadScheduler = require('./saas/thread-scheduler/runner');
 
-	return { internalAPI, openAPI, threadScheduler };
+	return { internalAPI, openAPI };
 };
 
 const getInternalAPI = () => {
-	const auth = require('./saas/internal-api/auth');
-	const accounts = require('./saas/internal-api/accounts');
+	const internalApiPath = './saas/internal-api';
 
-	const projects = require('./saas/internal-api/projects');
-	const tabs = require('./saas/internal-api/tabs');
+	const auth = require(`${internalApiPath}/auth`);
+	const accounts = require(`${internalApiPath}/accounts`);
 
-	const requirements = require('./saas/internal-api/requirements');
-	const contractors = require('./saas/internal-api/contractors');
+	const projects = require(`${internalApiPath}/projects`);
+	const tabs = require(`${internalApiPath}/tabs`);
 
-	const coi = require('./saas/internal-api/coi');
-	const compliance = require('./saas/internal-api/compliance');
-	const users = require('./saas/internal-api/users');
+	const requirements = require(`${internalApiPath}/requirements`);
+	const contractors = require(`${internalApiPath}/contractors`);
 
-	const reports = require('./saas/internal-api/reports');
-	const charts = require('./saas/internal-api/homepageCharts');
+	const coi = require(`${internalApiPath}/coi`);
+	const compliance = require(`${internalApiPath}/compliance`);
+	const users = require(`${internalApiPath}/users`);
 
+	const reports = require(`${internalApiPath}/reports`);
+	const charts = require(`${internalApiPath}/homepageCharts`);
+
+	const globalRecord = require(`${internalApiPath}/globalRecord`);
+
+	const threadScheduler = require(`${internalApiPath}/thread-scheduler/runner`);
 
 	const internalAPI = {
 		auth,
@@ -38,18 +42,21 @@ const getInternalAPI = () => {
 		compliance,
 		reports,
 		users,
-		charts
+		charts,
+		globalRecord,
+		threadScheduler
 	};
 
 	return internalAPI;
 };
 
 const getOpenAPI = () => {
-	const accounts = require('./saas/openapi/accounts/accounts.setup');
-	const tabs = require('./saas/openapi/tabs/tabs.setup');
-	const contractors = require('./saas/openapi/contractors/contractors.setup');
-	const projects = require('./saas/openapi/projects/projects.setup');
-	const requirements = require('./saas/openapi/requirements');
+	const openApiPath = './saas/openapi';
+	const accounts = require(`${openApiPath}/accounts/accounts.setup`);
+	const tabs = require(`${openApiPath}/tabs/tabs.setup`);
+	const contractors = require(`${openApiPath}/contractors/contractors.setup`);
+	const projects = require(`${openApiPath}/projects/projects.setup`);
+	const requirements = require(`${openApiPath}/requirements`);
 	const openAPI = { accounts, tabs, contractors, projects, requirements };
 	return openAPI;
 };

package/src/saas/internal-api/accounts/api/core/accounts.core.api.js

@@ -1,28 +1,28 @@
-const requests = require('../../../common/requests');
+const requests = require('../../../../../common/requests/cookieAuth/requests');
 const { backendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
-    getAccount: `${backendUrl}/saas/accounts`,
-    create: `${backendUrl}/saas/createaccount`,
-    delete: `${backendUrl}/saas/account`,
-    edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
+	getAccount: `${backendUrl}/saas/accounts`,
+	create: `${backendUrl}/saas/createaccount`,
+	delete: `${backendUrl}/saas/account`,
+	edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
 };
 
 const create = async (account, context) => {
-    return requests.postRequestHandler(Endpoints.create, account, context).then(res => res.data);
+	return requests.postRequestHandler(Endpoints.create, account, context).then(res => res.data);
 };
 
 const deleteAccount = async (accountId, context) => {
-    return requests.deleteRequestHandler(Endpoints.delete, context, {}, { 'userId': accountId });
+	return requests.deleteRequestHandler(Endpoints.delete, context, {}, { 'userId': accountId });
 };
 
 const updateAccountSettings = async (accountId, settings, context) => {
-    return requests.putRequestHandler(Endpoints.edit(accountId), { accountId, ...settings }, context);
+	return requests.putRequestHandler(Endpoints.edit(accountId), { accountId, ... settings }, context);
 };
 
 const getByName = async (accountName, context) => {
-    const params = { name: accountName };
-    return requests.getRequestHandler(Endpoints.getAccount, params, context).then(res => res.data);
+	const params = { name: accountName };
+	return requests.getRequestHandler(Endpoints.getAccount, params, context).then(res => res.data);
 };
 
 module.exports = { create, getByName, deleteAccount, updateAccountSettings };

package/src/saas/internal-api/accounts/api/core/accounts.core.setup.js

@@ -6,67 +6,66 @@ const { validateType } = require('../../../../../common/validations/typeValidati
 const { accountCreationSecret } = env.getEnv();
 
 const createAccount = async (createAccountModel, context) => {
-    validateType(createAccountModel, CreateAccountModel);
+	validateType(createAccountModel, CreateAccountModel);
 
-    env.requiredValidation({
-        accountCreationSecret: accountCreationSecret,
-        'credentials.strongPassword': createAccountModel.password
-    });
+	env.requiredValidation({
+		accountCreationSecret: accountCreationSecret,
+		'credentials.strongPassword': createAccountModel.password
+	});
 
-    return await accountsAPI.create(createAccountModel, context);
+	return await accountsAPI.create(createAccountModel, context);
 };
 
 const getAccount = async (accountName, context) => {
-    const existingAccounts = await accountsAPI.getByName(accountName, context);
+	const existingAccounts = await accountsAPI.getByName(accountName, context);
 
-    if (!existingAccounts || existingAccounts.length === 0) {
-        return null;
-    }
+	if (!existingAccounts || existingAccounts.length === 0) {
+		return null;
+	}
 
-    if (existingAccounts.length > 1) {
-        throw new Error(`Got more than one account with the name: ${accountName}. IDs: ${existingAccounts.map(item => item.userId).join(', ')}`);
-    }
+	if (existingAccounts.length > 1) {
+		throw new Error(`Got more than one account with the name: ${accountName}. IDs: ${existingAccounts.map(item => item.userId).join(', ')}`);
+	}
 
-    return existingAccounts[0];
+	return existingAccounts[0];
 };
 
 const getOrCreateAccount = async (createAccountModel, context) => {
-    validateType(createAccountModel, CreateAccountModel);
-    const existingAccount = await getAccount(createAccountModel.companyName, context);
+	validateType(createAccountModel, CreateAccountModel);
+	const existingAccount = await getAccount(createAccountModel.companyName, context);
 
-    if (existingAccount) {
-        return existingAccount;
-    }
+	if (existingAccount) {
+		return existingAccount;
+	}
 
-    return await createAccount(createAccountModel, context);
+	return await createAccount(createAccountModel, context);
 };
 
 const getAccountId = async (accountName, context) => {
-    const account = await getAccount(accountName, context);
+	const account = await getAccount(accountName, context);
 
-    if (!account) {
-        console.error(`Account ${accountName} does not exist`);
-        return null;
-    }
+	if (!account) {
+		console.error(`Account ${accountName} does not exist`);
+		return null;
+	}
 
-    return account.userId;
+	return account.userId;
 };
 
 const deleteAccountByName = async (accountName, context) => {
-    const accountId = await getAccountId(accountName, context);
-    return accountsAPI.deleteAccount(accountId, context);
+	const accountId = await getAccountId(accountName, context);
+	return accountsAPI.deleteAccount(accountId, context);
 };
 
 const deleteAccountById = async (accountId, context) => {
-    return accountsAPI.deleteAccount(accountId, context);
+	return accountsAPI.deleteAccount(accountId, context);
 };
 
 module.exports = {
-    getAccount,
-    getOrCreateAccount,
-    getAccountId,
-    createAccount,
-    deleteAccountByName,
-    deleteAccountById
+	getAccount,
+	getOrCreateAccount,
+	getAccountId,
+	createAccount,
+	deleteAccountByName,
+	deleteAccountById
 };
-

package/src/saas/internal-api/accounts/api/openapi/accounts.openapi.api.js

@@ -1,48 +1,48 @@
-const requests = require('../../../common/requests');
+const requests = require('../../../../../common/requests/cookieAuth/requests');
 const { backendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
-    createApiKey: `${backendUrl}/saas/api-keys`,
-    getStaticApiKeyByAccountId: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
-    getApiKeyByKeyValue: `${backendUrl}/saas/api-keys`,
-    removeStaticApiKey: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
-    dynamicApiKey: accountId =>`${backendUrl}/saas/accounts/${accountId}/dynamic-api-key`
+	createApiKey: `${backendUrl}/saas/api-keys`,
+	getStaticApiKeyByAccountId: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
+	getApiKeyByKeyValue: `${backendUrl}/saas/api-keys`,
+	removeStaticApiKey: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
+	dynamicApiKey: accountId => `${backendUrl}/saas/accounts/${accountId}/dynamic-api-key`
 };
 
 const createStaticApiKey = async (data, context) => {
-    return requests.postRequestHandler(Endpoints.createApiKey, data, context).then(res => res.data);
+	return requests.postRequestHandler(Endpoints.createApiKey, data, context).then(res => res.data);
 };
 
 const createGeneratorApiKey = async (data, context) => {
-    return requests.postRequestHandler(Endpoints.createApiKey, data, context).then(res => res.data);
+	return requests.postRequestHandler(Endpoints.createApiKey, data, context).then(res => res.data);
 };
 
 const getStaticApiKeyByAccountId = async (accountId, context) => {
-    return requests.getRequestHandler(Endpoints.getStaticApiKeyByAccountId(accountId), {}, context).then(res => res.data);
+	return requests.getRequestHandler(Endpoints.getStaticApiKeyByAccountId(accountId), {}, context).then(res => res.data);
 };
 
 const getApiKeyDetails = async (apiKeyValue, context) => {
-    return requests.getRequestHandler(Endpoints.getApiKeyByKeyValue, { apiKeyValue }, context).then(res => res.data);
+	return requests.getRequestHandler(Endpoints.getApiKeyByKeyValue, { apiKeyValue }, context).then(res => res.data);
 };
 
 const deleteStaticApiKey = async (accountId, context) => {
-    return requests.deleteRequestHandler(Endpoints.removeStaticApiKey(accountId), context).then(res=>res.data);
+	return requests.deleteRequestHandler(Endpoints.removeStaticApiKey(accountId), context).then(res => res.data);
 };
 
 const deleteDynamicApiKey = async (accountId, context) => {
-    return requests.deleteRequestHandler(Endpoints.dynamicApiKey(accountId), context).then(res => res.data);
+	return requests.deleteRequestHandler(Endpoints.dynamicApiKey(accountId), context).then(res => res.data);
 };
 
 const makeDynamicApiKeyExpired = async (accountId, context) => {
-    return requests.patchRequestHandler(Endpoints.dynamicApiKey(accountId), context, {}).then(res => res.data);
+	return requests.patchRequestHandler(Endpoints.dynamicApiKey(accountId), context, {}).then(res => res.data);
 };
 
 module.exports = {
-    createStaticApiKey,
-    createGeneratorApiKey,
-    getStaticApiKeyByAccountId,
-    getApiKeyDetails,
-    makeDynamicApiKeyExpired,
-    deleteStaticApiKey,
-    deleteDynamicApiKey
+	createStaticApiKey,
+	createGeneratorApiKey,
+	getStaticApiKeyByAccountId,
+	getApiKeyDetails,
+	makeDynamicApiKeyExpired,
+	deleteStaticApiKey,
+	deleteDynamicApiKey
 };

package/src/saas/internal-api/accounts/api/openapi/accounts.openapi.setup.js

@@ -2,73 +2,73 @@ const accountsAPI = require('./accounts.openapi.api');
 const crypto = require('crypto');
 
 const generateApiKeyValue = accountName => {
-    return crypto.createHash('sha256').update(accountName).digest('base64');
+	return crypto.createHash('sha256').update(accountName).digest('base64');
 };
 
 const createStaticApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'ACCOUNT_STATIC', apiKeyName = null } = {}) => {
-    const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
-    return accountsAPI.createStaticApiKey(data, context);
+	const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
+	return accountsAPI.createStaticApiKey(data, context);
 };
 
 const createGeneratorApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'GENERATOR', apiKeyName = null } = {}) => {
-    const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
-    return accountsAPI.createGeneratorApiKey(data, context);
+	const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
+	return accountsAPI.createGeneratorApiKey(data, context);
 };
 
 const getStaticApiKeyByAccountId = async (accountId, context) => {
-    return accountsAPI.getStaticApiKeyByAccountId(accountId, context);
+	return accountsAPI.getStaticApiKeyByAccountId(accountId, context);
 };
 
 const getApiKeyDetails = async (apiKeyValue, context) => {
-    return accountsAPI.getApiKeyDetails(apiKeyValue, context);
+	return accountsAPI.getApiKeyDetails(apiKeyValue, context);
 };
 
 const deleteStaticApiKey = async (accountId, context) => {
-    return accountsAPI.deleteStaticApiKey(accountId, context);
+	return accountsAPI.deleteStaticApiKey(accountId, context);
 };
 
 const getOrCreateStaticApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'ACCOUNT_STATIC', apiKeyName = null } = {}) => {
-    let existingApiKey = await getStaticApiKeyByAccountId(accountId, context);
+	let existingApiKey = await getStaticApiKeyByAccountId(accountId, context);
 
-    if (existingApiKey.apiKeyValue) {
-        return existingApiKey;
-    }
+	if (existingApiKey.apiKeyValue) {
+		return existingApiKey;
+	}
 
-    existingApiKey = await getApiKeyDetails(apiKeyValue, context);
+	existingApiKey = await getApiKeyDetails(apiKeyValue, context);
 
-    if (!existingApiKey.apiKeyValue) {
-        return createStaticApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
-    }
+	if (!existingApiKey.apiKeyValue) {
+		return createStaticApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
+	}
 
-    return existingApiKey;
+	return existingApiKey;
 };
 
 const getOrCreateGeneratorApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'GENERATOR', apiKeyName = null } = {}) => {
-    const existingApiKey = await getApiKeyDetails(apiKeyValue, context);
+	const existingApiKey = await getApiKeyDetails(apiKeyValue, context);
 
-    if (!existingApiKey.apiKeyValue) {
-        return createGeneratorApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
-    }
+	if (!existingApiKey.apiKeyValue) {
+		return createGeneratorApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
+	}
 
-    return existingApiKey;
+	return existingApiKey;
 };
 
-const deleteDynamicApiKey= async (accountId, context) => {
-    return accountsAPI.deleteDynamicApiKey(accountId, context);
+const deleteDynamicApiKey = async (accountId, context) => {
+	return accountsAPI.deleteDynamicApiKey(accountId, context);
 };
 
-const makeDynamicApiKeyExpired= async (accountId, context) => {
-    return accountsAPI.makeDynamicApiKeyExpired(accountId, context);
+const makeDynamicApiKeyExpired = async (accountId, context) => {
+	return accountsAPI.makeDynamicApiKeyExpired(accountId, context);
 };
 
 module.exports = {
-    createStaticApiKey,
-    generateApiKeyValue,
-    getOrCreateStaticApiKey,
-    getOrCreateGeneratorApiKey,
-    getStaticApiKeyByAccountId,
-    getApiKeyDetails,
-    makeDynamicApiKeyExpired,
-    deleteStaticApiKey,
-    deleteDynamicApiKey
+	createStaticApiKey,
+	generateApiKeyValue,
+	getOrCreateStaticApiKey,
+	getOrCreateGeneratorApiKey,
+	getStaticApiKeyByAccountId,
+	getApiKeyDetails,
+	makeDynamicApiKeyExpired,
+	deleteStaticApiKey,
+	deleteDynamicApiKey
 };

package/src/saas/internal-api/accounts/api/settings/settings.api.js

@@ -1,21 +1,21 @@
-const requests = require('../../../common/requests');
+const requests = require('../../../../../common/requests/cookieAuth/requests');
 const { backendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
-    get: accountId => `${backendUrl}/saas/account/${accountId}/settings`,
-    edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
+	get: accountId => `${backendUrl}/saas/account/${accountId}/settings`,
+	edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
 };
 
 const getAccountSettings = async (accountId, context) => {
-    return requests.getRequestHandler(Endpoints.get(accountId), {}, context);
+	return requests.getRequestHandler(Endpoints.get(accountId), {}, context);
 };
 
 const updateAccountSettings = async (updateAccountSettingsModel, context) => {
-    const { accountId } = updateAccountSettingsModel;
-    return requests.putRequestHandler(Endpoints.edit(accountId), updateAccountSettingsModel, context);
+	const { accountId } = updateAccountSettingsModel;
+	return requests.putRequestHandler(Endpoints.edit(accountId), updateAccountSettingsModel, context);
 };
 
 module.exports = {
-    getAccountSettings,
-    updateAccountSettings
+	getAccountSettings,
+	updateAccountSettings
 };

package/src/saas/internal-api/accounts/api/settings/settings.setup.js

@@ -3,21 +3,21 @@ const { validateType } = require('../../../../../common/validations/typeValidati
 const UpdateAccountSettingsModel = require('../../models/settings/update.settings.model');
 
 const getAccountSettings = async (accountId, context) => {
-    return accountsAPI.getAccountSettings(accountId, context).then(res => res.data);
+	return accountsAPI.getAccountSettings(accountId, context).then(res => res.data);
 };
 
 const updateAccountSettings = async (updateAccountSettingsModel, context) => {
-    validateType(updateAccountSettingsModel, UpdateAccountSettingsModel);
-    return accountsAPI.updateAccountSettings(updateAccountSettingsModel, context);
+	validateType(updateAccountSettingsModel, UpdateAccountSettingsModel);
+	return accountsAPI.updateAccountSettings(updateAccountSettingsModel, context);
 };
 
 const restoreAccountSettings = async (accountId, context) => {
-    const updateAccountSettingsModel = new UpdateAccountSettingsModel(accountId, false, false , false);
-    return accountsAPI.updateAccountSettings(updateAccountSettingsModel, context);
+	const updateAccountSettingsModel = new UpdateAccountSettingsModel(accountId, false, false, false);
+	return accountsAPI.updateAccountSettings(updateAccountSettingsModel, context);
 };
 
 module.exports = {
-    getAccountSettings,
-    updateAccountSettings,
-    restoreAccountSettings
-};
+	getAccountSettings,
+	updateAccountSettings,
+	restoreAccountSettings
+};