feat: introduce jsonFileSettingsService to work with JSON files

Intorduce a new service - `jsonFileSettingsService` to work with JSON files in which you need to persist specific settings. The read/write operation of the file are locked, which makes the service usable in multiple cases.
Having a separate service allows us to use multiple files to store data instead of writing everything in the user-settings.json file. To create the service reuse the logic from the old UserSettingsServiceBase and make it available through `$injector`.
Add logic in the service to allow writing/reading data within specific cache timeout. In case you want to save data with cache information, just pass this setting to saveSetting method and the service will automatically add required information in the file.
When you read information from the file, the service will check if you have passed cacheTimeout and will respect it when checking the value. In case you've passed cacheTimeout, but the value in the file does not have cache information, the service will return null as it is unable to determine if the cache is valid.
In case there's cache information, the service will return the value in case the cache had not expired and null otherwise. In case the value in the file has cache information, but the readSetting is called without cacheTimeout, the value is returned immediately without checking the cache.

The service is marked as non-shared, so for each `$injector.resolve("jsonFileSettingsService", { jsonFileSettingsPath: "myPath.json" })`, CLI will create a new instance of the service. As all actions are locked via lockfile, this shouldn't be a problem.

Author: rosen-vladimirov

lib/bootstrap.ts

@@ -230,3 +230,4 @@ $injector.requirePublicClass("initializeService", "./services/initialize-service
 
 $injector.require("npmConfigService", "./services/npm-config-service");
 $injector.require("ipService", "./services/ip-service");
+$injector.require("jsonFileSettingsService", "./common/services/json-file-settings-service");

lib/common/declarations.d.ts

@@ -1229,9 +1229,8 @@ interface IPlistParser {
 	parseFileSync(plistFilePath: string): any;
 }
 
-interface IUserSettingsService extends UserSettings.IUserSettingsService {
-	loadUserSettingsFile(): Promise<void>;
-	saveSettings(data: IDictionary<{}>): Promise<void>;
+interface IUserSettingsService extends IJsonFileSettingsService {
+	// keep for backwards compatibility
 }
 
 /**

lib/common/definitions/json-file-settings-service.d.ts

@@ -0,0 +1,15 @@
+interface ICacheTimeoutOpts {
+	cacheTimeout: number;
+}
+
+interface IUseCacheOpts {
+	useCaching: boolean;
+}
+
+interface IJsonFileSettingsService {
+	getSettingValue<T>(settingName: string, cacheOpts?: ICacheTimeoutOpts): Promise<T>;
+	saveSetting<T>(key: string, value: T, cacheOpts?: IUseCacheOpts): Promise<void>;
+	removeSetting(key: string): Promise<void>;
+	loadUserSettingsFile(): Promise<void>;
+	saveSettings(data: IDictionary<{}>, cacheOpts?: IUseCacheOpts): Promise<void>;
+}

lib/common/definitions/user-settings.d.ts

@@ -0,0 +1,132 @@
+import * as path from "path";
+import { parseJson } from "../helpers";
+
+export class JsonFileSettingsService implements IJsonFileSettingsService {
+	private jsonSettingsFilePath: string = null;
+	protected jsonSettingsData: any = null;
+	private get lockFilePath(): string {
+		return `${this.jsonSettingsFilePath}.lock`;
+	}
+
+	constructor(jsonFileSettingsPath: string,
+		private $fs: IFileSystem,
+		private $lockService: ILockService,
+		private $logger: ILogger) {
+		this.jsonSettingsFilePath = jsonFileSettingsPath;
+	}
+
+	public async getSettingValue<T>(settingName: string, cacheOpts?: { cacheTimeout: number }): Promise<T> {
+		const action = async (): Promise<T> => {
+			await this.loadUserSettingsFile();
+
+			if (this.jsonSettingsData && _.has(this.jsonSettingsData, settingName)) {
+				const data = this.jsonSettingsData[settingName];
+				const dataToReturn = data.modifiedByCacheMechanism ? data.value : data;
+				if (cacheOpts && cacheOpts.cacheTimeout) {
+					if (!data.modifiedByCacheMechanism) {
+						// If data has no cache, but we want to check the timeout, consider the data as outdated.
+						// this should be a really rare case
+						return null;
+					}
+
+					const currentTime = Date.now();
+					if ((currentTime - data.time) > cacheOpts.cacheTimeout) {
+						return null;
+					}
+				}
+
+				return dataToReturn;
+			}
+
+			return null;
+		};
+
+		return this.$lockService.executeActionWithLock<T>(action, this.lockFilePath);
+	}
+
+	public async saveSetting<T>(key: string, value: T, cacheOpts?: { useCaching: boolean }): Promise<void> {
+		const settingObject: any = {};
+		settingObject[key] = value;
+
+		return this.saveSettings(settingObject, cacheOpts);
+	}
+
+	public async removeSetting(key: string): Promise<void> {
+		const action = async (): Promise<void> => {
+			await this.loadUserSettingsFile();
+
+			delete this.jsonSettingsData[key];
+			await this.saveSettings();
+		};
+
+		return this.$lockService.executeActionWithLock<void>(action, this.lockFilePath);
+	}
+
+	public saveSettings(data?: any, cacheOpts?: { useCaching: boolean }): Promise<void> {
+		const action = async (): Promise<void> => {
+			await this.loadUserSettingsFile();
+			this.jsonSettingsData = this.jsonSettingsData || {};
+
+			_(data)
+				.keys()
+				.each(propertyName => {
+					this.jsonSettingsData[propertyName] = cacheOpts && cacheOpts.useCaching && !data[propertyName].modifiedByCacheMechanism ? {
+						time: Date.now(),
+						value: data[propertyName],
+						modifiedByCacheMechanism: true
+					} : data[propertyName];
+				});
+
+			this.$fs.writeJson(this.jsonSettingsFilePath, this.jsonSettingsData);
+		};
+
+		return this.$lockService.executeActionWithLock<void>(action, this.lockFilePath);
+	}
+
+	public async loadUserSettingsFile(): Promise<void> {
+		if (!this.jsonSettingsData) {
+			await this.loadUserSettingsData();
+		}
+	}
+
+	private async loadUserSettingsData(): Promise<void> {
+		if (!this.$fs.exists(this.jsonSettingsFilePath)) {
+			const unexistingDirs = this.getUnexistingDirectories(this.jsonSettingsFilePath);
+
+			this.$fs.writeFile(this.jsonSettingsFilePath, null);
+
+			// when running under 'sudo' we create the <path to home dir>/.local/share/.nativescript-cli dir with root as owner
+			// and other Applications cannot access this directory anymore. (bower/heroku/etc)
+			if (process.env.SUDO_USER) {
+				for (const dir of unexistingDirs) {
+					await this.$fs.setCurrentUserAsOwner(dir, process.env.SUDO_USER);
+				}
+			}
+		}
+
+		const data = this.$fs.readText(this.jsonSettingsFilePath);
+
+		try {
+			this.jsonSettingsData = parseJson(data);
+		} catch (err) {
+			this.$logger.trace(`Error while trying to parseJson ${data} data from ${this.jsonSettingsFilePath} file. Err is: ${err}`);
+			this.$fs.deleteFile(this.jsonSettingsFilePath);
+		}
+	}
+
+	private getUnexistingDirectories(filePath: string): Array<string> {
+		const unexistingDirs: Array<string> = [];
+		let currentDir = path.join(filePath, "..");
+		while (true) {
+			// this directory won't be created.
+			if (this.$fs.exists(currentDir)) {
+				break;
+			}
+			unexistingDirs.push(currentDir);
+			currentDir = path.join(currentDir, "..");
+		}
+		return unexistingDirs;
+	}
+}
+
+$injector.register("jsonFileSettingsService", JsonFileSettingsService, false);