Switch to modern async/await patterns from callbacks.

Author: jtwebman

SECURITY.md

@@ -13,10 +13,11 @@ process.stdin.on('data', chunk => {
   input += chunk;
 });
 
-process.stdin.on('end', () => {
-  handleInput(input, err => {
-    if (err) {
-      throw err;
-    }
-  });
+process.stdin.on('end', async () => {
+  try {
+    await handleInput(input);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
 });

bin/coveralls.js

@@ -3,10 +3,13 @@
 const fs = require('fs');
 const path = require('path');
 const lcovParse = require('lcov-parse');
+const { promisify } = require('util');
 const nodeCrypto = require('crypto');
 const index = require('..');
 const logger = require('./logger')(index.options);
 
+const lcovParseAsync = promisify(lcovParse);
+
 /**
  * Converts line hit details from LCOV format to Coveralls coverage array format
  * @param {number} length - Total number of lines in the source file
@@ -101,20 +104,16 @@ const cleanFilePath = file => {
  * @param {string} [options.service_pull_request] - Pull request number
  * @param {string} [options.repo_token] - Coveralls repository token
  * @param {boolean} [options.parallel] - Whether this is a parallel build
- * @param {Function} cb - Callback function (err, coverallsData)
- * @returns {void}
- * @throws {Error} Via callback if LCOV parsing fails or source files cannot be read
+ * @returns {Promise<Object>} Coveralls formatted coverage data
+ * @throws {Error} If LCOV parsing fails or source files cannot be read
  */
-const convertLcovToCoveralls = (input, options, cb) => {
+const convertLcovToCoveralls = async (input, options) => {
   let filepath = options.filepath || '';
   logger.debug('in: ', filepath);
   filepath = path.resolve(process.cwd(), filepath);
-  lcovParse(input, (err, parsed) => {
-    if (err) {
-      logger.error('error from lcovParse: ', err);
-      logger.error('input: ', input);
-      return cb(err);
-    }
+
+  try {
+    const parsed = await lcovParseAsync(input);
 
     const postJson = {
       source_files: [],
@@ -168,8 +167,12 @@ const convertLcovToCoveralls = (input, options, cb) => {
       }
     });
 
-    return cb(null, postJson);
-  });
+    return postJson;
+  } catch (err) {
+    logger.error('error from lcovParse: ', err);
+    logger.error('input: ', input);
+    throw err;
+  }
 };
 
 module.exports = convertLcovToCoveralls;

lib/convertLcovToCoveralls.js

@@ -1,6 +1,9 @@
 'use strict';
 
 const { execFile } = require('child_process');
+const { promisify } = require('util');
+
+const execFileAsync = promisify(execFile);
 
 /**
  * Fetches and enriches git metadata with information from the local git repository
@@ -15,26 +18,21 @@ const { execFile } = require('child_process');
  * @param {string} [git.head.message] - Commit message
  * @param {string} [git.branch] - Branch name
  * @param {Array<{name: string, url: string}>} [git.remotes] - Git remotes
- * @param {Function} cb - Callback function (err, enrichedGit)
- * @returns {void}
- * @throws {Error} Via callback if required fields are missing or git commands fail
+ * @returns {Promise<Object>} Enriched git metadata object
+ * @throws {Error} If required fields are missing or git commands fail
  */
-function fetchGitData(git, cb) {
-  if (!cb) {
-    throw new Error('fetchGitData requires a callback');
-  }
-
+async function fetchGitData(git) {
   // -- Malformed/undefined git object
   if (typeof git === 'undefined') {
-    return cb(new Error('No options passed'));
+    throw new Error('No options passed');
   }
 
   if (!Object.prototype.hasOwnProperty.call(git, 'head')) {
-    return cb(new Error('You must provide the head'));
+    throw new Error('You must provide the head');
   }
 
   if (!Object.prototype.hasOwnProperty.call(git.head, 'id')) {
-    return cb(new Error('You must provide the head.id'));
+    throw new Error('You must provide the head.id');
   }
 
   // -- Set required properties of git if they weren"t provided
@@ -56,38 +54,31 @@ function fetchGitData(git, cb) {
   }
 
   // -- Use git?
-  execFile('git', ['rev-parse', '--verify', git.head.id], err => {
-    if (err) {
-      // git is not available...
-      git.head.author_name = git.head.author_name || 'Unknown Author';
-      git.head.author_email = git.head.author_email || '';
-      git.head.committer_name = git.head.committer_name || 'Unknown Committer';
-      git.head.committer_email = git.head.committer_email || '';
-      git.head.message = git.head.message || 'Unknown Commit Message';
-      return cb(null, git);
-    }
-
-    fetchHeadDetails(git, cb);
-  });
+  try {
+    await execFileAsync('git', ['rev-parse', '--verify', git.head.id]);
+  } catch {
+    // git is not available...
+    git.head.author_name = git.head.author_name || 'Unknown Author';
+    git.head.author_email = git.head.author_email || '';
+    git.head.committer_name = git.head.committer_name || 'Unknown Committer';
+    git.head.committer_email = git.head.committer_email || '';
+    git.head.message = git.head.message || 'Unknown Commit Message';
+    return git;
+  }
+  return await fetchHeadDetails(git);
 }
 
 /**
  * Fetches the current branch name using git branch command
  * Sets git.branch if a valid branch is detected (excludes detached HEAD states)
  * @param {Object} git - Git metadata object to update
- * @param {Function} cb - Callback function (err, git)
- * @returns {void}
+ * @returns {Promise<Object>} Updated git metadata object
  * @private
  */
-function fetchBranch(git, cb) {
-  execFile('git', ['branch'], (err, branches) => {
-    if (err) {
-      return cb(err);
-    }
-
-    git.branch = (branches.match(/^\* ([\w./-]+)/m) || [])[1] ?? '';
-    fetchRemotes(git, cb);
-  });
+async function fetchBranch(git) {
+  const { stdout: branches } = await execFileAsync('git', ['branch']);
+  git.branch = (branches.match(/^\* ([\w./-]+)/m) || [])[1] ?? '';
+  return await fetchRemotes(git);
 }
 
 const REGEX_COMMIT_DETAILS =
@@ -97,60 +88,50 @@ const REGEX_COMMIT_DETAILS =
  * Fetches detailed commit information using git cat-file
  * Populates author, committer, and message fields in git.head
  * @param {Object} git - Git metadata object to update
- * @param {Function} cb - Callback function (err, git)
- * @returns {void}
+ * @returns {Promise<Object>} Updated git metadata object
  * @private
  */
-function fetchHeadDetails(git, cb) {
-  execFile('git', ['cat-file', '-p', git.head.id], (err, response) => {
-    if (err) {
-      return cb(err);
-    }
-
-    const match = response.match(REGEX_COMMIT_DETAILS);
-    if (!match) {
-      return cb(new Error('Unable to parse commit details from git cat-file output'));
-    }
+async function fetchHeadDetails(git) {
+  const { stdout: response } = await execFileAsync('git', ['cat-file', '-p', git.head.id]);
 
-    const items = match.slice(1);
-    const fields = ['author_name', 'author_email', 'committer_name', 'committer_email', 'message'];
-    fields.forEach((field, index) => {
-      git.head[field] = items[index];
-    });
+  const match = response.match(REGEX_COMMIT_DETAILS);
+  if (!match) {
+    throw new Error('Unable to parse commit details from git cat-file output');
+  }
 
-    if (git.branch) {
-      fetchRemotes(git, cb);
-    } else {
-      fetchBranch(git, cb);
-    }
+  const items = match.slice(1);
+  const fields = ['author_name', 'author_email', 'committer_name', 'committer_email', 'message'];
+  fields.forEach((field, index) => {
+    git.head[field] = items[index];
   });
+
+  if (git.branch) {
+    return await fetchRemotes(git);
+  } else {
+    return await fetchBranch(git);
+  }
 }
 
 /**
  * Fetches git remotes using git remote -v command
  * Filters to only include push remotes and deduplicates entries
  * @param {Object} git - Git metadata object to update
- * @param {Function} cb - Callback function (err, git)
- * @returns {void}
+ * @returns {Promise<Object>} Updated git metadata object
  * @private
  */
-function fetchRemotes(git, cb) {
-  execFile('git', ['remote', '-v'], (err, remotes) => {
-    if (err) {
-      return cb(err);
-    }
+async function fetchRemotes(git) {
+  const { stdout: remotes } = await execFileAsync('git', ['remote', '-v']);
 
-    const processed = {};
-    remotes.split('\n').forEach(remote => {
-      if (!/\s\(push\)$/.test(remote)) {
-        return;
-      }
+  const processed = {};
+  remotes.split('\n').forEach(remote => {
+    if (!/\s\(push\)$/.test(remote)) {
+      return;
+    }
 
-      remote = remote.split(/\s+/);
-      saveRemote(processed, git, remote[0], remote[1]);
-    });
-    cb(null, git);
+    remote = remote.split(/\s+/);
+    saveRemote(processed, git, remote[0], remote[1]);
   });
+  return git;
 }
 
 /**