Use async functions (#54)

cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import path from 'node:path';
+import process from 'node:process';
 import ora from 'ora';
 import meow from 'meow';
 import chalk from 'chalk';
@@ -67,70 +68,70 @@ const spinnerStart = text => {
     return spinner.start();
 };
 
-function doAutoPublish() {
+async function doAutoPublish() {
     spinnerStart('Fetching token');
 
-    fetchToken(apiConfig).then(token => {
-        spinnerStart(`Uploading ${path.basename(zipPath)}`);
-
-        return upload({
-            apiConfig,
-            token,
-            zipPath,
-        }).then(uploadRes => {
-            if (!isUploadSuccess(uploadRes)) {
-                spinner.stop();
-                return exitWithUploadFailure(uploadRes);
-            }
-
-            spinnerStart('Publishing');
-            return publish({ apiConfig, token }, trustedTesters && 'trustedTesters').then(publishRes => {
-                spinner.stop();
-                exitWithPublishStatus(publishRes);
-            });
-        });
-    }).catch(errorHandler);
+    const token = await fetchToken(apiConfig);
+    spinnerStart(`Uploading ${path.basename(zipPath)}`);
+
+    const uploadResponse = await upload({
+        apiConfig,
+        token,
+        zipPath,
+    });
+    if (!isUploadSuccess(uploadResponse)) {
+        spinner.stop();
+        return exitWithUploadFailure(uploadResponse);
+    }
+
+    spinnerStart('Publishing');
+    const publishResponse = await publish({ apiConfig, token }, trustedTesters && 'trustedTesters');
+    spinner.stop();
+    exitWithPublishStatus(publishResponse);
 }
 
-function doUpload() {
+async function doUpload() {
     spinnerStart(`Uploading ${path.basename(zipPath)}`);
-    upload({
+    const response = await upload({
         apiConfig,
         zipPath,
-    }).then(res => {
-        spinner.stop();
-        if (!isUploadSuccess(res)) {
-            return exitWithUploadFailure(res);
-        }
+    });
+
+    spinner.stop();
+    if (!isUploadSuccess(response)) {
+        return exitWithUploadFailure(response);
+    }
 
-        console.log(chalk.green('Upload Completed'));
-    }).catch(errorHandler);
+    console.log(chalk.green('Upload Completed'));
 }
 
-function doPublish() {
+async function doPublish() {
     spinnerStart('Publishing');
 
-    publish({ apiConfig }, trustedTesters && 'trustedTesters').then(res => {
-        spinner.stop();
-        exitWithPublishStatus(res);
-    }).catch(errorHandler);
+    const response = await publish({ apiConfig }, trustedTesters && 'trustedTesters');
+    spinner.stop();
+    exitWithPublishStatus(response);
 }
 
-function errorHandler(err) {
+function errorHandler(error) {
     spinner.stop();
-    console.error(chalk.red(err.message));
+    console.error(chalk.red(error.message));
 
-    if (err.response && err.response.body) {
-        console.error(chalk.yellow(JSON.stringify(err.response.body, null, 4)));
+    if (error.response && error.response.body) {
+        console.error(chalk.yellow(JSON.stringify(error.response.body, null, 4)));
     }
 
-    process.exit(1);
+    process.exitCode = 1;
 }
 
-if (isUpload && autoPublish) {
-    doAutoPublish();
-} else if (isUpload) {
-    doUpload();
-} else if (isPublish) {
-    doPublish();
+async function init() {
+    if (isUpload && autoPublish) {
+        await doAutoPublish();
+    } else if (isUpload) {
+        await doUpload();
+    } else if (isPublish) {
+        await doPublish();
+    }
 }
+
+init().catch(errorHandler);

config.js

@@ -1,3 +1,5 @@
+import process from 'node:process';
+
 export default function getConfig(command, flags) {
     const apiConfig = {
         extensionId: flags.extensionId || process.env.EXTENSION_ID,

package.json

@@ -58,10 +58,6 @@
         "always"
       ],
       "camelcase": "off",
-      "func-names": "off",
-      "node/prefer-global/process": "off",
-      "promise/prefer-await-to-then": "off",
-      "unicorn/prevent-abbreviations": "off",
       "unicorn/no-process-exit": "off"
     }
   }

test/config.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import test from 'ava';
 import createConfig from '../config.js';
 

test/helpers/stubs.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 
 export function stubProcessExit(stub) {
     const old = process.exit;

util.js

@@ -1,7 +1,8 @@
+import process from 'node:process';
 import { relative } from 'node:path';
 
-export function isUploadSuccess(res) {
-    return res.uploadState === 'SUCCESS';
+export function isUploadSuccess(response) {
+    return response.uploadState === 'SUCCESS';
 }
 
 export function exitWithUploadFailure(item) {

wrapper.js

@@ -1,11 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import process from 'node:process';
 import getClient from 'chrome-webstore-upload';
 import zipdir from './zipdir.js';
 
 const isZip = filepath => path.extname(filepath) === '.zip';
 
-export function upload({ apiConfig, zipPath, token }) {
+export async function upload({ apiConfig, zipPath, token }) {
     let client;
     try {
         client = getClient(apiConfig);
@@ -20,28 +21,17 @@ export function upload({ apiConfig, zipPath, token }) {
         return client.uploadExisting(zipStream, token);
     }
 
-    return zipdir(zipPath).then(zipStream => client.uploadExisting(zipStream, token));
+    const zipStream = await zipdir(zipPath);
+    return client.uploadExisting(zipStream, token);
 }
 
-export function publish({ apiConfig, token }, publishTarget) {
-    let client;
-    try {
-        client = getClient(apiConfig);
-    } catch (error) {
-        return Promise.reject(error);
-    }
-
+export async function publish({ apiConfig, token }, publishTarget) {
+    const client = getClient(apiConfig);
     return client.publish(publishTarget, token);
 }
 
-export function fetchToken(apiConfig) {
-    let client;
-    try {
-        client = getClient(apiConfig);
-    } catch (error) {
-        return Promise.reject(error);
-    }
-
+export async function fetchToken(apiConfig) {
+    const client = getClient(apiConfig);
     return client.fetchToken();
 }
 

zipdir.js

@@ -4,19 +4,17 @@ import yazl from 'yazl';
 import recursiveDir from 'recursive-readdir';
 import { zipPath } from './util.js';
 
-export default function zipStreamFromDir(dir) {
-    return recursiveDir(dir).then(files => {
-        const zip = new yazl.ZipFile();
-        for (const file of files) {
-            if (isNotJunk(basename(file))) {
-                zip.addFile(file, zipPath(dir, file));
-            }
+export default async function zipStreamFromDir(dir) {
+    const files = await recursiveDir(dir);
+    const zip = new yazl.ZipFile();
+    for (const file of files) {
+        if (isNotJunk(basename(file))) {
+            zip.addFile(file, zipPath(dir, file));
         }
+    }
 
-        return new Promise(resolve => {
-            zip.end(() => {
-                resolve(zip.outputStream);
-            });
-        });
+    await new Promise(resolve => {
+        zip.end(resolve);
     });
+    return zip.outputStream;
 }