feat(core): add ability to add metadata to projects

docs/generated/devkit/ProjectConfiguration.md

@@ -8,6 +8,7 @@ Project configuration
 
 - [generators](../../devkit/documents/ProjectConfiguration#generators): Object
 - [implicitDependencies](../../devkit/documents/ProjectConfiguration#implicitdependencies): string[]
+- [metadata](../../devkit/documents/ProjectConfiguration#metadata): Object
 - [name](../../devkit/documents/ProjectConfiguration#name): string
 - [namedInputs](../../devkit/documents/ProjectConfiguration#namedinputs): Object
 - [projectType](../../devkit/documents/ProjectConfiguration#projecttype): ProjectType
@@ -53,6 +54,19 @@ List of projects which are added as a dependency
 
 ---
 
+### metadata
+
+• `Optional` **metadata**: `Object`
+
+#### Type declaration
+
+| Name            | Type                             |
+| :-------------- | :------------------------------- |
+| `targetGroups?` | `Record`\<`string`, `string`[]\> |
+| `technologies?` | `string`[]                       |
+
+---
+
 ### name
 
 • `Optional` **name**: `string`

packages/cypress/src/plugins/plugin.spec.ts

@@ -69,6 +69,14 @@ describe('@nx/cypress/plugin', () => {
       {
         "projects": {
           ".": {
+            "metadata": {
+              "targetGroups": {
+                ".:e2e-ci": null,
+              },
+              "technologies": [
+                "cypress",
+              ],
+            },
             "projectType": "application",
             "targets": {
               "e2e": {
@@ -128,6 +136,14 @@ describe('@nx/cypress/plugin', () => {
       {
         "projects": {
           ".": {
+            "metadata": {
+              "targetGroups": {
+                ".:e2e-ci": null,
+              },
+              "technologies": [
+                "cypress",
+              ],
+            },
             "projectType": "application",
             "targets": {
               "component-test": {
@@ -186,6 +202,16 @@ describe('@nx/cypress/plugin', () => {
       {
         "projects": {
           ".": {
+            "metadata": {
+              "targetGroups": {
+                ".:e2e-ci": [
+                  "e2e-ci--src/test.cy.ts",
+                ],
+              },
+              "technologies": [
+                "cypress",
+              ],
+            },
             "projectType": "application",
             "targets": {
               "e2e": {

packages/cypress/src/plugins/plugin.ts

@@ -3,6 +3,8 @@ import {
   CreateNodes,
   CreateNodesContext,
   detectPackageManager,
+  joinPathFragments,
+  normalizePath,
   NxJsonConfiguration,
   readJsonFile,
   TargetConfiguration,
@@ -12,7 +14,6 @@ import { dirname, join, relative } from 'path';
 
 import { getLockFileName } from '@nx/js';
 
-import { CypressExecutorOptions } from '../executors/cypress/cypress.impl';
 import { getNamedInputs } from '@nx/devkit/src/utils/get-named-inputs';
 import { existsSync, readdirSync } from 'fs';
 import { globWithWorkspaceContext } from 'nx/src/utils/workspace-context';
@@ -30,24 +31,16 @@ export interface CypressPluginOptions {
 const cachePath = join(projectGraphCacheDirectory, 'cypress.hash');
 const targetsCache = existsSync(cachePath) ? readTargetsCache() : {};
 
-const calculatedTargets: Record<
-  string,
-  Record<string, TargetConfiguration>
-> = {};
+const calculatedTargets: CypressTargets = {
+  targets: {},
+  ciTestingGroup: null,
+};
 
-function readTargetsCache(): Record<
-  string,
-  Record<string, TargetConfiguration<CypressExecutorOptions>>
-> {
+function readTargetsCache(): Record<string, CypressTargets> {
   return readJsonFile(cachePath);
 }
 
-function writeTargetsToCache(
-  targets: Record<
-    string,
-    Record<string, TargetConfiguration<CypressExecutorOptions>>
-  >
-) {
+function writeTargetsToCache(targets: CypressTargets) {
   writeJsonFile(cachePath, targets);
 }
 
@@ -75,7 +68,7 @@ export const createNodes: CreateNodes<CypressPluginOptions> = [
       getLockFileName(detectPackageManager(context.workspaceRoot)),
     ]);
 
-    const targets = targetsCache[hash]
+    const { targets, ciTestingGroup } = targetsCache[hash]
       ? targetsCache[hash]
       : await buildCypressTargets(
           configFilePath,
@@ -91,6 +84,12 @@ export const createNodes: CreateNodes<CypressPluginOptions> = [
         [projectRoot]: {
           projectType: 'application',
           targets,
+          metadata: {
+            technologies: ['cypress'],
+            targetGroups: {
+              [`${projectRoot}:e2e-ci`]: ciTestingGroup,
+            },
+          },
         },
       },
     };
@@ -104,9 +103,9 @@ function getOutputs(
 ): string[] {
   function getOutput(path: string): string {
     if (path.startsWith('..')) {
-      return join('{workspaceRoot}', join(projectRoot, path));
+      return joinPathFragments('{workspaceRoot}', projectRoot, path);
     } else {
-      return join('{projectRoot}', path);
+      return joinPathFragments('{projectRoot}', path);
     }
   }
 
@@ -145,12 +144,17 @@ function getOutputs(
   return outputs;
 }
 
+interface CypressTargets {
+  targets: Record<string, TargetConfiguration>;
+  ciTestingGroup: string[];
+}
+
 async function buildCypressTargets(
   configFilePath: string,
   projectRoot: string,
   options: CypressPluginOptions,
   context: CreateNodesContext
-) {
+): Promise<CypressTargets> {
   const cypressConfig = await loadConfigFile(
     join(context.workspaceRoot, configFilePath)
   );
@@ -167,6 +171,7 @@ async function buildCypressTargets(
   const namedInputs = getNamedInputs(projectRoot, context);
 
   const targets: Record<string, TargetConfiguration> = {};
+  let ciTestingGroup: string[] = [];
 
   if ('e2e' in cypressConfig) {
     targets[options.targetName] = {
@@ -214,8 +219,10 @@ async function buildCypressTargets(
       const outputs = getOutputs(projectRoot, cypressConfig, 'e2e');
       const inputs = getInputs(namedInputs);
       for (const file of specFiles) {
-        const relativeSpecFilePath = relative(projectRoot, file);
+        const relativeSpecFilePath = normalizePath(relative(projectRoot, file));
         const targetName = options.ciTargetName + '--' + relativeSpecFilePath;
+
+        ciTestingGroup.push(targetName);
         targets[targetName] = {
           outputs,
           inputs,
@@ -254,7 +261,11 @@ async function buildCypressTargets(
     };
   }
 
-  return targets;
+  if (ciTestingGroup.length === 0) {
+    ciTestingGroup = null;
+  }
+
+  return { targets, ciTestingGroup };
 }
 
 function normalizeOptions(options: CypressPluginOptions): CypressPluginOptions {

packages/nx/src/adapter/compat.ts

@@ -44,6 +44,7 @@ export const allowedProjectExtensions = [
   'projectType',
   'release',
   'includedScripts',
+  'metadata',
 ] as const;
 
 // If we pass props on the workspace that angular doesn't know about,

packages/nx/src/config/workspace-json-project-json.ts

@@ -111,6 +111,10 @@ export interface ProjectConfiguration {
       'generator' | 'generatorOptions'
     >;
   };
+  metadata?: {
+    technologies?: string[];
+    targetGroups?: Record<string, string[]>;
+  };
 }
 
 export interface TargetDependencyConfig {

packages/nx/src/project-graph/utils/project-configuration-utils.spec.ts

@@ -731,6 +731,90 @@ describe('project-configuration-utils', () => {
       `);
     });
 
+    describe('metadata', () => {
+      it('should be set if not previously defined', () => {
+        const rootMap = new RootMapBuilder()
+          .addProject({
+            root: 'libs/lib-a',
+            name: 'lib-a',
+          })
+          .getRootMap();
+        const sourceMap: ConfigurationSourceMaps = {
+          'libs/lib-a': {},
+        };
+        mergeProjectConfigurationIntoRootMap(
+          rootMap,
+          {
+            root: 'libs/lib-a',
+            name: 'lib-a',
+            metadata: {
+              technologies: ['technology'],
+            },
+          },
+          sourceMap,
+          ['dummy', 'dummy.ts']
+        );
+
+        expect(rootMap.get('libs/lib-a').metadata).toEqual({
+          technologies: ['technology'],
+        });
+        expect(sourceMap['libs/lib-a']['metadata.technologies']).toEqual([
+          'dummy',
+          'dummy.ts',
+        ]);
+        expect(sourceMap['libs/lib-a']['metadata.technologies.0']).toEqual([
+          'dummy',
+          'dummy.ts',
+        ]);
+      });
+
+      it('should concat arrays', () => {
+        const rootMap = new RootMapBuilder()
+          .addProject({
+            root: 'libs/lib-a',
+            name: 'lib-a',
+            metadata: {
+              technologies: ['technology1'],
+            },
+          })
+          .getRootMap();
+        const sourceMap: ConfigurationSourceMaps = {
+          'libs/lib-a': {
+            'metadata.technologies': ['existing', 'existing.ts'],
+            'metadata.technologies.0': ['existing', 'existing.ts'],
+          },
+        };
+        mergeProjectConfigurationIntoRootMap(
+          rootMap,
+          {
+            root: 'libs/lib-a',
+            name: 'lib-a',
+            metadata: {
+              technologies: ['technology2'],
+            },
+          },
+          sourceMap,
+          ['dummy', 'dummy.ts']
+        );
+
+        expect(rootMap.get('libs/lib-a').metadata).toEqual({
+          technologies: ['technology1', 'technology2'],
+        });
+        expect(sourceMap['libs/lib-a']['metadata.technologies']).toEqual([
+          'existing',
+          'existing.ts',
+        ]);
+        expect(sourceMap['libs/lib-a']['metadata.technologies.0']).toEqual([
+          'existing',
+          'existing.ts',
+        ]);
+        expect(sourceMap['libs/lib-a']['metadata.technologies.1']).toEqual([
+          'dummy',
+          'dummy.ts',
+        ]);
+      });
+    });
+
     describe('source map', () => {
       it('should add new project info', () => {
         const rootMap = new RootMapBuilder().getRootMap();