@webpieces/dev-config 0.2.27 → 0.2.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/dev-config",
-  "version": "0.2.27",
+  "version": "0.2.28",
   "description": "Development configuration, scripts, and patterns for WebPieces projects",
   "type": "commonjs",
   "bin": {

package/plugin/index.d.ts

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

package/plugin/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * Re-export plugin from parent directory for clean imports
+ */
+tslib_1.__exportStar(require("../plugin"), exports);
+//# sourceMappingURL=index.js.map

package/plugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/tooling/dev-config/plugin/index.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,oDAA0B","sourcesContent":["/**\n * Re-export plugin from parent directory for clean imports\n */\nexport * from '../plugin';\n"]}

package/plugin.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * Unified Nx Inference Plugin for @webpieces/dev-config
+ *
+ * This plugin automatically creates targets for:
+ * 1. Workspace-level architecture validation (generate, visualize, validate-*)
+ * 2. Per-project circular dependency checking
+ *
+ * Install with: nx add @webpieces/dev-config
+ *
+ * Usage:
+ * Add to nx.json plugins array:
+ * {
+ *   "plugins": ["@webpieces/dev-config"]
+ * }
+ *
+ * Then all targets appear automatically without manual project.json configuration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodesV2 = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const DEFAULT_OPTIONS = {
+    circularDeps: {
+        enabled: true,
+        targetName: 'check-circular-deps',
+        excludePatterns: [],
+    },
+    workspace: {
+        enabled: true,
+        targetPrefix: 'arch:',
+        graphPath: 'architecture/dependencies.json',
+        validations: {
+            noCycles: true,
+            noSkipLevelDeps: true,
+            architectureUnchanged: true,
+        },
+        features: {
+            generate: true,
+            visualize: true,
+        },
+    },
+};
+function normalizeOptions(options) {
+    const circularDeps = {
+        ...DEFAULT_OPTIONS.circularDeps,
+        ...options?.circularDeps,
+    };
+    const workspace = {
+        ...DEFAULT_OPTIONS.workspace,
+        ...options?.workspace,
+        validations: {
+            ...DEFAULT_OPTIONS.workspace.validations,
+            ...options?.workspace?.validations,
+        },
+        features: {
+            ...DEFAULT_OPTIONS.workspace.features,
+            ...options?.workspace?.features,
+        },
+    };
+    return {
+        circularDeps,
+        workspace,
+    };
+}
+/**
+ * Nx V2 Inference Plugin
+ * Matches project.json files and creates architecture + circular-deps targets
+ */
+exports.createNodesV2 = [
+    // Pattern to match: look for project.json files
+    '**/project.json',
+    // Inference function
+    async (projectFiles, options, context) => {
+        const opts = normalizeOptions(options);
+        const results = [];
+        // Phase 1: Add workspace-level architecture targets to root
+        if (opts.workspace.enabled) {
+            const rootProject = projectFiles.find((f) => (0, path_1.dirname)(f) === '.');
+            if (rootProject) {
+                const workspaceTargets = createWorkspaceTargets(opts);
+                if (Object.keys(workspaceTargets).length > 0) {
+                    const result = {
+                        projects: {
+                            '.': {
+                                targets: workspaceTargets,
+                            },
+                        },
+                    };
+                    results.push([rootProject, result]);
+                }
+            }
+        }
+        // Phase 2: Add per-project circular-deps targets
+        if (opts.circularDeps.enabled) {
+            for (const projectFile of projectFiles) {
+                const projectRoot = (0, path_1.dirname)(projectFile);
+                // Skip workspace root (already handled)
+                if (projectRoot === '.')
+                    continue;
+                // Check exclude patterns
+                if (isExcluded(projectRoot, opts.circularDeps.excludePatterns)) {
+                    continue;
+                }
+                // Only create target if project has a src/ directory
+                const srcDir = (0, path_1.join)(context.workspaceRoot, projectRoot, 'src');
+                if ((0, fs_1.existsSync)(srcDir)) {
+                    const targetName = opts.circularDeps.targetName;
+                    const checkCircularDepsTarget = createCircularDepsTarget(projectRoot, targetName);
+                    const result = {
+                        projects: {
+                            [projectRoot]: {
+                                targets: {
+                                    [targetName]: checkCircularDepsTarget,
+                                },
+                            },
+                        },
+                    };
+                    results.push([projectFile, result]);
+                }
+            }
+        }
+        return results;
+    },
+];
+/**
+ * Create workspace-level architecture validation targets
+ */
+function createWorkspaceTargets(opts) {
+    const targets = {};
+    const prefix = opts.workspace.targetPrefix;
+    const graphPath = opts.workspace.graphPath;
+    // Add help target (always available)
+    targets[`${prefix}help`] = createHelpTarget();
+    if (opts.workspace.features.generate) {
+        targets[`${prefix}generate`] = createGenerateTarget(graphPath);
+    }
+    if (opts.workspace.features.visualize) {
+        targets[`${prefix}visualize`] = createVisualizeTarget(prefix, graphPath);
+    }
+    if (opts.workspace.validations.noCycles) {
+        targets[`${prefix}validate-no-cycles`] = createValidateNoCyclesTarget();
+    }
+    if (opts.workspace.validations.architectureUnchanged) {
+        targets[`${prefix}validate-architecture-unchanged`] = createValidateUnchangedTarget(graphPath);
+    }
+    if (opts.workspace.validations.noSkipLevelDeps) {
+        targets[`${prefix}validate-no-skiplevel-deps`] = createValidateNoSkipLevelTarget();
+    }
+    return targets;
+}
+function createGenerateTarget(graphPath) {
+    return {
+        executor: '@webpieces/dev-config:generate',
+        cache: true,
+        inputs: ['default'],
+        outputs: ['{workspaceRoot}/architecture/dependencies.json'],
+        options: { graphPath },
+        metadata: {
+            technologies: ['nx'],
+            description: 'Generate the architecture dependency graph from project.json files',
+        },
+    };
+}
+function createVisualizeTarget(prefix, graphPath) {
+    return {
+        executor: '@webpieces/dev-config:visualize',
+        dependsOn: [`${prefix}generate`],
+        options: { graphPath },
+        metadata: {
+            technologies: ['nx'],
+            description: 'Generate visual representations of the architecture graph',
+        },
+    };
+}
+function createValidateNoCyclesTarget() {
+    return {
+        executor: '@webpieces/dev-config:validate-no-cycles',
+        cache: true,
+        inputs: ['default'],
+        metadata: {
+            technologies: ['nx'],
+            description: 'Validate the architecture has no circular dependencies',
+        },
+    };
+}
+function createValidateUnchangedTarget(graphPath) {
+    return {
+        executor: '@webpieces/dev-config:validate-architecture-unchanged',
+        cache: true,
+        inputs: ['default', '{workspaceRoot}/architecture/dependencies.json'],
+        options: { graphPath },
+        metadata: {
+            technologies: ['nx'],
+            description: 'Validate the architecture matches the saved blessed graph',
+        },
+    };
+}
+function createValidateNoSkipLevelTarget() {
+    return {
+        executor: '@webpieces/dev-config:validate-no-skiplevel-deps',
+        cache: true,
+        inputs: ['default'],
+        metadata: {
+            technologies: ['nx'],
+            description: 'Validate no project has redundant transitive dependencies',
+        },
+    };
+}
+function createHelpTarget() {
+    return {
+        executor: '@webpieces/dev-config:help',
+        cache: true,
+        metadata: {
+            technologies: ['nx'],
+            description: 'Display help for @webpieces/dev-config commands and targets',
+        },
+    };
+}
+/**
+ * Create per-project circular dependency checking target
+ */
+function createCircularDepsTarget(projectRoot, targetName) {
+    return {
+        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',
+        },
+    };
+}
+/**
+ * Check if a project should be excluded based on patterns
+ */
+function isExcluded(projectRoot, excludePatterns) {
+    if (excludePatterns.length === 0) {
+        return false;
+    }
+    // Simple glob matching (could be enhanced with minimatch if needed)
+    return excludePatterns.some((pattern) => {
+        // Convert glob pattern to regex
+        const regexPattern = pattern
+            .replace(/\*\*/g, '.*') // ** matches any path
+            .replace(/\*/g, '[^/]*'); // * matches any string except /
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(projectRoot);
+    });
+}
+/**
+ * Export plugin as default for Nx
+ */
+exports.default = { createNodesV2: exports.createNodesV2 };
+//# sourceMappingURL=plugin.js.map