magicli/lib/magicli.js

#!/usr/bin/env node

'use strict';

const inspectFunction = require('inspect-function');
const pipe = require('pipe-functions');
const { callWithObject, fnParametersFromOptions } = require('./call-with-object');
const cli = require('commander');

function getFlattenedAPI(o, path = '', methods = {}) {
	for (let prop of Object.getOwnPropertyNames(o)) {
		if (o[prop].constructor === Function) {
			let methodCall = path ? `${path}-${prop}` : prop;
			methods[methodCall] = { method: o[prop] };

			let functionParams = inspectFunction(o[prop]).parameters.names;
			if (functionParams) {
				methods[methodCall] = {
					params: functionParams,
					method: o[prop]
				};
			}
		}
		if (o[prop].constructor === Object) {
			methods = getFlattenedAPI(o[prop], path ? `${path}-${prop}` : prop, methods);
		}
	}
	return methods;
}

function methodExec(fn, params, pipes = {}) {
	let pipeline = [];

	if (pipes.before) {
		pipeline.push(pipes.before);
	}

	// MAIN
	pipeline.push((args) => {
		let methodReturn = callWithObject(fn, args);
		if (methodReturn && methodReturn.then) {
			return methodReturn.then(data => data).catch(console.error);
		} else {
			return methodReturn;
		}
	});

	if(pipes.after){
		pipeline.push(pipes.after);
	}

	pipeline.push(console.log);
	pipe(params, ...pipeline);
}

function main(moduleRef, options = {pipes: {}}) {
	process.env.NODE_CLI = true;

	let packageJson;
	let moduleVersion;
	let moduleAPI;

	if (moduleRef.constructor === String) {
		packageJson = require(`${moduleRef}/package.json`);
		moduleAPI = require(`${moduleRef}/${packageJson.main}`);
		moduleVersion = packageJson.version;
	} else {
		moduleAPI = moduleRef;
	}

	// console.log('process.argv', process.argv);
	// return;
	if (moduleAPI.constructor === Function) {
		// Module is a Function :: TODO : Even being a function, it still can have properties and methods

		const params = inspectFunction(moduleAPI).parameters.names;
		params.forEach(param => {
			cli.option(`--${param} [value]`);
		});

		cli.version(moduleVersion);
		cli.usage(`<command> [options]`);
		cli.parse(process.argv);

		methodExec(moduleAPI, cli, options.pipes);

	} else {
		// Module is a set of methods within an Object Literal

		const methods = getFlattenedAPI(moduleAPI);
		Object.keys(methods).forEach(methodKey => {
			let cmd = cli.command(`${methodKey}`);
			methods[methodKey].params.forEach(param => cmd.option(`--${param} [option]`));
			cmd.action(args => {
				methodExec(methods[methodKey].method, args, options.pipes[methodKey] || options.pipes);
			});
		});

		cli.version(moduleVersion);
		cli.usage(`<command> [options]`);
		cli.parse(process.argv);
		if (!process.argv.slice(2).length) {
			return cli.outputHelp();
		}
	}
}

module.exports = main;