nx 20.7.2 → 20.8.0-beta.1

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/project-graph/utils/project-configuration-utils.js

@@ -138,8 +138,20 @@ skipTargetNormalization) {
             const normalizedTarget = skipTargetNormalization
                 ? target
                 : resolveCommandSyntacticSugar(target, project.root);
-            const mergedTarget = mergeTargetConfigurations(normalizedTarget, matchingProject.targets?.[targetName], sourceMap, sourceInformation, `targets.${targetName}`);
-            updatedProjectConfiguration.targets[targetName] = mergedTarget;
+            let matchingTargets = [];
+            if ((0, globs_1.isGlobPattern)(targetName)) {
+                // find all targets matching the glob pattern
+                // this will map atomized targets to the glob pattern same as it does for targetDefaults
+                matchingTargets = Object.keys(updatedProjectConfiguration.targets).filter((key) => (0, minimatch_1.minimatch)(key, targetName));
+            }
+            // If no matching targets were found, we can assume that the target name is not (meant to be) a glob pattern
+            if (!matchingTargets.length) {
+                matchingTargets = [targetName];
+            }
+            for (const matchingTargetName of matchingTargets) {
+                const mergedTarget = mergeTargetConfigurations(normalizedTarget, matchingProject.targets?.[matchingTargetName], sourceMap, sourceInformation, `targets.${matchingTargetName}`);
+                updatedProjectConfiguration.targets[matchingTargetName] = mergedTarget;
+            }
         }
     }
     projectRootMap[updatedProjectConfiguration.root] =

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/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);