Encourages programming with assertions by providing tools to compile them away.

See: "unassert - encourage reliable programming by writing assertions in production" -- talk at NodeFest 2015, and "One more thing..." in talk at NodeFest 2016, titled "From Library to Tool - power-assert as a General Purpose Assertion Enhancement Tool"

• unassertify: Browserify transform for unassert
• babel-plugin-unassert: Babel plugin for unassert
• webpack-unassert-loader: Webpack loader for unassert
• gulp-unassert: Gulp plugin for unassert
• unassert-cli: CLI for unassert
• rollup-plugin-unassert: RollupJS plugin for unassert

$ npm install --save-dev unassert

For given math.js below,

const assert = require('node:assert');

function add (a, b) {
  assert(typeof a === 'number');
  console.assert(!isNaN(a));
  assert.equal(typeof b, 'number');
  assert.ok(!isNaN(b));
  return a + b;
}

Apply unassertAst then generate modified code to console.

via CJS code

const { unassertAst } = require('unassert');
const { parse } = require('acorn');
const { generate } = require('escodegen');
const { readFileSync } = require('node:fs');
const { join, dirname } = require('node:path');

const filepath = join(__dirname, 'math.js');
const ast = parse(readFileSync(filepath), { ecmaVersion: '2022' });
const modifiedAst = unassertAst(ast);

console.log(generate(modifiedAst));

or via ESM code

import { unassertAst } from 'unassert';
import { parse } from 'acorn';
import { generate } from 'escodegen';
import { readFileSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
const __dirname = dirname(fileURLToPath(import.meta.url));

const filepath = join(__dirname, 'math.js');
const ast = parse(readFileSync(filepath), { ecmaVersion: '2022' });
const modifiedAst = unassertAst(ast);

console.log(generate(modifiedAst));

Then you will see assert calls disappear.

function add(a, b) {
  return a + b;
}

unassert package exports three functions. unassertAst is the main function. createVisitor and defaultOptions are for customization.

const { unassertAst } = require('unassert')

import { unassertAst } from 'unassert'

Remove assertion calls from ast (ECMAScript AST). Default behaviour can be customized by options. ast is manipulated directly so returned modifiedAst will be the same instance of ast.

Object for configuration options. passed options is Object.assigned with default options. If not passed, default options will be used.

Target module names for assertion call removal.

For example, the default target modules are as follows.

{
  modules: [
    'assert',
    'assert/strict',
    'node:assert',
    'node:assert/strict'
  ]

In this case, unassert will remove assert variable declarations such as,

• import assert from "assert"
• import assert from "assert/strict"
• import assert from "node:assert"
• import assert from "node:assert/strict"
• import * as assert from "assert"
• import * as assert from "node:assert"
• import * as assert from "assert/strict"
• import * as assert from "node:assert/strict"
• import { strict as assert } from "assert"
• import { strict as assert } from "node:assert"
• import { default as assert } from "assert"
• import { default as assert } from "node:assert"
• const assert = require("assert")
• const assert = require("node:assert")
• const assert = require("assert/strict")
• const assert = require("node:assert/strict")
• const assert = require("assert").strict
• const assert = require("node:assert").strict
• const { strict: assert } = require("assert")
• const { strict: assert } = require("node:assert")

and assignments.

• assert = require("assert")
• assert = require("node:assert")
• assert = require("assert/strict")
• assert = require("node:assert/strict")
• assert = require("assert").strict
• assert = require("node:assert").strict

In this default case, unassert will remove assertion calls such as,

• assert(value, [message])
• assert.ok(value, [message])
• assert.equal(actual, expected, [message])
• assert.notEqual(actual, expected, [message])
• assert.strictEqual(actual, expected, [message])
• assert.notStrictEqual(actual, expected, [message])
• assert.deepEqual(actual, expected, [message])
• assert.notDeepEqual(actual, expected, [message])
• assert.deepStrictEqual(actual, expected, [message])
• assert.notDeepStrictEqual(actual, expected, [message])
• assert.match(string, regexp[, message])
• assert.doesNotMatch(string, regexp[, message])
• assert.throws(block, [error], [message])
• assert.doesNotThrow(block, [message])
• await assert.rejects(asyncFn, [error], [message])
• await assert.doesNotReject(asyncFn, [error], [message])
• assert.fail([message])
• assert.fail(actual, expected, message, operator)
• assert.ifError(value)

in addition, unassert removes console.assert calls as well.

• console.assert(value, [message])

unassert automatically removes assertion calls based on their imported variable names.

So if import declaration is as follows,

• import strictAssert, { ok, equal as eq } from 'node:assert/strict';

unassert removes all strictAssert, ok, eq calls.

Please see customization example for more details.

const { createVisitor } = require('unassert')

import { createVisitor } from 'unassert'

Create visitor object to be used with estraverse.replace. Visitor can be customized by options.

const { defaultOptions } = require('unassert')

import { defaultOptions } from 'unassert'

Returns default options object for unassertAst and createVisitor function. In other words, returns

{
  modules: [
    'assert',
    'assert/strict',
    'node:assert',
    'node:assert/strict'
  ]
}

You can customize options such as target module names.

{
  modules: [
    'node:assert',
    'node:assert/strict',
    'power-assert',
    'invariant',
    'nanoassert',
    'uvu/assert'
  ]
}

For given custom.js below,

import invariant from 'invariant';
import nassert from 'nanoassert';
import * as uvuassert from 'uvu/assert';
import { strict as powerAssert } from 'power-assert';
import { default as looseAssert } from 'node:assert';
import strictAssert, { ok, equal as eq } from 'node:assert/strict';

async function add (a, b) {
  strictAssert(!isNaN(a));
  looseAssert(typeof a === 'number');
  eq(typeof b, 'number');
  ok(!isNaN(b));
  powerAssert(typeof a === typeof b);

  nassert(!isNaN(a));

  uvuassert.is(Math.sqrt(4), 2);
  uvuassert.is(Math.sqrt(144), 12);
  uvuassert.is(Math.sqrt(2), Math.SQRT2);

  invariant(someTruthyVal, 'This will not throw');
  invariant(someFalseyVal, 'This will throw an error with this message');

  await strictAssert.rejects(prms);
  await strictAssert.doesNotReject(prms2);

  return a + b;
}

Apply unassertAst with customized options then generate modified code to console.

import { unassertAst } from 'unassert';
import { parse } from 'acorn';
import { generate } from 'escodegen';
import { readFileSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
const __dirname = dirname(fileURLToPath(import.meta.url));

const filepath = join(__dirname, 'custom.js');
const ast = parse(readFileSync(filepath), { ecmaVersion: '2022' });
const modifiedAst = unassertAst(ast, {
  modules: [
    'node:assert',
    'node:assert/strict',
    'power-assert',
    'invariant',
    'nanoassert',
    'uvu/assert'
  ]
});

console.log(generate(modifiedAst));

Then you will see all assert calls disappear.

async function add(a, b) {
  return a + b;
}

We support Node under maintenance. In other words, we stop supporting old Node version when their maintenance ends.

This means that any other environment is not supported.

NOTE: If unassert works in any of the unsupported environments, it is purely coincidental and has no bearing on future compatibility. Use at your own risk.

• Takuto Wada

• Renée Kooi
• Jordan Harband

Licensed under the MIT license.