fastboot-config.js

/* eslint-env node */
'use strict';

const fs     = require('fs');
const fmt    = require('util').format;
const merge  = require('ember-cli-lodash-subset').merge;
const md5Hex = require('md5-hex');
const path   = require('path');
const Plugin = require('broccoli-plugin');
const child_process = require('child_process');
const rimraf = require('rimraf');

const stringify = require('json-stable-stringify');

const LATEST_SCHEMA_VERSION = 3;

module.exports = class FastBootConfig extends Plugin {
  constructor(inputNode, options) {
    super([inputNode], {
      annotation: 'Generate: FastBoot package.json',
      persistentOutput: true
    });

    this.project = options.project;

    this.name = options.name;
    this.ui = options.ui;
    this.fastbootAppConfig = options.fastbootAppConfig;
    this.outputPaths = options.outputPaths;
    this.appName = options.appConfig.modulePrefix;
    const appConfigModule = `${this.appName}`;
    this.fastbootConfig = {};
    this.fastbootConfig[appConfigModule] = options.appConfig;
    this._fileToChecksumMap = {};

    if (this.fastbootAppConfig && this.fastbootAppConfig.htmlFile) {
      this.htmlFile = this.fastbootAppConfig.htmlFile;
    } else {
      this.htmlFile = 'index.html';
    }

  }


  /**
   * The main hook called by Broccoli Plugin. Used to build or
   * rebuild the tree. In this case, we generate the configuration
   * and write it to `package.json`.
   */
  build() {
    return Promise.all([
      this.buildConfig(),
      this.buildDependencies(),
      this.buildManifest(),
      this.buildHostWhitelist()
    ]).then(() => {
      let packageOutputPath = path.join(this.outputPath, 'package.json');
      this.writeFileIfContentChanged(packageOutputPath, this.toJSONString());
    });
  }

  writeFileIfContentChanged(outputPath, content) {
    let previous = this._fileToChecksumMap[outputPath];
    let next = md5Hex(content);

    if (previous !== next) {
      fs.writeFileSync(outputPath, content);
      this._fileToChecksumMap[outputPath] = next; // update map
    }
  }

  buildConfig() {
    // we only walk the host app's addons to grab the config since ideally
    // addons that have dependency on other addons would never define
    // this advance hook.
    this.project.addons.forEach((addon) => {
      if (addon.fastbootConfigTree) {
        let configFromAddon = addon.fastbootConfigTree();

        if (!configFromAddon) {
          throw new Error('`fastbootConfigTree` requires a map to be returned');
        }

        merge(this.fastbootConfig, configFromAddon);
      }
    });
  }

  buildDependencies() {
    let dependencies = {};
    let moduleWhitelist = [];
    let ui = this.ui;

    eachAddonPackage(this.project, pkg => {
      let deps = getFastBootDependencies(pkg, ui);

      if (deps) {
        deps.forEach(dep => {
          let version = getDependencyVersion(pkg, dep);

          if (dep in dependencies) {
            version = dependencies[dep];
            ui.writeLine(fmt("Duplicate FastBoot dependency %s. Versions may mismatch. Using range %s.", dep, version), ui.WARNING);
            return;
          }

          moduleWhitelist.push(dep);

          if (version) {
            dependencies[dep] = version;
          }
        });
      }
    });

    let pkg = this.project.pkg;
    let projectDeps = pkg.fastbootDependencies;

    if (projectDeps) {
      projectDeps.forEach(dep => {
        moduleWhitelist.push(dep);

        let version = pkg.dependencies && pkg.dependencies[dep];
        if (version) {
          dependencies[dep] = version;
        }
      });
    }

    return this.updateDependencies(dependencies, moduleWhitelist);
  }

  updateDependencies(dependencies, moduleWhitelist) {
    if (this.dependenciesChanged(dependencies)) {
      return this.getPackageLock(dependencies).then(() => {
        this.dependencies = dependencies;
        this.moduleWhitelist = moduleWhitelist;
      });
    } else {
      this.dependencies = dependencies;
      this.moduleWhitelist = moduleWhitelist;
    }
  }

  dependenciesChanged(dependencies) {
    return stringify(dependencies) !== stringify(this.dependencies);
  }

  getPackageLock(dependencies) {
    let packagePath = path.join(this.project.root, 'package.json');
    let lockfilePath = path.join(this.project.root, 'package-lock.json');
    let tmpFolder = path.join(this.outputPath, 'package-lock-generator');

    fs.mkdirSync(tmpFolder);
    fs.symlinkSync(packagePath, path.join(tmpFolder, 'package.json'));
    fs.symlinkSync(lockfilePath, path.join(tmpFolder, 'package-lock.json'));

    const firstInstall = new Promise((resolve, reject) => {
      this.ui.writeLine('FastBoot: Building node module cache.');
      child_process.exec('npm install --cache=tmp', { cwd: tmpFolder }, (error) => {
        if (error) {
          reject(error);
        } else {
          resolve();
        }
      });
    })

    return firstInstall
      .then(() => {
        this.ui.writeLine('FastBoot: Generating lockfile.');

        fs.unlinkSync(path.join(tmpFolder, 'package.json'));
        fs.unlinkSync(path.join(tmpFolder, 'package-lock.json'));

        fs.writeFileSync(path.join(tmpFolder, 'package.json'), stringify({ dependencies }));

        const secondInstall = new Promise((resolve, reject) => {
          child_process.exec('npm install --cache=tmp --offline', { cwd: tmpFolder }, (error) => {
            if (error) {
              reject(error);
            } else {
              resolve();
            }
          });
        });

        return secondInstall;
      })
      .then(() => {
        this.ui.writeLine('FastBoot: Removing node module cache.');

        fs.renameSync(
          path.join(tmpFolder, 'package-lock.json'),
          path.join(this.outputPath, 'package-lock.json')
        );

        fs.renameSync(
          path.join(tmpFolder, 'node_modules'),
          path.join(this.outputPath, 'node_modules')
        );

        const removeTmpFolder = new Promise((resolve, reject) => {
          rimraf(tmpFolder, (error) => {
            if (error) {
              reject(error);
            } else {
              resolve();
            }
          });
        });

        return removeTmpFolder;
      });
  }

  updateFastBootManifest(manifest) {
    this.project.addons.forEach(addon =>{
      if (addon.updateFastBootManifest) {
        manifest = addon.updateFastBootManifest(manifest);

        if (!manifest) {
          throw new Error(`${addon.name} did not return the updated manifest from updateFastBootManifest hook.`);
        }
      }
    });

    return manifest;
  }

  buildManifest() {
    function stripLeadingSlash(filePath) {
      return filePath.replace(/^\//, '');
    }

    let appFilePath = stripLeadingSlash(this.outputPaths.app.js);
    let appFastbootFilePath = appFilePath.replace(/\.js$/, '') + '-fastboot.js';
    let vendorFilePath = stripLeadingSlash(this.outputPaths.vendor.js);

    let manifest = {
      appFiles: [appFilePath, appFastbootFilePath],
      vendorFiles: [vendorFilePath],
      htmlFile: this.htmlFile
    };

    this.manifest = this.updateFastBootManifest(manifest);
  }

  buildHostWhitelist() {
    if (this.fastbootAppConfig) {
      this.hostWhitelist = this.fastbootAppConfig.hostWhitelist;
    }
  }

  toJSONString() {
    return stringify({
      dependencies: this.dependencies,
      fastboot: {
        moduleWhitelist: this.moduleWhitelist,
        schemaVersion: LATEST_SCHEMA_VERSION,
        manifest: this.manifest,
        hostWhitelist: this.normalizeHostWhitelist(),
        config: this.fastbootConfig,
        appName: this.appName,
      }
    }, null, 2);
  }

  normalizeHostWhitelist() {
    if (!this.hostWhitelist) {
      return;
    }

    return this.hostWhitelist.map(function(entry) {
      // Is a regex
      if (entry.source) {
        return '/' + entry.source + '/';
      } else {
        return entry;
      }
    });
  }
}

function eachAddonPackage(project, cb) {
  project.addons.map(addon => cb(addon.pkg));
}

function getFastBootDependencies(pkg, ui) {
  let addon = pkg['ember-addon'];
  if (!addon) {
    return addon;
  }

  let deps = addon.fastBootDependencies;
  if (deps) {
    ui.writeDeprecateLine('ember-addon.fastBootDependencies has been replaced with ember-addon.fastbootDependencies [addon: ' + pkg.name + ']');
    return deps;
  }

  return addon.fastbootDependencies;
}

function getDependencyVersion(pkg, dep) {
  if (!pkg.dependencies) {
    throw new Error(fmt("Could not find FastBoot dependency '%s' in %s/package.json dependencies.", dep, pkg.name));
  }

  return pkg.dependencies[dep];
}