fetch-h 3.0.2

package/dist/lib/body.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BodyInspector = exports.DataBody = exports.StreamBody = exports.JsonBody = exports.Body = void 0;
+const crypto_1 = require("crypto");
+const already_1 = require("already");
+const get_stream_1 = require("get-stream");
+const through2 = require("through2");
+const toArrayBuffer = require("to-arraybuffer");
+const core_1 = require("./core");
+const abortError = new core_1.AbortError("Response aborted");
+function makeUnknownDataError() {
+    return new Error("Unknown body data");
+}
+function throwIntegrityMismatch() {
+    throw new Error("Resource integrity mismatch");
+}
+function throwLengthMismatch() {
+    throw new RangeError("Resource length mismatch (possibly incomplete body)");
+}
+function parseIntegrity(integrity) {
+    const [algorithm, ...expectedHash] = integrity.split("-");
+    return { algorithm, hash: expectedHash.join("-") };
+}
+function isStream(body) {
+    return body &&
+        ("readable" in Object(body));
+}
+const emptyBuffer = new ArrayBuffer(0);
+class Body {
+    constructor() {
+        this._length = null;
+        this._used = false;
+        Object.defineProperties(this, {
+            bodyUsed: {
+                enumerable: true,
+                get: () => this._used,
+            },
+        });
+    }
+    async arrayBuffer(allowIncomplete = false) {
+        this._ensureUnused();
+        this._ensureNotAborted();
+        if (this._body == null)
+            return this.validateIntegrity(emptyBuffer, allowIncomplete);
+        else if (isStream(this._body))
+            return this.awaitBuffer(this._body)
+                .then(buffer => this.validateIntegrity(buffer, allowIncomplete))
+                .then(buffer => toArrayBuffer(buffer));
+        else if (Buffer.isBuffer(this._body))
+            return this.validateIntegrity(toArrayBuffer(this._body), allowIncomplete);
+        else
+            throw makeUnknownDataError();
+    }
+    async formData() {
+        throw new Error("Body.formData() is not yet implemented");
+    }
+    async json() {
+        this._ensureUnused();
+        this._ensureNotAborted();
+        if (this._body == null)
+            return Promise.resolve(this.validateIntegrity(emptyBuffer, false))
+                .then(() => this._body);
+        else if (isStream(this._body))
+            return this.awaitBuffer(this._body)
+                .then((0, already_1.tap)(buffer => this.validateIntegrity(buffer, false)))
+                .then(buffer => JSON.parse(buffer.toString()));
+        else if (Buffer.isBuffer(this._body))
+            return Promise.resolve(this._body)
+                .then((0, already_1.tap)(buffer => this.validateIntegrity(buffer, false)))
+                .then(buffer => JSON.parse(buffer.toString()));
+        else
+            throw makeUnknownDataError();
+    }
+    async text(allowIncomplete = false) {
+        this._ensureUnused();
+        this._ensureNotAborted();
+        if (this._body == null)
+            return Promise.resolve(this.validateIntegrity(emptyBuffer, allowIncomplete))
+                .then(() => this._body);
+        else if (isStream(this._body))
+            return this.awaitBuffer(this._body)
+                .then((0, already_1.tap)(buffer => this.validateIntegrity(buffer, allowIncomplete)))
+                .then(buffer => buffer.toString());
+        else if (Buffer.isBuffer(this._body))
+            return Promise.resolve(this._body)
+                .then((0, already_1.tap)(buffer => this.validateIntegrity(buffer, allowIncomplete)))
+                .then(buffer => buffer.toString());
+        else
+            throw makeUnknownDataError();
+    }
+    async readable() {
+        this._ensureUnused();
+        this._ensureNotAborted();
+        if (this._body == null) {
+            const stream = through2();
+            stream.end();
+            return Promise.resolve(stream);
+        }
+        else if (isStream(this._body))
+            return Promise.resolve(this._body);
+        else if (Buffer.isBuffer(this._body))
+            return Promise.resolve(through2())
+                .then(stream => {
+                stream.write(this._body);
+                stream.end();
+                return stream;
+            });
+        else
+            throw makeUnknownDataError();
+    }
+    setSignal(signal) {
+        this._signal = signal;
+    }
+    hasBody() {
+        return "_body" in this;
+    }
+    setBody(body, mime, integrity, length = null) {
+        this._ensureUnused();
+        this._length = length;
+        this._used = false;
+        if (body instanceof Body) {
+            body._ensureUnused();
+            this._body = body._body;
+            this._mime = body._mime;
+        }
+        else if (typeof body === "string")
+            this._body = Buffer.from(body);
+        else if (body != null)
+            this._body = body;
+        else
+            this._body = body;
+        if (Buffer.isBuffer(this._body))
+            this._length = this._body.length;
+        if (mime)
+            this._mime = mime;
+        if (integrity)
+            this._integrity = integrity;
+    }
+    async awaitBuffer(readable) {
+        if (!this._signal)
+            return (0, get_stream_1.buffer)(readable);
+        // Race the readable against the abort signal
+        let callback = () => { };
+        const onAborted = new Promise((_, reject) => {
+            var _a;
+            callback = () => { reject(abortError); };
+            (_a = this._signal) === null || _a === void 0 ? void 0 : _a.addListener('abort', callback);
+        });
+        try {
+            this._ensureNotAborted();
+            return await Promise.race([
+                (0, get_stream_1.buffer)(readable),
+                onAborted,
+            ]);
+        }
+        finally {
+            this._signal.removeListener('abort', callback);
+            // Could happen if abort and other error happen practically
+            // simultaneously. Ensure Node.js won't get mad about this.
+            onAborted.catch(() => { });
+        }
+    }
+    validateIntegrity(data, allowIncomplete) {
+        this._ensureNotAborted();
+        if (!allowIncomplete &&
+            this._length != null &&
+            data.byteLength !== this._length)
+            throwLengthMismatch();
+        if (!this._integrity)
+            // This is valid
+            return data;
+        const { algorithm, hash: expectedHash } = parseIntegrity(this._integrity);
+        // jest (I presume) modifies ArrayBuffer, breaking instanceof
+        const instanceOfArrayBuffer = (val) => val && val.constructor && val.constructor.name === "ArrayBuffer";
+        const hash = (0, crypto_1.createHash)(algorithm)
+            .update(instanceOfArrayBuffer(data)
+            ? new DataView(data)
+            : data)
+            .digest("base64");
+        if (expectedHash.toLowerCase() !== hash.toLowerCase())
+            throwIntegrityMismatch();
+        return data;
+    }
+    _ensureNotAborted() {
+        if (this._signal && this._signal.aborted)
+            throw abortError;
+    }
+    _ensureUnused() {
+        if (this._used)
+            throw new ReferenceError("Body already used");
+        this._used = true;
+    }
+    // @ts-ignore
+    async blob() {
+        throw new Error("Body.blob() is not implemented (makes no sense in Node.js), " +
+            "use another getter.");
+    }
+}
+exports.Body = Body;
+class JsonBody extends Body {
+    constructor(obj) {
+        super();
+        const body = Buffer.from(JSON.stringify(obj));
+        this.setBody(body, "application/json");
+    }
+}
+exports.JsonBody = JsonBody;
+class StreamBody extends Body {
+    constructor(readable) {
+        super();
+        this.setBody(readable);
+    }
+}
+exports.StreamBody = StreamBody;
+class DataBody extends Body {
+    constructor(data) {
+        super();
+        this.setBody(data);
+    }
+}
+exports.DataBody = DataBody;
+class BodyInspector extends Body {
+    constructor(body) {
+        super();
+        this._ref = body;
+    }
+    _getMime() {
+        return this._mime;
+    }
+    _getLength() {
+        return this._length;
+    }
+    _getBody() {
+        return this._body;
+    }
+    get mime() {
+        return this._getMime.call(this._ref);
+    }
+    get length() {
+        return this._getLength.call(this._ref);
+    }
+    get stream() {
+        const rawBody = this._getBody.call(this._ref);
+        return rawBody && isStream(rawBody) ? rawBody : undefined;
+    }
+}
+exports.BodyInspector = BodyInspector;
+//# sourceMappingURL=body.js.map

package/dist/lib/context-http1.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+import { RequestOptions } from "https";
+import { Socket } from "net";
+import { URL } from "url";
+import { Http1Options } from "./core";
+import { Request } from "./request";
+export interface ConnectOptions {
+    rejectUnauthorized: boolean | undefined;
+    createConnection: () => Socket;
+}
+export interface SocketAndCleanup {
+    socket: Socket;
+    cleanup: () => void;
+}
+export interface FreeSocketInfoWithSocket extends SocketAndCleanup {
+    shouldCreateNew: boolean;
+}
+export interface FreeSocketInfoWithoutSocket {
+    socket: never;
+    cleanup: never;
+    shouldCreateNew: boolean;
+}
+export declare type FreeSocketInfo = FreeSocketInfoWithSocket | FreeSocketInfoWithoutSocket;
+export declare class OriginPool {
+    private usedSockets;
+    private unusedSockets;
+    private waiting;
+    private keepAlive;
+    private keepAliveMsecs;
+    private maxSockets;
+    private maxFreeSockets;
+    private connOpts;
+    constructor(keepAlive: boolean, keepAliveMsecs: number, maxSockets: number, maxFreeSockets: number, timeout: number | void);
+    connect(options: RequestOptions): import("http").ClientRequest;
+    addUsed(socket: Socket): () => void;
+    getFreeSocket(): FreeSocketInfo;
+    waitForSocket(): Promise<SocketAndCleanup>;
+    disconnectAll(): Promise<void>;
+    private getFirstUnused;
+    private tryReuse;
+    private pumpWaiting;
+    private disconnectSocket;
+    private makeCleaner;
+    private moveToUnused;
+    private moveToUsed;
+}
+export declare class H1Context {
+    private contextPool;
+    constructor(options: Partial<Http1Options>);
+    getSessionForOrigin(origin: string): OriginPool;
+    getFreeSocketForSession(session: OriginPool): FreeSocketInfo;
+    addUsedSocket(session: OriginPool, socket: Socket): () => void;
+    waitForSocketBySession(session: OriginPool): Promise<SocketAndCleanup>;
+    connect(url: URL, extraOptions: ConnectOptions, request: Request): import("http").ClientRequest;
+    makeNewConnection(url: string): Promise<Socket>;
+    disconnect(url: string): void;
+    disconnectAll(): void;
+}

package/dist/lib/context-http1.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.H1Context = exports.OriginPool = void 0;
+const http_1 = require("http");
+const https_1 = require("https");
+const net_1 = require("net");
+const url_1 = require("url");
+const already_1 = require("already");
+const core_1 = require("./core");
+const utils_1 = require("./utils");
+class OriginPool {
+    constructor(keepAlive, keepAliveMsecs, maxSockets, maxFreeSockets, timeout) {
+        this.usedSockets = new Set();
+        this.unusedSockets = new Set();
+        this.waiting = [];
+        this.keepAlive = keepAlive;
+        this.keepAliveMsecs = keepAliveMsecs;
+        this.maxSockets = maxSockets;
+        this.maxFreeSockets = maxFreeSockets;
+        this.connOpts = timeout == null ? {} : { timeout };
+    }
+    connect(options) {
+        const request = options.protocol === "https:"
+            ? https_1.request
+            : http_1.request;
+        const opts = { ...options };
+        if (opts.rejectUnauthorized == null || options.protocol === "https")
+            delete opts.rejectUnauthorized;
+        const req = request({ ...this.connOpts, ...opts });
+        return req;
+    }
+    addUsed(socket) {
+        if (this.keepAlive)
+            socket.setKeepAlive(true, this.keepAliveMsecs);
+        socket.once("close", () => {
+            this.usedSockets.delete(socket);
+            this.unusedSockets.delete(socket);
+        });
+        this.usedSockets.add(socket);
+        return this.makeCleaner(socket);
+    }
+    getFreeSocket() {
+        const socketAndCleanup = this.getFirstUnused();
+        if (socketAndCleanup)
+            return { ...socketAndCleanup, shouldCreateNew: false };
+        const shouldCreateNew = this.maxSockets >= this.usedSockets.size;
+        return { shouldCreateNew };
+    }
+    waitForSocket() {
+        const deferred = (0, already_1.defer)();
+        this.waiting.push(deferred);
+        // Trigger due to potential race-condition
+        this.pumpWaiting();
+        return deferred.promise;
+    }
+    async disconnectAll() {
+        await Promise.all([...this.usedSockets, ...this.unusedSockets]
+            .map(socket => socket.destroyed ? void 0 : this.disconnectSocket(socket)));
+        const waiting = this.waiting;
+        this.waiting.length = 0;
+        waiting.forEach(waiter => 
+        // TODO: Better error class + message
+        waiter.reject(new Error("Disconnected")));
+    }
+    getFirstUnused() {
+        for (const socket of this.unusedSockets.values()) {
+            // We obviously have a socket
+            this.moveToUsed(socket);
+            return { socket, cleanup: this.makeCleaner(socket) };
+        }
+        return null;
+    }
+    tryReuse(socket) {
+        if (this.waiting.length === 0)
+            return false;
+        const waiting = this.waiting.shift();
+        waiting.resolve({ socket, cleanup: this.makeCleaner(socket) });
+        return true;
+    }
+    pumpWaiting() {
+        while (this.waiting.length > 0 && this.unusedSockets.size > 0) {
+            const socketAndCleanup = this.getFirstUnused();
+            const waiting = this.waiting.shift();
+            waiting.resolve(socketAndCleanup);
+        }
+    }
+    async disconnectSocket(socket) {
+        socket.destroy();
+    }
+    makeCleaner(socket) {
+        let hasCleaned = false;
+        return () => {
+            if (hasCleaned)
+                return;
+            hasCleaned = true;
+            if (!socket.destroyed)
+                this.moveToUnused(socket);
+        };
+    }
+    async moveToUnused(socket) {
+        if (this.tryReuse(socket))
+            return;
+        this.usedSockets.delete(socket);
+        if (this.maxFreeSockets < this.unusedSockets.size + 1) {
+            await this.disconnectSocket(socket);
+            return;
+        }
+        this.unusedSockets.add(socket);
+        socket.unref();
+    }
+    moveToUsed(socket) {
+        this.unusedSockets.delete(socket);
+        this.usedSockets.add(socket);
+        socket.ref();
+        return socket;
+    }
+}
+exports.OriginPool = OriginPool;
+class ContextPool {
+    constructor(options) {
+        this.pools = new Map();
+        this.keepAlive = (0, core_1.parsePerOrigin)(options.keepAlive, true);
+        this.keepAliveMsecs = (0, core_1.parsePerOrigin)(options.keepAliveMsecs, 1000);
+        this.maxSockets = (0, core_1.parsePerOrigin)(options.maxSockets, 256);
+        this.maxFreeSockets = (0, core_1.parsePerOrigin)(options.maxFreeSockets, Infinity);
+        this.timeout = (0, core_1.parsePerOrigin)(options.timeout, void 0);
+    }
+    hasOrigin(origin) {
+        return this.pools.has(origin);
+    }
+    getOriginPool(origin) {
+        const pool = this.pools.get(origin);
+        if (!pool) {
+            const keepAlive = (0, core_1.getByOrigin)(this.keepAlive, origin);
+            const keepAliveMsecs = (0, core_1.getByOrigin)(this.keepAliveMsecs, origin);
+            const maxSockets = (0, core_1.getByOrigin)(this.maxSockets, origin);
+            const maxFreeSockets = (0, core_1.getByOrigin)(this.maxFreeSockets, origin);
+            const timeout = (0, core_1.getByOrigin)(this.timeout, origin);
+            const newPool = new OriginPool(keepAlive, keepAliveMsecs, maxSockets, maxFreeSockets, timeout);
+            this.pools.set(origin, newPool);
+            return newPool;
+        }
+        return pool;
+    }
+    async disconnect(origin) {
+        const pool = this.pools.get(origin);
+        if (pool)
+            await pool.disconnectAll();
+    }
+    async disconnectAll() {
+        const pools = [...this.pools.values()];
+        await Promise.all(pools.map(pool => pool.disconnectAll()));
+    }
+}
+function sessionToPool(session) {
+    return session;
+}
+class H1Context {
+    constructor(options) {
+        this.contextPool = new ContextPool(options);
+    }
+    getSessionForOrigin(origin) {
+        return this.contextPool.getOriginPool(origin);
+    }
+    getFreeSocketForSession(session) {
+        const pool = sessionToPool(session);
+        return pool.getFreeSocket();
+    }
+    addUsedSocket(session, socket) {
+        const pool = sessionToPool(session);
+        return pool.addUsed(socket);
+    }
+    waitForSocketBySession(session) {
+        return sessionToPool(session).waitForSocket();
+    }
+    connect(url, extraOptions, request) {
+        const { origin, protocol, hostname, password, pathname, search, username, } = url;
+        const path = pathname + search;
+        const port = parseInt((0, utils_1.parseInput)(url.href).port, 10);
+        const method = request.method;
+        const auth = (username || password)
+            ? { auth: `${username}:${password}` }
+            : {};
+        const options = {
+            ...extraOptions,
+            agent: false,
+            hostname,
+            method,
+            path,
+            port,
+            protocol,
+            ...auth,
+        };
+        if (!options.headers)
+            options.headers = {};
+        options.headers.connection = this.contextPool.keepAlive
+            ? "keep-alive"
+            : "close";
+        return this.contextPool.getOriginPool(origin).connect(options);
+    }
+    async makeNewConnection(url) {
+        return new Promise((resolve, reject) => {
+            const { hostname, port } = (0, utils_1.parseInput)(url);
+            const socket = (0, net_1.createConnection)(parseInt(port, 10), hostname, () => {
+                resolve(socket);
+            });
+            socket.once("error", reject);
+            return socket;
+        });
+    }
+    disconnect(url) {
+        const { origin } = new url_1.URL(url);
+        this.contextPool.disconnect(origin);
+    }
+    disconnectAll() {
+        this.contextPool.disconnectAll();
+    }
+}
+exports.H1Context = H1Context;
+//# sourceMappingURL=context-http1.js.map

package/dist/lib/context-http2.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+import { ClientHttp2Session, SecureClientSessionOptions } from "http2";
+import { Decoder } from "./core";
+import { Request } from "./request";
+import { Response } from "./response";
+interface H2SessionItem {
+    firstOrigin: string;
+    session: ClientHttp2Session;
+    promise: Promise<ClientHttp2Session>;
+    ref: () => void;
+    unref: () => void;
+}
+export interface CacheableH2Session {
+    ref: () => void;
+    session: Promise<ClientHttp2Session>;
+    unref: () => void;
+}
+export declare type PushHandler = (origin: string, request: Request, getResponse: () => Promise<Response>) => void;
+export declare type GetDecoders = (origin: string) => ReadonlyArray<Decoder>;
+export declare type GetSessionOptions = (origin: string) => SecureClientSessionOptions;
+export declare class H2Context {
+    _pushHandler?: PushHandler;
+    private _h2sessions;
+    private _h2staleSessions;
+    private _getDecoders;
+    private _getSessionOptions;
+    constructor(getDecoders: GetDecoders, getSessionOptions: GetSessionOptions);
+    createHttp2(origin: string, onGotGoaway: () => void, extraOptions?: SecureClientSessionOptions): CacheableH2Session;
+    disconnectSession(session: ClientHttp2Session): Promise<void>;
+    releaseSession(origin: string): void;
+    deleteActiveSession(origin: string): H2SessionItem | void;
+    disconnectStaleSessions(origin: string): Promise<void>;
+    disconnectAll(): Promise<void>;
+    disconnect(url: string, session?: ClientHttp2Session): Promise<void>;
+    private handleDisconnect;
+    private handlePush;
+    private connectHttp2;
+}
+export {};