@npy/fetch 0.1.0 → 0.1.2

package/io/writers.js

@@ -0,0 +1,195 @@
+import { bytesToStream } from "../_internal/streams.js";
+import { createEncoders, encodeStream } from "../encoding.js";
+import { parseContentLength, parseTransferEncoding } from "./_utils.js";
+import { sanitizeHeaderValue } from "./readers.js";
+import { isFumanReadable, isReadableStream } from "../_internal/guards.js";
+import { extractBody } from "../body.js";
+import { BufWriter } from "./buf-writer.js";
+import { nodeReadableToWeb } from "@fuman/node";
+import { Bytes, fumanReadableToWeb, write } from "@fuman/io";
+//#region src/io/writers.ts
+function toRequestTarget(url) {
+	return (url.pathname?.startsWith("/") ? url.pathname : "/") + (url.search || "");
+}
+function encodeHead(into, head) {
+	write.rawString(into, `${head.method.toUpperCase()} ${head.target} HTTP/1.1\r
+`);
+	for (const [k, v] of head.headers) write.rawString(into, `${k}: ${sanitizeHeaderValue(v)}\r
+`);
+	write.rawString(into, "\r\n");
+}
+function prepareBody(headers, init) {
+	const state = extractBody(init);
+	if (state.body != null && !headers.has("content-type")) headers.set("content-type", state.contentType ?? "application/octet-stream");
+	const body = state.body;
+	if (body == null) return { kind: "none" };
+	if (body instanceof Uint8Array) return {
+		kind: "bytes",
+		bytes: body,
+		length: body.byteLength
+	};
+	if (isReadableStream(body)) return {
+		kind: "stream",
+		stream: body,
+		length: state.contentLength
+	};
+	if (isFumanReadable(body)) return {
+		kind: "stream",
+		stream: fumanReadableToWeb(body),
+		length: state.contentLength
+	};
+	return {
+		kind: "stream",
+		stream: nodeReadableToWeb(body),
+		length: state.contentLength
+	};
+}
+function finalizeDelimitation(headers, body) {
+	if (body.kind === "none") return { chunked: false };
+	const te = parseTransferEncoding(headers);
+	if (te.has) {
+		headers.delete("content-length");
+		if (!te.chunked) {
+			const tokens = [...te.codings, "chunked"].filter(Boolean);
+			headers.set("transfer-encoding", tokens.join(", "));
+		}
+		return { chunked: true };
+	}
+	const knownLength = body.kind === "bytes" ? body.length : body.length ?? null;
+	if (knownLength != null) {
+		const existing = parseContentLength(headers);
+		if (existing != null && existing !== knownLength) throw new Error(`Conflicting content-length: header=${existing} body=${knownLength}`);
+		if (existing == null) headers.set("content-length", String(knownLength));
+		return { chunked: false };
+	}
+	if (parseContentLength(headers) != null) return { chunked: false };
+	headers.set("transfer-encoding", "chunked");
+	headers.delete("content-length");
+	return { chunked: true };
+}
+function createBufferedConnWriter(dst, opts) {
+	const bufferSize = opts.writeBufferSize ?? 16 * 1024;
+	const directWriteThreshold = opts.directWriteThreshold ?? 64 * 1024;
+	const bufWriter = new BufWriter(dst, bufferSize);
+	const flush = async () => {
+		await bufWriter.flush();
+	};
+	const writeBytes = async (bytes) => {
+		if (bytes.length === 0) return;
+		if (bytes.length >= directWriteThreshold) {
+			await bufWriter.flush();
+			await dst.write(bytes);
+			return;
+		}
+		await bufWriter.write(bytes);
+	};
+	const writeRawString = async (str) => {
+		if (str.length === 0) return;
+		write.rawString(bufWriter, str);
+	};
+	return {
+		flush,
+		writeBytes,
+		writeRawString,
+		directWriteThreshold
+	};
+}
+async function writeBody(dst, body, chunked, opts, signal) {
+	const bw = createBufferedConnWriter(dst, opts);
+	const writeChunk = async (chunk) => {
+		if (signal?.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("Request aborted");
+		if (!chunked) {
+			await bw.writeBytes(chunk);
+			return;
+		}
+		if (chunk.length === 0) return;
+		await bw.writeRawString(chunk.length.toString(16));
+		await bw.writeRawString("\r\n");
+		await bw.writeBytes(chunk);
+		await bw.writeRawString("\r\n");
+	};
+	if (body.kind === "bytes") await writeChunk(body.bytes);
+	else for await (const chunk of body.stream) await writeChunk(chunk);
+	if (chunked) await bw.writeRawString(`0\r
+\r
+`);
+	await bw.flush();
+}
+async function writeCoalesced(dst, scratch, head, bodyBytes, chunked) {
+	scratch.reset();
+	encodeHead(scratch, head);
+	if (!chunked) {
+		write.bytes(scratch, bodyBytes);
+		await dst.write(scratch.result());
+		scratch.reset();
+		return;
+	}
+	write.rawString(scratch, bodyBytes.length.toString(16));
+	write.rawString(scratch, "\r\n");
+	write.bytes(scratch, bodyBytes);
+	write.rawString(scratch, `\r
+0\r
+\r
+`);
+	await dst.write(scratch.result());
+	scratch.reset();
+}
+function createRequestWriter(dst, opts = {}) {
+	const scratch = Bytes.alloc(opts.writeBufferSize ?? 16 * 1024);
+	const write = async (req) => {
+		if (req.signal?.aborted) throw req.signal.reason ?? /* @__PURE__ */ new Error("Request aborted");
+		const method = req.method.toUpperCase();
+		const headers = req.headers ? new Headers(req.headers) : new Headers();
+		const url = req.url;
+		if (!headers.has("host")) headers.set("host", url.host);
+		if (!headers.has("date")) headers.set("date", (/* @__PURE__ */ new Date()).toUTCString());
+		const target = toRequestTarget(url);
+		let body = prepareBody(headers, req.body ?? null);
+		const ceRaw = headers.get("content-encoding") ?? void 0;
+		const ceEncoders = createEncoders(ceRaw);
+		if (body.kind !== "none" && ceEncoders.length > 0) {
+			body = {
+				kind: "stream",
+				stream: encodeStream(body.kind === "stream" ? body.stream : bytesToStream(body.bytes), ceRaw),
+				length: null
+			};
+			headers.delete("content-length");
+		}
+		const teInfo = parseTransferEncoding(headers);
+		if (body.kind !== "none" && teInfo.has && teInfo.codings.length > 0) {
+			body = {
+				kind: "stream",
+				stream: encodeStream(body.kind === "stream" ? body.stream : bytesToStream(body.bytes), teInfo.codings),
+				length: null
+			};
+			headers.delete("content-length");
+		}
+		const { chunked } = finalizeDelimitation(headers, body);
+		const head = {
+			method,
+			target,
+			headers
+		};
+		if (body.kind === "bytes") {
+			const max = opts.coalesceBodyMaxBytes ?? 64 * 1024;
+			if (body.bytes.length <= max) {
+				await writeCoalesced(dst, scratch, head, body.bytes, chunked);
+				return;
+			}
+		}
+		scratch.reset();
+		encodeHead(scratch, head);
+		await dst.write(scratch.result());
+		scratch.reset();
+		if (body.kind === "none") return;
+		if (body.kind === "bytes" && !chunked) {
+			if (req.signal?.aborted) throw req.signal.reason ?? /* @__PURE__ */ new Error("Request aborted");
+			await dst.write(body.bytes);
+			return;
+		}
+		await writeBody(dst, body, chunked, opts, req.signal);
+	};
+	return { write };
+}
+//#endregion
+export { createRequestWriter };

package/package.json

@@ -1,18 +1,29 @@
 {
     "name": "@npy/fetch",
     "type": "module",
-    "version": "0.1.0",
+    "version": "0.1.2",
+    "description": "HTTP/1.1 client built from raw TCP sockets with fetch-compatible primitives and proxy support.",
     "license": "MIT",
+    "keywords": [
+        "fetch",
+        "http",
+        "http-client",
+        "proxy",
+        "socks",
+        "socks5",
+        "tcp",
+        "node",
+        "bun"
+    ],
     "scripts": {},
     "dependencies": {
         "@fuman/io": "^0.0.19",
         "@fuman/net": "^0.0.19",
         "@fuman/node": "^0.0.19",
         "@fuman/utils": "^0.0.19",
-        "@npy/proxy-kit": "0.1.0",
+        "@npy/proxy-kit": "0.1.2",
         "bytes": "^3.1.2",
-        "generic-pool": "^3.9.0",
-        "mitata": "^1.0.34"
+        "generic-pool": "^3.9.0"
     },
     "exports": {
         ".": {
@@ -27,13 +38,15 @@
         }
     },
     "sideEffects": false,
-    "files": [
-        "dist",
-        "LICENSE",
-        "README.md"
-    ],
+    "homepage": "https://github.com/neeopy/npy",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/neeopy/npy.git"
-    }
+    },
+    "bugs": {
+        "url": "https://github.com/neeopy/npy/issues"
+    },
+    "files": [
+        "**/*"
+    ]
 }

package/types/agent.d.cts

@@ -0,0 +1,72 @@
+import { BodyInit } from '../body';
+import { LineReader, Readers } from '../io/readers';
+import { Writers } from '../io/writers';
+import { Dialer } from './dialer';
+export interface Agent {
+    [Symbol.dispose](): void;
+    close(): void;
+    readonly hostname: string;
+    readonly port: number;
+    /**
+     * Sends a single HTTP request and returns the raw {@link Response}.
+     *
+     * @remarks
+     * The returned response body preserves the advanced error mapping of this library.
+     * Limits configured through reader options are enforced while the body is consumed.
+     */
+    send(options: Agent.SendOptions): Promise<Response>;
+    whenIdle(): Promise<void>;
+    readonly isIdle: boolean;
+    readonly lastUsed: number;
+}
+export declare namespace Agent {
+    interface ConnectOptions {
+        timeout?: number;
+        keepAlive?: boolean | null;
+        noDelay?: boolean;
+    }
+    type ReaderOptions = Readers.Options & LineReader.ReadHeadersOptions;
+    type WriterOptions = Writers.Options;
+    interface IOOptions {
+        reader?: ReaderOptions;
+        writer?: WriterOptions;
+    }
+    interface Options {
+        connect?: ConnectOptions;
+        io?: IOOptions;
+    }
+    interface SendOptions {
+        url: string | URL;
+        method: string;
+        headers?: Headers;
+        body?: BodyInit | null;
+        signal?: AbortSignal;
+    }
+}
+export interface AgentPool {
+    [Symbol.asyncDispose](): Promise<void>;
+    close(): Promise<void>;
+    readonly hostname: string;
+    readonly port: number;
+    send(options: Agent.SendOptions): Promise<Response>;
+}
+export declare namespace AgentPool {
+    interface Options {
+        dialer?: Dialer;
+        poolMaxIdlePerHost?: number;
+        poolMaxPerHost?: number;
+        poolIdleTimeout?: number | false;
+        connect?: Agent.ConnectOptions;
+        io?: Agent.IOOptions;
+    }
+}
+export interface AgentConnectOptions extends Agent.ConnectOptions {
+}
+export interface AgentPoolOptions extends AgentPool.Options {
+}
+export interface SendOptions extends Agent.SendOptions {
+}
+export interface AgentIOOptions extends Agent.IOOptions {
+}
+export type AgentReaderOptions = Agent.ReaderOptions;
+export type AgentWriterOptions = Agent.WriterOptions;

package/types/agent.d.ts

@@ -0,0 +1,72 @@
+import { BodyInit } from '../body';
+import { LineReader, Readers } from '../io/readers';
+import { Writers } from '../io/writers';
+import { Dialer } from './dialer';
+export interface Agent {
+    [Symbol.dispose](): void;
+    close(): void;
+    readonly hostname: string;
+    readonly port: number;
+    /**
+     * Sends a single HTTP request and returns the raw {@link Response}.
+     *
+     * @remarks
+     * The returned response body preserves the advanced error mapping of this library.
+     * Limits configured through reader options are enforced while the body is consumed.
+     */
+    send(options: Agent.SendOptions): Promise<Response>;
+    whenIdle(): Promise<void>;
+    readonly isIdle: boolean;
+    readonly lastUsed: number;
+}
+export declare namespace Agent {
+    interface ConnectOptions {
+        timeout?: number;
+        keepAlive?: boolean | null;
+        noDelay?: boolean;
+    }
+    type ReaderOptions = Readers.Options & LineReader.ReadHeadersOptions;
+    type WriterOptions = Writers.Options;
+    interface IOOptions {
+        reader?: ReaderOptions;
+        writer?: WriterOptions;
+    }
+    interface Options {
+        connect?: ConnectOptions;
+        io?: IOOptions;
+    }
+    interface SendOptions {
+        url: string | URL;
+        method: string;
+        headers?: Headers;
+        body?: BodyInit | null;
+        signal?: AbortSignal;
+    }
+}
+export interface AgentPool {
+    [Symbol.asyncDispose](): Promise<void>;
+    close(): Promise<void>;
+    readonly hostname: string;
+    readonly port: number;
+    send(options: Agent.SendOptions): Promise<Response>;
+}
+export declare namespace AgentPool {
+    interface Options {
+        dialer?: Dialer;
+        poolMaxIdlePerHost?: number;
+        poolMaxPerHost?: number;
+        poolIdleTimeout?: number | false;
+        connect?: Agent.ConnectOptions;
+        io?: Agent.IOOptions;
+    }
+}
+export interface AgentConnectOptions extends Agent.ConnectOptions {
+}
+export interface AgentPoolOptions extends AgentPool.Options {
+}
+export interface SendOptions extends Agent.SendOptions {
+}
+export interface AgentIOOptions extends Agent.IOOptions {
+}
+export type AgentReaderOptions = Agent.ReaderOptions;
+export type AgentWriterOptions = Agent.WriterOptions;

package/types/dialer.d.cts

@@ -0,0 +1,30 @@
+import { ITcpConnection, ITlsConnection } from '@fuman/net';
+import { NodeTlsConnectOptions } from '@fuman/node';
+/**
+ * Transport abstraction responsible for opening a connection to an HTTP target.
+ */
+export interface Dialer {
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare namespace Dialer {
+    type ConnectionLike = ITcpConnection | ITlsConnection;
+    interface Target {
+        address: string;
+        port: number;
+        secure: boolean;
+        /** Server Name Indication (TLS). Defaults to the host when applicable. */
+        sni?: string;
+        /** Defaults to ["http/1.1"] when omitted by the dialer implementation. */
+        alpnProtocols?: string[];
+        /** Extra Node.js TLS options (minVersion, servername, etc.). */
+        extraOptions?: NodeTlsConnectOptions["extraOptions"];
+    }
+    interface Options {
+        signal?: AbortSignal;
+    }
+}
+/** Back-compat */
+export type ConnectionLike = Dialer.ConnectionLike;
+/** Back-compat */
+export interface DialTarget extends Dialer.Target {
+}

package/types/dialer.d.ts

@@ -0,0 +1,30 @@
+import { ITcpConnection, ITlsConnection } from '@fuman/net';
+import { NodeTlsConnectOptions } from '@fuman/node';
+/**
+ * Transport abstraction responsible for opening a connection to an HTTP target.
+ */
+export interface Dialer {
+    dial(target: Dialer.Target, options?: Dialer.Options): Promise<Dialer.ConnectionLike>;
+}
+export declare namespace Dialer {
+    type ConnectionLike = ITcpConnection | ITlsConnection;
+    interface Target {
+        address: string;
+        port: number;
+        secure: boolean;
+        /** Server Name Indication (TLS). Defaults to the host when applicable. */
+        sni?: string;
+        /** Defaults to ["http/1.1"] when omitted by the dialer implementation. */
+        alpnProtocols?: string[];
+        /** Extra Node.js TLS options (minVersion, servername, etc.). */
+        extraOptions?: NodeTlsConnectOptions["extraOptions"];
+    }
+    interface Options {
+        signal?: AbortSignal;
+    }
+}
+/** Back-compat */
+export type ConnectionLike = Dialer.ConnectionLike;
+/** Back-compat */
+export interface DialTarget extends Dialer.Target {
+}

package/types/index.d.cts

@@ -0,0 +1,2 @@
+export * from './agent';
+export * from './dialer';

package/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './agent';
+export * from './dialer';