feat(core): revert running plugins in isolation (#22246)
This commit is contained in:
Jason Jean
GitHub
parent
235ca8cbda
commit
c01b566728
@ -15,5 +15,5 @@ A plugin for Nx which creates nodes and dependencies for the [ProjectGraph](../.
|
||||
| Name | Type | Description |
|
||||
| :-------------------- | :------------------------------------------------------------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `createDependencies?` | [`CreateDependencies`](../../devkit/documents/CreateDependencies)\<`TOptions`\> | Provides a function to analyze files to create dependencies for the [ProjectGraph](../../devkit/documents/ProjectGraph) |
|
||||
| `createNodes?` | [`CreateNodes`](../../devkit/documents/CreateNodes)\<`TOptions`\> | Provides a file pattern and function that retrieves configuration info from those files. e.g. { '\*_/_.csproj': buildProjectsFromCsProjFile } |
|
||||
| `createNodes?` | [`CreateNodes`](../../devkit/documents/CreateNodes) | Provides a file pattern and function that retrieves configuration info from those files. e.g. { '\*_/_.csproj': buildProjectsFromCsProjFile } |
|
||||
| `name` | `string` | - |
|
||||
|
||||
@ -5,11 +5,10 @@
|
||||
#### Type declaration
|
||||
|
||||
| Name | Type |
|
||||
| :-------- | :-------------------------- |
|
||||
| :------ | :-------------------------- |
|
||||
| `debug` | (...`s`: `any`[]) => `void` |
|
||||
| `error` | (`s`: `any`) => `void` |
|
||||
| `fatal` | (...`s`: `any`[]) => `void` |
|
||||
| `info` | (`s`: `any`) => `void` |
|
||||
| `log` | (...`s`: `any`[]) => `void` |
|
||||
| `verbose` | (...`s`: `any`[]) => `void` |
|
||||
| `warn` | (`s`: `any`) => `void` |
|
||||
|
||||
@ -1,22 +1,17 @@
|
||||
import { requireNx } from '../../nx';
|
||||
import { convertNxExecutor } from './convert-nx-executor';
|
||||
|
||||
const { workspaceRoot } = requireNx();
|
||||
|
||||
describe('Convert Nx Executor', () => {
|
||||
it('should convertNxExecutor to builder correctly and produce the same output', async () => {
|
||||
// ARRANGE
|
||||
const { schema } = require('@angular-devkit/core');
|
||||
const {
|
||||
TestingArchitectHost,
|
||||
// nx-ignore-next-line
|
||||
} = require('@angular-devkit/architect/testing') as typeof import('@angular-devkit/architect/testing');
|
||||
} = require('@angular-devkit/architect/testing');
|
||||
const { Architect } = require('@angular-devkit/architect');
|
||||
|
||||
const registry = new schema.CoreSchemaRegistry();
|
||||
registry.addPostTransform(schema.transforms.addUndefinedDefaults);
|
||||
const testArchitectHost = new TestingArchitectHost();
|
||||
testArchitectHost.workspaceRoot = workspaceRoot;
|
||||
const architect = new Architect(testArchitectHost, registry);
|
||||
|
||||
const convertedExecutor = convertNxExecutor(echoExecutor);
|
||||
|
||||
@ -11,10 +11,10 @@ import { readNxJson } from '../src/config/nx-json';
|
||||
import { setupWorkspaceContext } from '../src/utils/workspace-context';
|
||||
|
||||
(async () => {
|
||||
const start = new Date();
|
||||
try {
|
||||
setupWorkspaceContext(workspaceRoot);
|
||||
if (isMainNxPackage() && fileExists(join(workspaceRoot, 'nx.json'))) {
|
||||
const b = new Date();
|
||||
assertSupportedPlatform();
|
||||
|
||||
try {
|
||||
@ -35,18 +35,15 @@ import { setupWorkspaceContext } from '../src/utils/workspace-context';
|
||||
});
|
||||
})
|
||||
);
|
||||
if (process.env.NX_VERBOSE_LOGGING === 'true') {
|
||||
const a = new Date();
|
||||
console.log(`Nx postinstall steps took ${a.getTime() - b.getTime()}ms`);
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
if (process.env.NX_VERBOSE_LOGGING === 'true') {
|
||||
console.log(e);
|
||||
}
|
||||
} finally {
|
||||
if (process.env.NX_VERBOSE_LOGGING === 'true') {
|
||||
const end = new Date();
|
||||
console.log(
|
||||
`Nx postinstall steps took ${end.getTime() - start.getTime()}ms`
|
||||
);
|
||||
}
|
||||
}
|
||||
})();
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
import type { NxPluginV2 } from '../src/project-graph/plugins';
|
||||
import type { NxPluginV2 } from '../src/utils/nx-plugin';
|
||||
import { workspaceRoot } from '../src/utils/workspace-root';
|
||||
import { createNodeFromPackageJson } from '../src/plugins/package-json-workspaces';
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@ import { existsSync } from 'fs';
|
||||
import * as path from 'path';
|
||||
import { readJsonFile } from '../utils/fileutils';
|
||||
import { ProjectsConfigurations } from '../config/workspace-json-project-json';
|
||||
import { NxPluginV2 } from '../project-graph/plugins';
|
||||
import { NxPluginV2 } from '../utils/nx-plugin';
|
||||
|
||||
export const NX_ANGULAR_JSON_PLUGIN_NAME = 'nx-angular-json-plugin';
|
||||
|
||||
@ -16,8 +16,6 @@ export const NxAngularJsonPlugin: NxPluginV2 = {
|
||||
],
|
||||
};
|
||||
|
||||
export default NxAngularJsonPlugin;
|
||||
|
||||
export function shouldMergeAngularProjects(
|
||||
root: string,
|
||||
includeProjectsFromAngularJson: boolean
|
||||
|
||||
@ -59,7 +59,7 @@ import {
|
||||
ExecutorsJson,
|
||||
TaskGraphExecutor,
|
||||
} from '../config/misc-interfaces';
|
||||
import { readPluginPackageJson } from '../project-graph/plugins';
|
||||
import { readPluginPackageJson } from '../utils/nx-plugin';
|
||||
import {
|
||||
getImplementationFactory,
|
||||
resolveImplementation,
|
||||
|
||||
@ -10,7 +10,7 @@ import {
|
||||
resolveSchema,
|
||||
} from '../../config/schema-utils';
|
||||
import { readJsonFile } from '../../utils/fileutils';
|
||||
import { readPluginPackageJson } from '../../project-graph/plugins';
|
||||
import { readPluginPackageJson } from '../../utils/nx-plugin';
|
||||
|
||||
export function getGeneratorInformation(
|
||||
collectionName: string,
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
import { dirname, join } from 'path';
|
||||
|
||||
import { readPluginPackageJson } from '../../project-graph/plugins';
|
||||
import { readPluginPackageJson } from '../../utils/nx-plugin';
|
||||
import {
|
||||
CustomHasher,
|
||||
Executor,
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
import { existsSync } from 'fs';
|
||||
import { extname, join } from 'path';
|
||||
import { registerPluginTSTranspiler } from '../project-graph/plugins';
|
||||
import { registerPluginTSTranspiler } from '../utils/nx-plugin';
|
||||
|
||||
/**
|
||||
* This function is used to get the implementation factory of an executor or generator.
|
||||
|
||||
@ -1,9 +1,22 @@
|
||||
import { toProjectName } from './workspaces';
|
||||
import { toProjectName, Workspaces } from './workspaces';
|
||||
import { TempFs } from '../internal-testing-utils/temp-fs';
|
||||
import { withEnvironmentVariables } from '../internal-testing-utils/with-environment';
|
||||
import { retrieveProjectConfigurations } from '../project-graph/utils/retrieve-workspace-files';
|
||||
import { readNxJson } from './configuration';
|
||||
import { loadNxPluginsInIsolation } from '../project-graph/plugins/internal-api';
|
||||
|
||||
const libConfig = (root, name?: string) => ({
|
||||
name: name ?? toProjectName(`${root}/some-file`),
|
||||
projectType: 'library',
|
||||
root: `libs/${root}`,
|
||||
sourceRoot: `libs/${root}/src`,
|
||||
targets: {
|
||||
'nx-release-publish': {
|
||||
dependsOn: ['^nx-release-publish'],
|
||||
executor: '@nx/js:release-publish',
|
||||
options: {},
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
describe('Workspaces', () => {
|
||||
let fs: TempFs;
|
||||
@ -35,21 +48,9 @@ describe('Workspaces', () => {
|
||||
|
||||
const { projects } = await withEnvironmentVariables(
|
||||
{
|
||||
NX_WORKSPACE_ROOT_PATH: fs.tempDir,
|
||||
NX_WORKSPACE_ROOT: fs.tempDir,
|
||||
},
|
||||
async () => {
|
||||
const [plugins, cleanup] = await loadNxPluginsInIsolation(
|
||||
readNxJson(fs.tempDir).plugins,
|
||||
fs.tempDir
|
||||
);
|
||||
const res = retrieveProjectConfigurations(
|
||||
plugins,
|
||||
fs.tempDir,
|
||||
readNxJson(fs.tempDir)
|
||||
);
|
||||
cleanup();
|
||||
return res;
|
||||
}
|
||||
() => retrieveProjectConfigurations(fs.tempDir, readNxJson(fs.tempDir))
|
||||
);
|
||||
expect(projects['my-package']).toEqual({
|
||||
name: 'my-package',
|
||||
|
||||
@ -3,8 +3,6 @@ import { serializeResult } from '../socket-utils';
|
||||
import { serverLogger } from './logger';
|
||||
import { getCachedSerializedProjectGraphPromise } from './project-graph-incremental-recomputation';
|
||||
import { HandlerResult } from './server';
|
||||
import { getPlugins } from './plugins';
|
||||
import { readNxJson } from '../../config/nx-json';
|
||||
|
||||
export async function handleRequestProjectGraph(): Promise<HandlerResult> {
|
||||
try {
|
||||
|
||||
@ -1,26 +0,0 @@
|
||||
import { readNxJson } from '../../config/nx-json';
|
||||
import {
|
||||
RemotePlugin,
|
||||
loadNxPluginsInIsolation,
|
||||
} from '../../project-graph/plugins/internal-api';
|
||||
import { workspaceRoot } from '../../utils/workspace-root';
|
||||
|
||||
let loadedPlugins: Promise<RemotePlugin[]>;
|
||||
let cleanup: () => void;
|
||||
|
||||
export async function getPlugins() {
|
||||
if (loadedPlugins) {
|
||||
return loadedPlugins;
|
||||
}
|
||||
const pluginsConfiguration = readNxJson().plugins ?? [];
|
||||
const [result, cleanupFn] = await loadNxPluginsInIsolation(
|
||||
pluginsConfiguration,
|
||||
workspaceRoot
|
||||
);
|
||||
cleanup = cleanupFn;
|
||||
return result;
|
||||
}
|
||||
|
||||
export function cleanupPlugins() {
|
||||
cleanup();
|
||||
}
|
||||
@ -29,8 +29,6 @@ import { workspaceRoot } from '../../utils/workspace-root';
|
||||
import { notifyFileWatcherSockets } from './file-watching/file-watcher-sockets';
|
||||
import { serverLogger } from './logger';
|
||||
import { NxWorkspaceFilesExternals } from '../../native';
|
||||
import { RemotePlugin } from '../../project-graph/plugins/internal-api';
|
||||
import { getPlugins } from './plugins';
|
||||
|
||||
interface SerializedProjectGraph {
|
||||
error: Error | null;
|
||||
@ -71,15 +69,14 @@ export async function getCachedSerializedProjectGraphPromise(): Promise<Serializ
|
||||
// reset the wait time
|
||||
waitPeriod = 100;
|
||||
await resetInternalStateIfNxDepsMissing();
|
||||
const plugins = await getPlugins();
|
||||
if (collectedUpdatedFiles.size == 0 && collectedDeletedFiles.size == 0) {
|
||||
if (!cachedSerializedProjectGraphPromise) {
|
||||
cachedSerializedProjectGraphPromise =
|
||||
processFilesAndCreateAndSerializeProjectGraph(plugins);
|
||||
processFilesAndCreateAndSerializeProjectGraph();
|
||||
}
|
||||
} else {
|
||||
cachedSerializedProjectGraphPromise =
|
||||
processFilesAndCreateAndSerializeProjectGraph(plugins);
|
||||
processFilesAndCreateAndSerializeProjectGraph();
|
||||
}
|
||||
return await cachedSerializedProjectGraphPromise;
|
||||
} catch (e) {
|
||||
@ -126,7 +123,7 @@ export function addUpdatedAndDeletedFiles(
|
||||
}
|
||||
|
||||
cachedSerializedProjectGraphPromise =
|
||||
processFilesAndCreateAndSerializeProjectGraph(await getPlugins());
|
||||
processFilesAndCreateAndSerializeProjectGraph();
|
||||
await cachedSerializedProjectGraphPromise;
|
||||
|
||||
if (createdFiles.length > 0) {
|
||||
@ -202,9 +199,7 @@ async function processCollectedUpdatedAndDeletedFiles(
|
||||
}
|
||||
}
|
||||
|
||||
async function processFilesAndCreateAndSerializeProjectGraph(
|
||||
plugins: RemotePlugin[]
|
||||
): Promise<SerializedProjectGraph> {
|
||||
async function processFilesAndCreateAndSerializeProjectGraph(): Promise<SerializedProjectGraph> {
|
||||
try {
|
||||
performance.mark('hash-watched-changes-start');
|
||||
const updatedFiles = [...collectedUpdatedFiles.values()];
|
||||
@ -222,9 +217,9 @@ async function processFilesAndCreateAndSerializeProjectGraph(
|
||||
serverLogger.requestLog([...updatedFiles.values()]);
|
||||
serverLogger.requestLog([...deletedFiles]);
|
||||
const nxJson = readNxJson(workspaceRoot);
|
||||
// Set this globally to allow plugins to know if they are being called from the project graph creation
|
||||
global.NX_GRAPH_CREATION = true;
|
||||
const graphNodes = await retrieveProjectConfigurations(
|
||||
plugins,
|
||||
workspaceRoot,
|
||||
nxJson
|
||||
);
|
||||
@ -234,6 +229,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(
|
||||
deletedFiles
|
||||
);
|
||||
const g = createAndSerializeProjectGraph(graphNodes);
|
||||
|
||||
delete global.NX_GRAPH_CREATION;
|
||||
return g;
|
||||
} catch (err) {
|
||||
@ -281,8 +277,7 @@ async function createAndSerializeProjectGraph({
|
||||
allWorkspaceFiles,
|
||||
rustReferences,
|
||||
currentProjectFileMapCache || readFileMapCache(),
|
||||
true,
|
||||
await getPlugins()
|
||||
true
|
||||
);
|
||||
currentProjectFileMapCache = projectFileMapCache;
|
||||
currentProjectGraph = projectGraph;
|
||||
|
||||
@ -4,26 +4,21 @@ import { serverLogger } from './logger';
|
||||
import { serializeResult } from '../socket-utils';
|
||||
import { deleteDaemonJsonProcessCache } from '../cache';
|
||||
import type { Watcher } from '../../native';
|
||||
import { cleanupPlugins } from './plugins';
|
||||
|
||||
export const SERVER_INACTIVITY_TIMEOUT_MS = 10800000 as const; // 10800000 ms = 3 hours
|
||||
|
||||
let watcherInstance: Watcher | undefined;
|
||||
|
||||
export function storeWatcherInstance(instance: Watcher) {
|
||||
watcherInstance = instance;
|
||||
}
|
||||
|
||||
export function getWatcherInstance() {
|
||||
return watcherInstance;
|
||||
}
|
||||
|
||||
let outputWatcherInstance: Watcher | undefined;
|
||||
|
||||
export function storeOutputWatcherInstance(instance: Watcher) {
|
||||
outputWatcherInstance = instance;
|
||||
}
|
||||
|
||||
export function getOutputWatcherInstance() {
|
||||
return outputWatcherInstance;
|
||||
}
|
||||
@ -40,7 +35,6 @@ export async function handleServerProcessTermination({
|
||||
try {
|
||||
server.close();
|
||||
deleteDaemonJsonProcessCache();
|
||||
cleanupPlugins();
|
||||
|
||||
if (watcherInstance) {
|
||||
await watcherInstance.stop();
|
||||
|
||||
@ -47,19 +47,16 @@ export { workspaceLayout } from './config/configuration';
|
||||
|
||||
export type {
|
||||
NxPlugin,
|
||||
NxPluginV1,
|
||||
NxPluginV2,
|
||||
ProjectTargetConfigurator,
|
||||
CreateNodes,
|
||||
CreateNodesFunction,
|
||||
CreateNodesResult,
|
||||
CreateNodesContext,
|
||||
CreateDependencies,
|
||||
CreateDependenciesContext,
|
||||
} from './project-graph/plugins';
|
||||
|
||||
export type {
|
||||
NxPluginV1,
|
||||
ProjectTargetConfigurator,
|
||||
} from './utils/nx-plugin.deprecated';
|
||||
} from './utils/nx-plugin';
|
||||
|
||||
/**
|
||||
* @category Workspace
|
||||
|
||||
@ -7,7 +7,6 @@ import { readNxJson } from '../../config/nx-json';
|
||||
import { Executor, ExecutorContext } from '../../config/misc-interfaces';
|
||||
import { retrieveProjectConfigurations } from '../../project-graph/utils/retrieve-workspace-files';
|
||||
import { ProjectsConfigurations } from '../../config/workspace-json-project-json';
|
||||
import { loadNxPluginsInIsolation } from '../../project-graph/plugins/internal-api';
|
||||
|
||||
/**
|
||||
* Convert an Nx Executor into an Angular Devkit Builder
|
||||
@ -18,22 +17,15 @@ export function convertNxExecutor(executor: Executor) {
|
||||
const builderFunction = (options, builderContext) => {
|
||||
const promise = async () => {
|
||||
const nxJsonConfiguration = readNxJson(builderContext.workspaceRoot);
|
||||
|
||||
const [plugins, cleanup] = await loadNxPluginsInIsolation(
|
||||
nxJsonConfiguration.plugins,
|
||||
builderContext.workspaceRoot
|
||||
);
|
||||
const projectsConfigurations: ProjectsConfigurations = {
|
||||
version: 2,
|
||||
projects: (
|
||||
await retrieveProjectConfigurations(
|
||||
plugins,
|
||||
builderContext.workspaceRoot,
|
||||
nxJsonConfiguration
|
||||
)
|
||||
).projects,
|
||||
};
|
||||
cleanup();
|
||||
const context: ExecutorContext = {
|
||||
root: builderContext.workspaceRoot,
|
||||
projectName: builderContext.target.project,
|
||||
|
||||
@ -4,7 +4,7 @@ import { basename, join, relative } from 'path';
|
||||
import {
|
||||
buildProjectConfigurationFromPackageJson,
|
||||
getGlobPatternsFromPackageManagerWorkspaces,
|
||||
createNodes as packageJsonWorkspacesCreateNodes,
|
||||
getNxPackageJsonWorkspacesPlugin,
|
||||
} from '../../plugins/package-json-workspaces';
|
||||
import {
|
||||
buildProjectFromProjectJson,
|
||||
@ -28,7 +28,6 @@ import { readJson, writeJson } from './json';
|
||||
import { readNxJson } from './nx-json';
|
||||
|
||||
import type { Tree } from '../tree';
|
||||
import { NxPlugin } from '../../project-graph/plugins';
|
||||
|
||||
export { readNxJson, updateNxJson } from './nx-json';
|
||||
|
||||
@ -201,8 +200,8 @@ function readAndCombineAllProjectConfigurations(tree: Tree): {
|
||||
),
|
||||
];
|
||||
const projectGlobPatterns = configurationGlobs([
|
||||
ProjectJsonProjectsPlugin,
|
||||
{ createNodes: packageJsonWorkspacesCreateNodes } as NxPlugin,
|
||||
{ plugin: ProjectJsonProjectsPlugin },
|
||||
{ plugin: getNxPackageJsonWorkspacesPlugin(tree.root) },
|
||||
]);
|
||||
const globbedFiles = globWithWorkspaceContext(tree.root, projectGlobPatterns);
|
||||
const createdFiles = findCreatedProjectFiles(tree, patterns);
|
||||
|
||||
@ -4,13 +4,13 @@ import { dirname } from 'path';
|
||||
import { readJson, writeJson } from '../../generators/utils/json';
|
||||
import { formatChangedFilesWithPrettierIfAvailable } from '../../generators/internal-utils/format-changed-files-with-prettier-if-available';
|
||||
import { retrieveProjectConfigurationPaths } from '../../project-graph/utils/retrieve-workspace-files';
|
||||
import { loadPlugins } from '../../project-graph/plugins/internal-api';
|
||||
import { loadNxPlugins } from '../../utils/nx-plugin';
|
||||
|
||||
export default async function (tree: Tree) {
|
||||
const nxJson = readNxJson(tree);
|
||||
const projectFiles = retrieveProjectConfigurationPaths(
|
||||
const projectFiles = await retrieveProjectConfigurationPaths(
|
||||
tree.root,
|
||||
(await loadPlugins(nxJson?.plugins ?? [], tree.root)).map((p) => p.plugin)
|
||||
await loadNxPlugins(nxJson?.plugins)
|
||||
);
|
||||
const projectJsons = projectFiles.filter((f) => f.endsWith('project.json'));
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ import {
|
||||
CreateDependencies,
|
||||
CreateDependenciesContext,
|
||||
CreateNodes,
|
||||
} from '../../project-graph/plugins';
|
||||
} from '../../utils/nx-plugin';
|
||||
import {
|
||||
getLockFileDependencies,
|
||||
getLockFileName,
|
||||
|
||||
@ -37,7 +37,7 @@ import {
|
||||
import { pruneProjectGraph } from './project-graph-pruning';
|
||||
import { normalizePackageJson } from './utils/package-json';
|
||||
import { readJsonFile } from '../../../utils/fileutils';
|
||||
import { CreateDependenciesContext } from '../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../utils/nx-plugin';
|
||||
|
||||
const YARN_LOCK_FILE = 'yarn.lock';
|
||||
const NPM_LOCK_FILE = 'package-lock.json';
|
||||
|
||||
@ -8,7 +8,7 @@ import { pruneProjectGraph } from './project-graph-pruning';
|
||||
import { vol } from 'memfs';
|
||||
import { ProjectGraph } from '../../../config/project-graph';
|
||||
import { ProjectGraphBuilder } from '../../../project-graph/project-graph-builder';
|
||||
import { CreateDependenciesContext } from '../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../utils/nx-plugin';
|
||||
|
||||
jest.mock('fs', () => {
|
||||
const memFs = require('memfs').fs;
|
||||
|
||||
@ -13,7 +13,7 @@ import {
|
||||
ProjectGraphExternalNode,
|
||||
} from '../../../config/project-graph';
|
||||
import { hashArray } from '../../../hasher/file-hasher';
|
||||
import { CreateDependenciesContext } from '../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../utils/nx-plugin';
|
||||
|
||||
/**
|
||||
* NPM
|
||||
|
||||
@ -11,7 +11,7 @@ import {
|
||||
ProjectGraphBuilder,
|
||||
RawProjectGraphDependency,
|
||||
} from '../../../project-graph/project-graph-builder';
|
||||
import { CreateDependenciesContext } from '../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../utils/nx-plugin';
|
||||
|
||||
jest.mock('fs', () => {
|
||||
const memFs = require('memfs').fs;
|
||||
|
||||
@ -25,7 +25,7 @@ import {
|
||||
ProjectGraphExternalNode,
|
||||
} from '../../../config/project-graph';
|
||||
import { hashArray } from '../../../hasher/file-hasher';
|
||||
import { CreateDependenciesContext } from '../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../utils/nx-plugin';
|
||||
|
||||
// we use key => node map to avoid duplicate work when parsing keys
|
||||
let keyMap = new Map<string, ProjectGraphExternalNode>();
|
||||
|
||||
@ -9,7 +9,7 @@ import { vol } from 'memfs';
|
||||
import { ProjectGraph } from '../../../config/project-graph';
|
||||
import { PackageJson } from '../../../utils/package-json';
|
||||
import { ProjectGraphBuilder } from '../../../project-graph/project-graph-builder';
|
||||
import { CreateDependenciesContext } from '../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../utils/nx-plugin';
|
||||
|
||||
jest.mock('fs', () => {
|
||||
const memFs = require('memfs').fs;
|
||||
|
||||
@ -14,7 +14,7 @@ import {
|
||||
} from '../../../config/project-graph';
|
||||
import { hashArray } from '../../../hasher/file-hasher';
|
||||
import { sortObjectByKeys } from '../../../utils/object-sort';
|
||||
import { CreateDependenciesContext } from '../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../utils/nx-plugin';
|
||||
|
||||
/**
|
||||
* Yarn
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
import { buildExplicitTypeScriptDependencies } from './explicit-project-dependencies';
|
||||
import { buildExplicitPackageJsonDependencies } from './explicit-package-json-dependencies';
|
||||
import { CreateDependenciesContext } from '../../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../../utils/nx-plugin';
|
||||
import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
|
||||
|
||||
export function buildExplicitDependencies(
|
||||
|
||||
@ -6,7 +6,7 @@ import { buildExplicitPackageJsonDependencies } from './explicit-package-json-de
|
||||
import { ProjectGraphProjectNode } from '../../../../config/project-graph';
|
||||
import { ProjectGraphBuilder } from '../../../../project-graph/project-graph-builder';
|
||||
import { createFileMap } from '../../../../project-graph/file-map-utils';
|
||||
import { CreateDependenciesContext } from '../../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../../utils/nx-plugin';
|
||||
import { getAllFileDataInContext } from '../../../../utils/workspace-context';
|
||||
|
||||
describe('explicit package json dependencies', () => {
|
||||
|
||||
@ -9,7 +9,7 @@ import {
|
||||
} from '../../../../config/workspace-json-project-json';
|
||||
import { NxJsonConfiguration } from '../../../../config/nx-json';
|
||||
import { PackageJson } from '../../../../utils/package-json';
|
||||
import { CreateDependenciesContext } from '../../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../../utils/nx-plugin';
|
||||
import {
|
||||
RawProjectGraphDependency,
|
||||
validateDependency,
|
||||
|
||||
@ -1,17 +1,15 @@
|
||||
import { TempFs } from '../../../../internal-testing-utils/temp-fs';
|
||||
|
||||
const tempFs = new TempFs('explicit-project-deps');
|
||||
|
||||
import { ProjectGraphBuilder } from '../../../../project-graph/project-graph-builder';
|
||||
import { buildExplicitTypeScriptDependencies } from './explicit-project-dependencies';
|
||||
import {
|
||||
retrieveProjectConfigurationPaths,
|
||||
retrieveProjectConfigurations,
|
||||
retrieveWorkspaceFiles,
|
||||
} from '../../../../project-graph/utils/retrieve-workspace-files';
|
||||
import { CreateDependenciesContext } from '../../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../../utils/nx-plugin';
|
||||
import { setupWorkspaceContext } from '../../../../utils/workspace-context';
|
||||
import ProjectJsonProjectsPlugin from '../../../project-json/build-nodes/project-json';
|
||||
import { loadNxPluginsInIsolation } from '../../../../project-graph/plugins/internal-api';
|
||||
|
||||
// projectName => tsconfig import path
|
||||
const dependencyProjectNamesToImportPaths = {
|
||||
@ -566,13 +564,10 @@ async function createContext(
|
||||
|
||||
setupWorkspaceContext(tempFs.tempDir);
|
||||
|
||||
const [plugins, cleanup] = await loadNxPluginsInIsolation([], tempFs.tempDir);
|
||||
const { projects, projectRootMap } = await retrieveProjectConfigurations(
|
||||
plugins,
|
||||
tempFs.tempDir,
|
||||
nxJson
|
||||
);
|
||||
cleanup();
|
||||
|
||||
const { fileMap } = await retrieveWorkspaceFiles(
|
||||
tempFs.tempDir,
|
||||
|
||||
@ -6,7 +6,7 @@ import {
|
||||
import { join, relative } from 'path';
|
||||
import { workspaceRoot } from '../../../../utils/workspace-root';
|
||||
import { normalizePath } from '../../../../utils/path';
|
||||
import { CreateDependenciesContext } from '../../../../project-graph/plugins';
|
||||
import { CreateDependenciesContext } from '../../../../utils/nx-plugin';
|
||||
import {
|
||||
RawProjectGraphDependency,
|
||||
validateDependency,
|
||||
|
||||
@ -8,22 +8,23 @@ import { toProjectName } from '../../config/workspaces';
|
||||
import { readJsonFile, readYamlFile } from '../../utils/fileutils';
|
||||
import { combineGlobPatterns } from '../../utils/globs';
|
||||
import { NX_PREFIX } from '../../utils/logger';
|
||||
import { NxPluginV2 } from '../../utils/nx-plugin';
|
||||
import { output } from '../../utils/output';
|
||||
import {
|
||||
PackageJson,
|
||||
readTargetsFromPackageJson,
|
||||
} from '../../utils/package-json';
|
||||
import { joinPathFragments } from '../../utils/path';
|
||||
import { workspaceRoot } from '../../utils/workspace-root';
|
||||
import { CreateNodes } from '../../project-graph/plugins';
|
||||
|
||||
const readJson = (f) => readJsonFile(join(workspaceRoot, f));
|
||||
const patterns = getGlobPatternsFromPackageManagerWorkspaces(
|
||||
workspaceRoot,
|
||||
readJson
|
||||
);
|
||||
export function getNxPackageJsonWorkspacesPlugin(root: string): NxPluginV2 {
|
||||
const readJson = (f) => readJsonFile(join(root, f));
|
||||
const patterns = getGlobPatternsFromPackageManagerWorkspaces(root, readJson);
|
||||
|
||||
// If the user only specified a negative pattern, we should find all package.json
|
||||
// files and only return those that don't match a negative pattern.
|
||||
const negativePatterns = patterns.filter((p) => p.startsWith('!'));
|
||||
const positivePatterns = patterns.filter((p) => !p.startsWith('!'));
|
||||
let positivePatterns = patterns.filter((p) => !p.startsWith('!'));
|
||||
|
||||
if (
|
||||
// There are some negative patterns
|
||||
negativePatterns.length > 0 &&
|
||||
@ -34,16 +35,21 @@ if (
|
||||
) {
|
||||
positivePatterns.push('**/package.json');
|
||||
}
|
||||
export const createNodes: CreateNodes = [
|
||||
|
||||
return {
|
||||
name: 'nx/core/package-json-workspaces',
|
||||
createNodes: [
|
||||
combineGlobPatterns(positivePatterns),
|
||||
(p, _, { workspaceRoot }) => {
|
||||
(p) => {
|
||||
if (!negativePatterns.some((negative) => minimatch(p, negative))) {
|
||||
return createNodeFromPackageJson(p, workspaceRoot);
|
||||
return createNodeFromPackageJson(p, root);
|
||||
}
|
||||
// A negative pattern matched, so we should not create a node for this package.json
|
||||
return {};
|
||||
},
|
||||
];
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
export function createNodeFromPackageJson(pkgJsonPath: string, root: string) {
|
||||
const json: PackageJson = readJsonFile(join(root, pkgJsonPath));
|
||||
|
||||
@ -1,2 +1 @@
|
||||
export * from './create-nodes';
|
||||
export const name = 'nx/core/package-json-workspaces';
|
||||
|
||||
@ -3,7 +3,7 @@ import * as memfs from 'memfs';
|
||||
import '../../../internal-testing-utils/mock-fs';
|
||||
|
||||
import { PackageJsonProjectsNextToProjectJsonPlugin } from './package-json-next-to-project-json';
|
||||
import { CreateNodesContext } from '../../../project-graph/plugins';
|
||||
import { CreateNodesContext } from '../../../utils/nx-plugin';
|
||||
const { createNodes } = PackageJsonProjectsNextToProjectJsonPlugin;
|
||||
|
||||
describe('nx project.json plugin', () => {
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
import { dirname, join } from 'path';
|
||||
import { existsSync } from 'fs';
|
||||
import { NxPluginV2 } from '../../../project-graph/plugins';
|
||||
import { NxPluginV2 } from '../../../utils/nx-plugin';
|
||||
import { readJsonFile } from '../../../utils/fileutils';
|
||||
import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
|
||||
import {
|
||||
@ -33,8 +33,6 @@ export const PackageJsonProjectsNextToProjectJsonPlugin: NxPluginV2 = {
|
||||
],
|
||||
};
|
||||
|
||||
export default PackageJsonProjectsNextToProjectJsonPlugin;
|
||||
|
||||
function createProjectFromPackageJsonNextToProjectJson(
|
||||
projectJsonPath: string,
|
||||
workspaceRoot: string
|
||||
|
||||
@ -3,7 +3,7 @@ import * as memfs from 'memfs';
|
||||
import '../../../internal-testing-utils/mock-fs';
|
||||
|
||||
import { ProjectJsonProjectsPlugin } from './project-json';
|
||||
import { CreateNodesContext } from '../../../project-graph/plugins';
|
||||
import { CreateNodesContext } from '../../../utils/nx-plugin';
|
||||
const { createNodes } = ProjectJsonProjectsPlugin;
|
||||
|
||||
describe('nx project.json plugin', () => {
|
||||
|
||||
@ -3,7 +3,7 @@ import { dirname, join } from 'node:path';
|
||||
import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
|
||||
import { toProjectName } from '../../../config/workspaces';
|
||||
import { readJsonFile } from '../../../utils/fileutils';
|
||||
import { NxPluginV2 } from '../../../project-graph/plugins';
|
||||
import { NxPluginV2 } from '../../../utils/nx-plugin';
|
||||
|
||||
export const ProjectJsonProjectsPlugin: NxPluginV2 = {
|
||||
name: 'nx/core/project-json',
|
||||
@ -23,8 +23,6 @@ export const ProjectJsonProjectsPlugin: NxPluginV2 = {
|
||||
],
|
||||
};
|
||||
|
||||
export default ProjectJsonProjectsPlugin;
|
||||
|
||||
export function buildProjectFromProjectJson(
|
||||
json: Partial<ProjectConfiguration>,
|
||||
path: string
|
||||
|
||||
@ -3,7 +3,7 @@ import * as memfs from 'memfs';
|
||||
import '../../../src/internal-testing-utils/mock-fs';
|
||||
|
||||
import { getTargetInfo, TargetDefaultsPlugin } from './target-defaults-plugin';
|
||||
import { CreateNodesContext } from '../../project-graph/plugins';
|
||||
import { CreateNodesContext } from '../../utils/nx-plugin';
|
||||
const {
|
||||
createNodes: [, createNodesFn],
|
||||
} = TargetDefaultsPlugin;
|
||||
|
||||
@ -8,7 +8,7 @@ import {
|
||||
} from '../../config/workspace-json-project-json';
|
||||
import { readJsonFile } from '../../utils/fileutils';
|
||||
import { combineGlobPatterns } from '../../utils/globs';
|
||||
import { NxPluginV2 } from '../../project-graph/plugins';
|
||||
import { NxPluginV2 } from '../../utils/nx-plugin';
|
||||
import {
|
||||
PackageJson,
|
||||
readTargetsFromPackageJson,
|
||||
@ -127,8 +127,6 @@ export const TargetDefaultsPlugin: NxPluginV2 = {
|
||||
],
|
||||
};
|
||||
|
||||
export default TargetDefaultsPlugin;
|
||||
|
||||
function getExecutorToTargetMap(
|
||||
packageJsonTargets: Record<string, TargetConfiguration>,
|
||||
projectJsonTargets: Record<string, TargetConfiguration>
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
import { ProjectGraphProjectNode } from '../../../config/project-graph';
|
||||
import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
|
||||
|
||||
import * as nxPlugin from '../../../project-graph/plugins';
|
||||
import * as nxPlugin from '../../../utils/nx-plugin';
|
||||
import { DeletedFileChange } from '../../file-utils';
|
||||
import { getTouchedProjectsFromProjectGlobChanges } from './project-glob-changes';
|
||||
|
||||
|
||||
@ -1,17 +1,23 @@
|
||||
import { TouchedProjectLocator } from '../affected-project-graph-models';
|
||||
import { minimatch } from 'minimatch';
|
||||
import { workspaceRoot } from '../../../utils/workspace-root';
|
||||
import { getNxRequirePaths } from '../../../utils/installation-directory';
|
||||
import { join } from 'path';
|
||||
import { existsSync } from 'fs';
|
||||
import { configurationGlobs } from '../../utils/retrieve-workspace-files';
|
||||
import { loadPlugins } from '../../plugins/internal-api';
|
||||
import { loadNxPlugins } from '../../../utils/nx-plugin';
|
||||
import { combineGlobPatterns } from '../../../utils/globs';
|
||||
|
||||
export const getTouchedProjectsFromProjectGlobChanges: TouchedProjectLocator =
|
||||
async (touchedFiles, projectGraphNodes, nxJson): Promise<string[]> => {
|
||||
const plugins = await loadPlugins(nxJson?.plugins ?? [], workspaceRoot);
|
||||
const globPattern = combineGlobPatterns(
|
||||
configurationGlobs(plugins.map((p) => p.plugin))
|
||||
configurationGlobs(
|
||||
await loadNxPlugins(
|
||||
nxJson?.plugins,
|
||||
getNxRequirePaths(workspaceRoot),
|
||||
workspaceRoot
|
||||
)
|
||||
)
|
||||
);
|
||||
|
||||
const touchedProjects = new Set<string>();
|
||||
|
||||
@ -13,9 +13,12 @@ import {
|
||||
} from './nx-deps-cache';
|
||||
import { applyImplicitDependencies } from './utils/implicit-project-dependencies';
|
||||
import { normalizeProjectNodes } from './utils/normalize-project-nodes';
|
||||
import { RemotePlugin } from './plugins/internal-api';
|
||||
import { isNxPluginV1, isNxPluginV2 } from './plugins/utils';
|
||||
import { CreateDependenciesContext } from './plugins';
|
||||
import {
|
||||
CreateDependenciesContext,
|
||||
isNxPluginV1,
|
||||
isNxPluginV2,
|
||||
loadNxPlugins,
|
||||
} from '../utils/nx-plugin';
|
||||
import { getRootTsConfigPath } from '../plugins/js/utils/typescript';
|
||||
import {
|
||||
FileMap,
|
||||
@ -29,8 +32,9 @@ import { ProjectConfiguration } from '../config/workspace-json-project-json';
|
||||
import { readNxJson } from '../config/configuration';
|
||||
import { existsSync } from 'fs';
|
||||
import { PackageJson } from '../utils/package-json';
|
||||
import { getNxRequirePaths } from '../utils/installation-directory';
|
||||
import { output } from '../utils/output';
|
||||
import { NxWorkspaceFilesExternals } from '../native';
|
||||
import { ExternalObject, NxWorkspaceFilesExternals } from '../native';
|
||||
|
||||
let storedFileMap: FileMap | null = null;
|
||||
let storedAllWorkspaceFiles: FileData[] | null = null;
|
||||
@ -66,8 +70,7 @@ export async function buildProjectGraphUsingProjectFileMap(
|
||||
allWorkspaceFiles: FileData[],
|
||||
rustReferences: NxWorkspaceFilesExternals,
|
||||
fileMapCache: FileMapCache | null,
|
||||
shouldWriteCache: boolean,
|
||||
plugins: RemotePlugin[]
|
||||
shouldWriteCache: boolean
|
||||
): Promise<{
|
||||
projectGraph: ProjectGraph;
|
||||
projectFileMapCache: FileMapCache;
|
||||
@ -117,8 +120,7 @@ export async function buildProjectGraphUsingProjectFileMap(
|
||||
externalNodes,
|
||||
context,
|
||||
cachedFileData,
|
||||
projectGraphVersion,
|
||||
plugins
|
||||
projectGraphVersion
|
||||
);
|
||||
const projectFileMapCache = createProjectFileMapCache(
|
||||
nxJson,
|
||||
@ -164,8 +166,7 @@ async function buildProjectGraphUsingContext(
|
||||
knownExternalNodes: Record<string, ProjectGraphExternalNode>,
|
||||
ctx: CreateDependenciesContext,
|
||||
cachedFileData: CachedFileData,
|
||||
projectGraphVersion: string,
|
||||
plugins: RemotePlugin[]
|
||||
projectGraphVersion: string
|
||||
) {
|
||||
performance.mark('build project graph:start');
|
||||
|
||||
@ -178,7 +179,7 @@ async function buildProjectGraphUsingContext(
|
||||
await normalizeProjectNodes(ctx, builder);
|
||||
const initProjectGraph = builder.getUpdatedProjectGraph();
|
||||
|
||||
const r = await updateProjectGraphWithPlugins(ctx, initProjectGraph, plugins);
|
||||
const r = await updateProjectGraphWithPlugins(ctx, initProjectGraph);
|
||||
|
||||
const updatedBuilder = new ProjectGraphBuilder(r, ctx.fileMap.projectFileMap);
|
||||
for (const proj of Object.keys(cachedFileData.projectFileMap)) {
|
||||
@ -235,11 +236,16 @@ function createContext(
|
||||
|
||||
async function updateProjectGraphWithPlugins(
|
||||
context: CreateDependenciesContext,
|
||||
initProjectGraph: ProjectGraph,
|
||||
plugins: RemotePlugin[]
|
||||
initProjectGraph: ProjectGraph
|
||||
) {
|
||||
const plugins = await loadNxPlugins(
|
||||
context.nxJsonConfiguration?.plugins,
|
||||
getNxRequirePaths(),
|
||||
context.workspaceRoot,
|
||||
context.projects
|
||||
);
|
||||
let graph = initProjectGraph;
|
||||
for (const plugin of plugins) {
|
||||
for (const { plugin } of plugins) {
|
||||
try {
|
||||
if (
|
||||
isNxPluginV1(plugin) &&
|
||||
@ -291,15 +297,14 @@ async function updateProjectGraphWithPlugins(
|
||||
);
|
||||
|
||||
const createDependencyPlugins = plugins.filter(
|
||||
(plugin) => isNxPluginV2(plugin) && plugin.createDependencies
|
||||
({ plugin }) => isNxPluginV2(plugin) && plugin.createDependencies
|
||||
);
|
||||
await Promise.all(
|
||||
createDependencyPlugins.map(async (plugin) => {
|
||||
createDependencyPlugins.map(async ({ plugin, options }) => {
|
||||
performance.mark(`${plugin.name}:createDependencies - start`);
|
||||
|
||||
try {
|
||||
// TODO: we shouldn't have to pass null here
|
||||
const dependencies = await plugin.createDependencies(null, {
|
||||
const dependencies = await plugin.createDependencies(options, {
|
||||
...context,
|
||||
});
|
||||
|
||||
|
||||
@ -27,6 +27,7 @@ import { getDefaultPluginsSync } from '../utils/nx-plugin.deprecated';
|
||||
import { minimatch } from 'minimatch';
|
||||
import { CreateNodesResult } from '../devkit-exports';
|
||||
import { PackageJsonProjectsNextToProjectJsonPlugin } from '../plugins/project-json/build-nodes/package-json-next-to-project-json';
|
||||
import { LoadedNxPlugin } from '../utils/nx-plugin';
|
||||
|
||||
export interface Change {
|
||||
type: string;
|
||||
@ -183,9 +184,9 @@ export { readNxJson, workspaceLayout } from '../config/configuration';
|
||||
function getProjectsSyncNoInference(root: string, nxJson: NxJsonConfiguration) {
|
||||
const projectFiles = retrieveProjectConfigurationPaths(
|
||||
root,
|
||||
getDefaultPluginsSync(root).map((p) => p.plugin)
|
||||
getDefaultPluginsSync(root)
|
||||
);
|
||||
const plugins = [
|
||||
const plugins: LoadedNxPlugin[] = [
|
||||
{ plugin: PackageJsonProjectsNextToProjectJsonPlugin },
|
||||
...getDefaultPluginsSync(root),
|
||||
];
|
||||
@ -193,21 +194,17 @@ function getProjectsSyncNoInference(root: string, nxJson: NxJsonConfiguration) {
|
||||
const projectRootMap: Map<string, ProjectConfiguration> = new Map();
|
||||
|
||||
// We iterate over plugins first - this ensures that plugins specified first take precedence.
|
||||
for (const { plugin } of plugins) {
|
||||
for (const { plugin, options } of plugins) {
|
||||
const [pattern, createNodes] = plugin.createNodes ?? [];
|
||||
if (!pattern) {
|
||||
continue;
|
||||
}
|
||||
for (const file of projectFiles) {
|
||||
if (minimatch(file, pattern, { dot: true })) {
|
||||
let r = createNodes(
|
||||
file,
|
||||
{},
|
||||
{
|
||||
let r = createNodes(file, options, {
|
||||
nxJsonConfiguration: nxJson,
|
||||
workspaceRoot: root,
|
||||
}
|
||||
) as CreateNodesResult;
|
||||
}) as CreateNodesResult;
|
||||
for (const node in r.projects) {
|
||||
const project = {
|
||||
root: node,
|
||||
|
||||
@ -1,6 +0,0 @@
|
||||
export * from './public-api';
|
||||
|
||||
export {
|
||||
readPluginPackageJson,
|
||||
registerPluginTSTranspiler,
|
||||
} from './worker-api';
|
||||
@ -1,117 +0,0 @@
|
||||
// This file contains the bits and bobs of the internal API for loading and interacting with Nx plugins.
|
||||
// For the public API, used by plugin authors, see `./public-api.ts`.
|
||||
|
||||
import { join } from 'path';
|
||||
|
||||
import { workspaceRoot } from '../../utils/workspace-root';
|
||||
import { PluginConfiguration } from '../../config/nx-json';
|
||||
import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
|
||||
import { shouldMergeAngularProjects } from '../../adapter/angular-json';
|
||||
|
||||
import { loadRemoteNxPlugin } from './plugin-pool';
|
||||
import {
|
||||
CreateNodesContext,
|
||||
CreateNodesResult,
|
||||
NxPluginV2,
|
||||
} from './public-api';
|
||||
|
||||
export { loadPlugins, loadPlugin } from './worker-api';
|
||||
|
||||
export type CreateNodesResultWithContext = CreateNodesResult & {
|
||||
file: string;
|
||||
pluginName: string;
|
||||
};
|
||||
|
||||
export type NormalizedPlugin = NxPluginV2 &
|
||||
Pick<NxPluginV1, 'processProjectGraph'>;
|
||||
|
||||
// This represents a plugin loaded in a plugin-worker. This is not an API for plugin authors,
|
||||
// rather an internal representation of how to interact with a loaded plugin.
|
||||
export type RemotePlugin =
|
||||
// A remote plugin is a v2 plugin, with a slightly different API for create nodes.
|
||||
Omit<NormalizedPlugin, 'createNodes'> & {
|
||||
createNodes: [
|
||||
filePattern: string,
|
||||
// The create nodes function takes all matched files instead of just one, and includes
|
||||
// the result's context.
|
||||
fn: (
|
||||
matchedFiles: string[],
|
||||
context: CreateNodesContext
|
||||
) => Promise<CreateNodesResultWithContext[]>
|
||||
];
|
||||
};
|
||||
|
||||
// Short lived cache (cleared between cmd runs)
|
||||
// holding resolved nx plugin objects.
|
||||
// Allows loaded plugins to not be reloaded when
|
||||
// referenced multiple times.
|
||||
export const nxPluginCache: Map<unknown, [Promise<RemotePlugin>, () => void]> =
|
||||
new Map();
|
||||
|
||||
/**
|
||||
* This loads plugins in isolation in their own worker so that they do not disturb other workers or the main process.
|
||||
*/
|
||||
export async function loadNxPluginsInIsolation(
|
||||
plugins: PluginConfiguration[],
|
||||
root = workspaceRoot
|
||||
): Promise<[RemotePlugin[], () => void]> {
|
||||
const result: Promise<RemotePlugin>[] = [];
|
||||
|
||||
plugins ??= [];
|
||||
|
||||
plugins.unshift(
|
||||
join(
|
||||
__dirname,
|
||||
'../../plugins/project-json/build-nodes/package-json-next-to-project-json'
|
||||
)
|
||||
);
|
||||
|
||||
// We push the nx core node plugins onto the end, s.t. it overwrites any other plugins
|
||||
plugins.push(...(await getDefaultPlugins(root)));
|
||||
|
||||
const cleanupFunctions: Array<() => void> = [];
|
||||
for (const plugin of plugins) {
|
||||
const [loadedPluginPromise, cleanup] = loadNxPluginInIsolation(
|
||||
plugin,
|
||||
root
|
||||
);
|
||||
result.push(loadedPluginPromise);
|
||||
cleanupFunctions.push(cleanup);
|
||||
}
|
||||
|
||||
return [
|
||||
await Promise.all(result),
|
||||
() => {
|
||||
for (const fn of cleanupFunctions) {
|
||||
fn();
|
||||
}
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
export function loadNxPluginInIsolation(
|
||||
plugin: PluginConfiguration,
|
||||
root = workspaceRoot
|
||||
): [Promise<RemotePlugin>, () => void] {
|
||||
const cacheKey = JSON.stringify(plugin);
|
||||
|
||||
if (nxPluginCache.has(cacheKey)) {
|
||||
return nxPluginCache.get(cacheKey);
|
||||
}
|
||||
|
||||
const [loadingPlugin, cleanup] = loadRemoteNxPlugin(plugin, root);
|
||||
nxPluginCache.set(cacheKey, [loadingPlugin, cleanup]);
|
||||
return [loadingPlugin, cleanup];
|
||||
}
|
||||
|
||||
export async function getDefaultPlugins(root: string) {
|
||||
return [
|
||||
join(__dirname, '../../plugins/js'),
|
||||
join(__dirname, '../../plugins/target-defaults/target-defaults-plugin'),
|
||||
...(shouldMergeAngularProjects(root, false)
|
||||
? [join(__dirname, '../../adapter/angular-json')]
|
||||
: []),
|
||||
join(__dirname, '../../plugins/package-json-workspaces'),
|
||||
join(__dirname, '../../plugins/project-json/build-nodes/project-json'),
|
||||
];
|
||||
}
|
||||
@ -1,153 +0,0 @@
|
||||
import {
|
||||
ProjectGraph,
|
||||
ProjectGraphProcessorContext,
|
||||
} from '../../config/project-graph';
|
||||
import { PluginConfiguration } from '../../config/nx-json';
|
||||
import { CreateDependenciesContext, CreateNodesContext } from './public-api';
|
||||
import { RemotePlugin } from './internal-api';
|
||||
|
||||
export interface PluginWorkerLoadMessage {
|
||||
type: 'load';
|
||||
payload: {
|
||||
plugin: PluginConfiguration;
|
||||
root: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface PluginWorkerLoadResult {
|
||||
type: 'load-result';
|
||||
payload:
|
||||
| {
|
||||
name: string;
|
||||
createNodesPattern: string;
|
||||
hasCreateDependencies: boolean;
|
||||
hasProcessProjectGraph: boolean;
|
||||
success: true;
|
||||
}
|
||||
| {
|
||||
success: false;
|
||||
error: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface PluginWorkerCreateNodesMessage {
|
||||
type: 'createNodes';
|
||||
payload: {
|
||||
configFiles: string[];
|
||||
context: CreateNodesContext;
|
||||
tx: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface PluginWorkerCreateNodesResult {
|
||||
type: 'createNodesResult';
|
||||
payload:
|
||||
| {
|
||||
success: true;
|
||||
result: Awaited<ReturnType<RemotePlugin['createNodes'][1]>>;
|
||||
tx: string;
|
||||
}
|
||||
| {
|
||||
success: false;
|
||||
error: string;
|
||||
tx: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface PluginCreateDependenciesMessage {
|
||||
type: 'createDependencies';
|
||||
payload: {
|
||||
context: CreateDependenciesContext;
|
||||
tx: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface PluginCreateDependenciesResult {
|
||||
type: 'createDependenciesResult';
|
||||
payload:
|
||||
| {
|
||||
dependencies: ReturnType<RemotePlugin['createDependencies']>;
|
||||
success: true;
|
||||
tx: string;
|
||||
}
|
||||
| {
|
||||
success: false;
|
||||
error: string;
|
||||
tx: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface PluginWorkerProcessProjectGraphMessage {
|
||||
type: 'processProjectGraph';
|
||||
payload: {
|
||||
graph: ProjectGraph;
|
||||
ctx: ProjectGraphProcessorContext;
|
||||
tx: string;
|
||||
};
|
||||
}
|
||||
|
||||
export interface PluginWorkerProcessProjectGraphResult {
|
||||
type: 'processProjectGraphResult';
|
||||
payload:
|
||||
| {
|
||||
graph: ProjectGraph;
|
||||
success: true;
|
||||
tx: string;
|
||||
}
|
||||
| {
|
||||
success: false;
|
||||
error: string;
|
||||
tx: string;
|
||||
};
|
||||
}
|
||||
|
||||
export type PluginWorkerMessage =
|
||||
| PluginWorkerLoadMessage
|
||||
| PluginWorkerCreateNodesMessage
|
||||
| PluginCreateDependenciesMessage
|
||||
| PluginWorkerProcessProjectGraphMessage;
|
||||
|
||||
export type PluginWorkerResult =
|
||||
| PluginWorkerLoadResult
|
||||
| PluginWorkerCreateNodesResult
|
||||
| PluginCreateDependenciesResult
|
||||
| PluginWorkerProcessProjectGraphResult;
|
||||
|
||||
type MaybePromise<T> = T | Promise<T>;
|
||||
|
||||
// The handler can return a message to be sent back to the process from which the message originated
|
||||
type MessageHandlerReturn<T extends PluginWorkerMessage | PluginWorkerResult> =
|
||||
T extends PluginWorkerResult
|
||||
? MaybePromise<PluginWorkerMessage | void>
|
||||
: MaybePromise<PluginWorkerResult | void>;
|
||||
|
||||
// Takes a message and a map of handlers and calls the appropriate handler
|
||||
// type safe and requires all handlers to be handled
|
||||
export async function consumeMessage<
|
||||
T extends PluginWorkerMessage | PluginWorkerResult
|
||||
>(
|
||||
raw: string | T,
|
||||
handlers: {
|
||||
[K in T['type']]: (
|
||||
// Extract restricts the type of payload to the payload of the message with the type K
|
||||
payload: Extract<T, { type: K }>['payload']
|
||||
) => MessageHandlerReturn<T>;
|
||||
}
|
||||
) {
|
||||
const message: T = typeof raw === 'string' ? JSON.parse(raw) : raw;
|
||||
const handler = handlers[message.type];
|
||||
if (handler) {
|
||||
const response = await handler(message.payload);
|
||||
if (response) {
|
||||
process.send!(createMessage(response));
|
||||
}
|
||||
} else {
|
||||
throw new Error(`Unhandled message type: ${message.type}`);
|
||||
}
|
||||
}
|
||||
|
||||
export function createMessage(
|
||||
message: PluginWorkerMessage | PluginWorkerResult
|
||||
): string {
|
||||
return JSON.stringify(message);
|
||||
}
|
||||
@ -1,247 +0,0 @@
|
||||
import { ChildProcess, fork } from 'child_process';
|
||||
import path = require('path');
|
||||
|
||||
import { PluginConfiguration } from '../../config/nx-json';
|
||||
|
||||
// TODO (@AgentEnder): After scoped verbose logging is implemented, re-add verbose logs here.
|
||||
// import { logger } from '../../utils/logger';
|
||||
|
||||
import { RemotePlugin, nxPluginCache } from './internal-api';
|
||||
import { PluginWorkerResult, consumeMessage, createMessage } from './messaging';
|
||||
|
||||
const cleanupFunctions = new Set<() => void>();
|
||||
|
||||
const pluginNames = new Map<ChildProcess, string>();
|
||||
|
||||
interface PendingPromise {
|
||||
promise: Promise<unknown>;
|
||||
resolver: (result: any) => void;
|
||||
rejector: (err: any) => void;
|
||||
}
|
||||
|
||||
export function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string) {
|
||||
// this should only really be true when running unit tests within
|
||||
// the Nx repo. We still need to start the worker in this case,
|
||||
// but its typescript.
|
||||
const isWorkerTypescript = path.extname(__filename) === '.ts';
|
||||
const workerPath = path.join(__dirname, 'plugin-worker');
|
||||
const worker = fork(workerPath, [], {
|
||||
stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
|
||||
env: {
|
||||
...process.env,
|
||||
...(isWorkerTypescript
|
||||
? {
|
||||
// Ensures that the worker uses the same tsconfig as the main process
|
||||
TS_NODE_PROJECT: path.join(__dirname, '../../../tsconfig.lib.json'),
|
||||
}
|
||||
: {}),
|
||||
},
|
||||
execArgv: [
|
||||
...process.execArgv,
|
||||
// If the worker is typescript, we need to register ts-node
|
||||
...(isWorkerTypescript ? ['-r', 'ts-node/register'] : []),
|
||||
],
|
||||
});
|
||||
worker.send(createMessage({ type: 'load', payload: { plugin, root } }));
|
||||
|
||||
// logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
|
||||
|
||||
const pendingPromises = new Map<string, PendingPromise>();
|
||||
|
||||
const exitHandler = createWorkerExitHandler(worker, pendingPromises);
|
||||
|
||||
const cleanupFunction = () => {
|
||||
worker.off('exit', exitHandler);
|
||||
shutdownPluginWorker(worker, pendingPromises);
|
||||
};
|
||||
|
||||
cleanupFunctions.add(cleanupFunction);
|
||||
|
||||
return [
|
||||
new Promise<RemotePlugin>((res, rej) => {
|
||||
worker.on(
|
||||
'message',
|
||||
createWorkerHandler(worker, pendingPromises, res, rej)
|
||||
);
|
||||
worker.on('exit', exitHandler);
|
||||
}),
|
||||
() => {
|
||||
cleanupFunction();
|
||||
cleanupFunctions.delete(cleanupFunction);
|
||||
},
|
||||
] as const;
|
||||
}
|
||||
|
||||
async function shutdownPluginWorker(
|
||||
worker: ChildProcess,
|
||||
pendingPromises: Map<string, PendingPromise>
|
||||
) {
|
||||
// Clears the plugin cache so no refs to the workers are held
|
||||
nxPluginCache.clear();
|
||||
|
||||
// logger.verbose(`[plugin-pool] starting worker shutdown`);
|
||||
|
||||
// Other things may be interacting with the worker.
|
||||
// Wait for all pending promises to be done before killing the worker
|
||||
await Promise.all(
|
||||
Array.from(pendingPromises.values()).map(({ promise }) => promise)
|
||||
);
|
||||
|
||||
worker.kill('SIGINT');
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a message handler for the given worker.
|
||||
* @param worker Instance of plugin-worker
|
||||
* @param pending Set of pending promises
|
||||
* @param onload Resolver for RemotePlugin promise
|
||||
* @param onloadError Rejecter for RemotePlugin promise
|
||||
* @returns Function to handle messages from the worker
|
||||
*/
|
||||
function createWorkerHandler(
|
||||
worker: ChildProcess,
|
||||
pending: Map<string, PendingPromise>,
|
||||
onload: (plugin: RemotePlugin) => void,
|
||||
onloadError: (err?: unknown) => void
|
||||
) {
|
||||
let pluginName: string;
|
||||
|
||||
return function (message: string) {
|
||||
const parsed = JSON.parse(message);
|
||||
// logger.verbose(
|
||||
// `[plugin-pool] received message: ${parsed.type} from ${
|
||||
// pluginName ?? worker.pid
|
||||
// }`
|
||||
// );
|
||||
consumeMessage<PluginWorkerResult>(parsed, {
|
||||
'load-result': (result) => {
|
||||
if (result.success) {
|
||||
const { name, createNodesPattern } = result;
|
||||
pluginName = name;
|
||||
pluginNames.set(worker, pluginName);
|
||||
onload({
|
||||
name,
|
||||
createNodes: createNodesPattern
|
||||
? [
|
||||
createNodesPattern,
|
||||
(configFiles, ctx) => {
|
||||
const tx = pluginName + ':createNodes:' + performance.now();
|
||||
return registerPendingPromise(tx, pending, () => {
|
||||
worker.send(
|
||||
createMessage({
|
||||
type: 'createNodes',
|
||||
payload: { configFiles, context: ctx, tx },
|
||||
})
|
||||
);
|
||||
});
|
||||
},
|
||||
]
|
||||
: undefined,
|
||||
createDependencies: result.hasCreateDependencies
|
||||
? (opts, ctx) => {
|
||||
const tx =
|
||||
pluginName + ':createDependencies:' + performance.now();
|
||||
return registerPendingPromise(tx, pending, () => {
|
||||
worker.send(
|
||||
createMessage({
|
||||
type: 'createDependencies',
|
||||
payload: { context: ctx, tx },
|
||||
})
|
||||
);
|
||||
});
|
||||
}
|
||||
: undefined,
|
||||
processProjectGraph: result.hasProcessProjectGraph
|
||||
? (graph, ctx) => {
|
||||
const tx =
|
||||
pluginName + ':processProjectGraph:' + performance.now();
|
||||
return registerPendingPromise(tx, pending, () => {
|
||||
worker.send(
|
||||
createMessage({
|
||||
type: 'processProjectGraph',
|
||||
payload: { graph, ctx, tx },
|
||||
})
|
||||
);
|
||||
});
|
||||
}
|
||||
: undefined,
|
||||
});
|
||||
} else if (result.success === false) {
|
||||
onloadError(result.error);
|
||||
}
|
||||
},
|
||||
createDependenciesResult: ({ tx, ...result }) => {
|
||||
const { resolver, rejector } = pending.get(tx);
|
||||
if (result.success) {
|
||||
resolver(result.dependencies);
|
||||
} else if (result.success === false) {
|
||||
rejector(result.error);
|
||||
}
|
||||
},
|
||||
createNodesResult: ({ tx, ...result }) => {
|
||||
const { resolver, rejector } = pending.get(tx);
|
||||
if (result.success) {
|
||||
resolver(result.result);
|
||||
} else if (result.success === false) {
|
||||
rejector(result.error);
|
||||
}
|
||||
},
|
||||
processProjectGraphResult: ({ tx, ...result }) => {
|
||||
const { resolver, rejector } = pending.get(tx);
|
||||
if (result.success) {
|
||||
resolver(result.graph);
|
||||
} else if (result.success === false) {
|
||||
rejector(result.error);
|
||||
}
|
||||
},
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
function createWorkerExitHandler(
|
||||
worker: ChildProcess,
|
||||
pendingPromises: Map<string, PendingPromise>
|
||||
) {
|
||||
return () => {
|
||||
for (const [_, pendingPromise] of pendingPromises) {
|
||||
pendingPromise.rejector(
|
||||
new Error(
|
||||
`Plugin worker ${
|
||||
pluginNames.get(worker) ?? worker.pid
|
||||
} exited unexpectedly with code ${worker.exitCode}`
|
||||
)
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
process.on('exit', () => {
|
||||
for (const fn of cleanupFunctions) {
|
||||
fn();
|
||||
}
|
||||
});
|
||||
|
||||
function registerPendingPromise(
|
||||
tx: string,
|
||||
pending: Map<string, PendingPromise>,
|
||||
callback: () => void
|
||||
): Promise<any> {
|
||||
let resolver, rejector;
|
||||
|
||||
const promise = new Promise((res, rej) => {
|
||||
resolver = res;
|
||||
rejector = rej;
|
||||
|
||||
callback();
|
||||
}).finally(() => {
|
||||
pending.delete(tx);
|
||||
});
|
||||
|
||||
pending.set(tx, {
|
||||
promise,
|
||||
resolver,
|
||||
rejector,
|
||||
});
|
||||
|
||||
return promise;
|
||||
}
|
||||
@ -1,122 +0,0 @@
|
||||
import { consumeMessage, PluginWorkerMessage } from './messaging';
|
||||
import { CreateNodesResultWithContext, NormalizedPlugin } from './internal-api';
|
||||
import { CreateNodesContext } from './public-api';
|
||||
import { CreateNodesError } from './utils';
|
||||
import { loadPlugin } from './worker-api';
|
||||
|
||||
global.NX_GRAPH_CREATION = true;
|
||||
|
||||
let plugin: NormalizedPlugin;
|
||||
let pluginOptions: unknown;
|
||||
|
||||
process.on('message', async (message: string) => {
|
||||
consumeMessage<PluginWorkerMessage>(message, {
|
||||
load: async ({ plugin: pluginConfiguration, root }) => {
|
||||
process.chdir(root);
|
||||
try {
|
||||
({ plugin, options: pluginOptions } = await loadPlugin(
|
||||
pluginConfiguration,
|
||||
root
|
||||
));
|
||||
return {
|
||||
type: 'load-result',
|
||||
payload: {
|
||||
name: plugin.name,
|
||||
createNodesPattern: plugin.createNodes?.[0],
|
||||
hasCreateDependencies:
|
||||
'createDependencies' in plugin && !!plugin.createDependencies,
|
||||
hasProcessProjectGraph:
|
||||
'processProjectGraph' in plugin && !!plugin.processProjectGraph,
|
||||
success: true,
|
||||
},
|
||||
};
|
||||
} catch (e) {
|
||||
return {
|
||||
type: 'load-result',
|
||||
payload: {
|
||||
success: false,
|
||||
error: `Could not load plugin ${plugin} \n ${
|
||||
e instanceof Error ? e.stack : ''
|
||||
}`,
|
||||
},
|
||||
};
|
||||
}
|
||||
},
|
||||
createNodes: async ({ configFiles, context, tx }) => {
|
||||
try {
|
||||
const result = await runCreateNodesInParallel(configFiles, context);
|
||||
return {
|
||||
type: 'createNodesResult',
|
||||
payload: { result, success: true, tx },
|
||||
};
|
||||
} catch (e) {
|
||||
return {
|
||||
type: 'createNodesResult',
|
||||
payload: { success: false, error: e.stack, tx },
|
||||
};
|
||||
}
|
||||
},
|
||||
createDependencies: async ({ context, tx }) => {
|
||||
try {
|
||||
const result = await plugin.createDependencies(pluginOptions, context);
|
||||
return {
|
||||
type: 'createDependenciesResult',
|
||||
payload: { dependencies: result, success: true, tx },
|
||||
};
|
||||
} catch (e) {
|
||||
return {
|
||||
type: 'createDependenciesResult',
|
||||
payload: { success: false, error: e.stack, tx },
|
||||
};
|
||||
}
|
||||
},
|
||||
processProjectGraph: async ({ graph, ctx, tx }) => {
|
||||
try {
|
||||
const result = await plugin.processProjectGraph(graph, ctx);
|
||||
return {
|
||||
type: 'processProjectGraphResult',
|
||||
payload: { graph: result, success: true, tx },
|
||||
};
|
||||
} catch (e) {
|
||||
return {
|
||||
type: 'processProjectGraphResult',
|
||||
payload: { success: false, error: e.stack, tx },
|
||||
};
|
||||
}
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
function runCreateNodesInParallel(
|
||||
configFiles: string[],
|
||||
context: CreateNodesContext
|
||||
): Promise<CreateNodesResultWithContext[]> {
|
||||
const promises: Array<
|
||||
CreateNodesResultWithContext | Promise<CreateNodesResultWithContext>
|
||||
> = configFiles.map((file) => {
|
||||
performance.mark(`${plugin.name}:createNodes:${file} - start`);
|
||||
// Result is either static or a promise, using Promise.resolve lets us
|
||||
// handle both cases with same logic
|
||||
const value = Promise.resolve(
|
||||
plugin.createNodes[1](file, pluginOptions, context)
|
||||
);
|
||||
return value
|
||||
.catch((e) => {
|
||||
performance.mark(`${plugin.name}:createNodes:${file} - end`);
|
||||
throw new CreateNodesError(
|
||||
`Unable to create nodes for ${file} using plugin ${plugin.name}.`,
|
||||
e
|
||||
);
|
||||
})
|
||||
.then((r) => {
|
||||
performance.mark(`${plugin.name}:createNodes:${file} - end`);
|
||||
performance.measure(
|
||||
`${plugin.name}:createNodes:${file}`,
|
||||
`${plugin.name}:createNodes:${file} - start`,
|
||||
`${plugin.name}:createNodes:${file} - end`
|
||||
);
|
||||
return { ...r, pluginName: plugin.name, file };
|
||||
});
|
||||
});
|
||||
return Promise.all(promises);
|
||||
}
|
||||
@ -1,119 +0,0 @@
|
||||
// This file represents the public API for plugins which live in nx.json's plugins array.
|
||||
// For methods to interact with plugins from within Nx, see `./internal-api.ts`.
|
||||
|
||||
import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
|
||||
import {
|
||||
FileMap,
|
||||
ProjectGraph,
|
||||
ProjectGraphExternalNode,
|
||||
} from '../../config/project-graph';
|
||||
|
||||
import { ProjectConfiguration } from '../../config/workspace-json-project-json';
|
||||
|
||||
import { NxJsonConfiguration } from '../../config/nx-json';
|
||||
import { RawProjectGraphDependency } from '../project-graph-builder';
|
||||
|
||||
/**
|
||||
* Context for {@link CreateNodesFunction}
|
||||
*/
|
||||
export interface CreateNodesContext {
|
||||
readonly nxJsonConfiguration: NxJsonConfiguration;
|
||||
readonly workspaceRoot: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* A function which parses a configuration file into a set of nodes.
|
||||
* Used for creating nodes for the {@link ProjectGraph}
|
||||
*/
|
||||
export type CreateNodesFunction<T = unknown> = (
|
||||
projectConfigurationFile: string,
|
||||
options: T | undefined,
|
||||
context: CreateNodesContext
|
||||
) => CreateNodesResult | Promise<CreateNodesResult>;
|
||||
|
||||
export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
|
||||
|
||||
export interface CreateNodesResult {
|
||||
/**
|
||||
* A map of project root -> project configuration
|
||||
*/
|
||||
projects?: Record<string, Optional<ProjectConfiguration, 'root'>>;
|
||||
|
||||
/**
|
||||
* A map of external node name -> external node. External nodes do not have a root, so the key is their name.
|
||||
*/
|
||||
externalNodes?: Record<string, ProjectGraphExternalNode>;
|
||||
}
|
||||
|
||||
/**
|
||||
* A pair of file patterns and {@link CreateNodesFunction}
|
||||
*/
|
||||
export type CreateNodes<T = unknown> = readonly [
|
||||
projectFilePattern: string,
|
||||
createNodesFunction: CreateNodesFunction<T>
|
||||
];
|
||||
|
||||
/**
|
||||
* Context for {@link CreateDependencies}
|
||||
*/
|
||||
export interface CreateDependenciesContext {
|
||||
/**
|
||||
* The external nodes that have been added to the graph.
|
||||
*/
|
||||
readonly externalNodes: ProjectGraph['externalNodes'];
|
||||
|
||||
/**
|
||||
* The configuration of each project in the workspace.
|
||||
*/
|
||||
readonly projects: Record<string, ProjectConfiguration>;
|
||||
|
||||
/**
|
||||
* The `nx.json` configuration from the workspace
|
||||
*/
|
||||
readonly nxJsonConfiguration: NxJsonConfiguration;
|
||||
|
||||
/**
|
||||
* All files in the workspace
|
||||
*/
|
||||
readonly fileMap: FileMap;
|
||||
|
||||
/**
|
||||
* Files changes since last invocation
|
||||
*/
|
||||
readonly filesToProcess: FileMap;
|
||||
|
||||
readonly workspaceRoot: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* A function which parses files in the workspace to create dependencies in the {@link ProjectGraph}
|
||||
* Use {@link validateDependency} to validate dependencies
|
||||
*/
|
||||
export type CreateDependencies<T = unknown> = (
|
||||
options: T | undefined,
|
||||
context: CreateDependenciesContext
|
||||
) => RawProjectGraphDependency[] | Promise<RawProjectGraphDependency[]>;
|
||||
|
||||
/**
|
||||
* A plugin for Nx which creates nodes and dependencies for the {@link ProjectGraph}
|
||||
*/
|
||||
export type NxPluginV2<TOptions = unknown> = {
|
||||
name: string;
|
||||
|
||||
/**
|
||||
* Provides a file pattern and function that retrieves configuration info from
|
||||
* those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
|
||||
*/
|
||||
createNodes?: CreateNodes<TOptions>;
|
||||
|
||||
// Todo(@AgentEnder): This shouldn't be a full processor, since its only responsible for defining edges between projects. What do we want the API to be?
|
||||
/**
|
||||
* Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
|
||||
*/
|
||||
createDependencies?: CreateDependencies<TOptions>;
|
||||
};
|
||||
|
||||
/**
|
||||
* A plugin for Nx
|
||||
*/
|
||||
export type NxPlugin = NxPluginV1 | NxPluginV2;
|
||||
@ -1,61 +0,0 @@
|
||||
import { dirname } from 'node:path';
|
||||
|
||||
import { toProjectName } from '../../config/workspaces';
|
||||
import { combineGlobPatterns } from '../../utils/globs';
|
||||
|
||||
import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
|
||||
import type { NormalizedPlugin, RemotePlugin } from './internal-api';
|
||||
import type { NxPlugin, NxPluginV2 } from './public-api';
|
||||
|
||||
export function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2 {
|
||||
return 'createNodes' in plugin || 'createDependencies' in plugin;
|
||||
}
|
||||
|
||||
export function isNxPluginV1(
|
||||
plugin: NxPlugin | RemotePlugin
|
||||
): plugin is NxPluginV1 {
|
||||
return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
|
||||
}
|
||||
|
||||
export function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin {
|
||||
if (isNxPluginV2(plugin)) {
|
||||
return plugin;
|
||||
}
|
||||
if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
|
||||
return {
|
||||
...plugin,
|
||||
createNodes: [
|
||||
`*/**/${combineGlobPatterns(plugin.projectFilePatterns)}`,
|
||||
(configFilePath) => {
|
||||
const root = dirname(configFilePath);
|
||||
return {
|
||||
projects: {
|
||||
[root]: {
|
||||
name: toProjectName(configFilePath),
|
||||
targets: plugin.registerProjectTargets?.(configFilePath),
|
||||
},
|
||||
},
|
||||
};
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
return plugin;
|
||||
}
|
||||
|
||||
export class CreateNodesError extends Error {
|
||||
constructor(msg, cause: Error | unknown) {
|
||||
const message = `${msg} ${
|
||||
!cause
|
||||
? ''
|
||||
: cause instanceof Error
|
||||
? `\n\n\t Inner Error: ${cause.stack}`
|
||||
: cause
|
||||
}`;
|
||||
// These errors are thrown during a JS callback which is invoked via rust.
|
||||
// The errors messaging gets lost in the rust -> js -> rust transition, but
|
||||
// logging the error here will ensure that it is visible in the console.
|
||||
console.error(message);
|
||||
super(message, { cause });
|
||||
}
|
||||
}
|
||||
@ -1,290 +0,0 @@
|
||||
// This file contains methods and utilities that should **only** be used by the plugin worker.
|
||||
|
||||
import { ProjectConfiguration } from '../../config/workspace-json-project-json';
|
||||
|
||||
import { join } from 'node:path/posix';
|
||||
import { getNxRequirePaths } from '../../utils/installation-directory';
|
||||
import {
|
||||
PackageJson,
|
||||
readModulePackageJsonWithoutFallbacks,
|
||||
} from '../../utils/package-json';
|
||||
import { readJsonFile } from '../../utils/fileutils';
|
||||
import { workspaceRoot } from '../../utils/workspace-root';
|
||||
import { existsSync } from 'node:fs';
|
||||
import { readTsConfig } from '../../utils/typescript';
|
||||
import {
|
||||
registerTranspiler,
|
||||
registerTsConfigPaths,
|
||||
} from '../../plugins/js/utils/register';
|
||||
import {
|
||||
createProjectRootMappingsFromProjectConfigurations,
|
||||
findProjectForPath,
|
||||
} from '../utils/find-project-for-path';
|
||||
import { normalizePath } from '../../utils/path';
|
||||
import { logger } from '../../utils/logger';
|
||||
|
||||
import type * as ts from 'typescript';
|
||||
import { extname } from 'node:path';
|
||||
import { NxPlugin } from './public-api';
|
||||
import path = require('node:path/posix');
|
||||
import { PluginConfiguration } from '../../config/nx-json';
|
||||
import { retrieveProjectConfigurationsWithoutPluginInference } from '../utils/retrieve-workspace-files';
|
||||
import { normalizeNxPlugin } from './utils';
|
||||
|
||||
export function readPluginPackageJson(
|
||||
pluginName: string,
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
paths = getNxRequirePaths()
|
||||
): {
|
||||
path: string;
|
||||
json: PackageJson;
|
||||
} {
|
||||
try {
|
||||
const result = readModulePackageJsonWithoutFallbacks(pluginName, paths);
|
||||
return {
|
||||
json: result.packageJson,
|
||||
path: result.path,
|
||||
};
|
||||
} catch (e) {
|
||||
if (e.code === 'MODULE_NOT_FOUND') {
|
||||
const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
|
||||
if (localPluginPath) {
|
||||
const localPluginPackageJson = path.join(
|
||||
localPluginPath.path,
|
||||
'package.json'
|
||||
);
|
||||
return {
|
||||
path: localPluginPackageJson,
|
||||
json: readJsonFile(localPluginPackageJson),
|
||||
};
|
||||
}
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
export function resolveLocalNxPlugin(
|
||||
importPath: string,
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root = workspaceRoot
|
||||
): { path: string; projectConfig: ProjectConfiguration } | null {
|
||||
return lookupLocalPlugin(importPath, projects, root);
|
||||
}
|
||||
|
||||
/**
|
||||
* Register swc-node or ts-node if they are not currently registered
|
||||
* with some default settings which work well for Nx plugins.
|
||||
*/
|
||||
export function registerPluginTSTranspiler() {
|
||||
// Get the first tsconfig that matches the allowed set
|
||||
const tsConfigName = [
|
||||
join(workspaceRoot, 'tsconfig.base.json'),
|
||||
join(workspaceRoot, 'tsconfig.json'),
|
||||
].find((x) => existsSync(x));
|
||||
|
||||
const tsConfig: Partial<ts.ParsedCommandLine> = tsConfigName
|
||||
? readTsConfig(tsConfigName)
|
||||
: {};
|
||||
|
||||
registerTsConfigPaths(tsConfigName);
|
||||
registerTranspiler({
|
||||
experimentalDecorators: true,
|
||||
emitDecoratorMetadata: true,
|
||||
...tsConfig.options,
|
||||
});
|
||||
}
|
||||
|
||||
function lookupLocalPlugin(
|
||||
importPath: string,
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root = workspaceRoot
|
||||
) {
|
||||
const plugin = findNxProjectForImportPath(importPath, projects, root);
|
||||
if (!plugin) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const projectConfig: ProjectConfiguration = projects[plugin];
|
||||
return { path: path.join(root, projectConfig.root), projectConfig };
|
||||
}
|
||||
|
||||
function findNxProjectForImportPath(
|
||||
importPath: string,
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root = workspaceRoot
|
||||
): string | null {
|
||||
const tsConfigPaths: Record<string, string[]> = readTsConfigPaths(root);
|
||||
const possiblePaths = tsConfigPaths[importPath]?.map((p) =>
|
||||
normalizePath(path.relative(root, path.join(root, p)))
|
||||
);
|
||||
if (possiblePaths?.length) {
|
||||
const projectRootMappings =
|
||||
createProjectRootMappingsFromProjectConfigurations(projects);
|
||||
for (const tsConfigPath of possiblePaths) {
|
||||
const nxProject = findProjectForPath(tsConfigPath, projectRootMappings);
|
||||
if (nxProject) {
|
||||
return nxProject;
|
||||
}
|
||||
}
|
||||
logger.verbose(
|
||||
'Unable to find local plugin',
|
||||
possiblePaths,
|
||||
projectRootMappings
|
||||
);
|
||||
throw new Error(
|
||||
'Unable to resolve local plugin with import path ' + importPath
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
let tsconfigPaths: Record<string, string[]>;
|
||||
|
||||
function readTsConfigPaths(root: string = workspaceRoot) {
|
||||
if (!tsconfigPaths) {
|
||||
const tsconfigPath: string | null = ['tsconfig.base.json', 'tsconfig.json']
|
||||
.map((x) => path.join(root, x))
|
||||
.filter((x) => existsSync(x))[0];
|
||||
if (!tsconfigPath) {
|
||||
throw new Error('unable to find tsconfig.base.json or tsconfig.json');
|
||||
}
|
||||
const { compilerOptions } = readJsonFile(tsconfigPath);
|
||||
tsconfigPaths = compilerOptions?.paths;
|
||||
}
|
||||
return tsconfigPaths ?? {};
|
||||
}
|
||||
|
||||
function readPluginMainFromProjectConfiguration(
|
||||
plugin: ProjectConfiguration
|
||||
): string | null {
|
||||
const { main } =
|
||||
Object.values(plugin.targets).find((x) =>
|
||||
[
|
||||
'@nx/js:tsc',
|
||||
'@nrwl/js:tsc',
|
||||
'@nx/js:swc',
|
||||
'@nrwl/js:swc',
|
||||
'@nx/node:package',
|
||||
'@nrwl/node:package',
|
||||
].includes(x.executor)
|
||||
)?.options ||
|
||||
plugin.targets?.build?.options ||
|
||||
{};
|
||||
return main;
|
||||
}
|
||||
|
||||
export function getPluginPathAndName(
|
||||
moduleName: string,
|
||||
paths: string[],
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root: string
|
||||
) {
|
||||
let pluginPath: string;
|
||||
let registerTSTranspiler = false;
|
||||
try {
|
||||
pluginPath = require.resolve(moduleName, {
|
||||
paths,
|
||||
});
|
||||
const extension = path.extname(pluginPath);
|
||||
registerTSTranspiler = extension === '.ts';
|
||||
} catch (e) {
|
||||
if (e.code === 'MODULE_NOT_FOUND') {
|
||||
const plugin = resolveLocalNxPlugin(moduleName, projects, root);
|
||||
if (plugin) {
|
||||
registerTSTranspiler = true;
|
||||
const main = readPluginMainFromProjectConfiguration(
|
||||
plugin.projectConfig
|
||||
);
|
||||
pluginPath = main ? path.join(root, main) : plugin.path;
|
||||
} else {
|
||||
logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
|
||||
throw e;
|
||||
}
|
||||
} else {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
const packageJsonPath = path.join(pluginPath, 'package.json');
|
||||
|
||||
// Register the ts-transpiler if we are pointing to a
|
||||
// plain ts file that's not part of a plugin project
|
||||
if (registerTSTranspiler) {
|
||||
registerPluginTSTranspiler();
|
||||
}
|
||||
|
||||
const { name } =
|
||||
!['.ts', '.js'].some((x) => extname(moduleName) === x) && // Not trying to point to a ts or js file
|
||||
existsSync(packageJsonPath) // plugin has a package.json
|
||||
? readJsonFile(packageJsonPath) // read name from package.json
|
||||
: { name: moduleName };
|
||||
return { pluginPath, name };
|
||||
}
|
||||
|
||||
let projectsWithoutInference: Record<string, ProjectConfiguration>;
|
||||
|
||||
export async function loadPlugins(
|
||||
plugins: PluginConfiguration[],
|
||||
root: string
|
||||
): Promise<LoadedNxPlugin[]> {
|
||||
return await Promise.all(plugins.map((p) => loadPlugin(p, root)));
|
||||
}
|
||||
|
||||
export async function loadPlugin(plugin: PluginConfiguration, root: string) {
|
||||
try {
|
||||
require.resolve(typeof plugin === 'string' ? plugin : plugin.plugin);
|
||||
} catch {
|
||||
// If a plugin cannot be resolved, we will need projects to resolve it
|
||||
projectsWithoutInference ??=
|
||||
await retrieveProjectConfigurationsWithoutPluginInference(root);
|
||||
}
|
||||
return await loadNxPluginAsync(
|
||||
plugin,
|
||||
getNxRequirePaths(root),
|
||||
projectsWithoutInference,
|
||||
root
|
||||
);
|
||||
}
|
||||
|
||||
export type LoadedNxPlugin = {
|
||||
plugin: NxPlugin;
|
||||
options?: unknown;
|
||||
};
|
||||
|
||||
export async function loadNxPluginAsync(
|
||||
pluginConfiguration: PluginConfiguration,
|
||||
paths: string[],
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root: string
|
||||
): Promise<LoadedNxPlugin> {
|
||||
const { plugin: moduleName, options } =
|
||||
typeof pluginConfiguration === 'object'
|
||||
? pluginConfiguration
|
||||
: { plugin: pluginConfiguration, options: undefined };
|
||||
|
||||
performance.mark(`Load Nx Plugin: ${moduleName} - start`);
|
||||
let { pluginPath, name } = await getPluginPathAndName(
|
||||
moduleName,
|
||||
paths,
|
||||
projects,
|
||||
root
|
||||
);
|
||||
const plugin = normalizeNxPlugin(await importPluginModule(pluginPath));
|
||||
plugin.name ??= name;
|
||||
performance.mark(`Load Nx Plugin: ${moduleName} - end`);
|
||||
performance.measure(
|
||||
`Load Nx Plugin: ${moduleName}`,
|
||||
`Load Nx Plugin: ${moduleName} - start`,
|
||||
`Load Nx Plugin: ${moduleName} - end`
|
||||
);
|
||||
return { plugin, options };
|
||||
}
|
||||
|
||||
async function importPluginModule(pluginPath: string): Promise<NxPlugin> {
|
||||
const m = await import(pluginPath);
|
||||
if (
|
||||
m.default &&
|
||||
('createNodes' in m.default || 'createDependencies' in m.default)
|
||||
) {
|
||||
return m.default;
|
||||
}
|
||||
return m;
|
||||
}
|
||||
@ -15,7 +15,7 @@ import {
|
||||
ProjectGraphProjectNode,
|
||||
} from '../config/project-graph';
|
||||
import { ProjectConfiguration } from '../config/workspace-json-project-json';
|
||||
import { CreateDependenciesContext } from './plugins';
|
||||
import { CreateDependenciesContext } from '../utils/nx-plugin';
|
||||
import { getFileMap } from './build-project-graph';
|
||||
|
||||
/**
|
||||
|
||||
@ -17,7 +17,7 @@ import {
|
||||
retrieveWorkspaceFiles,
|
||||
} from './utils/retrieve-workspace-files';
|
||||
import { readNxJson } from '../config/nx-json';
|
||||
import { loadNxPluginsInIsolation, RemotePlugin } from './plugins/internal-api';
|
||||
import { unregisterPluginTSTranspiler } from '../utils/nx-plugin';
|
||||
|
||||
/**
|
||||
* Synchronously reads the latest cached copy of the workspace's ProjectGraph.
|
||||
@ -78,14 +78,13 @@ export function readProjectsConfigurationFromProjectGraph(
|
||||
}
|
||||
|
||||
export async function buildProjectGraphAndSourceMapsWithoutDaemon() {
|
||||
// Set this globally to allow plugins to know if they are being called from the project graph creation
|
||||
global.NX_GRAPH_CREATION = true;
|
||||
const nxJson = readNxJson();
|
||||
|
||||
const [plugins, cleanup] = await loadNxPluginsInIsolation(nxJson.plugins);
|
||||
try {
|
||||
performance.mark('retrieve-project-configurations:start');
|
||||
const { projects, externalNodes, sourceMaps, projectRootMap } =
|
||||
await retrieveProjectConfigurations(plugins, workspaceRoot, nxJson);
|
||||
await retrieveProjectConfigurations(workspaceRoot, nxJson);
|
||||
performance.mark('retrieve-project-configurations:end');
|
||||
|
||||
performance.mark('retrieve-workspace-files:start');
|
||||
@ -103,16 +102,15 @@ export async function buildProjectGraphAndSourceMapsWithoutDaemon() {
|
||||
allWorkspaceFiles,
|
||||
rustReferences,
|
||||
cacheEnabled ? readFileMapCache() : null,
|
||||
cacheEnabled,
|
||||
plugins
|
||||
cacheEnabled
|
||||
)
|
||||
).projectGraph;
|
||||
performance.mark('build-project-graph-using-project-file-map:end');
|
||||
|
||||
unregisterPluginTSTranspiler();
|
||||
delete global.NX_GRAPH_CREATION;
|
||||
|
||||
return { projectGraph, sourceMaps };
|
||||
} finally {
|
||||
cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
function handleProjectGraphError(opts: { exitOnError: boolean }, e) {
|
||||
|
||||
@ -5,8 +5,9 @@ import {
|
||||
TargetConfiguration,
|
||||
} from '../../config/workspace-json-project-json';
|
||||
import { findMatchingProjects } from '../../utils/find-matching-projects';
|
||||
import { NX_PREFIX } from '../../utils/logger';
|
||||
import { resolveNxTokensInOptions } from '../utils/project-configuration-utils';
|
||||
import { CreateDependenciesContext } from '../plugins';
|
||||
import { CreateDependenciesContext } from '../../utils/nx-plugin';
|
||||
|
||||
export async function normalizeProjectNodes(
|
||||
ctx: CreateDependenciesContext,
|
||||
|
||||
@ -5,6 +5,7 @@ import {
|
||||
TargetConfiguration,
|
||||
} from '../../config/workspace-json-project-json';
|
||||
import { NX_PREFIX } from '../../utils/logger';
|
||||
import { CreateNodesResult, LoadedNxPlugin } from '../../utils/nx-plugin';
|
||||
import { readJsonFile } from '../../utils/fileutils';
|
||||
import { workspaceRoot } from '../../utils/workspace-root';
|
||||
import {
|
||||
@ -14,11 +15,6 @@ import {
|
||||
|
||||
import { minimatch } from 'minimatch';
|
||||
import { join } from 'path';
|
||||
import { CreateNodesError } from '../plugins/utils';
|
||||
import {
|
||||
CreateNodesResultWithContext,
|
||||
RemotePlugin,
|
||||
} from '../plugins/internal-api';
|
||||
|
||||
export type SourceInformation = [file: string, plugin: string];
|
||||
export type ConfigurationSourceMaps = Record<
|
||||
@ -204,34 +200,90 @@ export type ConfigurationResult = {
|
||||
export function buildProjectsConfigurationsFromProjectPathsAndPlugins(
|
||||
nxJson: NxJsonConfiguration,
|
||||
projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
|
||||
plugins: RemotePlugin[],
|
||||
plugins: LoadedNxPlugin[],
|
||||
root: string = workspaceRoot
|
||||
): Promise<ConfigurationResult> {
|
||||
type CreateNodesResultWithContext = CreateNodesResult & {
|
||||
file: string;
|
||||
pluginName: string;
|
||||
};
|
||||
|
||||
const results: Array<Promise<Array<CreateNodesResultWithContext>>> = [];
|
||||
|
||||
// We iterate over plugins first - this ensures that plugins specified first take precedence.
|
||||
for (const plugin of plugins) {
|
||||
for (const { plugin, options } of plugins) {
|
||||
const [pattern, createNodes] = plugin.createNodes ?? [];
|
||||
const pluginResults: Array<
|
||||
CreateNodesResultWithContext | Promise<CreateNodesResultWithContext>
|
||||
> = [];
|
||||
|
||||
performance.mark(`${plugin.name}:createNodes - start`);
|
||||
if (!pattern) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const matchedFiles = [];
|
||||
|
||||
performance.mark(`${plugin.name}:createNodes - start`);
|
||||
|
||||
for (const file of projectFiles) {
|
||||
performance.mark(`${plugin.name}:createNodes:${file} - start`);
|
||||
if (minimatch(file, pattern, { dot: true })) {
|
||||
matchedFiles.push(file);
|
||||
}
|
||||
}
|
||||
let r = createNodes(matchedFiles, {
|
||||
try {
|
||||
let r = createNodes(file, options, {
|
||||
nxJsonConfiguration: nxJson,
|
||||
workspaceRoot: root,
|
||||
});
|
||||
|
||||
results.push(r);
|
||||
if (r instanceof Promise) {
|
||||
pluginResults.push(
|
||||
r
|
||||
.catch((e) => {
|
||||
performance.mark(`${plugin.name}:createNodes:${file} - end`);
|
||||
throw new CreateNodesError(
|
||||
`Unable to create nodes for ${file} using plugin ${plugin.name}.`,
|
||||
e
|
||||
);
|
||||
})
|
||||
.then((r) => {
|
||||
performance.mark(`${plugin.name}:createNodes:${file} - end`);
|
||||
performance.measure(
|
||||
`${plugin.name}:createNodes:${file}`,
|
||||
`${plugin.name}:createNodes:${file} - start`,
|
||||
`${plugin.name}:createNodes:${file} - end`
|
||||
);
|
||||
return { ...r, file, pluginName: plugin.name };
|
||||
})
|
||||
);
|
||||
} else {
|
||||
performance.mark(`${plugin.name}:createNodes:${file} - end`);
|
||||
performance.measure(
|
||||
`${plugin.name}:createNodes:${file}`,
|
||||
`${plugin.name}:createNodes:${file} - start`,
|
||||
`${plugin.name}:createNodes:${file} - end`
|
||||
);
|
||||
pluginResults.push({
|
||||
...r,
|
||||
file,
|
||||
pluginName: plugin.name,
|
||||
});
|
||||
}
|
||||
} catch (e) {
|
||||
throw new CreateNodesError(
|
||||
`Unable to create nodes for ${file} using plugin ${plugin.name}.`,
|
||||
e
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
// If there are no promises (counter undefined) or all promises have resolved (counter === 0)
|
||||
results.push(
|
||||
Promise.all(pluginResults).then((results) => {
|
||||
performance.mark(`${plugin.name}:createNodes - end`);
|
||||
performance.measure(
|
||||
`${plugin.name}:createNodes`,
|
||||
`${plugin.name}:createNodes - start`,
|
||||
`${plugin.name}:createNodes - end`
|
||||
);
|
||||
return results;
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
return Promise.all(results).then((results) => {
|
||||
@ -345,6 +397,23 @@ export function readProjectConfigurationsFromRootMap(
|
||||
return projects;
|
||||
}
|
||||
|
||||
class CreateNodesError extends Error {
|
||||
constructor(msg, cause: Error | unknown) {
|
||||
const message = `${msg} ${
|
||||
!cause
|
||||
? ''
|
||||
: cause instanceof Error
|
||||
? `\n\n\t Inner Error: ${cause.stack}`
|
||||
: cause
|
||||
}`;
|
||||
// These errors are thrown during a JS callback which is invoked via rust.
|
||||
// The errors messaging gets lost in the rust -> js -> rust transition, but
|
||||
// logging the error here will ensure that it is visible in the console.
|
||||
console.error(message);
|
||||
super(message, { cause });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Merges two targets.
|
||||
*
|
||||
|
||||
@ -1,3 +1,4 @@
|
||||
import { getDefaultPlugins } from '../../utils/nx-plugin';
|
||||
import { TempFs } from '../../internal-testing-utils/temp-fs';
|
||||
import { retrieveProjectConfigurationPaths } from './retrieve-workspace-files';
|
||||
|
||||
@ -25,19 +26,10 @@ describe('retrieveProjectConfigurationPaths', () => {
|
||||
})
|
||||
);
|
||||
|
||||
const configPaths = retrieveProjectConfigurationPaths(fs.tempDir, [
|
||||
{
|
||||
name: 'test',
|
||||
createNodes: [
|
||||
'{project.json,**/project.json}',
|
||||
() => {
|
||||
return {
|
||||
projects: {},
|
||||
};
|
||||
},
|
||||
],
|
||||
},
|
||||
]);
|
||||
const configPaths = await retrieveProjectConfigurationPaths(
|
||||
fs.tempDir,
|
||||
await getDefaultPlugins(fs.tempDir)
|
||||
);
|
||||
|
||||
expect(configPaths).not.toContain('not-projects/project.json');
|
||||
expect(configPaths).toContain('projects/project.json');
|
||||
|
||||
@ -1,26 +1,29 @@
|
||||
import { performance } from 'perf_hooks';
|
||||
import { getNxRequirePaths } from '../../utils/installation-directory';
|
||||
import { ProjectConfiguration } from '../../config/workspace-json-project-json';
|
||||
import {
|
||||
NX_ANGULAR_JSON_PLUGIN_NAME,
|
||||
NxAngularJsonPlugin,
|
||||
shouldMergeAngularProjects,
|
||||
} from '../../adapter/angular-json';
|
||||
import { NxJsonConfiguration, readNxJson } from '../../config/nx-json';
|
||||
import { ProjectGraphExternalNode } from '../../config/project-graph';
|
||||
import { getNxPackageJsonWorkspacesPlugin } from '../../plugins/package-json-workspaces';
|
||||
import {
|
||||
buildProjectsConfigurationsFromProjectPathsAndPlugins,
|
||||
ConfigurationSourceMaps,
|
||||
} from './project-configuration-utils';
|
||||
import {
|
||||
RemotePlugin,
|
||||
loadNxPluginsInIsolation,
|
||||
} from '../plugins/internal-api';
|
||||
getDefaultPlugins,
|
||||
LoadedNxPlugin,
|
||||
loadNxPlugins,
|
||||
} from '../../utils/nx-plugin';
|
||||
import { ProjectJsonProjectsPlugin } from '../../plugins/project-json/build-nodes/project-json';
|
||||
import {
|
||||
getNxWorkspaceFilesFromContext,
|
||||
globWithWorkspaceContext,
|
||||
} from '../../utils/workspace-context';
|
||||
import { buildAllWorkspaceFiles } from './build-all-workspace-files';
|
||||
import { join } from 'path';
|
||||
import { NxPlugin } from '../plugins';
|
||||
|
||||
/**
|
||||
* Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
|
||||
@ -63,49 +66,41 @@ export async function retrieveWorkspaceFiles(
|
||||
|
||||
/**
|
||||
* Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
|
||||
*
|
||||
* @param workspaceRoot
|
||||
* @param nxJson
|
||||
*/
|
||||
export async function retrieveProjectConfigurations(
|
||||
plugins: RemotePlugin[],
|
||||
workspaceRoot: string,
|
||||
nxJson: NxJsonConfiguration
|
||||
): Promise<RetrievedGraphNodes> {
|
||||
const projects = await _retrieveProjectConfigurations(
|
||||
workspaceRoot,
|
||||
nxJson,
|
||||
plugins
|
||||
const plugins = await loadNxPlugins(
|
||||
nxJson?.plugins ?? [],
|
||||
getNxRequirePaths(workspaceRoot),
|
||||
workspaceRoot
|
||||
);
|
||||
return projects;
|
||||
|
||||
return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
|
||||
}
|
||||
|
||||
export async function retrieveProjectConfigurationsWithAngularProjects(
|
||||
workspaceRoot: string,
|
||||
nxJson: NxJsonConfiguration
|
||||
): Promise<RetrievedGraphNodes> {
|
||||
const pluginsToLoad = nxJson?.plugins ?? [];
|
||||
|
||||
if (
|
||||
shouldMergeAngularProjects(workspaceRoot, true) &&
|
||||
!pluginsToLoad.some(
|
||||
(p) =>
|
||||
p === NX_ANGULAR_JSON_PLUGIN_NAME ||
|
||||
(typeof p === 'object' && p.plugin === NX_ANGULAR_JSON_PLUGIN_NAME)
|
||||
)
|
||||
) {
|
||||
pluginsToLoad.push(join(__dirname, '../../adapter/angular-json'));
|
||||
}
|
||||
|
||||
const [plugins, cleanup] = await loadNxPluginsInIsolation(
|
||||
const plugins = await loadNxPlugins(
|
||||
nxJson?.plugins ?? [],
|
||||
getNxRequirePaths(workspaceRoot),
|
||||
workspaceRoot
|
||||
);
|
||||
|
||||
const res = _retrieveProjectConfigurations(
|
||||
workspaceRoot,
|
||||
nxJson,
|
||||
await plugins
|
||||
);
|
||||
cleanup();
|
||||
return res;
|
||||
if (
|
||||
shouldMergeAngularProjects(workspaceRoot, true) &&
|
||||
!plugins.some((p) => p.plugin.name === NX_ANGULAR_JSON_PLUGIN_NAME)
|
||||
) {
|
||||
plugins.push({ plugin: NxAngularJsonPlugin });
|
||||
}
|
||||
|
||||
return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
|
||||
}
|
||||
|
||||
export type RetrievedGraphNodes = {
|
||||
@ -118,7 +113,7 @@ export type RetrievedGraphNodes = {
|
||||
function _retrieveProjectConfigurations(
|
||||
workspaceRoot: string,
|
||||
nxJson: NxJsonConfiguration,
|
||||
plugins: RemotePlugin[]
|
||||
plugins: LoadedNxPlugin[]
|
||||
): Promise<RetrievedGraphNodes> {
|
||||
const globPatterns = configurationGlobs(plugins);
|
||||
const projectFiles = globWithWorkspaceContext(workspaceRoot, globPatterns);
|
||||
@ -133,7 +128,7 @@ function _retrieveProjectConfigurations(
|
||||
|
||||
export function retrieveProjectConfigurationPaths(
|
||||
root: string,
|
||||
plugins: NxPlugin[]
|
||||
plugins: LoadedNxPlugin[]
|
||||
): string[] {
|
||||
const projectGlobPatterns = configurationGlobs(plugins);
|
||||
return globWithWorkspaceContext(root, projectGlobPatterns);
|
||||
@ -149,7 +144,7 @@ export async function retrieveProjectConfigurationsWithoutPluginInference(
|
||||
root: string
|
||||
): Promise<Record<string, ProjectConfiguration>> {
|
||||
const nxJson = readNxJson(root);
|
||||
const [plugins, cleanup] = await loadNxPluginsInIsolation([]); // only load default plugins
|
||||
const plugins = await getDefaultPlugins(root);
|
||||
const projectGlobPatterns = retrieveProjectConfigurationPaths(root, plugins);
|
||||
const cacheKey = root + ',' + projectGlobPatterns.join(',');
|
||||
|
||||
@ -162,13 +157,14 @@ export async function retrieveProjectConfigurationsWithoutPluginInference(
|
||||
root,
|
||||
nxJson,
|
||||
projectFiles,
|
||||
plugins
|
||||
[
|
||||
{ plugin: getNxPackageJsonWorkspacesPlugin(root) },
|
||||
{ plugin: ProjectJsonProjectsPlugin },
|
||||
]
|
||||
);
|
||||
|
||||
projectsWithoutPluginCache.set(cacheKey, projects);
|
||||
|
||||
cleanup();
|
||||
|
||||
return projects;
|
||||
}
|
||||
|
||||
@ -176,7 +172,7 @@ export async function createProjectConfigurations(
|
||||
workspaceRoot: string,
|
||||
nxJson: NxJsonConfiguration,
|
||||
configFiles: string[],
|
||||
plugins: RemotePlugin[]
|
||||
plugins: LoadedNxPlugin[]
|
||||
): Promise<RetrievedGraphNodes> {
|
||||
performance.mark('build-project-configs:start');
|
||||
|
||||
@ -203,10 +199,10 @@ export async function createProjectConfigurations(
|
||||
};
|
||||
}
|
||||
|
||||
export function configurationGlobs(plugins: Array<NxPlugin>): string[] {
|
||||
export function configurationGlobs(plugins: LoadedNxPlugin[]): string[] {
|
||||
const globPatterns = [];
|
||||
for (const plugin of plugins) {
|
||||
if ('createNodes' in plugin && plugin.createNodes) {
|
||||
for (const { plugin } of plugins) {
|
||||
if (plugin.createNodes) {
|
||||
globPatterns.push(plugin.createNodes[0]);
|
||||
}
|
||||
}
|
||||
|
||||
@ -31,11 +31,6 @@ export const logger = {
|
||||
fatal: (...s) => {
|
||||
console.error(...s);
|
||||
},
|
||||
verbose: (...s) => {
|
||||
if (process.env.NX_VERBOSE_LOGGING) {
|
||||
console.log(...s);
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
export function stripIndent(str: string): string {
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
import { shouldMergeAngularProjects } from '../adapter/angular-json';
|
||||
import { ProjectGraphProcessor } from '../config/project-graph';
|
||||
import { TargetConfiguration } from '../config/workspace-json-project-json';
|
||||
import ProjectJsonProjectsPlugin from '../plugins/project-json/build-nodes/project-json';
|
||||
import TargetDefaultsPlugin from '../plugins/target-defaults/target-defaults-plugin';
|
||||
import * as PackageJsonWorkspacesPlugin from '../plugins/package-json-workspaces';
|
||||
import { NxPluginV2 } from '../project-graph/plugins';
|
||||
import { ProjectJsonProjectsPlugin } from '../plugins/project-json/build-nodes/project-json';
|
||||
import { TargetDefaultsPlugin } from '../plugins/target-defaults/target-defaults-plugin';
|
||||
import { getNxPackageJsonWorkspacesPlugin } from '../plugins/package-json-workspaces';
|
||||
import { LoadedNxPlugin, NxPluginV2 } from './nx-plugin';
|
||||
|
||||
/**
|
||||
* @deprecated Add targets to the projects in a {@link CreateNodes} function instead. This will be removed in Nx 19
|
||||
@ -39,14 +39,14 @@ export type NxPluginV1 = {
|
||||
/**
|
||||
* @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
|
||||
*/
|
||||
export function getDefaultPluginsSync(root: string) {
|
||||
export function getDefaultPluginsSync(root: string): LoadedNxPlugin[] {
|
||||
const plugins: NxPluginV2[] = [
|
||||
require('../plugins/js'),
|
||||
...(shouldMergeAngularProjects(root, false)
|
||||
? [require('../adapter/angular-json').NxAngularJsonPlugin]
|
||||
: []),
|
||||
TargetDefaultsPlugin,
|
||||
PackageJsonWorkspacesPlugin,
|
||||
getNxPackageJsonWorkspacesPlugin(root),
|
||||
ProjectJsonProjectsPlugin,
|
||||
];
|
||||
|
||||
|
||||
531
packages/nx/src/utils/nx-plugin.ts
Normal file
531
packages/nx/src/utils/nx-plugin.ts
Normal file
@ -0,0 +1,531 @@
|
||||
import { existsSync } from 'fs';
|
||||
import * as path from 'path';
|
||||
import {
|
||||
FileMap,
|
||||
ProjectGraph,
|
||||
ProjectGraphExternalNode,
|
||||
} from '../config/project-graph';
|
||||
import { toProjectName } from '../config/workspaces';
|
||||
|
||||
import { workspaceRoot } from './workspace-root';
|
||||
import { readJsonFile } from '../utils/fileutils';
|
||||
import {
|
||||
PackageJson,
|
||||
readModulePackageJsonWithoutFallbacks,
|
||||
} from './package-json';
|
||||
import {
|
||||
registerTranspiler,
|
||||
registerTsConfigPaths,
|
||||
} from '../plugins/js/utils/register';
|
||||
import { ProjectConfiguration } from '../config/workspace-json-project-json';
|
||||
import { logger } from './logger';
|
||||
import {
|
||||
createProjectRootMappingsFromProjectConfigurations,
|
||||
findProjectForPath,
|
||||
} from '../project-graph/utils/find-project-for-path';
|
||||
import { normalizePath } from './path';
|
||||
import { dirname, join } from 'path';
|
||||
import { getNxRequirePaths } from './installation-directory';
|
||||
import { readTsConfig } from '../plugins/js/utils/typescript';
|
||||
import {
|
||||
NxJsonConfiguration,
|
||||
PluginConfiguration,
|
||||
readNxJson,
|
||||
} from '../config/nx-json';
|
||||
|
||||
import type * as ts from 'typescript';
|
||||
import { NxPluginV1 } from './nx-plugin.deprecated';
|
||||
import { RawProjectGraphDependency } from '../project-graph/project-graph-builder';
|
||||
import { combineGlobPatterns } from './globs';
|
||||
import { shouldMergeAngularProjects } from '../adapter/angular-json';
|
||||
import { getNxPackageJsonWorkspacesPlugin } from '../plugins/package-json-workspaces';
|
||||
import { ProjectJsonProjectsPlugin } from '../plugins/project-json/build-nodes/project-json';
|
||||
import { PackageJsonProjectsNextToProjectJsonPlugin } from '../plugins/project-json/build-nodes/package-json-next-to-project-json';
|
||||
import { retrieveProjectConfigurationsWithoutPluginInference } from '../project-graph/utils/retrieve-workspace-files';
|
||||
import { TargetDefaultsPlugin } from '../plugins/target-defaults/target-defaults-plugin';
|
||||
|
||||
/**
|
||||
* Context for {@link CreateNodesFunction}
|
||||
*/
|
||||
export interface CreateNodesContext {
|
||||
readonly nxJsonConfiguration: NxJsonConfiguration;
|
||||
readonly workspaceRoot: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* A function which parses a configuration file into a set of nodes.
|
||||
* Used for creating nodes for the {@link ProjectGraph}
|
||||
*/
|
||||
export type CreateNodesFunction<T = unknown> = (
|
||||
projectConfigurationFile: string,
|
||||
options: T | undefined,
|
||||
context: CreateNodesContext
|
||||
) => CreateNodesResult | Promise<CreateNodesResult>;
|
||||
|
||||
export interface CreateNodesResult {
|
||||
/**
|
||||
* A map of project root -> project configuration
|
||||
*/
|
||||
projects?: Record<string, Optional<ProjectConfiguration, 'root'>>;
|
||||
|
||||
/**
|
||||
* A map of external node name -> external node. External nodes do not have a root, so the key is their name.
|
||||
*/
|
||||
externalNodes?: Record<string, ProjectGraphExternalNode>;
|
||||
}
|
||||
|
||||
/**
|
||||
* A pair of file patterns and {@link CreateNodesFunction}
|
||||
*/
|
||||
export type CreateNodes<T = unknown> = readonly [
|
||||
projectFilePattern: string,
|
||||
createNodesFunction: CreateNodesFunction<T>
|
||||
];
|
||||
|
||||
/**
|
||||
* Context for {@link CreateDependencies}
|
||||
*/
|
||||
export interface CreateDependenciesContext {
|
||||
/**
|
||||
* The external nodes that have been added to the graph.
|
||||
*/
|
||||
readonly externalNodes: ProjectGraph['externalNodes'];
|
||||
|
||||
/**
|
||||
* The configuration of each project in the workspace.
|
||||
*/
|
||||
readonly projects: Record<string, ProjectConfiguration>;
|
||||
|
||||
/**
|
||||
* The `nx.json` configuration from the workspace
|
||||
*/
|
||||
readonly nxJsonConfiguration: NxJsonConfiguration;
|
||||
|
||||
/**
|
||||
* All files in the workspace
|
||||
*/
|
||||
readonly fileMap: FileMap;
|
||||
|
||||
/**
|
||||
* Files changes since last invocation
|
||||
*/
|
||||
readonly filesToProcess: FileMap;
|
||||
|
||||
readonly workspaceRoot: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* A function which parses files in the workspace to create dependencies in the {@link ProjectGraph}
|
||||
* Use {@link validateDependency} to validate dependencies
|
||||
*/
|
||||
export type CreateDependencies<T = unknown> = (
|
||||
options: T | undefined,
|
||||
context: CreateDependenciesContext
|
||||
) => RawProjectGraphDependency[] | Promise<RawProjectGraphDependency[]>;
|
||||
|
||||
/**
|
||||
* A plugin for Nx which creates nodes and dependencies for the {@link ProjectGraph}
|
||||
*/
|
||||
export type NxPluginV2<TOptions = unknown> = {
|
||||
name: string;
|
||||
|
||||
/**
|
||||
* Provides a file pattern and function that retrieves configuration info from
|
||||
* those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
|
||||
*/
|
||||
createNodes?: CreateNodes;
|
||||
|
||||
// Todo(@AgentEnder): This shouldn't be a full processor, since its only responsible for defining edges between projects. What do we want the API to be?
|
||||
/**
|
||||
* Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
|
||||
*/
|
||||
createDependencies?: CreateDependencies<TOptions>;
|
||||
};
|
||||
|
||||
export * from './nx-plugin.deprecated';
|
||||
|
||||
/**
|
||||
* A plugin for Nx
|
||||
*/
|
||||
export type NxPlugin = NxPluginV1 | NxPluginV2;
|
||||
|
||||
export type LoadedNxPlugin = {
|
||||
plugin: NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
|
||||
options?: unknown;
|
||||
};
|
||||
|
||||
// Short lived cache (cleared between cmd runs)
|
||||
// holding resolved nx plugin objects.
|
||||
// Allows loadNxPlugins to be called multiple times w/o
|
||||
// executing resolution mulitple times.
|
||||
export const nxPluginCache: Map<string, LoadedNxPlugin['plugin']> = new Map();
|
||||
|
||||
export function getPluginPathAndName(
|
||||
moduleName: string,
|
||||
paths: string[],
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root: string
|
||||
) {
|
||||
let pluginPath: string;
|
||||
try {
|
||||
pluginPath = require.resolve(moduleName, {
|
||||
paths,
|
||||
});
|
||||
} catch (e) {
|
||||
if (e.code === 'MODULE_NOT_FOUND') {
|
||||
const plugin = resolveLocalNxPlugin(
|
||||
moduleName,
|
||||
readNxJson(root),
|
||||
projects,
|
||||
root
|
||||
);
|
||||
if (plugin) {
|
||||
const main = readPluginMainFromProjectConfiguration(
|
||||
plugin.projectConfig
|
||||
);
|
||||
pluginPath = main ? path.join(root, main) : plugin.path;
|
||||
} else {
|
||||
logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
|
||||
throw e;
|
||||
}
|
||||
} else {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
const packageJsonPath = path.join(pluginPath, 'package.json');
|
||||
|
||||
const extension = path.extname(pluginPath);
|
||||
|
||||
// Register the ts-transpiler if we are pointing to a
|
||||
// plain ts file that's not part of a plugin project
|
||||
if (extension === '.ts' && !tsNodeAndPathsUnregisterCallback) {
|
||||
registerPluginTSTranspiler();
|
||||
}
|
||||
|
||||
const { name } =
|
||||
!['.ts', '.js'].some((x) => x === extension) && // Not trying to point to a ts or js file
|
||||
existsSync(packageJsonPath) // plugin has a package.json
|
||||
? readJsonFile(packageJsonPath) // read name from package.json
|
||||
: { name: moduleName };
|
||||
return { pluginPath, name };
|
||||
}
|
||||
|
||||
export async function loadNxPluginAsync(
|
||||
pluginConfiguration: PluginConfiguration,
|
||||
paths: string[],
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root: string
|
||||
): Promise<LoadedNxPlugin> {
|
||||
const { plugin: moduleName, options } =
|
||||
typeof pluginConfiguration === 'object'
|
||||
? pluginConfiguration
|
||||
: { plugin: pluginConfiguration, options: undefined };
|
||||
let pluginModule = nxPluginCache.get(moduleName);
|
||||
if (pluginModule) {
|
||||
return { plugin: pluginModule, options };
|
||||
}
|
||||
performance.mark(`Load Nx Plugin: ${moduleName} - start`);
|
||||
let { pluginPath, name } = await getPluginPathAndName(
|
||||
moduleName,
|
||||
paths,
|
||||
projects,
|
||||
root
|
||||
);
|
||||
const plugin = ensurePluginIsV2(
|
||||
(await import(pluginPath)) as LoadedNxPlugin['plugin']
|
||||
);
|
||||
plugin.name ??= name;
|
||||
nxPluginCache.set(moduleName, plugin);
|
||||
performance.mark(`Load Nx Plugin: ${moduleName} - end`);
|
||||
performance.measure(
|
||||
`Load Nx Plugin: ${moduleName}`,
|
||||
`Load Nx Plugin: ${moduleName} - start`,
|
||||
`Load Nx Plugin: ${moduleName} - end`
|
||||
);
|
||||
return { plugin, options };
|
||||
}
|
||||
|
||||
export async function loadNxPlugins(
|
||||
plugins: PluginConfiguration[],
|
||||
paths = getNxRequirePaths(),
|
||||
root = workspaceRoot,
|
||||
projects?: Record<string, ProjectConfiguration>
|
||||
): Promise<LoadedNxPlugin[]> {
|
||||
const result: LoadedNxPlugin[] = [
|
||||
{ plugin: PackageJsonProjectsNextToProjectJsonPlugin },
|
||||
];
|
||||
|
||||
plugins ??= [];
|
||||
|
||||
// When loading plugins for `createNodes`, we don't know what projects exist yet.
|
||||
// Try resolving plugins
|
||||
for (const plugin of plugins) {
|
||||
try {
|
||||
require.resolve(typeof plugin === 'string' ? plugin : plugin.plugin);
|
||||
} catch {
|
||||
// If a plugin cannot be resolved, we will need projects to resolve it
|
||||
projects ??= await retrieveProjectConfigurationsWithoutPluginInference(
|
||||
root
|
||||
);
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (const plugin of plugins) {
|
||||
result.push(await loadNxPluginAsync(plugin, paths, projects, root));
|
||||
}
|
||||
|
||||
// We push the nx core node plugins onto the end, s.t. it overwrites any other plugins
|
||||
result.push(...(await getDefaultPlugins(root)));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
export function ensurePluginIsV2(plugin: NxPlugin): NxPluginV2 {
|
||||
if (isNxPluginV2(plugin)) {
|
||||
return plugin;
|
||||
}
|
||||
if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
|
||||
return {
|
||||
...plugin,
|
||||
createNodes: [
|
||||
`*/**/${combineGlobPatterns(plugin.projectFilePatterns)}`,
|
||||
(configFilePath) => {
|
||||
const root = dirname(configFilePath);
|
||||
return {
|
||||
projects: {
|
||||
[root]: {
|
||||
name: toProjectName(configFilePath),
|
||||
root,
|
||||
targets: plugin.registerProjectTargets?.(configFilePath),
|
||||
},
|
||||
},
|
||||
};
|
||||
},
|
||||
],
|
||||
};
|
||||
}
|
||||
return plugin;
|
||||
}
|
||||
|
||||
export function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2 {
|
||||
return 'createNodes' in plugin || 'createDependencies' in plugin;
|
||||
}
|
||||
|
||||
export function isNxPluginV1(plugin: NxPlugin): plugin is NxPluginV1 {
|
||||
return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
|
||||
}
|
||||
|
||||
export function readPluginPackageJson(
|
||||
pluginName: string,
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
paths = getNxRequirePaths()
|
||||
): {
|
||||
path: string;
|
||||
json: PackageJson;
|
||||
} {
|
||||
try {
|
||||
const result = readModulePackageJsonWithoutFallbacks(pluginName, paths);
|
||||
return {
|
||||
json: result.packageJson,
|
||||
path: result.path,
|
||||
};
|
||||
} catch (e) {
|
||||
if (e.code === 'MODULE_NOT_FOUND') {
|
||||
const nxJson = readNxJson();
|
||||
const localPluginPath = resolveLocalNxPlugin(
|
||||
pluginName,
|
||||
nxJson,
|
||||
projects
|
||||
);
|
||||
if (localPluginPath) {
|
||||
const localPluginPackageJson = path.join(
|
||||
localPluginPath.path,
|
||||
'package.json'
|
||||
);
|
||||
return {
|
||||
path: localPluginPackageJson,
|
||||
json: readJsonFile(localPluginPackageJson),
|
||||
};
|
||||
}
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds a plugin package and returns the path to output
|
||||
* @param importPath What is the import path that refers to a potential plugin?
|
||||
* @returns The path to the built plugin, or null if it doesn't exist
|
||||
*/
|
||||
const localPluginCache: Record<
|
||||
string,
|
||||
{ path: string; projectConfig: ProjectConfiguration }
|
||||
> = {};
|
||||
|
||||
export function resolveLocalNxPlugin(
|
||||
importPath: string,
|
||||
nxJsonConfiguration: NxJsonConfiguration,
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root = workspaceRoot
|
||||
): { path: string; projectConfig: ProjectConfiguration } | null {
|
||||
localPluginCache[importPath] ??= lookupLocalPlugin(
|
||||
importPath,
|
||||
nxJsonConfiguration,
|
||||
projects,
|
||||
root
|
||||
);
|
||||
return localPluginCache[importPath];
|
||||
}
|
||||
|
||||
let tsNodeAndPathsUnregisterCallback: (() => void) | undefined = undefined;
|
||||
|
||||
/**
|
||||
* Register swc-node or ts-node if they are not currently registered
|
||||
* with some default settings which work well for Nx plugins.
|
||||
*/
|
||||
export function registerPluginTSTranspiler() {
|
||||
if (!tsNodeAndPathsUnregisterCallback) {
|
||||
// nx-ignore-next-line
|
||||
const ts: typeof import('typescript') = require('typescript');
|
||||
|
||||
// Get the first tsconfig that matches the allowed set
|
||||
const tsConfigName = [
|
||||
join(workspaceRoot, 'tsconfig.base.json'),
|
||||
join(workspaceRoot, 'tsconfig.json'),
|
||||
].find((x) => existsSync(x));
|
||||
|
||||
const tsConfig: Partial<ts.ParsedCommandLine> = tsConfigName
|
||||
? readTsConfig(tsConfigName)
|
||||
: {};
|
||||
|
||||
const unregisterTsConfigPaths = registerTsConfigPaths(tsConfigName);
|
||||
const unregisterTranspiler = registerTranspiler({
|
||||
experimentalDecorators: true,
|
||||
emitDecoratorMetadata: true,
|
||||
...tsConfig.options,
|
||||
});
|
||||
tsNodeAndPathsUnregisterCallback = () => {
|
||||
unregisterTsConfigPaths();
|
||||
unregisterTranspiler();
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregister the ts-node transpiler if it is registered
|
||||
*/
|
||||
export function unregisterPluginTSTranspiler() {
|
||||
if (tsNodeAndPathsUnregisterCallback) {
|
||||
tsNodeAndPathsUnregisterCallback();
|
||||
tsNodeAndPathsUnregisterCallback = undefined;
|
||||
}
|
||||
}
|
||||
|
||||
function lookupLocalPlugin(
|
||||
importPath: string,
|
||||
nxJsonConfiguration: NxJsonConfiguration,
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root = workspaceRoot
|
||||
) {
|
||||
const plugin = findNxProjectForImportPath(importPath, projects, root);
|
||||
if (!plugin) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!tsNodeAndPathsUnregisterCallback) {
|
||||
registerPluginTSTranspiler();
|
||||
}
|
||||
|
||||
const projectConfig: ProjectConfiguration = projects[plugin];
|
||||
return { path: path.join(root, projectConfig.root), projectConfig };
|
||||
}
|
||||
|
||||
function findNxProjectForImportPath(
|
||||
importPath: string,
|
||||
projects: Record<string, ProjectConfiguration>,
|
||||
root = workspaceRoot
|
||||
): string | null {
|
||||
const tsConfigPaths: Record<string, string[]> = readTsConfigPaths(root);
|
||||
const possiblePaths = tsConfigPaths[importPath]?.map((p) =>
|
||||
normalizePath(path.relative(root, path.join(root, p)))
|
||||
);
|
||||
if (possiblePaths?.length) {
|
||||
const projectRootMappings =
|
||||
createProjectRootMappingsFromProjectConfigurations(projects);
|
||||
for (const tsConfigPath of possiblePaths) {
|
||||
const nxProject = findProjectForPath(tsConfigPath, projectRootMappings);
|
||||
if (nxProject) {
|
||||
return nxProject;
|
||||
}
|
||||
}
|
||||
if (process.env.NX_VERBOSE_LOGGING) {
|
||||
console.log(
|
||||
'Unable to find local plugin',
|
||||
possiblePaths,
|
||||
projectRootMappings
|
||||
);
|
||||
}
|
||||
throw new Error(
|
||||
'Unable to resolve local plugin with import path ' + importPath
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
let tsconfigPaths: Record<string, string[]>;
|
||||
|
||||
function readTsConfigPaths(root: string = workspaceRoot) {
|
||||
if (!tsconfigPaths) {
|
||||
const tsconfigPath: string | null = ['tsconfig.base.json', 'tsconfig.json']
|
||||
.map((x) => path.join(root, x))
|
||||
.filter((x) => existsSync(x))[0];
|
||||
if (!tsconfigPath) {
|
||||
throw new Error('unable to find tsconfig.base.json or tsconfig.json');
|
||||
}
|
||||
const { compilerOptions } = readJsonFile(tsconfigPath);
|
||||
tsconfigPaths = compilerOptions?.paths;
|
||||
}
|
||||
return tsconfigPaths ?? {};
|
||||
}
|
||||
|
||||
function readPluginMainFromProjectConfiguration(
|
||||
plugin: ProjectConfiguration
|
||||
): string | null {
|
||||
const { main } =
|
||||
Object.values(plugin.targets).find((x) =>
|
||||
[
|
||||
'@nx/js:tsc',
|
||||
'@nrwl/js:tsc',
|
||||
'@nx/js:swc',
|
||||
'@nrwl/js:swc',
|
||||
'@nx/node:package',
|
||||
'@nrwl/node:package',
|
||||
].includes(x.executor)
|
||||
)?.options ||
|
||||
plugin.targets?.build?.options ||
|
||||
{};
|
||||
return main;
|
||||
}
|
||||
|
||||
export async function getDefaultPlugins(
|
||||
root: string
|
||||
): Promise<LoadedNxPlugin[]> {
|
||||
const plugins: NxPluginV2[] = [
|
||||
await import('../plugins/js'),
|
||||
TargetDefaultsPlugin,
|
||||
...(shouldMergeAngularProjects(root, false)
|
||||
? [
|
||||
await import('../adapter/angular-json').then(
|
||||
(m) => m.NxAngularJsonPlugin
|
||||
),
|
||||
]
|
||||
: []),
|
||||
getNxPackageJsonWorkspacesPlugin(root),
|
||||
ProjectJsonProjectsPlugin,
|
||||
];
|
||||
|
||||
return plugins.map((p) => ({
|
||||
plugin: p,
|
||||
}));
|
||||
}
|
||||
|
||||
type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
|
||||
@ -1,18 +1,19 @@
|
||||
import { workspaceRoot } from '../workspace-root';
|
||||
import * as chalk from 'chalk';
|
||||
import { dirname, join } from 'path';
|
||||
|
||||
import { ProjectConfiguration } from '../../config/workspace-json-project-json';
|
||||
import { NxPlugin, readPluginPackageJson } from '../../project-graph/plugins';
|
||||
import { loadPlugin } from '../../project-graph/plugins/internal-api';
|
||||
import { readJsonFile } from '../fileutils';
|
||||
import { getNxRequirePaths } from '../installation-directory';
|
||||
import { output } from '../output';
|
||||
import { PackageJson } from '../package-json';
|
||||
import { getPackageManagerCommand } from '../package-manager';
|
||||
import { workspaceRoot } from '../workspace-root';
|
||||
import { hasElements } from './shared';
|
||||
|
||||
import type { PluginCapabilities } from './models';
|
||||
import { hasElements } from './shared';
|
||||
import { readJsonFile } from '../fileutils';
|
||||
import { getPackageManagerCommand } from '../package-manager';
|
||||
import {
|
||||
loadNxPluginAsync,
|
||||
NxPlugin,
|
||||
readPluginPackageJson,
|
||||
} from '../nx-plugin';
|
||||
import { getNxRequirePaths } from '../installation-directory';
|
||||
import { PackageJson } from '../package-json';
|
||||
import { ProjectConfiguration } from '../../config/workspace-json-project-json';
|
||||
|
||||
function tryGetCollection<T extends object>(
|
||||
packageJsonPath: string,
|
||||
@ -45,7 +46,7 @@ export async function getPluginCapabilities(
|
||||
getNxRequirePaths(workspaceRoot)
|
||||
);
|
||||
const pluginModule = includeRuntimeCapabilities
|
||||
? await tryGetModule(packageJson, workspaceRoot)
|
||||
? await tryGetModule(packageJson, workspaceRoot, projects)
|
||||
: ({} as Record<string, unknown>);
|
||||
return {
|
||||
name: pluginName,
|
||||
@ -98,7 +99,8 @@ export async function getPluginCapabilities(
|
||||
|
||||
async function tryGetModule(
|
||||
packageJson: PackageJson,
|
||||
workspaceRoot: string
|
||||
workspaceRoot: string,
|
||||
projects: Record<string, ProjectConfiguration>
|
||||
): Promise<NxPlugin | null> {
|
||||
try {
|
||||
return packageJson.generators ??
|
||||
@ -106,7 +108,14 @@ async function tryGetModule(
|
||||
packageJson['nx-migrations'] ??
|
||||
packageJson['schematics'] ??
|
||||
packageJson['builders']
|
||||
? (await loadPlugin(packageJson.name, workspaceRoot)).plugin
|
||||
? (
|
||||
await loadNxPluginAsync(
|
||||
packageJson.name,
|
||||
getNxRequirePaths(workspaceRoot),
|
||||
projects,
|
||||
workspaceRoot
|
||||
)
|
||||
).plugin
|
||||
: ({
|
||||
name: packageJson.name,
|
||||
} as NxPlugin);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user