@nx/eslint-plugin 0.0.0-pr-29314-e664f92 → 0.0.0-pr-29314-bfd9d0c

package/nx.d.ts

@@ -18,6 +18,7 @@ declare const plugin: {
             migrationsJson?: string;
             packageJson?: string;
             allowedVersionStrings: string[];
+            tsConfig?: string;
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "dependency-checks": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./src/rules/dependency-checks").MessageIds, import("./src/rules/dependency-checks").Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint-plugin",
-  "version": "0.0.0-pr-29314-e664f92",
+  "version": "0.0.0-pr-29314-bfd9d0c",
   "private": false,
   "description": "The eslint-plugin package is an ESLint plugin that contains a collection of recommended ESLint rule configurations which you can extend from in your own ESLint configs, as well as an Nx-specific lint rule called enforce-module-boundaries.",
   "repository": {
@@ -34,8 +34,8 @@
     }
   },
   "dependencies": {
-    "@nx/devkit": "0.0.0-pr-29314-e664f92",
-    "@nx/js": "0.0.0-pr-29314-e664f92",
+    "@nx/devkit": "0.0.0-pr-29314-bfd9d0c",
+    "@nx/js": "0.0.0-pr-29314-bfd9d0c",
     "@typescript-eslint/type-utils": "^8.0.0",
     "@typescript-eslint/utils": "^8.0.0",
     "chalk": "^4.1.0",

package/src/rules/nx-plugin-checks.d.ts

@@ -7,15 +7,20 @@ type Options = [
         migrationsJson?: string;
         packageJson?: string;
         allowedVersionStrings: string[];
+        tsConfig?: string;
     }
 ];
+type NormalizedOptions = Options[0] & {
+    rootDir?: string;
+    outDir?: string;
+};
 export type MessageIds = 'missingRequiredSchema' | 'invalidSchemaPath' | 'missingImplementation' | 'invalidImplementationPath' | 'invalidImplementationModule' | 'unableToReadImplementationExports' | 'invalidVersion' | 'missingVersion' | 'noGeneratorsOrSchematicsFound' | 'noExecutorsOrBuildersFound' | 'valueShouldBeObject';
 export declare const RULE_NAME = "nx-plugin-checks";
 declare const _default: TSESLint.RuleModule<MessageIds, Options, unknown, TSESLint.RuleListener>;
 export default _default;
-export declare function checkCollectionFileNode(baseNode: AST.JSONObjectExpression, mode: 'migration' | 'generator' | 'executor', context: TSESLint.RuleContext<MessageIds, Options>): void;
-export declare function checkCollectionNode(baseNode: AST.JSONObjectExpression, mode: 'migration' | 'generator' | 'executor', context: TSESLint.RuleContext<MessageIds, Options>): void;
-export declare function validateEntry(baseNode: AST.JSONObjectExpression, key: string, mode: 'migration' | 'generator' | 'executor', context: TSESLint.RuleContext<MessageIds, Options>): void;
-export declare function validateImplemenationNode(implementationNode: AST.JSONProperty, key: string, context: TSESLint.RuleContext<MessageIds, Options>): void;
+export declare function checkCollectionFileNode(baseNode: AST.JSONObjectExpression, mode: 'migration' | 'generator' | 'executor', context: TSESLint.RuleContext<MessageIds, Options>, options: NormalizedOptions): void;
+export declare function checkCollectionNode(baseNode: AST.JSONObjectExpression, mode: 'migration' | 'generator' | 'executor', context: TSESLint.RuleContext<MessageIds, Options>, options: NormalizedOptions): void;
+export declare function validateEntry(baseNode: AST.JSONObjectExpression, key: string, mode: 'migration' | 'generator' | 'executor', context: TSESLint.RuleContext<MessageIds, Options>, options: NormalizedOptions): void;
+export declare function validateImplementationNode(implementationNode: AST.JSONProperty, key: string, context: TSESLint.RuleContext<MessageIds, Options>, options: NormalizedOptions): void;
 export declare function validatePackageGroup(baseNode: AST.JSONObjectExpression, context: TSESLint.RuleContext<MessageIds, Options>): void;
 export declare function validateVersionJsonExpression(node: AST.JSONExpression, context: TSESLint.RuleContext<MessageIds, Options>): string | boolean;

package/src/rules/nx-plugin-checks.js

@@ -4,7 +4,7 @@ exports.RULE_NAME = void 0;
 exports.checkCollectionFileNode = checkCollectionFileNode;
 exports.checkCollectionNode = checkCollectionNode;
 exports.validateEntry = validateEntry;
-exports.validateImplemenationNode = validateImplemenationNode;
+exports.validateImplementationNode = validateImplementationNode;
 exports.validatePackageGroup = validatePackageGroup;
 exports.validateVersionJsonExpression = validateVersionJsonExpression;
 const tslib_1 = require("tslib");
@@ -12,7 +12,6 @@ const utils_1 = require("@typescript-eslint/utils");
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
 const internal_1 = require("@nx/js/src/internal");
-const fs_1 = require("fs");
 const path = tslib_1.__importStar(require("path"));
 const semver_1 = require("semver");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
@@ -23,6 +22,7 @@ const DEFAULT_OPTIONS = {
     migrationsJson: 'migrations.json',
     packageJson: 'package.json',
     allowedVersionStrings: ['*', 'latest', 'next'],
+    tsConfig: 'tsconfig.lib.json',
 };
 exports.RULE_NAME = 'nx-plugin-checks';
 exports.default = utils_1.ESLintUtils.RuleCreator(() => ``)({
@@ -56,6 +56,10 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => ``)({
                         description: 'A list of specifiers that are valid for versions within package group. Defaults to ["*", "latest", "next"]',
                         items: { type: 'string' },
                     },
+                    tsConfig: {
+                        type: 'string',
+                        description: 'The path to the tsconfig file used to build the plugin. Defaults to "tsconfig.lib.json".',
+                    },
                 },
                 additionalProperties: false,
             },
@@ -101,13 +105,13 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => ``)({
         return {
             ['JSONExpressionStatement > JSONObjectExpression'](node) {
                 if (sourceFilePath === generatorsJson) {
-                    checkCollectionFileNode(node, 'generator', context);
+                    checkCollectionFileNode(node, 'generator', context, options);
                 }
                 else if (sourceFilePath === migrationsJson) {
-                    checkCollectionFileNode(node, 'migration', context);
+                    checkCollectionFileNode(node, 'migration', context, options);
                 }
                 else if (sourceFilePath === executorsJson) {
-                    checkCollectionFileNode(node, 'executor', context);
+                    checkCollectionFileNode(node, 'executor', context, options);
                 }
                 else if (sourceFilePath === packageJson) {
                     validatePackageGroup(node, context);
@@ -117,7 +121,19 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => ``)({
     },
 });
 function normalizeOptions(sourceProject, options) {
+    let rootDir;
+    let outDir;
     const base = { ...DEFAULT_OPTIONS, ...options };
+    let runtimeTsConfig;
+    try {
+        runtimeTsConfig = require.resolve(path.join(sourceProject.data.root, base.tsConfig));
+        const tsConfig = (0, devkit_1.readJsonFile)(runtimeTsConfig);
+        rootDir = tsConfig.compilerOptions?.rootDir;
+        outDir = tsConfig.compilerOptions?.outDir;
+    }
+    catch {
+        // nothing
+    }
     const pathPrefix = sourceProject.data.root !== '.' ? `${sourceProject.data.root}/` : '';
     return {
         ...base,
@@ -133,9 +149,11 @@ function normalizeOptions(sourceProject, options) {
         packageJson: base.packageJson
             ? `${pathPrefix}${base.packageJson}`
             : undefined,
+        rootDir: rootDir ? path.join(sourceProject.data.root, rootDir) : undefined,
+        outDir: outDir ? path.join(sourceProject.data.root, outDir) : undefined,
     };
 }
-function checkCollectionFileNode(baseNode, mode, context) {
+function checkCollectionFileNode(baseNode, mode, context, options) {
     const schematicsRootNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'schematics');
     const generatorsRootNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'generators');
     const executorsRootNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'executors');
@@ -169,11 +187,11 @@ function checkCollectionFileNode(baseNode, mode, context) {
             });
         }
         else {
-            checkCollectionNode(collectionNode.value, mode, context);
+            checkCollectionNode(collectionNode.value, mode, context, options);
         }
     }
 }
-function checkCollectionNode(baseNode, mode, context) {
+function checkCollectionNode(baseNode, mode, context, options) {
     const entries = baseNode.properties;
     for (const entryNode of entries) {
         if (entryNode.value.type !== 'JSONObjectExpression') {
@@ -184,11 +202,11 @@ function checkCollectionNode(baseNode, mode, context) {
             });
         }
         else if (entryNode.key.type === 'JSONLiteral') {
-            validateEntry(entryNode.value, entryNode.key.value.toString(), mode, context);
+            validateEntry(entryNode.value, entryNode.key.value.toString(), mode, context, options);
         }
     }
 }
-function validateEntry(baseNode, key, mode, context) {
+function validateEntry(baseNode, key, mode, context, options) {
     const schemaNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'schema');
     if (mode !== 'migration' && !schemaNode) {
         context.report({
@@ -208,24 +226,28 @@ function validateEntry(baseNode, key, mode, context) {
             });
         }
         else {
+            let validJsonFound = false;
             const schemaFilePath = path.join(path.dirname(context.filename ?? context.getFilename()), schemaNode.value.value);
-            if (!(0, fs_1.existsSync)(schemaFilePath)) {
-                context.report({
-                    messageId: 'invalidSchemaPath',
-                    node: schemaNode.value,
-                });
+            try {
+                (0, devkit_1.readJsonFile)(schemaFilePath);
+                validJsonFound = true;
             }
-            else {
+            catch {
                 try {
-                    (0, devkit_1.readJsonFile)(schemaFilePath);
+                    // Try to map back to source, which will be the case with TS solution setup.
+                    (0, devkit_1.readJsonFile)(schemaFilePath.replace(options.outDir, options.rootDir));
+                    validJsonFound = true;
                 }
-                catch (e) {
-                    context.report({
-                        messageId: 'invalidSchemaPath',
-                        node: schemaNode.value,
-                    });
+                catch {
+                    // nothing, will be reported below
                 }
             }
+            if (!validJsonFound) {
+                context.report({
+                    messageId: 'invalidSchemaPath',
+                    node: schemaNode.value,
+                });
+            }
         }
     }
     const implementationNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' &&
@@ -240,7 +262,7 @@ function validateEntry(baseNode, key, mode, context) {
         });
     }
     else {
-        validateImplemenationNode(implementationNode, key, context);
+        validateImplementationNode(implementationNode, key, context, options);
     }
     if (mode === 'migration') {
         const versionNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'version');
@@ -277,7 +299,7 @@ function validateEntry(baseNode, key, mode, context) {
         }
     }
 }
-function validateImplemenationNode(implementationNode, key, context) {
+function validateImplementationNode(implementationNode, key, context, options) {
     if (implementationNode.value.type !== 'JSONLiteral' ||
         typeof implementationNode.value.value !== 'string') {
         context.report({
@@ -295,7 +317,15 @@ function validateImplemenationNode(implementationNode, key, context) {
         try {
             resolvedPath = require.resolve(modulePath);
         }
-        catch (e) {
+        catch {
+            try {
+                resolvedPath = require.resolve(modulePath.replace(options.outDir, options.rootDir));
+            }
+            catch {
+                // nothing, will be reported below
+            }
+        }
+        if (!resolvedPath) {
             context.report({
                 messageId: 'invalidImplementationPath',
                 data: {