@domu-ai/kiban-sdk 1.72.0

package/shared/fetcher.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * Custom HTTP fetcher for the Kiban API client.
+ *
+ * Supports Orval's mutator signature (`customFetcher(url, options)`) while
+ * preserving auth-token injection and robust JSON/non-JSON response parsing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAuthToken = setAuthToken;
+exports.clearAuthToken = clearAuthToken;
+exports.setApiBaseUrl = setApiBaseUrl;
+exports.clearApiBaseUrl = clearApiBaseUrl;
+exports.getApiBaseUrl = getApiBaseUrl;
+exports.isSuccessResponse = isSuccessResponse;
+exports.ensureSuccess = ensureSuccess;
+exports.getSuccessData = getSuccessData;
+exports.customFetcher = customFetcher;
+const DEFAULT_BASE_URL = "http://localhost:3000";
+const ENV_BASE_URL = typeof process !== "undefined"
+    ? process.env?.SDK_BASE_URL ?? process.env?.API_BASE_URL
+    : undefined;
+let baseUrlOverride = null;
+// Auth token getter - configured via setAuthToken()
+let authTokenGetter = null;
+/**
+ * Set the authentication token getter
+ *
+ * @example
+ * // After user login:
+ * setAuthToken(() => localStorage.getItem('authToken'));
+ *
+ * // With Clerk:
+ * setAuthToken(() => clerk.session?.getToken() ?? null);
+ */
+function setAuthToken(getter) {
+    authTokenGetter = getter;
+}
+/**
+ * Clear the authentication token (call on logout)
+ */
+function clearAuthToken() {
+    authTokenGetter = null;
+}
+function normalizeBaseUrl(url) {
+    return url.trim().replace(/\/+$/, "");
+}
+/**
+ * Set API base URL at runtime.
+ *
+ * @example
+ * setApiBaseUrl("https://api.example.com");
+ */
+function setApiBaseUrl(url) {
+    if (!url || !url.trim()) {
+        throw new Error("API base URL cannot be empty");
+    }
+    baseUrlOverride = normalizeBaseUrl(url);
+}
+/**
+ * Clear runtime API base URL override and fall back to env/default.
+ */
+function clearApiBaseUrl() {
+    baseUrlOverride = null;
+}
+/**
+ * Get the effective API base URL used by the fetcher.
+ */
+function getApiBaseUrl() {
+    return baseUrlOverride ?? ENV_BASE_URL ?? DEFAULT_BASE_URL;
+}
+function isAbsoluteUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+function resolveUrl(url, params) {
+    const effectiveBaseUrl = getApiBaseUrl();
+    const absolute = isAbsoluteUrl(url);
+    const baseForRelative = effectiveBaseUrl.endsWith("/")
+        ? effectiveBaseUrl
+        : `${effectiveBaseUrl}/`;
+    const normalizedRelativeUrl = url.startsWith("/") ? url.slice(1) : url;
+    const urlObj = absolute
+        ? new URL(url)
+        : new URL(normalizedRelativeUrl, baseForRelative);
+    // If the generated client still emits localhost absolute URLs, remap origin.
+    if (absolute && urlObj.origin === DEFAULT_BASE_URL) {
+        const baseUrlObj = new URL(effectiveBaseUrl);
+        urlObj.protocol = baseUrlObj.protocol;
+        urlObj.host = baseUrlObj.host;
+    }
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined && value !== null) {
+                urlObj.searchParams.set(key, String(value));
+            }
+        }
+    }
+    return urlObj.toString();
+}
+function withAuthHeader(headers) {
+    const requestHeaders = new Headers(headers);
+    const token = authTokenGetter?.();
+    if (token) {
+        requestHeaders.set("Authorization", `Bearer ${token}`);
+    }
+    return requestHeaders;
+}
+function serializeErrorPayload(data) {
+    try {
+        return JSON.stringify(data);
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
+/**
+ * Type guard for SDK response unions that discriminates 2xx responses.
+ */
+function isSuccessResponse(response) {
+    return response.status >= 200 && response.status < 300;
+}
+/**
+ * Assert an SDK response is successful (2xx), otherwise throw with payload context.
+ */
+function ensureSuccess(response, operationName = "request") {
+    if (isSuccessResponse(response)) {
+        return;
+    }
+    throw new Error(`[${operationName}] failed with status=${response.status} payload=${serializeErrorPayload(response.data)}`);
+}
+/**
+ * Return the success payload from an SDK response or throw for non-2xx responses.
+ */
+function getSuccessData(response, operationName = "request") {
+    ensureSuccess(response, operationName);
+    return response.data;
+}
+async function parseResponseBody(response) {
+    const text = await response.text();
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+        return text ? JSON.parse(text) : {};
+    }
+    return {
+        message: text || `HTTP ${response.status}`,
+        code: "NON_JSON_RESPONSE",
+    };
+}
+/**
+ * Custom fetcher used by all generated API functions.
+ */
+async function customFetcher(urlOrOptions, maybeOptions) {
+    if (typeof urlOrOptions === "string") {
+        const requestHeaders = withAuthHeader(maybeOptions?.headers);
+        const response = await fetch(resolveUrl(urlOrOptions), {
+            ...maybeOptions,
+            headers: requestHeaders,
+        });
+        const responseData = await parseResponseBody(response);
+        const envelope = {
+            data: responseData,
+            status: response.status,
+            headers: response.headers,
+        };
+        return envelope;
+    }
+    const { url, method, headers, params, data, signal } = urlOrOptions;
+    const requestHeaders = withAuthHeader(headers);
+    if (data !== undefined && !requestHeaders.has("Content-Type")) {
+        requestHeaders.set("Content-Type", "application/json");
+    }
+    const response = await fetch(resolveUrl(url, params), {
+        method,
+        headers: requestHeaders,
+        body: data !== undefined ? JSON.stringify(data) : undefined,
+        signal,
+    });
+    return {
+        data: await parseResponseBody(response),
+        status: response.status,
+        headers: response.headers,
+    };
+}
+exports.default = customFetcher;