@suitegeezus/suitecloud-cli 3.1.4

package/src/services/FileSystemService.js

@@ -0,0 +1,245 @@
+/*
+ ** 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 { lstatSync, readdirSync, readFile, writeFile, mkdirSync, renameSync, existsSync, unlinkSync, rmdirSync } = require('fs');
+const CLIException = require('../CLIException');
+const assert = require('assert');
+const path = require('path');
+const NodeTranslationService = require('../services/NodeTranslationService');
+const { CANT_CREATE_FOLDER } = require('../services/TranslationKeys').ERRORS;
+
+const CHAR_ENCODING_UTF8 = 'utf-8';
+
+module.exports = class FileSystemService {
+	getFoldersFromDirectory(parentFolder) {
+		assert(parentFolder);
+		const getDirectories = source =>
+			readdirSync(source)
+				.map(name => path.join(source, name))
+				.filter(source => lstatSync(source).isDirectory());
+
+		const availableDirectories = getDirectories(parentFolder);
+
+		return availableDirectories;
+	}
+
+	getFoldersFromDirectoryRecursively(parentFolder) {
+		assert(parentFolder);
+		if (!existsSync(parentFolder)) {
+			return [];
+		}
+		const folders = [];
+		const getFoldersRecursively = source =>
+				this.getFoldersFromDirectory(source).forEach(folder => {
+				folders.push(folder);
+				getFoldersRecursively(folder);
+			});
+		getFoldersRecursively(parentFolder);
+
+		return folders;
+	}
+
+	getFilesFromDirectory(parentFolder) {
+		assert(parentFolder);
+		const fullPathFiles = [];
+		const getFilesRecursively = source =>
+			readdirSync(source).forEach(file => {
+				const fullPath = path.join(source, file);
+				if (lstatSync(fullPath).isDirectory()) {
+					getFilesRecursively(fullPath);
+				} else {
+					fullPathFiles.push(fullPath);
+				}
+			});
+
+		getFilesRecursively(parentFolder);
+		return fullPathFiles;
+	}
+
+	/**
+	 * @see {FileSystemService}
+	 */
+	getFirstAncestorByName(names, startingPath, isDirectory = false) {
+		assert(names);
+		assert(names.length);
+		assert(startingPath);
+		let filesFound = [];
+		let limitReached = false;
+		try {
+			const getAncestorsRecursively = source => {
+				if (source === '/') limitReached = true;
+
+				if(limitReached) return;
+
+				const firstFound = readdirSync(source).find(fileOrDir => {
+					const fullPath = path.join(source, fileOrDir);
+					if(isDirectory && lstatSync(fullPath).isDirectory()){
+						if( names.includes(fileOrDir)) return true;
+					}
+
+					if (lstatSync(fullPath).isFile()) {
+						if (fileOrDir === 'package.json') limitReached = true;
+						if (!isDirectory && names.includes(fileOrDir)) return true;
+					}
+				});
+				const nextPath = path.join(source, '..');
+				if (nextPath === source) limitReached = true;
+
+				if( firstFound ) {
+					filesFound.push(path.resolve(path.join(source,firstFound)));
+					return;
+				}
+
+				if(limitReached) return;
+
+				getAncestorsRecursively(nextPath);
+			}
+			getAncestorsRecursively(startingPath);
+		} catch {
+			return;
+		}
+
+		return filesFound.shift();
+	}
+
+	createFileFromTemplate(options) {
+		assert(options.template);
+		assert(options.destinationFolder);
+		assert(options.fileName);
+
+		return new Promise((resolve, reject) => {
+			readFile(options.template, CHAR_ENCODING_UTF8, (readingError, content) => {
+				if (readingError) {
+					reject(readingError);
+				}
+				if (Array.isArray(options.bindings)) {
+					content = this._processTemplateBindings(content, options.bindings);
+				}
+
+				const fullFileName = options.fileExtension ? `${options.fileName}.${options.fileExtension}` : `${options.fileName}`;
+
+				writeFile(
+					path.join(options.destinationFolder, fullFileName),
+					content.toString(),
+					(writingError, data) => {
+						if (writingError) {
+							reject(writingError);
+						}
+						resolve();
+					}
+				);
+			});
+		});
+	}
+
+	createFolder(parentFolderPath, folderName) {
+		assert(parentFolderPath);
+		assert(folderName);
+
+		return this.createFolderFromAbsolutePath(path.join(parentFolderPath, folderName));
+	}
+
+	createFolderFromAbsolutePath(folderAbsolutePath) {
+		assert(folderAbsolutePath);
+
+		try {
+			if (!existsSync(folderAbsolutePath)) {
+				mkdirSync(path.join(folderAbsolutePath));
+			}
+		} catch (e) {
+			throw new CLIException(NodeTranslationService.getMessage(CANT_CREATE_FOLDER, e.path, e.code));
+		}
+
+		return folderAbsolutePath;
+	}
+
+	renameFolder(oldPath, newPath) {
+		assert(oldPath);
+		assert(newPath);
+
+		if (existsSync(oldPath) && oldPath !== newPath) {
+			renameSync(oldPath, newPath);
+		}
+	}
+
+	deleteFolderRecursive(folderPath) {
+		assert(folderPath);
+
+		let self = this;
+		if (existsSync(folderPath)) {
+			readdirSync(folderPath).forEach(file => {
+				let currentPath = path.join(folderPath, file);
+				if (lstatSync(currentPath).isDirectory()) {
+					self.deleteFolderRecursive(currentPath);
+				} else {
+					unlinkSync(currentPath);
+				}
+			});
+			rmdirSync(folderPath);
+		}
+	}
+
+	emptyFolderRecursive(folderPath) {
+		assert(folderPath);
+		let self = this;
+		if (existsSync(folderPath)) {
+			readdirSync(folderPath).forEach(file => {
+				let currentPath = path.join(folderPath, file);
+				if (lstatSync(currentPath).isDirectory()) {
+					self.deleteFolderRecursive(currentPath);
+				} else {
+					unlinkSync(currentPath);
+				}
+			});
+		}
+	}
+
+	replaceStringInFile(filePath, fromString, toString) {
+		assert(filePath);
+		assert(fromString);
+		assert(toString);
+
+		return new Promise((resolve, reject) => {
+			readFile(filePath, CHAR_ENCODING_UTF8, (readingError, content) => {
+				if (readingError) {
+					reject(readingError);
+				}
+
+				let result = content.replace(new RegExp(fromString, 'g'), toString);
+
+				writeFile(filePath, result, function(writingError) {
+					if (writingError) {
+						reject(writingError);
+					}
+
+					resolve();
+				});
+			});
+		});
+	}
+
+	folderExists(path) {
+		assert(path);
+		return existsSync(path);
+	}
+
+	fileExists(path) {
+		return this.folderExists(path);
+	}
+
+	isFolderEmpty(path) {
+		assert(path);
+		return readdirSync(path).length === 0;
+	}
+
+	_processTemplateBindings(content, bindings) {
+		let processedContent = content;
+		bindings.forEach(binding => {
+			processedContent = content.replace(`{{${binding.id}}}`, binding.value);
+		});
+		return processedContent;
+	}
+};

package/src/services/NodeTranslationService.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 path = require('path');
+const TranslationService = require('./TranslationService');
+const { DEFAULT_MESSAGES_FILE } = require('../ApplicationConstants');
+const FileUtils = require('../utils/FileUtils');
+
+class NodeTranslationService extends TranslationService {
+	constructor() {
+		super();
+		const filePath = path.join(__dirname, DEFAULT_MESSAGES_FILE);
+		// TODO refactor: use node require instead of FileUtils.readAsJson the initialize this._MESSAGES.
+		// Once the refactor is done FileUtils will be able to use NodeTranslationService again without a circular dependency.
+		this._MESSAGES = FileUtils.readAsJson(filePath);
+	}
+}
+
+module.exports = new NodeTranslationService();

package/src/services/NpmInstallRunner.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.
+*/
+const childProcess = require('child_process');
+
+const PLATFORM_WIN = 'win32';
+const COMMAND_NPM_WIN = 'npm.cmd';
+const COMMAND_NPM_UNIX = 'npm';
+const NPM_ARG_INSTALL = 'install';
+const NPM_RESULT_CLOSE = 'close';
+
+module.exports = {
+	run: function(projectAbsolutePath) {
+		return new Promise((resolve, reject) => {
+			let npm = process.platform === PLATFORM_WIN ? COMMAND_NPM_WIN : COMMAND_NPM_UNIX;
+
+			const result = childProcess.spawn(npm, [NPM_ARG_INSTALL], {
+				cwd: projectAbsolutePath,
+				stdio: 'inherit',
+				windowsHide: true
+			});
+
+			result.on(NPM_RESULT_CLOSE, code => {
+				if (code === 0) {
+					resolve();
+				} else if (code !== 0) {
+					reject();
+				}
+			});
+		});
+	}
+};

package/src/services/ProjectInfoService.js

@@ -0,0 +1,209 @@
+/*
+ ** 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 { ERRORS } = require('./TranslationKeys');
+const {
+	FILES,
+	FOLDERS,
+	LINKS: { INFO },
+	PROJECT_ACP,
+	PROJECT_SUITEAPP
+} = require('../ApplicationConstants');
+const CLIException = require('../CLIException');
+const FileUtils = require('../utils/FileUtils');
+const path = require('path');
+const NodeTranslationService = require('./NodeTranslationService');
+const xml2js = require('xml2js');
+const assert = require('assert');
+const { lineBreak } = require('../loggers/LoggerOsConstants');
+
+const MANIFEST_TAG_XML_PATH = '/manifest';
+const PROJECT_TYPE_ATTRIBUTE = 'projecttype';
+const MANIFEST_TAG_REGEX = '[\\s\\n]*<manifest.*>[^]*</manifest>[\\s\\n]*$';
+
+module.exports = class ProjectInfoService {
+	constructor(projectFolder) {
+		assert(projectFolder);
+		this._CACHED_PROJECT_TYPE = null;
+		this._CACHED_PROJECT_NAME = null;
+		this._CACHED_PUBLISHER_ID = null;
+		this._CACHED_PROJECT_ID = null;
+		this._projectFolder = projectFolder;
+	}
+
+	/**
+	 * This validation function has to be defined in xml2js.Parser in the "validator" option
+	 * When calling parserString this function will be executed for every tag of the xml we are
+	 * parsing.
+	 * @param {string} xmlPath Path of the tag that it's being evaluated at the current moment.
+	 * @param {Object} previousValue Existing value at this path if there is already one (e.g. this
+	 * 								  is the second or later item in an array).
+	 * @param {Object} newValue Value of the tag that it's being evaluated at the current moment.
+	 * @throws ValidationError if the validation fails
+	 */
+	_validateXml(xmlPath, previousValue, newValue) {
+		//TODO Add more cases
+		if (xmlPath === MANIFEST_TAG_XML_PATH) {
+			let manifestTagAttributes = newValue['$'];
+			if (!manifestTagAttributes || !manifestTagAttributes[PROJECT_TYPE_ATTRIBUTE]) {
+				throw new xml2js.ValidationError(
+					NodeTranslationService.getMessage(ERRORS.XML_PROJECTTYPE_ATTRIBUTE_MISSING)
+				);
+			} else if (
+				manifestTagAttributes[PROJECT_TYPE_ATTRIBUTE] !== PROJECT_SUITEAPP &&
+				manifestTagAttributes[PROJECT_TYPE_ATTRIBUTE] !== PROJECT_ACP
+			) {
+				throw new xml2js.ValidationError(
+					NodeTranslationService.getMessage(ERRORS.XML_PROJECTTYPE_INCORRECT)
+				);
+			}
+		}
+		return newValue;
+	}
+
+	getProjectType() {
+		if (!this._CACHED_PROJECT_TYPE) {
+			this._parseManifest();
+		}
+
+		return this._CACHED_PROJECT_TYPE;
+	}
+
+	getProjectName() {
+		if (!this._CACHED_PROJECT_NAME) {
+			this._parseManifest();
+		}
+		return this._CACHED_PROJECT_NAME;
+	}
+
+	getPublisherId() {
+		if (!this._CACHED_PUBLISHER_ID) {
+			this._parseManifest();
+		}
+
+		return this._CACHED_PUBLISHER_ID;
+	}
+
+	getProjectId() {
+		if (!this._CACHED_PROJECT_ID) {
+			this._parseManifest();
+		}
+
+		return this._CACHED_PROJECT_ID;
+	}
+
+	getApplicationId() {
+		return this.getPublisherId() + '.' + this.getProjectId();
+	}
+
+	_parseManifest() {
+		const manifestPath = this._getManifestPath();
+		const manifestString = this._getManifestString(manifestPath);
+
+		let projectName;
+		let projectType;
+		let publisherId;
+		let projectId;
+		let validationError;
+
+		let parser = new xml2js.Parser({ validator: this._validateXml });
+
+		parser.parseString(manifestString, function (err, result) {
+			if (err) {
+				const errorMessage = NodeTranslationService.getMessage(ERRORS.PROCESS_FAILED) +
+					' ' +
+					NodeTranslationService.getMessage(ERRORS.FILE, manifestPath);
+				validationError = errorMessage + ' ' + err;
+			}
+
+			if (result) {
+				projectType = result.manifest.$.projecttype;
+				projectName = result.manifest.projectname;
+				publisherId = result.manifest.publisherid;
+				projectId = result.manifest.projectid;
+			}
+		});
+
+		//TODO CHECK XML IS VALID
+		if (validationError) {
+			throw new CLIException(validationError);
+		}
+		this._CACHED_PROJECT_TYPE = projectType;
+		this._CACHED_PROJECT_NAME = projectName;
+		this._CACHED_PUBLISHER_ID = publisherId;
+		this._CACHED_PROJECT_ID = projectId;
+	}
+
+	_getManifestPath() {
+		const manifestPath = path.join(this._projectFolder, FILES.MANIFEST_XML);
+
+		if (!FileUtils.exists(manifestPath)) {
+			const errorMessage = NodeTranslationService.getMessage(ERRORS.PROCESS_FAILED) +
+				' ' +
+				NodeTranslationService.getMessage(ERRORS.FILE_NOT_EXIST, manifestPath) +
+				lineBreak +
+				NodeTranslationService.getMessage(ERRORS.SEE_PROJECT_STRUCTURE, INFO.PROJECT_STRUCTURE);
+
+			throw new CLIException(errorMessage);
+		}
+		return manifestPath;
+	}
+
+	_getManifestString(manifestPath) {
+		const manifestString = FileUtils.readAsString(manifestPath);
+
+		if (!manifestString.match(MANIFEST_TAG_REGEX)) {
+			const errorMessage = NodeTranslationService.getMessage(ERRORS.PROCESS_FAILED) +
+				' ' +
+				NodeTranslationService.getMessage(ERRORS.XML_MANIFEST_TAG_MISSING);
+			throw new CLIException(errorMessage);
+		}
+		return manifestString;
+	}
+
+	hasLockAndHideFiles() {
+		const pathToInstallationPreferences = path.join(
+			this._projectFolder,
+			FOLDERS.INSTALLATION_PREFERENCES
+		);
+		return (
+			FileUtils.exists(
+				path.join(pathToInstallationPreferences, FILES.HIDING_PREFERENCE)
+			) &&
+			FileUtils.exists(
+				path.join(pathToInstallationPreferences, FILES.LOCKING_PREFERENCE)
+			)
+		);
+	}
+
+	isAccountCustomizationProject() {
+		try {
+			return this.getProjectType() === PROJECT_ACP;
+		} catch (error) {
+			return false;
+		}
+	}
+
+	isSuiteAppProject() {
+		try {
+			return this.getProjectType() === PROJECT_SUITEAPP;
+		} catch (error) {
+			return false;
+		}
+	}
+
+	isSuiteCloudProject() {
+		return this.isAccountCustomizationProject() || this.isSuiteAppProject();
+	}
+
+	checkWorkingDirectoryContainsValidProject(commandName) {
+		if (!FileUtils.exists(path.join(this._projectFolder, FILES.MANIFEST_XML))) {
+			const errorMessage = NodeTranslationService.getMessage(ERRORS.NOT_PROJECT_FOLDER, FILES.MANIFEST_XML, this._projectFolder, commandName)
+				+ lineBreak + NodeTranslationService.getMessage(ERRORS.SEE_PROJECT_STRUCTURE, INFO.PROJECT_STRUCTURE);
+			throw new CLIException(errorMessage);
+		}
+	}
+};