lampamazaza-new-internal-utils 0.24.3

package/dist/utils/request.js

@@ -0,0 +1,99 @@
+import { HttpRequestError, TimeoutError } from "../errors/request.js";
+import { isNetworkError } from "../errors/utils/isNetworkError.js";
+import { toError } from "../errors/utils/toError.js";
+import { mergeAbortSignals } from "./abortSignal.js";
+import { withTimeout } from "./promise/withTimeout.js";
+import { requestShouldRetry } from "./requestShouldRetry.js";
+import { retry } from "@lifeomic/attempt";
+
+//#region src/utils/request.ts
+async function request({ retryOptions = { maxAttempts: 1 }, logger, ...params }) {
+	const overallStartTime = performance.now();
+	let totalNetworkTime = 0;
+	let attemptCount = 0;
+	const response = await retry(async (ctx) => {
+		attemptCount = ctx.attemptNum + 1;
+		const attemptStartTime = performance.now();
+		logger?.debug("Sending HTTP request", {
+			url: params.url.toString(),
+			method: params.fetchOptions?.method || "GET",
+			body: JSON.stringify(params.body),
+			attempt: ctx.attemptNum
+		});
+		const response$1 = await request_(params);
+		const attemptDuration = performance.now() - attemptStartTime;
+		totalNetworkTime += attemptDuration;
+		logger?.debug("HTTP request attempt completed", {
+			attempt: ctx.attemptNum,
+			attemptDuration: Math.floor(attemptDuration),
+			statusCode: response$1.status,
+			success: response$1.ok,
+			responseSize: response$1.headers.get("content-length")
+		});
+		return response$1;
+	}, {
+		...retryOptions,
+		handleError: (err, context) => {
+			logger?.error("HTTP request attempt failed", {
+				attempt: context.attemptNum,
+				errorMessage: toError(err).message
+			});
+			if (!requestShouldRetry(err) || params.fetchOptions?.signal?.reason === err) context.abort();
+		}
+	});
+	const overallDuration = performance.now() - overallStartTime;
+	const retryOverhead = overallDuration - totalNetworkTime;
+	logger?.[attemptCount > 1 ? "info" : "debug"]("HTTP request completed", {
+		statusCode: response.status,
+		success: response.ok,
+		totalDuration: Math.floor(overallDuration),
+		networkTime: Math.floor(totalNetworkTime),
+		retryOverhead: Math.floor(retryOverhead),
+		attempts: attemptCount,
+		responseSize: response.headers.get("content-length")
+	});
+	return response;
+}
+async function request_({ url, body, timeout = 1e4, fetchOptions }) {
+	const { headers: customHeaders, method, signal: signal_ } = fetchOptions ?? {};
+	try {
+		const headers = new Headers(customHeaders);
+		headers.set("Content-Type", "application/json");
+		const response = await withTimeout(({ signal }) => {
+			return fetch(url, {
+				...fetchOptions,
+				method,
+				headers,
+				body: JSON.stringify(body),
+				signal: mergeAbortSignals([signal_, timeout > 0 ? signal : null].filter(Boolean))
+			});
+		}, {
+			errorInstance: new TimeoutError({
+				body,
+				url: url.toString()
+			}),
+			timeout,
+			signal: true
+		});
+		if (!response.ok) throw new HttpRequestError({
+			body,
+			details: response.statusText,
+			headers: response.headers,
+			status: response.status,
+			url: url.toString()
+		});
+		return response;
+	} catch (err) {
+		if (err instanceof HttpRequestError) throw err;
+		if (err instanceof TimeoutError) throw err;
+		if (isNetworkError(err)) throw new HttpRequestError({
+			body,
+			cause: err,
+			url: url.toString()
+		});
+		throw err;
+	}
+}
+
+//#endregion
+export { request };

package/dist/utils/requestShouldRetry.cjs

@@ -0,0 +1,20 @@
+const require_request = require('../errors/request.cjs');
+
+//#region src/utils/requestShouldRetry.ts
+function requestShouldRetry(error) {
+	if (error instanceof require_request.HttpRequestError && error.status != null) {
+		if (error.status === 403) return true;
+		if (error.status === 408) return true;
+		if (error.status === 413) return true;
+		if (error.status === 429) return true;
+		if (error.status === 500) return true;
+		if (error.status === 502) return true;
+		if (error.status === 503) return true;
+		if (error.status === 504) return true;
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+exports.requestShouldRetry = requestShouldRetry;

package/dist/utils/requestShouldRetry.js

@@ -0,0 +1,20 @@
+import { HttpRequestError } from "../errors/request.js";
+
+//#region src/utils/requestShouldRetry.ts
+function requestShouldRetry(error) {
+	if (error instanceof HttpRequestError && error.status != null) {
+		if (error.status === 403) return true;
+		if (error.status === 408) return true;
+		if (error.status === 413) return true;
+		if (error.status === 429) return true;
+		if (error.status === 500) return true;
+		if (error.status === 502) return true;
+		if (error.status === 503) return true;
+		if (error.status === 504) return true;
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+export { requestShouldRetry };

package/dist/utils/retry.cjs

@@ -0,0 +1,66 @@
+
+//#region src/utils/retry.ts
+const RETRY_CONFIGS = {
+	THIRTY_SECS_AGGRESSIVE: {
+		delay: 500,
+		minDelay: 500,
+		factor: 2,
+		maxAttempts: 6,
+		jitter: true
+	},
+	ONE_MIN_MODERATE: {
+		delay: 1e3,
+		minDelay: 1e3,
+		factor: 1.5,
+		maxAttempts: 8,
+		jitter: true
+	},
+	TWO_MINS_GRADUAL: {
+		delay: 500,
+		minDelay: 500,
+		factor: 1.5,
+		maxAttempts: 12,
+		jitter: true
+	},
+	FIVE_MINS_STEADY: {
+		delay: 2e3,
+		minDelay: 2e3,
+		factor: 1.4,
+		maxAttempts: 12,
+		jitter: true
+	},
+	THIRTY_MINS_PATIENT: {
+		delay: 5e3,
+		minDelay: 5e3,
+		factor: 1.3,
+		maxAttempts: 18,
+		jitter: true
+	},
+	TWO_HOURS_PERSISTENT: {
+		delay: 1e4,
+		minDelay: 1e4,
+		factor: 1.2,
+		maxAttempts: 27,
+		jitter: true
+	}
+};
+/**
+* Calculates how many attempts fit within a timeout budget.
+*
+* @returns number of attempts that fit within the timeout
+*/
+function calculateMaxAttempts(timeout, delay, factor) {
+	let totalDelay = 0;
+	let currentDelay = delay;
+	let attempts = 1;
+	while (totalDelay + currentDelay <= timeout) {
+		totalDelay += currentDelay;
+		attempts++;
+		currentDelay *= factor;
+	}
+	return Math.max(1, attempts);
+}
+
+//#endregion
+exports.RETRY_CONFIGS = RETRY_CONFIGS;
+exports.calculateMaxAttempts = calculateMaxAttempts;

package/dist/utils/retry.d.cts

@@ -0,0 +1,56 @@
+import { AttemptOptions } from "@lifeomic/attempt";
+
+//#region src/utils/retry.d.ts
+type RetryOptions = Partial<Pick<AttemptOptions<unknown>, "delay" | "initialDelay" | "minDelay" | "maxDelay" | "factor" | "maxAttempts" | "timeout" | "jitter" | "initialJitter">>;
+declare const RETRY_CONFIGS: {
+  THIRTY_SECS_AGGRESSIVE: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  ONE_MIN_MODERATE: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  TWO_MINS_GRADUAL: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  FIVE_MINS_STEADY: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  THIRTY_MINS_PATIENT: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  TWO_HOURS_PERSISTENT: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+};
+/**
+ * Calculates how many attempts fit within a timeout budget.
+ *
+ * @returns number of attempts that fit within the timeout
+ */
+declare function calculateMaxAttempts(timeout: number, delay: number, factor: number): number;
+//#endregion
+export { RETRY_CONFIGS, RetryOptions, calculateMaxAttempts };

package/dist/utils/retry.d.ts

@@ -0,0 +1,56 @@
+import { AttemptOptions } from "@lifeomic/attempt";
+
+//#region src/utils/retry.d.ts
+type RetryOptions = Partial<Pick<AttemptOptions<unknown>, "delay" | "initialDelay" | "minDelay" | "maxDelay" | "factor" | "maxAttempts" | "timeout" | "jitter" | "initialJitter">>;
+declare const RETRY_CONFIGS: {
+  THIRTY_SECS_AGGRESSIVE: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  ONE_MIN_MODERATE: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  TWO_MINS_GRADUAL: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  FIVE_MINS_STEADY: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  THIRTY_MINS_PATIENT: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+  TWO_HOURS_PERSISTENT: {
+    delay: number;
+    minDelay: number;
+    factor: number;
+    maxAttempts: number;
+    jitter: boolean;
+  };
+};
+/**
+ * Calculates how many attempts fit within a timeout budget.
+ *
+ * @returns number of attempts that fit within the timeout
+ */
+declare function calculateMaxAttempts(timeout: number, delay: number, factor: number): number;
+//#endregion
+export { RETRY_CONFIGS, RetryOptions, calculateMaxAttempts };

package/dist/utils/retry.js

@@ -0,0 +1,64 @@
+//#region src/utils/retry.ts
+const RETRY_CONFIGS = {
+	THIRTY_SECS_AGGRESSIVE: {
+		delay: 500,
+		minDelay: 500,
+		factor: 2,
+		maxAttempts: 6,
+		jitter: true
+	},
+	ONE_MIN_MODERATE: {
+		delay: 1e3,
+		minDelay: 1e3,
+		factor: 1.5,
+		maxAttempts: 8,
+		jitter: true
+	},
+	TWO_MINS_GRADUAL: {
+		delay: 500,
+		minDelay: 500,
+		factor: 1.5,
+		maxAttempts: 12,
+		jitter: true
+	},
+	FIVE_MINS_STEADY: {
+		delay: 2e3,
+		minDelay: 2e3,
+		factor: 1.4,
+		maxAttempts: 12,
+		jitter: true
+	},
+	THIRTY_MINS_PATIENT: {
+		delay: 5e3,
+		minDelay: 5e3,
+		factor: 1.3,
+		maxAttempts: 18,
+		jitter: true
+	},
+	TWO_HOURS_PERSISTENT: {
+		delay: 1e4,
+		minDelay: 1e4,
+		factor: 1.2,
+		maxAttempts: 27,
+		jitter: true
+	}
+};
+/**
+* Calculates how many attempts fit within a timeout budget.
+*
+* @returns number of attempts that fit within the timeout
+*/
+function calculateMaxAttempts(timeout, delay, factor) {
+	let totalDelay = 0;
+	let currentDelay = delay;
+	let attempts = 1;
+	while (totalDelay + currentDelay <= timeout) {
+		totalDelay += currentDelay;
+		attempts++;
+		currentDelay *= factor;
+	}
+	return Math.max(1, attempts);
+}
+
+//#endregion
+export { RETRY_CONFIGS, calculateMaxAttempts };

package/dist/utils/serialize.cjs

@@ -0,0 +1,82 @@
+
+//#region src/utils/serialize.ts
+/**
+* Get the reference key for the circular value
+*
+* @param keys the keys to build the reference key from
+* @param cutoff the maximum number of keys to include
+* @returns the reference key
+*/
+function getReferenceKey(keys, cutoff) {
+	return keys.slice(0, cutoff).join(".") || ".";
+}
+/**
+* Faster `Array.prototype.indexOf` implementation build for slicing / splicing
+*
+* @param array the array to match the value in
+* @param value the value to match
+* @returns the matching index, or -1
+*/
+function getCutoff(array, value) {
+	const { length } = array;
+	for (let index = 0; index < length; ++index) if (array[index] === value) return index + 1;
+	return 0;
+}
+/**
+* Create a replacer method that handles circular values
+*
+* @param [replacer] a custom replacer to use for non-circular values
+* @param [circularReplacer] a custom replacer to use for circular methods
+* @returns the value to stringify
+*/
+function createReplacer(replacer, circularReplacer) {
+	const hasReplacer = typeof replacer === "function";
+	const hasCircularReplacer = typeof circularReplacer === "function";
+	const cache = [];
+	const keys = [];
+	return function replace(key, value) {
+		if (typeof value === "object") if (cache.length) {
+			const thisCutoff = getCutoff(cache, this);
+			if (thisCutoff === 0) cache[cache.length] = this;
+			else {
+				cache.splice(thisCutoff);
+				keys.splice(thisCutoff);
+			}
+			keys[keys.length] = key;
+			const valueCutoff = getCutoff(cache, value);
+			if (valueCutoff !== 0) return hasCircularReplacer ? circularReplacer.call(this, key, value, getReferenceKey(keys, valueCutoff)) : `[ref=${getReferenceKey(keys, valueCutoff)}]`;
+		} else {
+			cache[0] = value;
+			keys[0] = key;
+		}
+		return hasReplacer ? replacer.call(this, key, value) : value;
+	};
+}
+/**
+* Stringifier that handles circular values
+*
+* Forked from https://github.com/planttheidea/fast-stringify
+*
+* @param value to stringify
+* @param [replacer] a custom replacer function for handling standard values
+* @param [indent] the number of spaces to indent the output by
+* @param [circularReplacer] a custom replacer function for handling circular values
+* @returns the stringified output
+*/
+function serialize(value, replacer, indent, circularReplacer) {
+	return JSON.stringify(value, createReplacer((key, value_) => {
+		let value$1 = value_;
+		if (typeof value$1 === "bigint") value$1 = {
+			__type: "bigint",
+			value: value_.toString()
+		};
+		if (value$1 instanceof Map) value$1 = {
+			__type: "Map",
+			value: Array.from(value_.entries())
+		};
+		return replacer?.(key, value$1) ?? value$1;
+	}, circularReplacer), indent ?? void 0);
+}
+
+//#endregion
+exports.serialize = serialize;

package/dist/utils/serialize.d.cts

@@ -0,0 +1,17 @@
+//#region src/utils/serialize.d.ts
+type StandardReplacer = (key: string, value: any) => any;
+type CircularReplacer = (key: string, value: any, referenceKey: string) => any;
+/**
+ * Stringifier that handles circular values
+ *
+ * Forked from https://github.com/planttheidea/fast-stringify
+ *
+ * @param value to stringify
+ * @param [replacer] a custom replacer function for handling standard values
+ * @param [indent] the number of spaces to indent the output by
+ * @param [circularReplacer] a custom replacer function for handling circular values
+ * @returns the stringified output
+ */
+declare function serialize(value: any, replacer?: StandardReplacer | null | undefined, indent?: number | null | undefined, circularReplacer?: CircularReplacer | null | undefined): string;
+//#endregion
+export { serialize };

package/dist/utils/serialize.d.ts

@@ -0,0 +1,17 @@
+//#region src/utils/serialize.d.ts
+type StandardReplacer = (key: string, value: any) => any;
+type CircularReplacer = (key: string, value: any, referenceKey: string) => any;
+/**
+ * Stringifier that handles circular values
+ *
+ * Forked from https://github.com/planttheidea/fast-stringify
+ *
+ * @param value to stringify
+ * @param [replacer] a custom replacer function for handling standard values
+ * @param [indent] the number of spaces to indent the output by
+ * @param [circularReplacer] a custom replacer function for handling circular values
+ * @returns the stringified output
+ */
+declare function serialize(value: any, replacer?: StandardReplacer | null | undefined, indent?: number | null | undefined, circularReplacer?: CircularReplacer | null | undefined): string;
+//#endregion
+export { serialize };

package/dist/utils/serialize.js

@@ -0,0 +1,81 @@
+//#region src/utils/serialize.ts
+/**
+* Get the reference key for the circular value
+*
+* @param keys the keys to build the reference key from
+* @param cutoff the maximum number of keys to include
+* @returns the reference key
+*/
+function getReferenceKey(keys, cutoff) {
+	return keys.slice(0, cutoff).join(".") || ".";
+}
+/**
+* Faster `Array.prototype.indexOf` implementation build for slicing / splicing
+*
+* @param array the array to match the value in
+* @param value the value to match
+* @returns the matching index, or -1
+*/
+function getCutoff(array, value) {
+	const { length } = array;
+	for (let index = 0; index < length; ++index) if (array[index] === value) return index + 1;
+	return 0;
+}
+/**
+* Create a replacer method that handles circular values
+*
+* @param [replacer] a custom replacer to use for non-circular values
+* @param [circularReplacer] a custom replacer to use for circular methods
+* @returns the value to stringify
+*/
+function createReplacer(replacer, circularReplacer) {
+	const hasReplacer = typeof replacer === "function";
+	const hasCircularReplacer = typeof circularReplacer === "function";
+	const cache = [];
+	const keys = [];
+	return function replace(key, value) {
+		if (typeof value === "object") if (cache.length) {
+			const thisCutoff = getCutoff(cache, this);
+			if (thisCutoff === 0) cache[cache.length] = this;
+			else {
+				cache.splice(thisCutoff);
+				keys.splice(thisCutoff);
+			}
+			keys[keys.length] = key;
+			const valueCutoff = getCutoff(cache, value);
+			if (valueCutoff !== 0) return hasCircularReplacer ? circularReplacer.call(this, key, value, getReferenceKey(keys, valueCutoff)) : `[ref=${getReferenceKey(keys, valueCutoff)}]`;
+		} else {
+			cache[0] = value;
+			keys[0] = key;
+		}
+		return hasReplacer ? replacer.call(this, key, value) : value;
+	};
+}
+/**
+* Stringifier that handles circular values
+*
+* Forked from https://github.com/planttheidea/fast-stringify
+*
+* @param value to stringify
+* @param [replacer] a custom replacer function for handling standard values
+* @param [indent] the number of spaces to indent the output by
+* @param [circularReplacer] a custom replacer function for handling circular values
+* @returns the stringified output
+*/
+function serialize(value, replacer, indent, circularReplacer) {
+	return JSON.stringify(value, createReplacer((key, value_) => {
+		let value$1 = value_;
+		if (typeof value$1 === "bigint") value$1 = {
+			__type: "bigint",
+			value: value_.toString()
+		};
+		if (value$1 instanceof Map) value$1 = {
+			__type: "Map",
+			value: Array.from(value_.entries())
+		};
+		return replacer?.(key, value$1) ?? value$1;
+	}, circularReplacer), indent ?? void 0);
+}
+
+//#endregion
+export { serialize };