SIR-1522 - cli v2 pre flight validation gate on raisely deploy no validate

package.json

@@ -8,7 +8,7 @@
 		"raisely": "./bin/raisely.js"
 	},
 	"scripts": {
-		"test": "node --test"
+		"test": "vitest run --config vitest.config.js"
 	},
 	"engines": {
 		"node": ">=18"
@@ -40,7 +40,8 @@
 		"p-limit": "^4.0.0"
 	},
 	"devDependencies": {
-		"prettier": "^2.6.2"
+		"prettier": "^2.6.2",
+		"vitest": "^1.6.1"
 	},
 	"repository": {
 		"type": "git",

src/cli.js

@@ -63,6 +63,10 @@ export async function cli() {
 		.description(
 			'Synchronise (push) a remote Raisely campaign with the files on this machine'
 		)
+		.option(
+			'--no-validate',
+			'Skip pre-flight SCSS/component validation before upload'
+		)
 		.option(
 			'-f, --force',
 			'Deploy without asking for confirmation (non-interactive)'

src/deploy.js

@@ -21,35 +21,169 @@ import {
 import { uploadPage } from './actions/pages.js';
 import { loadConfig } from './config.js';
 import { getToken } from './actions/auth.js';
+import {
+	validateCampaignSass,
+	validateComponent,
+} from './actions/validate.js';
+
+function createDeployDependencies(overrides = {}) {
+	return {
+		loadConfigFn: overrides.loadConfigFn || loadConfig,
+		getTokenFn: overrides.getTokenFn || getToken,
+		getCampaignFn: overrides.getCampaignFn || getCampaign,
+		uploadStylesFn: overrides.uploadStylesFn || uploadStyles,
+		updateComponentConfigFn:
+			overrides.updateComponentConfigFn || updateComponentConfig,
+		updateComponentFileFn: overrides.updateComponentFileFn || updateComponentFile,
+		uploadPageFn: overrides.uploadPageFn || uploadPage,
+		validateCampaignSassFn:
+			overrides.validateCampaignSassFn || validateCampaignSass,
+		validateComponentFn: overrides.validateComponentFn || validateComponent,
+		globFn: overrides.globFn || glob,
+		fsModule: overrides.fsModule || fs,
+		pathModule: overrides.pathModule || path,
+		logFn: overrides.logFn || log,
+		brFn: overrides.brFn || br,
+		welcomeFn: overrides.welcomeFn || welcome,
+		informUpdateFn: overrides.informUpdateFn || informUpdate,
+		loaderFactory: overrides.loaderFactory || ora,
+		consoleRef: overrides.consoleRef || console,
+		cwd: overrides.cwd || process.cwd,
+		setExitCode:
+			overrides.setExitCode ||
+			((code) => {
+				process.exitCode = code;
+			}),
+	};
+}
+
+function formatValidationErrors(errors) {
+	return errors.map(({ context, error }) => `${context}: ${error}`);
+}
+
+function normalizeValidationResult(result, fallbackError) {
+	if (result && typeof result === 'object' && typeof result.ok === 'boolean') {
+		return {
+			ok: result.ok,
+			error:
+				typeof result.error === 'string' && result.error.trim()
+					? result.error
+					: fallbackError,
+		};
+	}
+
+	return {
+		ok: false,
+		error: fallbackError,
+	};
+}
+
+function getComponentNames({ fsModule, pathModule, cwd }) {
+	const componentsDir = pathModule.join(cwd(), 'components');
+	if (!fsModule.existsSync(componentsDir)) {
+		return [];
+	}
+
+	return fsModule
+		.readdirSync(componentsDir, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => entry.name);
+}
+
+async function runPreflightValidation({ config }, dependencies) {
+	const deps = createDeployDependencies(dependencies);
+	const validationLimit = pLimit(4);
+	const loader = deps.loaderFactory('Validating campaigns and components').start();
+	const campaigns = await Promise.all(
+		config.campaigns.map(async (campaignUuid) => {
+			const campaign = await deps.getCampaignFn({ uuid: campaignUuid });
+			return {
+				uuid: campaign.data.uuid,
+				path: campaign.data.path,
+			};
+		})
+	);
+	const componentNames = getComponentNames(deps);
+
+	const validationTasks = [
+		...campaigns.map((campaign) =>
+			validationLimit(async () => {
+				const rawResult = await deps.validateCampaignSassFn({
+					campaign,
+					token: config.token,
+				});
+				const result = normalizeValidationResult(
+					rawResult,
+					'SASS validator returned an invalid response.'
+				);
+				return {
+					ok: result.ok,
+					context: `Campaign ${campaign.path}`,
+					error: result.error,
+				};
+			})
+		),
+		...componentNames.map((name) =>
+			validationLimit(async () => {
+				const rawResult = await deps.validateComponentFn({ name });
+				const result = normalizeValidationResult(
+					rawResult,
+					'Component validator returned an invalid response.'
+				);
+				return {
+					ok: result.ok,
+					context: `Component ${name}`,
+					error: result.error,
+				};
+			})
+		),
+	];
+
+	const results = await Promise.all(validationTasks);
+	const failed = results.filter((result) => !result.ok);
+
+	if (failed.length > 0) {
+		loader.fail('Deploy validation failed');
+		formatValidationErrors(failed).forEach((message) => {
+			deps.logFn(message, 'red');
+		});
+		return false;
+	}
+
+	loader.succeed('Validation passed');
+	return true;
+}
 
-export default async function deploy(options = {}) {
-	const layout = detectLayout(process.cwd());
+export default async function deploy(options = {}, dependencies = {}) {
+	const deps = createDeployDependencies(dependencies);
+	const cwd = deps.cwd();
+	const layout = detectLayout(cwd);
 	if (shouldRefuseLayoutForCommand('deploy', layout)) {
-		br();
-		log(getLegacyLayoutRefusalMessage('deploy', layout), 'red');
-		process.exitCode = 1;
+		deps.brFn();
+		deps.logFn(getLegacyLayoutRefusalMessage('deploy', layout), 'red');
+		deps.setExitCode(1);
 		return;
 	}
 
 	// load config
-	let config = await loadConfig();
-	await getToken(program, config);
-
-	welcome();
-	log(`You are about to deploy your local directly to Raisely`, 'white');
-	br();
-	console.log(`    ${chalk.inverse(`${process.cwd()}`)}`);
-	br();
+	let config = await deps.loadConfigFn();
+	config.token = await deps.getTokenFn(program, config);
+
+	deps.welcomeFn();
+	deps.logFn(`You are about to deploy your local directly to Raisely`, 'white');
+	deps.brFn();
+	deps.consoleRef.log(`    ${chalk.inverse(`${cwd}`)}`);
+	deps.brFn();
 	if (config.apiUrl) {
-		br();
-		console.log(`Using custom API: ${chalk.inverse(config.apiUrl)}`);
-		br();
+		deps.brFn();
+		deps.consoleRef.log(`Using custom API: ${chalk.inverse(config.apiUrl)}`);
+		deps.brFn();
 	}
-	log(
+	deps.logFn(
 		`You will overwrite the styles, components, and pages in your campaign.`,
 		'white'
 	);
-	br();
+	deps.brFn();
 
 	if (!config.cli && !options.force) {
 		const response = await inquirer.prompt([
@@ -61,23 +195,36 @@ export default async function deploy(options = {}) {
 		]);
 
 		if (!response.confirm) {
-			br();
-			return log('Deploy aborted', 'red');
+			deps.brFn();
+			return deps.logFn('Deploy aborted', 'red');
 		}
 	}
 
+	if (options.validate !== false) {
+		const validationPassed = await runPreflightValidation({ config }, deps);
+		if (!validationPassed) {
+			deps.brFn();
+			deps.setExitCode(1);
+			return;
+		}
+	} else {
+		deps.logFn('Skipping validation due to --no-validate flag.', 'yellow');
+	}
+
 	// upload campaign stylesheets
 	for (const campaignUuid of config.campaigns) {
-		const loader = ora(`Uploading styles for ${campaignUuid}`).start();
+		const loader = deps.loaderFactory(`Uploading styles for ${campaignUuid}`).start();
 
-		const campaign = await getCampaign({ uuid: campaignUuid });
+		const campaign = await deps.getCampaignFn({ uuid: campaignUuid });
 
 		try {
-			await uploadStyles(campaign.data.path);
+			await deps.uploadStylesFn(campaign.data.path);
 		} catch (e) {
-			br();
-			console.error(e);
-			process.exit(1);
+			loader.fail(`Failed to upload styles for ${campaignUuid}`);
+			deps.brFn();
+			deps.consoleRef.error(e);
+			deps.setExitCode(1);
+			return;
 		}
 
 		loader.succeed();
@@ -87,27 +234,29 @@ export default async function deploy(options = {}) {
 	const limit = pLimit(5);
 	const components = [];
 
-	const componentsDir = path.join(process.cwd(), 'components');
-	for (const file of fs.readdirSync(componentsDir)) {
-		const data = {
-			file: fs.readFileSync(
-				path.join(componentsDir, file, `${file}.js`),
-				'utf8'
-			),
-			config: JSON.parse(
-				fs.readFileSync(
-					path.join(componentsDir, file, `${file}.json`),
+	const componentsDir = deps.pathModule.join(cwd, 'components');
+	if (deps.fsModule.existsSync(componentsDir)) {
+		for (const file of deps.fsModule.readdirSync(componentsDir)) {
+			const data = {
+				file: deps.fsModule.readFileSync(
+					deps.pathModule.join(componentsDir, file, `${file}.js`),
 					'utf8'
-				)
-			),
-		};
+				),
+				config: JSON.parse(
+					deps.fsModule.readFileSync(
+						deps.pathModule.join(componentsDir, file, `${file}.json`),
+						'utf8'
+					)
+				),
+			};
 
-		components.push(limit(() => updateComponentConfig(data)));
-		components.push(limit(() => updateComponentFile(data)));
+			components.push(limit(() => deps.updateComponentConfigFn(data)));
+			components.push(limit(() => deps.updateComponentFileFn(data)));
+		}
 	}
 
 	// Start loading all the components
-	const loader = ora(`Uploading components`).start();
+	const loader = deps.loaderFactory(`Uploading components`).start();
 	const deployResult = await Promise.allSettled(components);
 
 	const rejected = deployResult
@@ -117,21 +266,21 @@ export default async function deploy(options = {}) {
 	if (rejected.length > 0) {
 		loader.warn('The following errors occured while uploading components:');
 		rejected.forEach((error) => {
-			log(error, 'red');
+			deps.logFn(error, 'red');
 		});
 	} else {
 		loader.succeed();
 	}
 
 	// upload pages
-	const pageFiles = await glob('campaigns/*/pages/**/*.json', {
-		cwd: process.cwd(),
+	const pageFiles = await deps.globFn('campaigns/*/pages/**/*.json', {
+		cwd,
 	});
 
 	const pageTasks = [];
 	for (const file of pageFiles) {
-		const fullPath = path.join(process.cwd(), file);
-		const pageData = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+		const fullPath = deps.pathModule.join(cwd, file);
+		const pageData = JSON.parse(deps.fsModule.readFileSync(fullPath, 'utf8'));
 		if (!pageData.uuid) {
 			continue;
 		}
@@ -141,12 +290,12 @@ export default async function deploy(options = {}) {
 		) {
 			continue;
 		}
-		pageTasks.push(limit(() => uploadPage(pageData)));
+		pageTasks.push(limit(() => deps.uploadPageFn(pageData)));
 	}
 
 	let pageRejected = [];
 	if (pageTasks.length > 0) {
-		const pageLoader = ora(`Uploading pages`).start();
+		const pageLoader = deps.loaderFactory(`Uploading pages`).start();
 		const pageResults = await Promise.allSettled(pageTasks);
 
 		pageRejected = pageResults
@@ -158,16 +307,16 @@ export default async function deploy(options = {}) {
 				'The following errors occured while uploading pages:'
 			);
 			pageRejected.forEach((err) => {
-				log(err, 'red');
+				deps.logFn(err, 'red');
 			});
 		} else {
 			pageLoader.succeed();
 		}
 	}
 
 	if (rejected.length === 0 && pageRejected.length === 0) {
-		await informUpdate();
+		await deps.informUpdateFn();
 	}
-	br();
-	log(`All done!`, 'green');
+	deps.brFn();
+	deps.logFn(`All done!`, 'green');
 }

tests/campaigns.test.js

@@ -1,4 +1,4 @@
-import { test, describe } from 'node:test';
+import { describe, test } from 'vitest';
 import assert from 'node:assert/strict';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';

tests/command-layout-guard.test.js

@@ -1,4 +1,4 @@
-import { test } from 'node:test';
+import { test } from 'vitest';
 import assert from 'node:assert/strict';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';