@api-wrappers/api-core 0.0.1

package/dist/index.cjs

@@ -0,0 +1,994 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0@oxc-project+runtime@0.122.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region src/errors/ApiError.ts
+var ApiError = class extends Error {
+	constructor(message, status, responseBody, cause) {
+		super(message);
+		_defineProperty(this, "status", void 0);
+		_defineProperty(this, "responseBody", void 0);
+		_defineProperty(this, "cause", void 0);
+		this.name = "ApiError";
+		this.status = status;
+		this.responseBody = responseBody;
+		this.cause = cause;
+	}
+};
+//#endregion
+//#region src/errors/RateLimitError.ts
+var RateLimitError = class extends ApiError {
+	constructor(retryAfterMs, responseBody, cause) {
+		super("Rate limit exceeded", 429, responseBody, cause);
+		_defineProperty(this, "retryAfterMs", void 0);
+		this.name = "RateLimitError";
+		this.retryAfterMs = retryAfterMs;
+	}
+};
+//#endregion
+//#region src/graphql/GraphQLRequestError.ts
+/**
+* Thrown when a GraphQL server returns a well-formed HTTP 200 response that
+* contains a non-empty `errors` array.
+*
+* Extends {@link ApiError} so that code catching `ApiError` also catches
+* GraphQL-level failures. Callers that need to inspect the individual error
+* objects can narrow with `instanceof GraphQLRequestError` and read
+* `graphqlErrors`.
+*
+* When the server returns both `data` and `errors` (partial result), the
+* partial data is available on `partialData` but the error is still thrown —
+* callers must explicitly opt in to consuming partial results.
+*
+* @example
+* ```ts
+* import { GraphQLRequestError } from "@api-wrappers/api-core";
+*
+* try {
+*   const data = await client.graphql<MyQuery>("/graphql", { query: QUERY });
+* } catch (err) {
+*   if (err instanceof GraphQLRequestError) {
+*     for (const e of err.graphqlErrors) {
+*       console.error(e.message, e.path);
+*     }
+*   }
+* }
+* ```
+*/
+var GraphQLRequestError = class extends ApiError {
+	constructor(errors, partialData, cause) {
+		const message = errors.map((e) => e.message).join("; ");
+		super(`GraphQL errors: ${message}`, 200, { errors }, cause);
+		_defineProperty(this, "graphqlErrors", void 0);
+		_defineProperty(this, "partialData", void 0);
+		this.name = "GraphQLRequestError";
+		this.graphqlErrors = errors;
+		this.partialData = partialData;
+	}
+};
+//#endregion
+//#region src/plugin/PluginManager.ts
+var PluginManager = class {
+	/**
+	* @param logger - Logger used when an `onError` handler itself throws.
+	*   Defaults to `console`. Pass a no-op object to silence all output.
+	*/
+	constructor(logger = console) {
+		_defineProperty(this, "plugins", []);
+		_defineProperty(this, "logger", void 0);
+		this.logger = logger;
+	}
+	register(plugin) {
+		if (plugin.enabled === false) return;
+		this.plugins.push(plugin);
+		this.plugins.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+	}
+	getAll() {
+		return this.plugins;
+	}
+	async setup(client) {
+		for (const plugin of this.plugins) await plugin.setup?.(client);
+	}
+	/**
+	* Runs `beforeRequest` in ascending priority order (lowest first).
+	* Each plugin may return a mutated context.
+	*/
+	async beforeRequest(ctx) {
+		let current = ctx;
+		for (const plugin of this.plugins) try {
+			const result = await plugin.beforeRequest?.(current);
+			if (result != null) current = result;
+		} catch (err) {
+			throw wrapPluginError(plugin.name, "beforeRequest", err, current);
+		}
+		return current;
+	}
+	/**
+	* Runs `afterResponse` in descending priority order (highest first).
+	* Each plugin may return a mutated context.
+	*/
+	async afterResponse(ctx) {
+		let current = ctx;
+		for (const plugin of [...this.plugins].reverse()) try {
+			const result = await plugin.afterResponse?.(current);
+			if (result != null) current = result;
+		} catch (err) {
+			throw wrapPluginError(plugin.name, "afterResponse", err);
+		}
+		return current;
+	}
+	/**
+	* Runs `onError` on all plugins in registration order. A plugin throwing
+	* here is caught and logged via the configured logger but does not
+	* interrupt other `onError` handlers.
+	*/
+	async onError(error, ctx) {
+		for (const plugin of this.plugins) try {
+			await plugin.onError?.(error, ctx);
+		} catch (inner) {
+			this.logger.error(`[PluginManager] Plugin "${plugin.name}" threw inside onError:`, inner);
+		}
+	}
+	async dispose() {
+		for (const plugin of [...this.plugins].reverse()) await plugin.dispose?.();
+	}
+};
+function getPluginErrorContext(error) {
+	if (!error || typeof error !== "object") return void 0;
+	return error.requestContext;
+}
+function wrapPluginError(name, hook, cause, requestContext) {
+	const message = `Plugin "${name}" threw during "${hook}"`;
+	const err = new Error(message, { cause });
+	err.name = "PluginError";
+	err.requestContext = requestContext;
+	return err;
+}
+//#endregion
+//#region src/errors/TimeoutError.ts
+var TimeoutError = class extends Error {
+	constructor(message = "Request timed out", cause) {
+		super(message);
+		_defineProperty(this, "cause", void 0);
+		this.name = "TimeoutError";
+		this.cause = cause;
+	}
+};
+//#endregion
+//#region src/utils/buildUrl.ts
+/**
+* Appends a query string to a URL. Skips nullish values and repeats keys for
+* array values so APIs like TMDB can accept `with_genres=1&with_genres=2`.
+*/
+function buildUrl(base, query) {
+	if (!query || Object.keys(query).length === 0) return base;
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (item !== void 0 && item !== null) params.append(key, String(item));
+		} else params.append(key, String(value));
+	}
+	const qs = params.toString();
+	if (!qs) return base;
+	return `${base}${base.includes("?") ? base.endsWith("?") || base.endsWith("&") ? "" : "&" : "?"}${qs}`;
+}
+//#endregion
+//#region src/utils/isPlainObject.ts
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+//#endregion
+//#region src/transport/fetchTransport.ts
+/**
+* Creates a {@link Transport} backed by the provided `fetch` function.
+* Use this when you need a polyfill or a custom fetch interceptor:
+*
+* ```ts
+* import nodeFetch from "node-fetch";
+* createClient({ fetch: nodeFetch as typeof globalThis.fetch });
+* // — or set it directly on the transport:
+* const transport = createFetchTransport(nodeFetch as typeof globalThis.fetch);
+* ```
+*/
+function createFetchTransport(fetchFn = globalThis.fetch) {
+	return { async execute(ctx) {
+		const url = buildUrl(ctx.url, ctx.query);
+		const init = {
+			method: ctx.method,
+			headers: ctx.headers
+		};
+		if (ctx.body !== void 0 && ctx.method !== "GET" && ctx.method !== "HEAD") init.body = serializeRequestBody(ctx.body, ctx.headers);
+		if (ctx.timeoutMs !== void 0 || ctx.signal) {
+			const controller = new AbortController();
+			let timedOut = false;
+			const abortFromParent = () => controller.abort(ctx.signal?.reason);
+			const timer = ctx.timeoutMs !== void 0 ? setTimeout(() => {
+				timedOut = true;
+				controller.abort();
+			}, ctx.timeoutMs) : void 0;
+			if (ctx.signal) if (ctx.signal.aborted) controller.abort(ctx.signal.reason);
+			else ctx.signal.addEventListener("abort", abortFromParent, { once: true });
+			try {
+				return await fetchFn(url, {
+					...init,
+					signal: controller.signal
+				});
+			} catch (err) {
+				if (timedOut && err instanceof Error && err.name === "AbortError") throw new TimeoutError(`Request timed out after ${ctx.timeoutMs}ms`, err);
+				throw err;
+			} finally {
+				if (timer) clearTimeout(timer);
+				ctx.signal?.removeEventListener("abort", abortFromParent);
+			}
+		}
+		return fetchFn(url, init);
+	} };
+}
+/**
+* Default {@link Transport} backed by the global `fetch` API.
+*
+* Behaviour:
+* - Builds the final URL from `ctx.url` + `ctx.query` via {@link buildUrl}.
+* - Serialises `ctx.body` to JSON for non-GET/HEAD requests.
+* - Wires an `AbortController` when `ctx.timeoutMs` is set; throws
+*   {@link TimeoutError} on abort.
+*
+* Replace this with a custom {@link Transport} in tests, or provide a custom
+* `fetch` function via {@link ClientConfig.fetch}.
+*/
+const fetchTransport = createFetchTransport();
+function serializeRequestBody(body, headers) {
+	if (isBodyInit(body)) return body;
+	const contentType = headers["content-type"] ?? "";
+	if (isPlainObject(body) || Array.isArray(body) || contentType.includes("json")) return JSON.stringify(body);
+	return String(body);
+}
+function isBodyInit(body) {
+	if (typeof body === "string") return true;
+	if (body instanceof ArrayBuffer) return true;
+	if (ArrayBuffer.isView(body)) return true;
+	if (typeof Blob !== "undefined" && body instanceof Blob) return true;
+	if (typeof FormData !== "undefined" && body instanceof FormData) return true;
+	if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return true;
+	if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) return true;
+	return false;
+}
+//#endregion
+//#region src/utils/mergeHeaders.ts
+/**
+* Merges header objects left to right. Keys are normalized to
+* lowercase so merging is case-insensitive. Later sources win.
+*/
+function mergeHeaders(...sources) {
+	const result = {};
+	for (const source of sources) {
+		if (!source) continue;
+		for (const [key, value] of Object.entries(source)) result[key.toLowerCase()] = value;
+	}
+	return result;
+}
+//#endregion
+//#region src/utils/resolveUrl.ts
+/**
+* Joins a client base URL and request path without requiring callers to keep
+* slashes perfectly aligned. Absolute request URLs are returned unchanged.
+*/
+function resolveUrl(baseUrl, path) {
+	if (/^[a-z][a-z\d+\-.]*:\/\//i.test(path)) return path;
+	const base = baseUrl.replace(/\/+$/, "");
+	const next = path.replace(/^\/+/, "");
+	return next ? `${base}/${next}` : base;
+}
+//#endregion
+//#region src/utils/sleep.ts
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+//#region src/client/BaseHttpClient.ts
+const DEFAULT_RETRIABLE_STATUS_CODES = [
+	429,
+	500,
+	502,
+	503,
+	504
+];
+/**
+* Core HTTP client. Manages the plugin lifecycle, retry loop, and transport
+* dispatch for all requests.
+*
+* Plugins are initialised lazily on the first call to {@link request} (or any
+* convenience method). Call {@link dispose} when the client is no longer
+* needed so plugins can release timers, connections, or cache handles.
+*
+* Extend this class to add domain-specific methods while keeping the plugin
+* and transport infrastructure intact.
+*
+* @example
+* ```ts
+* // Prefer createClient() in application code:
+* const client = createClient({ baseUrl: "https://api.example.com/v1" });
+*
+* // Or subclass for wrapper packages:
+* class MyApiClient extends BaseHttpClient {
+*   getUser(id: string) { return this.get<User>(`/users/${id}`); }
+* }
+* ```
+*/
+var BaseHttpClient = class {
+	constructor(config) {
+		_defineProperty(this, "config", void 0);
+		_defineProperty(this, "pluginManager", void 0);
+		_defineProperty(this, "initialized", false);
+		_defineProperty(this, "initPromise", void 0);
+		this.config = config;
+		this.pluginManager = new PluginManager(config.logger);
+		for (const plugin of config.plugins ?? []) this.pluginManager.register(plugin);
+	}
+	/** Initializes all plugins. Called lazily on first request. */
+	async init() {
+		if (this.initialized) return;
+		this.initPromise ?? (this.initPromise = this.pluginManager.setup(this).then(() => {
+			this.initialized = true;
+		}).catch((err) => {
+			this.initPromise = void 0;
+			throw err;
+		}));
+		await this.initPromise;
+	}
+	/** Disposes all plugins. Call when the client is no longer needed. */
+	async dispose() {
+		await this.pluginManager.dispose();
+		this.initialized = false;
+		this.initPromise = void 0;
+	}
+	/**
+	* Executes an HTTP request through the full plugin pipeline.
+	*
+	* Lifecycle per attempt:
+	* 1. Build `RequestContext` with merged headers, query, and retry state.
+	* 2. Run `beforeRequest` hooks (ascending priority). A plugin may set
+	*    `ctx.syntheticResponse` to skip the transport entirely (e.g. cache hit).
+	* 3. Merge any `retry.*` meta written by {@link createRetryPlugin}.
+	* 4. Call transport (skipped when `syntheticResponse` is set).
+	* 5. Parse the response body (JSON or text).
+	* 6. Run `afterResponse` hooks (descending priority).
+	* 7. Retry on retriable status codes; throw on terminal failures.
+	*
+	* @param path - Path appended to `ClientConfig.baseUrl`. Should start with `/`.
+	* @param options - Per-request overrides for method, headers, body, query, etc.
+	* @returns The parsed response body cast to `T`.
+	* @throws {@link ApiError} for non-2xx responses.
+	* @throws {@link RateLimitError} for 429 responses.
+	* @throws {@link TimeoutError} when `timeoutMs` is exceeded.
+	*/
+	async request(path, options = {}) {
+		return (await this.requestWithResponse(path, options)).data;
+	}
+	/**
+	* Executes a request and returns the parsed body plus the final response
+	* context. Use this in wrappers that need response headers, status, or
+	* plugin metadata while keeping the same error/retry behaviour as
+	* {@link request}.
+	*/
+	async requestWithResponse(path, options = {}) {
+		await this.init();
+		const transport = this.config.transport ?? (this.config.fetch ? createFetchTransport(this.config.fetch) : fetchTransport);
+		const retryCfg = this.config.retry;
+		let maxAttempts = retryCfg?.maxAttempts ?? 1;
+		let baseDelay = retryCfg?.delayMs ?? 500;
+		let jitter = retryCfg?.jitter ?? true;
+		let retriableCodes = retryCfg?.retriableStatusCodes ?? DEFAULT_RETRIABLE_STATUS_CODES;
+		let lastError;
+		for (let attempt = 0; attempt < maxAttempts; attempt++) {
+			const baseCtx = {
+				url: resolveUrl(this.config.baseUrl, path),
+				method: options.method ?? "GET",
+				headers: mergeHeaders({ "content-type": "application/json" }, this.config.defaultHeaders, options.headers),
+				body: options.body,
+				query: options.query,
+				signal: options.signal,
+				meta: {},
+				cacheKey: options.cacheKey,
+				tags: options.tags,
+				retryCount: maxAttempts - 1 - attempt,
+				attempt,
+				timeoutMs: options.timeoutMs ?? this.config.timeoutMs
+			};
+			let ctx;
+			try {
+				ctx = await this.pluginManager.beforeRequest(baseCtx);
+			} catch (err) {
+				await this.pluginManager.onError(err, getPluginErrorContext(err) ?? baseCtx);
+				throw err;
+			}
+			if (ctx.meta["retry.maxAttempts"] !== void 0) maxAttempts = ctx.meta["retry.maxAttempts"];
+			if (ctx.meta["retry.delayMs"] !== void 0) baseDelay = ctx.meta["retry.delayMs"];
+			if (ctx.meta["retry.jitter"] !== void 0) jitter = ctx.meta["retry.jitter"];
+			if (ctx.meta["retry.retriableStatusCodes"] !== void 0) retriableCodes = ctx.meta["retry.retriableStatusCodes"];
+			let rawResponse;
+			if (ctx.syntheticResponse) rawResponse = ctx.syntheticResponse;
+			else try {
+				rawResponse = await transport.execute(ctx);
+			} catch (err) {
+				await this.pluginManager.onError(err, ctx);
+				lastError = err;
+				if (attempt < maxAttempts - 1) {
+					await this.waitForRetry(attempt, baseDelay, jitter);
+					continue;
+				}
+				throw err;
+			}
+			const parsedBody = await parseBody(rawResponse);
+			let resCtx = {
+				request: ctx,
+				response: rawResponse,
+				parsedBody,
+				meta: {}
+			};
+			try {
+				resCtx = await this.pluginManager.afterResponse(resCtx);
+			} catch (err) {
+				await this.pluginManager.onError(err, ctx);
+				throw err;
+			}
+			if (!rawResponse.ok) {
+				if (retriableCodes.includes(rawResponse.status) && attempt < maxAttempts - 1) {
+					if (rawResponse.status === 429) {
+						const wait = readRetryAfterMs(rawResponse);
+						await this.waitForRetry(attempt, wait ?? baseDelay, false);
+					} else await this.waitForRetry(attempt, baseDelay, jitter);
+					lastError = normalizeHttpError(rawResponse, resCtx.parsedBody);
+					continue;
+				}
+				const err = normalizeHttpError(rawResponse, resCtx.parsedBody);
+				await this.pluginManager.onError(err, ctx);
+				throw err;
+			}
+			return {
+				data: resCtx.parsedBody,
+				response: resCtx.response,
+				request: resCtx.request,
+				meta: resCtx.meta
+			};
+		}
+		throw lastError;
+	}
+	/** Sends a GET request. The response body is not cached unless a cache plugin is registered. */
+	get(path, options) {
+		return this.request(path, {
+			...options,
+			method: "GET"
+		});
+	}
+	post(path, body, options) {
+		return this.request(path, {
+			...options,
+			method: "POST",
+			body
+		});
+	}
+	put(path, body, options) {
+		return this.request(path, {
+			...options,
+			method: "PUT",
+			body
+		});
+	}
+	patch(path, body, options) {
+		return this.request(path, {
+			...options,
+			method: "PATCH",
+			body
+		});
+	}
+	delete(path, options) {
+		return this.request(path, {
+			...options,
+			method: "DELETE"
+		});
+	}
+	head(path, options) {
+		return this.request(path, {
+			...options,
+			method: "HEAD"
+		});
+	}
+	options(path, options) {
+		return this.request(path, {
+			...options,
+			method: "OPTIONS"
+		});
+	}
+	/**
+	* Executes a GraphQL query or mutation against a single endpoint path.
+	*
+	* The request is a `POST` with `content-type: application/json` carrying
+	* `{ query, variables?, operationName? }` as the body. It flows through
+	* the full plugin lifecycle (beforeRequest → transport → afterResponse →
+	* onError) and respects all retry configuration, exactly like REST calls.
+	*
+	* **Error handling:**
+	* - HTTP-level failures (429, 500, timeout) throw the same error classes
+	*   as REST requests (`RateLimitError`, `ApiError`, `TimeoutError`).
+	* - A successful HTTP 200 that contains a non-empty `errors` array throws
+	*   {@link GraphQLRequestError}, which extends `ApiError`.
+	*
+	* **Caching:**
+	* The cache plugin skips `POST` requests by default. Pass an explicit
+	* `cacheKey` in options to opt a specific operation into caching.
+	*
+	* @typeParam TData - Shape of the `data` field in the GraphQL response.
+	* @typeParam TVariables - Shape of the `variables` object. Defaults to
+	*   `Record<string, unknown>`.
+	* @param path - Endpoint path, e.g. `"/graphql"`. Appended to `baseUrl`.
+	* @param options - Query document, variables, and optional per-request overrides.
+	* @returns The `data` field from the GraphQL response envelope.
+	* @throws {@link GraphQLRequestError} when `response.errors` is non-empty.
+	* @throws {@link ApiError} / {@link RateLimitError} / {@link TimeoutError} on
+	*   HTTP-level failures.
+	*
+	* @example
+	* ```ts
+	* const data = await client.graphql<GetUserQuery, GetUserQueryVariables>(
+	*   "/graphql",
+	*   { query: GET_USER, variables: { id: "123" } },
+	* );
+	* ```
+	*/
+	async graphql(path, options) {
+		const { query, variables, operationName, headers, timeoutMs, cacheKey, tags } = options;
+		const envelope = await this.request(path, {
+			method: "POST",
+			body: {
+				query,
+				...variables !== void 0 && { variables },
+				...operationName !== void 0 && { operationName }
+			},
+			headers,
+			timeoutMs,
+			cacheKey,
+			tags
+		});
+		if (envelope.errors && envelope.errors.length > 0) throw new GraphQLRequestError(envelope.errors, envelope.data);
+		return envelope.data;
+	}
+	async waitForRetry(attempt, baseDelay, useJitter) {
+		const exponential = baseDelay * 2 ** attempt;
+		const ms = useJitter ? exponential * (.5 + Math.random() * .5) : exponential;
+		await sleep(Math.round(ms));
+	}
+};
+async function parseBody(response) {
+	if (response.status === 204 || response.status === 205) return void 0;
+	if (response.headers.get("content-length") === "0") return void 0;
+	const text = await response.text();
+	if (!text) return void 0;
+	if ((response.headers.get("content-type") ?? "").includes("application/json")) return JSON.parse(text);
+	return text;
+}
+function normalizeHttpError(response, body) {
+	if (response.status === 429) return new RateLimitError(readRetryAfterMs(response), body);
+	return new ApiError(`Request failed with status ${response.status}`, response.status, body);
+}
+function readRetryAfterMs(response) {
+	const raw = response.headers.get("retry-after");
+	if (!raw) return void 0;
+	const seconds = Number(raw);
+	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+	const date = Date.parse(raw);
+	if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+}
+//#endregion
+//#region src/client/createClient.ts
+/**
+* Factory function that creates a {@link BaseHttpClient} from the given
+* config. Prefer this over `new BaseHttpClient(config)` in application code
+* so that the concrete class stays an implementation detail.
+*
+* @example
+* ```ts
+* const client = createClient({
+*   baseUrl: "https://api.example.com/v1",
+*   defaultHeaders: { "x-api-key": "secret" },
+*   retry: { maxAttempts: 3, delayMs: 300 },
+*   plugins: [createLoggerPlugin(), createCachePlugin({ ttlMs: 60_000 })],
+* });
+* ```
+*/
+function createClient(config) {
+	return new BaseHttpClient(config);
+}
+//#endregion
+//#region src/plugins/auth/authPlugin.ts
+/**
+* Adds an auth token header before each request. The token can be static or
+* loaded asynchronously per request, which covers wrappers with refreshable
+* access tokens.
+*/
+function createAuthPlugin(input) {
+	const options = normalizeOptions(input);
+	const headerName = (options.headerName ?? "authorization").toLowerCase();
+	const scheme = options.scheme === void 0 ? "Bearer" : options.scheme;
+	return {
+		name: "auth",
+		priority: 2,
+		async beforeRequest(ctx) {
+			const token = await options.getToken();
+			if (!token) return ctx;
+			return {
+				...ctx,
+				headers: {
+					...ctx.headers,
+					[headerName]: scheme ? `${scheme} ${token}` : token
+				}
+			};
+		}
+	};
+}
+function normalizeOptions(input) {
+	if (typeof input === "string") return { getToken: () => input };
+	if (typeof input === "function") return { getToken: input };
+	return input;
+}
+//#endregion
+//#region src/plugins/cache/memoryStore.ts
+var MemoryStore = class {
+	constructor() {
+		_defineProperty(this, "store", /* @__PURE__ */ new Map());
+	}
+	get(key) {
+		const entry = this.store.get(key);
+		if (!entry) return void 0;
+		if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
+			this.store.delete(key);
+			return;
+		}
+		return entry.value;
+	}
+	set(key, value, ttlMs) {
+		this.store.set(key, {
+			value,
+			expiresAt: ttlMs != null ? Date.now() + ttlMs : null
+		});
+	}
+	delete(key) {
+		this.store.delete(key);
+	}
+	clear() {
+		this.store.clear();
+	}
+};
+//#endregion
+//#region src/plugins/cache/cachePlugin.ts
+const DEFAULT_CACHEABLE_METHODS = ["GET"];
+const CACHE_HIT_META_KEY = "cache.hit";
+function createCachePlugin(options = {}) {
+	const store = options.store ?? new MemoryStore();
+	const ttlMs = options.ttlMs;
+	const methods = options.methods ?? [...DEFAULT_CACHEABLE_METHODS];
+	const generateKey = options.generateKey ?? defaultCacheKey;
+	const tagIndex = /* @__PURE__ */ new Map();
+	return {
+		name: "cache",
+		priority: 20,
+		async beforeRequest(ctx) {
+			if (!methods.includes(ctx.method)) return ctx;
+			const key = ctx.cacheKey ?? generateKey(ctx);
+			const cached = await store.get(key);
+			if (cached !== void 0) {
+				const syntheticResponse = new Response(JSON.stringify(cached), {
+					status: 200,
+					headers: { "content-type": "application/json" }
+				});
+				return {
+					...ctx,
+					meta: {
+						...ctx.meta,
+						[CACHE_HIT_META_KEY]: {
+							key,
+							data: cached
+						}
+					},
+					syntheticResponse
+				};
+			}
+			return {
+				...ctx,
+				meta: {
+					...ctx.meta,
+					"cache.key": key
+				}
+			};
+		},
+		async afterResponse(ctx) {
+			const hit = ctx.request.meta[CACHE_HIT_META_KEY];
+			if (hit) return {
+				...ctx,
+				parsedBody: hit.data,
+				meta: {
+					...ctx.meta,
+					"cache.served": true
+				}
+			};
+			const key = ctx.request.meta["cache.key"];
+			if (key && methods.includes(ctx.request.method) && ctx.response.ok) {
+				await store.set(key, ctx.parsedBody, ttlMs);
+				ctx.meta["cache.stored"] = true;
+				for (const tag of ctx.request.tags ?? []) {
+					if (!tagIndex.has(tag)) tagIndex.set(tag, /* @__PURE__ */ new Set());
+					tagIndex.get(tag)?.add(key);
+				}
+			}
+			return ctx;
+		},
+		async invalidate(key) {
+			await store.delete(key);
+			for (const keys of tagIndex.values()) keys.delete(key);
+		},
+		async invalidateByTag(tag) {
+			const keys = tagIndex.get(tag);
+			if (!keys || keys.size === 0) return;
+			for (const key of keys) {
+				await store.delete(key);
+				for (const otherKeys of tagIndex.values()) otherKeys.delete(key);
+			}
+			tagIndex.delete(tag);
+		}
+	};
+}
+function defaultCacheKey(ctx) {
+	const queryStr = ctx.query ? new URLSearchParams(Object.fromEntries(Object.entries(ctx.query).filter(([, v]) => v !== void 0).map(([k, v]) => [k, String(v)]))).toString() : "";
+	return `${ctx.method}:${ctx.url}${queryStr ? `?${queryStr}` : ""}`;
+}
+//#endregion
+//#region src/plugins/logger/loggerPlugin.ts
+/**
+* Creates a plugin that logs request start, response status, and errors.
+*
+* Log lines are prefixed with `[api-core]` and include the HTTP method, URL,
+* attempt number (on `beforeRequest`), and status code (on `afterResponse`).
+*
+* Priority `10` means it runs _after_ auth or header-mutation plugins
+* (priority < 10) so the logged URL and headers reflect the final request,
+* but _before_ the cache plugin (priority `20`) so cache hits are still
+* visible in the log.
+*
+* @example
+* ```ts
+* createClient({
+*   baseUrl: "https://api.example.com",
+*   plugins: [createLoggerPlugin({ logRequest: true, logResponse: true })],
+* });
+* ```
+*/
+function createLoggerPlugin(options = {}) {
+	const { logRequest = true, logResponse = true, logError = true, logger = console } = options;
+	return {
+		name: "logger",
+		priority: 10,
+		beforeRequest(ctx) {
+			if (logRequest) logger.info(`[api-core] --> ${ctx.method} ${ctx.url}`, {
+				attempt: ctx.attempt,
+				body: ctx.body
+			});
+			return ctx;
+		},
+		afterResponse(ctx) {
+			if (logResponse) logger.info(`[api-core] <-- ${ctx.response.status} ${ctx.request.method} ${ctx.request.url}`);
+			return ctx;
+		},
+		onError(error, ctx) {
+			if (logError) logger.error(`[api-core] ERR ${ctx.method} ${ctx.url}`, error);
+		}
+	};
+}
+//#endregion
+//#region src/plugins/rateLimit/rateLimitPlugin.ts
+const RELEASE_META_KEY = "rateLimit.release";
+/**
+* Throttles request starts before they reach the transport. Supports
+* concurrency, minimum spacing, and fixed-window request budgets.
+*/
+function createRateLimitPlugin(options = {}) {
+	const maxConcurrent = options.maxConcurrent ?? Number.POSITIVE_INFINITY;
+	const minTimeMs = options.minTimeMs ?? 0;
+	const maxRequestsPerInterval = options.maxRequestsPerInterval;
+	const intervalMs = options.intervalMs;
+	if (maxConcurrent <= 0) throw new Error("maxConcurrent must be greater than 0");
+	if (minTimeMs < 0) throw new Error("minTimeMs must be greater than or equal to 0");
+	if ((maxRequestsPerInterval !== void 0 || intervalMs !== void 0) && (!maxRequestsPerInterval || maxRequestsPerInterval <= 0 || !intervalMs || intervalMs <= 0)) throw new Error("maxRequestsPerInterval and intervalMs must both be greater than 0");
+	const queue = [];
+	const starts = [];
+	let active = 0;
+	let lastStartAt = 0;
+	let timer;
+	const processQueue = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+		while (queue.length > 0) {
+			const now = Date.now();
+			pruneStarts(now);
+			if (active >= maxConcurrent) return;
+			const waitMs = getWaitMs(now);
+			if (waitMs > 0) {
+				timer = setTimeout(processQueue, waitMs);
+				return;
+			}
+			const item = queue.shift();
+			if (!item) return;
+			active++;
+			lastStartAt = now;
+			starts.push(now);
+			let released = false;
+			item.resolve(() => {
+				if (released) return;
+				released = true;
+				active--;
+				processQueue();
+			});
+		}
+	};
+	const acquire = () => new Promise((resolve) => {
+		queue.push({ resolve });
+		processQueue();
+	});
+	const release = (ctx) => {
+		const releaseFn = ctx.meta[RELEASE_META_KEY];
+		if (!releaseFn) return;
+		delete ctx.meta[RELEASE_META_KEY];
+		releaseFn();
+	};
+	const pruneStarts = (now) => {
+		if (!intervalMs) return;
+		while (starts.length > 0 && now - (starts[0] ?? 0) >= intervalMs) starts.shift();
+	};
+	const getWaitMs = (now) => {
+		const spacingWait = Math.max(0, lastStartAt + minTimeMs - now);
+		if (!maxRequestsPerInterval || !intervalMs) return spacingWait;
+		if (starts.length < maxRequestsPerInterval) return spacingWait;
+		const oldest = starts[0] ?? now;
+		const intervalWait = Math.max(0, oldest + intervalMs - now);
+		return Math.max(spacingWait, intervalWait);
+	};
+	return {
+		name: "rate-limit",
+		priority: 1,
+		async beforeRequest(ctx) {
+			const releaseFn = await acquire();
+			return {
+				...ctx,
+				meta: {
+					...ctx.meta,
+					[RELEASE_META_KEY]: releaseFn
+				}
+			};
+		},
+		afterResponse(ctx) {
+			release(ctx.request);
+			return ctx;
+		},
+		onError(_error, ctx) {
+			release(ctx);
+		}
+	};
+}
+//#endregion
+//#region src/plugins/retry/retryPlugin.ts
+/**
+* Writes retry configuration into request context meta so the
+* BaseHttpClient retry loop can read it. Use this when you need
+* per-request retry overrides rather than global ClientConfig.retry.
+*/
+function createRetryPlugin(options = {}) {
+	return {
+		name: "retry",
+		priority: 5,
+		beforeRequest(ctx) {
+			if (options.maxAttempts !== void 0) ctx.meta["retry.maxAttempts"] = options.maxAttempts;
+			if (options.delayMs !== void 0) ctx.meta["retry.delayMs"] = options.delayMs;
+			if (options.jitter !== void 0) ctx.meta["retry.jitter"] = options.jitter;
+			if (options.retriableStatusCodes !== void 0) ctx.meta["retry.retriableStatusCodes"] = options.retriableStatusCodes;
+			return ctx;
+		}
+	};
+}
+//#endregion
+//#region src/plugins/timeout/timeoutPlugin.ts
+/**
+* Sets `ctx.timeoutMs` on every request so all requests made by this client
+* abort after the configured duration. The actual abort and
+* {@link TimeoutError} are handled by {@link fetchTransport}.
+*
+* Priority `1` ensures the timeout is stamped before any other plugin (e.g.
+* logger, cache) runs — plugins that read `ctx.timeoutMs` will always see it.
+* Use a `beforeRequest` hook with a lower priority to override per-request.
+*
+* Prefer `ClientConfig.timeoutMs` for a static global timeout. Use this
+* plugin when you need to set or change the timeout through the plugin
+* pipeline (e.g. from environment config loaded asynchronously in `setup`).
+*
+* @example
+* ```ts
+* createClient({
+*   baseUrl: "https://api.example.com",
+*   plugins: [createTimeoutPlugin({ timeoutMs: 5_000 })],
+* });
+* ```
+*/
+function createTimeoutPlugin(options) {
+	return {
+		name: "timeout",
+		priority: 1,
+		beforeRequest(ctx) {
+			return {
+				...ctx,
+				timeoutMs: options.timeoutMs
+			};
+		}
+	};
+}
+//#endregion
+exports.ApiError = ApiError;
+exports.BaseHttpClient = BaseHttpClient;
+exports.GraphQLRequestError = GraphQLRequestError;
+exports.MemoryStore = MemoryStore;
+exports.PluginManager = PluginManager;
+exports.RateLimitError = RateLimitError;
+exports.TimeoutError = TimeoutError;
+exports.buildUrl = buildUrl;
+exports.createAuthPlugin = createAuthPlugin;
+exports.createCachePlugin = createCachePlugin;
+exports.createClient = createClient;
+exports.createFetchTransport = createFetchTransport;
+exports.createLoggerPlugin = createLoggerPlugin;
+exports.createRateLimitPlugin = createRateLimitPlugin;
+exports.createRetryPlugin = createRetryPlugin;
+exports.createTimeoutPlugin = createTimeoutPlugin;
+exports.fetchTransport = fetchTransport;
+exports.isPlainObject = isPlainObject;
+exports.mergeHeaders = mergeHeaders;
+exports.resolveUrl = resolveUrl;
+exports.sleep = sleep;
+
+//# sourceMappingURL=index.cjs.map