oidc-lib/src/install/import_platform_feature.js

A library for creating OIDC Service Providers

var fs = require('fs');
var path = require('path');
var base64url = require('base64url');
var node_input = require('./nodeInput');
var fetch = require('node-fetch');
var util = require('./util')
const lib_data = 'oidc_lib_data';

var debug = false;
startup();

async function startup(){
	try{
		var possibleError;
		// process exits when done
		// argv contains 'node' 'import_platform_feature.js ohip.json'
		await processAddition(process.argv[2], null, true, undefined, true);
	}
	catch(err){
		throw(err);
	}
}		

async function processAddition(inputFile, input, retainIssuerName, newIssuerName, includeJsCss){
	try{
		var possibleError;

		if (!input){
			possibleError = 'File not found: ' + inputFile;
			input = await fetch('https://raw.githubusercontent.com/kimcameron/oidc-lib-features/main/' + inputFile)
				.then(res => res.json());
    	}

    	if (input.oidc_lib_version){
			var import_lib_version = input.oidc_lib_version.replace('^', '');
			var ni = new node_input();
			var proceed = await ni.question(
				'Feature created with oidc-lib version ' + import_lib_version + '.  Press "Y" to proceed, "N" to exit.', 'trueFalse');
			if (!proceed){
				process.exit(1);
			}
		}

		var issuer;

		var configb64 = input.code['oidc_config.json'];
		var config = JSON.parse(base64url.decode(configb64));
		var config_files = config.config_files;

		for (var inputKey in input){
			switch (inputKey){
				case 'issuer':
					issuer = input.issuer;
					if (!retainIssuerName){
						issuer = newIssuerName;
					}
					break;

				case 'code':
					var codePath = path.join(process.cwd(), issuer);
					possibleError = 'Error applying directory: ' + codePath;
					applyDirectory(config_files, codePath, input.code);
					break;

				case 'description':
				case 'oidc_lib_version':
					break;

				default:
					var skip = false;
					var overwrite = true;

					switch (inputKey){
						case 'web/js':
						case 'web/css':
							overwrite = true;
							if (!includeJsCss){
								skip = true;
							}
							break;
	
						case 'web/code':
							inputKey = 'web/' + issuer;
							break;

						case 'views':
							overwrite = true;
							break;
					}

					var location;
					location = path.join(process.cwd(), inputKey);
					possibleError = 'Error applying directory: ' + location;
					applyDirectory(config_files, location, input[inputKey]);
					break;
			}			
		}

		console.log("Done");
		process.exit(0);
	}
	catch(err){
		console.log(possibleError);
		console.log(err.code);
		process.exit(-1);
	}
}

function applyDirectory(config_files, directoryName, directoryContent){
	var _workingDirectory = process.cwd();
	var _workingDirectoryLength = _workingDirectory.length;

	recurseDirectory(config_files, directoryName, directoryContent);

	function recurseDirectory(config_files, directoryName, directoryContent){
		for (var key in directoryContent){
			var content = directoryContent[key];
			if (typeof content === 'string'){
				var buffer = base64url.toBuffer(content);
				util.mkDirectoriesInPath(directoryName);
				var filename = path.join(directoryName, key);
				var relativePath = filename.substr(_workingDirectoryLength).replace(/\\/g, '/');

				var safe_filename = filename;
				if (fs.existsSync(filename) && config_files && config_files.includes(relativePath)){
					console.log('** not overwriting config_file ' + filename + ' - will write with .new extension');
					safe_filename = filename + '.new';
				}
				fs.writeFileSync(safe_filename, buffer);
			}
			else if (typeof content === 'object'){
				var subDirectoryName = path.join(directoryName, key);
				util.mkDirectoriesInPath(subDirectoryName);
				recurseDirectory(config_files, subDirectoryName, content);
			}
		}
	}
}