Installed-check-core NPM

Checks that the installed modules fulfill the requirements of package.json, both when it comes to the version ranges of the modules themselves and when it comes to the version range of their engine requirements.

Exists as a CLI as well: installed-check

Usage

import { installedCheck } from 'installed-check-core';

const { errors, suggestions } = await installedCheck(['version']);

if (result.errors.length) {
  console.error('Dependency errors: \n\n' + result.errors.join('\n') + '\n');
}
if (result.suggestions.length) {
  console.error('Suggestions: \n\n' + result.suggestions.join('\n') + '\n');
}

In CommonJS using dynamic `import()` expression

const { installedCheck } = await import('installed-check-core');

API

checkVersionRange()

The rich version range check that installed-check itself uses.

Syntax

checkVersionRange(pkg, key, installed, [options]) => VersionRangeResult

Arguments

pkg: Type PackageJsonLike – the content of the package.json file to check
key: Type string – the key of the version range to check, eg engines.node
installed: Type InstalledDependencies – the package.json files of the installed dependencies
options: Type VersionRangeOptions – optional options

Types

type VersionRangeItem = {
  valid: boolean | undefined,
  suggested?: string | undefined,
  note: string | undefined,
}
type VersionRangeResult = VersionRangeItem & {
  packageNotes: Array<
    VersionRangeItem & { name: string }
  >
}

Options

expectedInDependencies = false – a warning will be issued when the key is empty or not found in a dependency
noDev = false – dev dependencies won't be included in the check
ignore = string[]|((test: string) => boolean) – names of modules to exclude from checks or a function that returns true for those that should be ignores (the latter handy for supporting eg. glob patterns)
strict = false – converts most warnings into failures.

Example

import { checkVersionRange } from 'installed-check-core';
import { listInstalled } from 'list-installed';
import { readPackage } from 'read-pkg';

const cwd = '.';

const [pkg, installed] = await Promise.all([
  readPackage({ cwd }),
  listInstalled(cwd),
]);

const result = await checkVersionRange(
  pkg,
  'engines.node',
  installed,
  {
    expectedInDependencies: true,
    noDev: true,
    ignore: ['example'],
    strict: true,
  }
);

for (const item of result.packageNotes) {
  if (item.note) {
    console.log(`${item.valid === false ? 'Error' : 'Warning'} in ${item.name}: ${item.note}`);
  }
}

if (result.note) {
  console.log(`${result.valid === false ? 'Error' : 'Warning'}: ${result.note}`);
}

if (result.valid === true) {
  console.log('All good!');
} else if (result.suggested) {
  console.log('Combined engines.node needs to be narrower:', result.suggested);
} else {
  console.log('Incompatible combined engines.node requirements.');
}

checkVersionRangeCollection()

Wrapper around as checkVersionRange() that differs from it in three ways:

key is for a collection of range, eg engines rather than engines.node
The results for every individual version range is returned in an object keyed with the full key for that range, eg: { 'engines.node': ... }
Accepts an additional optional defaultKeys option that's used if the collection for key is empty. Eg: { defaultKeys: ['node'] }

Syntax

checkVersionRangeCollection(pkg, key, installed, [options]) => VersionRangeCollectionResult

Arguments

See main description of checkVersionRangeCollection() and full docs for checkVersionRange().

installedCheck()

The full on installed-check experience, returning error and warning strings only.

Syntax

installedCheck(checks, [lookupOptions], [options]) => Promise<InstalledCheckResult>

Arguments

checks: Type InstalledChecks[] – the checks to run, an array of one or more of: 'engine', 'peer', 'version'
lookupOptions: Type LookupOptions – optional – defaults to cwd='.' and includeWorkspaceRoot: true
options: Type InstalledCheckOptions – optional

Types

type LookupOptions = {
  cwd?: string | undefined;
  ignorePaths?: string[] | undefined;
  includeWorkspaceRoot?: boolean | undefined;
  skipWorkspaces?: boolean | undefined;
  workspace?: string[] | undefined;
};
type InstalledChecks = 'engine' | 'peer' | 'version'
type InstalledCheckOptions = {
  fix?: boolean | undefined;
  ignore?: string[] | undefined;
  noDev?: boolean | undefined;
  prefix?: string | undefined;
  strict?: boolean | undefined;
};
type InstalledCheckResult = {
  errors: string[],
  warnings: string[],
  suggestions: string[],
}

Checks

engine – will check that the installed modules comply with the engines requirements of the package.json and suggest an alternative requirement if the installed modules don't comply.
peer – like engine but for peerDependencies instead. Will check that the promised peerDependencies are not wider than those of ones required dependencies.
version – will check that the installed modules comply with the version requirements set for them the package.json.

Lookup options

The same as from read-workspaces / list-installed

Options

fix = false – when set it will modify the package.json files to apply fixes whenever possible
ignores = string[] – names of modules to exclude from checks. Supports picomatch globbing syntax, eg. @types/*. (Not supported by version checks)
noDev = false – exclude devDependencies from checks. devDependencies that are also in peerDependencies will not be ignored. (Not supported by version checks)
strict = false – converts most warnings into failures

Example

import { installedCheck } from 'installed-check-core';

const { errors, warnings, suggestions } = await installedCheck(['engine', 'version'], {
  cwd: 'path/to/module',
  ignore: ['foo'],
  noDev: true,
});

performInstalledCheck()

Similar to installedCheck() but expects to be given package data instead of looking it up itself..

Syntax

performInstalledCheck(checks, pkg, installed, options) => Promise<PerformInstalledCheckResult>

Arguments

checks: Type InstalledChecks[] – same as for installedCheck()
pkg: Type PackageJsonLike – the content of the package.json file to check
installed: Type InstalledDependencies – the package.json files of the installed dependencies
options: Type InstalledCheckOptions – same as for installedCheck(), but without the cwd option

Types

PackageJsonLike

// Subset of import('type-fest').PackageJson / import('read-pkg').NormalizedPackageJson
export type PackageJsonLike = {
  name?:    string | undefined;
  version?: string | undefined;
  engines?:              Record<string, string | undefined>;
  dependencies?:         Record<string, string | undefined>;
  devDependencies?:      Record<string, string | undefined>;
  optionalDependencies?: Record<string, string | undefined>;
  peerDependencies?:     Record<string, string | undefined>;
};

InstalledDependencies

// A map is allowed since that's what import('list-installed).listInstalled returns
export type InstalledDependencies = Map<string, PackageJsonLike> | Record<string, PackageJsonLike>;

Used by

Used by the installed-check CLI tool
- ...and eg. pretty much all of my (@voxpelli's) node.js projects uses the installed-check CLI tool
Find more on GitHub or npm