serverless-spy
Version:
CDK-based library for writing elegant integration tests on AWS serverless architecture and an additional web console to monitor events in real time.
238 lines (229 loc) • 7.95 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
FetchHttpHandler: () => FetchHttpHandler,
keepAliveSupport: () => keepAliveSupport,
streamCollector: () => streamCollector
});
module.exports = __toCommonJS(src_exports);
// src/fetch-http-handler.ts
var import_protocol_http = require("@smithy/protocol-http");
var import_querystring_builder = require("@smithy/querystring-builder");
// src/create-request.ts
function createRequest(url, requestOptions) {
return new Request(url, requestOptions);
}
__name(createRequest, "createRequest");
// src/request-timeout.ts
function requestTimeout(timeoutInMs = 0) {
return new Promise((resolve, reject) => {
if (timeoutInMs) {
setTimeout(() => {
const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`);
timeoutError.name = "TimeoutError";
reject(timeoutError);
}, timeoutInMs);
}
});
}
__name(requestTimeout, "requestTimeout");
// src/fetch-http-handler.ts
var keepAliveSupport = {
supported: void 0
};
var _FetchHttpHandler = class _FetchHttpHandler {
/**
* @returns the input if it is an HttpHandler of any class,
* or instantiates a new instance of this handler.
*/
static create(instanceOrOptions) {
if (typeof (instanceOrOptions == null ? void 0 : instanceOrOptions.handle) === "function") {
return instanceOrOptions;
}
return new _FetchHttpHandler(instanceOrOptions);
}
constructor(options) {
if (typeof options === "function") {
this.configProvider = options().then((opts) => opts || {});
} else {
this.config = options ?? {};
this.configProvider = Promise.resolve(this.config);
}
if (keepAliveSupport.supported === void 0) {
keepAliveSupport.supported = Boolean(
typeof Request !== "undefined" && "keepalive" in createRequest("https://[::1]")
);
}
}
destroy() {
}
async handle(request, { abortSignal } = {}) {
var _a;
if (!this.config) {
this.config = await this.configProvider;
}
const requestTimeoutInMs = this.config.requestTimeout;
const keepAlive = this.config.keepAlive === true;
const credentials = this.config.credentials;
if (abortSignal == null ? void 0 : abortSignal.aborted) {
const abortError = new Error("Request aborted");
abortError.name = "AbortError";
return Promise.reject(abortError);
}
let path = request.path;
const queryString = (0, import_querystring_builder.buildQueryString)(request.query || {});
if (queryString) {
path += `?${queryString}`;
}
if (request.fragment) {
path += `#${request.fragment}`;
}
let auth = "";
if (request.username != null || request.password != null) {
const username = request.username ?? "";
const password = request.password ?? "";
auth = `${username}:${password}@`;
}
const { port, method } = request;
const url = `${request.protocol}//${auth}${request.hostname}${port ? `:${port}` : ""}${path}`;
const body = method === "GET" || method === "HEAD" ? void 0 : request.body;
const requestOptions = {
body,
headers: new Headers(request.headers),
method,
credentials
};
if ((_a = this.config) == null ? void 0 : _a.cache) {
requestOptions.cache = this.config.cache;
}
if (body) {
requestOptions.duplex = "half";
}
if (typeof AbortController !== "undefined") {
requestOptions.signal = abortSignal;
}
if (keepAliveSupport.supported) {
requestOptions.keepalive = keepAlive;
}
if (typeof this.config.requestInit === "function") {
Object.assign(requestOptions, this.config.requestInit(request));
}
let removeSignalEventListener = /* @__PURE__ */ __name(() => {
}, "removeSignalEventListener");
const fetchRequest = createRequest(url, requestOptions);
const raceOfPromises = [
fetch(fetchRequest).then((response) => {
const fetchHeaders = response.headers;
const transformedHeaders = {};
for (const pair of fetchHeaders.entries()) {
transformedHeaders[pair[0]] = pair[1];
}
const hasReadableStream = response.body != void 0;
if (!hasReadableStream) {
return response.blob().then((body2) => ({
response: new import_protocol_http.HttpResponse({
headers: transformedHeaders,
reason: response.statusText,
statusCode: response.status,
body: body2
})
}));
}
return {
response: new import_protocol_http.HttpResponse({
headers: transformedHeaders,
reason: response.statusText,
statusCode: response.status,
body: response.body
})
};
}),
requestTimeout(requestTimeoutInMs)
];
if (abortSignal) {
raceOfPromises.push(
new Promise((resolve, reject) => {
const onAbort = /* @__PURE__ */ __name(() => {
const abortError = new Error("Request aborted");
abortError.name = "AbortError";
reject(abortError);
}, "onAbort");
if (typeof abortSignal.addEventListener === "function") {
const signal = abortSignal;
signal.addEventListener("abort", onAbort, { once: true });
removeSignalEventListener = /* @__PURE__ */ __name(() => signal.removeEventListener("abort", onAbort), "removeSignalEventListener");
} else {
abortSignal.onabort = onAbort;
}
})
);
}
return Promise.race(raceOfPromises).finally(removeSignalEventListener);
}
updateHttpClientConfig(key, value) {
this.config = void 0;
this.configProvider = this.configProvider.then((config) => {
config[key] = value;
return config;
});
}
httpHandlerConfigs() {
return this.config ?? {};
}
};
__name(_FetchHttpHandler, "FetchHttpHandler");
var FetchHttpHandler = _FetchHttpHandler;
// src/stream-collector.ts
var streamCollector = /* @__PURE__ */ __name(async (stream) => {
var _a;
if (typeof Blob === "function" && stream instanceof Blob || ((_a = stream.constructor) == null ? void 0 : _a.name) === "Blob") {
return new Uint8Array(await stream.arrayBuffer());
}
return collectStream(stream);
}, "streamCollector");
async function collectStream(stream) {
const chunks = [];
const reader = stream.getReader();
let isDone = false;
let length = 0;
while (!isDone) {
const { done, value } = await reader.read();
if (value) {
chunks.push(value);
length += value.length;
}
isDone = done;
}
const collected = new Uint8Array(length);
let offset = 0;
for (const chunk of chunks) {
collected.set(chunk, offset);
offset += chunk.length;
}
return collected;
}
__name(collectStream, "collectStream");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
keepAliveSupport,
FetchHttpHandler,
streamCollector
});