@radiusplus/api-sdk-v2 0.5.0

package/src/_generated/.kubb/client.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = exports.client = exports.defaultQuerySerializer = exports.defaultBodySerializer = exports.ResponseError = void 0;
+exports.createInterceptorStack = createInterceptorStack;
+exports.resolveAuth = resolveAuth;
+exports.createClientCore = createClientCore;
+/**
+ * Thrown for responses outside the 2xx range, so a resolved call always means success. The parsed
+ * error body and the native request/response stay reachable on the error.
+ */
+class ResponseError extends Error {
+    data;
+    status;
+    statusText;
+    request;
+    response;
+    constructor(config) {
+        super(`Request failed with status ${config.status}${config.statusText ? ` ${config.statusText}` : ''}`);
+        this.name = 'ResponseError';
+        this.data = config.data;
+        this.status = config.status;
+        this.statusText = config.statusText;
+        this.request = config.request;
+        this.response = config.response;
+    }
+}
+exports.ResponseError = ResponseError;
+function isFormBody(body) {
+    return (body instanceof FormData ||
+        body instanceof URLSearchParams ||
+        body instanceof Blob ||
+        body instanceof ArrayBuffer ||
+        ArrayBuffer.isView(body) ||
+        typeof body === 'string');
+}
+function appendFormDataValue(formData, key, value) {
+    if (value === undefined || value === null)
+        return;
+    if (value instanceof Blob)
+        formData.append(key, value);
+    else if (value instanceof Date)
+        formData.append(key, value.toISOString());
+    else if (typeof value === 'object')
+        formData.append(key, JSON.stringify(value));
+    else
+        formData.append(key, String(value));
+}
+/**
+ * Default body serializer: passes binary/form bodies through and JSON-serializes everything else.
+ * For `multipart/form-data` plain objects become `FormData` and for
+ * `application/x-www-form-urlencoded` they become `URLSearchParams`.
+ */
+const defaultBodySerializer = (body, contentType) => {
+    if (body === undefined || body === null)
+        return undefined;
+    if (isFormBody(body))
+        return body;
+    if (contentType?.includes('multipart/form-data')) {
+        const formData = new FormData();
+        for (const [key, value] of Object.entries(body)) {
+            if (Array.isArray(value))
+                for (const item of value)
+                    appendFormDataValue(formData, key, item);
+            else
+                appendFormDataValue(formData, key, value);
+        }
+        return formData;
+    }
+    if (contentType?.includes('application/x-www-form-urlencoded')) {
+        return new URLSearchParams(body);
+    }
+    return JSON.stringify(body);
+};
+exports.defaultBodySerializer = defaultBodySerializer;
+function appendQueryValue(search, key, value) {
+    if (value === undefined || value === null)
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            appendQueryValue(search, key, item);
+        return;
+    }
+    if (typeof value === 'object') {
+        for (const [prop, propValue] of Object.entries(value)) {
+            appendQueryValue(search, `${key}[${prop}]`, propValue);
+        }
+        return;
+    }
+    search.append(key, String(value));
+}
+/**
+ * Default query serializer: arrays explode into repeated keys and nested objects use the
+ * `deepObject` style (`key[prop]=value`).
+ */
+const defaultQuerySerializer = (params) => {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        appendQueryValue(search, key, value);
+    }
+    return search.toString();
+};
+exports.defaultQuerySerializer = defaultQuerySerializer;
+function serializeHeaders(headers) {
+    if (!headers)
+        return {};
+    const entries = Array.isArray(headers) ? headers : Object.entries(headers);
+    const result = {};
+    for (const [key, value] of entries) {
+        if (value === undefined || value === null)
+            continue;
+        result[key] = typeof value === 'string' ? value : typeof value === 'object' ? JSON.stringify(value) : String(value);
+    }
+    return result;
+}
+function mergeHeaders(...sources) {
+    return Object.assign({}, ...sources.map(serializeHeaders));
+}
+/**
+ * Joins the base and request URL parts, interpolates `{param}` segments from the path params
+ * (URL-encoded), and appends the serialized query. Shared by the send path and `getUrl` so both
+ * produce an identical URL.
+ */
+function serializeUrl(parts, pathParams, search) {
+    const path = parts
+        .filter(Boolean)
+        .join('')
+        .replace(/\{([^{}]+)\}/g, (_, key) => encodeURIComponent(String(pathParams[key] ?? '')));
+    return path + (search ? `?${search}` : '');
+}
+/**
+ * Creates a transport-agnostic interceptor channel. Interceptors run in registration order; `eject`
+ * removes one by id and `update` swaps its function in place without reordering.
+ */
+function createInterceptorStack() {
+    let entries = [];
+    let counter = 0;
+    return {
+        use(fn) {
+            const id = ++counter;
+            entries.push({ id, fn });
+            return id;
+        },
+        eject(id) {
+            entries = entries.filter((entry) => entry.id !== id);
+        },
+        update(id, fn) {
+            const entry = entries.find((item) => item.id === id);
+            if (entry)
+                entry.fn = fn;
+        },
+        async run(value) {
+            let result = value;
+            for (const entry of entries) {
+                result = await entry.fn(result);
+            }
+            return result;
+        },
+    };
+}
+/**
+ * Walks the per-operation security in order and places the first resolved token on the request,
+ * mutating `headers` / `query` in place. Bearer (and oauth2 / openIdConnect) tokens become a `Bearer`
+ * Authorization header, basic credentials are base64-encoded, and an apiKey is placed under its
+ * `name` in the header, query, or cookie.
+ */
+async function resolveAuth(params) {
+    const { security, auth, headers, query } = params;
+    if (!security?.length || auth === undefined)
+        return;
+    for (const scheme of security) {
+        const token = typeof auth === 'function' ? await auth(scheme) : auth;
+        if (token === undefined)
+            continue;
+        if (scheme.type === 'apiKey') {
+            const name = scheme.name ?? 'Authorization';
+            if (scheme.in === 'query')
+                query[name] = token;
+            else if (scheme.in === 'cookie')
+                headers.Cookie = [headers.Cookie, `${name}=${token}`].filter(Boolean).join('; ');
+            else
+                headers[name] = token;
+        }
+        else {
+            headers.Authorization = scheme.scheme === 'basic' ? `Basic ${btoa(token)}` : `Bearer ${token}`;
+        }
+        return;
+    }
+}
+async function runParser(parser, value) {
+    if (!parser)
+        return value;
+    return (await parser(value));
+}
+/**
+ * Builds the shared client core bound to a transport. Each plugin calls this with its
+ * `defaultTransport` and exports the resulting instance as `client`, plus a `createClient` factory.
+ */
+function createClientCore(options) {
+    const { defaultTransport, ...initialConfig } = options;
+    let config = { ...initialConfig };
+    const interceptors = {
+        request: createInterceptorStack(),
+        response: createInterceptorStack(),
+        error: createInterceptorStack(),
+    };
+    const client = (async (requestConfig) => {
+        const transport = requestConfig.transport ?? config.transport ?? defaultTransport;
+        const querySerializer = requestConfig.querySerializer ?? config.querySerializer ?? exports.defaultQuerySerializer;
+        const bodySerializer = requestConfig.bodySerializer ?? config.bodySerializer ?? exports.defaultBodySerializer;
+        const headers = mergeHeaders(config.headers, requestConfig.headers);
+        const requestContentType = requestConfig.contentType ?? headers['Content-Type'] ?? headers['content-type'];
+        const query = { ...(requestConfig.query ?? requestConfig.params) };
+        await resolveAuth({
+            security: requestConfig.security,
+            auth: requestConfig.auth ?? config.auth,
+            headers,
+            query,
+        });
+        const rawBody = requestConfig.body;
+        const validatedBody = await runParser(requestConfig.parser?.request, rawBody);
+        const body = bodySerializer(validatedBody, requestContentType);
+        // A FormData body must keep its Content-Type unset so the runtime appends the multipart boundary.
+        if (body instanceof FormData) {
+            delete headers['Content-Type'];
+            delete headers['content-type'];
+        }
+        else if (requestConfig.contentType) {
+            headers['Content-Type'] = requestConfig.contentType;
+        }
+        const url = serializeUrl([config.baseURL, requestConfig.baseURL, requestConfig.url], requestConfig.path ?? {}, querySerializer(query));
+        const options = config.options || requestConfig.options ? { ...config.options, ...requestConfig.options } : undefined;
+        let resolvedRequest = {
+            url,
+            method: (requestConfig.method ?? 'GET').toUpperCase(),
+            headers,
+            body,
+            signal: requestConfig.signal,
+            credentials: requestConfig.credentials,
+            options,
+            responseType: requestConfig.responseType,
+        };
+        resolvedRequest = await interceptors.request.run(resolvedRequest);
+        let result = await transport(resolvedRequest);
+        result = await interceptors.response.run(result);
+        const isSuccess = result.status >= 200 && result.status < 300;
+        const throwOnError = requestConfig.throwOnError ?? config.throwOnError ?? true;
+        if (!isSuccess && throwOnError) {
+            const error = new ResponseError({
+                data: result.data,
+                status: result.status,
+                statusText: result.statusText,
+                request: result.request,
+                response: result.response,
+            });
+            await interceptors.error.run(error);
+            throw error;
+        }
+        const data = isSuccess ? await runParser(requestConfig.parser?.response, result.data) : undefined;
+        const error = isSuccess ? undefined : await runParser(requestConfig.parser?.error, result.data);
+        return {
+            status: result.status,
+            data,
+            error,
+            request: result.request,
+            response: result.response,
+        };
+    });
+    client.getConfig = () => config;
+    client.setConfig = (next) => {
+        config = { ...config, ...next, headers: { ...serializeHeaders(config.headers), ...serializeHeaders(next.headers) } };
+        return config;
+    };
+    client.getUrl = (requestConfig) => {
+        const querySerializer = requestConfig.querySerializer ?? config.querySerializer ?? exports.defaultQuerySerializer;
+        const query = { ...(requestConfig.query ?? requestConfig.params) };
+        return serializeUrl([config.baseURL, requestConfig.baseURL, requestConfig.url], requestConfig.path ?? {}, querySerializer(query));
+    };
+    client.interceptors = interceptors;
+    client.createClient = (next) => createClientCore({ defaultTransport, ...config, ...next });
+    return client;
+}
+/**
+ * Picks a `responseType` from a `Content-Type` header, or `undefined` when it is not recognized.
+ */
+function detectResponseType(contentType) {
+    if (!contentType)
+        return undefined;
+    if (contentType.includes('application/json') || contentType.includes('text/json'))
+        return 'json';
+    if (contentType.includes('text/'))
+        return 'text';
+    if (contentType.includes('image/') || contentType.includes('application/octet-stream'))
+        return 'blob';
+    return undefined;
+}
+/**
+ * Parses a `fetch` response body. Empty responses (204/205/304 or no body) resolve to `undefined`.
+ * An explicit `responseType`, or one detected from the `Content-Type` header, forces the matching
+ * `Response` method; otherwise the body is read as text and `JSON.parse`d, falling back to raw text.
+ */
+async function parseResponse(response, responseType) {
+    if (response.status === 204 || response.status === 205 || response.status === 304 || !response.body) {
+        return undefined;
+    }
+    switch (responseType ?? detectResponseType(response.headers.get('Content-Type'))) {
+        case 'text':
+        case 'document':
+            return response.text();
+        case 'blob':
+            return response.blob();
+        case 'arraybuffer':
+            return response.arrayBuffer();
+        case 'stream':
+            return response.body ?? undefined;
+        case 'json': {
+            // An empty body with a JSON content-type would make response.json() throw; treat it as no data.
+            const body = await response.text();
+            return body ? JSON.parse(body) : undefined;
+        }
+    }
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+/**
+ * The default transport: builds a native `Request` from the resolved request, sends it through
+ * `globalThis.fetch`, and returns the parsed body alongside the native request/response objects.
+ */
+const defaultTransport = async (request) => {
+    const init = {
+        ...request.options, // cache, mode, redirect, keepalive, duplex, next, …
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: request.signal,
+    };
+    if (request.credentials)
+        init.credentials = request.credentials;
+    const nativeRequest = new Request(request.url, init);
+    const response = await globalThis.fetch(nativeRequest);
+    const data = await parseResponse(response, request.responseType);
+    return {
+        data,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        request: nativeRequest,
+        response,
+    };
+};
+exports.client = createClientCore({ defaultTransport });
+const createClient = (config) => exports.client.createClient(config);
+exports.createClient = createClient;
+exports.client.setConfig({ baseURL: "https://api.radiusplus.com/v2" });