handmux 0.23.0 → 0.25.0

package/dist/src/browser/hammerheadCompat.js

@@ -0,0 +1,104 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const PATCHED = Symbol.for('handmux.hammerhead.websocket-upgrade-socket');
+const RESPONDER_PATCHED = Symbol.for('handmux.hammerhead.websocket-mock-response');
+const REQUEST_INFO_PATCHED = Symbol.for('handmux.hammerhead.request-info-frame-nature');
+const recordOf = (value) => (value && (typeof value === 'object' || typeof value === 'function') ? value : null);
+export function patchHammerheadDestinationRequest(input) {
+    const prototype = recordOf(recordOf(input)?.prototype);
+    const original = prototype?._onUpgrade;
+    if (typeof original !== 'function' || original.length !== 3) {
+        throw new Error('unsupported Hammerhead DestinationRequest._onUpgrade signature');
+    }
+    if (!prototype)
+        throw new Error('unsupported Hammerhead DestinationRequest prototype');
+    const upgrade = original;
+    if (upgrade[PATCHED])
+        return false;
+    function onUpgrade(response, socket, head) {
+        const responseRecord = recordOf(response);
+        if (responseRecord)
+            responseRecord.socket ??= socket;
+        return upgrade.call(this, response, socket, head);
+    }
+    Object.defineProperty(onUpgrade, PATCHED, { value: true });
+    prototype._onUpgrade = onUpgrade;
+    return true;
+}
+export function patchHammerheadWebSocketResponder(websocketInput, headerTransformsInput) {
+    const websocket = recordOf(websocketInput);
+    const headerTransforms = recordOf(headerTransformsInput);
+    const original = websocket?.respondOnWebSocket;
+    if (typeof original !== 'function') {
+        throw new Error('unsupported Hammerhead WebSocket responder');
+    }
+    if (!websocket)
+        throw new Error('unsupported Hammerhead WebSocket module');
+    const respond = original;
+    if (respond[RESPONDER_PATCHED])
+        return false;
+    function respondOnWebSocket(ctx) {
+        const context = recordOf(ctx);
+        const response = recordOf(context?.res);
+        const destination = recordOf(context?.destRes);
+        if (destination?.socket)
+            return respond(ctx);
+        if (!destination || typeof response?.end !== 'function')
+            return respond(ctx);
+        if (typeof headerTransforms?.forResponse !== 'function')
+            throw new Error('unsupported Hammerhead header transforms');
+        const headers = recordOf(headerTransforms.forResponse(ctx)) ?? {};
+        const missingUpgradeSocket = destination.statusCode === 101;
+        const statusCode = missingUpgradeSocket ? 502 : destination.statusCode || 502;
+        const statusMessage = missingUpgradeSocket ? 'Bad Gateway' : destination.statusMessage || 'Bad Gateway';
+        const lines = [`HTTP/${destination.httpVersion || '1.1'} ${statusCode} ${statusMessage}`];
+        for (const [name, value] of Object.entries(headers)) {
+            if (Array.isArray(value))
+                value.forEach((item) => lines.push(`${name}: ${item}`));
+            else if (value != null)
+                lines.push(`${name}: ${value}`);
+        }
+        if (!Object.keys(headers).some((name) => name.toLowerCase() === 'connection')) {
+            lines.push('connection: close');
+        }
+        response.end(`${lines.join('\r\n')}\r\n\r\n`);
+        return undefined;
+    }
+    Object.defineProperty(respondOnWebSocket, RESPONDER_PATCHED, { value: true });
+    websocket.respondOnWebSocket = respondOnWebSocket;
+    return true;
+}
+export function patchHammerheadRequestInfo(input) {
+    const RequestInfo = recordOf(input);
+    const original = RequestInfo?.from;
+    if (typeof original !== 'function') {
+        throw new Error('unsupported Hammerhead RequestInfo.from');
+    }
+    if (!RequestInfo)
+        throw new Error('unsupported Hammerhead RequestInfo');
+    const createInfo = original;
+    if (createInfo[REQUEST_INFO_PATCHED])
+        return false;
+    function from(ctx) {
+        const info = createInfo.call(this, ctx);
+        const infoRecord = recordOf(info);
+        if (!infoRecord)
+            throw new Error('invalid Hammerhead RequestInfo result');
+        infoRecord.isIframe = Boolean(recordOf(ctx)?.isIframe);
+        return info;
+    }
+    Object.defineProperty(from, REQUEST_INFO_PATCHED, { value: true });
+    RequestInfo.from = from;
+    return true;
+}
+export function installHammerheadWebSocketUpgradeCompat() {
+    const DestinationRequest = require('testcafe-hammerhead/lib/request-pipeline/destination-request');
+    const websocket = require('testcafe-hammerhead/lib/request-pipeline/websocket');
+    const headerTransforms = require('testcafe-hammerhead/lib/request-pipeline/header-transforms');
+    const infoModule = require('testcafe-hammerhead/lib/request-pipeline/request-hooks/events/info');
+    const RequestInfo = recordOf(infoModule)?.RequestInfo;
+    const destinationPatched = patchHammerheadDestinationRequest(DestinationRequest);
+    const responderPatched = patchHammerheadWebSocketResponder(websocket, headerTransforms);
+    const requestInfoPatched = patchHammerheadRequestInfo(RequestInfo);
+    return destinationPatched || responderPatched || requestInfoPatched;
+}

package/dist/src/browser/hammerheadRedirectCompat.js

@@ -0,0 +1,37 @@
+import { createRequire } from 'node:module';
+import { randomBytes } from 'node:crypto';
+const require = createRequire(import.meta.url);
+const MARKER = 'x-handmux-browser-rebind';
+const MARKER_SECRET = randomBytes(32).toString('base64url');
+const PATCHED = Symbol.for('handmux.hammerhead.raw-rebind-location');
+const recordOf = (value) => (value && typeof value === 'object' ? value : null);
+export function hammerheadRebindHeaders(location) {
+    return { location, [MARKER]: MARKER_SECRET };
+}
+export function patchHammerheadRebindLocation(input, markerSecret = MARKER_SECRET) {
+    const responseTransforms = recordOf(input);
+    const original = responseTransforms?.location;
+    if (typeof original !== 'function')
+        throw new Error('unsupported Hammerhead location transform');
+    if (!responseTransforms)
+        throw new Error('unsupported Hammerhead response transforms');
+    const transform = original;
+    if (transform[PATCHED])
+        return false;
+    function location(src, ctx) {
+        const destination = recordOf(recordOf(ctx)?.destRes);
+        const headers = recordOf(destination?.headers);
+        if (headers?.[MARKER] === markerSecret)
+            return src;
+        return transform(src, ctx);
+    }
+    Object.defineProperty(location, PATCHED, { value: true });
+    responseTransforms.location = location;
+    responseTransforms[MARKER] = () => undefined;
+    return true;
+}
+export function installHammerheadRebindLocationCompat() {
+    const loaded = require('testcafe-hammerhead/lib/request-pipeline/header-transforms/transforms');
+    return patchHammerheadRebindLocation(recordOf(loaded)?.responseTransforms, MARKER_SECRET);
+}
+export { MARKER as HAMMERHEAD_REBIND_HEADER };