Spaces:
Sleeping
Sleeping
File size: 5,582 Bytes
cd6720a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | import { a as RequestController, c as Interceptor, n as FetchResponse, t as FetchRequest } from "./fetchUtils-BKJ1XmiO.mjs";
import { t as BatchInterceptor } from "./BatchInterceptor-C4-RX5rg.mjs";
import "./bufferUtils-DxPxwff_.mjs";
import { t as ClientRequestInterceptor } from "./ClientRequest-DGhBX21V.mjs";
import { n as isResponseError, t as handleRequest } from "./handleRequest-FIQv5pwH.mjs";
import "./node-lsdNwZEW.mjs";
import { t as XMLHttpRequestInterceptor } from "./XMLHttpRequest-Dw6Wm-UU.mjs";
import "./hasConfigurableGlobal-BiTmog1u.mjs";
import { t as FetchInterceptor } from "./fetch-CaC3rGEu.mjs";
//#region src/RemoteHttpInterceptor.ts
var RemoteHttpInterceptor = class extends BatchInterceptor {
constructor() {
super({
name: "remote-interceptor",
interceptors: [
new ClientRequestInterceptor(),
new XMLHttpRequestInterceptor(),
new FetchInterceptor()
]
});
}
setup() {
super.setup();
let handleParentMessage;
this.on("request", async ({ request, requestId, controller }) => {
const serializedRequest = JSON.stringify({
id: requestId,
method: request.method,
url: request.url,
headers: Array.from(request.headers.entries()),
credentials: request.credentials,
body: ["GET", "HEAD"].includes(request.method) ? null : await request.text()
});
this.logger.info("sent serialized request to the child:", serializedRequest);
process.send?.(`request:${serializedRequest}`);
const responsePromise = new Promise((resolve) => {
handleParentMessage = (message) => {
if (typeof message !== "string") return resolve();
if (message.startsWith(`response:${requestId}`)) {
const [, serializedResponse] = message.match(/^response:.+?:(.+)$/) || [];
if (!serializedResponse) return resolve();
const responseInit = JSON.parse(serializedResponse);
const mockedResponse = new FetchResponse(responseInit.body, {
url: request.url,
status: responseInit.status,
statusText: responseInit.statusText,
headers: responseInit.headers
});
/**
* @todo Support "errorWith" as well.
* This response handling from the child is incomplete.
*/
controller.respondWith(mockedResponse);
return resolve();
}
};
});
this.logger.info("add \"message\" listener to the parent process", handleParentMessage);
process.addListener("message", handleParentMessage);
return responsePromise;
});
this.subscriptions.push(() => {
process.removeListener("message", handleParentMessage);
});
}
};
function requestReviver(key, value) {
switch (key) {
case "url": return new URL(value);
case "headers": return new Headers(value);
default: return value;
}
}
var RemoteHttpResolver = class RemoteHttpResolver extends Interceptor {
static {
this.symbol = Symbol.for("remote-resolver");
}
constructor(options) {
super(RemoteHttpResolver.symbol);
this.process = options.process;
}
setup() {
const logger = this.logger.extend("setup");
const handleChildMessage = async (message) => {
logger.info("received message from child!", message);
if (typeof message !== "string" || !message.startsWith("request:")) {
logger.info("unknown message, ignoring...");
return;
}
const [, serializedRequest] = message.match(/^request:(.+)$/) || [];
if (!serializedRequest) return;
const requestJson = JSON.parse(serializedRequest, requestReviver);
logger.info("parsed intercepted request", requestJson);
const request = new FetchRequest(requestJson.url, {
method: requestJson.method,
headers: new Headers(requestJson.headers),
credentials: requestJson.credentials,
body: requestJson.body
});
const controller = new RequestController(request, {
passthrough: () => {},
respondWith: async (response) => {
if (isResponseError(response)) {
this.logger.info("received a network error!", { response });
throw new Error("Not implemented");
}
this.logger.info("received mocked response!", { response });
const responseClone = FetchResponse.clone(response);
const responseText = await responseClone.text();
const serializedResponse = JSON.stringify({
status: response.status,
statusText: response.statusText,
headers: Array.from(response.headers.entries()),
body: responseText
});
this.process.send(`response:${requestJson.id}:${serializedResponse}`, (error) => {
if (error) return;
this.emitter.emit("response", {
request,
requestId: requestJson.id,
response: responseClone,
isMockedResponse: true
});
});
logger.info("sent serialized mocked response to the parent:", serializedResponse);
},
errorWith: (reason) => {
this.logger.info("request has errored!", { error: reason });
throw new Error("Not implemented");
}
});
await handleRequest({
request,
requestId: requestJson.id,
controller,
emitter: this.emitter
});
};
this.subscriptions.push(() => {
this.process.removeListener("message", handleChildMessage);
logger.info("removed the \"message\" listener from the child process!");
});
logger.info("adding a \"message\" listener to the child process");
this.process.addListener("message", handleChildMessage);
this.process.once("error", () => this.dispose());
this.process.once("exit", () => this.dispose());
}
};
//#endregion
export { RemoteHttpInterceptor, RemoteHttpResolver, requestReviver };
//# sourceMappingURL=RemoteHttpInterceptor.mjs.map |