@nx/eslint-plugin 0.0.0-pr-22179-271588f

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

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateVersionJsonExpression = exports.validatePackageGroup = exports.validateImplemenationNode = exports.validateEntry = exports.checkCollectionNode = exports.checkCollectionFileNode = exports.RULE_NAME = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("@typescript-eslint/utils");
+const devkit_1 = require("@nx/devkit");
+const runtime_lint_utils_1 = require("../utils/runtime-lint-utils");
+const fs_1 = require("fs");
+const internal_1 = require("@nx/js/src/internal");
+const path = tslib_1.__importStar(require("path"));
+const path_1 = require("path");
+const project_graph_utils_1 = require("../utils/project-graph-utils");
+const semver_1 = require("semver");
+const DEFAULT_OPTIONS = {
+    generatorsJson: 'generators.json',
+    executorsJson: 'executors.json',
+    migrationsJson: 'migrations.json',
+    packageJson: 'package.json',
+    allowedVersionStrings: ['*', 'latest', 'next'],
+};
+exports.RULE_NAME = 'nx-plugin-checks';
+exports.default = utils_1.ESLintUtils.RuleCreator(() => ``)({
+    name: exports.RULE_NAME,
+    meta: {
+        docs: {
+            description: 'Checks common nx-plugin configuration files for validity',
+            recommended: 'recommended',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    generatorsJson: {
+                        type: 'string',
+                        description: "The path to the project's generators.json file, relative to the project root",
+                    },
+                    executorsJson: {
+                        type: 'string',
+                        description: "The path to the project's executors.json file, relative to the project root",
+                    },
+                    migrationsJson: {
+                        type: 'string',
+                        description: "The path to the project's migrations.json file, relative to the project root",
+                    },
+                    packageJson: {
+                        type: 'string',
+                        description: "The path to the project's package.json file, relative to the project root",
+                    },
+                    allowedVersionStrings: {
+                        type: 'array',
+                        description: 'A list of specifiers that are valid for versions within package group. Defaults to ["*", "latest", "next"]',
+                        items: { type: 'string' },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: 'problem',
+        messages: {
+            invalidSchemaPath: 'Schema path should point to a valid file',
+            invalidImplementationPath: '{{ key }}: Implementation path should point to a valid file',
+            invalidImplementationModule: '{{ key }}: Unable to find export {{ identifier }} in implementation module',
+            unableToReadImplementationExports: '{{ key }}: Unable to read exports for implementation module',
+            invalidVersion: '{{ key }}: Version should be a valid semver',
+            noGeneratorsOrSchematicsFound: 'Unable to find `generators` or `schematics` property',
+            noExecutorsOrBuildersFound: 'Unable to find `executors` or `builders` property',
+            valueShouldBeObject: '{{ key }} should be an object',
+            missingRequiredSchema: '{{ key }}: Missing required property - `schema`',
+            missingImplementation: '{{ key }}: Missing required property - `implementation`',
+            missingVersion: '{{ key }}: Missing required property - `version`',
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context) {
+        // jsonc-eslint-parser adds this property to parserServices where appropriate
+        if (!context.parserServices.isJSON) {
+            return {};
+        }
+        const { projectGraph, projectRootMappings } = (0, project_graph_utils_1.readProjectGraph)(exports.RULE_NAME);
+        const sourceFilePath = (0, runtime_lint_utils_1.getSourceFilePath)(context.getFilename(), devkit_1.workspaceRoot);
+        const sourceProject = (0, runtime_lint_utils_1.findProject)(projectGraph, projectRootMappings, sourceFilePath);
+        // If source is not part of an nx workspace, return.
+        if (!sourceProject) {
+            return {};
+        }
+        const options = normalizeOptions(sourceProject, context.options[0]);
+        context.options[0] = options;
+        const { generatorsJson, executorsJson, migrationsJson, packageJson } = options;
+        if (![generatorsJson, executorsJson, migrationsJson, packageJson].includes(sourceFilePath)) {
+            return {};
+        }
+        if (!global.tsProjectRegistered) {
+            (0, internal_1.registerTsProject)((0, path_1.join)(devkit_1.workspaceRoot, 'tsconfig.base.json'));
+            global.tsProjectRegistered = true;
+        }
+        return {
+            ['JSONExpressionStatement > JSONObjectExpression'](node) {
+                if (sourceFilePath === generatorsJson) {
+                    checkCollectionFileNode(node, 'generator', context);
+                }
+                else if (sourceFilePath === migrationsJson) {
+                    checkCollectionFileNode(node, 'migration', context);
+                }
+                else if (sourceFilePath === executorsJson) {
+                    checkCollectionFileNode(node, 'executor', context);
+                }
+                else if (sourceFilePath === packageJson) {
+                    validatePackageGroup(node, context);
+                }
+            },
+        };
+    },
+});
+function normalizeOptions(sourceProject, options) {
+    const base = { ...DEFAULT_OPTIONS, ...options };
+    const pathPrefix = sourceProject.data.root !== '.' ? `${sourceProject.data.root}/` : '';
+    return {
+        ...base,
+        executorsJson: base.executorsJson
+            ? `${pathPrefix}${base.executorsJson}`
+            : undefined,
+        generatorsJson: base.generatorsJson
+            ? `${pathPrefix}${base.generatorsJson}`
+            : undefined,
+        migrationsJson: base.migrationsJson
+            ? `${pathPrefix}${base.migrationsJson}`
+            : undefined,
+        packageJson: base.packageJson
+            ? `${pathPrefix}${base.packageJson}`
+            : undefined,
+    };
+}
+function checkCollectionFileNode(baseNode, mode, context) {
+    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');
+    const buildersRootNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'builders');
+    if (!schematicsRootNode && !generatorsRootNode && mode !== 'executor') {
+        context.report({
+            messageId: 'noGeneratorsOrSchematicsFound',
+            node: baseNode,
+        });
+        return;
+    }
+    if (!executorsRootNode && !buildersRootNode && mode === 'executor') {
+        context.report({
+            messageId: 'noExecutorsOrBuildersFound',
+            node: baseNode,
+        });
+        return;
+    }
+    const collectionNodes = [
+        { collectionNode: schematicsRootNode, key: 'schematics' },
+        { collectionNode: generatorsRootNode, key: 'generators' },
+        { collectionNode: executorsRootNode, key: 'executors' },
+        { collectionNode: buildersRootNode, key: 'builders' },
+    ].filter(({ collectionNode }) => !!collectionNode);
+    for (const { collectionNode, key } of collectionNodes) {
+        if (collectionNode.value.type !== 'JSONObjectExpression') {
+            context.report({
+                messageId: 'valueShouldBeObject',
+                data: { key },
+                node: schematicsRootNode,
+            });
+        }
+        else {
+            checkCollectionNode(collectionNode.value, mode, context);
+        }
+    }
+}
+exports.checkCollectionFileNode = checkCollectionFileNode;
+function checkCollectionNode(baseNode, mode, context) {
+    const entries = baseNode.properties;
+    for (const entryNode of entries) {
+        if (entryNode.value.type !== 'JSONObjectExpression') {
+            context.report({
+                messageId: 'valueShouldBeObject',
+                data: { key: entryNode.key.value },
+                node: entryNode,
+            });
+        }
+        else if (entryNode.key.type === 'JSONLiteral') {
+            validateEntry(entryNode.value, entryNode.key.value.toString(), mode, context);
+        }
+    }
+}
+exports.checkCollectionNode = checkCollectionNode;
+function validateEntry(baseNode, key, mode, context) {
+    const schemaNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'schema');
+    if (mode !== 'migration' && !schemaNode) {
+        context.report({
+            messageId: 'missingRequiredSchema',
+            data: {
+                key,
+            },
+            node: baseNode,
+        });
+    }
+    else if (schemaNode) {
+        if (schemaNode.value.type !== 'JSONLiteral' ||
+            typeof schemaNode.value.value !== 'string') {
+            context.report({
+                messageId: 'invalidSchemaPath',
+                node: schemaNode.value,
+            });
+        }
+        else {
+            const schemaFilePath = path.join(path.dirname(context.getFilename()), schemaNode.value.value);
+            if (!(0, fs_1.existsSync)(schemaFilePath)) {
+                context.report({
+                    messageId: 'invalidSchemaPath',
+                    node: schemaNode.value,
+                });
+            }
+            else {
+                try {
+                    (0, devkit_1.readJsonFile)(schemaFilePath);
+                }
+                catch (e) {
+                    context.report({
+                        messageId: 'invalidSchemaPath',
+                        node: schemaNode.value,
+                    });
+                }
+            }
+        }
+    }
+    const implementationNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' &&
+        (x.key.value === 'implementation' || x.key.value === 'factory'));
+    if (!implementationNode) {
+        context.report({
+            messageId: 'missingImplementation',
+            data: {
+                key,
+            },
+            node: baseNode,
+        });
+    }
+    else {
+        validateImplemenationNode(implementationNode, key, context);
+    }
+    if (mode === 'migration') {
+        const versionNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'version');
+        if (!versionNode) {
+            context.report({
+                messageId: 'missingVersion',
+                data: {
+                    key,
+                },
+                node: baseNode,
+            });
+        }
+        else if (versionNode.value.type !== 'JSONLiteral' ||
+            typeof versionNode.value.value !== 'string') {
+            context.report({
+                messageId: 'invalidVersion',
+                data: {
+                    key,
+                },
+                node: versionNode.value,
+            });
+        }
+        else {
+            const specifiedVersion = versionNode.value.value;
+            if (!(0, semver_1.valid)(specifiedVersion)) {
+                context.report({
+                    messageId: 'invalidVersion',
+                    data: {
+                        key,
+                    },
+                    node: versionNode.value,
+                });
+            }
+        }
+    }
+}
+exports.validateEntry = validateEntry;
+function validateImplemenationNode(implementationNode, key, context) {
+    if (implementationNode.value.type !== 'JSONLiteral' ||
+        typeof implementationNode.value.value !== 'string') {
+        context.report({
+            messageId: 'invalidImplementationPath',
+            data: {
+                key,
+            },
+            node: implementationNode.value,
+        });
+    }
+    else {
+        const [implementationPath, identifier] = implementationNode.value.value.split('#');
+        let resolvedPath;
+        const modulePath = path.join(path.dirname(context.getFilename()), implementationPath);
+        try {
+            resolvedPath = require.resolve(modulePath);
+        }
+        catch (e) {
+            context.report({
+                messageId: 'invalidImplementationPath',
+                data: {
+                    key,
+                },
+                node: implementationNode.value,
+            });
+        }
+        if (identifier) {
+            try {
+                const m = require(resolvedPath);
+                if (!(identifier in m && typeof m[identifier] === 'function')) {
+                    context.report({
+                        messageId: 'invalidImplementationModule',
+                        node: implementationNode.value,
+                        data: {
+                            identifier,
+                            key,
+                        },
+                    });
+                }
+            }
+            catch {
+                context.report({
+                    messageId: 'unableToReadImplementationExports',
+                    node: implementationNode.value,
+                    data: {
+                        key,
+                    },
+                });
+            }
+        }
+    }
+}
+exports.validateImplemenationNode = validateImplemenationNode;
+function validatePackageGroup(baseNode, context) {
+    const migrationsNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' &&
+        x.value.type === 'JSONObjectExpression' &&
+        (x.key.value === 'nx-migrations' ||
+            x.key.value === 'ng-update' ||
+            x.key.value === 'migrations'))?.value;
+    const packageGroupNode = migrationsNode?.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'packageGroup');
+    if (packageGroupNode) {
+        // Package group is defined as an array
+        if (packageGroupNode.value.type === 'JSONArrayExpression') {
+            // Look at entries which are an object
+            const members = packageGroupNode.value.elements.filter((x) => x.type === 'JSONObjectExpression');
+            // validate that the version property exists and is valid
+            for (const member of members) {
+                const versionPropertyNode = member.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'version');
+                const packageNode = member.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'package');
+                const key = packageNode?.value?.value ?? 'unknown';
+                if (versionPropertyNode) {
+                    if (!validateVersionJsonExpression(versionPropertyNode.value, context))
+                        context.report({
+                            messageId: 'invalidVersion',
+                            data: { key },
+                            node: versionPropertyNode.value,
+                        });
+                }
+                else {
+                    context.report({
+                        messageId: 'missingVersion',
+                        data: { key },
+                        node: member,
+                    });
+                }
+            }
+            // Package group is defined as an object (Record<PackageName, Version>)
+        }
+        else if (packageGroupNode.value.type === 'JSONObjectExpression') {
+            const properties = packageGroupNode.value.properties;
+            // For each property, ensure its value is a valid version
+            for (const propertyNode of properties) {
+                if (!validateVersionJsonExpression(propertyNode.value, context)) {
+                    context.report({
+                        messageId: 'invalidVersion',
+                        data: {
+                            key: propertyNode.key.value,
+                        },
+                        node: propertyNode.value,
+                    });
+                }
+            }
+        }
+    }
+}
+exports.validatePackageGroup = validatePackageGroup;
+function validateVersionJsonExpression(node, context) {
+    return (node &&
+        node.type === 'JSONLiteral' &&
+        typeof node.value === 'string' &&
+        ((0, semver_1.valid)(node.value) ||
+            context.options[0]?.allowedVersionStrings.includes(node.value)));
+}
+exports.validateVersionJsonExpression = validateVersionJsonExpression;

package/src/utils/ast-utils.d.ts

@@ -0,0 +1,12 @@
+import { ProjectGraphProjectNode } from '@nx/devkit';
+/**
+ *
+ * @param importScope like `@myorg/somelib`
+ * @returns
+ */
+export declare function getBarrelEntryPointByImportScope(importScope: string): string[];
+export declare function getBarrelEntryPointProjectNode(projectNode: ProjectGraphProjectNode): {
+    path: string;
+    importScope: string;
+}[] | null;
+export declare function getRelativeImportPath(exportedMember: any, filePath: any, basePath: any): any;

package/src/utils/ast-utils.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativeImportPath = exports.getBarrelEntryPointProjectNode = exports.getBarrelEntryPointByImportScope = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const type_utils_1 = require("@typescript-eslint/type-utils");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ts = require("typescript");
+function tryReadBaseJson() {
+    try {
+        return (0, devkit_1.readJsonFile)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, 'tsconfig.base.json'));
+    }
+    catch (e) {
+        devkit_1.logger.warn(`Error reading "tsconfig.base.json": \n${JSON.stringify(e)}`);
+        return null;
+    }
+}
+/**
+ *
+ * @param importScope like `@myorg/somelib`
+ * @returns
+ */
+function getBarrelEntryPointByImportScope(importScope) {
+    const tryPaths = (paths, importScope) => {
+        // TODO check and warn that the entries of paths[importScope] have no wildcards; that'd be user misconfiguration
+        if (paths[importScope])
+            return paths[importScope];
+        // accommodate wildcards (it's not glob) https://www.typescriptlang.org/docs/handbook/module-resolution.html#path-mapping
+        const result = new Set(); // set ensures there are no duplicates
+        for (const [alias, targets] of Object.entries(paths)) {
+            if (!alias.endsWith('*')) {
+                continue;
+            }
+            const strippedAlias = alias.slice(0, -1); // remove asterisk
+            if (!importScope.startsWith(strippedAlias)) {
+                continue;
+            }
+            const dynamicPart = importScope.slice(strippedAlias.length);
+            targets.forEach((target) => {
+                result.add(target.replace('*', dynamicPart)); // add interpolated value
+            });
+            // we found the entry for importScope; an import scope not supposed and has no sense having > 1 Aliases; TODO warn on duplicated entries
+            break;
+        }
+        return Array.from(result);
+    };
+    const tsConfigBase = tryReadBaseJson();
+    if (!tsConfigBase?.compilerOptions?.paths)
+        return [];
+    return tryPaths(tsConfigBase.compilerOptions.paths, importScope);
+}
+exports.getBarrelEntryPointByImportScope = getBarrelEntryPointByImportScope;
+function getBarrelEntryPointProjectNode(projectNode) {
+    const tsConfigBase = tryReadBaseJson();
+    if (tsConfigBase?.compilerOptions?.paths) {
+        const potentialEntryPoints = Object.keys(tsConfigBase.compilerOptions.paths)
+            .filter((entry) => {
+            const sourceFolderPaths = tsConfigBase.compilerOptions.paths[entry];
+            return sourceFolderPaths.some((sourceFolderPath) => {
+                return (sourceFolderPath === projectNode.data.sourceRoot ||
+                    sourceFolderPath.indexOf(`${projectNode.data.sourceRoot}/`) === 0);
+            });
+        })
+            .map((entry) => tsConfigBase.compilerOptions.paths[entry].map((x) => ({
+            path: x,
+            importScope: entry,
+        })));
+        return potentialEntryPoints.flat();
+    }
+    return null;
+}
+exports.getBarrelEntryPointProjectNode = getBarrelEntryPointProjectNode;
+function hasMemberExport(exportedMember, filePath) {
+    const fileContent = (0, fs_1.readFileSync)(filePath, 'utf8');
+    // use the TypeScript AST to find the path to the file where exportedMember is defined
+    const sourceFile = ts.createSourceFile(filePath, fileContent, ts.ScriptTarget.Latest, true);
+    // search whether there is already an export with our node
+    return ((0, js_1.findNodes)(sourceFile, ts.SyntaxKind.Identifier).filter((identifier) => identifier.text === exportedMember).length > 0);
+}
+function getRelativeImportPath(exportedMember, filePath, basePath) {
+    const status = (0, fs_1.lstatSync)(filePath, {
+        throwIfNoEntry: false,
+    });
+    if (!status /*not existed, but probably not full file with an extension*/) {
+        // try to find an extension that exists
+        const ext = ['.ts', '.tsx', '.js', '.jsx'].find((ext) => (0, fs_1.lstatSync)(filePath + ext, { throwIfNoEntry: false }));
+        if (ext) {
+            filePath += ext;
+        }
+    }
+    else if (status.isDirectory()) {
+        const file = (0, fs_1.readdirSync)(filePath).find((file) => /^index\.[jt]sx?$/.exec(file));
+        if (file) {
+            filePath = (0, devkit_1.joinPathFragments)(filePath, file);
+        }
+        else {
+            return;
+        }
+    }
+    const fileContent = (0, fs_1.readFileSync)(filePath, 'utf8');
+    // use the TypeScript AST to find the path to the file where exportedMember is defined
+    const sourceFile = ts.createSourceFile(filePath, fileContent, ts.ScriptTarget.Latest, true);
+    // Search in the current file whether there's an export already!
+    const memberNodes = (0, js_1.findNodes)(sourceFile, ts.SyntaxKind.Identifier).filter((identifier) => identifier.text === exportedMember);
+    let hasExport = false;
+    for (const memberNode of memberNodes || []) {
+        if (memberNode) {
+            // recursively navigate upwards to find the ExportKey modifier
+            let parent = memberNode;
+            do {
+                parent = parent.parent;
+                if (parent) {
+                    // if we are inside a parameter list or decorator or param assignment
+                    // then this is not what we're searching for, so break :)
+                    if (parent.kind === ts.SyntaxKind.Parameter ||
+                        parent.kind === ts.SyntaxKind.PropertyAccessExpression ||
+                        parent.kind === ts.SyntaxKind.TypeReference ||
+                        parent.kind === ts.SyntaxKind.HeritageClause ||
+                        parent.kind === ts.SyntaxKind.Decorator) {
+                        hasExport = false;
+                        break;
+                    }
+                    // if our identifier is within an ExportDeclaration but is not just
+                    // a re-export of some other module, we're good
+                    if (parent.kind === ts.SyntaxKind.ExportDeclaration &&
+                        !parent.moduleSpecifier) {
+                        hasExport = true;
+                        break;
+                    }
+                    if ((0, type_utils_1.getModifiers)(parent)?.find((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+                        /**
+                         * if we get to a function export declaration we need to verify whether the
+                         * exported function is actually the member we are searching for. Otherwise
+                         * we might end up finding a function that just uses our searched identifier
+                         * internally.
+                         *
+                         * Example: assume we try to find a constant member: `export const SOME_CONSTANT = 'bla'`
+                         *
+                         * Then we might end up in a file that uses it like
+                         *
+                         * import { SOME_CONSTANT } from '@myorg/samelib'
+                         *
+                         * export function someFunction() {
+                         *  return `Hi, ${SOME_CONSTANT}`
+                         * }
+                         *
+                         * We want to avoid accidentally picking the someFunction export since we're searching upwards
+                         * starting from `SOME_CONSTANT` identifier usages.
+                         */
+                        if (parent.kind === ts.SyntaxKind.FunctionDeclaration) {
+                            const parentName = parent.name?.text;
+                            if (parentName === exportedMember) {
+                                hasExport = true;
+                                break;
+                            }
+                        }
+                        else {
+                            hasExport = true;
+                            break;
+                        }
+                    }
+                }
+            } while (!!parent);
+        }
+        if (hasExport) {
+            break;
+        }
+    }
+    if (hasExport) {
+        // we found the file, now grab the path
+        return filePath;
+    }
+    // if we didn't find an export, let's try to follow
+    // all export declarations and see whether any of those
+    // exports the node we're searching for
+    const exportDeclarations = (0, js_1.findNodes)(sourceFile, ts.SyntaxKind.ExportDeclaration);
+    for (const exportDeclaration of exportDeclarations) {
+        if (exportDeclaration.moduleSpecifier) {
+            // verify whether the export declaration we're looking at is a named export
+            // cause in that case we need to check whether our searched member is
+            // part of the exports
+            if (exportDeclaration.exportClause &&
+                (0, js_1.findNodes)(exportDeclaration, ts.SyntaxKind.Identifier).filter((identifier) => identifier.text === exportedMember).length === 0) {
+                continue;
+            }
+            const modulePath = exportDeclaration.moduleSpecifier.text;
+            let moduleFilePath;
+            if (modulePath.endsWith('.js') || modulePath.endsWith('.jsx')) {
+                moduleFilePath = (0, devkit_1.joinPathFragments)((0, path_1.dirname)(filePath), modulePath);
+                if (!(0, fs_1.existsSync)(moduleFilePath)) {
+                    const tsifiedModulePath = modulePath.replace(/\.js(x?)$/, '.ts$1');
+                    moduleFilePath = (0, devkit_1.joinPathFragments)((0, path_1.dirname)(filePath), `${tsifiedModulePath}`);
+                }
+            }
+            else if (modulePath.endsWith('.ts') || modulePath.endsWith('.tsx')) {
+                moduleFilePath = (0, devkit_1.joinPathFragments)((0, path_1.dirname)(filePath), modulePath);
+            }
+            else {
+                moduleFilePath = (0, devkit_1.joinPathFragments)((0, path_1.dirname)(filePath), `${modulePath}.ts`);
+                if (!(0, fs_1.existsSync)(moduleFilePath)) {
+                    // might be a tsx file
+                    moduleFilePath = (0, devkit_1.joinPathFragments)((0, path_1.dirname)(filePath), `${modulePath}.tsx`);
+                }
+            }
+            if (!(0, fs_1.existsSync)(moduleFilePath)) {
+                // might be an index.ts
+                moduleFilePath = (0, devkit_1.joinPathFragments)((0, path_1.dirname)(filePath), `${modulePath}/index.ts`);
+            }
+            if (hasMemberExport(exportedMember, moduleFilePath)) {
+                const foundFilePath = getRelativeImportPath(exportedMember, moduleFilePath, basePath);
+                if (foundFilePath) {
+                    return foundFilePath;
+                }
+            }
+        }
+    }
+    return null;
+}
+exports.getRelativeImportPath = getRelativeImportPath;

package/src/utils/config-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if package is available
+ * @param name name of the package
+ * @returns
+ */
+export declare function packageExists(name: string): boolean;

package/src/utils/config-utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageExists = void 0;
+/**
+ * Checks if package is available
+ * @param name name of the package
+ * @returns
+ */
+function packageExists(name) {
+    try {
+        require.resolve(name);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.packageExists = packageExists;

package/src/utils/graph-utils.d.ts

@@ -0,0 +1,6 @@
+import type { FileData, ProjectFileMap, ProjectGraph, ProjectGraphProjectNode } from '@nx/devkit';
+export declare function getPath(graph: ProjectGraph, sourceProjectName: string, targetProjectName: string): Array<ProjectGraphProjectNode>;
+export declare function pathExists(graph: ProjectGraph, sourceProjectName: string, targetProjectName: string): boolean;
+export declare function checkCircularPath(graph: ProjectGraph, sourceProject: ProjectGraphProjectNode, targetProject: ProjectGraphProjectNode): ProjectGraphProjectNode[];
+export declare function findFilesInCircularPath(projectFileMap: ProjectFileMap, circularPath: ProjectGraphProjectNode[]): Array<string[]>;
+export declare function findFilesWithDynamicImports(projectFileMap: ProjectFileMap, sourceProjectName: string, targetProjectName: string): FileData[];