oidc-lib/src/install/newcontent.js

A library for creating OIDC Service Providers

const fs   = require('fs');
const path = require('path');
const nodeInput = require('./nodeInput');

const sourceRoot = './new_content/';
var moduleName;
const claimer_instance_config = 'claimer_instance_config.template';

var tasksToComplete = [
	claimer_instance_config,
	'claimer_config.js',
	'new_content.js',
	'data/scope_claim_map.js', 
	'Views/error_received.handlebars',
	'Views/get_creds.handlebars',
	'Views/get_consent.handlebars'
];

var errorsInJob = false;

var tasks = tasksToComplete.slice(3);

setInstallParameters()
.then(function(parameters){
	moduleName = parameters.moduleName;
	console.log();
	console.log('Installing new module: ' + moduleName);

	var workingDir = __dirname.replace(/\\/g, '/');

	if (!workingDir.endsWith('/claimer/install')){
		console.log('Please run newcontent from the /claimer/install directory rather than from \'' + __dirname + '\'.');
		process.exit();
	}

	var destRoot = '../claimer_content/' + moduleName + '/';

	updateClaimerInstanceConfig(claimer_instance_config, false);

	for (var i=0; i < tasks.length; i++){
		var relativePath = tasks[i];
		replaceModuleAndCopy(sourceRoot, destRoot, relativePath);
	}

	replaceModuleAndCopy(sourceRoot, destRoot, 'new_content.js', moduleName + '.js');


	updateClaimerInstanceConfig('claimer_config.js', true);
})

function replaceModuleAndCopy(sourceRoot, destRoot, sourceTail, destTail){
	if (destTail === undefined){
		destTail = sourceTail;
	}
	var destFile = destRoot + destTail;
	var directoryPath = destFile.substring(0, destFile.lastIndexOf('/')); 
	mkDirectoriesInPath(directoryPath);
	var stringEncoding = fs.readFileSync(sourceRoot + sourceTail, {encoding: 'utf8'});
	stringEncoding = replaceModuleName(stringEncoding);
	fs.writeFile(destRoot + destTail, stringEncoding, 'utf8', function(err){
		if (err){
			console.log("error writing " + destRoot + destTail);
			taskComplete(sourceTail);
			return;
		}

		taskComplete(sourceTail);
	});
}

function updateClaimerInstanceConfig(configPath, isModuleExport)
{
	var moduleInstanceString = replaceModuleName(fs.readFileSync(sourceRoot + claimer_instance_config, {encoding: 'utf8'}));
	try{
		var moduleInstanceObj = JSON.parse(moduleInstanceString);
	}
	catch(err){
		console.log('Error parsing \'' + sourceRoot + claimer_instance_config + '\'.');
		console.log('Processing of ' + configPath + ' has terminated.');
		errorsInJob = true;
		return;
	}

	fs.stat('../' + configPath, function(err, stat){
		if (err){
			if (err.code === 'ENOENT'){
				var instanceConfigObj = { content_modules: {} };
				writeInstanceConfig(instanceConfigObj, moduleInstanceObj, isModuleExport, configPath);			
			}
			else{
				console.log('unexpected error');
				console.log(err);
				process.exit();
			}
		}
		else{
			var stringEncoding = fs.readFileSync('../' + configPath, {encoding: 'utf8'});
			if (isModuleExport){
				var reg = new RegExp(/(\s*module.exports\s*\s*=\s*)([\w\W]*)/);
				var res = reg.exec(stringEncoding);
				if (res.length !== 3){
					console.log('no match in module.export file: ' + configPath);
					process.exit();
				}
				stringEncoding = res[2].replace(/;$/, '');
			}
			try{
				var instanceConfigObj = JSON.parse(stringEncoding);				
			}
			catch(err){
				console.log('Error parsing \'' + sourceRoot + claimer_instance_config + '\'.');
				console.log('Processing of ' + configPath + ' has terminated.');
				errorsInJob = true;
				return;
			}
			writeInstanceConfig(instanceConfigObj, moduleInstanceObj, isModuleExport, configPath);			
		}
	});
}

function writeInstanceConfig(instanceConfigObj, moduleInstanceObj, isModuleConfig, configPath){
	for (var k in moduleInstanceObj.content_modules){
		instanceConfigObj.content_modules[k] = moduleInstanceObj.content_modules[k];
	}

	var prefix = '';
	if (isModuleConfig){
		prefix = 'module.exports = '
	}

	fs.writeFile('../' + configPath, prefix + JSON.stringify(instanceConfigObj, null, 4), 'utf8', function(err){
		if (err){
			console.log("error writing " + '../' + configPath);
			taskComplete(configPath);
			return;
		}

		taskComplete(configPath);
	});
}			

function replaceModuleName(input){
	return input.replace(/\{\{_moduleName\}\}/g, moduleName);
}

async function setInstallParameters(){
	if (process.argv.length !== 3){
		console.log('ERROR:  usage is node newcontent.js <new_module_name>');
		process.exit();

	}

	var moduleName = process.argv[2];
	var parameters = {};
//	var ni = new nodeInput();
//	var proceed = await ni.question(
//		'Create a new content module called ' + moduleName + '?', 'trueFalse');
	var proceed = true;
	if (proceed){
		parameters.moduleName = moduleName;
		return parameters;
	}

	process.exit();
}

function taskComplete(taskName){
	var index = tasksToComplete.indexOf(taskName);
	if (index >= 0){
		tasksToComplete.splice(index, 1);
	}

	if (tasksToComplete.length === 0){
		if (errorsInJob){
			console.log('Addition of new content module is *incomplete* due to errors.');			
		}
		else{
			console.log('Addition of new content module is complete.');			
		}
		console.log();
		process.exit();
	}
}

function mkDirectoriesInPath(target) {
	const sep = '/';
	target = target.replace('\\', sep);
	var segments = target.split(sep);
	var path = '';
	var prefix = '';
	for (var i=0; i < segments.length; i++){
		path += prefix + segments[i];
		prefix = sep;
		if (!fs.existsSync(path)){
			fs.mkdirSync(path);
		}
	}
}