@harperfast/harper 5.0.0-alpha.10 → 5.0.0-beta.1

package/upgrade/upgradePrompt.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const prompt = require('prompt');
+const chalk = require('chalk');
+const log = require('../utility/logging/harper_logger.js');
+const os = require('os');
+const assignCMDENVVariables = require('../utility/assignCmdEnvVariables.js');
+
+const UPGRADE_PROCEED = ['yes', 'y'];
+
+/**
+ * Prompt the user that they need to run the upgrade scripts, typically after upgrading via a package manager.
+ * @param _upgradeObj - {UpgradeObject} Object includes the versions the data and current install are on
+ * @returns {Promise<boolean>}
+ */
+async function forceUpdatePrompt(_upgradeObj) {
+	let upgradeMessage =
+		`${os.EOL}` +
+		chalk.bold.green('Your current Harper version requires that we complete an update process.') +
+		`${os.EOL}` +
+		'If a backup of your data has not been created, we recommend you cancel this process and backup before proceeding.' +
+		`${os.EOL}${os.EOL}` +
+		'You can read more about the changes in this upgrade at https://harperdb.io/developers/release-notes/' +
+		`${os.EOL}`;
+	prompt.override = assignCMDENVVariables(['CONFIRM_UPGRADE']);
+	prompt.start();
+	prompt.message = upgradeMessage;
+	let upgradeConfirmation = {
+		properties: {
+			CONFIRM_UPGRADE: {
+				description: chalk.magenta(`${os.EOL}[CONFIRM_UPGRADE] Do you want to upgrade your HDB instance now? (yes/no)`),
+				pattern: /y(es)?$|n(o)?$/,
+				message: "Must respond 'yes' or 'no'",
+				default: 'no',
+				required: true,
+			},
+		},
+	};
+
+	let response;
+	try {
+		response = await prompt.get([upgradeConfirmation]);
+	} catch (err) {
+		log.error('There was an error when prompting user about an upgrade.');
+		log.error(err);
+		return false;
+	}
+
+	return UPGRADE_PROCEED.includes(response.CONFIRM_UPGRADE);
+}
+
+/**
+ * Prompt the user before proceeding with a minor version downgrade
+ * @param _upgradeObj - {UpgradeObject} Object includes the versions the data and current install are on
+ * @returns {Promise<boolean>}
+ */
+async function forceDowngradePrompt(_upgradeObj) {
+	let downgradeMessage =
+		`${os.EOL}` +
+		chalk.bold.green(
+			'Your installed Harper version is older than the version used to create your data.' +
+				' Downgrading is not recommended as it is not tested and guaranteed to work. However, if you need to' +
+				' downgrade, and a backup of your data has not been created, we recommend you cancel this process and' +
+				' backup before proceeding.' +
+				`${os.EOL}`
+		);
+	prompt.override = assignCMDENVVariables(['CONFIRM_DOWNGRADE']);
+	prompt.start();
+	prompt.message = downgradeMessage;
+	let downgradeConfirmation = {
+		properties: {
+			CONFIRM_DOWNGRADE: {
+				description: chalk.magenta(
+					`${os.EOL}[CONFIRM_DOWNGRADE] Do you want to proceed with using your downgraded HDB instance now? (yes/no)`
+				),
+				pattern: /y(es)?$|n(o)?$/,
+				message: "Must respond 'yes' or 'no'",
+				default: 'no',
+				required: true,
+			},
+		},
+	};
+
+	let response = await prompt.get([downgradeConfirmation]);
+
+	return UPGRADE_PROCEED.includes(response.CONFIRM_DOWNGRADE);
+}
+
+async function upgradeCertsPrompt() {
+	const upgradeCertMessage =
+		`${os.EOL}` +
+		chalk.bold.green(
+			'We now require a Certifacte Authority certificate. Harper can generate all new certificates for you (your existing certificates will be backed up) ' +
+				'or you can keep any existing certificates and add your own CA certificate. To add your own CA certificate set the <certificateAuthority> ' +
+				'parameter in harperdb-config.yaml'
+		);
+
+	prompt.override = assignCMDENVVariables(['GENERATE_CERTS']);
+	prompt.start();
+	prompt.message = upgradeCertMessage;
+	let upgradeConfirmation = {
+		properties: {
+			GENERATE_CERTS: {
+				description: chalk.magenta(
+					`${os.EOL}[GENERATE_CERTS] Do you want Harper to generate all new certificates? (yes/no)`
+				),
+				pattern: /y(es)?$|n(o)?$/,
+				message: "Must respond 'yes' or 'no'",
+				default: 'yes',
+				required: true,
+			},
+		},
+	};
+
+	const response = await prompt.get([upgradeConfirmation]);
+
+	return UPGRADE_PROCEED.includes(response.GENERATE_CERTS);
+}
+
+module.exports = {
+	forceUpdatePrompt,
+	forceDowngradePrompt,
+	upgradeCertsPrompt,
+};

package/upgrade/upgradeUtilities.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const hdbUtil = require('../utility/common_utils.js');
+const configUtils = require('../config/configUtils.js');
+
+module.exports = {
+	getOldPropsValue,
+};
+
+/**
+ * We need to make sure we are setting empty string for values that are null/undefined/empty string - PropertiesReader
+ * castes values in some awkward ways and this covers those scenarios AND ensures we have default values set for new
+ * config values that may have been added in a previous version (between when user installed HDB and is now upgrading)
+ * @param propName
+ * @param oldHdbProps
+ * @param valueRequired
+ * @returns {string|*}
+ */
+function getOldPropsValue(propName, oldHdbProps, valueRequired = false) {
+	const oldVal = oldHdbProps.getRaw(propName);
+	if (hdbUtil.isNotEmptyAndHasValue(oldVal)) {
+		return oldVal;
+	}
+	if (valueRequired) {
+		return configUtils.getDefaultConfig(propName);
+	}
+	return '';
+}

package/utility/AWS/AWSConnector.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { S3, GetObjectCommand } = require('@aws-sdk/client-s3');
+
+module.exports = {
+	getFileStreamFromS3,
+	getS3AuthObj,
+};
+
+async function getFileStreamFromS3(jsonMessage) {
+	const { s3 } = jsonMessage;
+	const params = {
+		Bucket: s3.bucket,
+		Key: s3.key,
+	};
+	const authenticatedS3 = getS3AuthObj(s3.aws_access_key_id, s3.aws_secret_access_key, s3.region);
+	const item = await authenticatedS3.send(new GetObjectCommand(params));
+	return item.Body;
+}
+
+function getS3AuthObj(accessKeyId, secretKey, region) {
+	return new S3({
+		credentials: {
+			accessKeyId,
+			secretAccessKey: secretKey,
+		},
+		region,
+	});
+}

package/utility/OperationFunctionCaller.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const log = require('./logging/harper_logger.js');
+const terms = require('./hdbTerms.ts');
+
+/**
+ * Calls the operation function specified in the parameter with the input specified in the parameter.  Once complete,
+ * calls the response function in the parameter with  the operation result as the first parameter.
+ * @param promisifiedFunction - The operation which is in async/await format
+ * @param functionInput - The input needed for the operationFunctionAsCallback function.
+ * @param followupAsyncFunc - The response function that will be called with the operation function response as an input.  The function is expected to be promisifed, callbacks not supported.
+ * @returns {Promise<{}>}
+ */
+async function callOperationFunctionAsAwait(promisifiedFunction, functionInput, followupAsyncFunc) {
+	if (!promisifiedFunction || typeof promisifiedFunction !== 'function') {
+		throw new Error('Invalid function parameter');
+	}
+	let result = undefined;
+	try {
+		result = await promisifiedFunction(functionInput);
+
+		if (followupAsyncFunc) {
+			//TODO: Passing result twice seems silly, why is this a thing?
+			await followupAsyncFunc(functionInput, result);
+		}
+
+		// The result from insert, update, or upsert contains a properties new_attributes/txnTime. It is used by postOperationHandler to propagate
+		// attribute metadata. After the property has been used we no longer need it and do not want the API returning it,
+		// therefore we delete it from the result.
+		if (
+			functionInput.operation === terms.OPERATIONS_ENUM.INSERT ||
+			functionInput.operation === terms.OPERATIONS_ENUM.UPDATE ||
+			functionInput.operation === terms.OPERATIONS_ENUM.UPSERT
+		) {
+			delete result.new_attributes;
+			delete result.txn_time;
+		} else if (functionInput.operation === terms.OPERATIONS_ENUM.DELETE) {
+			delete result.txn_time;
+		}
+
+		return result;
+	} catch (err) {
+		// This specific check was added to avoid an error message in the log which could make the error look worse than it
+		// seems when scanning a log.  In reality a schema already existing isn't really an error, just a failure.
+		if (err.message && typeof err.message === 'string' && err.message.includes('already exists')) {
+			log.info(err.message);
+			throw err;
+		}
+		// This check is here to make sure a new HdbError is logged correctly
+		if (err.http_resp_msg) {
+			log.error(`Error calling operation: ${promisifiedFunction.name}`);
+			log.error(err.http_resp_msg);
+			throw err;
+		}
+		log.error(`Error calling operation: ${promisifiedFunction.name}`);
+		log.error(err);
+		throw err;
+	}
+}
+
+module.exports = {
+	callOperationFunctionAsAwait,
+};

package/utility/assignCmdEnvVariables.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const minimist = require('minimist');
+
+module.exports = assignCMDENVVariables;
+
+/**
+ * This function receives a list of keys used to find if they exist in command line args &/or environment variables (command line always supercedes env vars).
+ * if found they key/value is assigned to the return object
+ * This is here and not common utils to avoid circular dependencies.
+ * @param keys - arrays of keys to search for and assign to the return object
+ * @param isConfigParam
+ * @returns {{}}
+ */
+function assignCMDENVVariables(keys = [], isConfigParam = false) {
+	if (!Array.isArray(keys)) {
+		return {};
+	}
+
+	let envArgs;
+	let cmdArgs;
+	if (isConfigParam) {
+		// Lowercase keys to make mapping to config params work
+		envArgs = objKeysToLowerCase(process.env);
+		cmdArgs = objKeysToLowerCase(minimist(process.argv));
+	} else {
+		envArgs = process.env;
+		cmdArgs = minimist(process.argv);
+	}
+
+	let hdbSettings = {};
+	for (let x = 0, length = keys.length; x < length; x++) {
+		let setting = keys[x];
+
+		//we set the env variable first which gets overridden by a command line arg (if present)
+		if (cmdArgs[setting] !== undefined) {
+			hdbSettings[setting] = cmdArgs[setting].toString().trim();
+		} else if (envArgs[setting] !== undefined) {
+			hdbSettings[setting] = envArgs[setting].toString().trim();
+		}
+	}
+	return hdbSettings;
+}
+
+/**
+ * Creates a new object where all its keys are lowercase
+ * @param obj
+ * @returns {{}}
+ */
+function objKeysToLowerCase(obj) {
+	let key,
+		keys = Object.keys(obj);
+	let i = keys.length;
+	const result = {};
+
+	while (i--) {
+		key = keys[i];
+		result[key.toLowerCase()] = obj[key];
+	}
+
+	return result;
+}