tessl/npm-nx--eslint-plugin

ESLint plugin for Nx monorepos with boundary enforcement and dependency management rules.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Dependency Management

Name: tessl/npm-nx--eslint-plugin
Author: tessl

The dependency-checks rule validates package.json dependencies against actual code usage, ensuring dependency declarations stay synchronized with implementation requirements across the workspace.

Capabilities

Dependency Checks Rule

Analyzes project files to detect missing dependencies, obsolete packages, and version mismatches in package.json files.

/**
 * ESLint rule that validates package.json dependencies against actual usage
 * Rule name: "@nx/dependency-checks"
 */
interface DependencyChecksRule {
  name: "dependency-checks";
  meta: {
    type: "suggestion";
    docs: {
      description: "Checks dependencies in project's package.json for version mismatches";
    };
    fixable: "code";
    schema: [DependencyChecksOptions];
    messages: Record<MessageIds, string>;
  };
  defaultOptions: [DependencyChecksOptions];
  create: (context: RuleContext) => RuleListener;
}

Configuration Options

Complete configuration interface for dependency validation behavior.

interface DependencyChecksOptions {
  /** Build target names used to determine production vs development dependencies */
  buildTargets?: string[];
  
  /** Check for dependencies used in code but missing from package.json */
  checkMissingDependencies?: boolean;
  
  /** Check for dependencies in package.json that are not used in code */
  checkObsoleteDependencies?: boolean;
  
  /** Check for version mismatches between declared and installed versions */
  checkVersionMismatches?: boolean;
  
  /** Package names to ignore during dependency checks */
  ignoredDependencies?: string[];
  
  /** File patterns to exclude from dependency analysis */
  ignoredFiles?: string[];
  
  /** Include transitive dependencies in the analysis */
  includeTransitiveDependencies?: boolean;
  
  /** Use local workspace paths instead of npm versions for workspace dependencies */
  useLocalPathsForWorkspaceDependencies?: boolean;
  
  /** Runtime helper packages that should be treated specially */
  runtimeHelpers?: string[];
}

Default Configuration

The rule comes with sensible defaults for most Nx workspaces.

const DEFAULT_OPTIONS: DependencyChecksOptions = {
  buildTargets: ['build'],
  checkMissingDependencies: true,
  checkObsoleteDependencies: true, 
  checkVersionMismatches: true,
  ignoredDependencies: [],
  ignoredFiles: [],
  includeTransitiveDependencies: false,
  useLocalPathsForWorkspaceDependencies: false,
  runtimeHelpers: []
};

Error Messages

All possible validation messages returned by the rule.

type MessageIds =
  | "missingDependency"
  | "obsoleteDependency" 
  | "versionMismatch"
  | "missingDependencySection";

interface ErrorMessages {
  missingDependency: string; // 'The "{{projectName}}" project uses the following packages, but they are missing from "{{section}}":{{packageNames}}'
  obsoleteDependency: string; // 'The "{{packageName}}" package is not used by "{{projectName}}" project.'
  versionMismatch: string; // 'The version specifier does not contain the installed version of "{{packageName}}" package: {{version}}.'
  missingDependencySection: string; // 'Dependency sections are missing from the "package.json" but following dependencies were detected:{{dependencies}}'
}

Usage Examples:

// Basic dependency checking
{
  rules: {
    "@nx/dependency-checks": [
      "error",
      {
        checkMissingDependencies: true,
        checkObsoleteDependencies: true,
        checkVersionMismatches: true
      }
    ]
  }
}

// Ignore specific packages and files
{
  rules: {
    "@nx/dependency-checks": [
      "error",
      {
        ignoredDependencies: [
          "@types/node", // Type definitions
          "nx", // Workspace tooling
          "typescript" // Build tooling
        ],
        ignoredFiles: [
          "**/*.spec.ts", // Test files
          "**/*.stories.ts", // Storybook files
          "**/jest.config.ts" // Config files
        ]
      }
    ]
  }
}

// Custom build targets and workspace handling
{
  rules: {
    "@nx/dependency-checks": [
      "error",
      {
        buildTargets: ["build", "build-prod", "compile"],
        useLocalPathsForWorkspaceDependencies: true,
        includeTransitiveDependencies: false,
        runtimeHelpers: ["tslib", "@babel/runtime"]
      }
    ]
  }
}

// Development vs production dependency checking
{
  rules: {
    "@nx/dependency-checks": [
      "error",
      {
        buildTargets: ["build"],
        // Will check that runtime dependencies are in dependencies
        // and build-time dependencies are in devDependencies
        checkMissingDependencies: true
      }
    ]
  }
}

Validation Behaviors

The rule performs several types of dependency analysis:

Missing Dependency Detection: Identifies imports and requires not declared in package.json
Obsolete Dependency Detection: Finds declared dependencies that aren't used in the codebase
Version Mismatch Detection: Compares declared versions with installed versions
Dependency Section Validation: Ensures dependencies are in the correct section (dependencies vs devDependencies)
Transitive Dependency Analysis: Optionally includes transitive dependencies in checks
Workspace Integration: Handles workspace dependencies with local paths

Build Target Integration

The rule uses build targets to determine dependency placement:

Runtime Dependencies: Required during build execution (goes in dependencies)
Build Dependencies: Only needed during build process (goes in devDependencies)
Test Dependencies: Only needed for testing (goes in devDependencies)

File Analysis Patterns

The rule analyzes various import patterns:

// ES6 imports
import { something } from 'package-name';
import * as pkg from 'package-name';
import pkg from 'package-name';

// CommonJS requires  
const pkg = require('package-name');
const { something } = require('package-name');

// Dynamic imports
const pkg = await import('package-name');

// Type-only imports (TypeScript)
import type { SomeType } from 'package-name';