@fontoxml/fontoxml-development-tools/src/FdtLicense.js

import compareVersions from 'compare-versions';
import fs from 'fs';
import os from 'os';
import path from 'path';
import requestPromise from 'request-promise-native';
import util from 'util';

import getParentDirectoryContainingFileSync from './getParentDirectoryContainingFileSync.js';

const readFile = util.promisify(fs.readFile);
const writeFile = util.promisify(fs.writeFile);

const DEFAULT_LICENSE_FILENAME = 'fonto.lic';

const LICENSE_FILE_ERROR_SOLUTION =
	'Please check if you have a license file installed, or contact support for obtaining a license file.';

const MINIMUM_LICENSE_VERSION = 1.0;

const VERSION_TYPES = {
	NIGHTLY: 'nightly',
	PRERELEASE: 'prerelease',
	STABLE: 'stable',
};

class ProductVersions {
	constructor(name, versions) {
		this._name = name;

		this._productVersions = versions
			.sort((a, b) => {
				if (a === VERSION_TYPES.NIGHTLY) {
					return -1;
				}
				if (b === VERSION_TYPES.NIGHTLY) {
					return 1;
				}

				try {
					return compareVersions(b, a);
				} catch (_error) {
					return String(b).localeCompare(a);
				}
			})
			.map((version) => {
				const type =
					version === VERSION_TYPES.NIGHTLY
						? VERSION_TYPES.NIGHTLY
						: version.includes('-')
						? VERSION_TYPES.PRERELEASE
						: VERSION_TYPES.STABLE;

				return { version, type };
			});
	}

	getAll() {
		return this._productVersions.map(
			(productVersion) => productVersion.version
		);
	}

	getAllStable() {
		return this._productVersions.reduce((acc, productVersion) => {
			if (productVersion.type === VERSION_TYPES.STABLE) {
				acc.push(productVersion.version);
			}
			return acc;
		}, []);
	}

	getLatestStable() {
		const latestStableproductVersion = this._productVersions.find(
			(productVersion) => productVersion.type === VERSION_TYPES.STABLE
		);

		return latestStableproductVersion
			? latestStableproductVersion.version
			: null;
	}

	includes(version) {
		return this._productVersions.some(
			(productVersion) => productVersion.version === version
		);
	}
}

export default class FdtLicense {
	constructor(app) {
		this.app = app;

		this._backendBaseUrl =
			process.env.LICENSE_SERVICE_URL ||
			'https://licenseserver.fontoxml.com';

		this._license = this._loadLicenseFile();
	}

	/**
	 * Determine the license file path.
	 *
	 * @return {string|null}
	 */
	_getLicenseFilename() {
		if (process.env.FDT_LICENSE_FILENAME) {
			return process.env.FDT_LICENSE_FILENAME;
		}

		const licenseFilenameInHomedir = path.join(
			os.homedir(),
			DEFAULT_LICENSE_FILENAME
		);
		const licenseFilenameInPathAncestry =
			getParentDirectoryContainingFileSync(
				process.cwd(),
				DEFAULT_LICENSE_FILENAME,
				true
			);

		if (licenseFilenameInPathAncestry) {
			return path.join(
				licenseFilenameInPathAncestry,
				DEFAULT_LICENSE_FILENAME
			);
		}

		try {
			fs.accessSync(licenseFilenameInHomedir, fs.constants.R_OK);
			return licenseFilenameInHomedir;
		} catch (_error) {
			// Do nothing
		}

		return null;
	}

	_decodeAndValidateLicenseFileData(data) {
		let decryptedData;

		try {
			decryptedData = JSON.parse(
				Buffer.from(data, 'base64').toString('utf8')
			);
		} catch (error) {
			return {
				error: new this.app.logger.ErrorWithSolution(
					'License file has invalid data.',
					LICENSE_FILE_ERROR_SOLUTION,
					error
				),
			};
		}

		if (typeof decryptedData !== 'object') {
			return {
				error: new this.app.logger.ErrorWithSolution(
					'License file has invalid data.',
					LICENSE_FILE_ERROR_SOLUTION
				),
			};
		}

		// key
		if (!decryptedData.key || typeof decryptedData.key !== 'string') {
			return {
				error: new this.app.logger.ErrorWithSolution(
					'License file has an invalid key.',
					LICENSE_FILE_ERROR_SOLUTION
				),
			};
		}

		// licensee
		if (
			!decryptedData.licensee ||
			typeof decryptedData.licensee !== 'string'
		) {
			return {
				error: new this.app.logger.ErrorWithSolution(
					'License file has an invalid licensee.',
					LICENSE_FILE_ERROR_SOLUTION
				),
			};
		}

		// products
		if (!decryptedData.products || !Array.isArray(decryptedData.products)) {
			return {
				error: new this.app.logger.ErrorWithSolution(
					'License file has invalid products.',
					LICENSE_FILE_ERROR_SOLUTION
				),
			};
		}

		const hasInvalidProducts = decryptedData.products.some((product) => {
			return (
				typeof product !== 'object' ||
				!product.id ||
				typeof product.id !== 'string' ||
				!product.label ||
				typeof product.label !== 'string'
			);
		});
		if (hasInvalidProducts) {
			return {
				error: new this.app.logger.ErrorWithSolution(
					'License file has invalid products.',
					LICENSE_FILE_ERROR_SOLUTION
				),
			};
		}

		// version
		if (typeof decryptedData.version !== 'number') {
			return {
				error: new this.app.logger.ErrorWithSolution(
					'License file has an invalid version.',
					LICENSE_FILE_ERROR_SOLUTION
				),
			};
		}

		if (decryptedData.version < MINIMUM_LICENSE_VERSION) {
			return {
				error: new this.app.logger.ErrorWithSolution(
					`The license file version is too old for this version of ${
						this.app.getInfo().name
					}.`,
					`Please upgrade your license by running '${
						this.app.getInfo().name
					} license validate'.`
				),
			};
		}

		if (decryptedData.version >= Math.floor(MINIMUM_LICENSE_VERSION) + 1) {
			return {
				error: new this.app.logger.ErrorWithSolution(
					`The license file version is too new for this version of ${
						this.app.getInfo().name
					}.`,
					`Please upgrade ${this.app.getInfo().name}.`
				),
			};
		}

		return {
			data: decryptedData,
		};
	}

	/**
	 * Load the local license file from disk and parse it.
	 *
	 * @return {Object} The license load data.
	 */
	_loadLicenseFile() {
		const filename = this._getLicenseFilename();
		if (!filename) {
			return {
				error: new this.app.logger.ErrorWithSolution(
					'The required license file could not be found.',
					LICENSE_FILE_ERROR_SOLUTION
				),
			};
		}

		let data;
		try {
			data = fs.readFileSync(filename, 'utf8');
		} catch (error) {
			return {
				error: new this.app.logger.ErrorWithSolution(
					'The required license file could not be read.',
					LICENSE_FILE_ERROR_SOLUTION,
					error
				),
			};
		}

		const validationResult = this._decodeAndValidateLicenseFileData(data);

		if (validationResult.data) {
			validationResult.filename = filename;
		}

		return validationResult;
	}

	/**
	 * Get all (public) license information.
	 *
	 * @return {Object|null}
	 * @return {string}        .licensee
	 * @return {Array<Object>} .products
	 */
	getLicenseInfo() {
		if (!this._license.data) {
			return null;
		}

		return {
			filepath: this._license.filename,
			licensee: this._license.data.licensee,
			products: this._license.data.products.map((product) => ({
				...product,
			})),
			version: this._license.data.version,
		};
	}

	/**
	 * Get a buffer for the license file.
	 *
	 * @return {Promise<Buffer>}
	 */
	getLicenseFileBuffer() {
		this.ensureLicenseFileExists();
		return readFile(this._license.filename).catch(() => {
			throw new Error('Could not read the license file.');
		});
	}

	/**
	 * Check if specific product licenses are present. This does not validate remotely.
	 *
	 * Set .setRequiresLicenseValidation() on your command first, if you need to make sure the
	 * license is up to date.
	 *
	 * @param {Array<string>} productIds
	 *
	 * @return {boolean}
	 */
	hasProductLicenses(productIds) {
		if (!this._license.data) {
			return false;
		}

		return productIds.every((productId) => {
			return this._license.data.products.find(
				(product) => product.id === productId
			);
		});
	}

	/**
	 * Check if there is a license file.
	 *
	 * @return {boolean} Returns true if there is a license file, throws otherwise.
	 */
	ensureLicenseFileExists() {
		if (!this._license.data) {
			throw this._license.error;
		}

		return true;
	}

	/**
	 * Ensure the user has the specified products licenses by checking the license file.
	 *
	 * Validate the license with .validateAndUpdateLicenseFile() first if you need to make sure the
	 * license is up to date.
	 *
	 * @param {Array<string>} productIds
	 *
	 * @return {boolean} Returns true if the user has the specified products licenses, throws otherwise.
	 */
	ensureProductLicenses(productIds) {
		this.ensureLicenseFileExists();

		const missingProductIds = productIds.filter((productId) => {
			return !this._license.data.products.find(
				(product) => product.id === productId
			);
		});

		if (missingProductIds.length) {
			throw new this.app.logger.ErrorWithSolution(
				`You appear to be missing one of the required product licenses (${missingProductIds.join(
					', '
				)}).`,
				`Check if your license is valid and have the required product licenses by running '${
					this.app.getInfo().name
				} license validate', and afterwards try to run the current command again.`
			);
		}

		return true;
	}

	/**
	 * Get the telemetry data for the system on which FDT is running.
	 *
	 * @return {Object}
	 */
	_getSystemTelemetryData() {
		return {
			fdt: {
				version: this.app.version,
			},
			node: {
				version: process.version,
				platform: process.platform,
				architecture: process.arch,
			},
		};
	}

	/**
	 * Validate the license by checking for validity online. This will also update the local license
	 * file in case the license is changed remotely.
	 *
	 * @return {Promise<boolean>}
	 */
	validateAndUpdateLicenseFile() {
		return this.getLicenseFileBuffer()
			.then((licenseFileBuffer) => {
				// Remotely validate the license file.
				return requestPromise.post(
					`${this._backendBaseUrl}/license/validate`,
					{
						formData: {
							request: {
								value: JSON.stringify(
									this._getSystemTelemetryData()
								),
								options: {
									contentType: 'application/json',
								},
							},
							license: {
								value: licenseFileBuffer,
								options: {
									filename: DEFAULT_LICENSE_FILENAME,
									contentType: 'application/octet-stream',
								},
							},
						},
						resolveWithFullResponse: true,
						simple: false,
					}
				);
			})
			.catch((error) => {
				if (error.hasOwnProperty('solution')) {
					throw error;
				}

				throw new Error(
					`Could not get response from license server. Please check if you have a working internet connection.`
				);
			})
			.then((response) => {
				switch (response.statusCode) {
					case 200: {
						// Validate response before writing to disk.
						const validationResult =
							this._decodeAndValidateLicenseFileData(
								response.body
							);
						if (validationResult.error) {
							throw new Error(
								'Invalid updated license data received while checking license.'
							);
						}

						// Update license file on disk.
						return writeFile(this._license.filename, response.body)
							.catch((_error) => {
								throw new Error(
									'Could not update local license file.'
								);
							})
							.then(() => {
								// Update license file in memory.
								this._license = this._loadLicenseFile();

								if (!this._license.data) {
									throw this._license.error;
								}

								return true;
							});
					}
					case 204:
						return true;
					case 400: {
						const error = new Error(
							`License is invalid. Run '${
								this.app.getInfo().name
							} license validate' to check your license.`
						);
						error.statusCode = response.statusCode;
						throw error;
					}
					case 401:
					case 403: {
						const error = new Error(
							`License is not valid (anymore). Run '${
								this.app.getInfo().name
							} license validate' to check your license.`
						);
						error.statusCode = response.statusCode;
						throw error;
					}
					default: {
						const error = new Error(
							`Error while checking license (${response.statusCode}).`
						);
						error.statusCode = response.statusCode;
						throw error;
					}
				}
			});
	}

	/**
	 * Get data for a specific product(s). This can be, for example, credentials for specific systems or urls for specific systems.
	 *
	 * @param {Object} productsWithData
	 * @param {Object} productsWithData.<productId>
	 *
	 * @return {Promise<Object>} An Object containing the data for the products, in the same format as the request, but filled with response values instead of request values.
	 */
	getDataForProducts(productsWithData) {
		return this.getLicenseFileBuffer()
			.then((licenseFileBuffer) => {
				// Remotely get the required data.
				return requestPromise.post(
					`${this._backendBaseUrl}/product/data`,
					{
						formData: {
							request: {
								value: JSON.stringify(
									Object.assign(
										this._getSystemTelemetryData(),
										{
											products: productsWithData,
										}
									)
								),
								options: {
									contentType: 'application/json',
								},
							},
							license: {
								value: licenseFileBuffer,
								options: {
									filename: DEFAULT_LICENSE_FILENAME,
									contentType: 'application/octet-stream',
								},
							},
						},
						resolveWithFullResponse: true,
						simple: false,
					}
				);
			})
			.catch((error) => {
				if (error.hasOwnProperty('solution')) {
					throw error;
				}

				throw new Error(
					`Could not get response from license server. Please check if you have a working internet connection.`
				);
			})
			.then((response) => {
				switch (response.statusCode) {
					case 200: {
						let data;
						try {
							data = JSON.parse(response.body);
						} catch (_error) {
							throw new Error(
								'Invalid response data while getting data for products.'
							);
						}
						return data;
					}
					case 400: {
						const error = new Error(
							`License is invalid. Run '${
								this.app.getInfo().name
							} license validate' to check your license.`
						);
						error.statusCode = response.statusCode;
						throw error;
					}
					case 401:
					case 403: {
						const error = new Error(
							`License is not valid (anymore). Run '${
								this.app.getInfo().name
							} license validate' to check your license.`
						);
						error.statusCode = response.statusCode;
						throw error;
					}
					case 404: {
						const error = new Error(
							'Could not get requested data, because one or more of the requested products or their data does not exist.'
						);
						error.statusCode = response.statusCode;
						throw error;
					}
					default: {
						const error = new Error(
							`Error while getting data for products (${response.statusCode}).`
						);
						error.statusCode = response.statusCode;
						throw error;
					}
				}
			});
	}

	/**
	 * Get the versions available of the specified Fonto product.
	 *
	 * @param {string}     productName
	 *
	 * @return {Promise<ProductVersions>}
	 */
	getVersionsForProduct(productName) {
		const requestObj = {};
		requestObj[productName] = {
			versions: true,
		};

		return this.getDataForProducts(requestObj).then((productData) => {
			return new ProductVersions(
				productName,
				productData.products[productName].versions
			);
		});
	}

	/**
	 * Send telemetry data to the license server.
	 *
	 * @param {Object} data
	 *
	 * @return {Promise<void>}
	 */
	sendTelemetry(data) {
		return this.getLicenseFileBuffer()
			.then((licenseFileBuffer) => {
				return requestPromise.post(
					`${this._backendBaseUrl}/telemetry`,
					{
						formData: {
							request: {
								value: JSON.stringify(
									Object.assign(
										this._getSystemTelemetryData(),
										{
											data,
										}
									)
								),
								options: {
									contentType: 'application/json',
								},
							},
							license: {
								value: licenseFileBuffer,
								options: {
									filename: DEFAULT_LICENSE_FILENAME,
									contentType: 'application/octet-stream',
								},
							},
						},
						resolveWithFullResponse: true,
						simple: false,
						timeout: 10000,
					}
				);
			})
			.then((response) => {
				switch (response.statusCode) {
					case 200:
					case 204:
						break;
					default: {
						const error = new Error(
							`Error while sending telemetry (${response.statusCode}).`
						);
						error.statusCode = response.statusCode;
						throw error;
					}
				}
			})
			.catch((_error) => {
				if (!this.app.hideStacktraceOnErrors) {
					this.app.logger.notice('Error while sending telemetry.');
				}
			});
	}
}