@kontent-ai/core-sdk 12.0.0-preview.8 → 12.0.0-preview.9

package/README.md

@@ -25,13 +25,13 @@ These implementations are designed to work out-of-the-box but are also fully cus
 The `HttpService` comes with several built-in capabilities, such as:
 
 - **Retry policies**
-- **Request validation**
+- **Request parsing and validation** (URL parsing, body serialization)
 - **Automatic header and tracking management**
 - **Kontent.ai-specific error extraction**
 
 To customize these behaviors entirely, you can replace the `HttpService` with your own implementation.
 
-However, if your goal is to retain the core features (e.g., retry policies, request validation) and only swap out the underlying HTTP client, you can do so by supplying a custom `HttpAdapter` to the `getDefaultHttpService` method.
+However, if your goal is to retain the core features (e.g., retry policies, request parsing) and only swap out the underlying HTTP client, you can do so by supplying a custom `HttpAdapter` to the `getDefaultHttpService` method.
 
 ---
 
@@ -40,7 +40,7 @@ However, if your goal is to retain the core features (e.g., retry policies, requ
 Below is an example demonstrating how to provide your own HTTP client by implementing a custom `HttpAdapter`:
 
 ```typescript
-const httpService = await getDefaultHttpService({
+const httpService = getDefaultHttpService({
   adapter: {
     requestAsync: async (options) => {
       // Execute the request using your custom HTTP client
@@ -49,6 +49,7 @@ const httpService = await getDefaultHttpService({
         responseHeaders: <arrayOfHeaders>,
         status: <statusCode>,
         statusText: <statusText>,
+        url: options.url,
         toJsonAsync: async () => <responseInJson>,
         toBlobAsync: async () => <responseInBlob>,
       };

package/dist/http/http.adapter.js

@@ -1,4 +1,4 @@
-import { toFetchHeaders, toSdkHeaders } from "../utils/header.utils.js";
+import { isApplicationJsonResponseType, toFetchHeaders, toSdkHeaders } from "../utils/header.utils.js";
 export function getDefaultHttpAdapter() {
     return {
         requestAsync: async (options) => {
@@ -7,19 +7,16 @@ export function getDefaultHttpAdapter() {
                 headers: toFetchHeaders(options.requestHeaders ?? []),
                 body: options.body,
             });
-            const sdkResponseHeaders = toSdkHeaders(response.headers);
+            const sdkHeaders = toSdkHeaders(response.headers);
             return {
                 isValidResponse: response.ok,
-                responseHeaders: sdkResponseHeaders,
+                responseHeaders: sdkHeaders,
                 status: response.status,
                 statusText: response.statusText,
+                url: options.url,
                 toBlobAsync: async () => await response.blob(),
                 toJsonAsync: async () => {
-                    const contentTypeResponseHeader = sdkResponseHeaders
-                        .find((m) => m.name.toLowerCase() === "Content-Type".toLowerCase())
-                        ?.value.toLowerCase();
-                    if (contentTypeResponseHeader?.includes("application/json")) {
-                        // Includes instead of equal due to the fact that the header value can be 'application/json; charset=utf-8' or similar
+                    if (isApplicationJsonResponseType(sdkHeaders)) {
                         return (await response.json());
                     }
                     return null;

package/dist/http/http.adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"http.adapter.js","sourceRoot":"","sources":["../../lib/http/http.adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAGxE,MAAM,UAAU,qBAAqB;IACpC,OAAO;QACN,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;YAC/B,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE;gBACzC,MAAM,EAAE,OAAO,CAAC,MAAM;gBACtB,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC;gBACrD,IAAI,EAAE,OAAO,CAAC,IAAI;aAClB,CAAC,CAAC;YAEH,MAAM,kBAAkB,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAE1D,OAAO;gBACN,eAAe,EAAE,QAAQ,CAAC,EAAE;gBAC5B,eAAe,EAAE,kBAAkB;gBACnC,MAAM,EAAE,QAAQ,CAAC,MAAM;gBACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;gBAC/B,WAAW,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE;gBAC9C,WAAW,EAAE,KAAK,IAAI,EAAE;oBACvB,MAAM,yBAAyB,GAAG,kBAAkB;yBAClD,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,KAAM,cAA2C,CAAC,WAAW,EAAE,CAAC;wBACjG,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC;oBAEvB,IAAI,yBAAyB,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;wBAC7D,sHAAsH;wBACtH,OAAO,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAc,CAAC;oBAC7C,CAAC;oBAED,OAAO,IAAI,CAAC;gBACb,CAAC;aACD,CAAC;QACH,CAAC;KACD,CAAC;AACH,CAAC"}
+{"version":3,"file":"http.adapter.js","sourceRoot":"","sources":["../../lib/http/http.adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAGvG,MAAM,UAAU,qBAAqB;IACpC,OAAO;QACN,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;YAC/B,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE;gBACzC,MAAM,EAAE,OAAO,CAAC,MAAM;gBACtB,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC;gBACrD,IAAI,EAAE,OAAO,CAAC,IAAI;aAClB,CAAC,CAAC;YAEH,MAAM,UAAU,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAElD,OAAO;gBACN,eAAe,EAAE,QAAQ,CAAC,EAAE;gBAC5B,eAAe,EAAE,UAAU;gBAC3B,MAAM,EAAE,QAAQ,CAAC,MAAM;gBACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;gBAC/B,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,WAAW,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE;gBAC9C,WAAW,EAAE,KAAK,IAAI,EAAE;oBACvB,IAAI,6BAA6B,CAAC,UAAU,CAAC,EAAE,CAAC;wBAC/C,OAAO,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAc,CAAC;oBAC7C,CAAC;oBAED,OAAO,IAAI,CAAC;gBACb,CAAC;aACD,CAAC;QACH,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/http/http.models.d.ts

@@ -1,6 +1,8 @@
-import type { Header, HttpMethod, LiteralUnionNumber, RetryStrategyOptions } from "../models/core.models.js";
-import type { SdkError } from "../models/error.models.js";
-import type { JsonValue } from "../models/json.models.js";
+import type { Header, HttpMethod, RetryStrategyOptions } from "../models/core.models.js";
+import type { KontentSdkError } from "../models/error.models.js";
+import type { JsonObject, JsonValue } from "../models/json.models.js";
+import type { LiteralUnionNumber } from "../models/utility.models.js";
+import type { QueryResponse } from "../sdk/sdk-models.js";
 type Success<TData> = {
     readonly success: true;
     readonly response: TData;
@@ -9,7 +11,7 @@ type Success<TData> = {
 type Failure = {
     readonly success: false;
     readonly response?: never;
-    readonly error: SdkError;
+    readonly error: KontentSdkError;
 };
 export type HttpResult<TData> = Success<TData> | Failure;
 /**
@@ -31,17 +33,20 @@ export type DefaultHttpServiceConfig = {
      */
     readonly adapter?: HttpAdapter;
 };
-export type HttpResponse<TResponseData extends JsonValue | Blob, TBodyData extends JsonValue | Blob> = HttpResult<{
+export type ResponseData = JsonValue | Blob;
+export type RequestBody = JsonObject | Blob | null;
+export type BodyData = RequestBody;
+export type HttpResponse<TResponseData extends ResponseData, TRequestBody extends RequestBody> = HttpResult<{
     readonly data: TResponseData;
-    readonly body: TBodyData;
+    readonly body: TRequestBody;
     readonly method: HttpMethod;
     readonly requestHeaders: readonly Header[];
     readonly adapterResponse: Omit<AdapterResponse, "toJsonAsync" | "toBlobAsync">;
 }>;
-export type ExecuteRequestOptions<TBodyData extends JsonValue | Blob> = {
+export type ExecuteRequestOptions<TRequestBody extends RequestBody> = {
     readonly url: string;
     readonly method: HttpMethod;
-    readonly body: TBodyData;
+    readonly body: TRequestBody;
     readonly requestHeaders?: readonly Header[];
 };
 export type UploadFileRequestOptions = Omit<ExecuteRequestOptions<Blob>, "method"> & {
@@ -62,7 +67,7 @@ export type HttpService = {
     /**
      * Executes request with the given method and body.
      */
-    requestAsync<TResponseData extends JsonValue, TBodyData extends JsonValue>(opts: ExecuteRequestOptions<TBodyData>): Promise<HttpResponse<TResponseData, TBodyData>>;
+    requestAsync<TResponseData extends JsonValue, TRequestBody extends RequestBody>(opts: ExecuteRequestOptions<TRequestBody>): Promise<HttpResponse<TResponseData, TRequestBody>>;
     /**
      * Downloads a file from the given URL as a blob.
      */
@@ -79,13 +84,26 @@ export type AdapterResponse<TStatusCode extends HttpServiceStatus = HttpServiceS
     readonly responseHeaders: readonly Header[];
     readonly status: TStatusCode;
     readonly statusText: string;
+    readonly url: string;
 };
+export type AdapterRequestBody = string | Blob | null;
 export type AdapterRequestOptions = {
     readonly url: string;
     readonly method: HttpMethod;
-    readonly body: string | Blob | undefined | null;
+    readonly body: AdapterRequestBody;
     readonly requestHeaders?: readonly Header[];
 };
+export type GetNextPageData<TResponseData extends JsonValue, TMeta> = (response: QueryResponse<TResponseData, TMeta>) => {
+    readonly continuationToken?: string;
+    readonly nextPageUrl?: string;
+};
+export type PaginationConfig = {
+    readonly maxPagesCount?: number;
+};
+export type Pagination<TResponseData extends JsonValue, TMeta> = {
+    readonly getNextPageData: GetNextPageData<TResponseData, TMeta>;
+    readonly config?: PaginationConfig;
+};
 /**
  * Defines the adapter responsible solely for executing HTTP requests.
  *

package/dist/http/http.service.js

@@ -1,183 +1,16 @@
+import { match, P } from "ts-pattern";
 import { sdkInfo } from "../sdk-info.js";
-import { isNotUndefined } from "../utils/core.utils.js";
-import { createSdkError, getErrorMessage } from "../utils/error.utils.js";
-import { getSdkIdHeader } from "../utils/header.utils.js";
+import { isBlob, isNotUndefined } from "../utils/core.utils.js";
+import { createSdkError, getErrorMessage, isKontentErrorResponseData } from "../utils/error.utils.js";
+import { getSdkIdHeader, isApplicationJsonResponseType } from "../utils/header.utils.js";
 import { runWithRetryAsync, toRequiredRetryStrategyOptions } from "../utils/retry.utils.js";
 import { tryCatch, tryCatchAsync } from "../utils/try.utils.js";
 import { getDefaultHttpAdapter } from "./http.adapter.js";
 export function getDefaultHttpService(config) {
-    const withUnknownErrorHandlingAsync = async ({ url, funcAsync, }) => {
-        const { success, data, error } = await tryCatchAsync(funcAsync);
-        if (success) {
-            return data;
-        }
-        return {
-            success: false,
-            error: createSdkError({
-                message: "Unknown error. See the error object for more details.",
-                url: url,
-                reason: "unknown",
-                originalError: error,
-            }),
-        };
-    };
-    const resolveRequestAsync = async ({ options, resolveDataAsync, }) => {
-        return await withUnknownErrorHandlingAsync({
-            url: options.url,
-            funcAsync: async () => {
-                const adapter = config?.adapter ?? getDefaultHttpAdapter();
-                const getCombinedRequestHeaders = () => {
-                    return getRequestHeaders([...(config?.requestHeaders ?? []), ...(options.requestHeaders ?? [])], options.body);
-                };
-                const getRequestBody = () => {
-                    if (options.body === null) {
-                        return {
-                            success: true,
-                            data: null,
-                        };
-                    }
-                    if (options.body instanceof Blob) {
-                        return {
-                            success: true,
-                            data: options.body,
-                        };
-                    }
-                    const { success, data: parsedBody, error } = tryCatch(() => JSON.stringify(options.body));
-                    if (!success) {
-                        return {
-                            success: false,
-                            error: createSdkError({
-                                message: "Failed to stringify body of request.",
-                                url: options.url,
-                                reason: "invalidBody",
-                                originalError: error,
-                            }),
-                        };
-                    }
-                    return {
-                        success: true,
-                        data: parsedBody,
-                    };
-                };
-                const getUrl = () => {
-                    const { success, data: parsedUrl, error } = tryCatch(() => new URL(options.url));
-                    if (!success) {
-                        return {
-                            success: false,
-                            error: createSdkError({
-                                message: `Failed to parse url '${options.url}'.`,
-                                url: options.url,
-                                reason: "invalidUrl",
-                                originalError: error,
-                            }),
-                        };
-                    }
-                    return {
-                        success: true,
-                        data: parsedUrl,
-                    };
-                };
-                const requestHeaders = getCombinedRequestHeaders();
-                const retryStrategyOptions = toRequiredRetryStrategyOptions(config?.retryStrategy);
-                const withRetryAsync = async (funcAsync) => {
-                    return await runWithRetryAsync({
-                        url: options.url,
-                        retryStrategyOptions,
-                        retryAttempt: 0,
-                        requestHeaders,
-                        method: options.method,
-                        funcAsync: async () => {
-                            return await funcAsync();
-                        },
-                    });
-                };
-                const { success: urlParsedSuccess, data: parsedUrl, error: urlError } = getUrl();
-                if (!urlParsedSuccess) {
-                    return {
-                        success: false,
-                        error: urlError,
-                    };
-                }
-                const { success: requestBodyParsedSuccess, data: requestBody, error: requestBodyError } = getRequestBody();
-                if (!requestBodyParsedSuccess) {
-                    return {
-                        success: false,
-                        error: requestBodyError,
-                    };
-                }
-                const getResponseAsync = async () => {
-                    return await adapter.requestAsync({
-                        url: parsedUrl.toString(),
-                        method: options.method,
-                        requestHeaders,
-                        body: requestBody,
-                    });
-                };
-                const getErrorDetailsForInvalidResponseAsync = async (response) => {
-                    const sharedErrorData = {
-                        message: getErrorMessage({
-                            url: options.url,
-                            adapterResponse: response,
-                            method: options.method,
-                        }),
-                        url: options.url,
-                    };
-                    if (response.status === 404) {
-                        const error404 = {
-                            ...sharedErrorData,
-                            reason: "notFound",
-                            isValidResponse: response.isValidResponse,
-                            responseHeaders: response.responseHeaders,
-                            status: 404,
-                            statusText: response.statusText,
-                            kontentErrorResponse: await getKontentErrorDataAsync(response),
-                        };
-                        return error404;
-                    }
-                    const error = {
-                        ...sharedErrorData,
-                        reason: "invalidResponse",
-                        isValidResponse: response.isValidResponse,
-                        responseHeaders: response.responseHeaders,
-                        status: response.status,
-                        statusText: response.statusText,
-                        kontentErrorResponse: await getKontentErrorDataAsync(response),
-                    };
-                    return error;
-                };
-                const getErrorForInvalidResponseAsync = async (response) => {
-                    return createSdkError(await getErrorDetailsForInvalidResponseAsync(response));
-                };
-                const resolveResponseAsync = async (response) => {
-                    if (!response.isValidResponse) {
-                        return {
-                            success: false,
-                            error: await getErrorForInvalidResponseAsync(response),
-                        };
-                    }
-                    return {
-                        success: true,
-                        response: {
-                            data: await resolveDataAsync(response),
-                            body: options.body,
-                            method: options.method,
-                            adapterResponse: {
-                                isValidResponse: response.isValidResponse,
-                                responseHeaders: response.responseHeaders,
-                                status: response.status,
-                                statusText: response.statusText,
-                            },
-                            requestHeaders: requestHeaders,
-                        },
-                    };
-                };
-                return await withRetryAsync(async () => await resolveResponseAsync(await getResponseAsync()));
-            },
-        });
-    };
     return {
         requestAsync: async (options) => {
             return await resolveRequestAsync({
+                config,
                 options,
                 resolveDataAsync: async (response) => {
                     return (await response.toJsonAsync());
@@ -186,6 +19,7 @@ export function getDefaultHttpService(config) {
         },
         downloadFileAsync: async (options) => {
             return await resolveRequestAsync({
+                config,
                 options: {
                     ...options,
                     method: "GET",
@@ -198,6 +32,7 @@ export function getDefaultHttpService(config) {
         },
         uploadFileAsync: async (options) => {
             return await resolveRequestAsync({
+                config,
                 options,
                 resolveDataAsync: async (response) => {
                     return (await response.toJsonAsync());
@@ -206,32 +41,224 @@ export function getDefaultHttpService(config) {
         },
     };
 }
-async function getKontentErrorDataAsync(response) {
-    if (response.responseHeaders
-        .find((header) => header.name.toLowerCase() === "Content-Type".toLowerCase())
-        ?.value.toLowerCase()
-        .includes("application/json")) {
-        const json = (await response.toJsonAsync());
-        // We check the existence of 'message' property which should always be set when the error is a Kontent API error
-        if (!json.message) {
-            return undefined;
+async function resolveRequestAsync({ options, resolveDataAsync, config, }) {
+    return await withUnknownErrorHandlingAsync({
+        url: options.url,
+        funcAsync: async () => {
+            const { success: parseSuccess, data: parsedRequest, error: parseError } = parseAndValidateRequest(options);
+            if (!parseSuccess) {
+                return {
+                    success: false,
+                    error: parseError,
+                };
+            }
+            const requestHeaders = buildRequestHeaders({
+                configHeaders: config?.requestHeaders,
+                optionHeaders: options.requestHeaders,
+                body: options.body,
+            });
+            return await withRetryAsync({
+                funcAsync: async () => {
+                    const adapterResponse = await executeWithAdapter({
+                        adapter: config?.adapter ?? getDefaultHttpAdapter(),
+                        parsedUrl: parsedRequest.parsedUrl,
+                        method: options.method,
+                        requestHeaders,
+                        parsedBody: parsedRequest.parsedBody,
+                    });
+                    return await resolveResponseAsync({
+                        method: options.method,
+                        requestBody: options.body,
+                        requestHeaders,
+                        response: adapterResponse,
+                        resolveDataAsync,
+                    });
+                },
+                url: options.url,
+                retryStrategyOptions: toRequiredRetryStrategyOptions(config?.retryStrategy),
+                requestHeaders,
+                method: options.method,
+            });
+        },
+    });
+}
+async function withUnknownErrorHandlingAsync({ url, funcAsync, }) {
+    const { success, data, error } = await tryCatchAsync(funcAsync);
+    if (success) {
+        return data;
+    }
+    return {
+        success: false,
+        error: createSdkError({
+            message: "Unknown error. See the error object for more details.",
+            url: url,
+            reason: "unknown",
+            originalError: error,
+        }),
+    };
+}
+async function resolveResponseAsync({ response, resolveDataAsync, method, requestHeaders, requestBody, }) {
+    if (!response.isValidResponse) {
+        return {
+            success: false,
+            error: await getErrorForInvalidResponseAsync(response, method),
+        };
+    }
+    return {
+        success: true,
+        response: {
+            data: await resolveDataAsync(response),
+            body: requestBody,
+            method: method,
+            adapterResponse: {
+                url: response.url,
+                isValidResponse: response.isValidResponse,
+                responseHeaders: response.responseHeaders,
+                status: response.status,
+                statusText: response.statusText,
+            },
+            requestHeaders: requestHeaders,
+        },
+    };
+}
+async function executeWithAdapter({ adapter, parsedUrl, method, requestHeaders, parsedBody, }) {
+    return await adapter.requestAsync({
+        url: parsedUrl.toString(),
+        method,
+        requestHeaders,
+        body: parsedBody,
+    });
+}
+async function withRetryAsync({ funcAsync, url, retryStrategyOptions, requestHeaders, method, }) {
+    return await runWithRetryAsync({
+        url: url,
+        retryStrategyOptions,
+        retryAttempt: 0,
+        requestHeaders,
+        method: method,
+        funcAsync: async () => {
+            return await funcAsync();
+        },
+    });
+}
+async function getErrorForInvalidResponseAsync(response, method) {
+    return createSdkError(await getErrorDetailsForInvalidResponseAsync(response, method));
+}
+async function getErrorDetailsForInvalidResponseAsync(response, method) {
+    const sharedErrorData = {
+        message: getErrorMessage({
+            url: response.url,
+            adapterResponse: response,
+            method: method,
+        }),
+        url: response.url,
+    };
+    return await match(response)
+        .returnType()
+        .with({ status: P.union(401, 404) }, async (m) => ({
+        ...sharedErrorData,
+        reason: m.status === 401 ? "unauthorized" : "notFound",
+        isValidResponse: m.isValidResponse,
+        responseHeaders: m.responseHeaders,
+        status: m.status,
+        statusText: m.statusText,
+        kontentErrorResponse: await getKontentErrorDataAsync(m),
+    }))
+        .otherwise(async () => ({
+        ...sharedErrorData,
+        reason: "invalidResponse",
+        isValidResponse: response.isValidResponse,
+        responseHeaders: response.responseHeaders,
+        status: response.status,
+        statusText: response.statusText,
+        kontentErrorResponse: await getKontentErrorDataAsync(response),
+    }));
+}
+function parseRequestBody({ requestBody, url, }) {
+    return match(requestBody)
+        .returnType()
+        .with(P.nullish, () => ({
+        success: true,
+        data: null,
+    }))
+        .when(isBlob, (blob) => ({
+        success: true,
+        data: blob,
+    }))
+        .otherwise((m) => {
+        const { success: isParseSuccess, data: parsedBody, error: parseError } = tryCatch(() => JSON.stringify(m));
+        if (!isParseSuccess) {
+            return {
+                success: false,
+                error: createSdkError({
+                    message: "Failed to stringify body of the request.",
+                    url: url,
+                    reason: "invalidBody",
+                    originalError: parseError,
+                }),
+            };
         }
         return {
-            ...json,
-            message: json.message,
+            success: true,
+            data: parsedBody,
         };
+    });
+}
+async function getKontentErrorDataAsync(response) {
+    if (isApplicationJsonResponseType(response.responseHeaders)) {
+        const json = await response.toJsonAsync();
+        if (isKontentErrorResponseData(json)) {
+            return json;
+        }
     }
     return undefined;
 }
-function getRequestHeaders(headers, body) {
-    const existingContentTypeHeader = headers?.find((header) => header.name.toLowerCase() === "Content-Type".toLowerCase());
-    const existingSdkVersionHeader = headers?.find((header) => header.name.toLowerCase() === "X-KC-SDKID".toLowerCase());
-    const contentTypeHeader = existingContentTypeHeader
-        ? undefined
-        : {
-            name: "Content-Type",
-            value: body instanceof Blob ? body.type : "application/json",
+function parseAndValidateRequest(options) {
+    const { success: urlParsedSuccess, data: parsedUrl, error: urlError } = parseUrl(options.url);
+    if (!urlParsedSuccess) {
+        return {
+            success: false,
+            error: urlError,
+        };
+    }
+    const { success: requestBodyParsedSuccess, data: parsedRequestBody, error: requestBodyError, } = parseRequestBody({ requestBody: options.body, url: options.url });
+    if (!requestBodyParsedSuccess) {
+        return {
+            success: false,
+            error: requestBodyError,
+        };
+    }
+    return {
+        success: true,
+        data: {
+            parsedUrl,
+            parsedBody: parsedRequestBody,
+        },
+    };
+}
+function parseUrl(url) {
+    const { success, data: parsedUrl, error } = tryCatch(() => new URL(url));
+    if (!success) {
+        return {
+            success: false,
+            error: createSdkError({
+                message: `Failed to parse url '${url}'.`,
+                url: url,
+                reason: "invalidUrl",
+                originalError: error,
+            }),
         };
+    }
+    return {
+        success: true,
+        data: parsedUrl,
+    };
+}
+function buildRequestHeaders({ configHeaders, optionHeaders, body, }) {
+    const combinedHeaders = [...(configHeaders ?? []), ...(optionHeaders ?? [])];
+    const existingContentTypeHeader = getExistingContentTypeHeader(combinedHeaders);
+    const existingSdkVersionHeader = getExistingSdkVersionHeader(combinedHeaders);
+    const contentTypeHeader = existingContentTypeHeader ? undefined : createDefaultContentTypeHeader(body);
     const sdkVersionHeader = existingSdkVersionHeader
         ? undefined
         : getSdkIdHeader({
@@ -239,12 +266,25 @@ function getRequestHeaders(headers, body) {
             name: sdkInfo.name,
             version: sdkInfo.version,
         });
-    const contentLengthHeader = body instanceof Blob
-        ? {
-            name: "Content-Length",
-            value: body.size.toString(),
-        }
-        : undefined;
-    return [...(headers ?? []), contentTypeHeader, contentLengthHeader, sdkVersionHeader].filter(isNotUndefined);
+    const contentLengthHeader = body instanceof Blob ? createDefaultContentLengthHeader(body) : undefined;
+    return [...combinedHeaders, contentTypeHeader, contentLengthHeader, sdkVersionHeader].filter(isNotUndefined);
+}
+function createDefaultContentTypeHeader(body) {
+    return {
+        name: "Content-Type",
+        value: body instanceof Blob ? body.type : "application/json",
+    };
+}
+function createDefaultContentLengthHeader(body) {
+    return {
+        name: "Content-Length",
+        value: body.size.toString(),
+    };
+}
+function getExistingContentTypeHeader(headers) {
+    return headers.find((header) => header.name.toLowerCase() === "Content-Type".toLowerCase());
+}
+function getExistingSdkVersionHeader(headers) {
+    return headers.find((header) => header.name.toLowerCase() === "X-KC-SDKID".toLowerCase());
 }
 //# sourceMappingURL=http.service.js.map