@trackunit/iris-app-playwright 0.1.1

package/src/plugins/redactTrace.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactTraceFile = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const jszip_1 = tslib_1.__importDefault(require("jszip"));
+const redactSensitive_1 = require("./redactSensitive");
+/**
+ * File suffixes inside a Playwright trace.zip whose contents are JSON Lines
+ * with action/network metadata — i.e. the places where a `page.goto(url)`
+ * call's URL argument is recorded verbatim. Other entries (binary resources,
+ * screenshots, network bodies under `sha1/`) are left alone; their content is
+ * referenced by hash so redacting the metadata is sufficient to suppress the
+ * sensitive string from any human-readable trace view.
+ */
+const TEXT_TRACE_SUFFIXES = [".trace", ".network", ".stacks"];
+const isTextTraceEntry = (relPath) => TEXT_TRACE_SUFFIXES.some(s => relPath.endsWith(s));
+/**
+ * Rewrites a Playwright trace.zip in place with sensitive values stripped from
+ * the action/network metadata. The `login()` fixture issues a `page.goto`
+ * against `/auth/manager-classic#session_token=...`; Playwright records the
+ * full URL as the action argument, so without this pass a retained trace zip
+ * would carry a live Okta session token alongside the test artifacts.
+ *
+ * The fragment is client-side only — it never reaches the HTTP server, and
+ * HAR/log redaction already covers everything that does — so this pass is the
+ * defense-in-depth layer that scrubs the remaining surface.
+ */
+const redactTraceFile = async (filePath) => {
+    const buf = (0, fs_1.readFileSync)(filePath);
+    const zip = await jszip_1.default.loadAsync(buf);
+    const rewrites = [];
+    zip.forEach((relPath, file) => {
+        if (file.dir)
+            return;
+        if (!isTextTraceEntry(relPath))
+            return;
+        rewrites.push((async () => {
+            const text = await file.async("text");
+            zip.file(relPath, (0, redactSensitive_1.redactSensitive)(text));
+        })());
+    });
+    await Promise.all(rewrites);
+    const out = await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
+    (0, fs_1.writeFileSync)(filePath, out);
+};
+exports.redactTraceFile = redactTraceFile;
+//# sourceMappingURL=redactTrace.js.map

package/src/plugins/setupPlugins.d.ts

@@ -0,0 +1,11 @@
+import type { PlaywrightTestConfig } from "@playwright/test";
+import type { Formatter } from "./writeFileWithPrettier";
+/**
+ * Augments a partial Playwright config with the Trackunit logs reporter and HAR folder env setup.
+ * Call this in `playwright.config.ts` after `defaultPlaywrightConfig()`.
+ *
+ * @param config - Partial config from `defaultPlaywrightConfig()`
+ * @param formatter - Prettier formatter used by `LogsReporter` to format JSON log files
+ * @returns {Partial<PlaywrightTestConfig>} A new partial config with the logs reporter merged into the reporter array
+ */
+export declare const setupPlugins: (config: Partial<PlaywrightTestConfig>, formatter: Formatter) => Partial<PlaywrightTestConfig>;

package/src/plugins/setupPlugins.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupPlugins = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const defaultPlaywrightConfig_1 = require("./defaultPlaywrightConfig");
+/**
+ * Resolves a Playwright `outputDir` (relative or absolute) to an absolute
+ * path anchored at `nxRoot`.
+ *
+ * Why this exists: `defaultPlaywrightConfig` intentionally returns a relative
+ * `outputDir` like `../../dist/playwright/apps/<project>/test-results` so it
+ * stays portable across machines and snapshot-stable for tests. Playwright
+ * itself resolves that string against `rootDir` (the directory containing
+ * `playwright.config.ts`) and writes screenshots/videos/traces in the right
+ * place. The custom `LogsReporter` however runs as a Playwright `Reporter`
+ * and calls `mkdirSync(logsFolder, { recursive: true })` directly — Node
+ * resolves the relative path against `process.cwd()`, which under
+ * `nx:run-commands` is the **workspace root**. The leading `../..` then
+ * walks the reporter two directories *above* the workspace, scattering log
+ * files (and HARs) into a sibling repo.
+ *
+ * The relative path Playwright emits always has the shape
+ * `<../>+<workspace-relative-subpath>`, so stripping the leading `../`s and
+ * anchoring the remainder at `nxRoot` yields the same absolute directory
+ * Playwright would land on — regardless of how the test runner was spawned.
+ */
+const absolutiseOutputDir = (outputDir, nxRoot) => {
+    if (path.isAbsolute(outputDir)) {
+        return outputDir;
+    }
+    const withoutLeadingDotDots = outputDir.replace(/^(?:\.\.[\\/])+/, "");
+    return path.resolve(nxRoot, withoutLeadingDotDots);
+};
+/**
+ * Augments a partial Playwright config with the Trackunit logs reporter and HAR folder env setup.
+ * Call this in `playwright.config.ts` after `defaultPlaywrightConfig()`.
+ *
+ * @param config - Partial config from `defaultPlaywrightConfig()`
+ * @param formatter - Prettier formatter used by `LogsReporter` to format JSON log files
+ * @returns {Partial<PlaywrightTestConfig>} A new partial config with the logs reporter merged into the reporter array
+ */
+const setupPlugins = (config, formatter) => {
+    const nxRoot = (0, defaultPlaywrightConfig_1.findWorkspaceRoot)();
+    // Both HARs and logs derive from the resolved `outputDir`, so every Playwright
+    // artifact for a run stays inside the one `dist/playwright` tree (under the
+    // per-executor partition on CI). This removes the legacy fixed
+    // `dist/playwright-results` location and the `hars_folders` env override.
+    const outputDirBase = typeof config.outputDir === "string"
+        ? absolutiseOutputDir(config.outputDir, nxRoot)
+        : path.join(nxRoot, "dist", "playwright");
+    const harsFolder = path.join(outputDirBase, "hars");
+    const logsFolder = path.join(outputDirBase, "logs");
+    const reporterOptions = {
+        logsFolder,
+        harsFolder,
+        nxRoot,
+        formatter,
+    };
+    const logsReporterEntry = [path.resolve(__dirname, "./logsReporter"), reporterOptions];
+    const existingReporters = Array.isArray(config.reporter) ? config.reporter : [];
+    return {
+        ...config,
+        reporter: [...existingReporters, logsReporterEntry],
+    };
+};
+exports.setupPlugins = setupPlugins;
+//# sourceMappingURL=setupPlugins.js.map

package/src/plugins/writeFileWithPrettier.d.ts

@@ -0,0 +1,17 @@
+import { WriteFileOptions } from "fs";
+import { format, resolveConfig } from "prettier";
+export type Formatter = {
+    resolveConfig: typeof resolveConfig;
+    format: typeof format;
+};
+/**
+ * Writes a file with Prettier formatting applied.
+ * Automatically detects parser based on file extension.
+ *
+ * @param nxRoot - Absolute path to the NX workspace root (used to locate `.prettierrc`)
+ * @param filePath - Destination file path
+ * @param content - Raw file content to format and write
+ * @param writer - Prettier formatter instance
+ * @param writeOptions - Node.js `writeFileSync` options (default: UTF-8)
+ */
+export declare const writeFileWithPrettier: (nxRoot: string, filePath: string, content: string, writer: Formatter, writeOptions?: WriteFileOptions) => Promise<void>;

package/src/plugins/writeFileWithPrettier.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileWithPrettier = void 0;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+/**
+ * Writes a file with Prettier formatting applied.
+ * Automatically detects parser based on file extension.
+ *
+ * @param nxRoot - Absolute path to the NX workspace root (used to locate `.prettierrc`)
+ * @param filePath - Destination file path
+ * @param content - Raw file content to format and write
+ * @param writer - Prettier formatter instance
+ * @param writeOptions - Node.js `writeFileSync` options (default: UTF-8)
+ */
+const writeFileWithPrettier = async (nxRoot, filePath, content, writer, writeOptions = { encoding: "utf-8" }) => {
+    const prettierConfigPath = path.join(nxRoot, ".prettierrc");
+    const options = await writer.resolveConfig(prettierConfigPath).catch(error => {
+        devkit_1.logger.info(`Prettier config error: ${String(error)}`);
+        return undefined;
+    });
+    if (!options) {
+        throw new Error("Could not find prettier config");
+    }
+    if (filePath.endsWith("json")) {
+        options.parser = "json";
+    }
+    else {
+        options.parser = "typescript";
+    }
+    const prettySrc = await writer.format(content, options);
+    (0, fs_1.writeFileSync)(filePath, prettySrc, writeOptions);
+};
+exports.writeFileWithPrettier = writeFileWithPrettier;
+//# sourceMappingURL=writeFileWithPrettier.js.map

package/src/support.d.ts

@@ -0,0 +1,2 @@
+export * from "./fixtures/baseTest";
+export * from "./fixtures/describe";

package/src/support.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./fixtures/baseTest"), exports);
+tslib_1.__exportStar(require("./fixtures/describe"), exports);
+//# sourceMappingURL=support.js.map

package/src/utils/Codeowner.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Parses lines from a CODEOWNERS-style file into a mapping of patterns → owners.
+ * Skips blank lines and comments (lines beginning with `#`).
+ *
+ * @param {string[]} lines - Each element is a line from your CODEOWNERS file.
+ * @returns {Record<string, string>} An object whose keys are normalized path patterns and values are the owner handle.
+ */
+export declare const parseCodeowners: (lines: Array<string>) => Record<string, string>;
+/**
+ * Converts a full team handle (potentially namespaced and with platform suffix)
+ * into its "short" team name.
+ *
+ * @param {string} teamName - e.g. `"@trackunit/backend-be"` or `"@trackunit/frontend-fe"`
+ * @returns {string | undefined} e.g. `"backend"` or `"frontend"`, or `undefined` if no name given.
+ */
+export declare const toShortTeamName: (teamName?: string) => string | undefined;
+/**
+ * Recursively looks up the CODEOWNER for a given file or directory path
+ * by reading your workspace's CODEOWNERS file.
+ *
+ * @param {string} currentPath - Absolute path to the file/directory you're querying.
+ * @param {string} workspaceRoot - Absolute path to your repo/workspace root.
+ * @param {string} [codeownersFileName="TEAM_CODEOWNERS"] - Filename to read at the root.
+ * @returns {string|undefined} The owner handle or `undefined` if none found.
+ */
+export declare const getCodeowner: (currentPath: string, workspaceRoot: string, codeownersFileName?: string) => string | undefined;

package/src/utils/Codeowner.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodeowner = exports.toShortTeamName = exports.parseCodeowners = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+/**
+ * Parses lines from a CODEOWNERS-style file into a mapping of patterns → owners.
+ * Skips blank lines and comments (lines beginning with `#`).
+ *
+ * @param {string[]} lines - Each element is a line from your CODEOWNERS file.
+ * @returns {Record<string, string>} An object whose keys are normalized path patterns and values are the owner handle.
+ */
+const parseCodeowners = (lines) => {
+    const patterns = {};
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        const [pattern, owner] = trimmed.split(/\s+/, 2);
+        if (pattern && owner) {
+            const normalizedPattern = pattern.replace(/^\/+|\/+$/g, "");
+            patterns[normalizedPattern] = owner;
+        }
+    }
+    return patterns;
+};
+exports.parseCodeowners = parseCodeowners;
+/**
+ * Converts a full team handle (potentially namespaced and with platform suffix)
+ * into its "short" team name.
+ *
+ * @param {string} teamName - e.g. `"@trackunit/backend-be"` or `"@trackunit/frontend-fe"`
+ * @returns {string | undefined} e.g. `"backend"` or `"frontend"`, or `undefined` if no name given.
+ */
+const toShortTeamName = (teamName) => {
+    if (!teamName) {
+        return undefined;
+    }
+    let shortName = teamName;
+    if (teamName.startsWith("@")) {
+        shortName = shortName.slice(shortName.indexOf("/") + 1);
+    }
+    if (shortName.endsWith("-be") || shortName.endsWith("-fe")) {
+        shortName = shortName.slice(0, shortName.lastIndexOf("-"));
+    }
+    return shortName;
+};
+exports.toShortTeamName = toShortTeamName;
+/**
+ * Recursively looks up the CODEOWNER for a given file or directory path
+ * by reading your workspace's CODEOWNERS file.
+ *
+ * @param {string} currentPath - Absolute path to the file/directory you're querying.
+ * @param {string} workspaceRoot - Absolute path to your repo/workspace root.
+ * @param {string} [codeownersFileName="TEAM_CODEOWNERS"] - Filename to read at the root.
+ * @returns {string|undefined} The owner handle or `undefined` if none found.
+ */
+const getCodeowner = (currentPath, workspaceRoot, codeownersFileName = "TEAM_CODEOWNERS") => {
+    if (!workspaceRoot) {
+        return undefined;
+    }
+    const codeownersPath = path_1.default.join(workspaceRoot, codeownersFileName);
+    if (!fs_1.default.existsSync(codeownersPath)) {
+        return undefined;
+    }
+    const codeownersLines = fs_1.default.readFileSync(codeownersPath, "utf8").split("\n");
+    const codeowners = (0, exports.parseCodeowners)(codeownersLines);
+    let relPath = path_1.default
+        .relative(workspaceRoot, currentPath)
+        .replace(/\\/g, "/")
+        .replace(/^\/+|\/+$/g, "");
+    let parent = path_1.default.posix.dirname(relPath);
+    while (relPath !== parent) {
+        const codeowner = codeowners[relPath];
+        if (codeowner) {
+            return codeowner;
+        }
+        if (parent === ".") {
+            break;
+        }
+        relPath = parent;
+        parent = path_1.default.posix.dirname(relPath);
+    }
+    return codeowners["."];
+};
+exports.getCodeowner = getCodeowner;
+//# sourceMappingURL=Codeowner.js.map

package/src/utils/fileNameBuilder.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sanitizes a string to be safe for use in filenames.
+ * Removes special characters and normalizes whitespace and hyphens.
+ *
+ * @param str - The string to sanitize (e.g., test suite or test name)
+ * @returns {string} Sanitized string safe for filesystem use
+ */
+export declare function sanitizeForFilename(str: string): string;
+/**
+ * Builds a standardized filename for test artifacts (e.g., screenshots, traces).
+ * Combines test name, state, and attempt number into a readable filename.
+ *
+ * @param testName - The name of the test (will be sanitized)
+ * @param state - The test state (e.g., 'passed', 'failed')
+ * @param currentRetry - The current retry attempt number (0-based)
+ * @returns {string} A sanitized filename in the format: "testName (state) (attempt N)"
+ */
+export declare function fileNameBuilder(testName: string, state: string, currentRetry?: number): string;

package/src/utils/fileNameBuilder.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeForFilename = sanitizeForFilename;
+exports.fileNameBuilder = fileNameBuilder;
+/**
+ * Sanitizes a string to be safe for use in filenames.
+ * Removes special characters and normalizes whitespace and hyphens.
+ *
+ * @param str - The string to sanitize (e.g., test suite or test name)
+ * @returns {string} Sanitized string safe for filesystem use
+ */
+function sanitizeForFilename(str) {
+    return str
+        .replace(/[^a-zA-Z0-9-_\s\[\]\(\)]/g, "")
+        .replace(/-+/g, "-")
+        .replace(/\s+/g, " ")
+        .replace(/^-|-$/g, "");
+}
+/**
+ * Builds a standardized filename for test artifacts (e.g., screenshots, traces).
+ * Combines test name, state, and attempt number into a readable filename.
+ *
+ * @param testName - The name of the test (will be sanitized)
+ * @param state - The test state (e.g., 'passed', 'failed')
+ * @param currentRetry - The current retry attempt number (0-based)
+ * @returns {string} A sanitized filename in the format: "testName (state) (attempt N)"
+ */
+function fileNameBuilder(testName, state, currentRetry) {
+    const fileName = `${testName} ${currentRetry !== undefined ? `(Attempt ${currentRetry + 1})` : ""} (${state.toLowerCase()})`;
+    return sanitizeForFilename(fileName);
+}
+//# sourceMappingURL=fileNameBuilder.js.map

package/src/utils/fileUpdater.d.ts

@@ -0,0 +1,16 @@
+import { Tree } from "@nx/devkit";
+/**
+ * Reads a file from an NX Tree, applies an updater function, and writes it back if changed.
+ *
+ * @param tree - File system tree
+ * @param path - Path to source file in the Tree
+ * @param updater - Function that maps the current file content to new content
+ */
+export declare const updateFileInTree: (tree: Tree, path: string, updater: (fileContent: string) => string) => void;
+/**
+ * Deletes a file from an NX Tree. No-op if the file does not exist.
+ *
+ * @param tree - File system tree
+ * @param path - Path to source file in the Tree
+ */
+export declare const deleteFileInTree: (tree: Tree, path: string) => void;

package/src/utils/fileUpdater.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteFileInTree = exports.updateFileInTree = void 0;
+/**
+ * Reads a file from an NX Tree, applies an updater function, and writes it back if changed.
+ *
+ * @param tree - File system tree
+ * @param path - Path to source file in the Tree
+ * @param updater - Function that maps the current file content to new content
+ */
+const updateFileInTree = (tree, path, updater) => {
+    if (!tree.exists(path)) {
+        throw new Error("File not found: " + path);
+    }
+    const fileContent = tree.read(path, "utf-8");
+    if (!fileContent) {
+        throw new Error("File is empty: " + path);
+    }
+    const result = updater(fileContent);
+    if (result !== fileContent) {
+        tree.write(path, result);
+    }
+};
+exports.updateFileInTree = updateFileInTree;
+/**
+ * Deletes a file from an NX Tree. No-op if the file does not exist.
+ *
+ * @param tree - File system tree
+ * @param path - Path to source file in the Tree
+ */
+const deleteFileInTree = (tree, path) => {
+    if (!tree.exists(path)) {
+        return;
+    }
+    tree.delete(path);
+};
+exports.deleteFileInTree = deleteFileInTree;
+//# sourceMappingURL=fileUpdater.js.map