Add tracking for the project types that users are creating and working with (#2497)

* Track from which template a project is created

Add tracking from which template a project is created. This will give us better picture of the usage of CLI and the types of projects that the users are creating.

* Track project type when deploy/run/livesync is executed

Track the project type (Angular, Pure TypeScript, Pure JavaScript) when any of the commands is executed:
* prepare
* deploy
* run
* livesync

This will allow us to better understand the type of projects that the users are building.

Author: rosen-vladimirov

lib/definitions/platform.d.ts

@@ -142,6 +142,14 @@ interface IPlatformService {
 	 * @returns {string} The contents of the file or null when there is no such file.
 	 */
 	readFile(device: Mobile.IDevice, deviceFilePath: string): Promise<string>;
+
+	/**
+	 * Sends information to analytics for current project type.
+	 * The information is sent once per process for each project.
+	 * In long living process, where the project may change, each of the projects will be tracked after it's being opened.
+	 * @returns {Promise<void>}
+	 */
+	trackProjectType(): Promise<void>;
 }
 
 interface IPlatformData {
@@ -183,4 +191,4 @@ interface INodeModulesDependenciesBuilder {
 interface IBuildInfo {
 	prepareTime: string;
 	buildTime: string;
-}
+}

lib/definitions/project.d.ts

@@ -53,8 +53,10 @@ interface IProjectData {
 	projectFilePath: string;
 	projectId?: string;
 	dependencies: any;
+	devDependencies: IStringDictionary;
 	appDirectoryPath: string;
 	appResourcesDirectoryPath: string;
+	projectType: string;
 }
 
 interface IProjectDataService {

lib/project-data.ts

@@ -2,9 +2,33 @@ import * as constants from "./constants";
 import * as path from "path";
 import { EOL } from "os";
 
+interface IProjectType {
+	type: string;
+	requiredDependencies?: string[];
+	isDefaultProjectType?: boolean;
+}
+
 export class ProjectData implements IProjectData {
 	private static OLD_PROJECT_FILE_NAME = ".tnsproject";
 
+	/**
+	 * NOTE: Order of the elements is important as the TypeScript dependencies are commonly included in Angular project as well.
+	 */
+	private static PROJECT_TYPES: IProjectType[] = [
+		{
+			type: "Pure JavaScript",
+			isDefaultProjectType: true
+		},
+		{
+			type: "Angular",
+			requiredDependencies: ["@angular/core", "nativescript-angular"]
+		},
+		{
+			type: "Pure TypeScript",
+			requiredDependencies: ["typescript", "nativescript-dev-typescript"]
+		}
+	];
+
 	public projectDir: string;
 	public platformsDir: string;
 	public projectFilePath: string;
@@ -13,6 +37,8 @@ export class ProjectData implements IProjectData {
 	public appDirectoryPath: string;
 	public appResourcesDirectoryPath: string;
 	public dependencies: any;
+	public devDependencies: IStringDictionary;
+	public projectType: string;
 
 	constructor(private $fs: IFileSystem,
 		private $errors: IErrors,
@@ -48,6 +74,8 @@ export class ProjectData implements IProjectData {
 				if (data) {
 					this.projectId = data.id;
 					this.dependencies = fileContent.dependencies;
+					this.devDependencies = fileContent.devDependencies;
+					this.projectType = this.getProjectType();
 				} else { // This is the case when we have package.json file but nativescipt key is not presented in it
 					this.tryToUpgradeProject();
 				}
@@ -57,6 +85,21 @@ export class ProjectData implements IProjectData {
 		}
 	}
 
+	private getProjectType(): string {
+		let detectedProjectType = _.find(ProjectData.PROJECT_TYPES, (projectType) => projectType.isDefaultProjectType).type;
+
+		const deps: string[] = _.keys(this.dependencies).concat(_.keys(this.devDependencies));
+
+		_.each(ProjectData.PROJECT_TYPES, projectType => {
+			if (_.some(projectType.requiredDependencies, requiredDependency => deps.indexOf(requiredDependency) !== -1)) {
+				detectedProjectType = projectType.type;
+				return false;
+			}
+		});
+
+		return detectedProjectType;
+	}
+
 	private throwNoProjectFoundError(): void {
 		this.$errors.fail("No project found at or above '%s' and neither was a --path specified.", this.$options.path || path.resolve("."));
 	}

lib/services/livesync/livesync-service.ts

@@ -102,6 +102,8 @@ class LiveSyncService implements ILiveSyncService {
 
 	@helpers.hook('livesync')
 	private async liveSyncCore(liveSyncData: ILiveSyncData[], applicationReloadAction: (deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]) => Promise<void>): Promise<void> {
+		await this.$platformService.trackProjectType();
+
 		let watchForChangeActions: ((event: string, filePath: string, dispatcher: IFutureDispatcher) => Promise<void>)[] = [];
 
 		for (let dataItem of liveSyncData) {

lib/services/platform-service.ts

@@ -17,6 +17,8 @@ export class PlatformService implements IPlatformService {
 		return this.$hooksService;
 	}
 
+	private _trackedProjectFilePath: string = null;
+
 	constructor(private $devicesService: Mobile.IDevicesService,
 		private $errors: IErrors,
 		private $fs: IFileSystem,
@@ -38,7 +40,8 @@ export class PlatformService implements IPlatformService {
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $deviceAppDataFactory: Mobile.IDeviceAppDataFactory,
 		private $projectChangesService: IProjectChangesService,
-		private $emulatorPlatformService: IEmulatorPlatformService) { }
+		private $emulatorPlatformService: IEmulatorPlatformService,
+		private $analyticsService: IAnalyticsService) { }
 
 	public async addPlatforms(platforms: string[]): Promise<void> {
 		let platformsDir = this.$projectData.platformsDir;
@@ -186,6 +189,8 @@ export class PlatformService implements IPlatformService {
 	public async preparePlatform(platform: string): Promise<boolean> {
 		this.validatePlatform(platform);
 
+		await this.trackProjectType();
+
 		//We need dev-dependencies here, so before-prepare hooks will be executed correctly.
 		try {
 			await this.$pluginsService.ensureAllDependenciesAreInstalled();
@@ -314,7 +319,7 @@ export class PlatformService implements IPlatformService {
 	}
 
 	public async shouldBuild(platform: string, buildConfig?: IBuildConfig): Promise<boolean> {
-			if (this.$projectChangesService.currentChanges.changesRequireBuild) {
+		if (this.$projectChangesService.currentChanges.changesRequireBuild) {
 			return true;
 		}
 		let platformData = this.$platformsData.getPlatformData(platform);
@@ -342,8 +347,21 @@ export class PlatformService implements IPlatformService {
 		return prepareInfo.changesRequireBuildTime !== buildInfo.prepareTime;
 	}
 
+	public async trackProjectType(): Promise<void> {
+		// Track each project once per process.
+		// In long living process, where we may work with multiple projects, we would like to track the information for each of them.
+		if (this.$projectData && (this.$projectData.projectFilePath !== this._trackedProjectFilePath)) {
+			this._trackedProjectFilePath = this.$projectData.projectFilePath;
+
+			await this.$analyticsService.track("Working with project type", this.$projectData.projectType);
+		}
+	}
+
 	public async buildPlatform(platform: string, buildConfig?: IBuildConfig): Promise<void> {
 		this.$logger.out("Building project...");
+
+		await this.trackProjectType();
+
 		let platformData = this.$platformsData.getPlatformData(platform);
 		await platformData.platformProjectService.buildProject(platformData.projectRoot, buildConfig);
 		let prepareInfo = this.$projectChangesService.getPrepareInfo(platform);
@@ -417,6 +435,8 @@ export class PlatformService implements IPlatformService {
 	}
 
 	public async runPlatform(platform: string): Promise<void> {
+		await this.trackProjectType();
+
 		if (this.$options.justlaunch) {
 			this.$options.watch = false;
 		}

lib/services/project-templates-service.ts

@@ -5,25 +5,24 @@ temp.track();
 
 export class ProjectTemplatesService implements IProjectTemplatesService {
 
-	public constructor(private $fs: IFileSystem,
+	public constructor(private $analyticsService: IAnalyticsService,
+		private $fs: IFileSystem,
 		private $logger: ILogger,
 		private $npmInstallationManager: INpmInstallationManager) { }
 
 	public async prepareTemplate(originalTemplateName: string, projectDir: string): Promise<string> {
-		let realTemplatePath: string;
 		// support <reserved_name>@<version> syntax
 		let data = originalTemplateName.split("@"),
 			name = data[0],
 			version = data[1];
 
-		if (constants.RESERVED_TEMPLATE_NAMES[name.toLowerCase()]) {
-			realTemplatePath = await this.prepareNativeScriptTemplate(constants.RESERVED_TEMPLATE_NAMES[name.toLowerCase()], version, projectDir);
-		} else {
-			// Use the original template name, specified by user as it may be case-sensitive.
-			realTemplatePath = await this.prepareNativeScriptTemplate(originalTemplateName, version, projectDir);
-		}
+		const templateName = constants.RESERVED_TEMPLATE_NAMES[name.toLowerCase()] || name;
 
-		//this removes dependencies from templates so they are not copied to app folder
+		await this.$analyticsService.track("Template used for project creation", templateName);
+
+		const realTemplatePath = await this.prepareNativeScriptTemplate(templateName, version, projectDir);
+
+		// this removes dependencies from templates so they are not copied to app folder
 		this.$fs.deleteDirectory(path.join(realTemplatePath, constants.NODE_MODULES_FOLDER_NAME));
 
 		return realTemplatePath;

test/npm-support.ts

@@ -79,6 +79,10 @@ function createTestInjector(): IInjector {
 	testInjector.register("config", StaticConfigLib.Configuration);
 	testInjector.register("projectChangesService", ProjectChangesLib.ProjectChangesService);
 	testInjector.register("emulatorPlatformService", stubs.EmulatorPlatformService);
+	testInjector.register("analyticsService", {
+		track: async () => undefined
+	});
+
 	return testInjector;
 }
 

test/platform-commands.ts

@@ -136,6 +136,10 @@ function createTestInjector() {
 	testInjector.register("childProcess", ChildProcessLib.ChildProcess);
 	testInjector.register("projectChangesService", ProjectChangesLib.ProjectChangesService);
 	testInjector.register("emulatorPlatformService", stubs.EmulatorPlatformService);
+	testInjector.register("analyticsService", {
+		track: async () => undefined
+	});
+
 	return testInjector;
 }
 

test/platform-service.ts

@@ -76,6 +76,9 @@ function createTestInjector() {
 	testInjector.register("childProcess", ChildProcessLib.ChildProcess);
 	testInjector.register("projectChangesService", ProjectChangesLib.ProjectChangesService);
 	testInjector.register("emulatorPlatformService", stubs.EmulatorPlatformService);
+	testInjector.register("analyticsService", {
+		track: async () => undefined
+	});
 
 	return testInjector;
 }

test/project-data.ts

@@ -0,0 +1,77 @@
+import { ProjectData } from "../lib/project-data";
+import { Yok } from "../lib/common/yok";
+import { assert } from "chai";
+import * as stubs from "./stubs";
+import * as path from "path";
+
+describe("projectData", () => {
+	const createTestInjector = (): IInjector => {
+		const testInjector = new Yok();
+
+		testInjector.register("projectHelper", {
+			projectDir: null,
+			sanitizeName: (name: string) => name
+		});
+
+		testInjector.register("fs", {
+			exists: () => true,
+			readJson: (): any => null
+		});
+
+		testInjector.register("staticConfig", {
+			CLIENT_NAME_KEY_IN_PROJECT_FILE: "nativescript",
+			PROJECT_FILE_NAME: "package.json"
+		});
+
+		testInjector.register("errors", stubs.ErrorsStub);
+
+		testInjector.register("logger", stubs.LoggerStub);
+
+		testInjector.register("options", {});
+
+		testInjector.register("projectData", ProjectData);
+
+		return testInjector;
+	};
+
+	describe("projectType", () => {
+
+		const assertProjectType = (dependencies: any, devDependencies: any, expectedProjecType: string) => {
+			const testInjector = createTestInjector();
+			const fs = testInjector.resolve("fs");
+			fs.exists = (filePath: string) => filePath && path.basename(filePath) === "package.json";
+
+			fs.readJson = () => ({
+				nativescript: {},
+				dependencies: dependencies,
+				devDependencies: devDependencies
+			});
+
+			const projectHelper: IProjectHelper = testInjector.resolve("projectHelper");
+			projectHelper.projectDir = "projectDir";
+
+			const projectData: IProjectData = testInjector.resolve("projectData");
+			assert.deepEqual(projectData.projectType, expectedProjecType);
+		};
+
+		it("detects project as Angular when @angular/core exists as dependency", () => {
+			assertProjectType({ "@angular/core": "*" }, null, "Angular");
+		});
+
+		it("detects project as Angular when nativescript-angular exists as dependency", () => {
+			assertProjectType({ "nativescript-angular": "*" }, null, "Angular");
+		});
+
+		it("detects project as TypeScript when nativescript-dev-typescript exists as dependency", () => {
+			assertProjectType(null, { "nativescript-dev-typescript": "*" }, "Pure TypeScript");
+		});
+
+		it("detects project as TypeScript when typescript exists as dependency", () => {
+			assertProjectType(null, { "typescript": "*" }, "Pure TypeScript");
+		});
+
+		it("detects project as JavaScript when no other project type is detected", () => {
+			assertProjectType(null, null, "Pure JavaScript");
+		});
+	});
+});