@suitegeezus/suitecloud-cli 3.1.4

package/src/CLI.js

@@ -0,0 +1,202 @@
+/*
+ ** 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 path = require('path');
+const assert = require('assert');
+const program = require('commander');
+const NodeConsoleLogger = require('./loggers/NodeConsoleLogger');
+const NodeTranslationService = require('./services/NodeTranslationService');
+const {
+	CLI: { INTERACTIVE_OPTION_DESCRIPTION, TITLE, USAGE, VERSION_HELP },
+	COMMAND_OPTIONS,
+	ERRORS,
+} = require('./services/TranslationKeys');
+const unwrapExceptionMessage = require('./utils/ExceptionUtils').unwrapExceptionMessage;
+const INTERACTIVE_ALIAS = '-i';
+const INTERACTIVE_OPTION = '--interactive';
+
+// suitecloud executable is in {root}/src/suitecloud.js. package.json file is one level before
+const PACKAGE_FILE = `${path.dirname(require.main.filename)}/../package.json`;
+const configFile = require(PACKAGE_FILE);
+const CLI_VERSION = configFile ? configFile.version : 'unknown';
+const { nsCompatibleVersion } = require(PACKAGE_FILE);
+const COMMAND_ALIAS = '[command]';
+const HELP_COMMAND = 'help';
+const HELP_OPTION = '--help';
+const HELP_ALIAS = '-h';
+const VERSION_OPTION = '--version';
+
+module.exports = class CLI {
+	constructor(dependencies) {
+		assert(dependencies);
+		assert(dependencies.commandsMetadataService);
+		assert(dependencies.commandActionExecutor);
+		assert(dependencies.commandRegistrationService);
+
+		this._commandsMetadataService = dependencies.commandsMetadataService;
+		this._commandActionExecutor = dependencies.commandActionExecutor;
+		this._commandRegistrationService = dependencies.commandRegistrationService;
+	}
+
+	start(process) {
+		try {
+			const commandMetadataList = this._commandsMetadataService.getCommandsMetadata();
+
+			this._addUbiquitousOptions(commandMetadataList, [] );
+			const thirdArgument = process.argv[2];
+			if (
+				thirdArgument &&
+				thirdArgument !== HELP_ALIAS &&
+				thirdArgument !== HELP_OPTION &&
+				thirdArgument !== HELP_COMMAND &&
+				thirdArgument !== VERSION_OPTION
+			) {
+				this._validateCommandExists(commandMetadataList, thirdArgument);
+			} else if (thirdArgument == HELP_COMMAND && process.argv[3]) {
+				this._validateCommandExists(commandMetadataList, process.argv[3]);
+			}
+
+			if (process.argv.length > 3 && (process.argv.includes(HELP_ALIAS) || process.argv.includes(HELP_OPTION))) {
+				process.argv = this._leaveOnlyHelpArguments();
+			}
+
+			const runInInteractiveMode = this._isRunningInInteractiveMode();
+			this._initializeCommands(commandMetadataList, runInInteractiveMode);
+
+			// If there are no arguments, we print SuiteCloud version header
+			if (!process.argv || process.argv.length <= 2) {
+				NodeConsoleLogger.info(NodeTranslationService.getMessage(TITLE, nsCompatibleVersion));
+			}
+
+			program
+				.version(CLI_VERSION, VERSION_OPTION, NodeTranslationService.getMessage(VERSION_HELP))
+				.option(
+					`${INTERACTIVE_ALIAS}, ${INTERACTIVE_OPTION}`,
+					NodeTranslationService.getMessage(INTERACTIVE_OPTION_DESCRIPTION),
+					this._validateInteractive
+				)
+				.helpOption(`${HELP_ALIAS}, ${HELP_OPTION}`, NodeTranslationService.getMessage(COMMAND_OPTIONS.HELP))
+				.addHelpCommand(`${HELP_COMMAND} ${COMMAND_ALIAS}`, NodeTranslationService.getMessage(COMMAND_OPTIONS.HELP))
+				.on('command:*', (args) => {
+					NodeConsoleLogger.error(NodeTranslationService.getMessage(ERRORS.COMMAND_DOES_NOT_EXIST, args[0]));
+				})
+				.usage(NodeTranslationService.getMessage(USAGE))
+				.parse(process.argv);
+		} catch (exception) {
+			NodeConsoleLogger.error(unwrapExceptionMessage(exception));
+		}
+	}
+
+	_validateCommandExists(commandMetadataList, possibleCommand) {
+		if (!commandMetadataList.hasOwnProperty(possibleCommand)) {
+			throw NodeTranslationService.getMessage(ERRORS.COMMAND_DOES_NOT_EXIST, possibleCommand);
+		}
+	}
+
+	_leaveOnlyHelpArguments() {
+		return process.argv.slice(0, 3).concat(HELP_ALIAS); //We only leave commandName and help argument
+	}
+
+	_isRunningInInteractiveMode() {
+		return process.argv.includes(INTERACTIVE_ALIAS) || process.argv.includes(INTERACTIVE_OPTION);
+	}
+
+	_validateInteractive() {
+		let additionalAllowed = 0;
+		process.argv.forEach((arg)=>{
+			if( /\b(authid|project|config|debug)\b/.test(arg) ) additionalAllowed += 2;
+		});
+		if (process.argv.length > (4 + additionalAllowed) ) {
+			// There are more options apart from -i or --interactive
+			throw NodeTranslationService.getMessage(ERRORS.INTERACTIVE_MODE_MORE_OPTIONS);
+		}
+	}
+
+	_addUbiquitousOptions(commandMetadataList, exemptions= []) {
+		Object.values(commandMetadataList).forEach((commandMetadata) => {
+			if(exemptions.includes( commandMetadata.name )) return;
+
+			Object.assign(
+				commandMetadata.options,
+				{
+					"config": {
+						"name": "config",
+						"option": "config",
+						"description": "Specify a config file to use. Otherwise cli will discover closest config file",
+						"mandatory": false,
+						"type": "SINGLE",
+						"usage": "\"./path/to/sdf.config.alt.js\"",
+						"defaultOption": false,
+						"disableInIntegrationMode": false,
+						"conflicts": ["noconfig"]
+					},
+					"noconfig": {
+						"name": "noconfig",
+						"option": "noconfig",
+						"description": "Do not use any config file",
+						"mandatory": false,
+						"type": "FLAG",
+						"usage": "",
+						"defaultOption": false,
+						"disableInIntegrationMode": false,
+						"conflicts": ["config"]
+					},
+					"customflag": {
+						"name": "customflag",
+						"option": "customflag",
+						"description": "A custom boolean that will be passed into the hooks. Has no effect unless you implement the logic in a hook",
+						"mandatory": false,
+						"type": "FLAG",
+						"usage": "",
+						"defaultOption": false,
+						"disableInIntegrationMode": false
+					},
+					"customoptions": {
+						"name": "customoptions",
+						"option": "customoptions",
+						"description": "Custom string values that will be passed into the hooks. Has no effect unless you implement the logic in a hook",
+						"mandatory": false,
+						"type": "MULTIPLE",
+						"usage": "\"value1\" \"value2\"",
+						"defaultOption": false,
+						"disableInIntegrationMode": false
+					},
+					"debug": {
+						"name": "debug",
+						"option": "debug",
+						"description": "Directory to dump debug data for debugging. Creates a unique {command}.{datetime}.json file per run",
+						"mandatory": false,
+						"type": "SINGLE",
+						"usage": "\"./debug-output\"",
+						"defaultOption": false,
+						"disableInIntegrationMode": false
+					}
+				}
+			);
+		});
+	}
+
+	_initializeCommands(commandMetadataList, runInInteractiveMode) {
+		const commandsMetadataArraySortedByCommandName = Object.values(commandMetadataList).sort((command1, command2) =>
+			command1.name.localeCompare(command2.name)
+		);
+
+		commandsMetadataArraySortedByCommandName.forEach((commandMetadata) => {
+			this._commandRegistrationService.register({
+				commandMetadata: commandMetadata,
+				program: program,
+				runInInteractiveMode: runInInteractiveMode,
+				executeCommandFunction: async (options) => {
+					return this._commandActionExecutor.executeAction({
+						commandName: commandMetadata.name,
+						runInInteractiveMode: runInInteractiveMode,
+						arguments: options,
+					});
+				},
+			});
+		});
+	}
+};

package/src/CLIException.js

@@ -0,0 +1,21 @@
+/*
+** 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';
+
+module.exports = class CLIException {
+	constructor(defaultMessage, infoMessage, translationKey) {
+		this._defaultMessage = defaultMessage;
+		this._infoMessage = infoMessage;
+		this._translationKey = translationKey;
+	}
+
+	getInfoMessage() {
+		return this._infoMessage;
+	}
+
+	getErrorMessage() {
+		return this._defaultMessage;
+	}
+};

package/src/ExecutionEnvironmentContext.js

@@ -0,0 +1,39 @@
+/*
+ ** 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 { SDK_CLIENT_PLATFORM } = require('./ApplicationConstants');
+
+module.exports = class ExecutionEnvironmentContext {
+
+    constructor(params) {
+        this._platform = SDK_CLIENT_PLATFORM;
+        this._platformVersion = process.version;
+
+        if (!params) {
+            params = {
+                platform: SDK_CLIENT_PLATFORM,
+                platformVersion: process.version,
+            };
+        }
+
+        if (params.platform) {
+            this._platform = params.platform;
+        }
+
+        if (params.platformVersion) {
+            this._platformVersion = params.platformVersion;
+        }
+    }
+
+    getPlatform() {
+        return this._platform;
+    }
+
+    getPlatformVersion() {
+        return this._platformVersion;
+    }
+
+}

package/src/SdkExecutionContext.js

@@ -0,0 +1,90 @@
+/*
+ ** 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 SdkExecutionContext {
+	constructor(options) {
+		assert(options.command, 'Command is mandatory option');
+		this._command = options.command;
+		this._integrationMode = options.integrationMode;
+		this._params = options.params;
+		this._flags = options.flags;
+	}
+
+	getCommand() {
+		return this._command;
+	}
+
+	getParams() {
+		return this._params;
+	}
+
+	getFlags() {
+		return this._flags;
+	}
+
+	isIntegrationMode() {
+		return this._integrationMode;
+	}
+
+	static get Builder() {
+		return new SdkExecutionContextBuilder();
+	}
+}
+
+class SdkExecutionContextBuilder {
+	constructor() {
+		this._params = {};
+		this._flags = [];
+		this._integrationMode = false;
+	}
+
+	forCommand(command) {
+		this._command = command;
+		return this;
+	}
+
+	integration() {
+		this._integrationMode = true;
+		return this;
+	}
+
+	addParams(params) {
+		Object.keys(params).forEach((key) => {
+			this.addParam(key, params[key]);
+		});
+		return this;
+	}
+
+	addParam(param, value) {
+		this._params[`-${param}`] = value;
+		return this;
+	}
+
+	addFlags(flags) {
+		flags.forEach((flag) => {
+			this.addFlag(flag);
+		});
+		return this;
+	}
+
+	addFlag(flag) {
+		this._flags.push(`-${flag}`);
+		return this;
+	}
+
+	build() {
+		return new SdkExecutionContext({
+			command: this._command,
+			params: this._params,
+			flags: this._flags,
+			integrationMode: this._integrationMode,
+		});
+	}
+}
+
+module.exports = SdkExecutionContext;

package/src/SdkExecutor.js

@@ -0,0 +1,160 @@
+/*
+ ** 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 {
+	SDK_INTEGRATION_MODE_JVM_OPTION,
+	SDK_CLIENT_PLATFORM_JVM_OPTION,
+	SDK_CLIENT_PLATFORM_VERSION_JVM_OPTION,
+	SDK_COMPATIBLE_JAVA_VERSIONS,
+} = require('./ApplicationConstants');
+const path = require('path');
+const FileUtils = require('./utils/FileUtils');
+const spawn = require('child_process').spawn;
+const CLISettingsService = require('./services/settings/CLISettingsService');
+const EnvironmentInformationService = require('./services/EnvironmentInformationService');
+const url = require('url');
+const NodeTranslationService = require('./services/NodeTranslationService');
+const { ERRORS } = require('./services/TranslationKeys');
+const ExecutionEnvironmentContext = require('./ExecutionEnvironmentContext');
+
+const DATA_EVENT = 'data';
+const CLOSE_EVENT = 'close';
+const UTF8 = 'utf8';
+
+module.exports = class SdkExecutor {
+	constructor(sdkPath, executionEnvironmentContext) {
+		this._sdkPath = sdkPath;
+
+		this._CLISettingsService = new CLISettingsService();
+		this._environmentInformationService = new EnvironmentInformationService();
+		this.childProcess = null;
+
+		if (!executionEnvironmentContext) {
+			this._executionEnvironmentContext = new ExecutionEnvironmentContext();
+		} else {
+			this._executionEnvironmentContext = executionEnvironmentContext;
+		}
+	}
+
+	execute(executionContext, token) {
+		return new Promise((resolve, reject) => {
+			if (token !== undefined && token !== null) {
+				token.cancel = (reason) => {
+					this.childProcess.kill('SIGKILL');
+					reject(reason);
+				};
+			}
+			try {
+				this.childProcess = this._launchJvmCommand(executionContext);
+				this._addChildProcessListeners(executionContext.isIntegrationMode(), resolve, reject);
+			} catch (e) {
+				reject(e);
+			}
+		});
+	}
+
+	_addChildProcessListeners(isIntegrationMode, resolve, reject) {
+		let lastSdkOutput = '';
+		let lastSdkError = '';
+
+		this.childProcess.stderr.on(DATA_EVENT, (data) => {
+			lastSdkError += data.toString(UTF8);
+		});
+		this.childProcess.stdout.on(DATA_EVENT, (data) => {
+			lastSdkOutput += data.toString(UTF8);
+		});
+
+		this.childProcess.on(CLOSE_EVENT, (code) => {
+			if (code === 0) {
+				try {
+					const output = isIntegrationMode ? JSON.parse(lastSdkOutput) : lastSdkOutput;
+					resolve(output);
+				} catch (error) {
+					reject(NodeTranslationService.getMessage(ERRORS.SDKEXECUTOR.RUNNING_COMMAND, error));
+				}
+			} else {
+				const javaVersionError = this._checkIfJavaVersionIssue();
+				if (javaVersionError) {
+					reject(javaVersionError);
+				}
+				reject(NodeTranslationService.getMessage(ERRORS.SDKEXECUTOR.SDK_ERROR, code, lastSdkError));
+			}
+		});
+	}
+
+	_launchJvmCommand(executionContext) {
+		if (!this._CLISettingsService.isJavaVersionValid()) {
+			const javaVersionError = this._checkIfJavaVersionIssue();
+			if (javaVersionError) {
+				throw javaVersionError;
+			}
+		}
+
+		const cliParams = this._convertParamsObjToString(executionContext.getParams(), executionContext.getFlags());
+
+		const integrationModeOption = executionContext.isIntegrationMode() ? SDK_INTEGRATION_MODE_JVM_OPTION : '';
+
+		const clientPlatform = `${SDK_CLIENT_PLATFORM_JVM_OPTION}=${this._executionEnvironmentContext.getPlatform()}`;
+		const clientPlatformVersionOption = `${SDK_CLIENT_PLATFORM_VERSION_JVM_OPTION}=${this._executionEnvironmentContext.getPlatformVersion()}`;
+		const customVmOptions = this._getCustomVmOptionsString();
+
+		if (!FileUtils.exists(this._sdkPath)) {
+			throw NodeTranslationService.getMessage(ERRORS.SDKEXECUTOR.NO_JAR_FILE_FOUND, path.join(__dirname, '..'));
+		}
+		const quotedSdkJarPath = `"${this._sdkPath}"`;
+
+		const vmOptions = `${integrationModeOption} ${clientPlatform} ${clientPlatformVersionOption} ${customVmOptions}`;
+		const jvmCommand = `java -jar ${vmOptions} ${quotedSdkJarPath} ${executionContext.getCommand()} ${cliParams}`;
+
+		return spawn(jvmCommand, [], { shell: true });
+	}
+
+	_convertParamsObjToString(cliParams, flags) {
+		let cliParamsAsString = '';
+		for (const param in cliParams) {
+			if (cliParams.hasOwnProperty(param)) {
+				const value = cliParams[param] ? ` ${cliParams[param]} ` : ' ';
+				cliParamsAsString += param + value;
+			}
+		}
+
+		if (flags && Array.isArray(flags)) {
+			flags.forEach((flag) => {
+				cliParamsAsString += ` ${flag} `;
+			});
+		}
+
+		return cliParamsAsString;
+	}
+
+	_getCustomVmOptionsString() {
+		const customVmOptions = this._CLISettingsService.getCustomVmOptions();
+		if (!customVmOptions) {
+			return '';
+		}
+
+		const addVmOptionToString = (prevString, vmOptionKey) =>
+			(prevString += customVmOptions[vmOptionKey] === '' ? ` ${vmOptionKey}` : ` ${vmOptionKey}="${customVmOptions[vmOptionKey].trim()}"`);
+		// customVmOptions are already validated at CLISettingsService, it will be an object at this point
+		return Object.keys(customVmOptions).reduce(addVmOptionToString, '').trim();
+	}
+
+	_checkIfJavaVersionIssue() {
+		const javaVersionInstalled = this._environmentInformationService.getInstalledJavaVersionString();
+		for (const compatibleJavaVersion of SDK_COMPATIBLE_JAVA_VERSIONS) {
+			if (javaVersionInstalled.startsWith(compatibleJavaVersion)) {
+				this._CLISettingsService.setJavaVersionValid(true);
+				return;
+			}
+		}
+
+		this._CLISettingsService.setJavaVersionValid(false);
+		if (javaVersionInstalled === '') {
+			return NodeTranslationService.getMessage(ERRORS.CLI_SDK_JAVA_VERSION_NOT_INSTALLED, SDK_COMPATIBLE_JAVA_VERSIONS.join(', '));
+		}
+		return NodeTranslationService.getMessage(ERRORS.CLI_SDK_JAVA_VERSION_NOT_COMPATIBLE, javaVersionInstalled, SDK_COMPATIBLE_JAVA_VERSIONS.join(', '));
+	}
+};

package/src/commands/Command.js

@@ -0,0 +1,158 @@
+/*
+ ** 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 CommandOptionsValidator = require('../core/CommandOptionsValidator');
+const { throwValidationException } = require('../utils/ExceptionUtils');
+const { ActionResult } = require('../services/actionresult/ActionResult');
+
+const BaseAction = require('./base/BaseAction');
+const BaseInputHandler = require('./base/BaseInputHandler');
+const BaseOutputHandler = require('./base/BaseOutputHandler');
+
+const INTERACTIVE_MODE = {
+	NEVER: 'NEVER',
+	ALWAYS: 'ALWAYS',
+	DEFAULT: 'DEFAULT',
+};
+
+const NEVER_PARAMS = {
+	'CONFIG': 'config',
+	'NOCONFIG': 'noconfig',
+	'CUSTOMFLAG': 'customflag',
+	'CUSTOMOPTIONS': 'customoptions',
+	'DEBUG': 'debug'
+};
+
+/** @type {import('./Command')} */
+class Command {
+	constructor(options, action, inputHandler, outputHandler) {
+		assert(options);
+		assert(options.commandMetadata);
+		assert(options.projectFolder);
+		assert(options.log);
+		assert(options.interactiveSupport);
+		assert(typeof options.runInInteractiveMode === 'boolean');
+
+		assert(action, 'Commands must have an action');
+		assert(inputHandler, 'Commands must have an input handler');
+		assert(outputHandler, 'Commands must have an output handler');
+
+		this._commandMetadata = options.commandMetadata;
+		this._projectFolder = options.projectFolder;
+		this.__executionPath = options.executionPath;
+		this._runInInteractiveMode = options.runInInteractiveMode;
+		this._interactiveSupport = options.interactiveSupport;
+		this._log = options.log;
+
+		this._action = new action(options);
+		this._inputHandler = new inputHandler(options);
+		this._outputHandler = new outputHandler(options);
+	}
+
+	get _executionPath(){
+		debugger;
+		return this.__executionPath;
+	}
+
+	async run(inputParams) {
+		this._cleanNeverParams(inputParams);
+		const execParams =
+			this._interactiveSupport === INTERACTIVE_MODE.ALWAYS || (this._interactiveSupport !== INTERACTIVE_MODE.NEVER && this._runInInteractiveMode)
+				? await this._inputHandler.getParameters(inputParams)
+				: inputParams;
+
+		if( this._interactiveSupport === INTERACTIVE_MODE.ALWAYS || (this._interactiveSupport !== INTERACTIVE_MODE.NEVER && this._runInInteractiveMode)) {
+			if( inputParams.authid) execParams.authid = inputParams.authid
+		}
+
+		const preExec = await this._action.preExecute(execParams);
+
+		this._validateActionParameters(preExec);
+
+		const exec = await this._action.execute(preExec);
+		const actionResult = await this._action.postExecute(exec);
+
+		if (!(actionResult instanceof ActionResult)) {
+			throw 'INTERNAL ERROR: Command must return an ActionResult object.';
+		} else if (!actionResult.isSuccess()) {
+			return this._outputHandler.parseError(actionResult);
+		} else {
+			return this._outputHandler.parse(actionResult);
+		}
+	}
+
+	_cleanNeverParams(params){
+		Object.values(NEVER_PARAMS).forEach((p)=>{
+			if( Reflect.has(params,p)) delete params[p];
+		})
+	}
+
+	_validateActionParameters(params) {
+		const commandOptionsValidator = new CommandOptionsValidator();
+		const validationErrors = commandOptionsValidator.validate({
+			commandOptions: this._commandMetadata.options,
+			arguments: params,
+		});
+		if (validationErrors.length > 0) {
+			throwValidationException(validationErrors, this._runInInteractiveMode, this._commandMetadata);
+		}
+	}
+
+	static get Builder() {
+		return new CommandBuilder();
+	}
+}
+
+class CommandBuilder {
+	constructor() {
+		this._options = {
+			interactiveSupport: INTERACTIVE_MODE.DEFAULT,
+		};
+		this._action = BaseAction;
+		this._input = BaseInputHandler;
+		this._output = BaseOutputHandler;
+	}
+
+	withOptions(options) {
+		this._options = {
+			...this._options,
+			...options,
+		};
+		return this;
+	}
+
+	neverInteractive() {
+		this._options.interactiveSupport = INTERACTIVE_MODE.NEVER;
+		return this;
+	}
+
+	alwaysInteractive() {
+		this._options.interactiveSupport = INTERACTIVE_MODE.ALWAYS;
+		return this;
+	}
+
+	withAction(action) {
+		this._action = action;
+		return this;
+	}
+
+	withInput(input) {
+		this._input = input;
+		return this;
+	}
+
+	withOutput(output) {
+		this._output = output;
+		return this;
+	}
+
+	build() {
+		return new Command(this._options, this._action, this._input, this._output);
+	}
+}
+
+module.exports = Command;