Merge pull request #3720 from NativeScript/fatme/merge-release-into-master

chore: merge release into master

Author: Fatme

lib/bootstrap.ts

@@ -169,3 +169,5 @@ $injector.requirePublic("assetsGenerationService", "./services/assets-generation
 $injector.require("filesHashService", "./services/files-hash-service");
 $injector.require("iOSLogParserService", "./services/ios-log-parser-service");
 $injector.require("iOSDebuggerPortService", "./services/ios-debugger-port-service");
+
+$injector.require("pacoteService", "./services/pacote-service");

lib/constants.ts

@@ -116,6 +116,7 @@ export const VERSION_STRING = "version";
 export const INSPECTOR_CACHE_DIRNAME = "ios-inspector";
 export const POST_INSTALL_COMMAND_NAME = "post-install-cli";
 export const ANDROID_RELEASE_BUILD_ERROR_MESSAGE = "When producing a release build, you need to specify all --key-store-* options.";
+export const CACACHE_DIRECTORY_NAME = "_cacache";
 
 export class DebugCommandErrors {
 	public static UNABLE_TO_USE_FOR_DEVICE_AND_EMULATOR = "The options --for-device and --emulator cannot be used simultaneously. Please use only one of them.";

lib/declarations.d.ts

@@ -46,6 +46,12 @@ interface INodePackageManager {
 	 * @returns {any} The full data from registry.npmjs.org for this package.
 	 */
 	getRegistryPackageData(packageName: string): Promise<any>;
+
+	/**
+	 * Gets the path to npm cache directory.
+	 * @returns {string} The full path to npm cache directory
+	 */
+	getCachePath(): Promise<string>;
 }
 
 interface INpmInstallationManager {

lib/definitions/pacote-service.d.ts

@@ -0,0 +1,38 @@
+import * as pacote from "pacote";
+import * as tar from "tar";
+
+declare global {
+
+	interface IPacoteService {
+		/**
+		 * Returns the package's json file content
+		 * @param packageName The name of the package
+		 * @param options The provided options can control which properties from package.json file will be returned. In case when fullMetadata option is provided, all data from package.json file will be returned.
+		 */
+		manifest(packageName: string, options: IPacoteManifestOptions): Promise<any>;
+		/**
+		 * Downloads the specified package and extracts it in specified destination directory
+		 * @param packageName The name of the package
+		 * @param destinationDirectory The path to directory where the downloaded tarball will be extracted.
+		 */
+		extractPackage(packageName: string, destinationDirectory: string, options?: IPacoteExtractOptions): Promise<void>;
+	}
+
+	interface IPacoteBaseOptions {
+		/**
+		 * The path to npm cache
+		 */
+		cache?: string;
+	}
+
+	interface IPacoteManifestOptions extends IPacoteBaseOptions {
+		/**
+		 * If true, the whole package.json data will be returned
+		 */
+		fullMetadata?: boolean;
+	}
+
+	interface IPacoteExtractOptions {
+		filter?: (path: string, stat: tar.FileStat) => boolean;
+	}
+}

lib/definitions/pacote.d.ts

@@ -0,0 +1,14 @@
+declare module "pacote" {
+	import * as stream from "stream";
+
+	export function manifest(packageName: string, options: IPacoteManifestOptions): Promise<any>;
+	export var tarball: IPacoteTarballResult;
+
+	interface IPacoteTarballResult {
+		stream: (packageName: string, options: IPacoteBaseOptions) => IPacoteTarballStreamResult;
+		toFile: (packageName: string) => IPacoteTarballFileResult;
+	}
+
+	interface IPacoteTarballStreamResult extends stream.Readable { }
+	interface IPacoteTarballFileResult { }
+}

lib/definitions/project.d.ts

@@ -210,8 +210,41 @@ interface IImageDefinitionsStructure {
 }
 
 interface ITemplateData {
+	/**
+	 * The normalized template name
+	 * In case no --template option is provided, use default template name
+	 * In case --template <templateName> option is provided, use <templateName>
+	 * In case --template <templateName>@<version> is provided, use <templateName>
+	 * In case --ng option is provided, use default angular template name
+	 * In case --ts option is provided, use default typescript template name
+	 */
+	templateName: string;
+	/**
+	 * The path to the template.
+	 * In case template is v1, will be {pathToProjectDir}/node_modules/{templateName}.
+	 * In case template is v2, will be null.
+	 */
 	templatePath: string;
+	/**
+	 * The templateVersion property from nativescript section inside package.json file
+	 * "nativescript": {
+			"id": "org.nativescript.app6",
+			"templateVersion": "v2"
+		}
+	 */
 	templateVersion: string;
+	/**
+	 * The whole content of package.json file
+	 */
+	templatePackageJsonContent: ITemplatePackageJsonContent;
+}
+
+interface ITemplatePackageJsonContent extends IBasePluginData {
+	dependencies: IStringDictionary;
+	devDependencies: IStringDictionary;
+	nativescript?: {
+		templateVersion?: string;
+	}
 }
 
 /**
@@ -227,14 +260,6 @@ interface IProjectTemplatesService {
 	 * @return {ITemplateData} Data describing the template - location where it is installed and its NativeScript version.
 	 */
 	prepareTemplate(templateName: string, projectDir: string): Promise<ITemplateData>;
-
-	/**
-	 * Gives information for the nativescript specific version of the template, for example v1, v2, etc.
-	 * Defaults to v1 in case there's no version specified.
-	 * @param {string} templatePath Full path to the template.
-	 * @returns {string} The version, for example v1 or v2.
-	 */
-	getTemplateVersion(templatePath: string): string;
 }
 
 interface IPlatformProjectServiceBase {

lib/node-package-manager.ts

@@ -1,6 +1,7 @@
 import * as path from "path";
-import { exported } from "./common/decorators";
+import { exported, cache } from "./common/decorators";
 import { isInteractive } from "./common/helpers";
+import { CACACHE_DIRECTORY_NAME } from "./constants";
 
 export class NodePackageManager implements INodePackageManager {
 	private static SCOPED_DEPENDENCY_REGEXP = /^(@.+?)(?:@(.+?))?$/;
@@ -128,6 +129,12 @@ export class NodePackageManager implements INodePackageManager {
 		return jsonData;
 	}
 
+	@cache()
+	public async getCachePath(): Promise<string> {
+		const cachePath = await this.$childProcess.exec(`npm config get cache`);
+		return path.join(cachePath.trim(), CACACHE_DIRECTORY_NAME);
+	}
+
 	private getNpmExecutableName(): string {
 		let npmExecutableName = "npm";
 

lib/services/pacote-service.ts

@@ -0,0 +1,35 @@
+import * as pacote from "pacote";
+import * as tar from "tar";
+
+export class PacoteService implements IPacoteService {
+	constructor(private $npm: INodePackageManager) { }
+
+	public async manifest(packageName: string, options?: IPacoteManifestOptions): Promise<any> {
+		// In case `tns create myapp --template https://github.com/NativeScript/template-hello-world.git` command is executed, pacote module throws an error if cache option is not provided.
+		const manifestOptions = { cache: await this.$npm.getCachePath() };
+		if (options) {
+			_.extend(manifestOptions, options);
+		}
+
+		return pacote.manifest(packageName, manifestOptions);
+	}
+
+	public async extractPackage(packageName: string, destinationDirectory: string, options?: IPacoteExtractOptions): Promise<void> {
+		// strip: Remove the specified number of leading path elements. Pathnames with fewer elements will be silently skipped. More info: https://github.com/npm/node-tar/blob/e89c4d37519b1c20133a9f49d5f6b85fa34c203b/README.md
+		// C: Create an archive
+		const extractOptions = { strip: 1, C: destinationDirectory };
+		if (options) {
+			_.extend(extractOptions, options);
+		}
+
+		const source = pacote.tarball.stream(packageName, { cache: await this.$npm.getCachePath() });
+		const destination = tar.x(extractOptions);
+		source.pipe(destination);
+
+		return new Promise<void>((resolve, reject) => {
+			destination.on("error", (err: Error) => reject(err));
+			destination.on("finish", () => resolve());
+		});
+	}
+}
+$injector.register("pacoteService", PacoteService);

lib/services/project-service.ts

@@ -1,6 +1,7 @@
 import * as constants from "../constants";
 import * as path from "path";
 import * as shelljs from "shelljs";
+import { format } from "util";
 import { exported } from "../common/decorators";
 import { Hooks } from "../constants";
 
@@ -11,6 +12,7 @@ export class ProjectService implements IProjectService {
 		private $errors: IErrors,
 		private $fs: IFileSystem,
 		private $logger: ILogger,
+		private $pacoteService: IPacoteService,
 		private $projectDataService: IProjectDataService,
 		private $projectHelper: IProjectHelper,
 		private $projectNameService: IProjectNameService,
@@ -21,7 +23,6 @@ export class ProjectService implements IProjectService {
 	@exported("projectService")
 	public async createProject(projectOptions: IProjectSettings): Promise<ICreateProjectData> {
 		let projectName = projectOptions.projectName;
-		let selectedTemplate = projectOptions.template;
 
 		if (!projectName) {
 			this.$errors.fail("You must specify <App name> when creating a new project.");
@@ -41,11 +42,8 @@ export class ProjectService implements IProjectService {
 		const appId = projectOptions.appId || this.$projectHelper.generateDefaultAppId(projectName, constants.DEFAULT_APP_IDENTIFIER_PREFIX);
 		this.createPackageJson(projectDir, appId);
 		this.$logger.trace(`Creating a new NativeScript project with name ${projectName} and id ${appId} at location ${projectDir}`);
-		if (!selectedTemplate) {
-			selectedTemplate = constants.RESERVED_TEMPLATE_NAMES["default"];
-		}
 
-		const projectCreationData = await this.createProjectCore({ template: selectedTemplate, projectDir, ignoreScripts: projectOptions.ignoreScripts, appId: appId, projectName });
+		const projectCreationData = await this.createProjectCore({ template: projectOptions.template, projectDir, ignoreScripts: projectOptions.ignoreScripts, appId: appId, projectName });
 
 		this.$logger.printMarkdown("Project `%s` was successfully created.", projectCreationData.projectName);
 
@@ -56,20 +54,25 @@ export class ProjectService implements IProjectService {
 		const { template, projectDir, appId, projectName, ignoreScripts } = projectCreationSettings;
 
 		try {
-			const { templatePath, templateVersion } = await this.$projectTemplatesService.prepareTemplate(template, projectDir);
-			await this.extractTemplate(projectDir, templatePath, templateVersion);
+			const templateData = await this.$projectTemplatesService.prepareTemplate(template, projectDir);
+			const templatePackageJsonContent = templateData.templatePackageJsonContent;
+			const templateVersion = templateData.templateVersion;
 
-			await this.ensureAppResourcesExist(projectDir);
+			await this.extractTemplate(projectDir, templateData);
 
-			const templatePackageJsonData = this.getDataFromJson(templatePath);
+			if (templateVersion === constants.TemplateVersions.v2) {
+				this.alterPackageJsonData(projectDir, appId);
+			}
 
-			if (!(templatePackageJsonData && templatePackageJsonData.dependencies && templatePackageJsonData.dependencies[constants.TNS_CORE_MODULES_NAME])) {
-				await this.$npmInstallationManager.install(constants.TNS_CORE_MODULES_NAME, projectDir, { dependencyType: "save" });
+			await this.ensureAppResourcesExist(projectDir);
+
+			if (!(templatePackageJsonContent && templatePackageJsonContent.dependencies && templatePackageJsonContent.dependencies[constants.TNS_CORE_MODULES_NAME])) {
+				await this.addTnsCoreModules(projectDir);
 			}
 
 			if (templateVersion === constants.TemplateVersions.v1) {
-				this.mergeProjectAndTemplateProperties(projectDir, templatePackageJsonData); // merging dependencies from template (dev && prod)
-				this.removeMergedDependencies(projectDir, templatePackageJsonData);
+				this.mergeProjectAndTemplateProperties(projectDir, templatePackageJsonContent); // merging dependencies from template (dev && prod)
+				this.removeMergedDependencies(projectDir, templatePackageJsonContent);
 			}
 
 			// Install devDependencies and execute all scripts:
@@ -79,12 +82,8 @@ export class ProjectService implements IProjectService {
 				ignoreScripts
 			});
 
-			const templatePackageJsonPath = templateVersion === constants.TemplateVersions.v2 ? path.join(projectDir, constants.PACKAGE_JSON_FILE_NAME) : path.join(templatePath, constants.PACKAGE_JSON_FILE_NAME);
-			const templatePackageJson = this.$fs.readJson(templatePackageJsonPath);
-
-			await this.$npm.uninstall(templatePackageJson.name, { save: true }, projectDir);
-			if (templateVersion === constants.TemplateVersions.v2) {
-				this.alterPackageJsonData(projectDir, appId);
+			if (templateVersion === constants.TemplateVersions.v1) {
+				await this.$npm.uninstall(templatePackageJsonContent.name, { save: true }, projectDir);
 			}
 		} catch (err) {
 			this.$fs.deleteDirectory(projectDir);
@@ -109,40 +108,27 @@ export class ProjectService implements IProjectService {
 		}
 	}
 
-	private getDataFromJson(templatePath: string): any {
-		const templatePackageJsonPath = path.join(templatePath, constants.PACKAGE_JSON_FILE_NAME);
-		if (this.$fs.exists(templatePackageJsonPath)) {
-			const templatePackageJsonData = this.$fs.readJson(templatePackageJsonPath);
-			return templatePackageJsonData;
-		} else {
-			this.$logger.trace(`Template ${templatePath} does not have ${constants.PACKAGE_JSON_FILE_NAME} file.`);
-		}
-
-		return null;
-	}
-
-	private async extractTemplate(projectDir: string, realTemplatePath: string, templateVersion: string): Promise<void> {
+	private async extractTemplate(projectDir: string, templateData: ITemplateData): Promise<void> {
 		this.$fs.ensureDirectoryExists(projectDir);
 
-		this.$logger.trace(`Template version is ${templateVersion}`);
-		let destinationDir = "";
-		switch (templateVersion) {
+		switch (templateData.templateVersion) {
 			case constants.TemplateVersions.v1:
 				const projectData = this.$projectDataService.getProjectData(projectDir);
-				const appDestinationPath = projectData.getAppDirectoryPath(projectDir);
-				this.$fs.createDirectory(appDestinationPath);
-				destinationDir = appDestinationPath;
+				const destinationDirectory = projectData.getAppDirectoryPath(projectDir);
+				this.$fs.createDirectory(destinationDirectory);
+
+				this.$logger.trace(`Copying application from '${templateData.templatePath}' into '${destinationDirectory}'.`);
+				shelljs.cp('-R', path.join(templateData.templatePath, "*"), destinationDirectory);
+
+				this.$fs.createDirectory(path.join(projectDir, "platforms"));
 				break;
 			case constants.TemplateVersions.v2:
+				await this.$pacoteService.extractPackage(templateData.templateName, projectDir);
+				break;
 			default:
-				destinationDir = projectDir;
+				this.$errors.failWithoutHelp(format(constants.ProjectTemplateErrors.InvalidTemplateVersionStringFormat, templateData.templateName, templateData.templateVersion));
 				break;
 		}
-
-		this.$logger.trace(`Copying application from '${realTemplatePath}' into '${destinationDir}'.`);
-		shelljs.cp('-R', path.join(realTemplatePath, "*"), destinationDir);
-
-		this.$fs.createDirectory(path.join(projectDir, "platforms"));
 	}
 
 	private async ensureAppResourcesExist(projectDir: string): Promise<void> {
@@ -154,36 +140,7 @@ export class ProjectService implements IProjectService {
 			this.$fs.createDirectory(appResourcesDestinationPath);
 
 			// the template installed doesn't have App_Resources -> get from a default template
-			const defaultTemplateName = constants.RESERVED_TEMPLATE_NAMES["default"];
-			await this.$npm.install(defaultTemplateName, projectDir, {
-				save: true,
-				disableNpmInstall: false,
-				frameworkPath: null,
-				ignoreScripts: false
-			});
-
-			const defaultTemplatePath = path.join(projectDir, constants.NODE_MODULES_FOLDER_NAME, defaultTemplateName);
-			const defaultTemplateVersion = this.$projectTemplatesService.getTemplateVersion(defaultTemplatePath);
-
-			let defaultTemplateAppResourcesPath: string = null;
-			switch (defaultTemplateVersion) {
-				case constants.TemplateVersions.v1:
-					defaultTemplateAppResourcesPath = path.join(projectDir,
-						constants.NODE_MODULES_FOLDER_NAME,
-						defaultTemplateName,
-						constants.APP_RESOURCES_FOLDER_NAME);
-					break;
-				case constants.TemplateVersions.v2:
-				default:
-					const defaultTemplateProjectData = this.$projectDataService.getProjectData(defaultTemplatePath);
-					defaultTemplateAppResourcesPath = defaultTemplateProjectData.appResourcesDirectoryPath;
-			}
-
-			if (defaultTemplateAppResourcesPath && this.$fs.exists(defaultTemplateAppResourcesPath)) {
-				shelljs.cp('-R', defaultTemplateAppResourcesPath, appPath);
-			}
-
-			await this.$npm.uninstall(defaultTemplateName, { save: true }, projectDir);
+			await this.$pacoteService.extractPackage(constants.RESERVED_TEMPLATE_NAMES["default"], appPath, { filter: (name: string, entry: any) => entry.path.indexOf(constants.APP_RESOURCES_FOLDER_NAME) !== -1 });
 		}
 	}
 
@@ -271,5 +228,15 @@ export class ProjectService implements IProjectService {
 	private setAppId(projectDir: string, projectId: string): void {
 		this.$projectDataService.setNSValue(projectDir, "id", projectId);
 	}
+
+	private async addTnsCoreModules(projectDir: string): Promise<void> {
+		const projectFilePath = path.join(projectDir, this.$staticConfig.PROJECT_FILE_NAME);
+		const packageJsonData = this.$fs.readJson(projectFilePath);
+
+		const version = await this.$npmInstallationManager.getLatestCompatibleVersion(constants.TNS_CORE_MODULES_NAME);
+		packageJsonData.dependencies[constants.TNS_CORE_MODULES_NAME] = version;
+
+		this.$fs.writeJson(projectFilePath, packageJsonData);
+	}
 }
 $injector.register("projectService", ProjectService);