152 lines
3.5 KiB
TypeScript
152 lines
3.5 KiB
TypeScript
import { parseArgs } from "node:util";
|
|
import chalk from "chalk";
|
|
import { loadBinding } from "#core/binding";
|
|
import type { MusePlugin } from "#core/plugins";
|
|
import { MuseError } from "#errors";
|
|
import { version } from "../../package.json";
|
|
|
|
interface CLIFlags {
|
|
help: boolean;
|
|
verbose: boolean;
|
|
stdout: boolean;
|
|
}
|
|
|
|
interface Loggers {
|
|
log: (msg: string) => void;
|
|
verbose: (msg: string) => void;
|
|
}
|
|
|
|
enum ExitCode {
|
|
Success = 0,
|
|
Error = 1,
|
|
}
|
|
|
|
export const USAGE = `
|
|
${chalk.bold("muse")} - Compile and process troves of data
|
|
${chalk.dim(`v${version}`)}
|
|
|
|
Usage:
|
|
muse [/path/to/binding.yaml] <options>
|
|
|
|
Options:
|
|
--stdout -s Output final data to stdout
|
|
--verbose, -v Enable verbose logging
|
|
--help, -h Show this help message
|
|
`.trim();
|
|
|
|
/**
|
|
* Given an array of CLI arguments, parse them into a structured object
|
|
*
|
|
* @param argv The arguments to parse
|
|
* @returns The parsed CLI arguments
|
|
*
|
|
* @throws {CLIError} if the arguments are invalid
|
|
*/
|
|
function parseCLIArguments(argv: string[]): [string, CLIFlags] {
|
|
const { values: options, positionals: args } = parseArgs({
|
|
args: argv,
|
|
options: {
|
|
help: {
|
|
short: "h",
|
|
default: false,
|
|
type: "boolean",
|
|
},
|
|
verbose: {
|
|
short: "v",
|
|
default: false,
|
|
type: "boolean",
|
|
},
|
|
stdout: {
|
|
short: "s",
|
|
default: false,
|
|
type: "boolean",
|
|
},
|
|
},
|
|
strict: true,
|
|
allowPositionals: true,
|
|
});
|
|
|
|
return [args[0] ?? "./", options];
|
|
}
|
|
|
|
function getStepLogLine(plugin: MusePlugin): string {
|
|
const { name, description } = plugin;
|
|
let processorLogLine = chalk.bold(`↪ ${name}`);
|
|
|
|
if (description && description.length > 0) {
|
|
processorLogLine += chalk.dim(` (${description})`);
|
|
}
|
|
|
|
return processorLogLine;
|
|
}
|
|
|
|
async function processBinding(
|
|
inputFilePath: string,
|
|
flags: CLIFlags,
|
|
{ log, verbose }: Loggers,
|
|
) {
|
|
// Load the binding
|
|
let binding = await loadBinding(inputFilePath);
|
|
verbose(`Binding ${binding.bindingPath}`);
|
|
|
|
const entryCount = binding.entries.length;
|
|
const stepCount = binding.plugins.length;
|
|
const stepWord = stepCount === 1 ? "step" : "steps";
|
|
log(`Processing ${entryCount} entries with ${stepCount} ${stepWord}`);
|
|
|
|
const processStart = performance.now();
|
|
|
|
// Run the data through relevant plugins
|
|
for (const plugin of binding.plugins) {
|
|
log(getStepLogLine(plugin));
|
|
const { step } = plugin;
|
|
binding = await step(binding);
|
|
}
|
|
|
|
const processEnd = performance.now();
|
|
const processTime = ((processEnd - processStart) / 1000).toFixed(2);
|
|
verbose(`Processing completed in ${processTime}s`);
|
|
|
|
if (flags.stdout) {
|
|
console.log(JSON.stringify(binding, null, 2));
|
|
}
|
|
return ExitCode.Success;
|
|
}
|
|
|
|
async function main(): Promise<number> {
|
|
const [inputFilePath, flags] = parseCLIArguments(Bun.argv.slice(2));
|
|
|
|
// If --help is specified, print usage and exit
|
|
if (flags.help) {
|
|
console.log(USAGE);
|
|
return ExitCode.Success;
|
|
}
|
|
|
|
const logFn = !flags.stdout ? console.log : () => {};
|
|
const verboseFn = flags.verbose
|
|
? (msg: string) => {
|
|
console.log(chalk.dim(msg));
|
|
}
|
|
: () => {};
|
|
|
|
const lastProcessResult = await processBinding(inputFilePath, flags, {
|
|
log: logFn,
|
|
verbose: verboseFn,
|
|
});
|
|
|
|
return lastProcessResult;
|
|
}
|
|
|
|
try {
|
|
const exitCode = await main();
|
|
process.exit(exitCode);
|
|
} catch (error) {
|
|
if (error instanceof MuseError) {
|
|
console.error(chalk.red(error.fmt()));
|
|
} else {
|
|
console.error("An unexpected error occurred");
|
|
console.error(error);
|
|
}
|
|
|
|
process.exit(1);
|
|
}
|