feat(publisher): adds dryRun and resumeDryRun to the API to allow pos…

…t-make publishes

Fixes #230

src/api/make.js

@@ -146,14 +146,21 @@ export default async (providedOptions = {}) => {
       // eslint-disable-next-line no-loop-func
       await asyncOra(`Making for target: ${target.cyan} - On platform: ${platform.cyan} - For arch: ${targetArch.cyan}`, async () => {
         try {
-          outputs.push(await maker({
+          const output = await maker({
             dir: packageDir,
             appName,
             targetPlatform: platform,
             targetArch,
             forgeConfig,
             packageJSON,
-          }));
+          });
+
+          output.platform = platform;
+          output.arch = targetArch;
+          output.packageJSON = packageJSON;
+          output.forgeConfig = forgeConfig;
+
+          outputs.push(output);
         } catch (err) {
           if (err) {
             throw {

src/api/publish.js

@@ -1,14 +1,19 @@
 import 'colors';
+import debug from 'debug';
+import fs from 'fs-extra';
 import path from 'path';
 
 import asyncOra from '../util/ora-handler';
 import getForgeConfig from '../util/forge-config';
 import readPackageJSON from '../util/read-package-json';
 import requireSearch from '../util/require-search';
 import resolveDir from '../util/resolve-dir';
+import PublishState from '../util/publish-state';
 
 import make from './make';
 
+const d = debug('electron-forge:publish');
+
 /**
  * @typedef {Object} PublishOptions
  * @property {string} [dir=process.cwd()] The path to the app to be published
@@ -17,6 +22,10 @@ import make from './make';
  * @property {string} [tag=packageJSON.version] The string to tag this release with
  * @property {Array<string>} [publishTargets=[github]] The publish targets
  * @property {MakeOptions} [makeOptions] Options object to passed through to make()
+ * @property {string} [outDir=`${dir}/out`] The path to the directory containing generated distributables
+ * @property {boolean} [dryRun=false] Whether or not to generate dry run meta data and not actually publish
+ * @property {boolean} [dryRunResume=false] Whether or not to attempt to resume a previously saved dryRun and publish
+ * @property {Object} [makeResults=null] Provide results from make so that the publish step doesn't run make itself
  */
 
 /**
@@ -25,21 +34,84 @@ import make from './make';
  * @param {PublishOptions} providedOptions - Options for the Publish method
  * @return {Promise} Will resolve when the publish process is complete
  */
-export default async (providedOptions = {}) => {
+const publish = async (providedOptions = {}) => {
   // eslint-disable-next-line prefer-const, no-unused-vars
-  let { dir, interactive, authToken, tag, publishTargets, makeOptions } = Object.assign({
+  let { dir, interactive, authToken, tag, publishTargets, makeOptions, dryRun, dryRunResume, makeResults } = Object.assign({
     dir: process.cwd(),
     interactive: false,
     tag: null,
     makeOptions: {},
     publishTargets: null,
+    dryRun: false,
+    dryRunResume: false,
+    makeResults: null,
   }, providedOptions);
   asyncOra.interactive = interactive;
 
-  const makeResults = await make(Object.assign({
-    dir,
-    interactive,
-  }, makeOptions));
+  const outDir = providedOptions.outDir || path.resolve(dir, 'out');
+  const dryRunDir = path.resolve(outDir, 'publish-dry-run');
+
+  if (dryRun && dryRunResume) {
+    throw 'Can\'t dry run and resume a dry run at the same time';
+  }
+  if (dryRunResume && makeResults) {
+    throw 'Can\'t resume a dry run and use the provided makeResults at the same time';
+  }
+
+  let packageJSON = await readPackageJSON(dir);
+
+  let forgeConfig = await getForgeConfig(dir);
+
+  if (dryRunResume) {
+    d('attempting to resume from dry run');
+    const publishes = await PublishState.loadFromDirectory(dryRunDir);
+    for (const states of publishes) {
+      d('publishing for given state set');
+      await publish({
+        dir,
+        interactive,
+        authToken,
+        tag,
+        target,
+        makeOptions,
+        dryRun,
+        dryRunResume: false,
+        makeResults: states.map(({ state }) => state),
+      });
+    }
+    return;
+  } else if (!makeResults) {
+    d('triggering make');
+    makeResults = await make(Object.assign({
+      dir,
+      interactive,
+    }, makeOptions));
+  } else {
+    // Restore values from dry run
+    d('restoring publish settings from dry run');
+
+    for (const makeResult of makeResults) {
+      packageJSON = makeResult.packageJSON;
+      forgeConfig = makeResult.forgeConfig;
+      makeOptions.platform = makeResult.platform;
+      makeOptions.arch = makeResult.arch;
+
+      for (const makePath of makeResult.paths) {
+        if (!await fs.exists(makePath)) {
+          throw `Attempted to resume a dry run but an artifact (${makePath}) could not be found`;
+        }
+      }
+    }
+
+    makeResults = makeResults.map(makeResult => makeResult.paths);
+  }
+
+  if (dryRun) {
+    d('saving results of make in dry run state');
+    await fs.remove(dryRunDir);
+    await PublishState.saveToDirectory(dryRunDir, makeResults);
+    return;
+  }
 
   dir = await resolveDir(dir);
   if (!dir) {
@@ -51,10 +123,6 @@ export default async (providedOptions = {}) => {
     return accum;
   }, []);
 
-  const packageJSON = await readPackageJSON(dir);
-
-  const forgeConfig = await getForgeConfig(dir);
-
   if (publishTargets === null) {
     publishTargets = forgeConfig.publish_targets[makeOptions.platform || process.platform];
   }
@@ -77,3 +145,5 @@ export default async (providedOptions = {}) => {
     await publisher(artifacts, packageJSON, forgeConfig, authToken, tag, makeOptions.platform || process.platform, makeOptions.arch || process.arch);
   }
 };
+
+export default publish;

src/electron-forge-publish.js

@@ -14,6 +14,8 @@ import { getMakeOptions } from './electron-forge-make';
     .option('--auth-token', 'Authorization token for your publisher target (if required)')
     .option('--tag', 'The tag to publish to on GitHub')
     .option('--target [target[,target...]]', 'The comma-separated deployment targets, defaults to "github"')
+    .option('--dry-run', 'Triggers a publish dry run which saves state and doesn\'t upload anything')
+    .option('--from-dry-run', 'Attempts to publish artifacts from the last saved dry run')
     .allowUnknownOption(true)
     .action((cwd) => {
       if (!cwd) return;
@@ -30,6 +32,8 @@ import { getMakeOptions } from './electron-forge-make';
     interactive: true,
     authToken: program.authToken,
     tag: program.tag,
+    dryRun: program.dryRun,
+    dryRunResume: program.fromDryRun,
   };
   if (program.target) publishOpts.publishTargets = program.target.split(',');
 

src/publishers/github.js

@@ -12,7 +12,7 @@ export default async (artifacts, packageJSON, forgeConfig, authToken, tag) => {
   const github = new GitHub(authToken, true);
 
   let release;
-  await asyncOra('Searching for target Release', async () => {
+  await asyncOra('Searching for target release', async () => {
     try {
       release = (await github.getGitHub().repos.getReleases({
         owner: forgeConfig.github_repository.owner,

src/util/publish-state.js

@@ -0,0 +1,76 @@
+import crypto from 'crypto';
+import fs from 'fs-extra';
+import path from 'path';
+
+const EXTENSION = '.forge.publish';
+
+export default class PublishState {
+  static async loadFromDirectory(directory) {
+    if (!await fs.exists(directory)) {
+      throw new Error(`Attempted to load publish state from a missing directory: ${directory}`);
+    }
+
+    const publishes = [];
+    for (const dirName of await fs.readdir(directory)) {
+      const subDir = path.resolve(directory, dirName);
+      const states = [];
+      if ((await fs.stat(subDir)).isDirectory()) {
+        const filePaths = (await fs.readdir(subDir))
+          .filter(fileName => fileName.endsWith(EXTENSION))
+          .map(fileName => path.resolve(subDir, fileName));
+
+        for (const filePath of filePaths) {
+          const state = new PublishState(filePath);
+          await state.load();
+          states.push(state);
+        }
+      }
+      publishes.push(states);
+    }
+    return publishes;
+  }
+
+  static async saveToDirectory(directory, artifacts) {
+    const id = crypto.createHash('md5').update(JSON.stringify(artifacts)).digest('hex');
+    for (const artifact of artifacts) {
+      const state = new PublishState(path.resolve(directory, id, 'null'), '', false);
+      state.setState({
+        paths: Array.from(artifact),
+        platform: artifact.platform,
+        arch: artifact.arch,
+        packageJSON: artifact.packageJSON,
+        forgeConfig: artifact.forgeConfig,
+      });
+      await state.saveToDisk();
+    }
+  }
+
+  constructor(filePath, hasHash = true) {
+    this.dir = path.dirname(filePath);
+    this.path = filePath;
+    this.hasHash = hasHash;
+  }
+
+  generateHash() {
+    const content = JSON.stringify(this.state || {});
+    return crypto.createHash('md5').update(content).digest('hex');
+  }
+
+  setState(state) {
+    this.state = state;
+  }
+
+  async load() {
+    this.state = await fs.readJson(this.path);
+  }
+
+  async saveToDisk() {
+    if (!this.hasHash) {
+      this.path = path.resolve(this.dir, `${this.generateHash()}${EXTENSION}`);
+      this.hasHash = true;
+    }
+
+    await fs.mkdirs(path.dirname(this.path));
+    await fs.writeJson(this.path, this.state);
+  }
+}