@suitegeezus/suitecloud-cli 3.1.4

package/src/templates/unittest/sample-test.js.template

@@ -0,0 +1,37 @@
+import record from 'N/record';
+import Record from 'N/record/instance';
+
+jest.mock('N/record');
+jest.mock('N/record/instance');
+
+beforeEach(() => {
+	jest.clearAllMocks();
+});
+
+describe('Basic jest test with simple assert', () => {
+	it('should assert strings are equal', () => {
+		const a = 'foobar';
+		const b = 'foobar';
+		expect(a).toMatch(b);
+	});
+});
+
+describe('Sample test with provided record module stubs', () => {
+	it('should update Sales Order memo field', () => {
+		// given
+		const salesOrderId = 1352;
+		record.load.mockReturnValue(Record);
+		Record.save.mockReturnValue(salesOrderId);
+
+		// when
+		let salesOrderRecord = record.load({id: salesOrderId});
+		salesOrderRecord.setValue({fieldId: 'memo', value: 'foobar'});
+		const updatedSalesOrderId = salesOrderRecord.save({enableSourcing: false});
+
+		// then
+		expect(record.load).toHaveBeenCalledWith({id: salesOrderId});
+		expect(Record.setValue).toHaveBeenCalledWith({fieldId: 'memo', value: 'foobar'});
+		expect(Record.save).toHaveBeenCalledWith({enableSourcing: false});
+		expect(salesOrderId).toBe(updatedSalesOrderId);
+	});
+});

package/src/templates/unittest/suitecloud.config.js.template

@@ -0,0 +1,15 @@
+const SuiteCloudJestUnitTestRunner = require('@oracle/suitecloud-unit-testing/services/SuiteCloudJestUnitTestRunner');
+
+module.exports = {
+	defaultProjectFolder: 'src',
+	commands: {
+		"project:deploy": {
+			beforeExecuting: async args => {
+				await SuiteCloudJestUnitTestRunner.run({
+				    // Jest configuration options.
+				});
+				return args;
+			},
+		},
+	},
+};

package/src/ui/CliSpinner.js

@@ -0,0 +1,34 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const assert = require('assert');
+const Spinner = require('cli-spinner').Spinner;
+
+const SPINNER_STRING = '⠋⠙⠹⠸⠼⠴⠦⠧⠏';
+
+module.exports = {
+	async executeWithSpinner(context) {
+		assert(context.action instanceof Promise, 'Promise is expected');
+		assert(context.message, 'Message is mandatory when spinner is enabled');
+
+		const promise = context.action;
+		const message = context.message;
+
+		const spinner = new Spinner(message);
+		// TODO: set spinner string conditionally based on the terminal cli is executed in
+		// spinner.setSpinnerString(SPINNER_STRING);
+
+		try {
+			spinner.start();
+			const result = await promise;
+			spinner.stop(true);
+			return result;
+		} catch (error) {
+			spinner.stop(true);
+			throw error;
+		}
+	},
+};

package/src/utils/AccountCredentialsFormatter.js

@@ -0,0 +1,62 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+const os = require('os');
+const NodeTranslationService = require('../services/NodeTranslationService');
+
+const {
+	ACCOUNT_CREDENTIALS: { AUTHID, ACCOUNT_INFO, DOMAIN },
+	ACCOUNT_TYPE,
+	COMMAND_MANAGE_ACCOUNT: { QUESTIONS_CHOICES },
+} = require('../services/TranslationKeys');
+const ApplicationConstants = require('../ApplicationConstants');
+
+const SANDBOX_ACCOUNT_ID_REGEX_PATTERN = '.+_SB\\d*$';
+const RELEASE_PREVIEW_ACCOUNT_ID_REGEX_PATTERN = '.+_RP\\d*$';
+
+function getInfoString(accountCredentials) {
+	const accountInfo = accountCredentials.accountInfo;
+	return (
+		NodeTranslationService.getMessage(AUTHID, accountCredentials.authId) +
+		os.EOL +
+		NodeTranslationService.getMessage(ACCOUNT_INFO.ACCOUNT_NAME, accountInfo.companyName) +
+		os.EOL +
+		NodeTranslationService.getMessage(ACCOUNT_INFO.ACCOUNT_ID, accountInfo.companyId) +
+		os.EOL +
+		NodeTranslationService.getMessage(ACCOUNT_INFO.ROLE, accountInfo.roleName) +
+		os.EOL +
+		NodeTranslationService.getMessage(DOMAIN, accountCredentials.domain) +
+		os.EOL +
+		NodeTranslationService.getMessage(ACCOUNT_INFO.ACCOUNT_TYPE, _getAccountType(accountInfo.companyId))
+	);
+}
+
+function _getAccountType(accountId) {
+	if (accountId.match(SANDBOX_ACCOUNT_ID_REGEX_PATTERN)) {
+		return NodeTranslationService.getMessage(ACCOUNT_TYPE.SANDBOX);
+	} else if (accountId.match(RELEASE_PREVIEW_ACCOUNT_ID_REGEX_PATTERN)) {
+		return NodeTranslationService.getMessage(ACCOUNT_TYPE.RELEASE_PREVIEW);
+	}
+	return NodeTranslationService.getMessage(ACCOUNT_TYPE.PRODUCTION);
+}
+
+function getListItemString(authID, accountCredentials) {
+	const isNotProductionUrl =
+		accountCredentials.hostInfo.hostName &&
+		!accountCredentials.hostInfo.hostName.match(ApplicationConstants.DOMAIN.PRODUCTION.PRODUCTION_DOMAIN_REGEX) &&
+		!accountCredentials.hostInfo.hostName.match(ApplicationConstants.DOMAIN.PRODUCTION.PRODUCTION_ACCOUNT_SPECIFIC_DOMAIN_REGEX);
+	const notProductionLabel = isNotProductionUrl
+		? NodeTranslationService.getMessage(QUESTIONS_CHOICES.SELECT_AUTHID.EXISTING_AUTH_ID_URL_NOT_PRODUCTION, accountCredentials.hostInfo.hostName)
+		: '';
+	const accountInfo = `${accountCredentials.accountInfo.roleName} @ ${accountCredentials.accountInfo.companyName}`;
+	return NodeTranslationService.getMessage(
+		QUESTIONS_CHOICES.SELECT_AUTHID.EXISTING_AUTH_ID,
+		authID,
+		accountInfo,
+		notProductionLabel
+	);
+}
+
+module.exports = { getInfoString, getListItemString };

package/src/utils/AccountSpecificValuesUtils.js

@@ -0,0 +1,55 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+
+'use strict';
+
+const assert = require('assert');
+const NodeTranslationService = require('../services/NodeTranslationService');
+const ProjectInfoService = require('../services/ProjectInfoService');
+const {
+	UTILS: {
+		ACCOUNT_SPECIFIC_VALUES_ARGUMENT_HANDLER: { ERRORS },
+	},
+} = require('../services/TranslationKeys');
+const { PROJECT_SUITEAPP } = require('../ApplicationConstants');
+
+const ACCOUNT_SPECIFIC_VALUES = 'accountspecificvalues';
+const ACCOUNT_SPECIFIC_VALUES_OPTIONS = {
+	ERROR: 'ERROR',
+	WARNING: 'WARNING',
+};
+
+function validate(args, projectFolder) {
+	const projectInfoService = new ProjectInfoService(projectFolder);
+
+	if (args.hasOwnProperty(ACCOUNT_SPECIFIC_VALUES)) {
+		assert(typeof args[ACCOUNT_SPECIFIC_VALUES] === 'string', NodeTranslationService.getMessage(ERRORS.WRONG_ACCOUNT_SPECIFIC_VALUES_OPTION));
+		if (projectInfoService.getProjectType() === PROJECT_SUITEAPP) {
+			throw NodeTranslationService.getMessage(ERRORS.APPLY_ACCOUNT_SPECIFIC_VALUES_IN_SUITEAPP);
+		}
+	}
+}
+
+function transformArgument(args) {
+	const newArgs = {};
+
+	if (args.hasOwnProperty(ACCOUNT_SPECIFIC_VALUES)) {
+		const upperCaseValue = args[ACCOUNT_SPECIFIC_VALUES].toUpperCase();
+		switch (upperCaseValue) {
+			case ACCOUNT_SPECIFIC_VALUES_OPTIONS.WARNING:
+				newArgs[ACCOUNT_SPECIFIC_VALUES] = ACCOUNT_SPECIFIC_VALUES_OPTIONS.WARNING;
+				break;
+			case ACCOUNT_SPECIFIC_VALUES_OPTIONS.ERROR:
+				newArgs[ACCOUNT_SPECIFIC_VALUES] = ACCOUNT_SPECIFIC_VALUES_OPTIONS.ERROR;
+				break;
+			default:
+				throw NodeTranslationService.getMessage(ERRORS.WRONG_ACCOUNT_SPECIFIC_VALUES_OPTION);
+		}
+	}
+
+	return newArgs;
+}
+
+module.exports = { validate, transformArgument, ACCOUNT_SPECIFIC_VALUES_OPTIONS, ACCOUNT_SPECIFIC_VALUES };

package/src/utils/ActionResultUtils.js

@@ -0,0 +1,47 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const { lineBreak } = require('../loggers/LoggerOsConstants');
+const disableInIntegrationMode = 'disableInIntegrationMode';
+
+module.exports = {
+	getErrorMessagesString: actionResult => {
+		return actionResult.errorMessages.join(lineBreak);
+	},
+
+	logResultMessage: (actionResult, log) => {
+		if (actionResult.resultMessage) {
+			log.result(actionResult.resultMessage);
+		}
+	},
+	extractNotInteractiveCommand: (commandName, commandMetadata, actionResult) => {
+		const options = _generateOptionsString(commandMetadata, actionResult);
+		return `${commandName} ${options}`;
+	},
+
+};
+
+function _generateOptionsString(commandMetadata, actionResult) {
+	const flagsReducer = (accumulator, key) => `${accumulator}--${key} `;
+	const commandReducer = (accumulator, key) => `${accumulator} --${key} ${actionResult.commandParameters[key]}`;
+
+	const flags = actionResult.commandFlags && actionResult.commandFlags.length > 0
+		? `${actionResult.commandFlags.filter(key => _hasToBeShown(key, commandMetadata.options)).reduce(flagsReducer, '')}`.trim()
+		: ' ';
+
+	return actionResult.commandParameters
+		? Object.keys(actionResult.commandParameters)
+			.filter(key => _hasToBeShown(key, commandMetadata.options))
+			.reduce(commandReducer, flags).trim()
+		: '';
+}
+
+function _hasToBeShown(key, options) {
+
+	return options.hasOwnProperty(key)
+		&& options[key].hasOwnProperty(disableInIntegrationMode)
+		&& options[key][disableInIntegrationMode] === false;
+}

package/src/utils/ApplyInstallationPreferencesUtils.js

@@ -0,0 +1,41 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+
+'use strict';
+
+const NodeTranslationService = require('../services/NodeTranslationService');
+const ProjectInfoService = require('../services/ProjectInfoService');
+const { LINKS, PROJECT_ACP } = require('../ApplicationConstants');
+
+const APPLY_INSTALLATION_PREFERENCES = 'applyinstallprefs';
+
+const {
+	COMMAND_DEPLOY: {
+		MESSAGES: { NOT_ASKING_INSTALLATION_PREFERENCES_REASON },
+	},
+	UTILS: {
+		APPLY_INSTALLATION_PREFERENCES_ARGUMENT_HANDLER: { INSTALLATION_PREFERENCES_ERRORS },
+		ERRORS: { COMMAND },
+	},
+} = require('../services/TranslationKeys');
+
+function validate(args, projectFolder, commandName) {
+	const projectInfoService = new ProjectInfoService(projectFolder);
+
+	if (args[APPLY_INSTALLATION_PREFERENCES] && projectInfoService.getProjectType() === PROJECT_ACP) {
+		throw NodeTranslationService.getMessage(INSTALLATION_PREFERENCES_ERRORS.APPLY_INSTALLATION_PREFERENCES_IN_ACP);
+	}
+
+	if (args[APPLY_INSTALLATION_PREFERENCES] && !projectInfoService.hasLockAndHideFiles()) {
+		const errorMessage = NodeTranslationService.getMessage(
+			NOT_ASKING_INSTALLATION_PREFERENCES_REASON,
+			LINKS.HOW_TO.CREATE_INSTALLATION_PREFERENCES
+		);
+
+		throw NodeTranslationService.getMessage(COMMAND, commandName, errorMessage);
+	}
+}
+
+module.exports = { validate };

package/src/utils/AuthenticationUtils.js

@@ -0,0 +1,262 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const FileUtils = require('./FileUtils');
+const assert = require('assert');
+const NodeTranslationService = require('../services/NodeTranslationService');
+const { ERRORS, UTILS } = require('../services/TranslationKeys');
+const { FILES } = require('../ApplicationConstants');
+const { ActionResult } = require('../services/actionresult/ActionResult');
+const AuthenticateActionResult = require('../services/actionresult/AuthenticateActionResult');
+const { executeWithSpinner } = require('../ui/CliSpinner');
+const path = require('path');
+const SdkExecutionContext = require('../SdkExecutionContext');
+const SdkOperationResultUtils = require('../utils/SdkOperationResultUtils');
+const SdkExecutor = require('../SdkExecutor');
+const { lineBreak } = require('../loggers/LoggerOsConstants')
+const ExecutionEnvironmentContext = require('../ExecutionEnvironmentContext');
+const SdkOperationResult = require('../utils/SdkOperationResult');
+const {ENV_VARS} = require('../ApplicationConstants');
+
+const DEFAULT_AUTH_ID_PROPERTY = 'defaultAuthId';
+
+const COMMANDS = {
+	AUTHENTICATE: {
+		SDK_COMMAND: 'authenticate',
+		PARAMS: {
+			AUTH_ID: 'authid',
+			ACCOUNT: 'account',
+			TOKEN_ID: 'tokenid',
+			TOKEN_SECRET: 'tokensecret',
+			URL: 'url',
+		},
+		MODES: {
+			OAUTH: 'OAUTH',
+			REUSE: 'REUSE',
+			CLIENT_CREDENTIALS: 'CLIENT_CREDENTIALS'
+		},
+	},
+	AUTHENTICATE_CI: {
+		SDK_COMMAND: 'authenticateci',
+		PARAMS: {
+			ACCOUNT: 'account',
+			AUTH_ID: 'authid',
+			CERTIFICATEID: 'certificateid',
+			PRIVATEKEYPATH: 'privatekeypath',
+			URL: 'url',
+		}
+	},
+	MANAGEAUTH: {
+		SDK_COMMAND: 'manageauth',
+	},
+	INSPECT_AUTHORIZATION: {
+		SDK_COMMAND: 'inspectauthorization',
+		PARAMS: {
+			AUTH_ID: 'authid',
+		}
+	},
+	REFRESH_AUTHORIZATION: {
+		SDK_COMMAND: 'refreshauthorization',
+		PARAMS: {
+			AUTH_ID: 'authid',
+		}
+	},
+	FORCE_REFRESH_AUTHORIZATION: {
+		SDK_COMMAND: 'forcerefreshauthorization',
+		PARAMS: {
+			AUTH_ID: 'authid',
+		}
+	},
+};
+
+const FLAGS = {
+	LIST: 'list'
+};
+
+function setDefaultAuthentication(projectFolder, authId) {
+	try {
+		// nest the values into a DEFAULT_AUTH_ID_PROPERTY property
+		const projectConfiguration = {
+			[DEFAULT_AUTH_ID_PROPERTY]: authId,
+		};
+		FileUtils.create(path.join(projectFolder, FILES.PROJECT_JSON), projectConfiguration);
+	} catch (error) {
+		const errorMessage = error != null && error.message ? NodeTranslationService.getMessage(ERRORS.ADD_ERROR_LINE, error.message) : '';
+		throw NodeTranslationService.getMessage(ERRORS.WRITING_PROJECT_JSON, errorMessage);
+	}
+}
+
+/**
+ * @description - Looks at the environment for the value. This should be settled after the command is setup and launched.
+ * - only call this internally before the command is generated
+ * @deprecated - no new commands should call this directly
+ * @returns {string|void}
+ */
+function getProjectDefaultAuthId() {
+	// look in the environment first
+	return process.env[ENV_VARS.SUITECLOUD_AUTHID];
+}
+
+async function getAuthIds(sdkPath) {
+	const sdkExecutor = new SdkExecutor(sdkPath);
+	const getAuthListContext = SdkExecutionContext.Builder.forCommand(COMMANDS.MANAGEAUTH.SDK_COMMAND).integration().addFlag(FLAGS.LIST).build();
+
+	const operationResult = await executeWithSpinner({
+		action: sdkExecutor.execute(getAuthListContext),
+		message: NodeTranslationService.getMessage(UTILS.AUTHENTICATION.LOADING_AUTHIDS),
+	}).catch((error) => {
+		return ActionResult.Builder.withErrors([error]).build();
+	});
+	return operationResult.status === SdkOperationResultUtils.STATUS.SUCCESS
+		? ActionResult.Builder.withData(operationResult.data).build()
+		: ActionResult.Builder.withErrors(operationResult.errorMessages).build();
+}
+
+async function authenticateWithOauth(params, sdkPath, projectFolder, cancelToken, executionEnvironmentContext) {
+	let authId = params.authid;
+	const sdkExecutor = new SdkExecutor(sdkPath, executionEnvironmentContext);
+	const contextBuilder = SdkExecutionContext.Builder.forCommand(COMMANDS.AUTHENTICATE.SDK_COMMAND)
+		.integration()
+		.addParam(COMMANDS.AUTHENTICATE.PARAMS.AUTH_ID, authId);
+
+	if (params.url) {
+		contextBuilder.addParam(COMMANDS.AUTHENTICATE.PARAMS.URL, params.url);
+	}
+	const oauthContext = contextBuilder.build();
+	return executeWithSpinner({
+		action: sdkExecutor.execute(oauthContext, cancelToken),
+		message: NodeTranslationService.getMessage(UTILS.AUTHENTICATION.STARTING_OAUTH_FLOW),
+	})
+		.then((operationResult) => {
+			if (operationResult.status === SdkOperationResultUtils.STATUS.ERROR) {
+				return AuthenticateActionResult.Builder.withErrors(operationResult.errorMessages)
+					.withCommandParameters(oauthContext.getParams())
+					.build();
+			}
+			setDefaultAuthentication(projectFolder, authId);
+			return AuthenticateActionResult.Builder.success()
+				.withMode(COMMANDS.AUTHENTICATE.MODES.OAUTH)
+				.withAuthId(authId)
+				.withAccountInfo(operationResult.data.accountInfo)
+				.withCommandParameters(oauthContext.getParams())
+				.build();
+		})
+		.catch((error) => AuthenticateActionResult.Builder.withErrors([error]).build());
+}
+
+async function authenticateCi(params, sdkPath, projectFolder, executionEnvironmentContext) {
+	const authId = params.authid;
+	const sdkExecutor = new SdkExecutor(sdkPath, executionEnvironmentContext);
+	const contextBuilder = SdkExecutionContext.Builder.forCommand(COMMANDS.AUTHENTICATE_CI.SDK_COMMAND)
+		.integration()
+		.addParam(COMMANDS.AUTHENTICATE_CI.PARAMS.AUTH_ID, authId)
+		.addParam(COMMANDS.AUTHENTICATE_CI.PARAMS.ACCOUNT, params.account)
+		.addParam(COMMANDS.AUTHENTICATE_CI.PARAMS.CERTIFICATEID, params.certificateid)
+		.addParam(COMMANDS.AUTHENTICATE_CI.PARAMS.PRIVATEKEYPATH, params.privatekeypath)
+
+	if (params.domain) {
+		contextBuilder.addParam(COMMANDS.AUTHENTICATE_CI.PARAMS.URL, params.domain);
+	}
+
+	const authenticateCiExecutionContext = contextBuilder.build();
+	const operationResult = await executeWithSpinner({
+		action: sdkExecutor.execute(authenticateCiExecutionContext),
+		message: NodeTranslationService.getMessage(UTILS.AUTHENTICATION.AUTHENTICATING),
+	});
+	if (operationResult.status === SdkOperationResultUtils.STATUS.ERROR) {
+		return AuthenticateActionResult.Builder.withErrors(operationResult.errorMessages).build();
+	}
+	setDefaultAuthentication(projectFolder, authId);
+	return AuthenticateActionResult.Builder.success()
+		.withMode(COMMANDS.AUTHENTICATE.MODES.CLIENT_CREDENTIALS)
+		.withAuthId(authId)
+		.withAccountInfo(operationResult.data.accountInfo)
+		.withCommandParameters(authenticateCiExecutionContext.getParams())
+		.build();
+}
+
+async function selectAuthenticationCI(authId, sdkPath, projectFolder) {
+	//Validate authId exists into the CI file
+	const authIDActionResult = await getAuthIds(sdkPath);
+	if (!authIDActionResult.isSuccess()) {
+		throw authIDActionResult.errorMessages;
+	}
+	const authIDs = Object.keys(authIDActionResult.data);
+
+	if (authIDs.includes(authId)) {
+		setDefaultAuthentication(projectFolder, authId);
+		return AuthenticateActionResult.Builder.success()
+			.withMode(COMMANDS.AUTHENTICATE.MODES.REUSE)
+			.withAuthId(authId)
+			.withAccountInfo(authIDActionResult.data[authId].accountInfo)
+			.build();
+	} else {
+		throw NodeTranslationService.getMessage(NOT_EXISTING_AUTH_ID, authId);
+	}
+}
+
+/**
+ * 
+ * @param {String} authid 
+ * @param {String} sdkPath 
+ * @param {ExecutionEnvironmentContext} executionEnvironmentContext 
+ * @returns {Promise<SdkOperationResult>}
+ */
+async function checkIfReauthorizationIsNeeded(authid, sdkPath, executionEnvironmentContext) {
+	const sdkExecutor = new SdkExecutor(sdkPath, executionEnvironmentContext);
+	const inspectAuthContext = SdkExecutionContext.Builder
+		.forCommand(COMMANDS.INSPECT_AUTHORIZATION.SDK_COMMAND)
+		.addParam(COMMANDS.INSPECT_AUTHORIZATION.PARAMS.AUTH_ID, authid)
+		.integration()
+		.build();
+	const result = await sdkExecutor.execute(inspectAuthContext);
+	return new SdkOperationResult(result);
+}
+
+/**
+ * 
+ * @param {String} authid 
+ * @param {String} sdkPath 
+ * @param {ExecutionEnvironmentContext} executionEnvironmentContext 
+ * @returns {Promise<SdkOperationResult>}
+ */
+async function refreshAuthorization(authid, sdkPath, executionEnvironmentContext) {
+	const sdkExecutor = new SdkExecutor(sdkPath, executionEnvironmentContext);
+	const reauthorizeAuthContext = SdkExecutionContext.Builder
+		.forCommand(COMMANDS.REFRESH_AUTHORIZATION.SDK_COMMAND)
+		.addParam(COMMANDS.REFRESH_AUTHORIZATION.PARAMS.AUTH_ID, authid)
+		.integration()
+		.build();
+	const result = await executeWithSpinner({
+		action: sdkExecutor.execute(reauthorizeAuthContext),
+		message: NodeTranslationService.getMessage(UTILS.AUTHENTICATION.AUTHORIZING)
+	});
+	return new SdkOperationResult(result);
+}
+
+/**
+ * 
+ * @param {String} authid 
+ * @param {String} sdkPath 
+ * @param {ExecutionEnvironmentContext} executionEnvironmentContext 
+ * @returns {Promise<SdkOperationResult>} with data that contains the refreshed accessToken
+ */
+async function forceRefreshAuthorization(authid, sdkPath, executionEnvironmentContext) {
+	const sdkExecutor = new SdkExecutor(sdkPath, executionEnvironmentContext);
+	const reauthorizeAuthContext = SdkExecutionContext.Builder
+		.forCommand(COMMANDS.FORCE_REFRESH_AUTHORIZATION.SDK_COMMAND)
+		.addParam(COMMANDS.FORCE_REFRESH_AUTHORIZATION.PARAMS.AUTH_ID, authid)
+		.integration()
+		.build();
+	const result = await executeWithSpinner({
+		action: sdkExecutor.execute(reauthorizeAuthContext),
+		message: NodeTranslationService.getMessage(UTILS.AUTHENTICATION.AUTHORIZING)
+	});
+	
+	return new SdkOperationResult(result);
+}
+
+module.exports = { setDefaultAuthentication, getProjectDefaultAuthId, getAuthIds, authenticateWithOauth, authenticateCi, selectAuthenticationCI, checkIfReauthorizationIsNeeded, refreshAuthorization, forceRefreshAuthorization, COMMANDS};

package/src/utils/CommandUtils.js

@@ -0,0 +1,50 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const assert = require('assert');
+
+class CommandUtils {
+	get INQUIRER_TYPES() {
+		return {
+			CHECKBOX: 'checkbox',
+			INPUT: 'input',
+			LIST: 'list',
+			PASSWORD: 'password',
+			PASSWORD_MASK: '*',
+		};
+	}
+
+	extractKeysFromObject(object, keys) {
+		return keys.reduce((obj, key) => {
+			if (object[key]) {
+				obj[key] = object[key];
+			}
+			return obj;
+		}, {});
+	}
+
+	extractCommandOptions(answers, commandMetadata) {
+		assert(answers);
+		assert(commandMetadata);
+		assert(commandMetadata.options);
+
+		const commandOptions = Object.keys(commandMetadata.options);
+		return this.extractKeysFromObject(answers, commandOptions);
+	}
+
+	quoteString(string) {
+		return `"${string}"`;
+	}
+
+	unquoteString(stringValue) {
+		if (stringValue.length > 1 && stringValue.startsWith('"') && stringValue.endsWith('"')) {
+			return stringValue.slice(1, -1);
+		}
+		return stringValue;
+	}
+}
+
+module.exports = new CommandUtils();

package/src/utils/CryptoUtils.js

@@ -0,0 +1,41 @@
+/*
+** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+*/
+'use strict';
+
+const crypto = require('crypto');
+const ALGORITHM = 'aes-256-cbc';
+const ENCRYPTION_KEY_BUFFER_LENGTH = 16;
+const IV_LENGTH = 16;
+const HEX = 'hex';
+const DELIMITER = ':';
+
+function encrypt(text, key) {
+	const iv = crypto.randomBytes(IV_LENGTH);
+	const cipher = crypto.createCipheriv(ALGORITHM, Buffer.from(key), iv);
+	let encrypted = cipher.update(text);
+	encrypted = Buffer.concat([encrypted, cipher.final()]);
+
+	return iv.toString(HEX) + DELIMITER + encrypted.toString(HEX);
+}
+
+function decrypt(text, key) {
+	const textParts = text.split(DELIMITER);
+	const iv = Buffer.from(textParts.shift(), HEX);
+	const encryptedText = Buffer.from(textParts.join(DELIMITER), HEX);
+	const decipher = crypto.createDecipheriv(ALGORITHM, Buffer.from(key), iv);
+	let decrypted = decipher.update(encryptedText);
+	decrypted = Buffer.concat([decrypted, decipher.final()]);
+
+	return decrypted.toString();
+}
+
+function generateRandomKey() {
+	return crypto
+		.randomBytes(ENCRYPTION_KEY_BUFFER_LENGTH)
+		.toString(HEX)
+		.substr(0, 32);
+}
+
+module.exports = { decrypt, encrypt, generateRandomKey };

package/src/utils/ExceptionUtils.js

@@ -0,0 +1,33 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const NodeTranslationService = require('../services/NodeTranslationService');
+const CLIException = require('../CLIException');
+const { COMMAND_OPTIONS } = require('../services/TranslationKeys');
+const ValidationErrorsFormatter = require('../utils/ValidationErrorsFormatter');
+
+function unwrapExceptionMessage(exception) {
+	return exception.getErrorMessage ? exception.getErrorMessage() : exception;
+}
+
+function unwrapInformationMessage(exception) {
+	return exception.getInfoMessage ? exception.getInfoMessage() : '';
+}
+
+function throwValidationException(errorMessages, runInInteractiveMode, commandMetadata) {
+	const formattedError = ValidationErrorsFormatter.formatErrors(errorMessages);
+	if (!runInInteractiveMode && commandMetadata.supportsInteractiveMode) {
+		const suggestedCommandMessage = NodeTranslationService.getMessage(
+			COMMAND_OPTIONS.VALIDATION_ERRORS_INTERACTIVE_SUGGESTION,
+			commandMetadata.name
+		);
+		throw new CLIException(formattedError, suggestedCommandMessage);
+	}
+
+	throw new CLIException(formattedError);
+}
+
+module.exports = { unwrapExceptionMessage, unwrapInformationMessage, throwValidationException };