postman-playwright 1.0.0

package/README.md

@@ -0,0 +1,58 @@
+<br>
+
+<div align="left">
+  <a href="https://www.getpostman.com/">
+    <img src="https://voyager.postman.com/logo/postman-logo-orange.svg" alt="Postman Logo" width="400" height="200">
+  </a>
+</div>
+
+<br>
+
+# postman-playwright
+
+The Postman Playwright integration. This plugin captures API traffic during your Playwright UI tests so the [Postman CLI](https://www.npmjs.com/package/postman-cli) can analyse it — match observed calls to your Postman collections, run `pm.test` assertions against the responses, and surface contract drift, coverage gaps, and silent failures the UI alone can't catch.
+
+This package is the capture half of the workflow. It is meant to be used **alongside `postman-cli`**.
+
+## Installation
+
+```bash
+npm install --save-dev postman-cli postman-playwright
+```
+
+`@playwright/test` (`>=1.40.0`) is a peer dependency — bring your own version.
+
+## Usage
+
+Wrap Playwright's `test` with `attachNetworkCapture` in your spec files:
+
+```typescript
+import { test as baseTest, expect } from '@playwright/test';
+import { attachNetworkCapture } from 'postman-playwright';
+
+const test = attachNetworkCapture(baseTest);
+
+test('has title', async ({ page }) => {
+  await page.goto('https://playwright.dev/');
+  await expect(page).toHaveTitle(/Playwright/);
+});
+```
+
+That is the only change in your spec files. The `page` fixture, `test.describe`, `test.beforeEach`, tags — everything else works exactly as before.
+
+Run your tests through the Postman CLI to capture and analyse in one step:
+
+```bash
+postman application test -- npx playwright test
+```
+
+Captured traffic is written to `pm-results/` and analysed against your Postman collections. Use `--environment` to inject collection variables.
+
+## Resources
+
+- **[Playwright Integration Guide]()** — End-to-end workflow, coverage policies, noise filters, and capturing traffic into collections _(link coming soon)_
+
+## Support
+
+- [Postman Support](https://support.postman.com/) — For general support and troubleshooting
+- [GitHub Issues](https://github.com/postmanlabs/postman-app-support/issues) — For bug reports and feature requests

package/dist/captureStream.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Append-only NDJSON: `t: log` per response; `meta_start` at test begin; `meta_end` when the test finishes.
+ * Legacy streams used a single `t: meta` line (same payload as `meta_end`); the CLI still accepts that.
+ */
+import type { NetworkLog, TestStatusEntry } from './types';
+export declare const CAPTURE_STREAM_VERSION: 1;
+export type CaptureStreamLogLine = {
+    v: typeof CAPTURE_STREAM_VERSION;
+    t: 'log';
+    testRunId: string;
+    displayKey: string;
+    log: NetworkLog;
+};
+export type CaptureStreamMetaStartLine = {
+    v: typeof CAPTURE_STREAM_VERSION;
+    t: 'meta_start';
+    testRunId: string;
+    displayKey: string;
+    meta: TestStatusEntry;
+};
+export type CaptureStreamMetaEndLine = {
+    v: typeof CAPTURE_STREAM_VERSION;
+    t: 'meta_end';
+    testRunId: string;
+    displayKey: string;
+    meta: TestStatusEntry;
+};
+export declare function appendCaptureLog(outputDir: string, testRunId: string, displayKey: string, log: NetworkLog): void;
+export declare function appendCaptureMetaStart(outputDir: string, testRunId: string, displayKey: string, meta: TestStatusEntry): void;
+export declare function appendCaptureMetaEnd(outputDir: string, testRunId: string, displayKey: string, meta: TestStatusEntry): void;
+export declare function flushCaptureStream(): void;
+export declare function closeCaptureStream(): void;
+export declare function getCaptureStreamPath(): string | null;

package/dist/captureStream.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Append-only NDJSON: `t: log` per response; `meta_start` at test begin; `meta_end` when the test finishes.
+ * Legacy streams used a single `t: meta` line (same payload as `meta_end`); the CLI still accepts that.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPTURE_STREAM_VERSION = void 0;
+exports.appendCaptureLog = appendCaptureLog;
+exports.appendCaptureMetaStart = appendCaptureMetaStart;
+exports.appendCaptureMetaEnd = appendCaptureMetaEnd;
+exports.flushCaptureStream = flushCaptureStream;
+exports.closeCaptureStream = closeCaptureStream;
+exports.getCaptureStreamPath = getCaptureStreamPath;
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fileUtils_1 = require("./utils/fileUtils");
+exports.CAPTURE_STREAM_VERSION = 1;
+let captureFd = null;
+let capturePath = null;
+function pidSuffix() {
+    return typeof process !== 'undefined' && process.pid != null ? process.pid : 0;
+}
+function cwdKey() {
+    const cwd = typeof process !== 'undefined' ? process.cwd() : '';
+    return (0, crypto_1.createHash)('sha256').update(cwd).digest('hex').slice(0, 10);
+}
+function ensureCaptureFd(outputDir) {
+    if (captureFd !== null) {
+        return;
+    }
+    (0, fileUtils_1.ensureDir)(outputDir);
+    capturePath = path_1.default.join(outputDir, `network-capture-cwd-${cwdKey()}-${pidSuffix()}.ndjson`);
+    captureFd = fs_1.default.openSync(capturePath, 'a');
+}
+function appendCaptureLog(outputDir, testRunId, displayKey, log) {
+    ensureCaptureFd(outputDir);
+    const line = {
+        v: exports.CAPTURE_STREAM_VERSION,
+        t: 'log',
+        testRunId,
+        displayKey,
+        log,
+    };
+    fs_1.default.writeSync(captureFd, `${JSON.stringify(line)}\n`);
+}
+function appendCaptureMetaStart(outputDir, testRunId, displayKey, meta) {
+    ensureCaptureFd(outputDir);
+    const line = {
+        v: exports.CAPTURE_STREAM_VERSION,
+        t: 'meta_start',
+        testRunId,
+        displayKey,
+        meta,
+    };
+    fs_1.default.writeSync(captureFd, `${JSON.stringify(line)}\n`);
+}
+function appendCaptureMetaEnd(outputDir, testRunId, displayKey, meta) {
+    ensureCaptureFd(outputDir);
+    const line = {
+        v: exports.CAPTURE_STREAM_VERSION,
+        t: 'meta_end',
+        testRunId,
+        displayKey,
+        meta,
+    };
+    fs_1.default.writeSync(captureFd, `${JSON.stringify(line)}\n`);
+}
+function flushCaptureStream() {
+    if (captureFd !== null) {
+        fs_1.default.fsyncSync(captureFd);
+    }
+}
+function closeCaptureStream() {
+    if (captureFd !== null) {
+        try {
+            fs_1.default.fsyncSync(captureFd);
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            fs_1.default.closeSync(captureFd);
+        }
+        catch {
+            /* ignore */
+        }
+        captureFd = null;
+        capturePath = null;
+    }
+}
+function getCaptureStreamPath() {
+    return capturePath;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * pm-network-capture — Public API
+ *
+ * Usage flow:
+ * 1. In your test file: import { test as baseTest, expect } from '@playwright/test'
+ * 2. import { attachNetworkCapture } from 'pm-network-capture'
+ * 3. const test = attachNetworkCapture(baseTest)
+ * 4. Use `test` as usual; network requests are captured and saved per test.
+ */
+export { attachNetworkCapture } from './networkLogger';

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * pm-network-capture — Public API
+ *
+ * Usage flow:
+ * 1. In your test file: import { test as baseTest, expect } from '@playwright/test'
+ * 2. import { attachNetworkCapture } from 'pm-network-capture'
+ * 3. const test = attachNetworkCapture(baseTest)
+ * 4. Use `test` as usual; network requests are captured and saved per test.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachNetworkCapture = void 0;
+var networkLogger_1 = require("./networkLogger");
+Object.defineProperty(exports, "attachNetworkCapture", { enumerable: true, get: function () { return networkLogger_1.attachNetworkCapture; } });

package/dist/networkLogger.d.ts

@@ -0,0 +1 @@
+export declare function attachNetworkCapture(test: any): any;

package/dist/networkLogger.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachNetworkCapture = attachNetworkCapture;
+const logUtils_1 = require("./utils/logUtils");
+const requestUtils_1 = require("./utils/requestUtils");
+const store = __importStar(require("./store"));
+const captureStream_1 = require("./captureStream");
+const fileUtils_1 = require("./utils/fileUtils");
+const testMapKey_1 = require("./utils/testMapKey");
+const DEFAULT_OUTPUT_DIR = 'pm-results';
+class NetworkLogger {
+    constructor() {
+        this.logs = [];
+        this.currentTestRunId = null;
+        this.currentDisplayKey = '';
+    }
+    setCurrentTestRunId(testRunId) {
+        this.currentTestRunId = testRunId;
+    }
+    setDisplayKey(displayKey) {
+        this.currentDisplayKey = displayKey;
+    }
+    async attach(contextOrPage) {
+        contextOrPage.on('response', async (response) => {
+            try {
+                const req = response.request();
+                const [responseBody, requestBody] = await Promise.all([
+                    (0, requestUtils_1.getResponseBody)(response),
+                    Promise.resolve((0, requestUtils_1.getRequestBody)(req)),
+                ]);
+                const networkLog = (0, logUtils_1.buildNetworkLog)({
+                    method: req.method(),
+                    url: req.url(),
+                    statusCode: response.status(),
+                    statusText: response.statusText(),
+                    requestHeaders: req.headers(),
+                    responseHeaders: response.headers(),
+                    requestBody,
+                    responseBody,
+                });
+                this.logs.push(networkLog);
+                store.addToGlobalLogs(networkLog);
+                if (this.currentTestRunId) {
+                    store.addToTestMap(this.currentTestRunId, networkLog);
+                    (0, captureStream_1.appendCaptureLog)(DEFAULT_OUTPUT_DIR, this.currentTestRunId, this.currentDisplayKey, networkLog);
+                }
+            }
+            catch (error) {
+                console.error('Failed to capture network log:', error);
+            }
+        });
+    }
+    getLogs() {
+        return this.logs;
+    }
+    clearLogs() {
+        this.logs = [];
+    }
+    static clearGlobalTestMap() {
+        store.clearGlobalStore();
+    }
+    static getGlobalTestMap() {
+        return store.getGlobalTestMap();
+    }
+    static getGlobalLogs() {
+        return store.getGlobalLogs();
+    }
+    static saveAll(outputDir = DEFAULT_OUTPUT_DIR) {
+        (0, captureStream_1.flushCaptureStream)();
+        (0, fileUtils_1.ensureDir)(outputDir);
+        (0, captureStream_1.closeCaptureStream)();
+    }
+}
+const networkCaptureFixtures = {
+    page: async ({ page }, use, testInfo) => {
+        const logger = new NetworkLogger();
+        const projectName = testInfo.project?.name ?? '';
+        const titlePath = Array.isArray(testInfo.titlePath) && testInfo.titlePath.length > 0
+            ? testInfo.titlePath
+            : [testInfo.title];
+        const displayKey = (0, testMapKey_1.buildNetworkTestMapKey)(projectName, titlePath);
+        const testRunId = (typeof testInfo.testId === 'string' && testInfo.testId.length > 0)
+            ? testInfo.testId
+            : displayKey;
+        logger.setCurrentTestRunId(testRunId);
+        logger.setDisplayKey(displayKey);
+        await logger.attach(page.context());
+        const startStatusEntry = {
+            title_path: titlePath,
+            status: 'running',
+            duration: 0,
+            file: testInfo.file ?? '',
+            test_id: testInfo.testId ?? '',
+            test_info_errors: [],
+            tags: (testInfo.tags ?? []),
+            project: projectName,
+        };
+        (0, captureStream_1.appendCaptureMetaStart)(DEFAULT_OUTPUT_DIR, testRunId, displayKey, startStatusEntry);
+        store.setTestStatus(testRunId, startStatusEntry);
+        try {
+            await use(page);
+        }
+        finally {
+            const testInfoErrors = (testInfo.errors ?? []).map((e) => ({
+                ...(e?.message !== undefined && { message: e.message }),
+                ...(e?.stack !== undefined && { stack: e.stack }),
+                ...(e?.value !== undefined && { value: e.value }),
+            }));
+            const statusEntry = {
+                title_path: titlePath,
+                status: testInfo.status ?? 'interrupted',
+                duration: testInfo.duration ?? 0,
+                file: testInfo.file ?? '',
+                test_id: testInfo.testId ?? '',
+                test_info_errors: testInfoErrors,
+                tags: (testInfo.tags ?? []),
+                project: projectName,
+            };
+            store.setTestStatus(testRunId, statusEntry);
+            (0, captureStream_1.appendCaptureMetaEnd)(DEFAULT_OUTPUT_DIR, testRunId, displayKey, statusEntry);
+            NetworkLogger.saveAll(DEFAULT_OUTPUT_DIR);
+        }
+    },
+};
+function attachNetworkCapture(test) {
+    return test.extend(networkCaptureFixtures);
+}

package/dist/store.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Global store for captured network logs
+ *
+ * Flow:
+ * - NetworkLogger.attach() captures requests and adds logs via addToGlobalLogs / addToTestMap.
+ * - NetworkLogger.saveAll() flushes the NDJSON capture stream (`network-capture-<pid>.ndjson`).
+ * - clearGlobalStore() resets state (e.g. between runs or in tests).
+ *
+ * In-memory maps use Playwright `testInfo.testId` as the key (short, stable on the hot path).
+ * The CLI reads `network-capture-*.ndjson` only.
+ */
+import type { NetworkLog, TestNetworkMap, TestStatusEntry, TestStatusMap, TestStatusSummary } from './types';
+export declare function getGlobalTestMap(): TestNetworkMap;
+export declare function getGlobalLogs(): NetworkLog[];
+export declare function clearGlobalStore(): void;
+export declare function addToGlobalLogs(log: NetworkLog): void;
+/** @param testRunId - Playwright `testInfo.testId` (or display key fallback from the fixture) */
+export declare function addToTestMap(testRunId: string, log: NetworkLog): void;
+/** @param testRunId - Same id passed to {@link addToTestMap} for this test run */
+export declare function setTestStatus(testRunId: string, entry: TestStatusEntry): void;
+export declare function getTestStatusMap(): TestStatusMap;
+/**
+ * Compute aggregate pass/fail/skip counts from the current status map.
+ * Useful for quick reporting without iterating the map yourself.
+ */
+export declare function getTestStatusSummary(): TestStatusSummary;

package/dist/store.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Global store for captured network logs
+ *
+ * Flow:
+ * - NetworkLogger.attach() captures requests and adds logs via addToGlobalLogs / addToTestMap.
+ * - NetworkLogger.saveAll() flushes the NDJSON capture stream (`network-capture-<pid>.ndjson`).
+ * - clearGlobalStore() resets state (e.g. between runs or in tests).
+ *
+ * In-memory maps use Playwright `testInfo.testId` as the key (short, stable on the hot path).
+ * The CLI reads `network-capture-*.ndjson` only.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalTestMap = getGlobalTestMap;
+exports.getGlobalLogs = getGlobalLogs;
+exports.clearGlobalStore = clearGlobalStore;
+exports.addToGlobalLogs = addToGlobalLogs;
+exports.addToTestMap = addToTestMap;
+exports.setTestStatus = setTestStatus;
+exports.getTestStatusMap = getTestStatusMap;
+exports.getTestStatusSummary = getTestStatusSummary;
+const captureStream_1 = require("./captureStream");
+let globalTestMap = {};
+let globalLogs = [];
+let globalTestStatusMap = {};
+function getGlobalTestMap() {
+    return globalTestMap;
+}
+function getGlobalLogs() {
+    return globalLogs;
+}
+function clearGlobalStore() {
+    (0, captureStream_1.closeCaptureStream)();
+    globalTestMap = {};
+    globalLogs = [];
+    globalTestStatusMap = {};
+}
+function addToGlobalLogs(log) {
+    globalLogs.push(log);
+}
+/** @param testRunId - Playwright `testInfo.testId` (or display key fallback from the fixture) */
+function addToTestMap(testRunId, log) {
+    if (!globalTestMap[testRunId]) {
+        globalTestMap[testRunId] = [];
+    }
+    globalTestMap[testRunId].push(log);
+}
+// ── Test-status store ──────────────────────────────────────────────────────
+/** @param testRunId - Same id passed to {@link addToTestMap} for this test run */
+function setTestStatus(testRunId, entry) {
+    globalTestStatusMap[testRunId] = entry;
+}
+function getTestStatusMap() {
+    return globalTestStatusMap;
+}
+/**
+ * Compute aggregate pass/fail/skip counts from the current status map.
+ * Useful for quick reporting without iterating the map yourself.
+ */
+function getTestStatusSummary() {
+    const summary = {
+        total: 0,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        timedOut: 0,
+        interrupted: 0,
+        running: 0,
+    };
+    for (const entry of Object.values(globalTestStatusMap)) {
+        summary.total += 1;
+        summary[entry.status] = (summary[entry.status] ?? 0) + 1;
+    }
+    return summary;
+}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Shared types for network capture
+ *
+ * Used by: networkLogger, store, utils/logUtils, and consumers.
+ * Keeps a single definition of NetworkLog and TestNetworkMap.
+ */
+/** A single captured HTTP request/response. */
+export interface NetworkLog {
+    method: string;
+    url: string;
+    statusCode: number;
+    statusText: string;
+    requestHeaders: Record<string, string>;
+    requestBody?: string;
+    responseHeaders: Record<string, string>;
+    responseBody?: string;
+    timestamp: string;
+}
+/**
+ * Map of internal test run id → network logs (in-memory store).
+ * Keys are Playwright `testInfo.testId` when present (fixture fallback: display key).
+ */
+export interface TestNetworkMap {
+    [testRunId: string]: NetworkLog[];
+}
+/**
+ * Result status for a single test, mirroring Playwright's TestInfo.status values.
+ * `running` is used only on {@link TestStatusEntry} written at capture start (NDJSON `meta_start`).
+ */
+export type TestResultStatus = 'passed' | 'failed' | 'timedOut' | 'skipped' | 'interrupted' | 'running';
+/** Raw error object from Playwright's testInfo.errors — mirrors TestInfoError. */
+export interface TestInfoError {
+    /** Human-readable error message. */
+    message?: string;
+    /** Stack trace string, if available. */
+    stack?: string;
+    /** Serialized error value, if available. */
+    value?: string;
+}
+/** Status data captured for a single test. */
+export interface TestStatusEntry {
+    /** Playwright-reported outcome for the test. */
+    status: TestResultStatus;
+    /** Wall-clock duration of the test in milliseconds. */
+    duration: number;
+    /** Absolute path to the spec file that contains this test (testInfo.file). */
+    file: string;
+    /** Unique test identifier assigned by Playwright (testInfo.testId). */
+    test_id: string;
+    /**
+     * Title segments after the project (file → describe → test), aligned with Playwright’s
+     * `titlePath` or `[title]` when `titlePath` is empty. Together with `project`, the merged JSON
+     * map key is `project + ' › ' + title_path.join(' › ')` (or only `title_path` joined when
+     * `project` is empty).
+     */
+    title_path: string[];
+    /** Full error objects from testInfo.errors — includes message, stack, and value. */
+    test_info_errors: TestInfoError[];
+    /** Playwright tags attached to the test (testInfo.tags). */
+    tags: string[];
+    /** Playwright project name the test ran under (testInfo.project.name). */
+    project: string;
+}
+/** Map of internal test run id → status entry, accumulated across the worker process. */
+export interface TestStatusMap {
+    [testRunId: string]: TestStatusEntry;
+}
+/** Aggregate counts computed from a TestStatusMap. */
+export interface TestStatusSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    timedOut: number;
+    interrupted: number;
+    /** Tests currently in progress (capture `meta_start` only; cleared when final status is stored). */
+    running: number;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Shared types for network capture
+ *
+ * Used by: networkLogger, store, utils/logUtils, and consumers.
+ * Keeps a single definition of NetworkLog and TestNetworkMap.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/fileUtils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * File system utilities
+ *
+ * Used by NetworkLogger.saveAll() to write output. Can be reused for custom
+ * output paths or formats (e.g. ensureDir before writing, writeJsonFile for JSON).
+ */
+/** Ensure a directory exists, creating it recursively if needed. */
+export declare function ensureDir(dir: string): void;
+/** Write JSON to a file with pretty-printing. */
+export declare function writeJsonFile(filePath: string, data: unknown): void;

package/dist/utils/fileUtils.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * File system utilities
+ *
+ * Used by NetworkLogger.saveAll() to write output. Can be reused for custom
+ * output paths or formats (e.g. ensureDir before writing, writeJsonFile for JSON).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDir = ensureDir;
+exports.writeJsonFile = writeJsonFile;
+const fs_1 = __importDefault(require("fs"));
+/** Ensure a directory exists, creating it recursively if needed. */
+function ensureDir(dir) {
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+}
+/** Write JSON to a file with pretty-printing. */
+function writeJsonFile(filePath, data) {
+    fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utils barrel — re-exports file, log, and request helpers for use by networkLogger and by consumers.
+ */
+export { ensureDir, writeJsonFile } from './fileUtils';
+export { isDuplicateLog, buildNetworkLog, type BuildNetworkLogParams } from './logUtils';
+export { getResponseBody, getRequestBody, UNABLE_TO_RETRIEVE_BODY } from './requestUtils';

package/dist/utils/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Utils barrel — re-exports file, log, and request helpers for use by networkLogger and by consumers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNABLE_TO_RETRIEVE_BODY = exports.getRequestBody = exports.getResponseBody = exports.buildNetworkLog = exports.isDuplicateLog = exports.writeJsonFile = exports.ensureDir = void 0;
+var fileUtils_1 = require("./fileUtils");
+Object.defineProperty(exports, "ensureDir", { enumerable: true, get: function () { return fileUtils_1.ensureDir; } });
+Object.defineProperty(exports, "writeJsonFile", { enumerable: true, get: function () { return fileUtils_1.writeJsonFile; } });
+var logUtils_1 = require("./logUtils");
+Object.defineProperty(exports, "isDuplicateLog", { enumerable: true, get: function () { return logUtils_1.isDuplicateLog; } });
+Object.defineProperty(exports, "buildNetworkLog", { enumerable: true, get: function () { return logUtils_1.buildNetworkLog; } });
+var requestUtils_1 = require("./requestUtils");
+Object.defineProperty(exports, "getResponseBody", { enumerable: true, get: function () { return requestUtils_1.getResponseBody; } });
+Object.defineProperty(exports, "getRequestBody", { enumerable: true, get: function () { return requestUtils_1.getRequestBody; } });
+Object.defineProperty(exports, "UNABLE_TO_RETRIEVE_BODY", { enumerable: true, get: function () { return requestUtils_1.UNABLE_TO_RETRIEVE_BODY; } });

package/dist/utils/logUtils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pure helpers for network log data
+ *
+ * Flow in capture:
+ * 1. buildNetworkLog() turns raw request/response data into a NetworkLog.
+ * 2. isDuplicateLog() checks if the same method+url was already logged (avoids duplicates).
+ *
+ * Reusable for building or filtering logs outside of Playwright (e.g. from HAR or other sources).
+ */
+import type { NetworkLog } from '../types';
+/** Check if a log with the same method+url already exists in the list. */
+export declare function isDuplicateLog(logs: NetworkLog[], entry: NetworkLog): boolean;
+/** Input shape for buildNetworkLog (timestamp is optional; default is now). */
+export interface BuildNetworkLogParams {
+    method: string;
+    url: string;
+    statusCode: number;
+    statusText: string;
+    requestHeaders: Record<string, string>;
+    responseHeaders: Record<string, string>;
+    requestBody?: string;
+    responseBody?: string;
+    timestamp?: string;
+}
+/** Build a NetworkLog from request/response data. Omits empty requestBody; includes responseBody when present. */
+export declare function buildNetworkLog(params: BuildNetworkLogParams): NetworkLog;

package/dist/utils/logUtils.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Pure helpers for network log data
+ *
+ * Flow in capture:
+ * 1. buildNetworkLog() turns raw request/response data into a NetworkLog.
+ * 2. isDuplicateLog() checks if the same method+url was already logged (avoids duplicates).
+ *
+ * Reusable for building or filtering logs outside of Playwright (e.g. from HAR or other sources).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDuplicateLog = isDuplicateLog;
+exports.buildNetworkLog = buildNetworkLog;
+/** Check if a log with the same method+url already exists in the list. */
+function isDuplicateLog(logs, entry) {
+    return logs.some((log) => log.method === entry.method && log.url === entry.url);
+}
+/** Build a NetworkLog from request/response data. Omits empty requestBody; includes responseBody when present. */
+function buildNetworkLog(params) {
+    const { requestBody, responseBody, ...rest } = params;
+    return {
+        ...rest,
+        timestamp: params.timestamp ?? new Date().toISOString(),
+        ...(requestBody != null && requestBody !== '' && { requestBody }),
+        ...(responseBody != null && { responseBody }),
+    };
+}

package/dist/utils/requestUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Helpers for reading request/response bodies from Playwright (or similar) objects.
+ * Used by NetworkLogger when capturing each response.
+ */
+export declare const UNABLE_TO_RETRIEVE_BODY = "[Unable to retrieve response body]";
+/** Safely read response body; return placeholder on failure. */
+export declare function getResponseBody(response: {
+    text(): Promise<string>;
+}): Promise<string>;
+/** Safely read request body (JSON or raw post data). */
+export declare function getRequestBody(request: {
+    postDataJSON?: () => unknown;
+    postData?: () => string | undefined;
+}): string | undefined;

package/dist/utils/requestUtils.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Helpers for reading request/response bodies from Playwright (or similar) objects.
+ * Used by NetworkLogger when capturing each response.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNABLE_TO_RETRIEVE_BODY = void 0;
+exports.getResponseBody = getResponseBody;
+exports.getRequestBody = getRequestBody;
+exports.UNABLE_TO_RETRIEVE_BODY = '[Unable to retrieve response body]';
+/** Safely read response body; return placeholder on failure. */
+async function getResponseBody(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return exports.UNABLE_TO_RETRIEVE_BODY;
+    }
+}
+/** Safely read request body (JSON or raw post data). */
+function getRequestBody(request) {
+    try {
+        const postData = request.postDataJSON != null
+            ? JSON.stringify(request.postDataJSON())
+            : request.postData?.();
+        return postData ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/utils/testMapKey.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Canonical display key for merged analysis (matches NDJSON `displayKey` / CLI nesting).
+ */
+/**
+ * Stable map key for merged JSON and CLI consumption.
+ *
+ * @param project - `testInfo.project.name` (empty when no project)
+ * @param titlePath - File → describe → test segments; same as `_meta.title_path`
+ */
+export declare function buildNetworkTestMapKey(project: string, titlePath: string[]): string;

package/dist/utils/testMapKey.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Canonical display key for merged analysis (matches NDJSON `displayKey` / CLI nesting).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNetworkTestMapKey = buildNetworkTestMapKey;
+/**
+ * Stable map key for merged JSON and CLI consumption.
+ *
+ * @param project - `testInfo.project.name` (empty when no project)
+ * @param titlePath - File → describe → test segments; same as `_meta.title_path`
+ */
+function buildNetworkTestMapKey(project, titlePath) {
+    const segments = project ? [project, ...titlePath] : [...titlePath];
+    return segments.join(' › ');
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "postman-playwright",
+  "version": "1.0.0",
+  "description": "Playwright plugin that captures network traffic during UI tests for use with the Postman CLI.",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "postman",
+    "playwright",
+    "playwright-plugin",
+    "network-capture",
+    "api-testing",
+    "contract-testing",
+    "ui-testing",
+    "e2e"
+  ],
+  "homepage": "https://www.postman.com/",
+  "author": "Postman Labs <help@postman.com>",
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.40.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^25.4.0",
+    "typescript": "^5.3.3"
+  }
+}