Expose loadExtension to fix double loading of packages

In case you install extension, the method automatically loads it. However calling `loadExtensions` after that loads it again, so our `$injector` fails.
In order to fix this, remove the loading from the `installExtension` method and expose `loadExtension(name)` method.
So in the future in case someone wants to load a new an extension after calling `loadExtensions`, they'll be able to use the new method.

Author: rosen-vladimirov

PublicAPI.md

@@ -180,6 +180,31 @@ for (let promise of loadExtensionsPromises) {
 }
 ```
 
+### loadExtension
+Loads a specified extension.
+
+* Definition
+```TypeScript
+/**
+ * Loads a single extension, so their methods and commands can be used from CLI.
+ * @param {string} extensionName Name of the extension to be installed. It may contain version as well, i.e. myPackage, myPackage@1.0.0
+ * A Promise is returned. It will be rejected in case the extension cannot be loaded.
+ * @returns {Promise<IExtensionData>} Promise, resolved with IExtensionData.
+ */
+loadExtension(extensionName: string): Promise<IExtensionData>;
+```
+
+* Usage:
+```JavaScript
+tns.extensibilityService.loadExtension("my-extension")
+	.then(extensionData => console.log(`Loaded extension: ${extensionData.extensionName}.`),
+		err => {
+			console.log(`Failed to load extension: ${err.extensionName}`);
+			console.log(err);
+		});
+}
+```
+
 ## settingsService
 `settingsService` module provides a way to configure various settings.
 

lib/definitions/extensibility.d.ts

@@ -35,6 +35,14 @@ interface IExtensibilityService {
 	 */
 	loadExtensions(): Promise<IExtensionData>[];
 
+	/**
+	 * Loads a single extension, so their methods and commands can be used from CLI.
+	 * @param {string} extensionName Name of the extension to be installed. It may contain version as well, i.e. myPackage, myPackage@1.0.0
+	 * A Promise is returned. It will be rejected in case the extension cannot be loaded.
+	 * @returns {Promise<IExtensionData>} Promise, resolved with IExtensionData.
+	 */
+	loadExtension(extensionName: string): Promise<IExtensionData>;
+
 	/**
 	 * Gets information about installed dependencies - names and versions.
 	 * @returns {IStringDictionary}

lib/services/extensibility-service.ts

@@ -35,7 +35,7 @@ export class ExtensibilityService implements IExtensibilityService {
 		const installResultInfo = await this.$npm.install(packageName, this.pathToExtensions, npmOpts);
 		this.$logger.trace(`Finished installation of extension '${extensionName}'. Trying to load it now.`);
 
-		return await this.loadExtension(installResultInfo.name);
+		return { extensionName: installResultInfo.name };
 	}
 
 	@exported("extensibilityService")
@@ -74,7 +74,8 @@ export class ExtensibilityService implements IExtensibilityService {
 		return null;
 	}
 
-	private async loadExtension(extensionName: string): Promise<IExtensionData> {
+	@exported("extensibilityService")
+	public async loadExtension(extensionName: string): Promise<IExtensionData> {
 		try {
 			await this.assertExtensionIsInstalled(extensionName);
 

test/nativescript-cli-lib.ts

@@ -19,7 +19,7 @@ describe("nativescript-cli-lib", () => {
 		localBuildService: ["build"],
 		deviceLogProvider: null,
 		npm: ["install", "uninstall", "view", "search"],
-		extensibilityService: ["loadExtensions", "getInstalledExtensions", "installExtension", "uninstallExtension"],
+		extensibilityService: ["loadExtensions", "loadExtension", "getInstalledExtensions", "installExtension", "uninstallExtension"],
 		analyticsService: ["startEqatecMonitor"],
 		debugService: ["debug"]
 	};

test/services/extensibility-service.ts

@@ -136,37 +136,6 @@ describe("extensibilityService", () => {
 			const actualResult = await extensibilityService.installExtension(extensionName);
 			assert.deepEqual(actualResult, { extensionName });
 		});
-
-		it("throws error that has extensionName property when unable to load extension", async () => {
-			const expectedErrorMessage = "Require failed";
-
-			const extensionName = "extension1";
-			const testInjector = getTestInjector();
-			const fs: IFileSystem = testInjector.resolve("fs");
-			fs.exists = (pathToCheck: string): boolean => path.basename(pathToCheck) !== extensionName;
-
-			fs.readDirectory = (dir: string): string[] => [extensionName];
-
-			const npm: INodePackageManager = testInjector.resolve("npm");
-			npm.install = async (packageName: string, pathToSave: string, config?: any): Promise<any> => ({ name: extensionName });
-
-			const requireService: IRequireService = testInjector.resolve("requireService");
-			requireService.require = (pathToRequire: string) => {
-				throw new Error(expectedErrorMessage);
-			};
-
-			const extensibilityService: IExtensibilityService = testInjector.resolve(ExtensibilityService);
-			let isErrorRaised = false;
-			try {
-				await extensibilityService.installExtension(extensionName);
-			} catch (err) {
-				isErrorRaised = true;
-				assert.deepEqual(err.message, `Unable to load extension ${extensionName}. You will not be able to use the functionality that it adds.`);
-				assert.deepEqual(err.extensionName, extensionName);
-			}
-
-			assert.isTrue(isErrorRaised);
-		});
 	});
 
 	describe("loadExtensions", () => {
@@ -609,4 +578,37 @@ describe("extensibilityService", () => {
 			assert.deepEqual(extensibilityService.getInstalledExtensions(), dependencies);
 		});
 	});
+
+	describe("loadExtension", () => {
+		it("throws error that has extensionName property when unable to load extension", async () => {
+			const expectedErrorMessage = "Require failed";
+
+			const extensionName = "extension1";
+			const testInjector = getTestInjector();
+			const fs: IFileSystem = testInjector.resolve("fs");
+			fs.exists = (pathToCheck: string): boolean => path.basename(pathToCheck) !== extensionName;
+
+			fs.readDirectory = (dir: string): string[] => [extensionName];
+
+			const npm: INodePackageManager = testInjector.resolve("npm");
+			npm.install = async (packageName: string, pathToSave: string, config?: any): Promise<any> => ({ name: extensionName });
+
+			const requireService: IRequireService = testInjector.resolve("requireService");
+			requireService.require = (pathToRequire: string) => {
+				throw new Error(expectedErrorMessage);
+			};
+
+			const extensibilityService: IExtensibilityService = testInjector.resolve(ExtensibilityService);
+			let isErrorRaised = false;
+			try {
+				await extensibilityService.loadExtension(extensionName);
+			} catch (err) {
+				isErrorRaised = true;
+				assert.deepEqual(err.message, `Unable to load extension ${extensionName}. You will not be able to use the functionality that it adds.`);
+				assert.deepEqual(err.extensionName, extensionName);
+			}
+
+			assert.isTrue(isErrorRaised);
+		});
+	});
 });