Update to electron-forge 6 & simplify build pipeline/project structure

.eslintrc.js

@@ -60,9 +60,6 @@ module.exports = {
       rules: Object.assign({}, require('eslint-plugin-node').configs.recommended.rules, {
         // add your custom rules and overrides for node files here
         'ember/avoid-leaking-state-in-ember-objects': 'off',
-        'node/no-unpublished-require': ['error', {
-          'allowModules': ['ember-cli']
-        }]
       })
     }
   ]

blueprints/ember-electron/index.js

@@ -11,8 +11,8 @@ const path = require('path');
 const { all, denodeify } = require('rsvp');
 
 const Blueprint = require('ember-cli/lib/models/blueprint');
-const efImport = require('electron-forge/dist/api/import').default;
-const { setupForgeEnv, shouldUseYarn } = require('../../lib/utils/yarn-or-npm');
+const { api } = require('@electron-forge/core');
+const { setupForgeEnv } = require('../../lib/utils/yarn-or-npm');
 
 const Logger = require('../../lib/utils/logger');
 
@@ -59,28 +59,28 @@ module.exports = class EmberElectronBlueprint extends Blueprint {
       });
   }
 
-  _installElectronTooling(logger) {
+  async _installElectronTooling(logger) {
     // n.b. addPackageToProject does not let us save prod deps, so we task
     let npmInstall = this.taskFor('npm-install');
     setupForgeEnv(this.project.root);
 
     logger.startProgress('Installing electron build tools');
 
-    return efImport({
-        updateScripts: false,
-        outDir: 'electron-out',
-      })
-      .then(() => npmInstall.run({
-        'save-dev': true,
-        verbose: false,
-        packages: ['devtron@^1.4.0'],
-      }))
-      .then(() => npmInstall.run({
-        save: true,
-        verbose: false,
-        packages: ['electron-protocol-serve@^1.3.0'],
-      }))
-      .then(() => logger.message('Installed electron build tools'));
+    await api.import({
+      shouldUpdateScript: () => false,
+      outDir: 'electron-out',
+    });
+    await npmInstall.run({
+      'save-dev': true,
+      verbose: false,
+      packages: ['devtron@^1.4.0'],
+    });
+    await npmInstall.run({
+      save: true,
+      verbose: false,
+      packages: ['electron-protocol-serve@^1.3.0'],
+    });
+    logger.message('Installed electron build tools');
   }
 
   _createResourcesDirectories(logger) {
@@ -109,7 +109,6 @@ module.exports = class EmberElectronBlueprint extends Blueprint {
 
     let packageJsonPath = path.join(this.project.root, 'package.json');
     let forgeConfigPath = './ember-electron/electron-forge-config.js';
-    let isUsingYarn = shouldUseYarn(this.project.root);
 
     // If we had a forge config before running forge import, then it may be
     // customized by the user, so let's not mess with it.
@@ -129,11 +128,6 @@ module.exports = class EmberElectronBlueprint extends Blueprint {
           return;
         }
 
-        // required to force the package manager to use yarn when the project uses yarn
-        if (isUsingYarn) {
-          forgeConfig.electronPackagerConfig.packageManager = 'yarn';
-        }
-
         forgeConfig = JSON.stringify(forgeConfig, null, 2);
 
         packageJson.config.forge = forgeConfigPath;

lib/commands/electron.js

@@ -7,7 +7,7 @@ const Command = require('ember-cli/lib/models/command');
 const Builder = require('../models/builder');
 const Watcher = require('ember-cli/lib/models/watcher');
 const Logger = require('../utils/logger');
-const efStart = require('electron-forge/dist/api/start').default;
+const { api } = require('@electron-forge/core');
 
 const { Promise } = RSVP;
 
@@ -69,7 +69,7 @@ module.exports = Command.extend({
     return buildWatcher;
   },
 
-  _startElectron({ outputPath, verbose }, logger = new Logger(this)) {
+  async _startElectron({ outputPath, verbose }, logger = new Logger(this)) {
     const argv = this._getArgv();
 
     let electronArgs = [];
@@ -83,37 +83,38 @@ module.exports = Command.extend({
 
     outputPath = path.resolve(outputPath);
 
-    return efStart({ appPath: outputPath, dir: outputPath, args: electronArgs })
-      .then((handle) => new Promise((resolve/* , reject */) => {
-        handle.on('close', (code, signal) => {
-          if (verbose) {
-            logger.section([
-              'Electron closed',
-              `  - with code: ${code}`,
-              `  - with signal: ${signal}`,
-            ]);
-          }
-        });
-
-        handle.on('disconnect', () => {
-          if (verbose) {
-            logger.message('Electron disconnected.');
-          }
-        });
-
-        handle.on('error', (err) => {
-          logger.error(err);
-        });
-
-        handle.on('exit', (/* code, signal */) => {
-          logger.message('Electron exited.');
-          resolve();
-        });
-
-        handle.on('message', (message) => {
-          logger.message(message);
-        });
-      }));
+    let handle = await api.start({ appPath: outputPath, dir: outputPath, args: electronArgs });
+
+    handle.on('close', (code, signal) => {
+      if (verbose) {
+        logger.section([
+          'Electron closed',
+          `  - with code: ${code}`,
+          `  - with signal: ${signal}`,
+        ]);
+      }
+    });
+
+    handle.on('disconnect', () => {
+      if (verbose) {
+        logger.message('Electron disconnected.');
+      }
+    });
+
+    handle.on('error', (err) => {
+      logger.error(err);
+    });
+
+    handle.on('message', (message) => {
+      logger.message(message);
+    });
+
+    await new Promise((resolve) => {
+      handle.on('exit', () => {
+        logger.message('Electron exited.');
+        resolve();
+      });
+    });
   },
 
   // For test instrumentation

lib/tasks/assemble.js

@@ -65,9 +65,9 @@ class AssembleTask extends Task {
 
   pruneCommand() {
     if (shouldUseYarn(this.project.root)) {
-      return 'yarn install --production --no-bin-links';
+      return 'yarn';
     } else {
-      return 'npm install --production --no-bin-links';
+      return 'npm install';
     }
   }
 

lib/tasks/make.js

@@ -1,10 +1,9 @@
 'use strict';
 
 const chalk = require('chalk');
-const { resolve } = require('rsvp');
 const Task = require('ember-cli/lib/models/task');
 const PackageTask = require('./package');
-const forgeMake = require('electron-forge/dist/api/make').default;
+const { api } = require('@electron-forge/core');
 
 //
 // A task that runs electron-forge make to make installers. The skipPackage
@@ -15,43 +14,38 @@ const forgeMake = require('electron-forge/dist/api/make').default;
 // rather than re-assembling/rebuilding.
 //
 class MakeTask extends Task {
-  run(options) {
+  async run(options) {
     let { ui, analytics, project } = this;
     let { skipPackage, outputPath, platform, arch, targets } = options;
 
-    let packagePromise;
-    if (skipPackage) {
-      // Nothing to do -- we assume the packaged app is present and let forge
-      // do the rest
-      packagePromise = resolve();
-    } else {
+    // If skipPackage is set, we assume the packaged app is present and let
+    // forge do the rest
+    if (!skipPackage) {
       let packageTask = new PackageTask({ ui, analytics, project });
-      packagePromise = packageTask.run(options);
+      await packageTask.run(options);
     }
 
-    return packagePromise.then(() => {
-      ui.writeLine(chalk.green('Making Electron project.'));
-
-      let overrideTargets;
-      if (typeof targets === 'string') {
-        overrideTargets = targets.split(',');
-      }
-
-      let options = {
-        dir: project.root,
-        outDir: outputPath,
-        skipPackage: true,
-        overrideTargets,
-      };
-      if (platform) {
-        options.platform = platform;
-      }
-      if (arch) {
-        options.arch = arch;
-      }
-
-      return forgeMake(options);
-    });
+    ui.writeLine(chalk.green('Making Electron project.'));
+
+    let overrideTargets;
+    if (typeof targets === 'string') {
+      overrideTargets = targets.split(',');
+    }
+
+    let makeOptions = {
+      dir: project.root,
+      outDir: outputPath,
+      skipPackage: true,
+      overrideTargets,
+    };
+    if (platform) {
+      makeOptions.platform = platform;
+    }
+    if (arch) {
+      makeOptions.arch = arch;
+    }
+
+    return await api.make(makeOptions);
   }
 }
 

lib/tasks/package.js

@@ -2,12 +2,11 @@
 
 const chalk = require('chalk');
 const childProcess = require('child_process');
-const { resolve } = require('rsvp');
 const quickTemp = require('quick-temp');
 const Task = require('ember-cli/lib/models/task');
 const AssembleTask = require('./assemble');
 const { setupForgeEnv } = require('../utils/yarn-or-npm');
-const forgePackage = require('electron-forge/dist/api/package').default;
+const { api } = require('@electron-forge/core');
 
 //
 // A task that runs electron-forge pacakge to package the app. The
@@ -16,46 +15,47 @@ const forgePackage = require('electron-forge/dist/api/package').default;
 // app rather than re-assembling/rebuilding.
 //
 class PackageTask extends Task {
-  run(options) {
+  async run(options) {
     let { ui, analytics, project } = this;
     let { projectPath, outputPath, platform, arch } = options;
 
-    let assemblePromise;
-    if (projectPath) {
-      // We have a path to an assembled project, so just pass it to forge
-      assemblePromise = resolve();
-    } else {
-      // Assemble the project and pass to forge
-      projectPath = quickTemp.makeOrRemake(this, '-tmpPath');
-
-      if (process.platform !== 'win32') {
-        childProcess.execSync(`chmod a+x ${projectPath}`);
+    let cleanupFn;
+    try {
+      // If projectPath is set then we already have an assembled project
+      if (!projectPath) {
+        // Assemble the project and pass to forge
+        projectPath = quickTemp.makeOrRemake(this, '-tmpPath');
+        cleanupFn = () => quickTemp.remove(this, '-tmpPath');
+
+        if (process.platform !== 'win32') {
+          childProcess.execSync(`chmod a+x ${projectPath}`);
+        }
+
+        options.outputPath = projectPath;
+        let assembleTask = new AssembleTask({ ui, analytics, project });
+        await assembleTask.run(options);
       }
 
-      options.outputPath = projectPath;
-      let assembleTask = new AssembleTask({ ui, analytics, project });
-      assemblePromise = assembleTask.run(options);
-    }
-
-    return assemblePromise.then(() => {
       setupForgeEnv(this.project.root);
       ui.writeLine(chalk.green('Packaging Electron project.'));
 
-      let options = {
+      let packageOptions = {
         dir: projectPath,
         outDir: outputPath,
       };
       if (platform) {
-        options.platform = platform;
+        packageOptions.platform = platform;
       }
       if (arch) {
-        options.arch = arch;
+        packageOptions.arch = arch;
       }
 
-      return forgePackage(options);
-    }).finally(() => {
-      quickTemp.remove(this, '-tmpPath');
-    });
+      return await api.package(packageOptions);
+    } finally {
+      if (cleanupFn) {
+        cleanupFn();
+      }
+    }
   }
 }