@stackone/transport 1.6.2 → 1.8.1

package/dist/index.mjs

@@ -0,0 +1,755 @@
+import { z } from "zod";
+import axios from "axios";
+import qs from "qs";
+import { isMissing, notMissing } from "@stackone/utils";
+import { safeEvaluate } from "@stackone/expressions";
+
+//#region src/authorization/authorizationHeaders.ts
+const createAuthorizationHeaders = (authenticationParams) => {
+	switch (authenticationParams.type) {
+		case "basic": return createBasicAuthorizationHeader(authenticationParams);
+		case "bearer": return createBearerAuthorizationHeader(authenticationParams);
+		default: throw new Error("Invalid authentication type");
+	}
+};
+const createBasicAuthorizationHeader = ({ username = "", password = "", encoding = "base64" }) => {
+	const credentialsEncoding = encoding;
+	const encodedCredentials = Buffer.from(`${username}:${password}`).toString(credentialsEncoding);
+	return { authorization: `Basic ${encodedCredentials}` };
+};
+const createBearerAuthorizationHeader = ({ token, includeBearer = true }) => {
+	return { authorization: `${includeBearer ? "Bearer " : ""}${token}` };
+};
+
+//#endregion
+//#region src/customErrors/schemas.ts
+const CUSTOM_ERROR_CONFIG_SCHEMA = z.object({
+	receivedStatus: z.number(),
+	targetStatus: z.number(),
+	message: z.string().optional(),
+	condition: z.string().optional()
+});
+
+//#endregion
+//#region src/customErrors/types.ts
+const HttpErrorMessages = {
+	100: "Continue",
+	101: "Switching Protocols",
+	102: "Processing",
+	200: "OK",
+	201: "Created",
+	202: "Accepted",
+	203: "Non-Authoritative Information",
+	204: "No Content",
+	205: "Reset Content",
+	206: "Partial Content",
+	207: "Multi-Status",
+	208: "Already Reported",
+	226: "IM Used",
+	300: "Multiple Choices",
+	301: "Moved Permanently",
+	302: "Found",
+	303: "See Other",
+	304: "Not Modified",
+	305: "Use Proxy",
+	307: "Temporary Redirect",
+	308: "Permanent Redirect",
+	400: "Bad request",
+	401: "Unauthorized",
+	402: "Payment Required",
+	403: "Forbidden",
+	404: "Not Found",
+	405: "Method Not Allowed",
+	406: "Not Acceptable",
+	407: "Proxy Authentication Required",
+	408: "Request Timeout",
+	409: "Conflict",
+	410: "Gone",
+	411: "Length Required",
+	412: "Precondition Failed",
+	413: "Payload Too Large",
+	414: "URI Too Long",
+	415: "Unsupported Media Type",
+	416: "Range Not Satisfiable",
+	417: "Expectation Failed",
+	418: "I'm a teapot",
+	421: "Misdirected Request",
+	422: "Unprocessable Entity",
+	423: "Locked",
+	424: "Failed Dependency",
+	425: "Too Early",
+	426: "Upgrade Required",
+	428: "Precondition Required",
+	429: "Too many Requests",
+	431: "Request Header Fields Too Large",
+	451: "Unavailable For Legal Reasons",
+	499: "Client Closed Request",
+	500: "Internal server error",
+	501: "Not Implemented",
+	502: "Bad Gateway",
+	503: "Unavailable",
+	504: "Gateway Timeout",
+	505: "HTTP Version Not Supported",
+	506: "Variant Also Negotiates",
+	507: "Insufficient Storage",
+	508: "Loop Detected",
+	510: "Not Extended",
+	511: "Network Authentication Required"
+};
+
+//#endregion
+//#region src/errors/httpResponseError.ts
+/**
+* Represents an error resulting from an HTTP response.
+*
+* @remarks
+* This class is used to encapsulate HTTP response errors, including the response object and an optional message.
+* Extend this class to create more specific HTTP error types if needed.
+*
+* @example
+* try {
+*   // ... code that may throw an HttpResponseError
+* } catch (error) {
+*   if (error instanceof HttpResponseError) {
+*     console.error(error.response.status, error.message);
+*   }
+* }
+*
+* @public
+*/
+var HttpResponseError = class HttpResponseError extends Error {
+	response;
+	/**
+	* Creates a new HttpResponseError instance.
+	*
+	* @param response - The HttpResponse object associated with the error.
+	* @param message - Optional. A custom error message. If not provided, a default message is generated from the response status and message.
+	*/
+	constructor(response, message) {
+		super(message);
+		this.name = "HttpResponseError";
+		this.response = response;
+		this.message = message ?? `HTTP error: ${response.status}`;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, HttpResponseError);
+	}
+	/**
+	* Returns a string representation of the error, including the status code and message.
+	*
+	* @returns A string describing the error.
+	*/
+	toString() {
+		const message = this.message ? `: ${this.message}` : "";
+		return `${this.name} [${this.response.status}]${message}`;
+	}
+};
+
+//#endregion
+//#region src/httpClient/httpClient.ts
+const createAxiosInstance = () => {
+	return axios.create({ maxBodyLength: Infinity });
+};
+var HttpClient = class {
+	#transportInstance;
+	constructor({ transportInstance = createAxiosInstance() } = {}) {
+		this.#transportInstance = transportInstance;
+	}
+	async request({ headers = {}, url, method = "get", queryParams, maxRedirects = 0, responseType, cacheTTL, context, payload, httpsAgent }) {
+		try {
+			const urlWithQueryParams = new URLSearchParams(queryParams).toString();
+			const requestHeaders = this.#normalizeHeaders(headers);
+			const response = await this.#transportInstance.request({
+				headers: requestHeaders,
+				url: urlWithQueryParams ? `${url}?${urlWithQueryParams}` : url,
+				method,
+				maxRedirects,
+				responseType,
+				data: this.#getSafePayload(payload, requestHeaders),
+				httpsAgent
+			});
+			const requestResponse = {
+				data: response.data,
+				status: response.status,
+				headers: this.#extractAxiosHeaders(response.headers),
+				requestUrl: url,
+				responseType: response?.config?.responseType,
+				responseTime: /* @__PURE__ */ new Date()
+			};
+			return requestResponse;
+		} catch (e) {
+			throw e;
+		}
+	}
+	async get({ headers, url, queryParams, maxRedirects, cacheTTL, context }) {
+		return this.request({
+			url,
+			method: "get",
+			queryParams,
+			headers,
+			maxRedirects,
+			cacheTTL,
+			context
+		});
+	}
+	async post({ headers, url, maxRedirects, cacheTTL, context, payload }) {
+		return this.request({
+			url,
+			method: "post",
+			headers,
+			maxRedirects,
+			cacheTTL,
+			context,
+			payload
+		});
+	}
+	#normalizeHeaders(requestHeaders) {
+		if (!requestHeaders) return {};
+		const headers = {};
+		Object.keys(requestHeaders).forEach((key) => {
+			headers[key.toLowerCase()] = requestHeaders[key] || "";
+		});
+		return headers;
+	}
+	#extractAxiosHeaders(axiosHeaders) {
+		if (!axiosHeaders) return {};
+		const headers = {};
+		Object.keys(axiosHeaders).forEach((key) => {
+			headers[key] = axiosHeaders[key] || "";
+		});
+		return headers;
+	}
+	#isFormUrlEncoded(headers) {
+		return headers["content-type"] === "application/x-www-form-urlencoded";
+	}
+	#getSafePayload(payload, headers) {
+		if (!payload) return void 0;
+		if (this.#isFormUrlEncoded(headers)) return qs.stringify(payload);
+		return payload;
+	}
+};
+
+//#endregion
+//#region src/httpClient/httpClientManager.ts
+const buildHttpClientInstance = () => {
+	return new HttpClient();
+};
+var HttpClientManager = class {
+	static httpClientInstance = null;
+	static async getInstance({ getHttpClient = buildHttpClientInstance } = {}) {
+		this.httpClientInstance ??= getHttpClient();
+		return this.httpClientInstance;
+	}
+	static resetInstance() {
+		this.httpClientInstance = null;
+	}
+};
+
+//#endregion
+//#region src/httpClient/types.ts
+const HttpMethods = [
+	"get",
+	"post",
+	"put",
+	"delete",
+	"patch"
+];
+
+//#endregion
+//#region src/lockManager/index.ts
+/**
+* Manages asynchronous locks based on string keys.
+* Useful for ensuring sequential execution of async operations that share a resource.
+*/
+var LockManager = class {
+	locks;
+	constructor() {
+		this.locks = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Acquires a lock for the given key and runs the provided asynchronous operation.
+	* Ensures the operation executes only after previous locks on the same key are released.
+	*
+	* @param key - A unique string representing the lock.
+	* @param operation - An async function to run while the lock is held.
+	* @returns The result of the operation.
+	*/
+	async withLock(key, operation) {
+		await this.lock(key);
+		try {
+			return operation();
+		} finally {
+			this.unlock(key);
+		}
+	}
+	/**
+	* Queues a lock for the given key. If the key is already locked,
+	* waits until the previous lock is released.
+	*
+	* @param key - A unique string representing the lock.
+	*/
+	async lock(key) {
+		let unlock;
+		const promise = new Promise((resolve) => unlock = resolve);
+		const hasLock = this.locks.has(key);
+		const currentLocks = this.locks.get(key);
+		if (hasLock && currentLocks) {
+			currentLocks.push({
+				lock: promise,
+				unlock
+			});
+			const previousLockIndex = currentLocks.length - 2;
+			await currentLocks[previousLockIndex].lock;
+		} else this.locks.set(key, [{
+			lock: promise,
+			unlock
+		}]);
+	}
+	/**
+	* Releases the lock for the given key. If more locks are queued, allows the next one to proceed.
+	*
+	* @param key - A unique string representing the lock.
+	*/
+	unlock(key) {
+		const hasLock = this.locks.has(key);
+		const currentLocks = this.locks.get(key);
+		if (hasLock && currentLocks && currentLocks.length > 0) {
+			const nextUnlock = currentLocks.shift()?.unlock;
+			nextUnlock?.();
+		}
+		if (this.queueLength(key) === 0) this.locks.delete(key);
+	}
+	/**
+	* Returns the number of queued locks for a given key.
+	*
+	* @param key - The lock key to check.
+	* @returns Number of locks in the queue, or undefined if none exist.
+	*/
+	queueLength(key) {
+		return this.locks.get(key)?.length;
+	}
+	/**
+	* Clears all locks and queued operations.
+	*/
+	close() {
+		this.locks.clear();
+	}
+};
+
+//#endregion
+//#region src/memoryStore/constants.ts
+const ONE_THOUSAND = 1e3;
+const ONE_HUNDRED = 100;
+const ONE_MINUTE_IN_SECONDS = 60;
+const ONE_MINUTE_IN_MS = 6e4;
+const DEFAULT_CACHE_TTL = ONE_MINUTE_IN_SECONDS;
+const DEFAULT_EVICTION_FREQUENCY = ONE_MINUTE_IN_MS;
+const DEFAULT_STALE_DATA_THRESHOLD = ONE_MINUTE_IN_MS * 10;
+const DEFAULT_TRUNCATION_THRESHOLD = ONE_HUNDRED;
+const DEFAULT_TRUNCATION_PERCENTAGE = 10;
+let MemoryStoreErrorCodes = /* @__PURE__ */ function(MemoryStoreErrorCodes$1) {
+	MemoryStoreErrorCodes$1["MemoryStorePruneError"] = "MemoryStorePruneError";
+	return MemoryStoreErrorCodes$1;
+}({});
+
+//#endregion
+//#region src/memoryStore/index.ts
+var MemoryStore = class {
+	config;
+	instantiator;
+	dataStore;
+	lockManager;
+	expiryMap;
+	evictionFrequency;
+	staleDataThreshold;
+	truncateThreshold;
+	truncationPercentage;
+	logger;
+	typeGuard;
+	dispose;
+	evictionInterval;
+	lastAccessedAt = Date.now();
+	/**
+	* Constructs a new MemoryStore instance with optional configuration.
+	* @param config Configuration options for the store.
+	*/
+	constructor(config = {}) {
+		this.config = config;
+		this.initialize(config);
+	}
+	initialize(config = this.config) {
+		this.instantiator = config?.instantiator ?? "Unknown";
+		this.logger = config?.logger;
+		this.dataStore = config?.dataStore ?? /* @__PURE__ */ new Map();
+		this.lockManager = config?.lockManager ?? new LockManager();
+		this.expiryMap = config?.expiryMap ?? /* @__PURE__ */ new Map();
+		this.evictionFrequency = config?.evictionFrequency ?? DEFAULT_EVICTION_FREQUENCY;
+		this.staleDataThreshold = config?.staleDataThreshold ?? DEFAULT_STALE_DATA_THRESHOLD;
+		this.truncateThreshold = config?.truncateThreshold ?? DEFAULT_TRUNCATION_THRESHOLD;
+		this.truncationPercentage = config?.truncationPercentage ?? DEFAULT_TRUNCATION_PERCENTAGE;
+		this.typeGuard = config?.typeGuard;
+		this.dispose = config?.dispose;
+		this.startEvictionTask();
+	}
+	/**
+	* Retrieves data for a given key.
+	* @param key Cache key.
+	* @returns The cached data or `null` if not found.
+	*/
+	async getData(key) {
+		if (!this.isReady()) this.initialize();
+		this.updateLastAccessedAt();
+		return this.lockManager.withLock(key, async () => this.dataStore.get(key) ?? null);
+	}
+	/**
+	* Stores data in the cache.
+	* @param key The key to store the data under.
+	* @param value The value to store.
+	* @param cacheTTL Time-to-live in seconds (default: 60s).
+	* @returns `true` if data was stored, `false` if rejected by type guard.
+	*/
+	async setData({ key, value, cacheTTL = DEFAULT_CACHE_TTL }) {
+		if (!this.isReady()) this.initialize();
+		this.updateLastAccessedAt();
+		if (notMissing(this.typeGuard) && !this.typeGuard(value)) return false;
+		const cacheTTLInMs = cacheTTL * ONE_THOUSAND;
+		const expiryTime = Date.now() + cacheTTLInMs;
+		await this.lockManager.withLock(key, async () => {
+			if (notMissing(this.typeGuard) && this.typeGuard(value) || isMissing(this.typeGuard) && this.typeGuardBypass(value)) this.dataStore.set(key, value);
+			this.expiryMap.set(key, expiryTime);
+		});
+		return true;
+	}
+	typeGuardBypass(data) {
+		this.logger?.debug({
+			category: "MemoryStore",
+			message: `${this.instantiator} MemoryStore setting data without type guard - you should probably configure one`
+		});
+		return true;
+	}
+	/**
+	* Deletes a key from the cache.
+	* Calls the dispose callback if defined.
+	* @param key Cache key to delete.
+	* @returns `true` if deleted, `false` otherwise.
+	*/
+	async delete(key) {
+		if (!this.isReady()) this.initialize();
+		this.updateLastAccessedAt();
+		return this.lockManager.withLock(key, async () => {
+			if (this.dispose) {
+				const value = this.dataStore.get(key);
+				await this.dispose(key, value);
+			}
+			return this.dataStore.delete(key);
+		});
+	}
+	/**
+	* Prunes expired or stale keys from the cache.
+	* Also triggers truncation if store exceeds threshold.
+	* @returns Stats on pruning if any keys were removed.
+	*/
+	async pruneExpiredKeys() {
+		const dataStoreSize = this.dataStore.size;
+		const shouldTruncate = dataStoreSize >= this.truncateThreshold;
+		if (dataStoreSize <= 0) return;
+		const asyncDeletions = [];
+		let index = 0;
+		this.dataStore.forEach(async (value, key) => {
+			const currentTime = Date.now();
+			const expiresAt = this.expiryMap.get(key) ?? 0;
+			const truncateLimit = this.truncateThreshold * this.truncationPercentage / ONE_HUNDRED;
+			if (expiresAt <= currentTime || shouldTruncate && index >= 0 && index <= truncateLimit) asyncDeletions.push(this.lockManager.withLock(key, async () => {
+				if (this.dispose) await this.dispose(key, value);
+				return this.dataStore.delete(key);
+			}));
+			index++;
+		});
+		await Promise.all(asyncDeletions);
+		const prunedDataStoreSize = this.dataStore.size;
+		return {
+			dataStoreSize,
+			prunedDataStoreSize
+		};
+	}
+	startEvictionTask() {
+		if (notMissing(this.evictionInterval)) return;
+		const executePrune = async () => {
+			let result;
+			try {
+				const instanceDataExpiry = this.lastAccessedAt + this.staleDataThreshold;
+				const now = Date.now();
+				if (instanceDataExpiry < now) {
+					this.logger?.warning({
+						message: `Closing the ${this.instantiator}'s MemoryStore instance - received no requests for a while.`,
+						category: "MemoryStore"
+					});
+					this.close();
+					return;
+				}
+				result = await this.pruneExpiredKeys();
+				this.evictionInterval = setTimeout(executePrune, this.evictionFrequency);
+			} catch (error) {
+				if (error instanceof Error) this.logger?.error({
+					message: "Error during pruning expired keys:",
+					category: "MemoryStore",
+					error,
+					code: MemoryStoreErrorCodes.MemoryStorePruneError
+				});
+				this.evictionInterval = setTimeout(executePrune, this.evictionFrequency);
+			} finally {
+				if (notMissing(result?.dataStoreSize) && notMissing(result?.prunedDataStoreSize)) {
+					const { dataStoreSize, prunedDataStoreSize } = result;
+					const prunedKeysTotal = dataStoreSize - prunedDataStoreSize;
+					this.logger?.debug({
+						message: `Pruned ${prunedKeysTotal} expired keys, ${prunedDataStoreSize} remain, scheduling next prune.`,
+						category: "MemoryStore",
+						context: { instantiator: this.instantiator }
+					});
+				}
+			}
+		};
+		this.evictionInterval = setTimeout(executePrune, this.evictionFrequency);
+	}
+	stopEvictionTask() {
+		if (this.evictionInterval) {
+			clearTimeout(this.evictionInterval);
+			this.evictionInterval = void 0;
+		}
+	}
+	updateLastAccessedAt() {
+		this.lastAccessedAt = Date.now();
+	}
+	/**
+	* Checks if the store is initialized and ready for use.
+	* @returns `true` if ready, `false` otherwise.
+	*/
+	isReady() {
+		return notMissing(this.evictionInterval) && notMissing(this.dataStore) && notMissing(this.expiryMap) && notMissing(this.lockManager);
+	}
+	/**
+	* Stops eviction and clears all data.
+	*/
+	close() {
+		this.stopEvictionTask();
+		this.dataStore.clear();
+		this.expiryMap.clear();
+		this.lockManager.close();
+	}
+	/**
+	* Lists keys and their data, with pagination.
+	* @param partialKey Match keys containing this string.
+	* @param cursor Optional offset for pagination.
+	* @param limit Max number of items to return.
+	* @returns Matching items and next cursor (if any).
+	*/
+	async listData({ partialKey, cursor, limit }) {
+		const mapKeys = Array.from(this.dataStore.keys());
+		const matchingKeys = mapKeys.filter((key) => key.includes(partialKey));
+		const matches = [];
+		const parsedCursor = cursor ? parseInt(cursor, 10) : 0;
+		for (let i = parsedCursor; i < limit + parsedCursor; i++) {
+			const key = matchingKeys[i];
+			if (!key) break;
+			const data = await this.getData(key);
+			if (data) matches.push(data);
+			if (matches.length >= limit) break;
+		}
+		return {
+			items: matches,
+			cursor: matches.length < limit ? void 0 : (parsedCursor + limit).toString()
+		};
+	}
+};
+
+//#endregion
+//#region src/instanceManager/constants.ts
+const DEFAULT_INSTANCE_TTL = 300;
+
+//#endregion
+//#region src/instanceManager/index.ts
+/**
+* Singleton cache manager that wraps a `MemoryStore` and ensures only one instance is used across the app.
+* Primarily used for simple key-value caching with TTL and optional logger support.
+*/
+var InstanceManager = class InstanceManager {
+	static instance = null;
+	static logger = null;
+	dataStore = null;
+	constructor(logger) {
+		this.initialize(logger);
+	}
+	/**
+	* Returns the singleton instance of the InstanceManager.
+	* If it hasn't been created yet, it initializes it with optional logger.
+	*
+	* @param logger Optional logger instance.
+	* @returns The shared InstanceManager instance.
+	*/
+	static getInstance(logger) {
+		if (isMissing(InstanceManager.instance)) InstanceManager.instance = new InstanceManager(logger);
+		return InstanceManager.instance;
+	}
+	/**
+	* Initializes the internal MemoryStore with optional logger.
+	*
+	* @param logger Optional logger for debug/info messages.
+	*/
+	initialize(logger) {
+		this.dataStore = new MemoryStore({
+			instantiator: InstanceManager.name,
+			logger,
+			typeGuard: (data) => notMissing(data)
+		});
+		InstanceManager.logger = logger ?? null;
+		InstanceManager.logger?.info({
+			category: InstanceManager.name,
+			message: "InstanceManager initialized."
+		});
+	}
+	/**
+	* Retrieves a value from the cache.
+	*
+	* @param key The key to fetch.
+	* @returns The cached value, or `null` if not found.
+	*/
+	async get(key) {
+		this.ensureReady();
+		return await InstanceManager.getInstance().dataStore?.getData(key) ?? null;
+	}
+	/**
+	* Stores a value in the cache with optional TTL.
+	*
+	* @param key The key to associate with the value.
+	* @param value The value to store.
+	* @param cacheTTL Optional TTL in seconds (defaults to `DEFAULT_INSTANCE_TTL`).
+	* @returns `true` if successfully stored, `false` otherwise.
+	*/
+	async set(key, value, cacheTTL) {
+		this.ensureReady();
+		return await InstanceManager.getInstance().dataStore?.setData({
+			key,
+			value,
+			cacheTTL: notMissing(cacheTTL) ? cacheTTL : DEFAULT_INSTANCE_TTL
+		}) ?? false;
+	}
+	/**
+	* Ensures the store is initialized. If not, reinitializes it.
+	*/
+	ensureReady() {
+		if (!this.isReady()) this.initialize();
+	}
+	/**
+	* Checks if the cache is initialized and ready.
+	*
+	* @returns `true` if ready, `false` otherwise.
+	*/
+	isReady() {
+		return notMissing(this?.dataStore);
+	}
+	/**
+	* Clears the current instance and internal store.
+	*/
+	close() {
+		InstanceManager.instance = null;
+		this.dataStore = null;
+	}
+};
+/**
+* Singleton export for convenient shared access.
+*/
+const instanceManager = InstanceManager.getInstance();
+
+//#endregion
+//#region src/parsers/requestParameters.ts
+const parseRequestParameters = (parameters) => {
+	return parameters.reduce((acc, param) => {
+		if (Array.isArray(acc[param.in][param.name])) acc[param.in][param.name] = acc[param.in][param.name].concat(param.value);
+		else if (typeof acc[param.in][param.name] === "object" && typeof param.value === "object") acc[param.in][param.name] = {
+			...acc[param.in][param.name],
+			...param.value
+		};
+		else acc[param.in][param.name] = param.in === "body" ? param.value : String(param.value);
+		return acc;
+	}, {
+		query: {},
+		body: {},
+		headers: {}
+	});
+};
+
+//#endregion
+//#region src/parsers/types.ts
+const RequestParameterLocations = [
+	"query",
+	"body",
+	"headers"
+];
+
+//#endregion
+//#region src/customErrors/index.ts
+const translateCustomError = (response, configs) => {
+	if (isMissing(configs) || configs?.length === 0 || isMissing(response)) return {
+		data: response.data,
+		status: response.status,
+		headers: response.headers,
+		requestUrl: response.requestUrl,
+		responseType: response.responseType,
+		responseTime: response.responseTime,
+		message: response.message
+	};
+	const customErrors = configs?.filter((errorConfig) => errorConfig.receivedStatus === response.status);
+	if (customErrors?.length) for (const customError of customErrors) {
+		const conditionExpression = customError.condition;
+		const isConditionMet = safeEvaluate(conditionExpression, response) === true;
+		if (isMissing(conditionExpression) || isConditionMet) return {
+			data: response.data,
+			headers: response.headers,
+			requestUrl: response.requestUrl,
+			responseType: response.responseType,
+			responseTime: response.responseTime,
+			status: customError.targetStatus,
+			message: customError?.message ?? HttpErrorMessages[customError.targetStatus] ?? "Unknown error"
+		};
+	}
+	return response;
+};
+
+//#endregion
+//#region src/validators/statusCodes.ts
+const isSuccessStatusCode = (status) => notMissing(status) && status >= 200 && status <= 299;
+const isFailedStatusCode = (status) => notMissing(status) && status >= 400 && status <= 599;
+const isInfoStatusCode = (status) => notMissing(status) && status >= 100 && status <= 199;
+
+//#endregion
+//#region src/requestClient/restClient.ts
+var RestClient = class {
+	async performRequest({ httpClient, url, method, headers, body, customErrorConfigs }) {
+		let response;
+		try {
+			response = await httpClient?.request({
+				method,
+				url,
+				headers,
+				maxRedirects: 0,
+				payload: body
+			});
+		} catch (error) {
+			if (isMissing(error?.response)) throw error;
+			else response = error.response;
+		}
+		const translatedResponse = translateCustomError(response, customErrorConfigs);
+		if (isFailedStatusCode(translatedResponse?.status)) throw new HttpResponseError(translatedResponse, translatedResponse.message);
+		else return translatedResponse;
+	}
+};
+
+//#endregion
+//#region src/requestClient/requestClientFactory.ts
+var RequestClientFactory = class {
+	static build(type = "rest") {
+		if (type === "rest") return new RestClient();
+		else throw new Error(`Unknown request client type: ${type}`);
+	}
+};
+
+//#endregion
+export { CUSTOM_ERROR_CONFIG_SCHEMA, HttpClient, HttpClientManager, HttpErrorMessages, HttpMethods, HttpResponseError, InstanceManager, LockManager, MemoryStore, RequestClientFactory, RequestParameterLocations, createAuthorizationHeaders, isFailedStatusCode, isInfoStatusCode, isSuccessStatusCode, parseRequestParameters };