@electron-forge/publisher-electron-release-server 6.0.1 → 6.0.2

package/LICENSE

@@ -0,0 +1,19 @@
+The MIT License (MIT)
+Copyright (c) 2016 Samuel Attard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@electron-forge/publisher-electron-release-server",
-  "version": "6.0.1",
+  "version": "6.0.2",
   "description": "Electron release server publisher for Electron Forge",
   "repository": "https://github.com/electron/forge",
   "author": "Samuel Attard",
@@ -18,11 +18,15 @@
     "node": ">= 14.17.5"
   },
   "dependencies": {
-    "@electron-forge/publisher-base": "6.0.1",
-    "@electron-forge/shared-types": "6.0.1",
+    "@electron-forge/publisher-base": "^6.0.2",
+    "@electron-forge/shared-types": "^6.0.2",
     "debug": "^4.3.1",
     "form-data": "^4.0.0",
     "fs-extra": "^10.0.0",
     "node-fetch": "^2.6.7"
-  }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "11cf4b58359c9881c05c06e0d62be575a0ed70d1"
 }

package/src/Config.ts

@@ -0,0 +1,34 @@
+export interface PublisherERSConfig {
+  /**
+   * The base URL of your instance of ERS.
+   *
+   * E.g. https://my-update.server.com
+   */
+  baseUrl: string;
+  /**
+   * The username you use to sign in to ERS
+   */
+  username: string;
+  /**
+   * The password you use to sign in to ERS
+   */
+  password: string;
+  /**
+   * The release channel you want to send artifacts to, normally something like
+   * "stable", "beta" or "alpha".
+   *
+   * If left unspecified we will try to infer the channel from your version
+   * field in your package.json.
+   *
+   * Default: stable
+   */
+  channel?: string;
+
+  /**
+   * The "flavor" of the binary that you want to release to.
+   * This is useful if you want to provide multiple versions
+   * of the same application version (e.g. full and lite)
+   * to end users.
+   */
+  flavor?: string;
+}

package/src/PublisherERS.ts

@@ -0,0 +1,153 @@
+import path from 'path';
+
+import { PublisherBase, PublisherOptions } from '@electron-forge/publisher-base';
+import { ForgeArch, ForgePlatform } from '@electron-forge/shared-types';
+import debug from 'debug';
+import FormData from 'form-data';
+import fs from 'fs-extra';
+import fetch, { RequestInfo, RequestInit, Response } from 'node-fetch';
+
+import { PublisherERSConfig } from './Config';
+
+const d = debug('electron-forge:publish:ers');
+
+interface ERSVersion {
+  name: string;
+  assets: { name: string }[];
+  flavor?: string;
+}
+
+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';
+    case 'linux':
+      return arch === 'ia32' ? 'linux_32' : 'linux_64';
+    case 'win32':
+      return arch === 'ia32' ? 'windows_32' : 'windows_64';
+    default:
+      return platform;
+  }
+};
+
+export default class PublisherERS extends PublisherBase<PublisherERSConfig> {
+  name = 'electron-release-server';
+
+  async publish({ makeResults, setStatusLine }: PublisherOptions): Promise<void> {
+    const { config } = this;
+
+    if (!(config.baseUrl && config.username && config.password)) {
+      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 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 { packageJSON } = makeResult;
+      const artifacts = makeResult.artifacts.filter((artifactPath) => path.basename(artifactPath).toLowerCase() !== 'releases');
+
+      const existingVersion = versions.find((version) => {
+        return version.name === packageJSON.version && (!version.flavor || version.flavor === flavor);
+      });
+
+      let channel = 'stable';
+      if (config.channel) {
+        channel = config.channel;
+      } else if (packageJSON.version.includes('beta')) {
+        channel = 'beta';
+      } else if (packageJSON.version.includes('alpha')) {
+        channel = 'alpha';
+      }
+
+      if (!existingVersion) {
+        await authFetch('api/version', {
+          method: 'POST',
+          body: JSON.stringify({
+            channel: {
+              name: channel,
+            },
+            flavor: config.flavor,
+            name: packageJSON.version,
+            notes: '',
+          }),
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        });
+      }
+
+      let uploaded = 0;
+      const updateStatusLine = () => setStatusLine(`Uploading distributable (${uploaded}/${artifacts.length})`);
+      updateStatusLine();
+
+      await Promise.all(
+        artifacts.map(async (artifactPath) => {
+          if (existingVersion) {
+            const existingAsset = existingVersion.assets.find((asset) => asset.name === path.basename(artifactPath));
+
+            if (existingAsset) {
+              d('asset at path:', artifactPath, 'already exists on server');
+              uploaded += 1;
+              updateStatusLine();
+              return;
+            }
+          }
+          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;
+          updateStatusLine();
+        })
+      );
+    }
+  }
+}
+
+export { PublisherERS, PublisherERSConfig };

package/test/PublisherERS_spec.ts

@@ -0,0 +1,223 @@
+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';
+
+import type { PublisherERS as PublisherERSType } from '../src/PublisherERS';
+
+const noop = () => void 0;
+
+describe('PublisherERS', () => {
+  let fetch: typeof fetchMock;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let PublisherERS: typeof PublisherERSType;
+
+  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, setStatusLine: noop });
+
+      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, setStatusLine: noop });
+
+      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, setStatusLine: noop });
+
+      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, setStatusLine: noop });
+
+      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', () => {
+    // @ts-expect-error testing invalid options
+    const publisher = new PublisherERS({});
+
+    expect(publisher.publish({ makeResults: [], dir: '', forgeConfig: {} as ResolvedForgeConfig, setStatusLine: noop })).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, setStatusLine: noop })).to.eventually.be.rejectedWith(
+      'ERS publish failed with status code: 400 (http://example.com/api/auth/login)'
+    );
+  });
+});

package/dist/Config.d.ts

@@ -1,34 +0,0 @@
-export interface PublisherERSConfig {
-    /**
-     * The base URL of your instance of ERS.
-     *
-     * E.g. https://my-update.server.com
-     */
-    baseUrl: string;
-    /**
-     * The username you use to sign in to ERS
-     */
-    username: string;
-    /**
-     * The password you use to sign in to ERS
-     */
-    password: string;
-    /**
-     * The release channel you want to send artifacts to, normally something like
-     * "stable", "beta" or "alpha".
-     *
-     * If left unspecified we will try to infer the channel from your version
-     * field in your package.json.
-     *
-     * Default: stable
-     */
-    channel?: string;
-    /**
-     * The "flavor" of the binary that you want to release to.
-     * This is useful if you want to provide multiple versions
-     * of the same application version (e.g. full and lite)
-     * to end users.
-     */
-    flavor?: string;
-}
-//# sourceMappingURL=Config.d.ts.map

package/dist/Config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../src/Config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/Config.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/PublisherERS.d.ts

@@ -1,10 +0,0 @@
-import { PublisherBase, PublisherOptions } from '@electron-forge/publisher-base';
-import { ForgeArch, ForgePlatform } from '@electron-forge/shared-types';
-import { PublisherERSConfig } from './Config';
-export declare const ersPlatform: (platform: ForgePlatform, arch: ForgeArch) => string;
-export default class PublisherERS extends PublisherBase<PublisherERSConfig> {
-    name: string;
-    publish({ makeResults, setStatusLine }: PublisherOptions): Promise<void>;
-}
-export { PublisherERS, PublisherERSConfig };
-//# sourceMappingURL=PublisherERS.d.ts.map

package/dist/PublisherERS.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PublisherERS.d.ts","sourceRoot":"","sources":["../src/PublisherERS.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACjF,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAMxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAmB9C,eAAO,MAAM,WAAW,aAAc,aAAa,QAAQ,SAAS,KAAG,MAWtE,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa,CAAC,kBAAkB,CAAC;IACzE,IAAI,SAA6B;IAE3B,OAAO,CAAC,EAAE,WAAW,EAAE,aAAa,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;CA0G/E;AAED,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/PublisherERS.js

@@ -1,150 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "PublisherERSConfig", {
-    enumerable: true,
-    get: function() {
-        return _config.PublisherERSConfig;
-    }
-});
-exports.PublisherERS = exports.default = exports.ersPlatform = void 0;
-var _path = _interopRequireDefault(require("path"));
-var _publisherBase = require("@electron-forge/publisher-base");
-var _debug = _interopRequireDefault(require("debug"));
-var _formData = _interopRequireDefault(require("form-data"));
-var _fsExtra = _interopRequireDefault(require("fs-extra"));
-var _nodeFetch = _interopRequireDefault(require("node-fetch"));
-var _config = require("./Config");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const d = (0, _debug).default('electron-forge:publish:ers');
-const fetchAndCheckStatus = async (url, init)=>{
-    const result = await (0, _nodeFetch).default(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})`);
-};
-const ersPlatform = (platform, arch)=>{
-    switch(platform){
-        case 'darwin':
-            return 'osx_64';
-        case 'linux':
-            return arch === 'ia32' ? 'linux_32' : 'linux_64';
-        case 'win32':
-            return arch === 'ia32' ? 'windows_32' : 'windows_64';
-        default:
-            return platform;
-    }
-};
-exports.ersPlatform = ersPlatform;
-class PublisherERS extends _publisherBase.PublisherBase {
-    async publish({ makeResults , setStatusLine  }) {
-        const { config  } = this;
-        if (!(config.baseUrl && config.username && config.password)) {
-            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)=>`${config.baseUrl}/${apiPath}`
-        ;
-        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, options)=>fetchAndCheckStatus(api(apiPath), {
-                ...options || {},
-                headers: {
-                    ...(options || {}).headers,
-                    Authorization: `Bearer ${token}`
-                }
-            })
-        ;
-        const versions = await (await authFetch('api/version')).json();
-        const flavor = config.flavor || 'default';
-        for (const makeResult of makeResults){
-            const { packageJSON  } = makeResult;
-            const artifacts = makeResult.artifacts.filter((artifactPath)=>_path.default.basename(artifactPath).toLowerCase() !== 'releases'
-            );
-            const existingVersion = versions.find((version)=>{
-                return version.name === packageJSON.version && (!version.flavor || version.flavor === flavor);
-            });
-            let channel = 'stable';
-            if (config.channel) {
-                channel = config.channel;
-            } else if (packageJSON.version.includes('beta')) {
-                channel = 'beta';
-            } else if (packageJSON.version.includes('alpha')) {
-                channel = 'alpha';
-            }
-            if (!existingVersion) {
-                await authFetch('api/version', {
-                    method: 'POST',
-                    body: JSON.stringify({
-                        channel: {
-                            name: channel
-                        },
-                        flavor: config.flavor,
-                        name: packageJSON.version,
-                        notes: ''
-                    }),
-                    headers: {
-                        'Content-Type': 'application/json'
-                    }
-                });
-            }
-            let uploaded = 0;
-            const updateStatusLine = ()=>setStatusLine(`Uploading distributable (${uploaded}/${artifacts.length})`)
-            ;
-            updateStatusLine();
-            await Promise.all(artifacts.map(async (artifactPath)=>{
-                if (existingVersion) {
-                    const existingAsset = existingVersion.assets.find((asset)=>asset.name === _path.default.basename(artifactPath)
-                    );
-                    if (existingAsset) {
-                        d('asset at path:', artifactPath, 'already exists on server');
-                        uploaded += 1;
-                        updateStatusLine();
-                        return;
-                    }
-                }
-                d('attempting to upload asset:', artifactPath);
-                const artifactForm = new _formData.default();
-                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: _fsExtra.default.statSync(artifactPath).size
-                };
-                artifactForm.append('file', _fsExtra.default.createReadStream(artifactPath), fileOptions);
-                await authFetch('api/asset', {
-                    method: 'POST',
-                    body: artifactForm,
-                    headers: artifactForm.getHeaders()
-                });
-                d('upload successful for asset:', artifactPath);
-                uploaded += 1;
-                updateStatusLine();
-            }));
-        }
-    }
-    constructor(...args){
-        super(...args);
-        this.name = 'electron-release-server';
-    }
-}
-exports.default = PublisherERS;
-exports.PublisherERS = PublisherERS;
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/PublisherERS.ts"],"sourcesContent":["import path from 'path';\n\nimport { PublisherBase, PublisherOptions } from '@electron-forge/publisher-base';\nimport { ForgeArch, ForgePlatform } from '@electron-forge/shared-types';\nimport debug from 'debug';\nimport FormData from 'form-data';\nimport fs from 'fs-extra';\nimport fetch, { RequestInfo, RequestInit, Response } from 'node-fetch';\n\nimport { PublisherERSConfig } from './Config';\n\nconst d = debug('electron-forge:publish:ers');\n\ninterface ERSVersion {\n  name: string;\n  assets: { name: string }[];\n  flavor?: string;\n}\n\nconst fetchAndCheckStatus = async (url: RequestInfo, init?: RequestInit): Promise<Response> => {\n  const result = await fetch(url, init);\n  if (result.ok) {\n    // res.status >= 200 && res.status < 300\n    return result;\n  }\n  throw new Error(`ERS publish failed with status code: ${result.status} (${result.url})`);\n};\n\nexport const ersPlatform = (platform: ForgePlatform, arch: ForgeArch): string => {\n  switch (platform) {\n    case 'darwin':\n      return 'osx_64';\n    case 'linux':\n      return arch === 'ia32' ? 'linux_32' : 'linux_64';\n    case 'win32':\n      return arch === 'ia32' ? 'windows_32' : 'windows_64';\n    default:\n      return platform;\n  }\n};\n\nexport default class PublisherERS extends PublisherBase<PublisherERSConfig> {\n  name = 'electron-release-server';\n\n  async publish({ makeResults, setStatusLine }: PublisherOptions): Promise<void> {\n    const { config } = this;\n\n    if (!(config.baseUrl && config.username && config.password)) {\n      throw new Error(\n        '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'\n      );\n    }\n\n    d('attempting to authenticate to ERS');\n\n    const api = (apiPath: string) => `${config.baseUrl}/${apiPath}`;\n\n    const { token } = await (\n      await fetchAndCheckStatus(api('api/auth/login'), {\n        method: 'POST',\n        body: JSON.stringify({\n          username: config.username,\n          password: config.password,\n        }),\n        headers: {\n          'Content-Type': 'application/json',\n        },\n      })\n    ).json();\n\n    const authFetch = (apiPath: string, options?: RequestInit) =>\n      fetchAndCheckStatus(api(apiPath), { ...(options || {}), headers: { ...(options || {}).headers, Authorization: `Bearer ${token}` } });\n\n    const versions: ERSVersion[] = await (await authFetch('api/version')).json();\n    const flavor = config.flavor || 'default';\n\n    for (const makeResult of makeResults) {\n      const { packageJSON } = makeResult;\n      const artifacts = makeResult.artifacts.filter((artifactPath) => path.basename(artifactPath).toLowerCase() !== 'releases');\n\n      const existingVersion = versions.find((version) => {\n        return version.name === packageJSON.version && (!version.flavor || version.flavor === flavor);\n      });\n\n      let channel = 'stable';\n      if (config.channel) {\n        channel = config.channel;\n      } else if (packageJSON.version.includes('beta')) {\n        channel = 'beta';\n      } else if (packageJSON.version.includes('alpha')) {\n        channel = 'alpha';\n      }\n\n      if (!existingVersion) {\n        await authFetch('api/version', {\n          method: 'POST',\n          body: JSON.stringify({\n            channel: {\n              name: channel,\n            },\n            flavor: config.flavor,\n            name: packageJSON.version,\n            notes: '',\n          }),\n          headers: {\n            'Content-Type': 'application/json',\n          },\n        });\n      }\n\n      let uploaded = 0;\n      const updateStatusLine = () => setStatusLine(`Uploading distributable (${uploaded}/${artifacts.length})`);\n      updateStatusLine();\n\n      await Promise.all(\n        artifacts.map(async (artifactPath) => {\n          if (existingVersion) {\n            const existingAsset = existingVersion.assets.find((asset) => asset.name === path.basename(artifactPath));\n\n            if (existingAsset) {\n              d('asset at path:', artifactPath, 'already exists on server');\n              uploaded += 1;\n              updateStatusLine();\n              return;\n            }\n          }\n          d('attempting to upload asset:', artifactPath);\n          const artifactForm = new FormData();\n          artifactForm.append('token', token);\n          artifactForm.append('version', packageJSON.version);\n          artifactForm.append('platform', ersPlatform(makeResult.platform, makeResult.arch));\n\n          // see https://github.com/form-data/form-data/issues/426\n          const fileOptions = {\n            knownLength: fs.statSync(artifactPath).size,\n          };\n          artifactForm.append('file', fs.createReadStream(artifactPath), fileOptions);\n\n          await authFetch('api/asset', {\n            method: 'POST',\n            body: artifactForm,\n            headers: artifactForm.getHeaders(),\n          });\n          d('upload successful for asset:', artifactPath);\n          uploaded += 1;\n          updateStatusLine();\n        })\n      );\n    }\n  }\n}\n\nexport { PublisherERS, PublisherERSConfig };\n"],"names":["PublisherERSConfig","d","debug","fetchAndCheckStatus","url","init","result","fetch","ok","Error","status","ersPlatform","platform","arch","PublisherERS","PublisherBase","publish","makeResults","setStatusLine","config","baseUrl","username","password","api","apiPath","token","method","body","JSON","stringify","headers","json","authFetch","options","Authorization","versions","flavor","makeResult","packageJSON","artifacts","filter","artifactPath","path","basename","toLowerCase","existingVersion","find","version","name","channel","includes","notes","uploaded","updateStatusLine","length","Promise","all","map","existingAsset","assets","asset","artifactForm","FormData","append","fileOptions","knownLength","fs","statSync","size","createReadStream","getHeaders"],"mappings":"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"}