@npy/fetch 0.1.3 → 0.1.4

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.d.cts

@@ -0,0 +1,110 @@
+export declare const ErrorType: {
+    readonly ABORTED: "ABORTED";
+    readonly NETWORK: "NETWORK";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly HTTP_CLIENT_ERROR: "HTTP_CLIENT_ERROR";
+    readonly HTTP_SERVER_ERROR: "HTTP_SERVER_ERROR";
+};
+export type ErrorType = (typeof ErrorType)[keyof typeof ErrorType];
+export declare const FetchErrorCode: {
+    readonly ABORTED: "ERR_FETCH_ABORTED";
+    readonly TIMEOUT: "ERR_FETCH_TIMEOUT";
+    readonly CONNECTION: "ERR_FETCH_CONNECTION";
+    readonly AGENT_CLOSED: "ERR_FETCH_AGENT_CLOSED";
+    readonly AGENT_BUSY: "ERR_FETCH_AGENT_BUSY";
+    readonly ORIGIN_MISMATCH: "ERR_FETCH_ORIGIN_MISMATCH";
+    readonly UNSUPPORTED_PROTOCOL: "ERR_FETCH_UNSUPPORTED_PROTOCOL";
+    readonly UNSUPPORTED_METHOD: "ERR_FETCH_UNSUPPORTED_METHOD";
+    readonly TLS_ALPN: "ERR_FETCH_TLS_ALPN";
+    readonly REQUEST_WRITE: "ERR_FETCH_REQUEST_WRITE";
+    readonly RESPONSE_HEADERS: "ERR_FETCH_RESPONSE_HEADERS";
+    readonly RESPONSE_BODY: "ERR_FETCH_RESPONSE_BODY";
+    readonly RESPONSE_DECODE: "ERR_FETCH_RESPONSE_DECODE";
+    readonly HTTP_STATUS: "ERR_FETCH_HTTP_STATUS";
+};
+export type FetchErrorCode = (typeof FetchErrorCode)[keyof typeof FetchErrorCode];
+export type FetchErrorPhase = "agent" | "connect" | "request" | "response" | "body" | "decode" | "policy";
+export interface FetchErrorContext {
+    url?: string;
+    method?: string;
+    origin?: string;
+    scheme?: string;
+    host?: string;
+    port?: number;
+    status?: number;
+    alpn?: string | null;
+    details?: Record<string, unknown>;
+}
+export interface FetchErrorOptions {
+    message: string;
+    code: FetchErrorCode;
+    phase: FetchErrorPhase;
+    cause?: unknown;
+    context?: FetchErrorContext;
+    retryable?: boolean;
+    type?: ErrorType;
+}
+export declare class FetchError extends Error {
+    readonly code: FetchErrorCode;
+    readonly phase: FetchErrorPhase;
+    readonly context?: FetchErrorContext;
+    readonly retryable: boolean;
+    readonly type?: ErrorType;
+    readonly cause: unknown;
+    constructor(options: FetchErrorOptions);
+    get name(): string;
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        name: string;
+        message: string;
+        code: FetchErrorCode;
+        phase: FetchErrorPhase;
+        retryable: boolean;
+        type: ErrorType | undefined;
+        context: FetchErrorContext | undefined;
+        cause: unknown;
+    };
+}
+export declare class RequestAbortedError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ConnectTimeoutError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ConnectionError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class AgentClosedError extends FetchError {
+    constructor(context?: FetchErrorContext, cause?: unknown);
+}
+export declare class AgentBusyError extends FetchError {
+    constructor(context?: FetchErrorContext, cause?: unknown);
+}
+export declare class OriginMismatchError extends FetchError {
+    constructor(expectedOrigin: string, actualOrigin: string, context?: FetchErrorContext);
+}
+export declare class UnsupportedProtocolError extends FetchError {
+    constructor(protocol: string, context?: FetchErrorContext);
+}
+export declare class UnsupportedMethodError extends FetchError {
+    constructor(method: string, context?: FetchErrorContext);
+}
+export declare class UnsupportedAlpnProtocolError extends FetchError {
+    constructor(alpn: string, context?: FetchErrorContext, cause?: unknown);
+}
+export declare class RequestWriteError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ResponseHeaderError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ResponseBodyError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ResponseDecodeError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class HttpStatusError extends FetchError {
+    readonly statusCode: number;
+    constructor(statusCode: number, context?: FetchErrorContext, cause?: unknown, message?: string);
+}

package/errors.d.ts

@@ -0,0 +1,110 @@
+export declare const ErrorType: {
+    readonly ABORTED: "ABORTED";
+    readonly NETWORK: "NETWORK";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly HTTP_CLIENT_ERROR: "HTTP_CLIENT_ERROR";
+    readonly HTTP_SERVER_ERROR: "HTTP_SERVER_ERROR";
+};
+export type ErrorType = (typeof ErrorType)[keyof typeof ErrorType];
+export declare const FetchErrorCode: {
+    readonly ABORTED: "ERR_FETCH_ABORTED";
+    readonly TIMEOUT: "ERR_FETCH_TIMEOUT";
+    readonly CONNECTION: "ERR_FETCH_CONNECTION";
+    readonly AGENT_CLOSED: "ERR_FETCH_AGENT_CLOSED";
+    readonly AGENT_BUSY: "ERR_FETCH_AGENT_BUSY";
+    readonly ORIGIN_MISMATCH: "ERR_FETCH_ORIGIN_MISMATCH";
+    readonly UNSUPPORTED_PROTOCOL: "ERR_FETCH_UNSUPPORTED_PROTOCOL";
+    readonly UNSUPPORTED_METHOD: "ERR_FETCH_UNSUPPORTED_METHOD";
+    readonly TLS_ALPN: "ERR_FETCH_TLS_ALPN";
+    readonly REQUEST_WRITE: "ERR_FETCH_REQUEST_WRITE";
+    readonly RESPONSE_HEADERS: "ERR_FETCH_RESPONSE_HEADERS";
+    readonly RESPONSE_BODY: "ERR_FETCH_RESPONSE_BODY";
+    readonly RESPONSE_DECODE: "ERR_FETCH_RESPONSE_DECODE";
+    readonly HTTP_STATUS: "ERR_FETCH_HTTP_STATUS";
+};
+export type FetchErrorCode = (typeof FetchErrorCode)[keyof typeof FetchErrorCode];
+export type FetchErrorPhase = "agent" | "connect" | "request" | "response" | "body" | "decode" | "policy";
+export interface FetchErrorContext {
+    url?: string;
+    method?: string;
+    origin?: string;
+    scheme?: string;
+    host?: string;
+    port?: number;
+    status?: number;
+    alpn?: string | null;
+    details?: Record<string, unknown>;
+}
+export interface FetchErrorOptions {
+    message: string;
+    code: FetchErrorCode;
+    phase: FetchErrorPhase;
+    cause?: unknown;
+    context?: FetchErrorContext;
+    retryable?: boolean;
+    type?: ErrorType;
+}
+export declare class FetchError extends Error {
+    readonly code: FetchErrorCode;
+    readonly phase: FetchErrorPhase;
+    readonly context?: FetchErrorContext;
+    readonly retryable: boolean;
+    readonly type?: ErrorType;
+    readonly cause: unknown;
+    constructor(options: FetchErrorOptions);
+    get name(): string;
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        name: string;
+        message: string;
+        code: FetchErrorCode;
+        phase: FetchErrorPhase;
+        retryable: boolean;
+        type: ErrorType | undefined;
+        context: FetchErrorContext | undefined;
+        cause: unknown;
+    };
+}
+export declare class RequestAbortedError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ConnectTimeoutError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ConnectionError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class AgentClosedError extends FetchError {
+    constructor(context?: FetchErrorContext, cause?: unknown);
+}
+export declare class AgentBusyError extends FetchError {
+    constructor(context?: FetchErrorContext, cause?: unknown);
+}
+export declare class OriginMismatchError extends FetchError {
+    constructor(expectedOrigin: string, actualOrigin: string, context?: FetchErrorContext);
+}
+export declare class UnsupportedProtocolError extends FetchError {
+    constructor(protocol: string, context?: FetchErrorContext);
+}
+export declare class UnsupportedMethodError extends FetchError {
+    constructor(method: string, context?: FetchErrorContext);
+}
+export declare class UnsupportedAlpnProtocolError extends FetchError {
+    constructor(alpn: string, context?: FetchErrorContext, cause?: unknown);
+}
+export declare class RequestWriteError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ResponseHeaderError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ResponseBodyError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class ResponseDecodeError extends FetchError {
+    constructor(cause?: unknown, context?: FetchErrorContext, message?: string);
+}
+export declare class HttpStatusError extends FetchError {
+    readonly statusCode: number;
+    constructor(statusCode: number, context?: FetchErrorContext, cause?: unknown, message?: string);
+}