@webpieces/dev-config 0.2.21 → 0.2.24

package/README.md

@@ -6,6 +6,7 @@ Development configuration, scripts, and patterns for WebPieces projects.
 
 This package provides shareable development tools for projects using the WebPieces framework:
 
+- **Nx Plugin** for automatic architecture validation and circular dependency checking
 - **Executable scripts** for common development tasks
 - **ESLint configuration** with WebPieces patterns and best practices
 - **Jest preset** for testing TypeScript projects
@@ -14,6 +15,14 @@ This package provides shareable development tools for projects using the WebPiec
 
 ## Installation
 
+For Nx workspaces (recommended):
+
+```bash
+nx add @webpieces/dev-config
+```
+
+For non-Nx projects:
+
 ```bash
 npm install --save-dev @webpieces/dev-config
 ```
@@ -73,7 +82,41 @@ To develop against a local copy of webpieces-ts:
    wp-use-published
    ```
 
-### 2. ESLint Configuration
+### 2. Nx Plugin (Architecture Validation)
+
+Automatically adds architecture validation and circular dependency checking to Nx workspaces.
+
+#### Quick Start
+
+```bash
+# Install and register the plugin
+nx add @webpieces/dev-config
+
+# Generate dependency graph
+nx run .:arch:generate
+
+# Validate architecture
+nx run .:arch:validate-no-cycles
+
+# Check project for circular dependencies
+nx run my-project:check-circular-deps
+```
+
+#### Available Targets
+
+**Workspace-level:**
+- `arch:generate` - Generate dependency graph
+- `arch:visualize` - Visualize dependency graph
+- `arch:validate-no-cycles` - Validate no circular dependencies
+- `arch:validate-no-skiplevel-deps` - Validate no redundant dependencies
+- `arch:validate-architecture-unchanged` - Validate against blessed graph
+
+**Per-project:**
+- `check-circular-deps` - Check for circular dependencies (auto-added to all projects)
+
+For detailed documentation, see [Plugin README](./plugin/README.md).
+
+### 3. ESLint Configuration
 
 Import the base configuration in your `eslint.config.mjs`:
 

package/generators/init/generator.ts

@@ -0,0 +1,240 @@
+import { formatFiles, readNxJson, Tree, updateNxJson, updateJson, addDependenciesToPackageJson } from '@nx/devkit';
+import type { InitGeneratorSchema } from './schema';
+
+/**
+ * Init generator for @webpieces/dev-config
+ *
+ * Automatically runs when users execute: nx add @webpieces/dev-config
+ *
+ * Responsibilities:
+ * - Registers the plugin in nx.json
+ * - Creates architecture/ directory if needed
+ * - Adds madge as a devDependency (required for circular dep checking)
+ * - Adds convenient npm scripts to package.json
+ * - Always creates eslint.webpieces.config.mjs with @webpieces rules
+ * - Creates eslint.config.mjs (if not exists) that imports eslint.webpieces.config.mjs
+ * - If eslint.config.mjs exists, shows user how to import eslint.webpieces.config.mjs
+ * - Provides helpful output about available targets
+ */
+export default async function initGenerator(tree: Tree, options: InitGeneratorSchema) {
+    registerPlugin(tree);
+    const installTask = addMadgeDependency(tree);
+    createArchitectureDirectory(tree);
+    addNpmScripts(tree);
+    createEslintConfig(tree);
+
+    if (!options.skipFormat) {
+        await formatFiles(tree);
+    }
+
+    return createSuccessCallback(installTask);
+}
+
+function registerPlugin(tree: Tree): void {
+    const nxJson = readNxJson(tree);
+    if (!nxJson) {
+        throw new Error('Could not read nx.json. Are you in an Nx workspace?');
+    }
+
+    if (!nxJson.plugins) {
+        nxJson.plugins = [];
+    }
+
+    const pluginName = '@webpieces/dev-config';
+    const alreadyRegistered = nxJson.plugins.some(
+        (p) => typeof p === 'string' ? p === pluginName : p.plugin === pluginName
+    );
+
+    if (!alreadyRegistered) {
+        nxJson.plugins.push(pluginName);
+        updateNxJson(tree, nxJson);
+        console.log(`✅ Registered ${pluginName} plugin in nx.json`);
+    } else {
+        console.log(`ℹ️  ${pluginName} plugin is already registered`);
+    }
+}
+
+function addMadgeDependency(tree: Tree) {
+    return addDependenciesToPackageJson(tree, {}, { 'madge': '^8.0.0' });
+}
+
+function createArchitectureDirectory(tree: Tree): void {
+    if (!tree.exists('architecture')) {
+        tree.write('architecture/.gitkeep', '');
+        console.log('✅ Created architecture/ directory');
+    }
+}
+
+function addNpmScripts(tree: Tree): void {
+    updateJson(tree, 'package.json', (pkgJson) => {
+        pkgJson.scripts = pkgJson.scripts ?? {};
+
+        // Add architecture validation scripts
+        pkgJson.scripts['arch:generate'] = 'nx run .:arch:generate';
+        pkgJson.scripts['arch:visualize'] = 'nx run .:arch:visualize';
+        pkgJson.scripts['arch:validate'] = 'nx run .:arch:validate-no-cycles && nx run .:arch:validate-no-skiplevel-deps';
+        pkgJson.scripts['arch:validate-all'] = 'nx run .:arch:validate-no-cycles && nx run .:arch:validate-no-skiplevel-deps && nx run .:arch:validate-architecture-unchanged';
+
+        // Add circular dependency checking scripts
+        pkgJson.scripts['arch:check-circular'] = 'nx run-many --target=check-circular-deps --all';
+        pkgJson.scripts['arch:check-circular-affected'] = 'nx affected --target=check-circular-deps';
+
+        // Complete validation including circular deps
+        pkgJson.scripts['arch:validate-complete'] = 'npm run arch:validate-all && npm run arch:check-circular';
+
+        return pkgJson;
+    });
+
+    console.log('✅ Added npm scripts for architecture validation and circular dependency checking');
+}
+
+function createEslintConfig(tree: Tree): void {
+    const webpiecesConfigPath = 'eslint.webpieces.config.mjs';
+    const mainConfigPath = 'eslint.config.mjs';
+
+    // Always create eslint.webpieces.config.mjs with our rules
+    createWebpiecesEslintConfig(tree, webpiecesConfigPath);
+
+    // Check if main eslint.config.mjs exists
+    if (tree.exists(mainConfigPath)) {
+        // Existing config - show them how to import
+        console.log('');
+        console.log('📋 Existing eslint.config.mjs detected');
+        console.log('');
+        console.log('To use @webpieces/dev-config ESLint rules, add this import to your eslint.config.mjs:');
+        console.log('');
+        console.log('  import webpiecesConfig from \'./eslint.webpieces.config.mjs\';');
+        console.log('');
+        console.log('Then spread it into your config array:');
+        console.log('');
+        console.log('  export default [');
+        console.log('    ...webpiecesConfig,  // Add this line');
+        console.log('    // ... your existing config');
+        console.log('  ];');
+        console.log('');
+    } else {
+        // No existing config - create one that imports webpieces config
+        const mainConfig = `// ESLint configuration
+// Imports @webpieces/dev-config rules
+
+import webpiecesConfig from './eslint.webpieces.config.mjs';
+
+// Export the webpieces configuration
+// You can add your own rules after spreading webpiecesConfig
+export default [
+    ...webpiecesConfig,
+    // Add your custom ESLint configuration here
+];
+`;
+
+        tree.write(mainConfigPath, mainConfig);
+        console.log('✅ Created eslint.config.mjs with @webpieces/dev-config rules');
+    }
+}
+
+function createWebpiecesEslintConfig(tree: Tree, configPath: string): void {
+    const webpiecesConfig = `// @webpieces/dev-config ESLint rules
+// This file contains the ESLint configuration provided by @webpieces/dev-config
+// You can modify or remove rules as needed for your project
+
+import webpiecesPlugin from '@webpieces/dev-config/eslint-plugin';
+import tseslint from '@typescript-eslint/eslint-plugin';
+import tsparser from '@typescript-eslint/parser';
+
+export default [
+    {
+        ignores: ['**/dist', '**/node_modules', '**/coverage', '**/.nx'],
+    },
+    {
+        files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
+        plugins: {
+            '@webpieces': webpiecesPlugin,
+            '@typescript-eslint': tseslint,
+        },
+        languageOptions: {
+            parser: tsparser,
+            ecmaVersion: 2021,
+            sourceType: 'module',
+        },
+        rules: {
+            // WebPieces custom rules
+            '@webpieces/catch-error-pattern': 'error',
+            '@webpieces/no-unmanaged-exceptions': 'error',
+            '@webpieces/max-method-lines': ['error', { max: 70 }],
+            '@webpieces/max-file-lines': ['error', { max: 700 }],
+            '@webpieces/enforce-architecture': 'error',
+
+            // TypeScript rules
+            '@typescript-eslint/no-explicit-any': 'off',
+            '@typescript-eslint/explicit-function-return-type': 'off',
+            '@typescript-eslint/no-unused-vars': 'off',
+            '@typescript-eslint/no-empty-interface': 'off',
+            '@typescript-eslint/no-empty-function': 'off',
+
+            // General code quality
+            'no-console': 'off',
+            'no-debugger': 'off',
+            'no-var': 'error',
+            'prefer-const': 'off',
+        },
+    },
+    {
+        // Test files - relaxed rules
+        files: ['**/*.spec.ts', '**/*.test.ts'],
+        rules: {
+            '@typescript-eslint/no-explicit-any': 'off',
+            '@typescript-eslint/no-non-null-assertion': 'off',
+            '@webpieces/max-method-lines': 'off',
+        },
+    },
+];
+`;
+
+    tree.write(configPath, webpiecesConfig);
+    console.log('✅ Created eslint.webpieces.config.mjs with @webpieces/dev-config rules');
+}
+
+function createSuccessCallback(installTask: ReturnType<typeof addDependenciesToPackageJson>) {
+    return async () => {
+        await installTask();
+        console.log('✅ Added madge to devDependencies');
+        console.log('');
+        console.log('✅ @webpieces/dev-config plugin initialized!');
+        console.log('');
+        printAvailableTargets();
+    };
+}
+
+function printAvailableTargets(): void {
+    console.log('📝 Available npm scripts (convenient shortcuts):');
+    console.log('');
+    console.log('  Architecture graph:');
+    console.log('    npm run arch:generate                  # Generate dependency graph');
+    console.log('    npm run arch:visualize                 # Visualize dependency graph');
+    console.log('');
+    console.log('  Validation:');
+    console.log('    npm run arch:validate                  # Quick validation (no-cycles + no-skiplevel-deps)');
+    console.log('    npm run arch:validate-all              # Full arch validation (+ unchanged check)');
+    console.log('    npm run arch:check-circular            # Check all projects for circular deps');
+    console.log('    npm run arch:check-circular-affected   # Check affected projects only');
+    console.log('    npm run arch:validate-complete         # Complete validation (arch + circular)');
+    console.log('');
+    console.log('📝 Available Nx targets:');
+    console.log('');
+    console.log('  Workspace-level architecture validation:');
+    console.log('    nx run .:arch:generate                         # Generate dependency graph');
+    console.log('    nx run .:arch:visualize                        # Visualize dependency graph');
+    console.log('    nx run .:arch:validate-no-cycles               # Check for circular dependencies');
+    console.log('    nx run .:arch:validate-no-skiplevel-deps       # Check for redundant dependencies');
+    console.log('    nx run .:arch:validate-architecture-unchanged  # Validate against blessed graph');
+    console.log('');
+    console.log('  Per-project circular dependency checking:');
+    console.log('    nx run <project>:check-circular-deps           # Check project for circular deps');
+    console.log('    nx affected --target=check-circular-deps       # Check all affected projects');
+    console.log('    nx run-many --target=check-circular-deps --all # Check all projects');
+    console.log('');
+    console.log('💡 Quick start:');
+    console.log('   npm run arch:generate           # Generate the graph first');
+    console.log('   npm run arch:validate-complete  # Run complete validation');
+    console.log('');
+}

package/generators/init/schema.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "InitGenerator",
+  "title": "Initialize @webpieces/dev-config",
+  "description": "Initialize @webpieces/dev-config plugin in an Nx workspace",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files with Prettier",
+      "default": false
+    }
+  },
+  "required": []
+}

package/generators.json

@@ -0,0 +1,10 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "generators": {
+        "init": {
+            "factory": "./generators/init/generator",
+            "schema": "./generators/init/schema.json",
+            "description": "Initialize @webpieces/dev-config in an Nx workspace"
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/dev-config",
-  "version": "0.2.21",
+  "version": "0.2.24",
   "description": "Development configuration, scripts, and patterns for WebPieces projects",
   "type": "commonjs",
   "bin": {
@@ -12,6 +12,7 @@
     "wp-setup-patterns": "./bin/setup-claude-patterns.sh"
   },
   "executors": "./executors.json",
+  "generators": "./generators.json",
   "exports": {
     ".": "./index.js",
     "./package.json": "./package.json",
@@ -19,9 +20,11 @@
     "./eslint-plugin": "./eslint-plugin/index.js",
     "./jest": "./config/jest/preset.js",
     "./tsconfig": "./config/typescript/tsconfig.base.json",
+    "./plugin": "./plugin.js",
     "./plugins/circular-deps": "./plugins/circular-deps/index.js",
     "./architecture": "./architecture/index.js",
-    "./executors.json": "./executors.json"
+    "./executors.json": "./executors.json",
+    "./generators.json": "./generators.json"
   },
   "files": [
     "bin/**/*",
@@ -29,6 +32,10 @@
     "eslint-plugin/**/*",
     "patterns/**/*",
     "plugins/**/*",
+    "plugin/**/*",
+    "plugin.js",
+    "generators/**/*",
+    "generators.json",
     "architecture/**/*",
     "executors.json",
     "README.md"

package/plugin/README.md

@@ -0,0 +1,243 @@
+# @webpieces/dev-config Plugin
+
+Nx inference plugin that automatically provides architecture validation and circular dependency checking for your workspace.
+
+## Features
+
+### Workspace-Level Architecture Validation
+
+Automatically adds targets for managing and validating your project architecture:
+
+- **`arch:generate`** - Generate dependency graph from project.json files
+- **`arch:visualize`** - Create visual representations of the dependency graph
+- **`arch:validate-no-cycles`** - Validate the architecture has no circular dependencies
+- **`arch:validate-no-skiplevel-deps`** - Validate no redundant transitive dependencies
+- **`arch:validate-architecture-unchanged`** - Validate against blessed dependency graph
+
+### Per-Project Circular Dependency Checking
+
+Automatically adds a `check-circular-deps` target to every project with a `src/` directory using [madge](https://github.com/pahen/madge).
+
+## Installation
+
+Add the plugin to your Nx workspace:
+
+```bash
+nx add @webpieces/dev-config
+```
+
+This automatically:
+- Registers the plugin in `nx.json`
+- Adds `madge` as a devDependency (required for circular dependency checking)
+- Creates the `architecture/` directory
+- Adds convenient npm scripts to `package.json`
+- Creates `eslint.webpieces.config.mjs` with @webpieces ESLint rules
+- Creates `eslint.config.mjs` (if you don't have one) that imports the webpieces rules
+- If you already have `eslint.config.mjs`, shows you how to import the webpieces rules (one line)
+- Makes all targets immediately available
+
+**For new projects: Zero configuration needed!** All architecture validation, circular dependency checking, and ESLint rules are active.
+
+**For existing projects with ESLint:** Just add one import line shown during installation to enable the @webpieces ESLint rules.
+
+## Usage
+
+### Convenient npm Scripts
+
+The init generator adds these npm scripts for easy access:
+
+```bash
+# Generate and visualize
+npm run arch:generate     # Generate dependency graph
+npm run arch:visualize    # Visualize in browser
+
+# Validation
+npm run arch:validate                  # Quick: no-cycles + no-skiplevel-deps
+npm run arch:validate-all              # Full: adds architecture-unchanged check
+npm run arch:check-circular            # Check all projects for circular deps (madge)
+npm run arch:check-circular-affected   # Check only affected projects
+npm run arch:validate-complete         # Complete: all validations + circular deps
+
+# Recommended workflow
+npm run arch:generate           # 1. Generate graph first
+npm run arch:validate-complete  # 2. Run all validations
+```
+
+### Direct Nx Targets
+
+You can also run targets directly with Nx:
+
+```bash
+# Generate the dependency graph
+nx run .:arch:generate
+
+# Visualize the graph in your browser
+nx run .:arch:visualize
+
+# Validate no circular dependencies
+nx run .:arch:validate-no-cycles
+
+# Validate against blessed graph (for CI)
+nx run .:arch:validate-architecture-unchanged
+
+# Check for redundant dependencies
+nx run .:arch:validate-no-skiplevel-deps
+```
+
+### Per-Project Circular Dependency Checking
+
+```bash
+# Check a specific project
+nx run my-project:check-circular-deps
+
+# Check all affected projects
+nx affected --target=check-circular-deps
+
+# Check all projects
+nx run-many --target=check-circular-deps --all
+```
+
+## Configuration
+
+Configure the plugin in `nx.json`:
+
+```json
+{
+  "plugins": [
+    {
+      "plugin": "@webpieces/dev-config",
+      "options": {
+        "circularDeps": {
+          "enabled": true,
+          "targetName": "check-circular-deps",
+          "excludePatterns": ["**/test-fixtures/**"]
+        },
+        "workspace": {
+          "enabled": true,
+          "targetPrefix": "arch:",
+          "validations": {
+            "noCycles": true,
+            "noSkipLevelDeps": true,
+            "architectureUnchanged": true
+          },
+          "features": {
+            "generate": true,
+            "visualize": true
+          }
+        }
+      }
+    }
+  ]
+}
+```
+
+### Configuration Options
+
+#### `circularDeps`
+
+- **`enabled`** (boolean, default: `true`) - Enable/disable circular dependency checking
+- **`targetName`** (string, default: `'check-circular-deps'`) - Name of the target to create
+- **`excludePatterns`** (string[], default: `[]`) - Patterns to exclude from checking
+
+#### `workspace`
+
+- **`enabled`** (boolean, default: `true`) - Enable/disable workspace-level validation
+- **`targetPrefix`** (string, default: `'arch:'`) - Prefix for workspace target names
+- **`graphPath`** (string, default: `'architecture/dependencies.json'`) - Path to dependency graph file
+
+##### `workspace.validations`
+
+- **`noCycles`** (boolean, default: `true`) - Enable no-cycles validation
+- **`noSkipLevelDeps`** (boolean, default: `true`) - Enable skip-level deps validation
+- **`architectureUnchanged`** (boolean, default: `true`) - Enable unchanged graph validation
+
+##### `workspace.features`
+
+- **`generate`** (boolean, default: `true`) - Enable graph generation target
+- **`visualize`** (boolean, default: `true`) - Enable visualization target
+
+## Examples
+
+### Disable Architecture Validation, Keep Circular Deps
+
+```json
+{
+  "plugin": "@webpieces/dev-config",
+  "options": {
+    "workspace": { "enabled": false }
+  }
+}
+```
+
+### Disable Circular Deps, Keep Architecture Validation
+
+```json
+{
+  "plugin": "@webpieces/dev-config",
+  "options": {
+    "circularDeps": { "enabled": false }
+  }
+}
+```
+
+### Disable Specific Validations
+
+```json
+{
+  "plugin": "@webpieces/dev-config",
+  "options": {
+    "workspace": {
+      "validations": {
+        "architectureUnchanged": false,
+        "noSkipLevelDeps": false
+      }
+    }
+  }
+}
+```
+
+### Exclude Test Fixtures from Circular Deps
+
+```json
+{
+  "plugin": "@webpieces/dev-config",
+  "options": {
+    "circularDeps": {
+      "excludePatterns": ["**/test-fixtures/**", "**/__tests__/**"]
+    }
+  }
+}
+```
+
+### Custom Target Names
+
+```json
+{
+  "plugin": "@webpieces/dev-config",
+  "options": {
+    "circularDeps": { "targetName": "circular-check" },
+    "workspace": { "targetPrefix": "architecture:" }
+  }
+}
+```
+
+## How It Works
+
+The plugin uses Nx's [Project Crystal (Inferred Tasks)](https://nx.dev/concepts/inferred-tasks) feature via the `createNodesV2` API to automatically detect and configure targets:
+
+1. **Workspace Detection**: Looks for a `project.json` at the workspace root to add architecture targets
+2. **Project Detection**: Scans all projects for `src/` directories to add circular-deps targets
+3. **Pattern Matching**: Respects exclude patterns for fine-grained control
+
+## Requirements
+
+- Nx >= 18.0.0
+- Node.js >= 18.0.0
+- [Graphviz](https://graphviz.org/) (for visualization)
+- [madge](https://github.com/pahen/madge) (bundled, used for circular dep checking)
+
+## Related Documentation
+
+- [Nx Inferred Tasks](https://nx.dev/concepts/inferred-tasks)
+- [Architecture Validation Guide](../../architecture/README.md)
+- [ESLint Plugin](../eslint-plugin/README.md)

package/plugin/index.ts

@@ -0,0 +1,4 @@
+/**
+ * Re-export plugin from parent directory for clean imports
+ */
+export * from '../plugin';

package/plugins/circular-deps/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Circular Dependencies Plugin
- *
- * Nx inference plugin that automatically adds check-circular-deps target
- * to all projects with a src/ directory.
- */
-export * from './plugin';
-export { default } from './plugin';

package/plugins/circular-deps/index.js

@@ -1,14 +0,0 @@
-"use strict";
-/**
- * Circular Dependencies Plugin
- *
- * Nx inference plugin that automatically adds check-circular-deps target
- * to all projects with a src/ directory.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./plugin"), exports);
-var plugin_1 = require("./plugin");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return tslib_1.__importDefault(plugin_1).default; } });
-//# sourceMappingURL=index.js.map

package/plugins/circular-deps/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../packages/tooling/dev-config/plugins/circular-deps/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;;AAEH,mDAAyB;AACzB,mCAAmC;AAA1B,0HAAA,OAAO,OAAA","sourcesContent":["/**\n * Circular Dependencies Plugin\n *\n * Nx inference plugin that automatically adds check-circular-deps target\n * to all projects with a src/ directory.\n */\n\nexport * from './plugin';\nexport { default } from './plugin';\n"]}

package/plugins/circular-deps/index.ts

@@ -1,9 +0,0 @@
-/**
- * Circular Dependencies Plugin
- *
- * Nx inference plugin that automatically adds check-circular-deps target
- * to all projects with a src/ directory.
- */
-
-export * from './plugin';
-export { default } from './plugin';

package/plugins/circular-deps/plugin.d.ts

@@ -1,32 +0,0 @@
-/**
- * Nx Inference Plugin for Circular Dependency Checking
- *
- * This plugin automatically creates a "check-circular-deps" target for ANY project
- * that has a src/ directory, similar to how @nx/eslint/plugin creates lint targets.
- *
- * Benefits:
- * - Zero configuration per project
- * - Works for ALL projects (services + libraries)
- * - New projects automatically get the target
- * - `nx affected --target=check-circular-deps` works on everything
- *
- * Usage:
- * Add to nx.json plugins array:
- * {
- *   "plugins": ["@webpieces/dev-config/plugins/circular-deps"]
- * }
- *
- * Then run:
- * - nx run <project>:check-circular-deps
- * - nx affected --target=check-circular-deps
- */
-import type { CreateNodesV2 } from '@nx/devkit';
-/**
- * Nx V2 Inference Plugin
- * Matches project.json files and creates check-circular-deps target
- */
-export declare const createNodesV2: CreateNodesV2;
-declare const _default: {
-    createNodesV2: CreateNodesV2;
-};
-export default _default;

package/plugins/circular-deps/plugin.js

@@ -1,73 +0,0 @@
-"use strict";
-/**
- * Nx Inference Plugin for Circular Dependency Checking
- *
- * This plugin automatically creates a "check-circular-deps" target for ANY project
- * that has a src/ directory, similar to how @nx/eslint/plugin creates lint targets.
- *
- * Benefits:
- * - Zero configuration per project
- * - Works for ALL projects (services + libraries)
- * - New projects automatically get the target
- * - `nx affected --target=check-circular-deps` works on everything
- *
- * Usage:
- * Add to nx.json plugins array:
- * {
- *   "plugins": ["@webpieces/dev-config/plugins/circular-deps"]
- * }
- *
- * Then run:
- * - nx run <project>:check-circular-deps
- * - nx affected --target=check-circular-deps
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodesV2 = void 0;
-const path_1 = require("path");
-const fs_1 = require("fs");
-/**
- * Nx V2 Inference Plugin
- * Matches project.json files and creates check-circular-deps target
- */
-exports.createNodesV2 = [
-    // Pattern to match: look for project.json files
-    '**/project.json',
-    // Inference function
-    async (projectFiles, _options, context) => {
-        const results = [];
-        for (const projectFile of projectFiles) {
-            const projectRoot = (0, path_1.dirname)(projectFile);
-            const srcDir = (0, path_1.join)(context.workspaceRoot, projectRoot, 'src');
-            // Only create target if project has a src/ directory
-            if ((0, fs_1.existsSync)(srcDir)) {
-                const checkCircularDepsTarget = {
-                    executor: 'nx:run-commands',
-                    cache: true,
-                    inputs: ['default'],
-                    outputs: [],
-                    options: {
-                        command: 'npx madge --circular --extensions ts,tsx src',
-                        cwd: projectRoot,
-                    },
-                    metadata: {
-                        technologies: ['madge'],
-                        description: 'Check for circular dependencies using madge',
-                    },
-                };
-                const result = {
-                    projects: {
-                        [projectRoot]: {
-                            targets: {
-                                'check-circular-deps': checkCircularDepsTarget,
-                            },
-                        },
-                    },
-                };
-                results.push([projectFile, result]);
-            }
-        }
-        return results;
-    },
-];
-exports.default = { createNodesV2: exports.createNodesV2 };
-//# sourceMappingURL=plugin.js.map

package/plugins/circular-deps/plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../../../../../packages/tooling/dev-config/plugins/circular-deps/plugin.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;AAEH,+BAAqC;AACrC,2BAAgC;AAGhC;;;GAGG;AACU,QAAA,aAAa,GAAkB;IACxC,gDAAgD;IAChD,iBAAiB;IAEjB,qBAAqB;IACrB,KAAK,EACD,YAA+B,EAC/B,QAAiB,EACjB,OAA6B,EACD,EAAE;QAC9B,MAAM,OAAO,GAAgD,EAAE,CAAC;QAEhE,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;YACrC,MAAM,WAAW,GAAG,IAAA,cAAO,EAAC,WAAW,CAAC,CAAC;YACzC,MAAM,MAAM,GAAG,IAAA,WAAI,EAAC,OAAO,CAAC,aAAa,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;YAE/D,qDAAqD;YACrD,IAAI,IAAA,eAAU,EAAC,MAAM,CAAC,EAAE,CAAC;gBACrB,MAAM,uBAAuB,GAAG;oBAC5B,QAAQ,EAAE,iBAAiB;oBAC3B,KAAK,EAAE,IAAI;oBACX,MAAM,EAAE,CAAC,SAAS,CAAC;oBACnB,OAAO,EAAE,EAAc;oBACvB,OAAO,EAAE;wBACL,OAAO,EAAE,8CAA8C;wBACvD,GAAG,EAAE,WAAW;qBACnB;oBACD,QAAQ,EAAE;wBACN,YAAY,EAAE,CAAC,OAAO,CAAC;wBACvB,WAAW,EAAE,6CAA6C;qBAC7D;iBACJ,CAAC;gBAEF,MAAM,MAAM,GAAsB;oBAC9B,QAAQ,EAAE;wBACN,CAAC,WAAW,CAAC,EAAE;4BACX,OAAO,EAAE;gCACL,qBAAqB,EAAE,uBAAuB;6BACjD;yBACJ;qBACJ;iBACJ,CAAC;gBAEF,OAAO,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,MAAM,CAAU,CAAC,CAAC;YACjD,CAAC;QACL,CAAC;QAED,OAAO,OAAO,CAAC;IACnB,CAAC;CACJ,CAAC;AAEF,kBAAe,EAAE,aAAa,EAAb,qBAAa,EAAE,CAAC","sourcesContent":["/**\n * Nx Inference Plugin for Circular Dependency Checking\n *\n * This plugin automatically creates a \"check-circular-deps\" target for ANY project\n * that has a src/ directory, similar to how @nx/eslint/plugin creates lint targets.\n *\n * Benefits:\n * - Zero configuration per project\n * - Works for ALL projects (services + libraries)\n * - New projects automatically get the target\n * - `nx affected --target=check-circular-deps` works on everything\n *\n * Usage:\n * Add to nx.json plugins array:\n * {\n *   \"plugins\": [\"@webpieces/dev-config/plugins/circular-deps\"]\n * }\n *\n * Then run:\n * - nx run <project>:check-circular-deps\n * - nx affected --target=check-circular-deps\n */\n\nimport { dirname, join } from 'path';\nimport { existsSync } from 'fs';\nimport type { CreateNodesV2, CreateNodesContextV2, CreateNodesResultV2, CreateNodesResult } from '@nx/devkit';\n\n/**\n * Nx V2 Inference Plugin\n * Matches project.json files and creates check-circular-deps target\n */\nexport const createNodesV2: CreateNodesV2 = [\n    // Pattern to match: look for project.json files\n    '**/project.json',\n\n    // Inference function\n    async (\n        projectFiles: readonly string[],\n        _options: unknown,\n        context: CreateNodesContextV2\n    ): Promise<CreateNodesResultV2> => {\n        const results: Array<readonly [string, CreateNodesResult]> = [];\n\n        for (const projectFile of projectFiles) {\n            const projectRoot = dirname(projectFile);\n            const srcDir = join(context.workspaceRoot, projectRoot, 'src');\n\n            // Only create target if project has a src/ directory\n            if (existsSync(srcDir)) {\n                const checkCircularDepsTarget = {\n                    executor: 'nx:run-commands',\n                    cache: true,\n                    inputs: ['default'],\n                    outputs: [] as string[],\n                    options: {\n                        command: 'npx madge --circular --extensions ts,tsx src',\n                        cwd: projectRoot,\n                    },\n                    metadata: {\n                        technologies: ['madge'],\n                        description: 'Check for circular dependencies using madge',\n                    },\n                };\n\n                const result: CreateNodesResult = {\n                    projects: {\n                        [projectRoot]: {\n                            targets: {\n                                'check-circular-deps': checkCircularDepsTarget,\n                            },\n                        },\n                    },\n                };\n\n                results.push([projectFile, result] as const);\n            }\n        }\n\n        return results;\n    },\n];\n\nexport default { createNodesV2 };\n"]}

package/plugins/circular-deps/plugin.ts

@@ -1,83 +0,0 @@
-/**
- * Nx Inference Plugin for Circular Dependency Checking
- *
- * This plugin automatically creates a "check-circular-deps" target for ANY project
- * that has a src/ directory, similar to how @nx/eslint/plugin creates lint targets.
- *
- * Benefits:
- * - Zero configuration per project
- * - Works for ALL projects (services + libraries)
- * - New projects automatically get the target
- * - `nx affected --target=check-circular-deps` works on everything
- *
- * Usage:
- * Add to nx.json plugins array:
- * {
- *   "plugins": ["@webpieces/dev-config/plugins/circular-deps"]
- * }
- *
- * Then run:
- * - nx run <project>:check-circular-deps
- * - nx affected --target=check-circular-deps
- */
-
-import { dirname, join } from 'path';
-import { existsSync } from 'fs';
-import type { CreateNodesV2, CreateNodesContextV2, CreateNodesResultV2, CreateNodesResult } from '@nx/devkit';
-
-/**
- * Nx V2 Inference Plugin
- * Matches project.json files and creates check-circular-deps target
- */
-export const createNodesV2: CreateNodesV2 = [
-    // Pattern to match: look for project.json files
-    '**/project.json',
-
-    // Inference function
-    async (
-        projectFiles: readonly string[],
-        _options: unknown,
-        context: CreateNodesContextV2
-    ): Promise<CreateNodesResultV2> => {
-        const results: Array<readonly [string, CreateNodesResult]> = [];
-
-        for (const projectFile of projectFiles) {
-            const projectRoot = dirname(projectFile);
-            const srcDir = join(context.workspaceRoot, projectRoot, 'src');
-
-            // Only create target if project has a src/ directory
-            if (existsSync(srcDir)) {
-                const checkCircularDepsTarget = {
-                    executor: 'nx:run-commands',
-                    cache: true,
-                    inputs: ['default'],
-                    outputs: [] as string[],
-                    options: {
-                        command: 'npx madge --circular --extensions ts,tsx src',
-                        cwd: projectRoot,
-                    },
-                    metadata: {
-                        technologies: ['madge'],
-                        description: 'Check for circular dependencies using madge',
-                    },
-                };
-
-                const result: CreateNodesResult = {
-                    projects: {
-                        [projectRoot]: {
-                            targets: {
-                                'check-circular-deps': checkCircularDepsTarget,
-                            },
-                        },
-                    },
-                };
-
-                results.push([projectFile, result] as const);
-            }
-        }
-
-        return results;
-    },
-];
-
-export default { createNodesV2 };