@node-core/utils 6.4.0 → 7.0.0

package/components/metadata.js

@@ -4,9 +4,71 @@ import Request from '../lib/request.js';
 import auth from '../lib/auth.js';
 import PRData from '../lib/pr_data.js';
 import PRSummary from '../lib/pr_summary.js';
-import PRChecker from '../lib/pr_checker.js';
+import PRChecker, {
+  PR_CHECK_REASON_CODES
+} from '../lib/pr_checker.js';
 import MetadataGenerator from '../lib/metadata_gen.js';
 
+export const METADATA_READINESS = Object.freeze({
+  READY: 'ready',
+  DEFERRABLE: 'deferrable',
+  FAILED: 'failed'
+});
+
+export const METADATA_EXIT_CODES = Object.freeze({
+  READY: 0,
+  DEFERRABLE: 20,
+  FAILED: 40
+});
+
+const DEFERRABLE_REASON_CODES = new Set([
+  PR_CHECK_REASON_CODES.WAIT_TIME
+]);
+
+export function classifyMetadataReadiness(ready, reasonCodes) {
+  if (ready) {
+    return METADATA_READINESS.READY;
+  }
+
+  if (reasonCodes.length > 0 &&
+      reasonCodes.every((code) => DEFERRABLE_REASON_CODES.has(code))) {
+    return METADATA_READINESS.DEFERRABLE;
+  }
+
+  return METADATA_READINESS.FAILED;
+}
+
+export function getMetadataExitCode(readiness) {
+  switch (readiness) {
+    case METADATA_READINESS.READY:
+      return METADATA_EXIT_CODES.READY;
+    case METADATA_READINESS.DEFERRABLE:
+      return METADATA_EXIT_CODES.DEFERRABLE;
+    default:
+      return METADATA_EXIT_CODES.FAILED;
+  }
+}
+
+export function formatMetadataResult({ status, data, metadata, checker }) {
+  const reasonCodes = [...new Set(checker.reasons.map(({ code }) => code))];
+  const readiness = classifyMetadataReadiness(status, reasonCodes);
+  const exitCode = getMetadataExitCode(readiness);
+  return {
+    ready: status,
+    readiness,
+    exitCode,
+    pullRequest: {
+      owner: data.owner,
+      repo: data.repo,
+      number: data.prid,
+      url: data.pr.url
+    },
+    metadata,
+    reasonCodes,
+    reasons: checker.reasons
+  };
+}
+
 export async function getMetadata(argv, skipRefs, cli) {
   const credentials = await auth({
     github: true,
@@ -22,7 +84,7 @@ export async function getMetadata(argv, skipRefs, cli) {
   summary.display();
 
   const metadata = new MetadataGenerator({ skipRefs, ...data }).getMetadata();
-  if (!process.stdout.isTTY) {
+  if (!argv.json && !process.stdout.isTTY) {
     process.stdout.write(metadata);
   }
 
@@ -33,17 +95,23 @@ export async function getMetadata(argv, skipRefs, cli) {
     cli.stopSpinner(`Done writing metadata to ${argv.file}`);
   }
 
-  cli.separator('Generated metadata');
-  cli.write(metadata);
-  cli.separator();
+  if (!argv.json) {
+    cli.separator('Generated metadata');
+    cli.write(metadata);
+    cli.separator();
+  }
 
   const checker = new PRChecker(cli, data, request, argv);
   const status = await checker.checkAll(argv.checkComments, argv.checkCI);
-  return {
+  const result = {
     status,
     request,
     data,
     metadata,
     checker
   };
-};
+  return {
+    ...result,
+    json: formatMetadataResult(result)
+  };
+}

package/lib/auth.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
 import { ClientRequest } from 'node:http';
 
-// eslint-disable-next-line import/no-unresolved
 import ghauth from 'ghauth';
 
 import { clearCachedConfig, encryptValue, getMergedConfig, getNcurcPath } from './config.js';
@@ -76,7 +75,7 @@ async function auth(
       let token;
       try {
         ({ username, token } = getMergedConfig());
-      } catch (e) {
+      } catch {
         // Ignore error and prompt
       }
 
@@ -94,7 +93,7 @@ async function auth(
           'and run the following command to add it to your ncu config: ' +
           'ncu-config --global set -x jenkins_token'
         );
-      };
+      }
       check(username, jenkins_token);
       const jenkins = encode(username, jenkins_token);
       setOwnProperty(result, 'jenkins', jenkins);
@@ -127,7 +126,7 @@ async function auth(
       let token;
       try {
         token = await encryptValue(credentials.token);
-      } catch (err) {
+      } catch {
         console.warn('Failed encrypt token, storing unencrypted instead');
         token = credentials.token;
       }

package/lib/backport_session.js

@@ -27,7 +27,7 @@ export default class BackportSession extends Session {
       logs = runSync('git',
         ['log', `-${num}`, '--format=%h', rev, '--', file]
       ).trim();
-    } catch (e) {
+    } catch {
       return null;
     }
     if (!logs) {
@@ -273,7 +273,7 @@ export default class BackportSession extends Session {
     const upstreamCommit = this.getBranchCommit(`${this.upstream}/${branch}`);
 
     return localCommit === upstreamCommit;
-  };
+  }
 
   isLocalBranchExists(branch) {
     try {
@@ -282,7 +282,7 @@ export default class BackportSession extends Session {
         ['rev-parse', '--verify', '--quiet', branch]
       );
       return true;
-    } catch (e) {
+    } catch {
       return false;
     }
   }

package/lib/benchmark.js

@@ -0,0 +1,243 @@
+import { basename } from 'node:path';
+
+import { getPrURL } from './links.js';
+import { IGNORE } from './run.js';
+
+const BENCHMARK_DIR = 'benchmark';
+// Entries in the benchmark folder that are not benchmark categories.
+const NON_CATEGORY_DIRS = new Set(['fixtures']);
+
+export default class BenchmarkSession {
+  constructor(cli, request, argv) {
+    this.cli = cli;
+    this.request = request;
+    this.argv = argv;
+    this.workflow = argv.workflow || 'benchmark.yml';
+  }
+
+  get prUrl() {
+    const { owner, repo, prid } = this.argv;
+    return getPrURL({ owner, repo, prid });
+  }
+
+  async getPullRequest() {
+    const { cli } = this;
+    cli.startSpinner(`Fetching data for ${this.prUrl}`);
+    const pr = await this.request.getPullRequest(this.prUrl);
+    if (!pr || !pr.head) {
+      cli.stopSpinner(
+        `Could not find pull request ${this.prUrl}`,
+        cli.SPINNER_STATUS.FAILED);
+      throw new Error(IGNORE);
+    }
+    cli.stopSpinner(`Fetched data for ${this.prUrl}`);
+    this.pr = pr;
+    return pr;
+  }
+
+  async getCategories() {
+    const { cli, pr } = this;
+    const head = pr.head;
+    // Prefer listing the benchmark folder on the PR head, falling back to the
+    // base branch if the head repository is unavailable (e.g. deleted fork).
+    const source = head.repo
+      ? { fullName: head.repo.full_name, ref: head.sha }
+      : { fullName: pr.base.repo.full_name, ref: pr.base.ref };
+    const [owner, repo] = source.fullName.split('/');
+
+    cli.startSpinner('Fetching available benchmark categories');
+    let entries;
+    try {
+      entries = await this.request.listDirectory({
+        owner,
+        repo,
+        path: BENCHMARK_DIR,
+        ref: source.ref
+      });
+    } catch (e) {
+      cli.stopSpinner(
+        'Could not fetch benchmark categories',
+        cli.SPINNER_STATUS.FAILED);
+      throw e;
+    }
+
+    const categories = entries
+      .filter((entry) => entry.type === 'dir')
+      .map((entry) => entry.name)
+      .filter((name) => !NON_CATEGORY_DIRS.has(name))
+      .sort();
+
+    if (categories.length === 0) {
+      cli.stopSpinner(
+        `No benchmark categories found in ${source.fullName}/${BENCHMARK_DIR}`,
+        cli.SPINNER_STATUS.FAILED);
+      throw new Error(IGNORE);
+    }
+
+    cli.stopSpinner(`Found ${categories.length} benchmark categories`);
+    this.categories = categories;
+    return categories;
+  }
+
+  async getTouchedBenchmarks() {
+    const { cli, argv } = this;
+    const touched = [];
+    try {
+      const files = this.request.getPullRequestFiles({
+        owner: argv.owner,
+        repo: argv.repo,
+        prid: argv.prid
+      });
+      for await (const file of files) {
+        const match = /^benchmark\/([^/]+)\/(.+\.js)$/.exec(file.filename);
+        if (match && this.categories.includes(match[1])) {
+          touched.push({
+            category: match[1],
+            name: basename(match[2], '.js')
+          });
+        }
+      }
+    } catch {
+      // Not being able to fetch the changed files is not fatal: fall back to
+      // an empty pre-selection.
+      cli.warn('Could not determine which benchmark files the PR touches.');
+    }
+    this.touched = touched;
+    return touched;
+  }
+
+  // Guess relevant categories from the PR subsystem labels, matching a label
+  // to a category name up to a trailing plural "s" (e.g. `buffer` -> `buffers`).
+  categoriesFromLabels() {
+    const normalize = (name) => name.toLowerCase().replace(/s$| /, '');
+    const labels = (this.pr.labels ?? [])
+      .map((label) => (typeof label === 'string' ? label : label.name))
+      .filter(Boolean)
+      .map(normalize);
+    return new Set(
+      this.categories.filter((category) =>
+        labels.includes(normalize(category))));
+  }
+
+  async promptCategories() {
+    const { cli, categories } = this;
+    // Fall back to the PR labels when the PR does not touch any benchmark file.
+    const preselected = this.touched.length
+      ? new Set(this.touched.map((f) => f.category))
+      : this.categoriesFromLabels();
+
+    if (preselected.size) {
+      cli.info(`Based on the PR ${
+        this.touched.length ? 'changed files' : 'labels'
+        }, this/these benchmark(s) seem(s) relevant:`);
+      cli.info([...preselected].join(', '));
+      cli.info('If not relevant, do not forget to unselect it/them.');
+    }
+
+    const selected = await cli.promptCheckbox(
+      'Select the benchmark categories to run:',
+      categories.map((name) => ({
+        name,
+        value: name,
+        checked: preselected.has(name)
+      })));
+
+    if (!selected || selected.length === 0) {
+      cli.warn('No benchmark category selected, aborting.');
+      throw new Error(IGNORE);
+    }
+    return selected;
+  }
+
+  async promptFilter(selected) {
+    const { cli, touched } = this;
+
+    // When a single benchmark file was touched and only its category is
+    // selected, pre-fill the filter with that file so it runs on its own.
+    const defaultAnswer =
+      touched.length === 1 && selected.length === 1 &&
+      selected[0] === touched[0].category
+        ? touched[0].name
+        : '';
+
+    const filter = await cli.prompt(
+      'Substring to filter which benchmarks run (leave empty to run all):',
+      { questionType: cli.QUESTION_TYPE.INPUT, defaultAnswer });
+    return filter?.trim() || undefined;
+  }
+
+  async start() {
+    const { cli, argv } = this;
+
+    await this.getPullRequest();
+    await this.getCategories();
+    cli.startSpinner('Checking for benchmark files listed in the PR changes...');
+    await this.getTouchedBenchmarks();
+    cli.stopSpinner(`Found ${this.touched.length} benchmark file(s) in the PR changes`);
+    const selected = await this.promptCategories();
+    const filter = await this.promptFilter(selected);
+
+    const workflowOwner = argv.workflowOwner || argv.owner;
+    const workflowRepo = argv.workflowRepo || argv.repo;
+    const prRepo = `${argv.owner}/${argv.repo}`;
+    // The workflow token can only comment when it runs in the PR repository;
+    // default to not commenting when the workflow lives elsewhere.
+    const sameRepo = `${workflowOwner}/${workflowRepo}` === prRepo;
+    const postComment = await cli.prompt(
+      'Should the workflow post the results as a comment on the PR?',
+      { defaultAnswer: sameRepo });
+
+    const category = selected.join(' ');
+    // Benchmark the commit provided on the command line, defaulting to the
+    // current PR head.
+    const commit = argv.commit || this.pr.head.sha;
+
+    const inputs = {
+      pr_id: `${argv.prid}`,
+      commit,
+      category
+    };
+    // The benchmark workflow checks out `inputs.repo || github.repository`; only
+    // set it when the workflow lives in a different repository than the PR.
+    if (!sameRepo) {
+      inputs.repo = prRepo;
+    }
+    if (filter) {
+      inputs.filter = filter;
+    }
+    if (argv.runs != null) {
+      inputs.runs = `${argv.runs}`;
+    }
+    inputs['post-comment'] = `${postComment}`;
+
+    cli.separator('Benchmark');
+    cli.table('PR:', this.prUrl);
+    cli.table('Commit:', commit);
+    cli.table('Categories:', category);
+    if (inputs.filter) cli.table('Filter:', inputs.filter);
+    if (inputs.runs) cli.table('Runs:', inputs.runs);
+    cli.table('Comment on PR:', postComment ? 'yes' : 'no');
+    cli.table('Workflow:',
+      `${workflowOwner}/${workflowRepo} (${this.workflow}@${argv.ref})`);
+
+    const confirmed = await cli.prompt(
+      'Trigger the benchmark workflow with these settings?',
+      { defaultAnswer: true });
+    if (!confirmed) {
+      cli.warn('Aborted, no workflow was triggered.');
+      throw new Error(IGNORE);
+    }
+
+    cli.startSpinner('Dispatching benchmark workflow');
+    await this.request.dispatchWorkflow(this.workflow, {
+      owner: workflowOwner,
+      repo: workflowRepo,
+      ref: argv.ref,
+      inputs
+    });
+    cli.stopSpinner('Benchmark workflow dispatched');
+    cli.info('Follow the run at ' +
+      `https://github.com/${workflowOwner}/${workflowRepo}/actions/` +
+      `workflows/${this.workflow}`);
+  }
+}

package/lib/cherry_pick.js

@@ -16,20 +16,31 @@ export default class CherryPick {
     lint,
     includeCVE,
     cveIds,
-    vulnCveMap
+    vulnCveMap,
+    promptAmend,
+    skipMessagePrompt
   } = {}) {
     this.prid = prid;
     this.cli = cli;
     this.dir = dir;
     this.upstream = upstream;
     this.gpgSign = gpgSign;
-    this.options = { owner, repo, lint, includeCVE, cveIds, vulnCveMap };
+    this.skipMessagePrompt = skipMessagePrompt ?? false;
+    this.options = {
+      owner, repo, lint, includeCVE, cveIds, vulnCveMap, promptAmend
+    };
   }
 
   get includeCVE() {
     return this.options.includeCVE ?? false;
   }
 
+  // Whether to ask before amending the PR to the proposal. Callers that already
+  // asked opt out of it.
+  get promptAmend() {
+    return this.options.promptAmend ?? true;
+  }
+
   get cveIds() {
     return this.options.cveIds ?? null;
   }
@@ -82,14 +93,22 @@ export default class CherryPick {
     }, false, cli);
     this.expectedCommitShas =
       metadata.data.commits.map(({ commit }) => commit.oid);
-
-    const amend = await cli.prompt(
-      'Would you like to amend this PR to the proposal?',
-      { default: true }
-    );
-
-    if (!amend) {
-      return true;
+    // In security releases the fix may have already landed publicly, so the
+    // PR is merged and refs/pull/<prid>/merge no longer exists - pick the
+    // commits as they landed on the base branch instead.
+    this.landedCommitSha = metadata.data.pr.merged
+      ? metadata.data.pr.mergeCommit?.oid
+      : undefined;
+
+    if (this.promptAmend) {
+      const amend = await cli.prompt(
+        'Would you like to amend this PR to the proposal?',
+        { default: true }
+      );
+
+      if (!amend) {
+        return true;
+      }
     }
 
     try {
@@ -117,7 +136,7 @@ export default class CherryPick {
       { captureStdout: 'lines' });
 
     if (commitInfo.shas.length !== 1) {
-      const fixupAll = await cli.prompt(
+      const fixupAll = this.skipMessagePrompt || await cli.prompt(
         `${subjects.length} commits from the original PR are going to be` +
         'squashed into a single commit. OK to proceed?', {
           defaultAnswer: true
@@ -151,3 +170,5 @@ CherryPick.prototype.downloadAndPatch = LandingSession.prototype.downloadAndPatc
 CherryPick.prototype.validateLint = LandingSession.prototype.validateLint;
 CherryPick.prototype.getMessagePath = LandingSession.prototype.getMessagePath;
 CherryPick.prototype.saveMessage = LandingSession.prototype.saveMessage;
+CherryPick.prototype.generateAmendedMessage =
+  LandingSession.prototype.generateAmendedMessage;

package/lib/ci/failure_aggregator.js

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import chalk from 'chalk';
 
 import { getMachineUrl, parsePRFromURL } from '../links.js';
@@ -15,6 +14,11 @@ import {
 
 const { FAILURE_TYPES_NAME } = CIFailureParser;
 
+function uniqBy(array, key) {
+  const seen = new Set();
+  return array.filter((item) => !seen.has(item[key]) && seen.add(item[key]));
+}
+
 export class FailureAggregator {
   constructor(cli, data) {
     this.cli = cli;
@@ -24,37 +28,29 @@ export class FailureAggregator {
   }
 
   aggregate() {
-    const failures = this.failures;
-    const groupedByReason = _.chain(failures)
-      .groupBy(getHighlight)
-      .toPairs()
-      .sortBy(0)
-      .value();
+    const groupedByReason = Object.groupBy(this.failures, getHighlight);
     const data = [];
-    for (const item of groupedByReason) {
-      const [reason, failures] = item;
+    for (const reason of Object.keys(groupedByReason).sort()) {
+      const failures = groupedByReason[reason];
       // Uncomment this and redirect stderr away to see matched highlights
       // console.log('HIGHLIGHT', reason);
 
       // If multiple sub builds of one PR are failed by the same reason,
       // we'll only take one of those builds, as that might be a genuine failure
-      const prs = _.chain(failures)
-        .uniqBy('source')
-        .sortBy((f) => parseJobFromURL(f.upstream).jobid)
-        .map((item) => ({ source: item.source, upstream: item.upstream }))
-        .value();
-      const machines = _.uniqBy(
+      const prs = uniqBy(failures, 'source')
+        .map(({ source, upstream }) => ({ source, upstream, _id: parseJobFromURL(upstream).jobid }))
+        .sort((a, b) => a._id - b._id);
+      const machines = uniqBy(
         failures.map(f => ({ hostname: f.builtOn, url: f.url })),
         'hostname');
       data.push({
         reason, type: failures[0].type, failures, prs, machines
       });
-    };
+    }
 
-    const groupedByType = _.groupBy(data, 'type');
-    for (const type of Object.keys(groupedByType)) {
-      groupedByType[type] =
-        _.sortBy(groupedByType[type], r => 0 - (r.prs.length));
+    const groupedByType = Object.groupBy(data, ({ type }) => type);
+    for (const group of Object.values(groupedByType)) {
+      group.sort((a, b) => b.prs.length - a.prs.length);
     }
     this.aggregates = groupedByType;
     return groupedByType;

package/lib/ci/run_ci.js

@@ -38,7 +38,7 @@ export class RunPRJob {
     try {
       const { crumb } = await this.request.json(CI_CRUMB_URL);
       return crumb;
-    } catch (e) {
+    } catch {
       return false;
     }
   }

package/lib/cli.js

@@ -94,6 +94,16 @@ export default class CLI {
     return answer;
   }
 
+  async promptRadio(message, choices, opts = undefined) {
+    if (Object.hasOwn(opts, 'defaultAnswer')) {
+      opts.default = opts.defaultAnswer;
+    }
+    return inquirer.select({
+      ...opts,
+      message, choices,
+    });
+  }
+
   async promptCheckbox(message, choices) {
     if (this.assumeYes) {
       return choices.filter((c) => c.checked).map((c) => c.value);
@@ -102,6 +112,20 @@ export default class CLI {
     return inquirer.checkbox({ message, choices });
   }
 
+  async promptSelect(message, choices, opts = {}) {
+    const defaultAnswer = opts.defaultAnswer ?? choices[0]?.value;
+
+    if (this.assumeYes) {
+      return defaultAnswer;
+    }
+
+    return inquirer.select({
+      message,
+      choices,
+      default: defaultAnswer
+    });
+  }
+
   setAssumeYes() {
     this.assumeYes = true;
   }
@@ -193,7 +217,7 @@ export default class CLI {
   setExitCode(statusCode) {
     process.exitCode = statusCode;
   }
-};
+}
 
 CLI.SPINNER_STATUS = SPINNER_STATUS;
 CLI.QUESTION_TYPE = QUESTION_TYPE;

package/lib/config.js

@@ -40,7 +40,7 @@ export function getMergedConfig(dir, home, additional) {
       ...Object.getOwnPropertyDescriptors(additional),
     })
     : mergedConfig;
-};
+}
 export function clearCachedConfig() {
   mergedConfig = null;
 }
@@ -117,7 +117,7 @@ export function getConfig(configType, dir, raw = false) {
   } catch (cause) {
     throw new Error('Unable to parse config file ' + configPath, { cause });
   }
-};
+}
 
 function getConfigPath(configType, dir) {
   switch (configType) {
@@ -135,7 +135,7 @@ function getConfigPath(configType, dir) {
     default:
       throw Error('Invalid configType');
   }
-};
+}
 
 function writeConfig(configType, obj, dir) {
   const configPath = getConfigPath(configType, dir);
@@ -158,20 +158,20 @@ function writeConfig(configType, obj, dir) {
   }
   writeJson(configPath, obj);
   return configPath;
-};
+}
 
 export function updateConfig(configType, obj, dir) {
   const config = getConfig(configType, dir, true);
   writeConfig(configType, Object.assign(config, obj), dir);
-};
+}
 
 export function getHomeDir(home) {
   if (process.env.XDG_CONFIG_HOME) {
     return process.env.XDG_CONFIG_HOME;
   }
   return home || os.homedir();
-};
+}
 
 export function getNcuDir(dir) {
   return path.join(dir || process.cwd(), '.ncu');
-};
+}