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

import ask from 'ask-nicely';
import path from 'path';
import { fileURLToPath, pathToFileURL } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const FILENAMES_TO_SKIP_FOR_SET_CONTROLLER_CALLSITES = Symbol(
	'FILENAMES_TO_SKIP_FOR_SET_CONTROLLER_CALLSITES'
);

/**
 * A FDT custom version of AskNicely#Command that has extra options for checking Fonto specific commands.
 *
 * @augments AskNicely.Command
 */
export default class FdtCommand extends ask.Command {
	/**
	 * @constructor
	 * @param {string} commandName
	 * @param {function(AskNicelyRequest, FdtResponse)} [controller]
	 */
	constructor(commandName, controller) {
		super(commandName, controller);

		this._moduleRegistration = null;

		this.examples = [];
		this.isHelpCommand = false;
		this.longDescription = null;

		this.hideIfMissingRequiredProductLicenses = false;
		this.requiredProductLicenses = [];
		this.requiresEditorRepository = false;
		this.requiresToValidateLicenseFile = false;

		this.rawOutput = false;

		this.setNewChildClass(FdtCommand);

		this.addPreController(this._preController.bind(this));
	}

	static addFileNameToSkipForSetControllerCallsites(fileNameToSkip) {
		FdtCommand[FILENAMES_TO_SKIP_FOR_SET_CONTROLLER_CALLSITES].push(
			path.join(fileNameToSkip)
		);
	}

	/**
	 * Get the module registration to which this command, or it's ancestors, belongs.
	 *
	 * @return {ModuleRegistration|null} The module registration.
	 */
	getModuleRegistration() {
		let command = this;
		while (command) {
			if (command._moduleRegistration) {
				return command._moduleRegistration;
			}
			command = command.parent;
		}
		return null;
	}

	_createLazyLoadController(controllerSource) {
		if (!path.isAbsolute(controllerSource)) {
			throw new Error(
				`Command controller "${controllerSource}" should be registered using an absolute path instead of a relative one.`
			);
		}

		return (...args) => {
			return import(pathToFileURL(controllerSource)).then((module) =>
				module.default(...args)
			);
		};
	}

	/**
	 * Set the main controller.
	 *
	 * @param {string|function(AskNicelyRequest, FdtResponse)} [controller]
	 *
	 * @return {FdtCommand} This command.
	 */
	setController(controller) {
		if (typeof controller === 'string') {
			controller = this._createLazyLoadController(controller);
		}

		return super.setController(controller);
	}

	/**
	 * Register an example usage of this command. Each example is rendered as a definition item,
	 * meaning the definition is indented below the caption.
	 *
	 * @param {string} caption
	 * @param {string} content
	 *
	 * @return {FdtCommand}
	 */
	addExample(caption, content) {
		this.examples.push({
			caption,
			content,
		});

		return this;
	}

	/**
	 * Register a hidden command as a child of this, and register this as parent of the child.
	 *
	 * @param {string|Command} commandName The identifying name of this option, unique for its ancestry.
	 * @param {string|function(AskNicelyRequest, FdtResponse)} [controller]
	 *
	 * @return {Command} The child command.
	 */
	addHiddenCommand(commandName, controller) {
		const addedCommand = super.addCommand(commandName, controller);
		addedCommand.hidden = true;
		return addedCommand;
	}

	/**
	 * Describe a hidden option.
	 *
	 * @param {Option|string} long          The identifying name of this option, unique for its ancestry.
	 * @param {string}        [short]       A one-character alias of this option, unique for its ancestry.
	 * @param {string}        [description] A description for the option.
	 * @param {boolean}       [required]    If true, an omittance would throw an error.
	 *
	 * @return {Command}
	 */
	addHiddenOption(long, short, description, required) {
		super.addOption(long, short, description, required);
		const addedOption = this.options[this.options.length - 1];
		addedOption.hidden = true;
		return this;
	}

	/**
	 * Register a long description for a command - one that is printed in the full width of the terminal.
	 *
	 * @param {string} description
	 * @return {FdtCommand}
	 */
	setLongDescription(description) {
		this.longDescription = description;

		return this;
	}

	/**
	 * Configure this command to not execute a controller, but instead output the help as if the
	 * --help option was passed to the command.
	 *
	 * @param {boolean} enabled
	 *
	 * @return {FdtCommand}
	 */
	setAsHelpCommand(enabled) {
		this.isHelpCommand = enabled !== undefined ? !!enabled : true;

		return this;
	}

	/**
	 * Gets the "long" name of a command, which includes the parameters and the long names of it's ancestors.
	 *
	 * @return {string}
	 */
	getLongName() {
		return (this.parent ? [this.parent.getLongName()] : [])
			.concat([this.name])
			.concat(this.parameters.map((parameter) => `<${parameter.name}>`))
			.join(' ');
	}

	/**
	 * Pre-controller which performs optional checks before executing the actual controller.
	 *
	 * @param {Object}  req
	 * @param {Object}  res
	 *
	 * @return {Promise}
	 */
	_preController(req, res) {
		let preControllerPromise = Promise.resolve();

		if (this.requiresEditorRepository) {
			preControllerPromise = preControllerPromise.then(() => {
				req.fdt.editorRepository.throwIfNotInsideEditorRepository();
			});
		}

		if (this.requiresToValidateLicenseFile) {
			preControllerPromise = preControllerPromise.then(() => {
				const destroySpinner = res.spinner('Validating license...');

				return req.fdt.license
					.validateAndUpdateLicenseFile()
					.then((result) => {
						destroySpinner();
						return result;
					})
					.catch((error) => {
						destroySpinner();
						throw error;
					});
			});
		}

		if (this.requiredProductLicenses.length > 0) {
			preControllerPromise = preControllerPromise.then(() => {
				const destroySpinner = res.spinner(
					'Checking required product licenses...'
				);

				try {
					req.fdt.license.ensureProductLicenses(
						this.requiredProductLicenses
					);
					destroySpinner();
				} catch (error) {
					destroySpinner();
					throw error;
				}

				return true;
			});
		}

		return preControllerPromise;
	}

	/**
	 * Add a list of required product licenses for performing this command. If the user does not have
	 * access to a product, the command will fail.
	 *
	 * @param {Array<string>} productIds
	 *
	 * @return {FdtCommand}
	 */
	addRequiredProductLicenses(productIds) {
		this.requiredProductLicenses =
			this.requiredProductLicenses.concat(productIds);

		return this;
	}

	/**
	 * Hide the command if a required product license is not available.
	 *
	 * @param {boolean} [hide=true]
	 *
	 * @return {FdtCommand}
	 */
	setHideIfMissingRequiredProductLicenses(hide = true) {
		this.hideIfMissingRequiredProductLicenses = !!hide;

		return this;
	}

	/**
	 * If set, check the license for validity online before executing the command, fail
	 * otherwise.
	 *
	 * @param {boolean} [validateLicense=true]
	 *
	 * @return {FdtCommand}
	 */
	setRequiresLicenseValidation(validateLicense = true) {
		this.requiresToValidateLicenseFile = !!validateLicense;

		return this;
	}

	/**
	 * If set, check if running from an editor repository before executing the command, fail
	 * otherwise.
	 *
	 * @param {boolean} [value=true]
	 *
	 * @return {FdtCommand}
	 */
	setRequiresEditorRepository(value = true) {
		this.requiresEditorRepository = !!value;

		return this;
	}

	/**
	 * If set, the output will be optimized for raw/machine readable output.
	 *
	 * Accepts either a boolean, or a function, which receives the request object, and should return
	 * a boolean indicating if the command should use raw output. This can be useful when raw output
	 * is dependend on, for example, an option.
	 *
	 * Setting to, or returning, true has the following impact:
	 * * Use response.raw() to skip any output formatting.
	 *
	 * @param {boolean|function(request): boolean} [value=true]
	 *
	 * @return {FdtCommand}
	 */
	setRawOutput(value = true) {
		this.rawOutput = value;

		return this;
	}
}

const fdtBasename = path.basename(path.resolve(__dirname, '..'));
FdtCommand[FILENAMES_TO_SKIP_FOR_SET_CONTROLLER_CALLSITES] = [];
FdtCommand.addFileNameToSkipForSetControllerCallsites(
	'/ask-nicely/dist/AskNicely.js'
);
FdtCommand.addFileNameToSkipForSetControllerCallsites(
	`/${fdtBasename}/src/FdtCommand.js`
);
FdtCommand.addFileNameToSkipForSetControllerCallsites(
	`/${fdtBasename}/src/ModuleRegistrationApi.js`
);
FdtCommand.addFileNameToSkipForSetControllerCallsites(
	`/${fdtBasename}/src/response/FdtResponse.js`
);