@nx/playwright 17.3.0-canary.20231220-b40773c → 17.3.0-canary.20231222-d819e6c

package/executors.json

@@ -1,7 +1,7 @@
 {
   "executors": {
     "playwright": {
-      "implementation": "./src/executors/playwright/playwright",
+      "implementation": "./src/executors/playwright/playwright.impl",
       "schema": "./src/executors/playwright/schema.json",
       "description": "Run Playwright tests."
     }

package/index.d.ts

@@ -1,3 +1,3 @@
-export { playwrightExecutor, PlaywrightExecutorSchema, } from './src/executors/playwright/playwright';
+export { playwrightExecutor, PlaywrightExecutorSchema, } from './src/executors/playwright/playwright.impl';
 export { initGenerator } from './src/generators/init/init';
 export { configurationGenerator } from './src/generators/configuration/configuration';

package/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configurationGenerator = exports.initGenerator = exports.playwrightExecutor = void 0;
-var playwright_1 = require("./src/executors/playwright/playwright");
-Object.defineProperty(exports, "playwrightExecutor", { enumerable: true, get: function () { return playwright_1.playwrightExecutor; } });
+var playwright_impl_1 = require("./src/executors/playwright/playwright.impl");
+Object.defineProperty(exports, "playwrightExecutor", { enumerable: true, get: function () { return playwright_impl_1.playwrightExecutor; } });
 var init_1 = require("./src/generators/init/init");
 Object.defineProperty(exports, "initGenerator", { enumerable: true, get: function () { return init_1.initGenerator; } });
 var configuration_1 = require("./src/generators/configuration/configuration");

package/migrations.json

@@ -0,0 +1,3 @@
+{
+  "generators": {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/playwright",
-  "version": "17.3.0-canary.20231220-b40773c",
+  "version": "17.3.0-canary.20231222-d819e6c",
   "type": "commonjs",
   "homepage": "https://nx.dev",
   "private": false,
@@ -32,9 +32,11 @@
     "directory": "packages/playwright"
   },
   "dependencies": {
-    "@nx/devkit": "17.3.0-canary.20231220-b40773c",
-    "@nx/eslint": "17.3.0-canary.20231220-b40773c",
-    "tslib": "^2.3.0"
+    "@nx/devkit": "17.3.0-canary.20231222-d819e6c",
+    "@nx/eslint": "17.3.0-canary.20231222-d819e6c",
+    "@nx/js": "17.3.0-canary.20231222-d819e6c",
+    "tslib": "^2.3.0",
+    "minimatch": "3.0.5"
   },
   "peerDependencies": {
     "@playwright/test": "^1.36.0"
@@ -54,6 +56,10 @@
     "./generators/*/schema.json": "./src/generators/*/schema.json",
     "./executors.json": "./executors.json",
     "./executors/*/schema.json": "./src/executors/*/schema.json",
+    "./plugin": "./plugin.js",
     "./preset": "./src/utils/preset.js"
+  },
+  "nx-migrations": {
+    "migrations": "./migrations.json"
   }
 }

package/plugin.d.ts

@@ -0,0 +1 @@
+export { createNodes, PlaywrightPluginOptions } from './src/plugins/plugin';

package/plugin.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = void 0;
+var plugin_1 = require("./src/plugins/plugin");
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });

package/src/executors/playwright/{playwright.d.ts → playwright.impl.d.ts}

@@ -8,6 +8,7 @@ export interface PlaywrightExecutorSchema {
     grep?: string;
     globalTimeout?: number;
     grepInvert?: string;
+    testFiles?: string[];
     headed?: boolean;
     ignoreSnapshots?: boolean;
     workers?: string;

package/src/executors/playwright/{playwright.js → playwright.impl.js}

@@ -36,14 +36,18 @@ async function playwrightExecutor(options, context) {
 exports.playwrightExecutor = playwrightExecutor;
 function createArgs(opts, exclude = ['skipInstall']) {
     const args = [];
-    for (const key in opts) {
+    const { testFiles, ...rest } = opts;
+    if (testFiles) {
+        args.push(...testFiles);
+    }
+    for (const key in rest) {
         if (exclude.includes(key))
             continue;
         const value = opts[key];
         // NOTE: playwright doesn't accept pascalCase args, only kebab-case
         const arg = (0, devkit_1.names)(key).fileName;
         if (Array.isArray(value)) {
-            args.push(`--${arg}=${value.map((v) => v.trim()).join(',')}`);
+            args.push(...value.map((v) => `--${arg}=${v.trim()}`));
         }
         else if (typeof value === 'boolean') {
             // NOTE: playwright don't accept --arg=false, instead just don't pass the arg.

package/src/executors/playwright/schema.json

@@ -43,6 +43,14 @@
       "type": "string",
       "description": "Only run tests that do not match this regular expression"
     },
+    "testFiles": {
+      "alias": "t",
+      "type": "array",
+      "description": "Test files to run",
+      "items": {
+        "type": "string"
+      }
+    },
     "headed": {
       "type": "boolean",
       "description": "Run tests in headed browsers",

package/src/generators/configuration/configuration.js

@@ -5,6 +5,7 @@ const devkit_1 = require("@nx/devkit");
 const path = require("path");
 const init_1 = require("../init/init");
 const add_linter_1 = require("../../utils/add-linter");
+const versions_1 = require("@nx/js/src/utils/versions");
 async function configurationGenerator(tree, options) {
     const tasks = [];
     tasks.push(await (0, init_1.default)(tree, {
@@ -19,8 +20,13 @@ async function configurationGenerator(tree, options) {
         webServerAddress: options.webServerAddress ?? null,
         ...options,
     });
-    addE2eTarget(tree, options);
-    setupE2ETargetDefaults(tree);
+    const hasPlugin = (0, devkit_1.readNxJson)(tree).plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/playwright/plugin'
+        : p.plugin === '@nx/playwright/plugin');
+    if (!hasPlugin) {
+        addE2eTarget(tree, options);
+        setupE2ETargetDefaults(tree);
+    }
     tasks.push(await (0, add_linter_1.addLinterToPlaywrightProject)(tree, {
         project: options.project,
         linter: options.linter,
@@ -31,7 +37,8 @@ async function configurationGenerator(tree, options) {
         rootProject: options.rootProject ?? projectConfig.root === '.',
     }));
     if (options.js) {
-        (0, devkit_1.toJS)(tree);
+        const { ModuleKind } = (0, devkit_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+        (0, devkit_1.toJS)(tree, { extension: '.cjs', module: ModuleKind.CommonJS });
     }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
@@ -66,7 +73,7 @@ Rename or remove the existing e2e target.`);
         executor: '@nx/playwright:playwright',
         outputs: [`{workspaceRoot}/dist/.playwright/${projectConfig.root}`],
         options: {
-            config: `${projectConfig.root}/playwright.config.${options.js ? 'js' : 'ts'}`,
+            config: `${projectConfig.root}/playwright.config.${options.js ? 'cjs' : 'ts'}`,
         },
     };
     (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);

package/src/generators/init/init.js

@@ -31,6 +31,9 @@ async function initGenerator(tree, options) {
             recommendations: ['ms-playwright.playwright'],
         }, null, 2));
     }
+    if (process.env.NX_PCV3 === 'true') {
+        addPlugin(tree);
+    }
     if (!options.skipInstall) {
         tasks.push(() => {
             devkit_1.output.log({
@@ -44,4 +47,19 @@ async function initGenerator(tree, options) {
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 exports.initGenerator = initGenerator;
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    if (!nxJson.plugins.some((p) => typeof p === 'string'
+        ? p === '@nx/playwright/plugin'
+        : p.plugin === '@nx/playwright/plugin')) {
+        nxJson.plugins.push({
+            plugin: '@nx/playwright/plugin',
+            options: {
+                targetName: 'e2e',
+            },
+        });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
 exports.default = initGenerator;

package/src/plugins/plugin.d.ts

@@ -0,0 +1,7 @@
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
+export interface PlaywrightPluginOptions {
+    targetName?: string;
+    ciTargetName?: string;
+}
+export declare const createDependencies: CreateDependencies;
+export declare const createNodes: CreateNodes<PlaywrightPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const devkit_1 = require("@nx/devkit");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
+const minimatch = require("minimatch");
+const load_config_file_1 = require("../utils/load-config-file");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const js_1 = require("@nx/js");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'playwright.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/playwright.config.{js,ts,cjs,cts,mjs,mts}',
+    async (configFilePath, options, context) => {
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        // Do not create a project if package.json and project.json isn't there.
+        const siblingFiles = (0, fs_1.readdirSync)(projectRoot);
+        if (!siblingFiles.includes('package.json') &&
+            !siblingFiles.includes('project.json')) {
+            return {};
+        }
+        const normalizedOptions = normalizeOptions(options);
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [
+            (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
+        ]);
+        const targets = targetsCache[hash] ??
+            (await buildPlaywrightTargets(configFilePath, projectRoot, normalizedOptions, context));
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    root: projectRoot,
+                    targets,
+                },
+            },
+        };
+    },
+];
+async function buildPlaywrightTargets(configFilePath, projectRoot, options, context) {
+    const playwrightConfig = await (0, load_config_file_1.loadPlaywrightConfig)((0, path_1.join)(context.workspaceRoot, configFilePath));
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {};
+    const baseTargetConfig = {
+        command: 'playwright test',
+        options: {
+            cwd: '{projectRoot}',
+        },
+    };
+    targets[options.targetName] = {
+        ...baseTargetConfig,
+        cache: true,
+        inputs: 'production' in namedInputs
+            ? ['default', '^production']
+            : ['default', '^default'],
+        outputs: getOutputs(projectRoot, playwrightConfig),
+    };
+    if (options.ciTargetName) {
+        const ciBaseTargetConfig = {
+            ...baseTargetConfig,
+            cache: true,
+            inputs: 'production' in namedInputs
+                ? ['default', '^production']
+                : ['default', '^default'],
+            outputs: getOutputs(projectRoot, playwrightConfig),
+        };
+        const testDir = playwrightConfig.testDir
+            ? (0, devkit_1.joinPathFragments)(projectRoot, playwrightConfig.testDir)
+            : projectRoot;
+        // Playwright defaults to the following pattern.
+        playwrightConfig.testMatch ??= '**/*.@(spec|test).?(c|m)[jt]s?(x)';
+        const dependsOn = [];
+        forEachTestFile((testFile) => {
+            const relativeToProjectRoot = (0, path_1.relative)(projectRoot, testFile);
+            const targetName = `${options.ciTargetName}--${relativeToProjectRoot}`;
+            targets[targetName] = {
+                ...ciBaseTargetConfig,
+                command: `${baseTargetConfig.command} ${relativeToProjectRoot}`,
+            };
+            dependsOn.push({
+                target: targetName,
+                projects: 'self',
+                params: 'forward',
+            });
+        }, {
+            context,
+            path: testDir,
+            config: playwrightConfig,
+        });
+        targets[options.ciTargetName] ??= {};
+        targets[options.ciTargetName] = {
+            executor: 'nx:noop',
+            cache: ciBaseTargetConfig.cache,
+            inputs: ciBaseTargetConfig.inputs,
+            outputs: ciBaseTargetConfig.outputs,
+            dependsOn,
+        };
+    }
+    return targets;
+}
+async function forEachTestFile(cb, opts) {
+    const files = (0, workspace_context_1.getFilesInDirectoryUsingContext)(opts.context.workspaceRoot, opts.path);
+    const matcher = createMatcher(opts.config.testMatch);
+    const ignoredMatcher = opts.config.testIgnore
+        ? createMatcher(opts.config.testIgnore)
+        : () => false;
+    for (const file of files) {
+        if (matcher(file) && !ignoredMatcher(file)) {
+            cb(file);
+        }
+    }
+}
+function createMatcher(pattern) {
+    if (Array.isArray(pattern)) {
+        const matchers = pattern.map((p) => createMatcher(p));
+        return (path) => matchers.some((m) => m(path));
+    }
+    else if (pattern instanceof RegExp) {
+        return (path) => pattern.test(path);
+    }
+    else {
+        return (path) => {
+            try {
+                return minimatch(path, pattern);
+            }
+            catch (e) {
+                throw new Error(`Error matching ${path} with ${pattern}: ${e.message}`);
+            }
+        };
+    }
+}
+function getOutputs(projectRoot, playwrightConfig) {
+    function getOutput(path) {
+        if (path.startsWith('..')) {
+            return (0, path_1.join)('{workspaceRoot}', (0, path_1.join)(projectRoot, path));
+        }
+        else {
+            return (0, path_1.join)('{projectRoot}', path);
+        }
+    }
+    const outputs = [];
+    const { reporter, outputDir } = playwrightConfig;
+    if (reporter) {
+        const DEFAULT_REPORTER_OUTPUT = getOutput('playwright-report');
+        if (reporter === 'html' || reporter === 'json') {
+            // Reporter is a string, so it uses the default output directory.
+            outputs.push(DEFAULT_REPORTER_OUTPUT);
+        }
+        else if (Array.isArray(reporter)) {
+            for (const r of reporter) {
+                const [, opts] = r;
+                // There are a few different ways to specify an output file or directory
+                // depending on the reporter. This is a best effort to find the output.
+                if (!opts) {
+                    outputs.push(DEFAULT_REPORTER_OUTPUT);
+                }
+                else if (opts.outputFile) {
+                    outputs.push(getOutput(opts.outputFile));
+                }
+                else if (opts.outputDir) {
+                    outputs.push(getOutput(opts.outputDir));
+                }
+                else if (opts.outputFolder) {
+                    outputs.push(getOutput(opts.outputFolder));
+                }
+                else {
+                    outputs.push(DEFAULT_REPORTER_OUTPUT);
+                }
+            }
+        }
+    }
+    if (outputDir) {
+        outputs.push(getOutput(outputDir));
+    }
+    else {
+        outputs.push(getOutput('./test-results'));
+    }
+    return outputs;
+}
+function normalizeOptions(options) {
+    return {
+        ...options,
+        targetName: options.targetName ?? 'e2e',
+        ciTargetName: options.ciTargetName ?? 'e2e-ci',
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { PlaywrightTestConfig } from '@playwright/test';
+export declare let dynamicImport: Function;
+export declare function loadPlaywrightConfig(configFilePath: any): Promise<PlaywrightTestConfig>;

package/src/utils/load-config-file.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlaywrightConfig = exports.dynamicImport = void 0;
+const path_1 = require("path");
+const js_1 = require("@nx/js");
+const internal_1 = require("@nx/js/src/internal");
+exports.dynamicImport = new Function('modulePath', 'return import(modulePath);');
+async function loadPlaywrightConfig(configFilePath) {
+    {
+        let module;
+        if ((0, path_1.extname)(configFilePath) === '.ts') {
+            const tsConfigPath = (0, js_1.getRootTsConfigPath)();
+            if (tsConfigPath) {
+                const unregisterTsProject = (0, internal_1.registerTsProject)(tsConfigPath);
+                try {
+                    // Require's cache doesn't notice when the file is updated, and
+                    // this function is ran during daemon operation. If the config file
+                    // is updated, we need to read its new contents, so we need to clear the cache.
+                    // We can't just delete the cache entry for the config file, because
+                    // it might have imports that need to be updated as well.
+                    clearRequireCache();
+                    // ts-node doesn't support dynamic import, so we need to use require
+                    module = require(configFilePath);
+                }
+                finally {
+                    unregisterTsProject();
+                }
+            }
+            else {
+                module = await (0, exports.dynamicImport)(configFilePath);
+            }
+        }
+        else {
+            module = await (0, exports.dynamicImport)(configFilePath);
+        }
+        return module.default ?? module;
+    }
+}
+exports.loadPlaywrightConfig = loadPlaywrightConfig;
+const packageInstallationDirectories = ['node_modules', '.yarn'];
+function clearRequireCache() {
+    Object.keys(require.cache).forEach((key) => {
+        // We don't want to clear the require cache of installed packages.
+        // Clearing them can cause some issues when running Nx without the daemon
+        // and may cause issues for other packages that use the module state
+        // in some to store cached information.
+        if (!packageInstallationDirectories.some((dir) => key.includes(dir))) {
+            delete require.cache[key];
+        }
+    });
+}