@kontent-ai/core-sdk 12.0.0-preview.2 → 12.0.0-preview.20

package/lib/http/http.service.ts

@@ -1,320 +0,0 @@
-import type { CommonHeaderNames, Header, KontentErrorResponseData, RetryStrategyOptions } from "../models/core.models.js";
-import type { CoreSdkError } from "../models/error.models.js";
-import type { JsonValue } from "../models/json.models.js";
-import { sdkInfo } from "../sdk-info.js";
-import { isNotUndefined } from "../utils/core.utils.js";
-import { getErrorMessage } from "../utils/error.utils.js";
-import { getSdkIdHeader } from "../utils/header.utils.js";
-import { runWithRetryAsync, toRequiredRetryStrategyOptions } from "../utils/retry.utils.js";
-import { type Result, tryCatch, tryCatchAsync } from "../utils/try.utils.js";
-import { getDefaultHttpAdapter } from "./http.adapter.js";
-import type {
-	AdapterResponse,
-	DefaultHttpServiceConfig,
-	DownloadFileRequestOptions,
-	ExecuteRequestOptions,
-	HttpResponse,
-	HttpService,
-	UploadFileRequestOptions,
-} from "./http.models.js";
-
-export function getDefaultHttpService(config?: DefaultHttpServiceConfig): HttpService {
-	const withUnknownErrorHandlingAsync = async <TResponseData extends JsonValue | Blob, TBodyData extends JsonValue | Blob>({
-		url,
-		funcAsync,
-	}: {
-		readonly url: string;
-		readonly funcAsync: () => Promise<HttpResponse<TResponseData, TBodyData>>;
-	}): Promise<HttpResponse<TResponseData, TBodyData>> => {
-		const { success, data, error } = await tryCatchAsync(funcAsync);
-
-		if (success) {
-			return data;
-		}
-
-		return {
-			success: false,
-			error: {
-				reason: "unknown",
-				message: "Unknown error. See the error object for more details.",
-				url: url,
-				originalError: error,
-			},
-		};
-	};
-
-	const resolveRequestAsync = async <TResponseData extends JsonValue | Blob, TBodyData extends JsonValue | Blob>({
-		options,
-		resolveDataAsync,
-	}: {
-		readonly options: ExecuteRequestOptions<TBodyData>;
-		readonly resolveDataAsync: (response: AdapterResponse) => Promise<TResponseData>;
-	}): Promise<HttpResponse<TResponseData, TBodyData>> => {
-		return await withUnknownErrorHandlingAsync({
-			url: options.url,
-			funcAsync: async () => {
-				const adapter = config?.adapter ?? getDefaultHttpAdapter();
-
-				const getCombinedRequestHeaders = (): readonly Header[] => {
-					return getRequestHeaders([...(config?.requestHeaders ?? []), ...(options.requestHeaders ?? [])], options.body);
-				};
-
-				const getRequestBody = (): Result<string | Blob | null, CoreSdkError> => {
-					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: {
-								message: "Failed to stringify body of request.",
-								url: options.url,
-								reason: "invalidBody",
-								originalError: error,
-							},
-						};
-					}
-
-					return {
-						success: true,
-						data: parsedBody,
-					};
-				};
-
-				const getUrl = (): Result<URL, CoreSdkError> => {
-					const { success, data: parsedUrl, error } = tryCatch(() => new URL(options.url));
-
-					if (!success) {
-						return {
-							success: false,
-							error: {
-								message: `Failed to parse url '${options.url}'.`,
-								url: options.url,
-								reason: "invalidUrl",
-								originalError: error,
-							},
-						};
-					}
-
-					return {
-						success: true,
-						data: parsedUrl,
-					};
-				};
-
-				const requestHeaders = getCombinedRequestHeaders();
-				const retryStrategyOptions: Required<RetryStrategyOptions> = toRequiredRetryStrategyOptions(config?.retryStrategy);
-
-				const withRetryAsync = async (
-					funcAsync: () => Promise<HttpResponse<TResponseData, TBodyData>>,
-				): Promise<HttpResponse<TResponseData, TBodyData>> => {
-					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 (): Promise<AdapterResponse> => {
-					return await adapter.requestAsync({
-						url: parsedUrl.toString(),
-						method: options.method,
-						requestHeaders,
-						body: requestBody,
-					});
-				};
-
-				const getErrorForInvalidResponseAsync = async (response: AdapterResponse): Promise<CoreSdkError> => {
-					const sharedErrorData: Pick<CoreSdkError, "message" | "url"> = {
-						message: getErrorMessage({
-							url: options.url,
-							adapterResponse: response,
-							method: options.method,
-						}),
-						url: options.url,
-					};
-
-					if (response.status === 404) {
-						const error: CoreSdkError<"notFound"> = {
-							...sharedErrorData,
-							reason: "notFound",
-							isValidResponse: response.isValidResponse,
-							responseHeaders: response.responseHeaders,
-							status: 404,
-							statusText: response.statusText,
-							kontentErrorResponse: await getKontentErrorDataAsync(response),
-						};
-
-						return error;
-					}
-
-					const error: CoreSdkError<"invalidResponse"> = {
-						...sharedErrorData,
-						reason: "invalidResponse",
-						isValidResponse: response.isValidResponse,
-						responseHeaders: response.responseHeaders,
-						status: response.status,
-						statusText: response.statusText,
-						kontentErrorResponse: await getKontentErrorDataAsync(response),
-					};
-
-					return error;
-				};
-
-				const resolveResponseAsync = async (response: AdapterResponse): Promise<HttpResponse<TResponseData, TBodyData>> => {
-					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 <TResponseData extends JsonValue, TBodyData extends JsonValue>(options: ExecuteRequestOptions<TBodyData>) => {
-			return await resolveRequestAsync<TResponseData, TBodyData>({
-				options,
-				resolveDataAsync: async (response) => {
-					return (await response.toJsonAsync()) as TResponseData;
-				},
-			});
-		},
-
-		downloadFileAsync: async (options: DownloadFileRequestOptions): Promise<HttpResponse<Blob, null>> => {
-			return await resolveRequestAsync<Blob, null>({
-				options: {
-					...options,
-					method: "GET",
-					body: null,
-				},
-				resolveDataAsync: async (response) => {
-					return await response.toBlobAsync();
-				},
-			});
-		},
-
-		uploadFileAsync: async <TResponseData extends JsonValue>(
-			options: UploadFileRequestOptions,
-		): Promise<HttpResponse<TResponseData, Blob>> => {
-			return await resolveRequestAsync<TResponseData, Blob>({
-				options,
-				resolveDataAsync: async (response) => {
-					return (await response.toJsonAsync()) as TResponseData;
-				},
-			});
-		},
-	};
-}
-
-async function getKontentErrorDataAsync(response: AdapterResponse): Promise<KontentErrorResponseData | undefined> {
-	if (
-		response.responseHeaders
-			.find((header) => header.name.toLowerCase() === ("Content-Type" satisfies CommonHeaderNames).toLowerCase())
-			?.value.toLowerCase()
-			.includes("application/json")
-	) {
-		const json = (await response.toJsonAsync()) as Partial<KontentErrorResponseData>;
-
-		// 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;
-		}
-
-		return {
-			...json,
-			message: json.message,
-		};
-	}
-	return undefined;
-}
-
-function getRequestHeaders(headers: readonly Header[] | undefined, body: Blob | JsonValue): readonly Header[] {
-	const existingContentTypeHeader = headers?.find(
-		(header) => header.name.toLowerCase() === ("Content-Type" satisfies CommonHeaderNames).toLowerCase(),
-	);
-	const existingSdkVersionHeader = headers?.find(
-		(header) => header.name.toLowerCase() === ("X-KC-SDKID" satisfies CommonHeaderNames).toLowerCase(),
-	);
-
-	const contentTypeHeader: Header | undefined = existingContentTypeHeader
-		? undefined
-		: {
-				name: "Content-Type" satisfies CommonHeaderNames,
-				value: body instanceof Blob ? body.type : "application/json",
-			};
-
-	const sdkVersionHeader: Header | undefined = existingSdkVersionHeader
-		? undefined
-		: getSdkIdHeader({
-				host: sdkInfo.host,
-				name: sdkInfo.name,
-				version: sdkInfo.version,
-			});
-
-	const contentLengthHeader: Header | undefined =
-		body instanceof Blob
-			? {
-					name: "Content-Length" satisfies CommonHeaderNames,
-					value: body.size.toString(),
-				}
-			: undefined;
-
-	return [...(headers ?? []), contentTypeHeader, contentLengthHeader, sdkVersionHeader].filter(isNotUndefined);
-}

package/lib/models/core.models.ts

@@ -1,89 +0,0 @@
-import type { CoreSdkError } from "./error.models.js";
-import type { PickStringLiteral } from "./utility.models.js";
-
-/**
- * SDK info for identification of the SDK
- */
-export type SDKInfo = {
-	/**
-	 * The name of the SDK.
-	 */
-	readonly name: string;
-
-	/**
-	 * The version of the SDK.
-	 */
-	readonly version: string;
-
-	/**
-	 * The host of the SDK.
-	 */
-	readonly host: LiteralUnion<"npmjs.com">;
-};
-
-export type CommonHeaderNames = "Retry-After" | "X-KC-SDKID" | "Authorization" | "Content-Type" | "Content-Length" | "X-Continuation";
-
-export type ContinuationHeaderName = PickStringLiteral<CommonHeaderNames, "X-Continuation">;
-
-export type Header = {
-	readonly name: string;
-	readonly value: string;
-};
-
-export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-
-export type KontentValidationError = {
-	readonly message: string;
-	readonly path?: string;
-	readonly line?: number;
-	readonly position?: number;
-};
-
-export type KontentErrorResponseData = {
-	readonly message: string;
-	readonly requestId?: string;
-	readonly error_code?: number;
-	readonly validation_errors?: readonly KontentValidationError[];
-};
-
-export type RetryStrategyOptions = {
-	/**
-	 * Maximum number of retry attempts.
-	 *
-	 * If not provided, the default implementation will be used.
-	 */
-	readonly maxRetries?: number;
-
-	/**
-	 * Function to determine if the error should be retried.
-	 *
-	 * If not provided, the default implementation will be used.
-	 */
-	readonly canRetryError?: (error: CoreSdkError) => boolean;
-
-	/**
-	 * Function to determine the delay between requests in milliseconds.
-	 *
-	 * If not provided, the default implementation will be used.
-	 */
-	readonly getDelayBetweenRetriesMs?: (error: CoreSdkError) => number;
-
-	/**
-	 * Whether to log the retry attempt.
-	 *
-	 * If false, the retry attempt will not be logged.
-	 * If undefined, the default implementation will be used.
-	 * Otherwise, the function will be called with the retry attempt and url.
-	 */
-	readonly logRetryAttempt?: false | ((retryAttempt: number, url: string) => void);
-};
-
-/**
- * Adds intellisense for string union type, but also allows any string
- */
-export type LiteralUnion<T extends string | undefined> = T | (string & NonNullable<unknown>);
-
-/**
- * Adds intellisense for number union type, but also allows any number
- */
-export type LiteralUnionNumber<T extends number | undefined> = T | (number & NonNullable<unknown>);

package/lib/models/error.models.ts

@@ -1,83 +0,0 @@
-import type { ZodError } from "zod";
-import type { AdapterResponse, HttpServiceStatus } from "../http/http.models.js";
-import type { SuccessfulHttpResponse } from "../sdk/sdk-models.js";
-import type { KontentErrorResponseData, RetryStrategyOptions } from "./core.models.js";
-import type { JsonValue } from "./json.models.js";
-
-export type ErrorReason = "invalidResponse" | "invalidUrl" | "unknown" | "invalidBody" | "notFound" | "validationFailed" | "noResponses";
-
-export type CoreSdkErrorDetails<TReason extends ErrorReason = ErrorReason> = (
-	| Details<
-			"invalidResponse",
-			{
-				readonly kontentErrorResponse: KontentErrorResponseData | undefined;
-			} & Pick<AdapterResponse<HttpServiceStatus>, "isValidResponse" | "responseHeaders" | "status" | "statusText">
-	  >
-	| Details<
-			"notFound",
-			{
-				readonly kontentErrorResponse: KontentErrorResponseData | undefined;
-			} & Pick<AdapterResponse<404>, "isValidResponse" | "responseHeaders" | "status" | "statusText">
-	  >
-	| Details<
-			"invalidBody",
-			{
-				readonly originalError: unknown;
-			}
-	  >
-	| Details<
-			"invalidUrl",
-			{
-				readonly originalError: unknown;
-			}
-	  >
-	| Details<
-			"unknown",
-			{
-				readonly originalError: unknown;
-			}
-	  >
-	| Details<
-			"validationFailed",
-			{
-				readonly reason: "validationFailed";
-				readonly zodError: ZodError;
-				readonly response: SuccessfulHttpResponse<JsonValue, JsonValue>;
-				readonly url: string;
-			}
-	  >
-	| Details<
-			"noResponses",
-			{
-				readonly url: string;
-			}
-	  >
-) & {
-	readonly reason: TReason;
-};
-
-export type CoreSdkError<TReason extends ErrorReason = ErrorReason> = {
-	/**
-	 * The message of the error
-	 */
-	readonly message: string;
-
-	/**
-	 * The URL of the request.
-	 */
-	readonly url: string;
-
-	/**
-	 * Used retry strategy.
-	 */
-	readonly retryStrategyOptions?: Required<RetryStrategyOptions>;
-
-	/**
-	 * The number of times the request has been retried.
-	 */
-	readonly retryAttempt?: number;
-} & CoreSdkErrorDetails<TReason>;
-
-type Details<TReason extends ErrorReason, TDetails> = {
-	readonly reason: TReason;
-} & TDetails;

package/lib/models/json.models.ts

@@ -1,9 +0,0 @@
-import type { EmptyObject } from "./utility.models.js";
-
-export type JsonValue = string | number | null | boolean | JsonObject | JsonArray | EmptyObject;
-
-export interface JsonObject {
-	readonly [property: string]: JsonValue;
-}
-
-export type JsonArray = readonly JsonValue[];

package/lib/models/utility.models.ts

@@ -1,21 +0,0 @@
-/**
- * Improves the type readability by flattening the type.
- */
-export type Prettify<T> = {
-	[K in keyof T]: T[K];
-} & {};
-
-/**
- * Override selected properties of a type. Uses Omit to remove the properties and then adds the new properties.
- */
-export type Override<Type, NewType extends { [key in keyof Type]?: NewType[key] }> = Omit<Type, keyof NewType> & NewType;
-
-/**
- * Represents an empty object type.
- */
-export type EmptyObject = Record<string, never>;
-
-/**
- * Picks a string literal type from a union type.
- */
-export type PickStringLiteral<T extends string, U extends T> = U;

package/lib/public_api.ts

@@ -1,45 +0,0 @@
-// biome-ignore lint/performance/noBarrelFile: One barrel for the public API is fine
-export { getDefaultHttpAdapter } from "./http/http.adapter.js";
-export type {
-	AdapterRequestOptions,
-	AdapterResponse,
-	DefaultHttpServiceConfig,
-	DownloadFileRequestOptions,
-	ExecuteRequestOptions,
-	HttpAdapter,
-	HttpResponse,
-	HttpService,
-	HttpServiceStatus,
-	UploadFileRequestOptions,
-} from "./http/http.models.js";
-export { getDefaultHttpService } from "./http/http.service.js";
-export type {
-	CommonHeaderNames,
-	Header,
-	HttpMethod,
-	RetryStrategyOptions,
-	SDKInfo,
-} from "./models/core.models.js";
-export type {
-	CoreSdkError,
-	CoreSdkErrorDetails,
-	ErrorReason,
-} from "./models/error.models.js";
-export type { JsonArray, JsonObject, JsonValue } from "./models/json.models.js";
-export type { EmptyObject, Override, Prettify } from "./models/utility.models.js";
-export type {
-	CoreResponse,
-	CoreResponseMeta,
-	CoreSdkConfig,
-	PagingQuery,
-	PagingQueryResult,
-	Query,
-	QueryResult,
-	ResultOfSuccessfulQuery,
-	SuccessfulHttpResponse,
-} from "./sdk/sdk-models.js";
-export { extractContinuationToken, getPagingQuery, getQuery } from "./sdk/sdk-queries.js";
-export { isKontent404Error } from "./utils/error.utils.js";
-export { getSdkIdHeader } from "./utils/header.utils.js";
-export { toRequiredRetryStrategyOptions } from "./utils/retry.utils.js";
-export { tryCatch, tryCatchAsync } from "./utils/try.utils.js";

package/lib/sdk/sdk-models.ts

@@ -1,85 +0,0 @@
-/**
- * Shared query models/types intended to be reused across SDKs (e.g. Sync, Delivery, Management)
- * to keep common code and behavior consistent.
- */
-
-import type { AdapterResponse, HttpResponse, HttpService } from "../http/http.models.js";
-import type { CoreSdkError } from "../models/error.models.js";
-import type { JsonValue } from "../models/json.models.js";
-import type { Prettify } from "../models/utility.models.js";
-
-export type CoreResponseMeta<TExtraMetadata = unknown> = Pick<AdapterResponse, "status" | "responseHeaders"> & {
-	readonly continuationToken?: string;
-} & TExtraMetadata;
-
-export type CoreResponse<TPayload, TExtraMetadata = unknown> = {
-	readonly payload: TPayload;
-	readonly meta: CoreResponseMeta<TExtraMetadata>;
-};
-export type CoreSdkConfig = {
-	/**
-	 * The HTTP service to use for the request. If not provided, the default HTTP service will be used.
-	 *
-	 * You may provide your own HTTP service implementation to customize the request behavior.
-	 *
-	 * See https://github.com/kontent-ai/core-sdk-js for more information regarding the HTTP service customization.
-	 */
-	readonly httpService?: HttpService;
-
-	/**
-	 * The base URL to use for the request. If not provided, the default base URL will be used.
-	 *
-	 * If provided, it will override the default base URL based on selected API mode.
-	 */
-	readonly baseUrl?: string;
-
-	/**
-	 * Configuration for response validation.
-	 */
-	readonly responseValidation?: {
-		/**
-		 * When enabled, the response payload will be validated against the expected Zod schema from which the types
-		 * this library are based on. This ensures that you are working with the correct data types.
-		 *
-		 * @default false
-		 */
-		readonly enable: boolean;
-	};
-};
-
-export type Query<TPayload, TExtraData = unknown> = {
-	toUrl(): string;
-	toPromise(): Promise<QueryResult<CoreResponse<TPayload, TExtraData>>>;
-};
-
-export type PagingQuery<TPayload, TExtraData = unknown> = Query<TPayload, TExtraData> & {
-	toAllPromise(): Promise<PagingQueryResult<CoreResponse<TPayload, TExtraData>>>;
-};
-
-export type SuccessfulHttpResponse<TPayload extends JsonValue, TBodyData extends JsonValue> = Prettify<
-	Extract<HttpResponse<TPayload, TBodyData>, { readonly success: true }>["response"]
->;
-
-export type ResultOfSuccessfulQuery<TQuery extends Query<unknown>> = Extract<
-	Awaited<ReturnType<TQuery["toPromise"]>>,
-	{ readonly success: true }
->["response"];
-
-/**
- * A nomadic result type that represents a success or failure of an operation.
- *
- * Ensures that consumers of this library handle both success and failure cases.
- */
-export type QueryResult<TResponse> = (Success & { readonly response: TResponse }) | (Failure & { readonly response?: never });
-export type PagingQueryResult<TResponse> =
-	| (Success & { readonly responses: TResponse[]; readonly lastContinuationToken: string })
-	| (Failure & { readonly responses?: never; readonly lastContinuationToken?: never });
-
-type Success = {
-	readonly success: true;
-	readonly error?: never;
-};
-type Failure = {
-	readonly success: false;
-	readonly error: CoreSdkError;
-};