@npy/fetch 0.1.0 → 0.1.1

package/encoding.js

@@ -0,0 +1,91 @@
+import { nodeReadableToWeb } from "@fuman/node";
+import { Readable } from "node:stream";
+//#region src/encoding.ts
+function applyTransforms(stream, contentEncoding, factory) {
+	const transforms = factory(contentEncoding);
+	if (transforms.length === 0) return stream;
+	let result;
+	if (stream instanceof ReadableStream) result = stream;
+	else result = nodeReadableToWeb(Readable.from(stream));
+	for (const t of transforms) result = result.pipeThrough(t);
+	return result;
+}
+function decodeStream(stream, contentEncoding) {
+	return applyTransforms(stream, contentEncoding, createDecoders);
+}
+function encodeStream(stream, contentEncoding) {
+	return applyTransforms(stream, contentEncoding, createEncoders);
+}
+/**
+* Create a series of decoding streams based on the content-encoding header. The
+* resulting streams should be piped together to decode the content.
+*
+* @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+*/
+function createDecoders(contentEncoding) {
+	const decoders = [];
+	if (contentEncoding?.length) {
+		const encodings = Array.isArray(contentEncoding) ? contentEncoding.flatMap(commaSplit) : contentEncoding.split(",");
+		for (const encoding of encodings) {
+			const normalizedEncoding = normalizeEncoding(encoding);
+			if (normalizedEncoding === "identity") continue;
+			decoders.push(createDecoder(normalizedEncoding));
+		}
+	}
+	return decoders.reverse();
+}
+/**
+* Create a series of encoding streams based on the content-encoding header (or
+* transfer-coding list).
+*
+* The resulting streams should be piped together to apply the encoding in the
+* declared order.
+*
+* @see {@link https://datatracker.ietf.org/doc/html/rfc9110#section-8.4.1}
+*/
+function createEncoders(contentEncoding) {
+	const encoders = [];
+	if (contentEncoding?.length) {
+		const encodings = Array.isArray(contentEncoding) ? contentEncoding.flatMap(commaSplit) : contentEncoding.split(",");
+		for (const encoding of encodings) {
+			const normalizedEncoding = normalizeEncoding(encoding);
+			if (normalizedEncoding === "identity") continue;
+			encoders.push(createEncoder(normalizedEncoding));
+		}
+	}
+	return encoders;
+}
+function commaSplit(header) {
+	return header.split(",");
+}
+function normalizeEncoding(encoding) {
+	return encoding.trim().toLowerCase();
+}
+function createDecoder(normalizedEncoding) {
+	switch (normalizedEncoding) {
+		case "gzip":
+		case "x-gzip": return new DecompressionStream("gzip");
+		case "deflate":
+		case "x-deflate": return new DecompressionStream("deflate");
+		case "zstd":
+		case "x-zstd": return new DecompressionStream("zstd");
+		case "br": return new DecompressionStream("brotli");
+		case "identity": return new TransformStream();
+		default: throw new TypeError(`Unsupported content-encoding: "${normalizedEncoding}"`);
+	}
+}
+function createEncoder(normalizedEncoding) {
+	switch (normalizedEncoding) {
+		case "gzip":
+		case "x-gzip": return new CompressionStream("gzip");
+		case "deflate":
+		case "x-deflate": return new CompressionStream("deflate");
+		case "zstd":
+		case "x-zstd": return new CompressionStream("zstd");
+		case "br": return new CompressionStream("brotli");
+		case "identity": return new TransformStream();
+		default: throw new TypeError(`Unsupported content-encoding: "${normalizedEncoding}"`);
+	}
+}
+//#endregion
+export { createDecoders, createEncoders, decodeStream, encodeStream };

package/errors.cjs

@@ -0,0 +1,275 @@
+//#region src/errors.ts
+var ErrorType = {
+	ABORTED: "ABORTED",
+	NETWORK: "NETWORK",
+	TIMEOUT: "TIMEOUT",
+	HTTP_CLIENT_ERROR: "HTTP_CLIENT_ERROR",
+	HTTP_SERVER_ERROR: "HTTP_SERVER_ERROR"
+};
+var FetchErrorCode = {
+	ABORTED: "ERR_FETCH_ABORTED",
+	TIMEOUT: "ERR_FETCH_TIMEOUT",
+	CONNECTION: "ERR_FETCH_CONNECTION",
+	AGENT_CLOSED: "ERR_FETCH_AGENT_CLOSED",
+	AGENT_BUSY: "ERR_FETCH_AGENT_BUSY",
+	ORIGIN_MISMATCH: "ERR_FETCH_ORIGIN_MISMATCH",
+	UNSUPPORTED_PROTOCOL: "ERR_FETCH_UNSUPPORTED_PROTOCOL",
+	UNSUPPORTED_METHOD: "ERR_FETCH_UNSUPPORTED_METHOD",
+	TLS_ALPN: "ERR_FETCH_TLS_ALPN",
+	REQUEST_WRITE: "ERR_FETCH_REQUEST_WRITE",
+	RESPONSE_HEADERS: "ERR_FETCH_RESPONSE_HEADERS",
+	RESPONSE_BODY: "ERR_FETCH_RESPONSE_BODY",
+	RESPONSE_DECODE: "ERR_FETCH_RESPONSE_DECODE",
+	HTTP_STATUS: "ERR_FETCH_HTTP_STATUS"
+};
+var FetchError = class extends Error {
+	code;
+	phase;
+	context;
+	retryable;
+	type;
+	cause;
+	constructor(options) {
+		super(options.message, { cause: options.cause });
+		this.code = options.code;
+		this.phase = options.phase;
+		this.context = options.context;
+		this.retryable = options.retryable ?? false;
+		this.type = options.type;
+		this.cause = options.cause;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	get name() {
+		return this.constructor.name;
+	}
+	get [Symbol.toStringTag]() {
+		return this.name;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			phase: this.phase,
+			retryable: this.retryable,
+			type: this.type,
+			context: this.context,
+			cause: this.cause instanceof Error ? {
+				name: this.cause.name,
+				message: this.cause.message
+			} : this.cause
+		};
+	}
+};
+var RequestAbortedError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "The request was aborted",
+			code: FetchErrorCode.ABORTED,
+			phase: "request",
+			cause,
+			context,
+			retryable: false,
+			type: ErrorType.ABORTED
+		});
+	}
+};
+var ConnectTimeoutError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Connection timed out",
+			code: FetchErrorCode.TIMEOUT,
+			phase: "connect",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.TIMEOUT
+		});
+	}
+};
+var ConnectionError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Network connection failed",
+			code: FetchErrorCode.CONNECTION,
+			phase: "connect",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var AgentClosedError = class extends FetchError {
+	constructor(context, cause) {
+		super({
+			message: "Agent is closed",
+			code: FetchErrorCode.AGENT_CLOSED,
+			phase: "agent",
+			cause,
+			context,
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var AgentBusyError = class extends FetchError {
+	constructor(context, cause) {
+		super({
+			message: "Agent is busy",
+			code: FetchErrorCode.AGENT_BUSY,
+			phase: "agent",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var OriginMismatchError = class extends FetchError {
+	constructor(expectedOrigin, actualOrigin, context) {
+		super({
+			message: `Agent origin mismatch: expected ${expectedOrigin}, got ${actualOrigin}`,
+			code: FetchErrorCode.ORIGIN_MISMATCH,
+			phase: "policy",
+			context: {
+				...context,
+				details: {
+					...context?.details ?? {},
+					expectedOrigin,
+					actualOrigin
+				}
+			},
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var UnsupportedProtocolError = class extends FetchError {
+	constructor(protocol, context) {
+		super({
+			message: `Unsupported protocol: ${protocol}`,
+			code: FetchErrorCode.UNSUPPORTED_PROTOCOL,
+			phase: "policy",
+			context,
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var UnsupportedMethodError = class extends FetchError {
+	constructor(method, context) {
+		super({
+			message: `Unsupported method: ${method}`,
+			code: FetchErrorCode.UNSUPPORTED_METHOD,
+			phase: "policy",
+			context,
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var UnsupportedAlpnProtocolError = class extends FetchError {
+	constructor(alpn, context, cause) {
+		super({
+			message: `Unsupported ALPN protocol negotiated: ${alpn}`,
+			code: FetchErrorCode.TLS_ALPN,
+			phase: "connect",
+			cause,
+			context: {
+				...context,
+				alpn
+			},
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var RequestWriteError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Failed to write HTTP request",
+			code: FetchErrorCode.REQUEST_WRITE,
+			phase: "request",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var ResponseHeaderError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Failed while reading response headers",
+			code: FetchErrorCode.RESPONSE_HEADERS,
+			phase: "response",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var ResponseBodyError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Failed while reading response body",
+			code: FetchErrorCode.RESPONSE_BODY,
+			phase: "body",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var ResponseDecodeError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Failed while decoding response body",
+			code: FetchErrorCode.RESPONSE_DECODE,
+			phase: "decode",
+			cause,
+			context,
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var HttpStatusError = class extends FetchError {
+	statusCode;
+	constructor(statusCode, context, cause, message) {
+		super({
+			message: message ?? `HTTP ${statusCode}`,
+			code: FetchErrorCode.HTTP_STATUS,
+			phase: "response",
+			cause,
+			context: {
+				...context,
+				status: statusCode
+			},
+			retryable: statusCode >= 500,
+			type: statusCode < 500 ? ErrorType.HTTP_CLIENT_ERROR : ErrorType.HTTP_SERVER_ERROR
+		});
+		this.statusCode = statusCode;
+	}
+};
+//#endregion
+exports.AgentBusyError = AgentBusyError;
+exports.AgentClosedError = AgentClosedError;
+exports.ConnectTimeoutError = ConnectTimeoutError;
+exports.ConnectionError = ConnectionError;
+exports.ErrorType = ErrorType;
+exports.FetchError = FetchError;
+exports.FetchErrorCode = FetchErrorCode;
+exports.HttpStatusError = HttpStatusError;
+exports.OriginMismatchError = OriginMismatchError;
+exports.RequestAbortedError = RequestAbortedError;
+exports.RequestWriteError = RequestWriteError;
+exports.ResponseBodyError = ResponseBodyError;
+exports.ResponseDecodeError = ResponseDecodeError;
+exports.ResponseHeaderError = ResponseHeaderError;
+exports.UnsupportedAlpnProtocolError = UnsupportedAlpnProtocolError;
+exports.UnsupportedMethodError = UnsupportedMethodError;
+exports.UnsupportedProtocolError = UnsupportedProtocolError;

package/errors.js

@@ -0,0 +1,259 @@
+//#region src/errors.ts
+var ErrorType = {
+	ABORTED: "ABORTED",
+	NETWORK: "NETWORK",
+	TIMEOUT: "TIMEOUT",
+	HTTP_CLIENT_ERROR: "HTTP_CLIENT_ERROR",
+	HTTP_SERVER_ERROR: "HTTP_SERVER_ERROR"
+};
+var FetchErrorCode = {
+	ABORTED: "ERR_FETCH_ABORTED",
+	TIMEOUT: "ERR_FETCH_TIMEOUT",
+	CONNECTION: "ERR_FETCH_CONNECTION",
+	AGENT_CLOSED: "ERR_FETCH_AGENT_CLOSED",
+	AGENT_BUSY: "ERR_FETCH_AGENT_BUSY",
+	ORIGIN_MISMATCH: "ERR_FETCH_ORIGIN_MISMATCH",
+	UNSUPPORTED_PROTOCOL: "ERR_FETCH_UNSUPPORTED_PROTOCOL",
+	UNSUPPORTED_METHOD: "ERR_FETCH_UNSUPPORTED_METHOD",
+	TLS_ALPN: "ERR_FETCH_TLS_ALPN",
+	REQUEST_WRITE: "ERR_FETCH_REQUEST_WRITE",
+	RESPONSE_HEADERS: "ERR_FETCH_RESPONSE_HEADERS",
+	RESPONSE_BODY: "ERR_FETCH_RESPONSE_BODY",
+	RESPONSE_DECODE: "ERR_FETCH_RESPONSE_DECODE",
+	HTTP_STATUS: "ERR_FETCH_HTTP_STATUS"
+};
+var FetchError = class extends Error {
+	code;
+	phase;
+	context;
+	retryable;
+	type;
+	cause;
+	constructor(options) {
+		super(options.message, { cause: options.cause });
+		this.code = options.code;
+		this.phase = options.phase;
+		this.context = options.context;
+		this.retryable = options.retryable ?? false;
+		this.type = options.type;
+		this.cause = options.cause;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	get name() {
+		return this.constructor.name;
+	}
+	get [Symbol.toStringTag]() {
+		return this.name;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			phase: this.phase,
+			retryable: this.retryable,
+			type: this.type,
+			context: this.context,
+			cause: this.cause instanceof Error ? {
+				name: this.cause.name,
+				message: this.cause.message
+			} : this.cause
+		};
+	}
+};
+var RequestAbortedError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "The request was aborted",
+			code: FetchErrorCode.ABORTED,
+			phase: "request",
+			cause,
+			context,
+			retryable: false,
+			type: ErrorType.ABORTED
+		});
+	}
+};
+var ConnectTimeoutError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Connection timed out",
+			code: FetchErrorCode.TIMEOUT,
+			phase: "connect",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.TIMEOUT
+		});
+	}
+};
+var ConnectionError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Network connection failed",
+			code: FetchErrorCode.CONNECTION,
+			phase: "connect",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var AgentClosedError = class extends FetchError {
+	constructor(context, cause) {
+		super({
+			message: "Agent is closed",
+			code: FetchErrorCode.AGENT_CLOSED,
+			phase: "agent",
+			cause,
+			context,
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var AgentBusyError = class extends FetchError {
+	constructor(context, cause) {
+		super({
+			message: "Agent is busy",
+			code: FetchErrorCode.AGENT_BUSY,
+			phase: "agent",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var OriginMismatchError = class extends FetchError {
+	constructor(expectedOrigin, actualOrigin, context) {
+		super({
+			message: `Agent origin mismatch: expected ${expectedOrigin}, got ${actualOrigin}`,
+			code: FetchErrorCode.ORIGIN_MISMATCH,
+			phase: "policy",
+			context: {
+				...context,
+				details: {
+					...context?.details ?? {},
+					expectedOrigin,
+					actualOrigin
+				}
+			},
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var UnsupportedProtocolError = class extends FetchError {
+	constructor(protocol, context) {
+		super({
+			message: `Unsupported protocol: ${protocol}`,
+			code: FetchErrorCode.UNSUPPORTED_PROTOCOL,
+			phase: "policy",
+			context,
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var UnsupportedMethodError = class extends FetchError {
+	constructor(method, context) {
+		super({
+			message: `Unsupported method: ${method}`,
+			code: FetchErrorCode.UNSUPPORTED_METHOD,
+			phase: "policy",
+			context,
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var UnsupportedAlpnProtocolError = class extends FetchError {
+	constructor(alpn, context, cause) {
+		super({
+			message: `Unsupported ALPN protocol negotiated: ${alpn}`,
+			code: FetchErrorCode.TLS_ALPN,
+			phase: "connect",
+			cause,
+			context: {
+				...context,
+				alpn
+			},
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var RequestWriteError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Failed to write HTTP request",
+			code: FetchErrorCode.REQUEST_WRITE,
+			phase: "request",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var ResponseHeaderError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Failed while reading response headers",
+			code: FetchErrorCode.RESPONSE_HEADERS,
+			phase: "response",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var ResponseBodyError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Failed while reading response body",
+			code: FetchErrorCode.RESPONSE_BODY,
+			phase: "body",
+			cause,
+			context,
+			retryable: true,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var ResponseDecodeError = class extends FetchError {
+	constructor(cause, context, message) {
+		super({
+			message: message ?? "Failed while decoding response body",
+			code: FetchErrorCode.RESPONSE_DECODE,
+			phase: "decode",
+			cause,
+			context,
+			retryable: false,
+			type: ErrorType.NETWORK
+		});
+	}
+};
+var HttpStatusError = class extends FetchError {
+	statusCode;
+	constructor(statusCode, context, cause, message) {
+		super({
+			message: message ?? `HTTP ${statusCode}`,
+			code: FetchErrorCode.HTTP_STATUS,
+			phase: "response",
+			cause,
+			context: {
+				...context,
+				status: statusCode
+			},
+			retryable: statusCode >= 500,
+			type: statusCode < 500 ? ErrorType.HTTP_CLIENT_ERROR : ErrorType.HTTP_SERVER_ERROR
+		});
+		this.statusCode = statusCode;
+	}
+};
+//#endregion
+export { AgentBusyError, AgentClosedError, ConnectTimeoutError, ConnectionError, ErrorType, FetchError, FetchErrorCode, HttpStatusError, OriginMismatchError, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError };