@npy/fetch 0.1.3 → 0.1.4

package/examples/http-client.ts

@@ -1,47 +0,0 @@
-import { HttpClient } from "../src/http-client";
-
-const client = new HttpClient({
-    poolMaxPerHost: 32,
-    poolMaxIdlePerHost: 8,
-    connect: {
-        keepAlive: true,
-        noDelay: true,
-    },
-    io: {
-        reader: {
-            highWaterMark: 16 * 1024,
-            maxHeaderSize: 64 * 1024,
-            maxLineSize: 64 * 1024,
-            maxBufferedBytes: 256 * 1024,
-            decompress: true,
-        },
-        writer: {
-            highWaterMark: 16 * 1024,
-            directWriteThreshold: 64 * 1024,
-            coalesceBodyMaxBytes: 64 * 1024,
-        },
-    },
-});
-
-try {
-    const response = await client.send({
-        url: "https://httpbin.org/anything",
-        method: "POST",
-        headers: new Headers({
-            "content-type": "application/json",
-            "x-example": "advanced-http-client",
-        }),
-        body: JSON.stringify({
-            source: "HttpClient.send",
-            features: ["pooling", "custom I/O", "raw Response access"],
-        }),
-    });
-
-    console.log("status:", response.status);
-    console.log("headers:", Object.fromEntries(response.headers.entries()));
-
-    const data = await response.json();
-    console.log("echoed json:", data.json);
-} finally {
-    await client.close();
-}

package/examples/proxy.ts

@@ -1,16 +0,0 @@
-import { fetch } from "../src/fetch";
-
-const proxyUrl = "http://V0rk3M:phA3fT@186.179.61.64:9183";
-
-const response = await fetch("https://httpbin.org/ip", { proxy: proxyUrl });
-
-if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-}
-
-const data = await response.json();
-
-console.log("proxy:", proxyUrl);
-console.log("origin seen by server:", data.origin);
-
-await fetch.close();

package/examples/simple.ts

@@ -1,15 +0,0 @@
-import { fetch } from "../src/fetch";
-
-const response = await fetch("https://httpbin.org/anything");
-
-if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-}
-
-const data = await response.json();
-
-console.log("status:", response.status);
-console.log("url:", data.url);
-console.log("headers sent:", data.headers);
-
-await fetch.close();

package/src/_internal/consts.ts

@@ -1,3 +0,0 @@
-export const CRLF_BYTES = new Uint8Array([0x0d, 0x0a]);
-export const CRLF_STR = "\r\n";
-export const CRLF_LENGTH = 2;

package/src/_internal/error-mapping.ts

@@ -1,160 +0,0 @@
-import { DecodeStreamError } from "../_internal/decode-stream-error";
-import {
-    ConnectionError,
-    ConnectTimeoutError,
-    FetchError,
-    type FetchErrorContext,
-    RequestAbortedError,
-    RequestWriteError,
-    ResponseBodyError,
-    ResponseDecodeError,
-    ResponseHeaderError,
-} from "../errors";
-
-/** Casts or converts the unknown into an Error */
-export function unknownToError(err: unknown): Error {
-    if (err instanceof Error) {
-        return err;
-    }
-
-    if (typeof err === "string") {
-        return new Error(err);
-    }
-
-    return new Error("unknown error", { cause: err });
-}
-
-function isAbortOrTimeoutError(error: unknown): boolean {
-    if (!error || typeof error !== "object") {
-        return false;
-    }
-
-    const name = String((error as { name?: unknown }).name ?? "");
-    return name === "AbortError" || name === "TimeoutError";
-}
-
-export function toConnectError(
-    error: unknown,
-    {
-        signal,
-        context,
-        timedOut,
-    }: {
-        signal?: AbortSignal;
-        context?: FetchErrorContext;
-        timedOut?: boolean;
-    },
-): FetchError {
-    if (error instanceof FetchError) return error;
-
-    if (timedOut || signal?.reason?.name === "TimeoutError") {
-        return new ConnectTimeoutError(
-            unknownToError(error),
-            context,
-            "Connection timeout",
-        );
-    }
-
-    if (signal?.aborted || isAbortOrTimeoutError(error)) {
-        return new RequestAbortedError(
-            unknownToError(
-                signal?.reason ??
-                    error ??
-                    new DOMException(
-                        "This operation was aborted",
-                        "AbortError",
-                    ),
-            ),
-            context,
-            "The request was aborted while connecting",
-        );
-    }
-
-    return new ConnectionError(
-        unknownToError(error),
-        context,
-        "Connection failed",
-    );
-}
-
-export function toSendError(
-    error: unknown,
-    {
-        signal,
-        context,
-        phase,
-    }: {
-        signal?: AbortSignal;
-        context?: FetchErrorContext;
-        phase: "request" | "response" | "body";
-    },
-): FetchError {
-    if (error instanceof FetchError) return error;
-
-    if (signal?.aborted || isAbortOrTimeoutError(error)) {
-        return new RequestAbortedError(
-            unknownToError(
-                signal?.reason ??
-                    error ??
-                    new DOMException(
-                        "This operation was aborted",
-                        "AbortError",
-                    ),
-            ),
-            context,
-            phase === "body"
-                ? "The request was aborted while reading the response body"
-                : "The request was aborted",
-        );
-    }
-
-    const cause = unknownToError(error);
-
-    if (phase === "request") return new RequestWriteError(cause, context);
-    if (phase === "response") return new ResponseHeaderError(cause, context);
-
-    if (error instanceof DecodeStreamError) {
-        return new ResponseDecodeError(unknownToError(error.cause), context);
-    }
-
-    return new ResponseBodyError(cause, context);
-}
-
-export function toWebFetchError(error: unknown, signal?: AbortSignal): unknown {
-    if (signal?.aborted) {
-        return (
-            signal.reason ??
-            new DOMException("This operation was aborted", "AbortError")
-        );
-    }
-
-    if (error instanceof DOMException || error instanceof TypeError) {
-        return error;
-    }
-
-    return new TypeError("fetch failed", { cause: unknownToError(error) });
-}
-
-export function toWebBodyReadError(
-    error: unknown,
-    signal?: AbortSignal,
-): unknown {
-    if (signal?.aborted) {
-        return (
-            signal.reason ??
-            new DOMException("This operation was aborted", "AbortError")
-        );
-    }
-
-    if (
-        error instanceof DOMException ||
-        error instanceof TypeError ||
-        error instanceof RangeError
-    ) {
-        return error;
-    }
-
-    return new TypeError("Failed to read response body", {
-        cause: unknownToError(error),
-    });
-}

package/src/_internal/guards.ts

@@ -1,78 +0,0 @@
-import { Readable } from "node:stream";
-import type { IClosable, IReadable } from "@fuman/io";
-
-export interface FormDataPolyfill extends Readable {
-    getBoundary(): string;
-    getLengthSync(): number;
-    hasKnownLength(): boolean;
-}
-
-export const isReadable = (object: any): object is Readable =>
-    Boolean(Readable.isReadable(object));
-
-export const isIterable = (
-    object: any,
-): object is AsyncIterable<any> | Iterable<any> =>
-    typeof object?.[Symbol.asyncIterator] === "function" ||
-    typeof object?.[Symbol.iterator] === "function";
-
-export const isMultipartFormDataStream = (
-    object: any,
-): object is FormDataPolyfill =>
-    typeof object?.getBoundary === "function" &&
-    typeof object?.hasKnownLength === "function" &&
-    typeof object?.getLengthSync === "function" &&
-    Boolean(Readable.isReadable(object));
-
-export const isFormData = (object: any): object is FormData =>
-    typeof object === "object" &&
-    typeof object?.append === "function" &&
-    typeof object?.set === "function" &&
-    typeof object?.get === "function" &&
-    typeof object?.getAll === "function" &&
-    typeof object?.delete === "function" &&
-    typeof object?.keys === "function" &&
-    typeof object?.values === "function" &&
-    typeof object?.entries === "function" &&
-    typeof object?.constructor === "function" &&
-    object?.[Symbol.toStringTag] === "FormData";
-
-export const isURLSearchParameters = (object: any): object is URLSearchParams =>
-    typeof object === "object" &&
-    typeof object?.append === "function" &&
-    typeof object?.delete === "function" &&
-    typeof object?.get === "function" &&
-    typeof object?.getAll === "function" &&
-    typeof object?.has === "function" &&
-    typeof object?.set === "function" &&
-    typeof object?.sort === "function" &&
-    object?.[Symbol.toStringTag] === "URLSearchParams";
-
-export const isReadableStream = (object: any): object is ReadableStream =>
-    typeof object === "object" &&
-    typeof object?.getReader === "function" &&
-    typeof object?.cancel === "function" &&
-    typeof object?.tee === "function";
-
-export const isFumanReadable = (object: any): object is IReadable & IClosable =>
-    typeof object?.read === "function" &&
-    typeof object?.close === "function" &&
-    !isReadable(object) &&
-    !isReadableStream(object);
-
-export const isBlob = (object: any): object is Blob => {
-    if (
-        typeof object === "object" &&
-        object !== null &&
-        typeof object.arrayBuffer === "function" &&
-        typeof object.size === "number" &&
-        typeof object.slice === "function" &&
-        typeof object.stream === "function" &&
-        typeof object.text === "function" &&
-        typeof object.type === "string"
-    ) {
-        return true;
-    }
-
-    return false;
-};

package/src/_internal/net.ts

@@ -1,173 +0,0 @@
-import { createConnection } from "node:net";
-import { connect as nodeTlsConnect } from "node:tls";
-import type {
-    ConnectFunction,
-    TcpEndpoint,
-    TlsUpgradeFunction,
-} from "@fuman/net";
-import {
-    type NodeTlsConnectOptions,
-    type NodeTlsUpgradeOptions,
-    TcpConnection,
-    TlsConnection,
-} from "@fuman/node";
-
-export type WithSignal<T = {}> = T & { signal?: AbortSignal };
-
-type SocketLike = {
-    on(event: string, handler: (...args: any[]) => void): void;
-    removeListener(event: string, handler: (...args: any[]) => void): void;
-    destroy(error?: Error): void;
-};
-
-export interface AbortError extends Error {
-    name: "AbortError";
-}
-
-function toAbortError(reason: unknown): AbortError {
-    if (reason instanceof Error && reason.name === "AbortError") {
-        return reason as AbortError;
-    }
-
-    const message =
-        reason instanceof Error
-            ? reason.message
-            : typeof reason === "string"
-              ? reason
-              : "The operation was aborted";
-
-    if (typeof DOMException !== "undefined") {
-        return new DOMException(message, "AbortError") as AbortError;
-    }
-
-    const error = new Error(message) as AbortError;
-    error.name = "AbortError";
-    return error;
-}
-
-function throwIfAborted(signal?: AbortSignal): void {
-    if (signal?.aborted) {
-        throw toAbortError(signal.reason);
-    }
-}
-
-async function withSocketSignal<T extends SocketLike, R>(
-    createSocket: () => T,
-    wrapConnection: (socket: T) => R,
-    signal?: AbortSignal,
-    readyEvent = "connect",
-    onFailureCleanup?: () => void,
-): Promise<R> {
-    return new Promise<R>((resolve, reject) => {
-        throwIfAborted(signal);
-
-        const socket = createSocket();
-        let settled = false;
-
-        const cleanup = () => {
-            socket.removeListener("error", onError);
-            socket.removeListener("timeout", onError);
-            socket.removeListener(readyEvent, onReady);
-            signal?.removeEventListener("abort", onAbort);
-        };
-
-        const safeCleanup = () => {
-            try {
-                onFailureCleanup?.();
-            } catch {}
-        };
-
-        const resolveOnce = (value: R) => {
-            if (settled) return;
-            settled = true;
-            cleanup();
-            resolve(value);
-        };
-
-        const rejectOnce = (error: unknown) => {
-            if (settled) return;
-            settled = true;
-            cleanup();
-            reject(error);
-        };
-
-        const onError = (error: unknown) => {
-            safeCleanup();
-            rejectOnce(error);
-        };
-
-        const onAbort = () => {
-            const error = toAbortError(signal?.reason);
-            safeCleanup();
-            rejectOnce(error);
-
-            try {
-                socket.destroy(error);
-            } catch {}
-        };
-
-        const onReady = () => {
-            resolveOnce(wrapConnection(socket));
-        };
-
-        signal?.addEventListener("abort", onAbort, { once: true });
-        socket.on("error", onError);
-        socket.on("timeout", onError);
-        socket.on(readyEvent, onReady);
-    });
-}
-
-export const connectTcp: ConnectFunction<
-    WithSignal<TcpEndpoint>,
-    TcpConnection
-> = async ({ address, port, signal }) => {
-    return withSocketSignal(
-        () => createConnection({ host: address, port }),
-        (socket) => new TcpConnection(socket),
-        signal,
-    );
-};
-
-export const connectTls: ConnectFunction<
-    WithSignal<NodeTlsConnectOptions>,
-    TlsConnection
-> = async (options) => {
-    const { address, port, signal, sni, caCerts, alpnProtocols, extraOptions } =
-        options;
-
-    return withSocketSignal(
-        () =>
-            nodeTlsConnect({
-                host: address,
-                port,
-                ca: caCerts,
-                ALPNProtocols: alpnProtocols,
-                servername: sni,
-                ...extraOptions,
-            }),
-        (socket) => new TlsConnection(socket),
-        signal,
-        "secureConnect",
-    );
-};
-
-export const upgradeTls: TlsUpgradeFunction<
-    WithSignal<NodeTlsUpgradeOptions>,
-    TcpConnection,
-    TlsConnection
-> = async (conn, options) => {
-    return withSocketSignal(
-        () =>
-            nodeTlsConnect({
-                socket: conn.socket,
-                ca: options.caCerts,
-                ALPNProtocols: options.alpnProtocols,
-                servername: options.sni,
-                ...options.extraOptions,
-            }),
-        (socket) => new TlsConnection(socket),
-        options.signal,
-        "secureConnect",
-        () => conn.close(),
-    );
-};

package/src/_internal/promises.ts

@@ -1,22 +0,0 @@
-export function raceSignal<T>(
-    promise: PromiseLike<T>,
-    signal: AbortSignal,
-): Promise<T> {
-    return Promise.race([
-        promise,
-        new Promise<never>((_, reject) => {
-            function onAbort() {
-                reject(signal.reason);
-            }
-            if (signal.aborted) {
-                onAbort();
-            } else {
-                signal.addEventListener("abort", onAbort, { once: true });
-                function cleanup() {
-                    signal.removeEventListener("abort", onAbort);
-                }
-                promise.then(cleanup, cleanup);
-            }
-        }),
-    ]);
-}

package/src/_internal/streams.ts

@@ -1,52 +0,0 @@
-/**
- * Create a ReadableStream from a Uint8Array.
- *
- * The stream will emit the entire byte array as a single chunk,
- * then close immediately.
- *
- * @param bytes - The byte array to wrap.
- * @returns A ReadableStream that emits the bytes.
- */
-export function bytesToStream(bytes: Uint8Array) {
-    return new ReadableStream<Uint8Array>({
-        start(controller) {
-            controller.enqueue(bytes);
-            controller.close();
-        },
-    });
-}
-
-/**
- * A TransformStream that limits the total number of bytes passed through.
- *
- * It accumulates the byte count from incoming chunks and enqueues them
- * if the total remains within the limit; otherwise, it errors.
- *
- * @param maxBytes - The maximum allowed bytes before erroring.
- */
-export class MaxBytesTransformStream extends TransformStream<
-    Uint8Array,
-    Uint8Array
-> {
-    constructor(maxBytes: number) {
-        // Note: negation accounts for invalid value types (NaN, non numbers)
-        if (!(maxBytes >= 0)) {
-            throw new TypeError("maxBytes must be a non-negative number");
-        }
-
-        let bytesRead = 0;
-
-        super({
-            transform: (
-                chunk: Uint8Array,
-                ctrl: TransformStreamDefaultController<Uint8Array>,
-            ) => {
-                if ((bytesRead += chunk.length) <= maxBytes) {
-                    ctrl.enqueue(chunk);
-                } else {
-                    ctrl.error(new Error("Response too large"));
-                }
-            },
-        });
-    }
-}

package/src/_internal/symbols.ts

@@ -1 +0,0 @@
-export const bodyErrorMapperSymbol = Symbol("fetch.bodyErrorMapper");