@digitalspaces/cli/lib/Config.js

/*
 * Copyright (C) 2019 Forward Thinking, Inc. - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 */
'use strict';
const _ = require('lodash');
const __ = require('@digitalspaces/utils');
const Path = require('path');
const Fs = require('fs-extra');

const validConfigKeys = {
	'authToken': true,
	'baseUrl': true,
	'configPath': true,
	'debugRuntimeToken': true,
	'userId': true
};

function ifObjectProxy(value) {

	switch( __.type(value) ) {
		case 'undefined':
		case 'null':
		case 'boolean':
		case 'number':
		case 'string':
			return value;
		default:
			return readOnlyProxy(value);
	}

}

function readOnlyProxy(target, handlers) {

	return new Proxy(target, Object.assign({
		apply(target, thisArg, args) {
			Reflect.apply(target, thisArg, args);
		},
		get(target, prop, receiver) {
			return ifObjectProxy(Reflect.get(target, prop, receiver));
		},
		getOwnPropertyDescriptor(target, prop) {
			const result = Reflect.getOwnPropertyDescriptor(target, prop);
			if( result === undefined )
				return undefined;
			result.value = ifObjectProxy(result.value)
		},
		defineProperty() {
			return false;
		},
		deleteProperty() {
			return false;
		},
		set(target, prop, value, receiver) {
			if( receiver !== this )
				return Reflect.set(target, prop, value, receiver);
			return false;
		},
		setPrototypeOf() {
			return false;
		},
		construct() {
			throw __.error();
		}
	}, handlers));

}

class Config {

	constructor(configOverride) {

		//only resolve the defaultConfigPath once per run (keeps the path stable if their were somehow to exist a project level config mid operation
		let defaultConfigPath;

		this._configDefaults = Object.create(null, {
			baseUrl: {
				value: 'https://my.digitalspaces.app',
				writable: true,
				configurable: true,
				enumerable: true
			},
			configPath: {
				get: () => {
					if( defaultConfigPath !== undefined )
						return defaultConfigPath;
					defaultConfigPath = Path.resolve(process.cwd(), '.digitalspaces', 'config.json');
					if( Fs.pathExistsSync(defaultConfigPath) )
						return defaultConfigPath;
					return defaultConfigPath = Path.resolve(require('os').homedir(), '.digitalspaces', 'config.json');
				},
				configurable: true,
				enumerable: true
			}
		});

		const self = this;

		this._configPersist = Object.create(readOnlyProxy(this._configDefaults, {
			ownKeys(target, receiver) {
				const keysObj = {};
				for( let keys = Reflect.ownKeys(self._configDefaults), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				for( let keys = Reflect.ownKeys(self._configPersist), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				return Reflect.ownKeys(keysObj);
			},
			getOwnPropertyDescriptor(target, prop) {
				const result = Reflect.getOwnPropertyDescriptor(self._configPersist, prop)
					|| Reflect.getOwnPropertyDescriptor(self._configDefaults, prop);
				if( result !== undefined && result.get === undefined )
					result.value = ifObjectProxy(result.value);
				return result;
			}
		}));

		this._configEnv = Object.create(readOnlyProxy(this._configPersist, {
			ownKeys(target, receiver) {
				const keysObj = {};
				for( let keys = Reflect.ownKeys(self._configDefaults), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				for( let keys = Reflect.ownKeys(self._configPersist), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				for( let keys = Reflect.ownKeys(self._configEnv), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				return Reflect.ownKeys(keysObj);
			},
			getOwnPropertyDescriptor(target, prop) {
				const result = Reflect.getOwnPropertyDescriptor(self._configEnv, prop)
					|| Reflect.getOwnPropertyDescriptor(self._configPersist, prop)
					|| Reflect.getOwnPropertyDescriptor(self._configDefaults, prop);
				if( result !== undefined && result.get === undefined )
					result.value = ifObjectProxy(result.value);
				return result;
			}
		}));

		this._configOverride = Object.create(readOnlyProxy(this._configEnv, {
			ownKeys(target, receiver) {
				const keysObj = {};
				for( let keys = Reflect.ownKeys(self._configDefaults), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				for( let keys = Reflect.ownKeys(self._configPersist), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				for( let keys = Reflect.ownKeys(self._configEnv), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				for( let keys = Reflect.ownKeys(self._configOverride), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				return Reflect.ownKeys(keysObj);
			},
			getOwnPropertyDescriptor(target, prop) {
				const result = Reflect.getOwnPropertyDescriptor(self._configOverride, prop)
					|| Reflect.getOwnPropertyDescriptor(self._configEnv, prop)
					|| Reflect.getOwnPropertyDescriptor(self._configPersist, prop)
					|| Reflect.getOwnPropertyDescriptor(self._configDefaults, prop);
				if( result !== undefined && result.get === undefined )
					result.value = ifObjectProxy(result.value);
				return result;
			}
		}));

		this._config = readOnlyProxy(this._configOverride, {
			ownKeys(target, receiver) {
				const keysObj = {};
				for( let keys = Reflect.ownKeys(self._configDefaults), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				for( let keys = Reflect.ownKeys(self._configPersist), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				for( let keys = Reflect.ownKeys(self._configEnv), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				for( let keys = Reflect.ownKeys(self._configOverride), i = keys.length; i--; )
					keysObj[keys[i]] = true;
				return Reflect.ownKeys(keysObj);
			},
			getOwnPropertyDescriptor(target, prop) {
				const result = Reflect.getOwnPropertyDescriptor(self._configOverride, prop)
					|| Reflect.getOwnPropertyDescriptor(self._configEnv, prop)
					|| Reflect.getOwnPropertyDescriptor(self._configPersist, prop)
					|| Reflect.getOwnPropertyDescriptor(self._configDefaults, prop);
				if( result !== undefined && result.get === undefined )
					result.value = ifObjectProxy(result.value);
				return result;
			}
		});

		this._refreshed = undefined;

		if( configOverride !== undefined )
			this.override(configOverride)

	}

	async get(key, defaultValue) {

		await this.refresh();

		if( key !== undefined ) {

			if( __.type(key) !== 'string' || key === '' )
				throw __.error('expect (key) to be a non-empty string if provided.', {key});

			//if( ! this._refreshed || this._refreshed < Date.now() - 60000 )
			//	await this.refresh();

			const result = Reflect.get(this._config, key);

			if( result === undefined )
				return defaultValue;

			return result;

		}
		else {

			//if( ! this._refreshed || this._refreshed < Date.now() - 60000 )
			//	await this.refresh();

			return this._config;

		}

	}

	async set(configDetails) {

		if( __.type(configDetails) !== 'object' || _.isEmpty(configDetails) )
			throw __.error();

		//Everything should be an override first (to override environmental variables, etc).
		//Then we try to persist the details that make sense
		await this.override(configDetails);

		await this._persistUpdate(configDetails);

		return await this.get();
	}

	async wipe(){

		_.forEach(this._configOverride, (v, k, configOverride) => {
			delete configOverride[k];
		});

		await Promise.all([
			this._persistWipe(),
			this._configEnvRefresh()
		]);

		return this._config
	}

	/**
	 *
	 * @param configDetails {object<{authToken: string=, baseUrl: string=, configPath: string=, userId: string=}>}
	 * @returns {*}
	 */
	override(configDetails) {

		if( __.type(configDetails) !== 'object' || _.isEmpty(configDetails) )
			throw __.error();

		_.transform(configDetails, (configOverride, value, key) => {

			if( ! validConfigKeys[key] )
				throw __.error({key});

			if( value === undefined )
				Reflect.deleteProperty(this._configOverride, key);
			else
				Reflect.defineProperty(this._configOverride, key, {
					value: value,
					enumerable: true,
					writable: true,
					configurable: true
				});

		}, this._configOverride);

		return this._config;
	}

	/**
	 *
	 * @returns {object} Config object.
	 */
	async refresh() {

		//Note: need to do the refreshes in order so that if something in environment overrides configPath it is used in the persistRefresh();

		await this._configEnvRefresh();

		await this._persistRefresh();

		this._refreshed = Date.now();

		return this._config;

	}

	async _configEnvRefresh() {

		_.forEach(this._configEnv, (v, k) => {

			const envKey = `DIGITALSPACES_CLI_CONFIG_${_.toUpper(_.snakeCase(k))}`;

			if( ! Object.hasOwnProperty.call(process.env, envKey) )
				delete this._configEnv[k];

		});

		_.forEach(process.env, (v, envKey) => {

			const envKeyLower = envKey.toLowerCase();

			if( ! envKeyLower.startsWith('digitalspaces_cli_config_') )
				return;

			const configKey = _.camelCase(envKeyLower.slice(25));

			if( ! validConfigKeys[configKey] )
				return;

			if( Object.hasOwnProperty.call(this._configEnv, configKey) )
				return;

			Object.defineProperty(this._configEnv, configKey, {
				get: () => {
					switch( process.env[envKey] ) {
						case '':
						case 'undefined':
							return undefined;
						case 'null':
							return null;
						case 'true':
							return true;
						case 'false':
							return false;
						default:
							if( _.isFinite(+process.env[envKey]) )
								return +process.env[envKey];
							return process.env[envKey];
					}
				},
				configurable: true, enumerable: true
			});

		});

		return this._configEnv;
	}

	async _persistWipe(){

		const persistPath = await this._persistPath();

		if( ! persistPath )
			throw __.error('expect (persistPath) to be truthy.', {persistPath});

		await Fs.unlink(persistPath);

		return await this._persistRefresh();
	}

	/**
	 *
	 * @param configDetails
	 * @returns {Promise<*>}
	 * @private
	 * @TODO Need to do write locking
	 */
	async _persistUpdate(configDetails) {

		if( ! __.isPlainObject(configDetails) )
			throw __.error({configDetails});

		if( configDetails.configPath !== undefined )
			configDetails = _.transform(configDetails, (r, v, k) => {
				k !== 'configPath' && (r[k] = v);
			}, {});

		const configPersist = await this._persistRefresh();

		if( configPersist === undefined )
			return false;
		else if( _.isEmpty(configDetails) )
			return configPersist;

		let updated;

		_.transform(configDetails, (configPersist, v, k) => {
			if( ! _.isEqual(v, configPersist[k]) ) {
				updated = true;
				Reflect.defineProperty(configPersist, k, {
					value: v,
					enumerable: true,
					writable: true,
					configurable: true
				});
			}

		}, configPersist);

		if( ! updated )
			return configPersist;

		await this._persistWrite(configPersist);

		return configPersist
	}

	async _persistRefresh() {

		const configStored = await this._persistRead();

		if( configStored === undefined )
			return undefined;

		if( ! __.isObject(configStored) )
			throw __.error({configStored});

		if( _.isEmpty(configStored) ) {

			_.forEach(this._configPersist, (v, k, existingPersistedConfig) => {
				delete existingPersistedConfig[k];
			});

		}
		else {

			//Delete removed items first
			_.forEach(this._configPersist, (v, k, existingPersistedConfig) => {
				if( ! Object.hasOwnProperty.call(configStored, k) || configStored[k] === undefined )
					delete existingPersistedConfig[k];
			});

			_.transform(configStored, (existingPersistedConfig, v, k) => {
				existingPersistedConfig[k] = v;
			}, this._configPersist)
		}

		return this._configPersist;
	}

	async _persistRead(configPath) {

		if( configPath === undefined )
			configPath = await this._persistPath();

		if( ! configPath )
			return undefined;

		try {
			return await Fs.readJson(configPath);
		}
		catch( err ) {
			return {}
		}
	}

	async _persistWrite(configJson, configPath) {

		if( __.type(configJson) !== 'object' )
			throw new Error();

		if( _.some(configJson, (v, k) => ! validConfigKeys[k]) )
			throw new Error();

		if( ! configPath ) {
			configPath = await this._persistPath();
			if( ! configPath )
				throw __.error({configPath});
		}

		await Fs.outputJson(configPath, configJson);

		return configJson;
	}

	async _persistPath(configPath) {
		if( configPath === undefined ){
			configPath = this._config.configPath;
			if( ! configPath )
				return undefined;
		}
		await Fs.ensureFile(configPath);
		return configPath;
	}
}

module.exports = Config;

module.exports.Config = Config;