@electron-forge/publisher-electron-release-server 6.0.0-beta.7 → 6.0.0-beta.70

package/src/PublisherERS.ts

@@ -1,12 +1,12 @@
-import PublisherBase, { PublisherOptions } from '@electron-forge/publisher-base';
-import { asyncOra } from '@electron-forge/async-ora';
-import { ForgePlatform, ForgeArch } from '@electron-forge/shared-types';
+import path from 'path';
 
+import { asyncOra } from '@electron-forge/async-ora';
+import { PublisherBase, PublisherOptions } from '@electron-forge/publisher-base';
+import { ForgeArch, ForgePlatform } from '@electron-forge/shared-types';
 import debug from 'debug';
-import fetch from 'node-fetch';
 import FormData from 'form-data';
 import fs from 'fs-extra';
-import path from 'path';
+import fetch, { RequestInfo, RequestInit, Response } from 'node-fetch';
 
 import { PublisherERSConfig } from './Config';
 
@@ -14,10 +14,20 @@ const d = debug('electron-forge:publish:ers');
 
 interface ERSVersion {
   name: string;
-  assets: { name: string; }[];
+  assets: { name: string }[];
+  flavor?: string;
 }
 
-export const ersPlatform = (platform: ForgePlatform, arch: ForgeArch) => {
+const fetchAndCheckStatus = async (url: RequestInfo, init?: RequestInit): Promise<Response> => {
+  const result = await fetch(url, init);
+  if (result.ok) {
+    // res.status >= 200 && res.status < 300
+    return result;
+  }
+  throw new Error(`ERS publish failed with status code: ${result.status} (${result.url})`);
+};
+
+export const ersPlatform = (platform: ForgePlatform, arch: ForgeArch): string => {
   switch (platform) {
     case 'darwin':
       return 'osx_64';
@@ -33,39 +43,45 @@ export const ersPlatform = (platform: ForgePlatform, arch: ForgeArch) => {
 export default class PublisherERS extends PublisherBase<PublisherERSConfig> {
   name = 'electron-release-server';
 
-  async publish({ makeResults }: PublisherOptions) {
+  async publish({ makeResults }: PublisherOptions): Promise<void> {
     const { config } = this;
 
     if (!(config.baseUrl && config.username && config.password)) {
-      throw 'In order to publish to ERS you must set the "electronReleaseServer.baseUrl", "electronReleaseServer.username" and "electronReleaseServer.password" properties in your forge config. See the docs for more info'; // eslint-disable-line
+      throw new Error(
+        'In order to publish to ERS you must set the "electronReleaseServer.baseUrl", "electronReleaseServer.username" and "electronReleaseServer.password" properties in your Forge config. See the docs for more info'
+      );
     }
 
     d('attempting to authenticate to ERS');
 
     const api = (apiPath: string) => `${config.baseUrl}/${apiPath}`;
 
-    const { token } = await (await fetch(api('api/auth/login'), {
-      method: 'POST',
-      body: JSON.stringify({
-        username: config.username,
-        password: config.password,
-      }),
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    })).json();
-
-    const authFetch = (apiPath: string, options?: any) =>
-      fetch(api(apiPath), Object.assign({}, options || {}, {
-        headers: Object.assign({}, (options || {}).headers, { Authorization: `Bearer ${token}` }),
-      }));
+    const { token } = await (
+      await fetchAndCheckStatus(api('api/auth/login'), {
+        method: 'POST',
+        body: JSON.stringify({
+          username: config.username,
+          password: config.password,
+        }),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      })
+    ).json();
+
+    const authFetch = (apiPath: string, options?: RequestInit) =>
+      fetchAndCheckStatus(api(apiPath), { ...(options || {}), headers: { ...(options || {}).headers, Authorization: `Bearer ${token}` } });
 
     const versions: ERSVersion[] = await (await authFetch('api/version')).json();
+    const flavor = config.flavor || 'default';
 
     for (const makeResult of makeResults) {
-      const { artifacts, packageJSON } = makeResult;
+      const { packageJSON } = makeResult;
+      const artifacts = makeResult.artifacts.filter((artifactPath) => path.basename(artifactPath).toLowerCase() !== 'releases');
 
-      const existingVersion = versions.find(version => version.name === packageJSON.version);
+      const existingVersion = versions.find((version) => {
+        return version.name === packageJSON.version && (!version.flavor || version.flavor === flavor);
+      });
 
       let channel = 'stable';
       if (config.channel) {
@@ -83,6 +99,7 @@ export default class PublisherERS extends PublisherBase<PublisherERSConfig> {
             channel: {
               name: channel,
             },
+            flavor: config.flavor,
             name: packageJSON.version,
             notes: '',
           }),
@@ -100,12 +117,10 @@ export default class PublisherERS extends PublisherBase<PublisherERSConfig> {
           uploadSpinner.text = getText();
         };
 
-        await Promise.all(artifacts.map(artifactPath =>
-          new Promise(async (resolve, reject) => {
+        await Promise.all(
+          artifacts.map(async (artifactPath) => {
             if (existingVersion) {
-              const existingAsset = existingVersion.assets.find(
-                asset => asset.name === path.basename(artifactPath),
-              );
+              const existingAsset = existingVersion.assets.find((asset) => asset.name === path.basename(artifactPath));
 
               if (existingAsset) {
                 d('asset at path:', artifactPath, 'already exists on server');
@@ -114,28 +129,31 @@ export default class PublisherERS extends PublisherBase<PublisherERSConfig> {
                 return;
               }
             }
-            try {
-              d('attempting to upload asset:', artifactPath);
-              const artifactForm = new FormData();
-              artifactForm.append('token', token);
-              artifactForm.append('version', packageJSON.version);
-              artifactForm.append('platform', ersPlatform(makeResult.platform, makeResult.arch));
-              artifactForm.append('file', fs.createReadStream(artifactPath));
-              await authFetch('api/asset', {
-                method: 'POST',
-                body: artifactForm,
-                headers: artifactForm.getHeaders(),
-              });
-              d('upload successful for asset:', artifactPath);
-              uploaded += 1;
-              updateSpinner();
-              resolve();
-            } catch (err) {
-              reject(err);
-            }
-          }),
-        ));
+            d('attempting to upload asset:', artifactPath);
+            const artifactForm = new FormData();
+            artifactForm.append('token', token);
+            artifactForm.append('version', packageJSON.version);
+            artifactForm.append('platform', ersPlatform(makeResult.platform, makeResult.arch));
+
+            // see https://github.com/form-data/form-data/issues/426
+            const fileOptions = {
+              knownLength: fs.statSync(artifactPath).size,
+            };
+            artifactForm.append('file', fs.createReadStream(artifactPath), fileOptions);
+
+            await authFetch('api/asset', {
+              method: 'POST',
+              body: artifactForm,
+              headers: artifactForm.getHeaders(),
+            });
+            d('upload successful for asset:', artifactPath);
+            uploaded += 1;
+            updateSpinner();
+          })
+        );
       });
     }
   }
 }
+
+export { PublisherERS, PublisherERSConfig };

package/test/PublisherERS_spec.ts

@@ -0,0 +1,218 @@
+import { ForgeMakeResult, ResolvedForgeConfig } from '@electron-forge/shared-types';
+import { expect } from 'chai';
+import fetchMock from 'fetch-mock';
+import proxyquire from 'proxyquire';
+import { stub } from 'sinon';
+
+describe('PublisherERS', () => {
+  let fetch: typeof fetchMock;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let PublisherERS: any;
+
+  beforeEach(() => {
+    fetch = fetchMock.sandbox();
+    PublisherERS = proxyquire.noCallThru().load('../src/PublisherERS', {
+      'node-fetch': fetch,
+      'fs-extra': { createReadStream: stub().returns(''), statSync: stub().returns({ size: 100 }) },
+    }).default;
+  });
+
+  afterEach(() => {
+    fetch.restore();
+  });
+
+  describe('new version', () => {
+    it('can publish a new version to ERS', async () => {
+      const baseUrl = 'https://example.com';
+      const token = 'FAKE_TOKEN';
+      const flavor = 'lite';
+      const version = '3.0.0';
+
+      // mock login
+      fetch.postOnce('path:/api/auth/login', { body: { token }, status: 200 });
+      // mock fetch all existing versions
+      fetch.getOnce('path:/api/version', { body: [{ name: '2.0.0', assets: [], flavor: 'default' }], status: 200 });
+      // mock creating a new version
+      fetch.postOnce('path:/api/version', { status: 200 });
+      // mock asset upload
+      fetch.post('path:/api/asset', { status: 200 });
+
+      const publisher = new PublisherERS({
+        baseUrl,
+        username: 'test',
+        password: 'test',
+        flavor,
+      });
+
+      const makeResults: ForgeMakeResult[] = [
+        {
+          artifacts: ['/path/to/artifact'],
+          packageJSON: {
+            version,
+          },
+          platform: 'linux',
+          arch: 'x64',
+        },
+      ];
+
+      await publisher.publish({ makeResults, dir: '', forgeConfig: {} as ResolvedForgeConfig });
+
+      const calls = fetch.calls();
+
+      // creates a new version with the correct flavor, name, and channel
+      expect(calls[2][0]).to.equal(`${baseUrl}/api/version`);
+      expect(calls[2][1]?.body).to.equal(`{"channel":{"name":"stable"},"flavor":"${flavor}","name":"${version}","notes":""}`);
+
+      // uploads asset successfully
+      expect(calls[3][0]).to.equal(`${baseUrl}/api/asset`);
+    });
+  });
+
+  describe('existing version', () => {
+    it('can add new assets', async () => {
+      const baseUrl = 'https://example.com';
+      const token = 'FAKE_TOKEN';
+      const channel = 'stable';
+      const flavor = 'lite';
+      const version = '2.0.0';
+
+      // mock login
+      fetch.postOnce('path:/api/auth/login', { body: { token }, status: 200 });
+      // mock fetch all existing versions
+      fetch.getOnce('path:/api/version', { body: [{ name: '2.0.0', assets: [], flavor: 'lite' }], status: 200 });
+      // mock asset upload
+      fetch.post('path:/api/asset', { status: 200 });
+
+      const publisher = new PublisherERS({
+        baseUrl,
+        username: 'test',
+        password: 'test',
+        channel,
+        flavor,
+      });
+
+      const makeResults: ForgeMakeResult[] = [
+        {
+          artifacts: ['/path/to/artifact'],
+          packageJSON: {
+            version,
+          },
+          platform: 'linux',
+          arch: 'x64',
+        },
+      ];
+
+      await publisher.publish({ makeResults, dir: '', forgeConfig: {} as ResolvedForgeConfig });
+
+      const calls = fetch.calls();
+
+      // uploads asset successfully
+      expect(calls[2][0]).to.equal(`${baseUrl}/api/asset`);
+    });
+
+    it('does not replace assets for existing version', async () => {
+      const baseUrl = 'https://example.com';
+      const token = 'FAKE_TOKEN';
+      const channel = 'stable';
+      const version = '2.0.0';
+
+      // mock login
+      fetch.postOnce('path:/api/auth/login', { body: { token }, status: 200 });
+      // mock fetch all existing versions
+      fetch.getOnce('path:/api/version', { body: [{ name: '2.0.0', assets: [{ name: 'existing-artifact' }], flavor: 'default' }], status: 200 });
+
+      const publisher = new PublisherERS({
+        baseUrl,
+        username: 'test',
+        password: 'test',
+        channel,
+      });
+
+      const makeResults: ForgeMakeResult[] = [
+        {
+          artifacts: ['/path/to/existing-artifact'],
+          packageJSON: {
+            version,
+          },
+          platform: 'linux',
+          arch: 'x64',
+        },
+      ];
+
+      await publisher.publish({ makeResults, dir: '', forgeConfig: {} as ResolvedForgeConfig });
+
+      const calls = fetch.calls();
+      expect(calls).to.have.length(2);
+    });
+
+    it('can upload a new flavor for an existing version', async () => {
+      const baseUrl = 'https://example.com';
+      const token = 'FAKE_TOKEN';
+      const version = '2.0.0';
+      const flavor = 'lite';
+
+      // mock login
+      fetch.postOnce('path:/api/auth/login', { body: { token }, status: 200 });
+      // mock fetch all existing versions
+      fetch.getOnce('path:/api/version', { body: [{ name: '2.0.0', assets: [{ name: 'existing-artifact' }], flavor: 'default' }], status: 200 });
+      // mock creating a new version
+      fetch.postOnce('path:/api/version', { status: 200 });
+      // mock asset upload
+      fetch.post('path:/api/asset', { status: 200 });
+
+      const publisher = new PublisherERS({
+        baseUrl,
+        username: 'test',
+        password: 'test',
+        flavor,
+      });
+
+      const makeResults: ForgeMakeResult[] = [
+        {
+          artifacts: ['/path/to/artifact'],
+          packageJSON: {
+            version,
+          },
+          platform: 'linux',
+          arch: 'x64',
+        },
+      ];
+
+      await publisher.publish({ makeResults, dir: '', forgeConfig: {} as ResolvedForgeConfig });
+
+      const calls = fetch.calls();
+
+      // creates a new version with the correct flavor, name, and channel
+      expect(calls[2][0]).to.equal(`${baseUrl}/api/version`);
+      expect(calls[2][1]?.body).to.equal(`{"channel":{"name":"stable"},"flavor":"${flavor}","name":"${version}","notes":""}`);
+
+      // uploads asset successfully
+      expect(calls[3][0]).to.equal(`${baseUrl}/api/asset`);
+    });
+
+    // TODO: implement edge cases
+    it('can read the channel from the package.json version');
+    it('does not upload the RELEASES file');
+  });
+
+  it('fails if username and password are not provided', () => {
+    const publisher = new PublisherERS({});
+
+    expect(publisher.publish({ makeResults: [], dir: '', forgeConfig: {} as ResolvedForgeConfig })).to.eventually.be.rejectedWith(
+      'In order to publish to ERS you must set the "electronReleaseServer.baseUrl", "electronReleaseServer.username" and "electronReleaseServer.password" properties in your Forge config. See the docs for more info'
+    );
+  });
+
+  it('fails if the server returns 4xx', async () => {
+    fetch.mock('begin:http://example.com', { body: {}, status: 400 });
+
+    const publisher = new PublisherERS({
+      baseUrl: 'http://example.com',
+      username: 'test',
+      password: 'test',
+    });
+    return expect(publisher.publish({ makeResults: [], dir: '', forgeConfig: {} as ResolvedForgeConfig })).to.eventually.be.rejectedWith(
+      'ERS publish failed with status code: 400 (http://example.com/api/auth/login)'
+    );
+  });
+});

package/tsconfig.json

@@ -1,23 +1,42 @@
 {
-	"compilerOptions": {
-		"module": "commonjs",
-		"target": "es6",
-		"outDir": "dist",
-		"lib": [
-			"es6",
-			"dom",
-			"es7"
-		],
-		"sourceMap": true,
-		"rootDir": "src",
-		"experimentalDecorators": true,
-		"strict": true,
-		"esModuleInterop": true,
-		"declaration": true
-	},
-	"exclude": [
-		"node_modules",
-		"dist",
-		"test"
-	]
+  "//": "⚠️ AUTOGENERATED ⚠️ This file was automatically generated by tools/gen-tsconfigs.ts, do not edit manually.",
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2019",
+    "outDir": "dist",
+    "lib": [
+      "dom",
+      "es2019"
+    ],
+    "sourceMap": true,
+    "rootDir": "src",
+    "experimentalDecorators": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "composite": true,
+    "declarationMap": true,
+    "typeRoots": [
+      "../../../typings",
+      "../../../node_modules/@types"
+    ]
+  },
+  "exclude": [
+    "node_modules",
+    "dist",
+    "test",
+    "index.ts",
+    "tmpl"
+  ],
+  "references": [
+    {
+      "path": "../../utils/async-ora"
+    },
+    {
+      "path": "../base"
+    },
+    {
+      "path": "../../utils/types"
+    }
+  ]
 }