create-request 1.6.0 → 2.0.0-next.0

package/dist/index.js

@@ -0,0 +1,717 @@
+//#region src/error.ts
+var RequestError = class extends Error {
+	name = "RequestError";
+	constructor(message, options) {
+		super(message, options);
+		Object.assign(this, options);
+	}
+	get data() {
+		if (this._data === void 0 && this.body) try {
+			this._data = JSON.parse(this.body);
+		} catch {}
+		return this._data;
+	}
+	get isTimeout() {
+		return this.code === "TIMEOUT";
+	}
+	get isAborted() {
+		return this.code === "ABORTED";
+	}
+};
+const isRequestError = (error) => error instanceof RequestError;
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+
+//#endregion
+//#region src/schema.ts
+const isSchema = (value) => !!value && (typeof value === "object" || typeof value === "function") && "~standard" in value;
+
+//#endregion
+//#region src/utils.ts
+const anySignal = (signals) => {
+	const list = signals.filter((signal) => !!signal);
+	if (list.length < 2) return list[0];
+	if (AbortSignal.any) return AbortSignal.any(list);
+	const controller = new AbortController();
+	for (const signal of list) {
+		if (signal.aborted) {
+			controller.abort(signal.reason);
+			break;
+		}
+		signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+	}
+	return controller.signal;
+};
+const abortError = (signal, deadline) => {
+	if (deadline?.controller.signal.aborted) return ["TIMEOUT", `Request timed out after ${deadline.ms}ms`];
+	if (!signal?.aborted) return void 0;
+	return signal.reason?.name === "TimeoutError" ? ["TIMEOUT", "Request timed out"] : ["ABORTED", "Request aborted"];
+};
+const MAX_DELAY = 2 ** 31 - 1;
+const sleep = (ms, signal) => new Promise((resolve) => {
+	if (signal?.aborted) return resolve();
+	const done = () => {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", done);
+		resolve();
+	};
+	const timer = setTimeout(done, Math.min(ms, MAX_DELAY));
+	signal?.addEventListener("abort", done);
+});
+const release = (body) => void body?.cancel().catch(() => void 0);
+const readCapped = async (body, max) => {
+	const decoder = new TextDecoder();
+	let text = "";
+	let size = 0;
+	try {
+		for (const reader = body?.getReader(); reader;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if ((size += value.length) > max) return void reader.cancel().catch(() => void 0);
+			text += decoder.decode(value, { stream: true });
+		}
+		return text + decoder.decode();
+	} catch {
+		return;
+	}
+};
+const validUrl = (url) => {
+	try {
+		return !!url.trim() && !!new URL(url, "http://_");
+	} catch {
+		return false;
+	}
+};
+const sameOrigin = (url) => {
+	if (typeof location === "undefined") return true;
+	try {
+		return new URL(url, typeof document !== "undefined" && document.baseURI || location.href).origin === location.origin;
+	} catch {
+		return false;
+	}
+};
+const readCookie = (name) => {
+	if (typeof document === "undefined") return void 0;
+	for (const part of document.cookie.split(";")) {
+		const at = part.indexOf("=");
+		if (at > 0 && part.slice(0, at).trim() === name) {
+			const value = part.slice(at + 1).trim();
+			try {
+				return decodeURIComponent(value);
+			} catch {
+				return value;
+			}
+		}
+	}
+};
+const retryAfter = (response) => {
+	const header = response?.headers.get("retry-after");
+	if (!header) return void 0;
+	const ms = /^\d+(\.\d+)?$/.test(header) ? +header * 1e3 : Date.parse(header) - Date.now();
+	return ms >= 0 ? ms : ms < 0 ? 0 : void 0;
+};
+
+//#endregion
+//#region src/response.ts
+var ResponseWrapper = class {
+	raw;
+	url;
+	method;
+	constructor(raw, url = "", method = "GET") {
+		this.raw = raw;
+		this.url = url;
+		this.method = method;
+	}
+	get status() {
+		return this.raw.status;
+	}
+	get statusText() {
+		return this.raw.statusText;
+	}
+	get ok() {
+		return this.raw.ok;
+	}
+	get headers() {
+		return this.raw.headers;
+	}
+	_err(message, code, extra) {
+		return new RequestError(message, {
+			code,
+			url: this.url,
+			method: this.method,
+			status: this.raw.status,
+			response: this.raw,
+			...extra
+		});
+	}
+	_unreadable(fallback, extra) {
+		clearTimeout(this._timeout?.timer);
+		const aborted = abortError(this._signal, this._timeout);
+		return this._err(aborted?.[1] ?? fallback, aborted?.[0] ?? "PARSE", extra);
+	}
+	_buffer() {
+		if (!this._bin) {
+			if (this.raw.bodyUsed) return Promise.reject(this._unreadable("Response body already consumed"));
+			this._bin = this.raw.arrayBuffer().then((buffer) => {
+				clearTimeout(this._timeout?.timer);
+				return buffer;
+			}, (e) => {
+				throw this._unreadable(`Failed to read response body: ${messageOf(e)}`, { cause: e });
+			});
+		}
+		return this._bin;
+	}
+	async _validate(schema, data) {
+		let result;
+		try {
+			result = await schema["~standard"].validate(data);
+		} catch (e) {
+			throw this._err(`Schema validation threw: ${messageOf(e)}`, "VALIDATION", { cause: e });
+		}
+		if (result.issues) {
+			const [issue] = result.issues;
+			const path = issue?.path?.map((p) => String(typeof p === "object" ? p.key : p)).join(".");
+			throw this._err(`Response validation failed: ${issue?.message}${path ? ` at ${path}` : ""}`, "VALIDATION", {
+				body: await this.getText(),
+				issues: result.issues
+			});
+		}
+		return result.value;
+	}
+	getArrayBuffer() {
+		return this._buffer();
+	}
+	async getBlob() {
+		return new Blob([await this._buffer()], { type: this.raw.headers.get("content-type") ?? "" });
+	}
+	getText() {
+		return this._text ??= this._buffer().then((buffer) => new TextDecoder().decode(buffer));
+	}
+	async getFormData() {
+		const buffer = await this._buffer();
+		try {
+			return await new Response(buffer, { headers: this.raw.headers }).formData();
+		} catch (e) {
+			throw this._err(`Failed to parse form data: ${messageOf(e)}`, "PARSE", { cause: e });
+		}
+	}
+	getBody() {
+		if (this.raw.bodyUsed) throw this._unreadable("Response body already consumed");
+		clearTimeout(this._timeout?.timer);
+		return this.raw.body;
+	}
+	getJson(schema) {
+		this._json ??= this.getText().then((text) => {
+			if (!text.trim()) return null;
+			let data;
+			try {
+				data = JSON.parse(text);
+			} catch (e) {
+				throw this._err(`Invalid JSON response: ${messageOf(e)}`, "PARSE", {
+					body: text,
+					cause: e
+				});
+			}
+			const errors = this._gqlThrow ? data?.errors : void 0;
+			if (Array.isArray(errors) && errors.length) {
+				const messages = errors.map((e) => {
+					const message = e?.message ?? e;
+					return typeof message === "string" ? message : JSON.stringify(message);
+				});
+				throw this._err(`GraphQL error: ${messages.join("; ")}`, "GRAPHQL", { body: text });
+			}
+			return data;
+		});
+		return schema ? this._json.then((data) => this._validate(schema, data)) : this._json;
+	}
+	async getData(schemaOrSelector, selector) {
+		const schema = isSchema(schemaOrSelector) ? schemaOrSelector : void 0;
+		const select = schema ? selector : schemaOrSelector;
+		const data = await this.getJson(schema);
+		if (!select) return data;
+		try {
+			return select(data);
+		} catch (e) {
+			throw this._err(`Selector failed: ${messageOf(e)}`, "PARSE", { cause: e });
+		}
+	}
+};
+
+//#endregion
+//#region src/request.ts
+const RETRY_STATUSES = [
+	408,
+	425,
+	429,
+	500,
+	502,
+	503,
+	504
+];
+var HttpRequest = class HttpRequest {
+	method;
+	_o = {
+		init: {},
+		headers: {},
+		query: new URLSearchParams(),
+		signals: [],
+		req: [],
+		res: [],
+		err: []
+	};
+	_url;
+	constructor(method, url) {
+		this.method = method;
+		this._url = url;
+	}
+	get url() {
+		const query = this._o.query.toString();
+		if (!query) return this._url;
+		const hashAt = this._url.indexOf("#");
+		const base = hashAt < 0 ? this._url : this._url.slice(0, hashAt);
+		return `${base}${base.includes("?") ? "&" : "?"}${query}${hashAt < 0 ? "" : this._url.slice(hashAt)}`;
+	}
+	_fail(message, code, extra) {
+		return new RequestError(message, {
+			url: this.url,
+			method: this.method,
+			...extra,
+			code
+		});
+	}
+	_set(key, value) {
+		this._o.init[key] = value;
+		return this;
+	}
+	withHeaders(headers) {
+		for (const [name, value] of Object.entries(headers)) {
+			const key = name.toLowerCase();
+			if (value == null) delete this._o.headers[key];
+			else this._o.headers[key] = String(value);
+		}
+		return this;
+	}
+	withHeader(name, value) {
+		return this.withHeaders({ [name]: value });
+	}
+	withContentType(contentType) {
+		return this.withHeader("content-type", contentType);
+	}
+	withAuthorization(value) {
+		return this.withHeader("authorization", value);
+	}
+	withBearerToken(token) {
+		return this.withAuthorization(`Bearer ${token}`);
+	}
+	withBasicAuth(username, password) {
+		return this.withAuthorization(`Basic ${btoa(String.fromCharCode(...new TextEncoder().encode(`${username}:${password}`)))}`);
+	}
+	withCookies(cookies) {
+		for (const [name, value] of Object.entries(cookies)) {
+			const previous = this._o.headers["cookie"];
+			this.withHeader("cookie", `${previous ? `${previous}; ` : ""}${name}=${value}`);
+		}
+		return this;
+	}
+	withCookie(name, value) {
+		return this.withCookies({ [name]: value });
+	}
+	withCsrf(options = {}) {
+		this._o.csrf = options;
+		return this;
+	}
+	withCsrfToken(token, header = "X-CSRF-Token") {
+		return this.withHeader(header, token);
+	}
+	withQueryParams(params) {
+		const entries = params instanceof URLSearchParams ? [...params] : Object.entries(params);
+		for (const [key] of entries) this._o.query.delete(key);
+		for (const [key, value] of entries) for (const item of Array.isArray(value) ? value : [value]) if (item != null) this._o.query.append(key, item instanceof Date ? item.toISOString() : String(item));
+		return this;
+	}
+	withQueryParam(key, value) {
+		return this.withQueryParams({ [key]: value });
+	}
+	withTimeout(ms) {
+		if (!(ms >= 0)) throw this._fail(`Invalid timeout: ${ms}`, "VALIDATION");
+		this._o.timeout = ms > 0 && ms <= MAX_DELAY ? ms : void 0;
+		return this;
+	}
+	withRetries(retries) {
+		const config = typeof retries === "number" ? { attempts: retries } : retries;
+		if (!(Number.isInteger(config.attempts) && config.attempts >= 0)) throw this._fail(`Invalid retry attempts: ${config.attempts}`, "VALIDATION");
+		this._o.retry = {
+			...this._o.retry,
+			...config
+		};
+		return this;
+	}
+	onRetry(callback) {
+		this._o.retry = {
+			attempts: 0,
+			...this._o.retry,
+			onRetry: callback
+		};
+		return this;
+	}
+	withSignal(signal) {
+		this._o.signals.push(signal);
+		return this;
+	}
+	withAbortController(controller) {
+		return this.withSignal(controller.signal);
+	}
+	withFetch(fetchFn) {
+		this._o.fetch = fetchFn;
+		return this;
+	}
+	withCredentials(credentials) {
+		return this._set("credentials", credentials);
+	}
+	withMode(mode) {
+		return this._set("mode", mode);
+	}
+	withRedirect(redirect) {
+		return this._set("redirect", redirect);
+	}
+	withReferrer(referrer) {
+		return this._set("referrer", referrer);
+	}
+	withReferrerPolicy(policy) {
+		return this._set("referrerPolicy", policy);
+	}
+	withPriority(priority) {
+		return this._set("priority", priority);
+	}
+	withKeepAlive(keepalive = true) {
+		return this._set("keepalive", keepalive);
+	}
+	withIntegrity(integrity) {
+		return this._set("integrity", integrity);
+	}
+	withCache(cache) {
+		return this._set("cache", cache);
+	}
+	withRequestInterceptor(interceptor) {
+		this._o.req.push(interceptor);
+		return this;
+	}
+	withResponseInterceptor(interceptor) {
+		this._o.res.push(interceptor);
+		return this;
+	}
+	withErrorInterceptor(interceptor) {
+		this._o.err.push(interceptor);
+		return this;
+	}
+	withBody(body) {
+		const o = this._o;
+		const tag = Object.prototype.toString.call(body).slice(8, -1);
+		const raw = ArrayBuffer.isView(body) || /^(String|Blob|File|FormData|URLSearchParams|ArrayBuffer|ReadableStream)$/.test(tag);
+		o.stream = tag === "ReadableStream";
+		if (raw) o.body = body;
+		else try {
+			o.body = JSON.stringify(body);
+		} catch (e) {
+			throw this._fail(`Body is not JSON-serializable: ${messageOf(e)}`, "VALIDATION", { cause: e });
+		}
+		if (tag === "FormData") delete o.headers["content-type"];
+		else if (!("content-type" in o.headers) && (!raw || tag === "String")) this.withContentType(raw ? "text/plain" : "application/json");
+		return this;
+	}
+	withGraphQL(query, variables, options) {
+		this._o.gqlThrow = options?.throwOnError;
+		return this.withBody({
+			query,
+			variables
+		});
+	}
+	clone() {
+		const o = this._o;
+		const copy = new HttpRequest(this.method, this._url);
+		copy._o = {
+			...o,
+			init: { ...o.init },
+			headers: { ...o.headers },
+			query: new URLSearchParams(o.query),
+			signals: [...o.signals],
+			req: [...o.req],
+			res: [...o.res],
+			err: [...o.err]
+		};
+		return copy;
+	}
+	async getResponse() {
+		const o = this._o;
+		const retry = o.retry;
+		let error;
+		for (let attempt = 0;; attempt++) try {
+			return await this._attempt();
+		} catch (e) {
+			error = e instanceof RequestError ? e : this._fail(`Unexpected error: ${messageOf(e)}`, "NETWORK", { cause: e });
+			const context = {
+				attempt: attempt + 1,
+				error
+			};
+			if (attempt >= (retry?.attempts ?? 0)) break;
+			try {
+				if (!await this._retriable(context)) break;
+				const maxDelay = retry.maxDelay ?? 3e4;
+				const serverDelay = retry.delay === void 0 ? retryAfter(error.response) : void 0;
+				if (serverDelay > maxDelay) break;
+				const delay = serverDelay ?? (typeof retry.delay === "function" ? retry.delay(context) : retry.delay ?? Math.min(300 * 2 ** attempt + Math.random() * 100, maxDelay));
+				await retry.onRetry?.({
+					...context,
+					delay
+				});
+				release(error.response?.body);
+				await sleep(delay, anySignal(o.signals));
+			} catch (e) {
+				error = this._fail(`Retry callback failed: ${messageOf(e)}`, "INTERCEPTOR", {
+					...error,
+					cause: e
+				});
+				break;
+			}
+		}
+		for (const interceptor of o.err) try {
+			const result = await interceptor(error, this);
+			if (result instanceof ResponseWrapper) return result;
+			if (result) error = result;
+		} catch (e) {
+			error = e instanceof RequestError ? e : this._fail(`Error interceptor failed: ${messageOf(e)}`, "INTERCEPTOR", {
+				...error,
+				cause: e
+			});
+		}
+		throw error;
+	}
+	async _retriable(context) {
+		const o = this._o;
+		const retry = o.retry;
+		const { code, status } = context.error;
+		if (code === "ABORTED" || o.stream || o.signals.some((signal) => signal.aborted)) return false;
+		if (retry.shouldRetry) return retry.shouldRetry(context);
+		if (retry.methods && !retry.methods.includes(this.method)) return false;
+		return code === "NETWORK" || code === "TIMEOUT" || code === "HTTP" && (retry.statuses ?? RETRY_STATUSES).includes(status);
+	}
+	async _attempt() {
+		const o = this._o;
+		const method = this.method;
+		let config = {
+			...o.init,
+			url: this.url,
+			method,
+			headers: { ...o.headers },
+			body: o.body,
+			signal: anySignal(o.signals)
+		};
+		if (o.stream) config.duplex = "half";
+		const fail = (message, code, extra) => new RequestError(message, {
+			code,
+			url: config.url,
+			method,
+			...extra
+		});
+		const early = abortError(config.signal, void 0);
+		if (early) throw fail(early[1], early[0], { cause: config.signal.reason });
+		let response;
+		for (const interceptor of o.req) {
+			let result;
+			try {
+				result = await interceptor(config);
+			} catch (e) {
+				throw fail(`Request interceptor failed: ${messageOf(e)}`, "INTERCEPTOR", { cause: e });
+			}
+			if (result instanceof Response) {
+				response = result;
+				break;
+			}
+			if (result) config = result;
+		}
+		let deadline;
+		let signal = config.signal;
+		if (!response) {
+			if (!validUrl(config.url)) throw fail(`Invalid URL: "${config.url}"`, "VALIDATION");
+			try {
+				this._csrf(config);
+			} catch (e) {
+				throw fail(`CSRF token callback failed: ${messageOf(e)}`, "INTERCEPTOR", { cause: e });
+			}
+			try {
+				new Headers(config.headers);
+			} catch (e) {
+				throw fail(`Invalid header: ${messageOf(e)}`, "VALIDATION", { cause: e });
+			}
+			if (o.timeout) {
+				const controller = new AbortController();
+				deadline = {
+					ms: o.timeout,
+					controller,
+					timer: setTimeout(() => controller.abort(), o.timeout)
+				};
+			}
+			const { url, ...init } = config;
+			init.signal = signal = anySignal([config.signal, deadline?.controller.signal]);
+			try {
+				response = await (o.fetch ?? fetch)(url, init);
+			} catch (e) {
+				clearTimeout(deadline?.timer);
+				const aborted = abortError(signal, deadline);
+				if (aborted) throw fail(aborted[1], aborted[0], { cause: e });
+				const cause = e?.cause;
+				const detail = cause && (messageOf(cause) || cause.code);
+				throw fail(`Network error: ${messageOf(e)}${detail ? ` (${detail})` : ""}`, "NETWORK", { cause: e });
+			}
+		}
+		const manualRedirect = config.redirect === "manual" && response.status >= 300 && response.status < 400;
+		if (!response.ok && !manualRedirect && response.type !== "opaque" && response.type !== "opaqueredirect") {
+			const body = response.bodyUsed || +response.headers.get("content-length") > 1e6 ? void 0 : await readCapped(response.body, 1e6);
+			clearTimeout(deadline?.timer);
+			throw fail(`HTTP ${response.status} ${response.statusText}`.trim(), "HTTP", {
+				status: response.status,
+				response,
+				body
+			});
+		}
+		if (!response.body) clearTimeout(deadline?.timer);
+		const arm = (wrapper) => {
+			wrapper._timeout ??= deadline;
+			wrapper._signal ??= signal;
+			wrapper._gqlThrow ??= o.gqlThrow;
+			return wrapper;
+		};
+		let wrapped = arm(new ResponseWrapper(response, config.url, method));
+		for (const interceptor of o.res) try {
+			const result = await interceptor(wrapped, this);
+			if (result && result.raw !== response) {
+				clearTimeout(deadline?.timer);
+				release(response.body);
+			}
+			wrapped = arm(result ?? wrapped);
+		} catch (e) {
+			clearTimeout(deadline?.timer);
+			throw fail(`Response interceptor failed: ${messageOf(e)}`, "INTERCEPTOR", {
+				status: wrapped.status,
+				response: wrapped.raw,
+				cause: e
+			});
+		}
+		return wrapped;
+	}
+	_csrf(config) {
+		const csrf = this._o.csrf;
+		if (!csrf || !(csrf.crossOrigin || sameOrigin(config.url))) return;
+		const fromToken = csrf.token !== void 0;
+		const token = fromToken ? typeof csrf.token === "function" ? csrf.token() : csrf.token : readCookie(csrf.cookie ?? "XSRF-TOKEN");
+		const header = (csrf.header ?? (fromToken ? "X-CSRF-Token" : "X-XSRF-TOKEN")).toLowerCase();
+		if (token && !(header in config.headers)) config.headers[header] = token;
+	}
+	getJson(schema) {
+		return this.getResponse().then((response) => response.getJson(schema));
+	}
+	getText() {
+		return this.getResponse().then((response) => response.getText());
+	}
+	getBlob() {
+		return this.getResponse().then((response) => response.getBlob());
+	}
+	getArrayBuffer() {
+		return this.getResponse().then((response) => response.getArrayBuffer());
+	}
+	getFormData() {
+		return this.getResponse().then((response) => response.getFormData());
+	}
+	getBody() {
+		return this.getResponse().then((response) => response.getBody());
+	}
+	getData(schemaOrSelector, selector) {
+		return this.getResponse().then((response) => response.getData(schemaOrSelector, selector));
+	}
+	async getResult(schema) {
+		try {
+			return {
+				data: await this.getJson(schema),
+				error: null
+			};
+		} catch (error) {
+			return {
+				data: null,
+				error
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/api.ts
+const ABSOLUTE = /^([a-z][a-z0-9+.-]*:)?\/\//i;
+var Api = class Api {
+	_base;
+	_defaults;
+	constructor(_base = "", _defaults = []) {
+		this._base = _base;
+		this._defaults = _defaults;
+	}
+	_with(fn) {
+		fn(new HttpRequest("GET", ""));
+		return new Api(this._base, [...this._defaults, fn]);
+	}
+	withBaseURL(baseURL) {
+		return new Api(baseURL, this._defaults);
+	}
+	_make(method, path = "") {
+		const base = this._base;
+		const url = !base ? path : !path ? base : ABSOLUTE.test(path) ? path : `${base.replace(/\/+$/, "")}/${path.replace(/^\.?\/+/, "")}`;
+		const request = new HttpRequest(method, url);
+		for (const apply of this._defaults) apply(request);
+		return request;
+	}
+};
+const METHODS = [
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
+let installed = false;
+function createApi() {
+	if (!installed) {
+		installed = true;
+		const proto = Api.prototype;
+		for (const method of METHODS) proto[method.toLowerCase()] = function(path) {
+			return this._make(method, path);
+		};
+		proto["del"] = proto["delete"];
+		for (const key of Object.getOwnPropertyNames(HttpRequest.prototype)) if (/^(with|onRetry)/.test(key) && !/^with(Body|GraphQL|Signal|AbortController)$/.test(key)) proto[key] = function(...args) {
+			return this._with((request) => void request[key](...args));
+		};
+	}
+	return new Api();
+}
+
+//#endregion
+//#region src/index.ts
+const createGet = (url) => new HttpRequest("GET", url);
+const createHead = (url) => new HttpRequest("HEAD", url);
+const createOptions = (url) => new HttpRequest("OPTIONS", url);
+const createPost = (url) => new HttpRequest("POST", url);
+const createPut = (url) => new HttpRequest("PUT", url);
+const createPatch = (url) => new HttpRequest("PATCH", url);
+const createDelete = (url) => new HttpRequest("DELETE", url);
+const create = {
+	get: createGet,
+	head: createHead,
+	options: createOptions,
+	post: createPost,
+	put: createPut,
+	patch: createPatch,
+	delete: createDelete,
+	del: createDelete,
+	api: createApi
+};
+
+//#endregion
+export { HttpRequest, RequestError, ResponseWrapper, createApi, createDelete, createGet, createHead, createOptions, createPatch, createPost, createPut, create as default, isRequestError };