@plugjs/plug 0.0.16 → 0.0.17

package/src/assert.ts

@@ -2,46 +2,32 @@
  * BUILD FAILURES                                                             *
  * ========================================================================== */
 
-const buildError = Symbol.for('plugjs:buildError')
-const buildFailure = Symbol.for('plugjs:buildFailure')
+import { BuildFailure } from './failure'
 
-/** Check if the specified argument is a {@link BuildError} */
-export function isBuildError(arg: any): arg is BuildError {
-  return arg && arg[buildError] === buildError
-}
+/** Await and assert that all specified promises were fulfilled */
+export async function assertPromises<T>(promises: (T | Promise<T>)[], message: string): Promise<T[]> {
+  // Await for the settlement of all the promises
+  const settlements = await Promise.allSettled(promises)
 
-/** Check if the specified argument is a {@link BuildFailure} */
-export function isBuildFailure(arg: any): arg is BuildFailure {
-  return arg && arg[buildFailure] === buildFailure
-}
+  // Separate the good from the bad...
+  const results: T[] = []
+  const failures = new Set<any>()
 
-/** An error produced in our build, with proper inspection for logging */
-export class BuildError extends Error {
-  constructor(message: string) {
-    super(message)
-    Object.defineProperty(this, buildError, { value: buildError })
-  }
-}
+  settlements.forEach((settlement) => {
+    if (settlement.status === 'fulfilled') {
+      results.push(settlement.value)
+    } else {
+      failures.add(settlement.reason)
+    }
+  })
+
+  // Check for errors and report/fail if anything happened
+  if (failures.size) throw new BuildFailure(message, [ ...failures ])
 
-/** A {@link BuildFailure} represents an error _already logged_ in our build. */
-export class BuildFailure extends Error {
-  constructor() {
-    super('Build Failure')
-    Object.defineProperty(this, buildFailure, { value: buildFailure })
-  }
+  return results
 }
 
 /** Asserts something as _truthy_ and fail the build if not */
 export function assert(assertion: any, message: string): asserts assertion {
-  if (! assertion) throw new BuildError(message)
-}
-
-/** Throw a {@link BuildError} (an {@link Error} printed nicely) */
-export function fail(message: string): never {
-  throw new BuildError(message)
-}
-
-/** Return a non-logged {@link BuildFailure} */
-export function failure(): BuildFailure {
-  return new BuildFailure()
+  if (! assertion) throw new BuildFailure(message)
 }

package/src/async.ts

@@ -1,6 +1,6 @@
+import type { Context } from './pipe'
+
 import { AsyncLocalStorage } from 'node:async_hooks'
-import { assert } from './assert'
-import { Context } from './pipe'
 
 /* ========================================================================== *
  * EXPORTED                                                                   *
@@ -39,7 +39,7 @@ export function currentContext(): Context | undefined {
  */
 export function requireContext(): Context {
   const context = storage.getStore()
-  assert(context, 'Unable to retrieve current context')
+  if (! context) throw new Error('Unable to retrieve current context')
   return context
 }
 

package/src/failure.ts

@@ -0,0 +1,31 @@
+/** A symbol marking {@link BuildFailure} instances */
+const buildFailure = Symbol.for('plugjs:buildFailure')
+
+/** Check if the specified argument is a {@link BuildFailure} */
+export function isBuildFailure(arg: any): arg is BuildFailure {
+  return arg && arg[buildFailure] === buildFailure
+}
+
+/** A {@link BuildFailure} represents an error _already logged_ in our build. */
+export class BuildFailure extends Error {
+  readonly errors: readonly any[]
+  logged: boolean
+
+  /** Construct a {@link BuildFailure} that was already _logged_ (internal) */
+  constructor(options: { logged: true })
+  /** Construct a {@link BuildFailure} with a detail message */
+  constructor(message: string, errors?: any[])
+  // Constructor overload implementation
+  constructor(options: string | { logged: boolean } = 'Build Failure', errors: any[] = []) {
+    const { logged, message } =
+      typeof options === 'string' ?
+        { message: options, logged: false } :
+        { message: 'Build Failure', ...options }
+
+    super(message)
+    Error.captureStackTrace(this, BuildFailure)
+    Object.defineProperty(this, 'buildFailure', { value: buildFailure })
+    this.errors = errors.filter((e) => ! (isBuildFailure(e) && e.logged))
+    this.logged = logged
+  }
+}

package/src/fork.ts

@@ -1,10 +1,11 @@
 import { fork } from 'node:child_process'
-import { assert, failure } from './assert'
+import { assert } from './assert'
 import { runAsync } from './async'
+import { BuildFailure } from './failure'
 import { Files } from './files'
 import { $gry, $p, LogOptions, logOptions } from './log'
 import { AbsolutePath, requireFilename, resolveFile } from './paths'
-import { Plug, PlugResult, Context } from './pipe'
+import { Context, install, Plug, PlugName, PlugResult } from './pipe'
 
 /** Fork data, from parent to child process */
 export interface ForkData {
@@ -88,7 +89,7 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
 
       child.on('error', (error) => {
         context.log.error('Child process error', error)
-        return done || reject(failure())
+        return done || reject(new BuildFailure({ logged: true }))
       })
 
       child.on('message', (message: ForkResult) => {
@@ -99,16 +100,16 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
       child.on('exit', (code, signal) => {
         if (signal) {
           context.log.error(`Child process exited with signal ${signal}`, $gry(`(pid=${child.pid})`))
-          return done || reject(failure())
+          return done || reject(new BuildFailure({ logged: true }))
         } else if (code !== 0) {
           context.log.error(`Child process exited with code ${code}`, $gry(`(pid=${child.pid})`))
-          return done || reject(failure())
+          return done || reject(new BuildFailure({ logged: true }))
         } else if (! result) {
           context.log.error('Child process exited with no result', $gry(`(pid=${child.pid})`))
-          return done || reject(failure())
+          return done || reject(new BuildFailure({ logged: true }))
         } else if (result.failed) {
           // definitely logged on the child side
-          return done || reject(failure())
+          return done || reject(new BuildFailure({ logged: true }))
         }
 
         /* We definitely have a successful result! */
@@ -122,16 +123,16 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
         const result = child.send(message, (error) => {
           if (error) {
             context.log.error('Error sending message to child process (callback failure)', error)
-            reject(failure())
+            reject(new BuildFailure({ logged: true }))
           }
         })
         if (! result) {
           context.log.error('Error sending message to child process (send returned false)')
-          reject(failure())
+          reject(new BuildFailure({ logged: true }))
         }
       } catch (error) {
         context.log.error('Error sending message to child process (exception caught)', error)
-        reject(failure())
+        reject(new BuildFailure({ logged: true }))
       }
     }).finally(() => done = true)
   }
@@ -223,3 +224,35 @@ if ((process.argv[1] === requireFilename(__fileurl)) && (process.send)) {
     })
   })
 }
+
+/**
+ * Install a _forking_ {@link Plug} in the {@link Pipe}, in other words
+ * execute the plug in a separate process.
+ *
+ * As a contract, if the _last non-null_ parameter of the constructor is an
+ * object and contains the key `coverageDir`, the process will be forked with
+ * the approptiately resolved `NODE_V8_COVERAGE` environment variable.
+ *
+ * Also, forking plugs require some special attention:
+ *
+ * * plug functions are not supported, only classes implementing the
+ *   {@link Plug} interface can be used with this.
+ *
+ * * the class itself _MUST_ be exported as the _default_ export for the
+ *   `scriptFile` specified below. This is to simplify interoperability between
+ *   CommonJS and ESM modules as we use dynamic `import(...)` statements.
+ */
+export function installForking<Name extends PlugName>(
+    plugName: Name,
+    scriptFile: AbsolutePath,
+): void {
+  /** Extend out our ForkingPlug below */
+  const ctor = class extends ForkingPlug {
+    constructor(...args: any[]) {
+      super(scriptFile, args)
+    }
+  }
+
+  /** Install the plug in  */
+  install(plugName, ctor as any)
+}

package/src/helpers.ts

@@ -31,7 +31,7 @@ export function find(...args: ParseOptions<FindOptions>): Pipe {
   const { params: globs, options } = parseOptions(args, {})
 
   const context = requireContext()
-  return new Pipe(context, async (): Promise<Files> => {
+  return new Pipe(context, Promise.resolve().then(async () => {
     const directory = options.directory ?
       context.resolve(options.directory) :
       getCurrentWorkingDirectory()
@@ -42,7 +42,7 @@ export function find(...args: ParseOptions<FindOptions>): Pipe {
     }
 
     return builder.build()
-  })
+  }))
 }
 
 /**

package/src/index.ts

@@ -2,14 +2,15 @@
 
 export type { AbsolutePath } from './paths'
 export type { Files, FilesBuilder } from './files'
+
+export { BuildFailure } from './failure'
 export { Pipe } from './pipe'
 
 // Our minimal exports
 export * from './assert'
 export * from './build'
+export * from './fork'
 export * from './helpers'
 export * from './log'
-
-// PlugJS types
 export * from './plugs'
 export * from './types'

package/src/log/logger.ts

@@ -1,4 +1,4 @@
-import { isBuildError, isBuildFailure } from '../assert'
+import { BuildFailure, isBuildFailure } from '../failure'
 import { emitColor, emitPlain, LogEmitter } from './emit'
 import { DEBUG, ERROR, INFO, LogLevel, NOTICE, TRACE, WARN } from './levels'
 import { logOptions } from './options'
@@ -34,6 +34,8 @@ export interface Log {
   warn(...args: [ any, ...any ]): this
   /** Log an `ERROR` message */
   error(...args: [ any, ...any ]): this
+  /** Log an `ERROR` message and fail the build */
+  fail(...args: [ any, ...any ]): never
 }
 
 /** A {@link Logger} extends the basic {@link Log} adding some state. */
@@ -83,9 +85,18 @@ class LoggerImpl implements Logger {
   private _emit(level: LogLevel, args: [ any, ...any ]): this {
     if (this._level > level) return this
 
-    // Filter out build failures (they are not to be logged)
-    const params = args.filter((arg) => ! isBuildFailure(arg))
-    if (params.length === 0) return this // no logging only build failures
+    // Filter out build failures that were already logged
+    const params = args.filter((arg) => {
+      if (isBuildFailure(arg)) {
+        if (arg.logged) return false // already logged? skip!
+        return arg.logged = true // set logged to true and log!
+      } else {
+        return true
+      }
+    })
+
+    // If there's nothing left to log, then we're done
+    if (params.length === 0) return this
 
     // Prepare our options for logging
     const options = { level, taskName: this._task, indent: this._indent }
@@ -98,18 +109,8 @@ class LoggerImpl implements Logger {
       this._stack.splice(0)
     }
 
-    // Print all `BuildError`s _before_ any other entry
-    const remaining = params.filter((arg) => {
-      if (isBuildError(arg)) {
-        this._emitter({ ...options, level: ERROR }, [ arg.message ])
-        return false
-      } else {
-        return true
-      }
-    })
-
-    // If we have any leftovers, dump them out, too!
-    if (remaining) this._emitter(options, remaining)
+    // Emit our log lines and return
+    this._emitter(options, params)
     return this
   }
 
@@ -145,6 +146,11 @@ class LoggerImpl implements Logger {
     return this._emit(ERROR, args)
   }
 
+  fail(...args: [ any, ...any ]): never {
+    this._emit(ERROR, args)
+    throw new BuildFailure({ logged: true })
+  }
+
   enter(): this
   enter(level: LogLevel, message: string): this
   enter(...args: [] | [ level: LogLevel, message: string ]): this {

package/src/log/report.ts

@@ -1,4 +1,4 @@
-import { fail, failure } from '../assert'
+import { BuildFailure } from '../failure'
 import { AbsolutePath } from '../paths'
 import { readFile } from '../utils/asyncfs'
 import { $blu, $cyn, $gry, $red, $und, $wht, $ylw } from './colors'
@@ -191,7 +191,11 @@ export class ReportImpl implements Report {
             [ ...record.message.map((msg) => msg.split('\n')).flat(1) ] :
             record.message.split('\n')
       messages = messages.filter((message) => !! message)
-      if (! messages.length) fail('No message for report record')
+      if (! messages.length) {
+        const options = { taskName: this._task, level: ERROR }
+        this._emitter(options, [ 'No message for report record' ])
+        throw new BuildFailure({ logged: true })
+      }
 
       const level = record.level
       const file = record.file
@@ -263,7 +267,7 @@ export class ReportImpl implements Report {
   done(showSources?: boolean | undefined): void {
     if (showSources == null) showSources = logOptions.showSources
     if (! this.empty) this._emit(showSources)
-    if (this.errors) throw failure()
+    if (this.errors) throw new BuildFailure({ logged: true })
   }
 
   private _emit(showSources: boolean): this {

package/src/log.ts

@@ -58,6 +58,10 @@ export const log: LogFunction = ((): LogFunction => {
       logger().error(...args)
       return wrapper
     },
+
+    fail(...args: [ any, ...any ]): never {
+      throw logger().fail(...args) // fail() returns never but ?!?!?!?!?
+    },
   }
 
   /* Create a function that will default logging to "NOTICE" */

package/src/pipe.ts

@@ -7,11 +7,11 @@ import {
 } from './paths'
 
 import { sep } from 'path'
-import { assert } from './assert'
+import { assert, assertPromises } from './assert'
 import { requireContext } from './async'
 import { Files } from './files'
-import { ForkingPlug } from './fork'
 import { getLogger, Logger } from './log'
+import { Result } from './types'
 
 /* ========================================================================== *
  * PLUGS                                                                      *
@@ -86,6 +86,25 @@ export class Context {
  * PIPES                                                                      *
  * ========================================================================== */
 
+/**
+ * In pipe chains, we want to keep track of the _leaf_ `Files` promises (that
+ * is, when a derived pipe is created calling `plug` we want to track only the
+ * new, derived, promise).
+ *
+ * We key these _leaf_ promises by _context_ (with a WeakMap), and those will
+ * be awaited at the end of the task.
+ */
+const contextPromises = new WeakMap<Context, Set<Promise<Result>>>()
+
+export function getContextPromises(context: Context): Set<Promise<Result>> {
+  let promises = contextPromises.get(context)
+  if (! promises) {
+    promises = new Set<Promise<Files>>()
+    contextPromises.set(context, promises)
+  }
+  return promises
+}
+
 /**
  * A class that will be extended by {@link Pipe} where {@link install} will
  * add prototype properties from installed {@link Plug}s
@@ -98,14 +117,63 @@ abstract class PipeProto {
  * The {@link Pipe} class defines processing pipeline where multiple
  * {@link Plug}s can transform lists of {@link Files}.
  */
-export class Pipe extends PipeProto {
+export class Pipe extends PipeProto implements Promise<Files> {
+  readonly [Symbol.toStringTag] = 'Pipe'
+
   constructor(
       private readonly _context: Context,
-      private readonly _run: () => Promise<Files>,
+      private readonly _promise: Promise<Result>,
   ) {
     super()
+
+    // New "Pipe", remember the promise!
+    getContextPromises(_context).add(_promise)
+  }
+
+  /* ------------------------------------------------------------------------ *
+   * Promise implementation                                                   *
+   * ------------------------------------------------------------------------ *
+   * From a _types_ point of view, the `Pipe` implements a `Promise<Files>`   *
+   * (because only when plugging the correct `Plug` the correct value are     *
+   * returned).                                                               *
+   *                                                                          *
+   * Whether to return (as a type) another `Pipe` or a `Promise<undefined>`   *
+   * is determined by the type of the `plug` parameter below.                 *
+   *                                                                          *
+   * That said, in practice, a `Pipe` implements `Promise<Files | undefined>` *
+   * because the result of the plug is _eventually_ computed asynchronously   *
+   * while `plug` returns immediately.
+   *                                                                          *
+   * So, all those "as whatever" below are kind-of-legit...                   *
+   * ------------------------------------------------------------------------ */
+
+  then<R1 = Files, R2 = never>(
+      onfulfilled?: ((value: Files) => R1 | PromiseLike<R1>) | null | undefined,
+      onrejected?: ((reason: any) => R2 | PromiseLike<R2>) | null | undefined,
+  ): Promise<R1 | R2> {
+    // We are delegating the handling of this promise to the caller
+    getContextPromises(this._context).delete(this._promise)
+    return this._promise.then(onfulfilled as (value: Result) => R1 | PromiseLike<R1>, onrejected)
+  }
+
+  catch<R = never>(
+      onrejected?: ((reason: any) => R | PromiseLike<R>) | null | undefined,
+  ): Promise<Files | R> {
+    // We are delegating the handling of this promise to the caller
+    getContextPromises(this._context).delete(this._promise)
+    return this._promise.catch(onrejected) as Promise<Files | R>
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<Files> {
+    // We are delegating the handling of this promise to the caller
+    getContextPromises(this._context).delete(this._promise)
+    return this._promise.finally(onfinally) as Promise<Files>
   }
 
+  /* ------------------------------------------------------------------------ *
+   * Pipe implementation                                                      *
+   * ------------------------------------------------------------------------ */
+
   plug(plug: Plug<Files>): Pipe
   plug(plug: PlugFunction<Files>): Pipe
   plug(plug: Plug<void | undefined>): Promise<undefined>
@@ -113,18 +181,15 @@ export class Pipe extends PipeProto {
   plug(arg: Plug<PlugResult> | PlugFunction<PlugResult>): Pipe | Promise<undefined> {
     const plug = typeof arg === 'function' ? { pipe: arg } : arg
 
-    const parent = this
-    const context = this._context
-    return new Pipe(context, async (): Promise<Files> => {
-      const previous = await parent.run()
-      const current = await plug.pipe(previous, context)
-      assert(current, 'Unable to extend pipe')
-      return current
-    })
-  }
+    // We are creating a new "leaf" Pipe, we can forget our promise
+    getContextPromises(this._context).delete(this._promise)
 
-  run(): Promise<Files> {
-    return this._run()
+    // Create and return the new Pipe
+    return new Pipe(this._context, this._promise.then(async (result) => {
+      assert(result, 'Unable to extend pipe')
+      const result2 = await plug.pipe(result, this._context)
+      return result2 || undefined
+    }))
   }
 
   /**
@@ -137,8 +202,6 @@ export class Pipe extends PipeProto {
    *
    * ```
    * const pipe: Pipe = merge([
-   *   // other tasks return `Pipe & Promise<Files>` so we can
-   *   // direcrly await their result without invoking `run()`
    *   await this.anotherTask1(),
    *   await this.anotherTask2(),
    * ])
@@ -146,20 +209,20 @@ export class Pipe extends PipeProto {
    */
   static merge(pipes: (Pipe | Files | Promise<Files>)[]): Pipe {
     const context = requireContext()
-    return new Pipe(context, async (): Promise<Files> => {
+    return new Pipe(context, Promise.resolve().then(async () => {
+      // No pipes? Just send off an empty pipe...
       if (pipes.length === 0) return Files.builder(getCurrentWorkingDirectory()).build()
 
-      const [ first, ...other ] = await Promise.all(pipes.map((pipe) => {
-        return 'run' in pipe ? pipe.run() : pipe
-      }))
-
-      const firstDir = first.directory
-      const otherDirs = other.map((f) => f.directory)
+      // Await for all pipes / files / files promises
+      const results = await assertPromises<Files>(pipes, 'Error in pipe while merging')
 
+      // Find the common directory between all the Files instances
+      const [ firstDir, ...otherDirs ] = results.map((f) => f.directory)
       const directory = commonPath(firstDir, ...otherDirs)
 
-      return Files.builder(directory).merge(first, ...other).build()
-    })
+      // Build our new files instance merging all the results
+      return Files.builder(directory).merge(...results).build()
+    }))
   }
 }
 
@@ -168,7 +231,7 @@ export class Pipe extends PipeProto {
  * ========================================================================== */
 
 /** The names which can be installed as direct plugs. */
-export type PlugName = string & Exclude<keyof Pipe, 'plug' | 'run'>
+export type PlugName = string & Exclude<keyof Pipe, 'plug' | keyof Promise<any>>
 
 /** The parameters of the plug extension with the given name */
 export type PipeParameters<Name extends PlugName> = PipeOverloads<Name>['args']
@@ -282,35 +345,3 @@ export function install<
   /* Inject the create function in the Pipe's prototype */
   Object.defineProperty(PipeProto.prototype, name, { value: plug })
 }
-
-/**
- * Install a _forking_ {@link Plug} in the {@link Pipe}, in other words
- * execute the plug in a separate process.
- *
- * As a contract, if the _last non-null_ parameter of the constructor is an
- * object and contains the key `coverageDir`, the process will be forked with
- * the approptiately resolved `NODE_V8_COVERAGE` environment variable.
- *
- * Also, forking plugs require some special attention:
- *
- * * plug functions are not supported, only classes implementing the
- *   {@link Plug} interface can be used with this.
- *
- * * the class itself _MUST_ be exported as the _default_ export for the
- *   `scriptFile` specified below. This is to simplify interoperability between
- *   CommonJS and ESM modules as we use dynamic `import(...)` statements.
- */
-export function installForking<Name extends PlugName>(
-    plugName: Name,
-    scriptFile: AbsolutePath,
-): void {
-  /** Extend out our ForkingPlug below */
-  const ctor = class extends ForkingPlug {
-    constructor(...args: any[]) {
-      super(scriptFile, args)
-    }
-  } as unknown as PlugConstructor<Name>
-
-  /** Install the plug in  */
-  install(plugName, ctor)
-}

package/src/plugs/copy.ts

@@ -2,7 +2,7 @@ import { assert } from '../assert'
 import { Files } from '../files'
 import { $p } from '../log'
 import { assertAbsolutePath, getAbsoluteParent, resolveAbsolutePath } from '../paths'
-import { install, PipeParameters, Plug, Context } from '../pipe'
+import { Context, install, PipeParameters, Plug } from '../pipe'
 import { chmod, copyFile, fsConstants, mkdir } from '../utils/asyncfs'
 
 /** Options for copying files */

package/src/plugs/coverage/report.ts

@@ -10,7 +10,7 @@ import {
   isTSTypeReference,
   isTypeScript,
   Node,
-  VISITOR_KEYS
+  VISITOR_KEYS,
 } from '@babel/types'
 
 import { parse } from '@babel/parser'

package/src/plugs/coverage.ts

@@ -1,10 +1,9 @@
 import { html, initFunction } from '@plugjs/cov8-html'
 import { sep } from 'node:path'
-import { fail } from '../assert'
 import { Files } from '../files'
 import { $gry, $ms, $p, $red, $ylw, ERROR, NOTICE, WARN } from '../log'
 import { AbsolutePath, resolveAbsolutePath } from '../paths'
-import { install, PipeParameters, Plug, Context } from '../pipe'
+import { Context, install, PipeParameters, Plug } from '../pipe'
 import { walk } from '../utils/walk'
 import { createAnalyser, SourceMapBias } from './coverage/analysis'
 import { coverageReport, CoverageResult } from './coverage/report'
@@ -79,7 +78,7 @@ install('coverage', class Coverage implements Plug<Files | undefined> {
     }
 
     if (coverageFiles.length === 0) {
-      fail(`No coverage files found in ${$p(coverageDir)}`)
+      throw context.log.fail(`No coverage files found in ${$p(coverageDir)}`)
     }
 
     const sourceFiles = [ ...files.absolutePaths() ]

package/src/plugs/debug.ts

@@ -1,6 +1,6 @@
 import { Files } from '../files'
 import { $gry, $p, $und, $ylw } from '../log'
-import { install, Plug, Context, PipeParameters } from '../pipe'
+import { Context, install, PipeParameters, Plug } from '../pipe'
 
 declare module '../pipe' {
   export interface Pipe {

package/src/plugs/esbuild.ts

@@ -4,7 +4,7 @@ import { assert } from '../assert'
 import { Files, FilesBuilder } from '../files'
 import { $p, ERROR, Logger, ReportLevel, ReportRecord, WARN } from '../log'
 import { AbsolutePath, getAbsoluteParent, resolveAbsolutePath } from '../paths'
-import { install, PipeParameters, Plug, Context } from '../pipe'
+import { Context, install, PipeParameters, Plug } from '../pipe'
 import { readFile } from '../utils/asyncfs'
 
 export type ESBuildOptions = Omit<BuildOptions, 'absWorkingDir' | 'entryPoints' | 'watch'>

package/src/plugs/eslint/runner.ts

@@ -1,9 +1,10 @@
 import { ESLint as RealESLint } from 'eslint'
-import { assert, failure } from '../../assert'
+import { assert } from '../../assert'
+import { BuildFailure } from '../../failure'
 import { Files } from '../../files'
 import { $p, ERROR, NOTICE, WARN } from '../../log'
 import { getCurrentWorkingDirectory, resolveAbsolutePath, resolveDirectory, resolveFile } from '../../paths'
-import { PipeParameters, Plug, Context } from '../../pipe'
+import { Context, PipeParameters, Plug } from '../../pipe'
 import { readFile } from '../../utils/asyncfs'
 import { ESLintOptions } from '../eslint'
 
@@ -59,7 +60,7 @@ export default class ESLint implements Plug<void> {
 
     /* In case of failures from promises, fail! */
     const { results, failures } = summary
-    if (failures) throw failure() // already logged above
+    if (failures) throw new BuildFailure({ logged: true })
 
     /* Create our report */
     const report = context.log.report('ESLint Report')