Big News: Socket raises $60M Series C at a $1B valuation to secure software supply chains for AI-driven development.Announcement →
Sign In

@smithy/node-http-handler

Package Overview
Dependencies
Maintainers
3
Versions
93
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@smithy/node-http-handler - npm Package Compare versions

Comparing version
4.7.4
 to
4.7.5
+2
-2
package.json
{
"name": "@smithy/node-http-handler",
"version": "4.7.4",
"version": "4.7.5",
"description": "Provides a way to make requests",

@@ -29,3 +29,3 @@ "scripts": {

"dependencies": {
"@smithy/core": "^3.24.4",
"@smithy/core": "^3.24.5",
"@smithy/types": "^4.14.2",

@@ -32,0 +32,0 @@ "tslib": "^2.6.2"

-21
dist-es/readable.mock.js
import { Readable } from "node:stream";
export class ReadFromBuffers extends Readable {
buffersToRead;
numBuffersRead = 0;
errorAfter;
constructor(options) {
super(options);
this.buffersToRead = options.buffers;
this.errorAfter = typeof options.errorAfter === "number" ? options.errorAfter : -1;
}
_read() {
if (this.errorAfter !== -1 && this.errorAfter === this.numBuffersRead) {
this.emit("error", new Error("Mock Error"));
return;
}
if (this.numBuffersRead >= this.buffersToRead.length) {
return this.push(null);
}
return this.push(this.buffersToRead[this.numBuffersRead++]);
}
}
-88
dist-es/server.mock.js
import { readFileSync } from "node:fs";
import { createServer as createHttp2Server } from "node:http2";
import { createServer as createHttpServer, } from "node:http";
import { createServer as createHttpsServer } from "node:https";
import { join } from "node:path";
import { Readable } from "node:stream";
import { timing } from "./timing";
const fixturesDir = join(__dirname, "..", "fixtures");
const setResponseHeaders = (response, headers) => {
for (const [key, value] of Object.entries(headers)) {
response.setHeader(key, value);
}
};
const setResponseBody = (response, body) => {
if (body instanceof Readable) {
body.pipe(response);
}
else {
response.end(body);
}
};
export const createResponseFunction = (httpResp) => (request, response) => {
response.statusCode = httpResp.statusCode;
if (httpResp.reason) {
response.statusMessage = httpResp.reason;
}
setResponseHeaders(response, httpResp.headers);
setResponseBody(response, httpResp.body);
};
export const createResponseFunctionWithDelay = (httpResp, delay) => (request, response) => {
response.statusCode = httpResp.statusCode;
if (httpResp.reason) {
response.statusMessage = httpResp.reason;
}
setResponseHeaders(response, httpResp.headers);
timing.setTimeout(() => setResponseBody(response, httpResp.body), delay);
};
export const createContinueResponseFunction = (httpResp) => (request, response) => {
response.writeContinue();
timing.setTimeout(() => {
createResponseFunction(httpResp)(request, response);
}, 100);
};
export const createMockHttpsServer = () => {
const server = createHttpsServer({
key: readFileSync(join(fixturesDir, "test-server-key.pem")),
cert: readFileSync(join(fixturesDir, "test-server-cert.pem")),
});
return server;
};
export const createMockHttpServer = () => {
const server = createHttpServer();
return server;
};
export const createMockHttp2Server = () => {
const server = createHttp2Server();
return server;
};
export const createMirrorResponseFunction = (httpResp) => (request, response) => {
const bufs = [];
request.on("data", (chunk) => {
bufs.push(chunk);
});
request.on("end", () => {
response.statusCode = httpResp.statusCode;
setResponseHeaders(response, httpResp.headers);
setResponseBody(response, Buffer.concat(bufs));
});
request.on("error", (err) => {
response.statusCode = 500;
setResponseHeaders(response, httpResp.headers);
setResponseBody(response, err.message);
});
};
export const getResponseBody = (response) => {
return new Promise((resolve, reject) => {
const bufs = [];
response.body.on("data", function (d) {
bufs.push(d);
});
response.body.on("end", function () {
resolve(Buffer.concat(bufs).toString());
});
response.body.on("error", (err) => {
reject(err);
});
});
};
-21
dist-es/stream-collector/readable.mock.js
import { Readable } from "node:stream";
export class ReadFromBuffers extends Readable {
buffersToRead;
numBuffersRead = 0;
errorAfter;
constructor(options) {
super(options);
this.buffersToRead = options.buffers;
this.errorAfter = typeof options.errorAfter === "number" ? options.errorAfter : -1;
}
_read(size) {
if (this.errorAfter !== -1 && this.errorAfter === this.numBuffersRead) {
this.emit("error", new Error("Mock Error"));
return;
}
if (this.numBuffersRead >= this.buffersToRead.length) {
return this.push(null);
}
return this.push(this.buffersToRead[this.numBuffersRead++]);
}
}
-12
dist-types/readable.mock.d.ts
import { Readable, type ReadableOptions } from "node:stream";
export interface ReadFromBuffersOptions extends ReadableOptions {
buffers: Buffer[];
errorAfter?: number;
}
export declare class ReadFromBuffers extends Readable {
private buffersToRead;
private numBuffersRead;
private errorAfter;
constructor(options: ReadFromBuffersOptions);
_read(): boolean | undefined;
}
-12
dist-types/server.mock.d.ts
import { type Http2Server } from "node:http2";
import { type Server as HttpServer, type IncomingMessage, type ServerResponse } from "node:http";
import { type Server as HttpsServer } from "node:https";
import type { HttpResponse } from "@smithy/types";
export declare const createResponseFunction: (httpResp: HttpResponse) => (request: IncomingMessage, response: ServerResponse) => void;
export declare const createResponseFunctionWithDelay: (httpResp: HttpResponse, delay: number) => (request: IncomingMessage, response: ServerResponse) => void;
export declare const createContinueResponseFunction: (httpResp: HttpResponse) => (request: IncomingMessage, response: ServerResponse) => void;
export declare const createMockHttpsServer: () => HttpsServer;
export declare const createMockHttpServer: () => HttpServer;
export declare const createMockHttp2Server: () => Http2Server;
export declare const createMirrorResponseFunction: (httpResp: HttpResponse) => (request: IncomingMessage, response: ServerResponse) => void;
export declare const getResponseBody: (response: HttpResponse) => Promise<string>;
-12
dist-types/stream-collector/readable.mock.d.ts
import { Readable, type ReadableOptions } from "node:stream";
export interface ReadFromBuffersOptions extends ReadableOptions {
buffers: Buffer[];
errorAfter?: number;
}
export declare class ReadFromBuffers extends Readable {
private buffersToRead;
private numBuffersRead;
private errorAfter;
constructor(options: ReadFromBuffersOptions);
_read(size: number): boolean | undefined;
}