nx 20.7.1 → 20.8.0-beta.0

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -49,6 +49,9 @@ class TargetProjectLocator {
             }
             return acc;
         }, {});
+        if (this.tsConfig.config?.compilerOptions?.paths) {
+            this.parsePaths(this.tsConfig.config.compilerOptions.paths);
+        }
     }
     /**
      * Resolve any workspace or external project that matches the given import expression,
@@ -63,14 +66,15 @@ class TargetProjectLocator {
             return this.findProjectOfResolvedModule(resolvedModule);
         }
         // find project using tsconfig paths
-        const results = this.findPaths(importExpr);
+        const results = this.findMatchingPaths(importExpr);
         if (results) {
             const [path, paths] = results;
+            const matchedStar = typeof path === 'string'
+                ? undefined
+                : importExpr.substring(path.prefix.length, importExpr.length - path.suffix.length);
             for (let p of paths) {
-                const r = p.endsWith('/*')
-                    ? (0, node_path_1.join)((0, node_path_1.dirname)(p), (0, node_path_1.relative)(path.replace(/\*$/, ''), importExpr))
-                    : p;
-                const maybeResolvedProject = this.findProjectOfResolvedModule(r);
+                const path = matchedStar ? p.replace('*', matchedStar) : p;
+                const maybeResolvedProject = this.findProjectOfResolvedModule(path);
                 if (maybeResolvedProject) {
                     return maybeResolvedProject;
                 }
@@ -172,7 +176,7 @@ class TargetProjectLocator {
     /**
      * Return file paths matching the import relative to the repo root
      * @param normalizedImportExpr
-     * @returns
+     * @deprecated Use `findMatchingPaths` instead. It will be removed in Nx v22.
      */
     findPaths(normalizedImportExpr) {
         if (!this.paths) {
@@ -189,6 +193,29 @@ class TargetProjectLocator {
         }
         return undefined;
     }
+    findMatchingPaths(importExpr) {
+        if (!this.parsedPathPatterns) {
+            return undefined;
+        }
+        const { matchableStrings, patterns } = this.parsedPathPatterns;
+        if (matchableStrings.has(importExpr)) {
+            return [importExpr, this.paths[importExpr]];
+        }
+        // https://github.com/microsoft/TypeScript/blob/29e6d6689dfb422e4f1395546c1917d07e1f664d/src/compiler/core.ts#L2410
+        let matchedValue;
+        let longestMatchPrefixLength = -1;
+        for (let i = 0; i < patterns.length; i++) {
+            const pattern = patterns[i];
+            if (pattern.prefix.length > longestMatchPrefixLength &&
+                this.isPatternMatch(pattern, importExpr)) {
+                longestMatchPrefixLength = pattern.prefix.length;
+                matchedValue = pattern;
+            }
+        }
+        return matchedValue
+            ? [matchedValue, this.paths[matchedValue.pattern]]
+            : undefined;
+    }
     findImportInWorkspaceProjects(importPath) {
         this.packagesMetadata ??= (0, packages_1.getWorkspacePackagesMetadata)(this.nodes);
         if (this.packagesMetadata.entryPointsToProjectMap[importPath]) {
@@ -201,6 +228,32 @@ class TargetProjectLocator {
         this.packagesMetadata ??= (0, packages_1.getWorkspacePackagesMetadata)(this.nodes);
         return this.packagesMetadata.packageToProjectMap[dep]?.name;
     }
+    isPatternMatch({ prefix, suffix }, candidate) {
+        return (candidate.length >= prefix.length + suffix.length &&
+            candidate.startsWith(prefix) &&
+            candidate.endsWith(suffix));
+    }
+    parsePaths(paths) {
+        this.parsedPathPatterns = {
+            matchableStrings: new Set(),
+            patterns: [],
+        };
+        for (const key of Object.keys(paths)) {
+            const parts = key.split('*');
+            if (parts.length > 2) {
+                continue;
+            }
+            if (parts.length === 1) {
+                this.parsedPathPatterns.matchableStrings.add(key);
+                continue;
+            }
+            this.parsedPathPatterns.patterns.push({
+                pattern: key,
+                prefix: parts[0],
+                suffix: parts[1],
+            });
+        }
+    }
     resolveImportWithTypescript(normalizedImportExpr, filePath) {
         let resolvedModule;
         if (this.typescriptResolutionCache.has(normalizedImportExpr)) {

package/src/project-graph/error-types.js

@@ -153,10 +153,37 @@ function isProjectWithNoNameError(e) {
 }
 class ProjectConfigurationsError extends Error {
     constructor(errors, partialProjectConfigurationsResult) {
-        super('Failed to create project configurations');
+        const messageFragments = ['Failed to create project configurations.'];
+        const mergeNodesErrors = [];
+        const unknownErrors = [];
+        for (const e of errors) {
+            if (
+            // Known error type, but unlikely to be caused by the user
+            isMergeNodesError(e)) {
+                mergeNodesErrors.push(e);
+            }
+            else if (
+            // Known errors that are self-explanatory
+            !isAggregateCreateNodesError(e) &&
+                !isProjectsWithNoNameError(e) &&
+                !isMultipleProjectsWithSameNameError(e)) {
+                unknownErrors.push(e);
+            }
+        }
+        if (mergeNodesErrors.length > 0) {
+            messageFragments.push(`This type of error most likely points to an issue within Nx. Please report it.`);
+        }
+        if (unknownErrors.length > 0) {
+            messageFragments.push(`If the error cause is not obvious from the below error messages, running "nx reset" may fix it. Please report the issue if you keep seeing it.`);
+        }
+        super(messageFragments.join(' '));
         this.errors = errors;
         this.partialProjectConfigurationsResult = partialProjectConfigurationsResult;
         this.name = this.constructor.name;
+        this.errors = errors;
+        this.stack = errors
+            .map((error) => indentString(formatErrorStackAndCause(error), 2))
+            .join('\n');
     }
 }
 exports.ProjectConfigurationsError = ProjectConfigurationsError;

package/src/tasks-runner/cache.d.ts

@@ -38,6 +38,7 @@ export declare class DbCache {
     private getSharedCache;
     private getGcsCache;
     private getAzureCache;
+    private getHttpCache;
     private resolveRemoteCache;
     private resolvePackage;
     private assertCacheIsValid;

package/src/tasks-runner/cache.js

@@ -169,6 +169,7 @@ class DbCache {
                 (await this.getSharedCache()) ??
                 (await this.getGcsCache()) ??
                 (await this.getAzureCache()) ??
+                this.getHttpCache() ??
                 null);
         }
     }
@@ -196,6 +197,16 @@ class DbCache {
             return cache;
         return this.resolveRemoteCache('@nx/powerpack-azure-cache');
     }
+    getHttpCache() {
+        if (process.env.NX_SELF_HOSTED_REMOTE_CACHE_SERVER) {
+            if (native_1.IS_WASM) {
+                logger_1.logger.warn('The HTTP remote cache is not yet supported in the wasm build of Nx.');
+                return null;
+            }
+            return new native_1.HttpRemoteCache();
+        }
+        return null;
+    }
     async resolveRemoteCache(pkg) {
         let getRemoteCache = null;
         try {

package/src/tasks-runner/run-command.js

@@ -146,7 +146,7 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
 }
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
     let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
-    if (nxArgs.skipSync) {
+    if (nxArgs.skipSync || (0, is_ci_1.isCI)()) {
         return { projectGraph, taskGraph };
     }
     // collect unique syncGenerators from the tasks
@@ -166,9 +166,8 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
     const outOfSyncTitle = 'The workspace is out of sync';
     const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results);
     const fixMessage = 'Make sure to run `nx sync` to apply the identified changes or set `sync.applyChanges` to `true` in your `nx.json` to apply them automatically when running tasks in interactive environments.';
-    const willErrorOnCiMessage = 'This will result in an error in CI.';
-    if ((0, is_ci_1.isCI)() || !process.stdout.isTTY) {
-        // If the user is running in CI or is running in a non-TTY environment we
+    if (!process.stdout.isTTY) {
+        // If the user is running a non-TTY environment we
         // throw an error to stop the execution of the tasks.
         if (areAllResultsFailures) {
             output_1.output.error({
@@ -216,7 +215,6 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
                 ...resultBodyLines,
                 '',
                 'Your workspace is set to not apply the identified changes automatically (`sync.applyChanges` is set to `false` in your `nx.json`).',
-                willErrorOnCiMessage,
                 fixMessage,
             ],
         });
@@ -235,10 +233,12 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
         title: outOfSyncTitle,
         bodyLines: [
             ...resultBodyLines,
-            '',
-            nxJson.sync?.applyChanges === true
-                ? 'Proceeding to sync the identified changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).'
-                : willErrorOnCiMessage,
+            ...(nxJson.sync?.applyChanges === true
+                ? [
+                    '',
+                    'Proceeding to sync the identified changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).',
+                ]
+                : []),
         ],
     });
     const applyChanges = nxJson.sync?.applyChanges === true ||

package/src/utils/handle-errors.js

@@ -31,6 +31,21 @@ async function handleErrors(isVerbose, fn) {
                     : projectGraphError.getErrors().map((e) => e.message),
             });
         }
+        else if (err.name === 'ProjectConfigurationsError') {
+            const projectConfigurationsError = err;
+            let title = projectConfigurationsError.message;
+            if (projectConfigurationsError.cause &&
+                typeof projectConfigurationsError.cause === 'object' &&
+                'message' in projectConfigurationsError.cause) {
+                title += ' ' + projectConfigurationsError.cause.message + '.';
+            }
+            output_1.output.error({
+                title,
+                bodyLines: isVerbose
+                    ? formatErrorStackAndCause(projectConfigurationsError, isVerbose)
+                    : projectConfigurationsError.errors.map((e) => e.message),
+            });
+        }
         else {
             const lines = (err.message ? err.message : err.toString()).split('\n');
             const bodyLines = lines.slice(1);