index.js

#!/usr/bin/env node

const fs = require('node:fs/promises');
const path = require('node:path');
const { exec } = require('node:child_process');
const { parseArgs, promisify, styleText } = require('node:util');
const execPromise = promisify(exec);

const hasBinary = require('./src/has-binary');
const diffDirectories = require('./src/gen-diff-object');
const isInvalidPath = require('./src/is-invalid-path');

const { version } = require('./package.json');

(async () => {
	const has_zip = hasBinary('zip');
	const has_diff = hasBinary('diff');

	if (!(has_zip && has_diff)) {
		// prettier-ignore
		console.error(`Could not find both "${styleText('yellow', 'zip')}" and "${styleText('yellow', 'diff')}" binaries, both of which are required. Exiting.`);
		process.exit(1);
	}

	const {
		values: argv,
		positionals: [build_old, build_new],
	} = parseArgs({
		args: process.argv.slice(2),
		options: {
			quiet: { type: 'boolean', short: 'q', default: false },
			json: { type: 'boolean', short: 'j', default: false },
			output: { type: 'string', short: 'o', default: 'build_for_upload' },
		},
		allowPositionals: true,
	});

	// @todo Have options table automatically generated
	const usage_message = `
Usage: build-diff [options] <old-build-directory> <new-build-directory>

CLI to compare two folders and copy out the differences between them.

Version ${version}

Options:
  -q, --quiet          Hides progress as it compares the directories. Defaults to false.
  -j, --json           Outputs results as JSON. Defaults to false.
  -o, --output <name>  Name of the output folder and ZIP file. Defaults to "build_for_upload".
`;

	if (!build_old || !build_new) {
		console.error(usage_message);
		process.exit(1);
	}

	// Check that build folders exist
	let build_old_exists = await pathExists(build_old);
	let build_new_exists = await pathExists(build_new);

	if (!build_old_exists || !build_new_exists) {
		console.error(
			styleText('red', 'The passed build directories do not exist:', {
				stream: process.stderr,
			}),
			`\n  "${build_old}"\n  "${build_new}"\n`
		);
		console.error(usage_message);
		process.exit(1);
	}

	const { quiet, json, output } = argv;
	const logger = createLogger(quiet);

	if (isInvalidPath(output)) {
		console.error(
			styleText('red', 'The passed output directory has invalid characters:', {
				stream: process.stderr,
			}),
			`\n  "${output}"\n`
		);
		console.error(usage_message);
		process.exit(1);
	}

	logger.log(
		`Comparing "${styleText('magenta', build_old)}" against "${styleText('magenta', build_new)}"...`
	);

	// If we are here, both directories exist, so let's compute the differences between them

	let {
		filesAdded: files_added,
		filesUpdated: files_updated,
		filesDeleted: files_deleted,
	} = await diffDirectories(build_old, build_new, { quiet });

	if (files_added.length + files_updated + files_deleted.length === 0) {
		console.error(`No files were different between "${build_old}" and "${build_new}", exiting`);
		process.exit(0);
	}

	// Concat 'added' and 'updated' since functionally they are no different when uploading to AWS (or other)
	let files_changed = files_updated.concat(files_added);

	// Sort newly formed `files_changed`; other lists are already sorted
	files_changed.sort();

	let output_dir = path.resolve(output);

	// Create our output directory
	try {
		await fs.mkdir(output_dir, { recursive: true });
	} catch (e) {
		console.error(`Unable to create output directory at "${output_dir}"`);
		console.error(e);
		process.exit(2);
	}

	// Copy our changed files over to the output directory!
	if (files_changed.length) {
		logger.write(styleText('yellow', 'Copying over changed files... '));

		await Promise.all(
			files_changed.map(async (file) => {
				const source = path.join(build_new, file);
				const destination = path.join(output_dir, file);
				await fs.mkdir(path.dirname(destination), { recursive: true });
				await fs.cp(source, destination, { recursive: true });
			})
		);

		logger.log(styleText('green', 'Done'));
	}

	// Zip the files up
	// @todo Use a native option
	logger.write(styleText('yellow', 'Zipping changed files... '));
	let relative_output_dir = path.relative(process.cwd(), output_dir);
	await execPromise(
		`zip -9 -x "**/.DS_Store" -q -r ${relative_output_dir}.zip ${relative_output_dir}`
	);
	logger.log(styleText('green', 'Done\n'));

	if (json) {
		const json_output = {
			filesDeleted: files_deleted,
			filesChanged: files_changed,
			outputDir: relative_output_dir,
			outputZip: relative_output_dir + '.zip',
		};

		console.log(JSON.stringify(json_output));
	} else {
		if (files_deleted.length) {
			console.log(styleText('red', 'The following files were deleted:'));
			console.log('  ' + files_deleted.join('\n  ') + '\n');
		}

		if (files_changed.length) {
			console.log(styleText('green', '\nThe following files were changed:'));
			console.log('  ' + files_changed.join('\n  ') + '\n');
		}

		console.log(
			`All changed files have been copied to ${styleText('cyan', relative_output_dir)}, and zipped in ${styleText(
				'cyan',
				relative_output_dir + '.zip'
			)}\n`
		);
	}
})();

async function pathExists(target) {
	try {
		await fs.access(target);
		return true;
	} catch {
		return false;
	}
}

function createLogger(quiet) {
	if (quiet) {
		return {
			log() {},
			write() {},
		};
	}

	return {
		log: console.log.bind(console),
		write: process.stdout.write.bind(process.stdout),
	};
}