@suitegeezus/suitecloud-cli 3.1.4

package/src/commands/account/setupci/AccountSetupCiAction.js

@@ -0,0 +1,58 @@
+/*
+ ** 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 BaseAction = require('../../base/BaseAction');
+const { authenticateCi, selectAuthenticationCI } = require('../../../utils/AuthenticationUtils');
+const { DOMAIN: { PRODUCTION: { GENERIC_NETSUITE_DOMAIN } } } = require('../../../ApplicationConstants');
+const { ACCOUNT_SETUP_CI: { COMMAND: { OPTIONS } } } = require('./AccountSetupCiConstants');
+const ProjectInfoService = require('../../../services/ProjectInfoService');
+const { validateMachineToMachineAuthIsAllowed } = require('../../../services/ExecutionContextService');
+const AccountSetupCiValidation = require('./AccountSetupCiValidation');
+
+module.exports = class AccountSetupCiAction extends BaseAction {
+
+	constructor(options) {
+		super(options);
+		this._projectInfoService = new ProjectInfoService(this._projectFolder);
+		this._validator = new AccountSetupCiValidation(this._commandMetadata, this._runInInteractiveMode);
+	}
+
+	preExecute(params) {
+		this._projectInfoService.checkWorkingDirectoryContainsValidProject(this._commandMetadata.name);
+
+		if (params[OPTIONS.ACCOUNT]) {
+			params[OPTIONS.ACCOUNT] = params[OPTIONS.ACCOUNT].toUpperCase();
+		}
+
+		return params;
+	}
+
+	async execute(params) {
+		if (params[OPTIONS.DOMAIN] === GENERIC_NETSUITE_DOMAIN) {
+			delete params[OPTIONS.DOMAIN];
+		}
+
+		validateMachineToMachineAuthIsAllowed();
+
+		const isSetupMode = this._isSetupMode(params);
+		this._validator.validateActionParametersByMode(params, isSetupMode);
+		this._validator.validateAuthIDFormat(this._getAuthId(params), isSetupMode);
+
+		if (isSetupMode) {
+			return await authenticateCi(params, this._sdkPath, this._executionPath, this._executionEnvironmentContext);
+		} else {
+			return await selectAuthenticationCI(this._getAuthId(params), this._sdkPath, this._executionPath);
+		}
+	}
+
+	_isSetupMode(params) {
+		return (!params[OPTIONS.SELECT]);
+	}
+
+	_getAuthId(params) {
+		return this._isSetupMode(params) ? params[OPTIONS.AUTHID] : params[OPTIONS.SELECT];
+	}
+}

package/src/commands/account/setupci/AccountSetupCiCommand.js

@@ -0,0 +1,20 @@
+/*
+ ** 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 Command = require('../../Command');
+const AccountSetupCiAction = require('./AccountSetupCiAction');
+const AccountSetupCiOutputHandler = require('./AccountSetupCiOutputHandler');
+
+module.exports = {
+	create(options) {
+		return Command.Builder
+			.withOptions(options)
+			.withAction(AccountSetupCiAction)
+			.withOutput(AccountSetupCiOutputHandler)
+			.neverInteractive()
+			.build();
+	},
+};

package/src/commands/account/setupci/AccountSetupCiConstants.js

@@ -0,0 +1,21 @@
+/*
+ ** Copyright (c) 2025 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 = {
+	ACCOUNT_SETUP_CI: {
+		COMMAND: {
+			OPTIONS: {
+				ACCOUNT: 'account',
+				AUTHID: 'authid',
+				CERTIFCATEID: 'certificateid',
+				PRIVATEKEYPATH: 'privatekeypath',
+				DOMAIN: 'domain',
+				SELECT: 'select'
+			},
+			SDK_COMMAND: 'authenticateci',
+			MANDATORY_PARAMS_FOR_SETUP_MODE: ['account', 'authid', 'certificateid', 'privatekeypath']
+		},
+	}
+};

package/src/commands/account/setupci/AccountSetupCiOutputHandler.js

@@ -0,0 +1,40 @@
+/*
+ ** 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 BaseOutputHandler = require('../../base/BaseOutputHandler');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const {
+	COMMAND_SETUPACCOUNTCI: { OUTPUT: { SELECT_DEFAULT_ACCOUNT, NEW_OAUTH } },
+	UTILS,
+} = require('../../../services/TranslationKeys');
+
+const { COMMANDS: { AUTHENTICATE: { MODES: { REUSE } } } } = require('../../../utils/AuthenticationUtils');
+
+module.exports = class AccountSetupCiOutputHandler extends BaseOutputHandler {
+	constructor(options) {
+		super(options);
+	}
+
+	parse(actionResult) {
+
+		if (actionResult.mode === REUSE) {
+			//SELECT mode
+			this._log.result(NodeTranslationService.getMessage(
+				SELECT_DEFAULT_ACCOUNT,
+				actionResult.authId,
+			));
+		} else {
+			//SETUP mode
+			this._log.result(NodeTranslationService.getMessage(
+				NEW_OAUTH,
+				actionResult.accountInfo.companyName,
+				actionResult.accountInfo.roleName,
+				actionResult.authId,
+			));
+			this._log.result(NodeTranslationService.getMessage(UTILS.AUTHENTICATION.SUCCESS_SETUP));
+		}
+		return actionResult;
+	}
+};

package/src/commands/account/setupci/AccountSetupCiValidation.js

@@ -0,0 +1,100 @@
+const {
+	showValidationResults,
+	validateFieldIsNotEmpty,
+	validateFieldHasNoSpaces,
+	validateAlphanumericHyphenUnderscore,
+	validateMaximumLength,
+} = require('../../../validation/InteractiveAnswersValidator');
+const assert = require('assert');
+const { throwValidationException } = require('../../../utils/ExceptionUtils');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const TRANSLATION_KEYS = require('../../../services/TranslationKeys');
+const {
+	ACCOUNT_SETUP_CI: {
+		COMMAND: {
+			OPTIONS,
+			MANDATORY_PARAMS_FOR_SETUP_MODE,
+		},
+	},
+} = require('./AccountSetupCiConstants');
+const { COMMAND_SETUPACCOUNTCI: { ERRORS } } = require('../../../services/TranslationKeys');
+
+class AccountSetupCiValidation {
+	constructor(commandMetadata, runInInteractiveMode) {
+		this._commandMetadata = commandMetadata;
+		this._runInInteractiveMode = runInInteractiveMode;
+	}
+
+	validateAuthIDFormat(authId, isSetupMode) {
+		const validateResult = showValidationResults(
+			authId,
+			validateFieldIsNotEmpty,
+			validateFieldHasNoSpaces,
+			validateAlphanumericHyphenUnderscore,
+			validateMaximumLength,
+		);
+		if (validateResult !== true) {
+			throwValidationException(
+				[NodeTranslationService.getMessage(TRANSLATION_KEYS.COMMAND_OPTIONS.VALIDATION_SHOW_ERROR_MESSAGE,
+					isSetupMode ? OPTIONS.AUTHID : OPTIONS.SELECT, validateResult
+				)],
+				false,
+				this._commandMetadata
+			);
+		}
+	}
+
+	/**
+	 * There are 2 options, select mode --select <authI> and nothing else allowed.
+	 * and the setup mode --authid <authI> --certificateid <certId>--privatekeypath <privatekeypath> -account <account> -domain <domain>
+	 * all mandatory except domain which is optional.
+	 * @param params
+	 * @param isSetupMode
+	 */
+	validateActionParametersByMode(params, isSetupMode) {
+		assert(this._commandMetadata);
+		assert(this._commandMetadata.options);
+		const validationErrors = isSetupMode ?
+			this._validateActionParametersSetupMode(params) :
+			this._validateActionParametersSelectMode(params);
+
+		if (validationErrors.length > 0) {
+			throwValidationException(validationErrors, this._runInInteractiveMode, this._commandMetadata);
+		}
+	}
+
+	/**
+	 * Since account:setup:ci in standard setup mode and account:setup:ci --select are handled by the same default
+	 * parameter validations, all the parameters are configured as not mandatory.
+	 * The validation of the mandatory parameters for account:setup:ci standard setup mode is done here.
+	 * This method makes sure all the mandatory params for the standard mode are present
+	 * @param params input parameters
+	 * @returns empty list if the validation is correct, otherwise it returns the list of errors with the missing mandatory
+	 * fields
+	 * @private
+	 */
+	_validateActionParametersSetupMode(params) {
+		return MANDATORY_PARAMS_FOR_SETUP_MODE
+			.filter(mandatoryOption => !params[mandatoryOption])
+			.map(missingParam => NodeTranslationService.getMessage(ERRORS.IS_MANDATORY_SETUP_MODE, missingParam));
+	}
+
+	/**
+	 * Since account:setup:ci in standard setup mode and account:setup:ci --select are handled by the same default
+	 * parameter validations, all the parameters are configured as not mandatory.
+	 * The validation of the not allowed parameters for account:setup:ci select mode is done here.
+	 * This method makes sure none the not allowed params for the setup mode is present
+	 * @param params input parameters
+	 * @returns empty list if the validation is correct, otherwise it returns the list of errors with the not allowed
+	 * fields
+	 * @private
+	 */
+	_validateActionParametersSelectMode(params) {
+		return Object.keys(params)
+			.filter(paramKey => paramKey !== OPTIONS.SELECT)
+			.map(notAllowedParam => NodeTranslationService.getMessage(ERRORS.IS_NOT_ALLOWED_SELECT_MODE, notAllowedParam));
+	}
+
+}
+
+module.exports = AccountSetupCiValidation;

package/src/commands/base/BaseAction.js

@@ -0,0 +1,37 @@
+/*
+ ** 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 { ActionResult } = require('../../services/actionresult/ActionResult');
+const SdkExecutor = require('../../SdkExecutor');
+const { getProjectDefaultAuthId } = require('../../utils/AuthenticationUtils');
+
+module.exports = class BaseAction {
+	constructor(options) {
+		this._projectFolder = options.projectFolder;
+		// an optional opportunity to override;
+		this._authId = options.authId || getProjectDefaultAuthId();
+		this._commandMetadata = options.commandMetadata;
+		this._executionPath = options.executionPath;
+		this._runInInteractiveMode = options.runInInteractiveMode;
+		this._log = options.log;
+		this._sdkPath = options.sdkPath;
+
+		this._executionEnvironmentContext = options.executionEnvironmentContext;
+		this._sdkExecutor = new SdkExecutor(this._sdkPath, this._executionEnvironmentContext);
+	}
+
+	async preExecute(params) {
+		return params;
+	}
+
+	async execute(params) {
+		return ActionResult.Builder.withErrors(['BaseAction execute should never be called']);
+	}
+
+	async postExecute(actionResult) {
+		return actionResult;
+	}
+};

package/src/commands/base/BaseInputHandler.js

@@ -0,0 +1,24 @@
+/*
+ ** 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 { getProjectDefaultAuthId } = require('../../utils/AuthenticationUtils');
+module.exports = class BaseInputHandler {
+	constructor(options) {
+		this._projectFolder = options.projectFolder;
+		this._commandMetadata = options.commandMetadata;
+		this._executionPath = options.executionPath;
+		this._configPath = options.configPath;
+		this._log = options.log;
+		this._authId = options.authId || getProjectDefaultAuthId();
+		this._runInInteractiveMode = options.runInInteractiveMode;
+		this._executionEnvironmentContext = options.executionEnvironmentContext;
+		this._sdkPath = options.sdkPath;
+	}
+
+	async getParameters(params) {
+		return params;
+	}
+};

package/src/commands/base/BaseOutputHandler.js

@@ -0,0 +1,30 @@
+/*
+ ** 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 { getProjectDefaultAuthId } = require('../../utils/AuthenticationUtils');
+module.exports = class BaseOutputHandler {
+	constructor(options) {
+		this._log = options.log;
+		this._projectFolder = options.projectFolder;
+		this._authId = options.authId || getProjectDefaultAuthId();
+
+		this._log.info(`[${options.authId || 'N/A'}]: ${options.projectFolder}`);
+	}
+
+	parse(actionResult) {
+		return actionResult;
+	}
+
+	parseError(actionResult) {
+		if (actionResult.errorMessages && actionResult.errorMessages.length > 0) {
+			for (let i =0; i<actionResult.errorMessages.length; i++) {
+				this._log.error(actionResult.errorMessages[i]);
+			}
+		}
+		return actionResult;
+	}
+};

package/src/commands/custom/hello/Action.js

@@ -0,0 +1,58 @@
+/*
+ ** 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 BaseAction = require('../../base/BaseAction');
+const { HelloActionResult } = require('../../../services/actionresult/HelloActionResult');
+const {ENV_VARS} = require('../../../ApplicationConstants');
+
+const COMMAND = {
+	OPTIONS: {
+		PHRASE: 'phrase'
+	},
+	SDK_COMMAND: 'null',
+};
+
+module.exports = class HelloAction extends BaseAction {
+	
+	constructor(options) {
+		super(options);
+		this._options = options;
+		// this._projectInfoService = new ProjectInfoService(this._projectFolder);
+	}
+
+	/**
+	 * @An opportunity to:
+	 * - modify the params. e.g. use a command argument to override the project folder?
+	 * - check the environment
+	 * - prompt the user, etc
+	 * @param params
+	 * @returns {any}
+	 */
+	preExecute(params) {
+
+		if( params.debug) console.log('preExecute', params, this._options);
+		return params;
+	}
+
+	/**
+	 * @description - do whatever you want in here
+	 * @param params
+	 * @returns {Promise<void>}
+	 */
+	async execute(params) {
+		if(params.debug) {
+			console.log('execute', params, this._options);
+			Object.values(ENV_VARS).forEach((envKey)=>{
+				console.log(envKey,process.env[envKey]);
+			});
+		}
+		return new HelloActionResult({
+			status: 'SUCCESS',
+			data: {},
+			commandParameters: params
+		});
+	}
+};

package/src/commands/custom/hello/Command.js

@@ -0,0 +1,20 @@
+/*
+ ** 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 Command = require('../../Command');
+const Action = require('./Action');
+const Handler = require('./Handler');
+
+module.exports = {
+	create(options) {
+		return Command.Builder
+			.withOptions(options)
+			.withAction(Action)
+			.withOutput(Handler)
+			.neverInteractive()
+			.build();
+	},
+};

package/src/commands/custom/hello/Handler.js

@@ -0,0 +1,26 @@
+/*
+ ** 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 BaseOutputHandler = require('../../base/BaseOutputHandler');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+
+const tranKeys = require('../../../services/TranslationKeys');
+
+module.exports = class HelloOutputHandler extends BaseOutputHandler {
+	constructor(options) {
+		super(options);
+	}
+
+	parse(actionResult) {
+		const resultMessage = NodeTranslationService.getMessage(
+			tranKeys.COMMAND_HELLO.TEST,
+			actionResult.commandParameters.phrase
+		);
+
+		this._log.result(resultMessage);
+		this._log.result(NodeTranslationService.getMessage(tranKeys.COMMAND_HELLO.TEST2));
+		return actionResult;
+	}
+};

package/src/commands/custom/hello/README.md

@@ -0,0 +1,78 @@
+# Experimenting with creating a custom command inside the cli
+
+this is a hello world example
+
+
+# TODO
+- copying from another command to see what i can do
+
+# Discoveries
+Internally "SDK" refers to the java application that will run commands against Netsuite.  The node cli is a wrapper to this SDK.
+
+
+- A command such as `custom:hello` can  be setup in the [SdkCommandsMetadata.json](../../../metadata/SdkCommandsMetadata.json) file.
+  - You don't need an entry in [SdkCommandMetadataPath.json](../../../metadata/SdkCommandsMetadataPatch.json)
+- A generator needs to be setup in [CommandGenerators.json](../../../metadata/CommandGenerators.json)
+- 
+- If configured with `isSetupRequired` property then the `authId will be injected
+- In `beforeExecuting` hooks only changes to the `options.arguments` are kept.  Changes to `projectFolder` are
+
+## Command.run
+After you "build" the Command (in your Command.js) the instance object that you have has a method `run` on it.  This could be overridden to not call the SDK (i.e. the java application)
+
+## SKIP_AUHTORIZATION_CHECK and reauth
+- There is a concept of reauthorization that is provided via (hidden?) properties on the command. 
+
+## `projectFolder` and `defaultProjectFolder` can override
+`defaultProjectFolder` can be set as a relative path to the location of the suitecloud.config.js file. 
+This folder should be the containing directory of the `FileCabinet` directory.  But either way it is going to be the expected
+location of the deploy and manifest files.  And other paths are going to be relative to that.  Such as `~/FileCabinet` and `~/Objects` folders
+
+You can override this with `projectFolder` on any command hook.  
+
+Example use-case: 
+You are doing a file:upload
+
+
+## current working directory
+
+THis is by default uses as the `_executionPath` internally and is `node:path.join` with the projectFolder above in order to location the FileCabinet. 
+it is expected that the suitecloud.config.js file reside there as well. 
+
+
+# Features Todo
+
+## Look for the closest suitecloud.config file instead of requiring it be in the working directory
+
+## expand on the config that is accepted for a command
+currently authid is available to `beforeExecuting` hooks BUT any chances you make to it are not respective. 
+Instead it is already forced from a read of the project.json file. 
+So we could extend the modification of options to include options.authid
+
+- `authid` could be modifiedy-orprovided-by `beforeExecuting` 
+  - e.g. you could provide a prompt
+- `beforeExecuting` could be provided additional object to do things such as provide an interactive experience for the user.
+
+```ts
+const customCommandHandler = {
+	beforeExecuting: (options: any, helpers: { 
+		promptUser: any; // function,
+        displayMesage: any; // function
+    })=>{
+		return options;
+    }
+}
+```
+
+- additionally: be able to know whether setup is required for a command.  As this should be determined immediately, you shouldn't be able to change it, but you should be able to know via a property in the options. `options.setupRequired: boolean` ?
+- additionally: know whether the command will fire the SDK.  Any custom commands will not fire it.
+- `options.isSDK : boolean`
+- There are some commands where not both are true
+
+## Make `beforeExecuting` more powerful
+- carry-over changes to `options.projectFolder` property (see CommandActionExecutor#executeAction)
+- Continue to not allow a change to options.CommandName
+
+## Type definitions for the commands and arguments
+
+adding some slowly

package/src/commands/custom/hook/Action.js

@@ -0,0 +1,28 @@
+/*
+ ** 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 BaseAction = require('../../base/BaseAction');
+const { ActionResult, STATUS } = require('../../../services/actionresult/ActionResult');
+
+module.exports = class AcsExtraAction extends BaseAction {
+	constructor(options) {
+		super(options);
+	}
+
+	/**
+	 *
+	 * @param params
+	 * @returns {Promise<ActionResult>}
+	 */
+	async execute(params) {
+		return new ActionResult({
+			status: STATUS.SUCCESS,
+			data: {},
+			commandParameters: params
+		});
+	}
+
+};

package/src/commands/custom/hook/Command.js

@@ -0,0 +1,22 @@
+/*
+ ** 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 Command = require('../../Command');
+const Action = require('./Action');
+const InputHandler = require('./InputHandler');
+const OutputHandler = require('./OutputHandler')
+
+module.exports = {
+	create(options) {
+		return Command.Builder
+			.withOptions(options)
+			.withAction(Action)
+			.withInput(InputHandler)
+			.withOutput(OutputHandler)
+			.neverInteractive()
+			.build();
+	},
+};

package/src/commands/custom/hook/InputHandler.js

@@ -0,0 +1,8 @@
+/*
+ ** 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 BaseInputHandler = require('../../base/BaseInputHandler');
+
+module.exports = BaseInputHandler;

package/src/commands/custom/hook/OutputHandler.js

@@ -0,0 +1,8 @@
+/*
+ ** 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 BaseOutputHandler = require('../../base/BaseOutputHandler');
+
+module.exports = BaseOutputHandler

package/src/commands/custom/hook/README.md

@@ -0,0 +1,32 @@
+For commands that will be completely reliant on hooks.
+
+Good for temporary commands.
+
+there are no additional command parameters supported. You will need to provide this support in your own way as any attempt to use command line arguments wil result in an error. 
+
+Some options for you are: 
+1. Use different configuration files and point to them with the `--config` option
+2. Build your own interaction
+3. Make a feature request to the author
+
+# Usage: Example
+
+```js
+// in your sdf.config.js file you could have
+module.exports = { 
+	defaultProjectFolder: 'src',
+    commands: { 
+		'custom:hook': { 
+			beforeExecuting(options) {
+				// do stuff
+                if (options.arguments.option1 === 'words') console.log(options.arguments.mulit1.join(' '));
+            }, 
+        }, 
+    },
+};
+```
+
+
+```shell
+sdf custom:hook --option1 words --multi1 hi there guy --flag1
+```