Spaces:
Sleeping
Sleeping
File size: 5,791 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 154 155 | const require_fetchUtils = require('./fetchUtils-umV5xXBy.cjs');
const require_BatchInterceptor = require('./BatchInterceptor-BGhH8z1z.cjs');
require('./bufferUtils-S5_-2eN4.cjs');
const require_ClientRequest = require('./ClientRequest-2loAH7xM.cjs');
const require_handleRequest = require('./handleRequest-C-cKYjIh.cjs');
require('./node-DIKcnzhK.cjs');
const require_XMLHttpRequest = require('./XMLHttpRequest-BtDNZipW.cjs');
require('./hasConfigurableGlobal-MjY06_Ok.cjs');
const require_fetch = require('./fetch-D2ClLNN-.cjs');
//#region src/RemoteHttpInterceptor.ts
var RemoteHttpInterceptor = class extends require_BatchInterceptor.BatchInterceptor {
constructor() {
super({
name: "remote-interceptor",
interceptors: [
new require_ClientRequest.ClientRequestInterceptor(),
new require_XMLHttpRequest.XMLHttpRequestInterceptor(),
new require_fetch.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 require_fetchUtils.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 require_fetchUtils.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 require_fetchUtils.FetchRequest(requestJson.url, {
method: requestJson.method,
headers: new Headers(requestJson.headers),
credentials: requestJson.credentials,
body: requestJson.body
});
const controller = new require_fetchUtils.RequestController(request, {
passthrough: () => {},
respondWith: async (response) => {
if (require_handleRequest.isResponseError(response)) {
this.logger.info("received a network error!", { response });
throw new Error("Not implemented");
}
this.logger.info("received mocked response!", { response });
const responseClone = require_fetchUtils.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 require_handleRequest.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
exports.RemoteHttpInterceptor = RemoteHttpInterceptor;
exports.RemoteHttpResolver = RemoteHttpResolver;
exports.requestReviver = requestReviver;
//# sourceMappingURL=RemoteHttpInterceptor.cjs.map |