feat(@angular/cli): version check the CLI version against npm

Fixes angular#6592

Author: Brocco

packages/@angular/cli/commands/generate.ts

@@ -125,6 +125,17 @@ export default Command.extend({
     };
 
     return blueprint.install(blueprintOptions)
+      .then(() => {
+        const VersionCheckTask = require('../tasks/version-check').default;
+        const versionCheckTask = new VersionCheckTask({
+          ui: this.ui,
+          project: this.project
+        });
+        return versionCheckTask.run({
+          forceCheck: false,
+          includeUnstable: CliConfig.getValue('update.includePrerelease')
+        });
+      })
       .then(() => {
         const lintFix = commandOptions.lintFix !== undefined ?
           commandOptions.lintFix : CliConfig.getValue('defaults.lintFix');

packages/@angular/cli/commands/version-check.ts

@@ -0,0 +1,37 @@
+const Command = require('../ember-cli/lib/models/command');
+import { default as VersionCheckTask, VersionCheckTaskOptions } from '../tasks/version-check';
+
+export interface UpdateOptions {
+  includeUnstable: boolean;
+}
+
+const VersionCheckCommand = Command.extend({
+  name: 'version-check',
+  description: 'Checks for an updated version.',
+  works: 'insideProject',
+  availableOptions: [
+    {
+      name: 'include-unstable',
+      type: Boolean,
+      default: false,
+      description: 'Include unstable releases when checking.'
+    }
+  ],
+
+  run: function(commandOptions: UpdateOptions) {
+    const versionCheckTask = new VersionCheckTask({
+      ui: this.ui,
+      project: this.project
+    });
+    const options: VersionCheckTaskOptions = {...commandOptions, ...{ forceCheck: true } };
+
+    return versionCheckTask.run(options)
+      .then((newVersionAvailable: boolean) => {
+        if (!newVersionAvailable) {
+          console.log('@angular/cli is up to date.');
+        }
+      });
+  }
+});
+
+export default VersionCheckCommand;

packages/@angular/cli/lib/cli/index.js

@@ -23,6 +23,7 @@ function loadCommands() {
     'help': require('../../commands/help').default,
     'lint': require('../../commands/lint').default,
     'version': require('../../commands/version').default,
+    'version-check': require('../../commands/version-check').default,
     'completion': require('../../commands/completion').default,
     'doc': require('../../commands/doc').default,
     'xi18n': require('../../commands/xi18n').default,

packages/@angular/cli/lib/config/schema.json

@@ -514,6 +514,28 @@
           "default": true
         }
       }
+    },
+    "update": {
+      "type": "object",
+      "description": "Configuration for CLI update checks.",
+      "default": {},
+      "properties": {
+        "lastChecked": {
+          "type": "object",
+          "default": {},
+          "additionalProperties": true
+        },
+        "checkFrequency": {
+          "type": "string",
+          "description": "Defines how often to check for an updated version.",
+          "default": "1d"
+        },
+        "includePrerelease": {
+          "type": "boolean",
+          "description": "Include pre-release versions when checking for updates.",
+          "default": false
+        }
+      }
     }
   },
   "additionalProperties": false

packages/@angular/cli/tasks/version-check.ts

@@ -0,0 +1,75 @@
+const Task = require('../ember-cli/lib/models/task');
+import { CliConfig } from '../models/config';
+import { CliConfig as ConfigInterface } from '../lib/config/schema';
+import { timeToCheck, newVersionAvailable, CheckResult } from '../update/check';
+import { oneLine } from 'common-tags';
+import * as chalk from 'chalk';
+
+export interface VersionCheckTaskOptions {
+  forceCheck: boolean;
+  includeUnstable: boolean;
+}
+
+export default Task.extend({
+  run: function(options: VersionCheckTaskOptions) {
+    const globalConfigManager = CliConfig.fromGlobal();
+    const globalConfig = globalConfigManager.config;
+    const lastChecked = getLastChecked(globalConfig, this.project.root);
+    const frequency = getFrequency(globalConfig);
+
+    const isTimeToCheck = timeToCheck(lastChecked, frequency);
+    if (isTimeToCheck) {
+      updateLastChecked(globalConfigManager, this.project.root);
+    }
+
+    if (options.forceCheck || isTimeToCheck) {
+      const rootDir = '';
+      const packageName = '@angular/cli';
+      return newVersionAvailable(rootDir, packageName, options)
+        .then((result: CheckResult) => {
+          const newVersionAvailable = !!result.newVersion;
+          if (newVersionAvailable) {
+            this.ui.writeLine(chalk.yellow(oneLine`Current version (${result.currentVersion})
+              is out of date consider updating to the new version (${result.newVersion})`));
+          }
+          return newVersionAvailable;
+        })
+        .catch(() => {}); // Ignore version check failures.
+    }
+  }
+});
+
+function getLastChecked(config: ConfigInterface, rootDir: string): Date {
+  let lastChecked;
+  if (config && config.update && config.update.lastChecked) {
+    lastChecked = config.update.lastChecked[encodePath(rootDir)];
+    if (lastChecked) {
+      lastChecked = new Date(lastChecked);
+    }
+  }
+  return lastChecked || new Date(0);
+}
+
+function updateLastChecked(config: CliConfig, rootDir: string): void {
+  const now = (new Date()).toISOString();
+  if (!config.get('update')) {
+    config.set('update', {});
+  }
+  if (!config.get('update.lastChecked')) {
+    config.set('update.lastChecked', {});
+  }
+  config.set(`update.lastChecked.${encodePath(rootDir)}`, now);
+  config.save();
+}
+
+function encodePath(path: string): string {
+  return path.replace(/\./g, '|');
+}
+
+function getFrequency(config: ConfigInterface): string {
+  let frequency;
+  if (config && config.update) {
+    frequency = config.update.checkFrequency;
+  }
+  return frequency || '1d';
+}

packages/@angular/cli/update/check.ts

@@ -0,0 +1,143 @@
+import * as path from 'path';
+import * as https from 'https';
+import {lt} from 'semver';
+
+
+const ONE_HOUR = 3600000;
+const ONE_DAY = ONE_HOUR * 24;
+const ONE_WEEK = ONE_DAY * 7;
+
+export interface CheckOptions {
+  includeUnstable: boolean;
+}
+
+export interface CheckResult {
+  currentVersion: string;
+  newVersion?: string;
+}
+
+export function timeToCheck(lastChecked: Date, frequency: string): boolean {
+  const freq = frequency || '1d';
+  if (freq.toLowerCase() === 'never') {
+    return false;
+  } else if (freq.toLowerCase() === 'always') {
+    return true;
+  }
+  if (!lastChecked) {
+    lastChecked = new Date(0);
+  }
+  const diff = Math.abs(lastChecked.valueOf() - new Date().valueOf());
+  const threshold = convertFrequency(freq);
+  return diff > threshold;
+}
+
+export function newVersionAvailable(
+  rootDir: string,
+  name: string,
+  options?: CheckOptions): Promise<CheckResult> {
+  return Promise.all([
+      getLocalVersion(rootDir, name),
+      getRemoteVersion(name, options)
+    ])
+    .then(([localVersion, remoteVersion]) => {
+      const newer = lt(localVersion, remoteVersion);
+      const result: CheckResult = {
+        currentVersion: localVersion
+      };
+      if (newer) {
+        result.newVersion = remoteVersion;
+      }
+      return result;
+    });
+}
+
+function encodePackageName(name: string): string {
+  let encoded = encodeURIComponent(name);
+  if (name.startsWith('@')) {
+    encoded = `@${encoded.substr(3)}`;
+  }
+  return encoded;
+}
+
+function getRemoteVersion(name: string, options?: CheckOptions): Promise<string> {
+  const url = `https://registry.npmjs.org/${encodePackageName(name)}`;
+  return httpsGet(url)
+    .then(resp => {
+      const version = options.includeUnstable ?
+        resp['dist-tags'].next :
+        resp['dist-tags'].latest;
+      return version;
+    });
+}
+
+function getLocalVersion(rootDir: string, name: string): Promise<string> {
+  const packagePath = path.resolve(rootDir, 'node_modules', name, 'package.json');
+  return new Promise((resolve, reject) => {
+    try {
+      const packageInfo = require(packagePath);
+      resolve(packageInfo.version);
+    } catch (err) {
+      reject();
+    }
+
+  });
+}
+
+function httpsGet(url: string): Promise<any> {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      const { statusCode } = res;
+      const contentType = res.headers['content-type'];
+
+      let error;
+      if (statusCode !== 200) {
+        error = new Error(`Request Failed. Status Code: ${statusCode}`);
+      } else if (!/^application\/json/.test(contentType)) {
+        error = new Error(
+          `Invalid content-type. Expected application/json but received ${contentType}`);
+      }
+      if (error) {
+        reject(error.message);
+        // consume response data to free up memory
+        res.resume();
+        return;
+      }
+
+      res.setEncoding('utf8');
+      let rawData = '';
+      res.on('data', (chunk) => {
+        rawData += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const parsedData = JSON.parse(rawData);
+          resolve(parsedData);
+        } catch (e) {
+          reject(e.message);
+        }
+      });
+    }).on('error', (e) => {
+      reject(e.message);
+    });
+  });
+}
+
+function convertFrequency(frequency: string): number {
+  const value = parseFloat(frequency.substring(0, frequency.length - 1));
+  const unit = frequency[frequency.length - 1];
+  let factor = 1;
+  switch (unit.toLowerCase()) {
+    case 'h':
+      factor = ONE_HOUR;
+      break;
+    case 'w':
+      factor = ONE_WEEK;
+      break;
+    default:
+      factor = ONE_DAY;
+      break;
+  }
+
+  return value * factor;
+}

packages/@angular/cli/update/update.ts

@@ -0,0 +1,21 @@
+// import * as checker from './check';
+
+// const lastChecked = getLastChecked();
+// const frequency = '1d';
+
+// if (checker.timeToCheck(lastChecked, frequency)) {
+//   const rootDir = '';
+//   const options = {
+//     includeUnstable: false
+//   };
+//   checker.newVersionAvailable(rootDir, '@angular/cli', options)
+//     .then(newVersion => {
+//       if (!!newVersion) {
+//         console.log('NEW VERSION AVAILABLE');
+//       }
+//     });
+// }
+
+// function getLastChecked(): Date {
+//   return new Date();
+// }

packages/@ngtools/json-schema/src/schema-class-factory.ts

@@ -130,7 +130,6 @@ class SchemaClassBase<T> implements SchemaClass<T> {
   /** Set a value from a JSON path. */
   $$set(path: string, value: any): void {
     const node = _getSchemaNodeForPath(this.$$schema(), path);
-
     if (node) {
       node.set(value);
     } else {

tests/e2e/tests/generate/version-check-not-up-to-date.ts

@@ -0,0 +1,18 @@
+import { ng } from '../../utils/process';
+import { updateJsonFile } from '../../utils/project';
+import { oneLine } from 'common-tags';
+
+export default function () {
+  return updateJsonFile('node_modules/@angular/cli/package.json', (json) => {
+      json.version = '1.0.0';
+    })
+    .then(() => ng('generate', 'component', 'basic'))
+    .then(({ stdout }) => {
+      if (!stdout.match(/is out of date/)) {
+        throw new Error(oneLine`
+          Expected to match "is out of date"
+          in ${stdout}.
+        `);
+      }
+    });
+}

tests/e2e/tests/generate/version-check-up-to-date.ts

@@ -0,0 +1,14 @@
+import { ng } from '../../utils/process';
+import { oneLine } from 'common-tags';
+
+export default function () {
+  return ng('generate', 'component', 'basic')
+    .then(({ stdout }) => {
+      if (stdout.match(/is out of date/)) {
+        throw new Error(oneLine`
+          Expected to not match "is out of date"
+          in ${stdout}.
+        `);
+      }
+    });
+}

tests/e2e/utils/process.ts

@@ -15,7 +15,7 @@ let _processes: child_process.ChildProcess[] = [];
 
 type ProcessOutput = {
   stdout: string;
-  stdout: string;
+  stderr: string;
 };
 
 
@@ -77,7 +77,7 @@ function _exec(options: ExecOptions, cmd: string, args: string[]): Promise<Proce
       _processes = _processes.filter(p => p !== childProcess);
 
       if (!error) {
-        resolve({ stdout });
+        resolve({ stdout, stderr });
       } else {
         err.message += `${error}...\n\nSTDOUT:\n${stdout}\n`;
         reject(err);