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

package/lib/sdk/sdk-queries.ts

@@ -1,232 +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 { ZodError, ZodType } from "zod";
-import type { HttpService } from "../http/http.models.js";
-import { getDefaultHttpService } from "../http/http.service.js";
-import type { CommonHeaderNames, ContinuationHeaderName, Header, SDKInfo } from "../models/core.models.js";
-import type { JsonValue } from "../models/json.models.js";
-import type { EmptyObject } from "../models/utility.models.js";
-import { getSdkIdHeader } from "../utils/header.utils.js";
-import type { CoreResponse, CoreSdkConfig, PagingQuery, Query, SuccessfulHttpResponse } from "./sdk-models.js";
-
-type ResolveToPromiseQuery<TPayload extends JsonValue, TExtraMetadata = EmptyObject> = ReturnType<
-	Pick<Query<TPayload, TExtraMetadata>, "toPromise">["toPromise"]
->;
-
-type ResolveToAllPromiseQuery<TPayload extends JsonValue, TExtraMetadata = EmptyObject> = ReturnType<
-	Pick<PagingQuery<TPayload, TExtraMetadata>, "toAllPromise">["toAllPromise"]
->;
-
-export function getQuery<TPayload extends JsonValue, TBodyData extends JsonValue, TExtraMetadata>(
-	data: Parameters<typeof resolveQueryAsync<TPayload, TBodyData, TExtraMetadata>>[0],
-): Pick<Query<TPayload, TExtraMetadata>, "toPromise"> {
-	return {
-		toPromise: async () => {
-			return await resolveQueryAsync<TPayload, TBodyData, TExtraMetadata>(data);
-		},
-	};
-}
-
-export function getPagingQuery<TPayload extends JsonValue, TBodyData extends JsonValue, TExtraMetadata = EmptyObject>(
-	data: Parameters<typeof resolveQueryAsync<TPayload, TBodyData, TExtraMetadata>>[0] & {
-		readonly canFetchNextResponse: (response: CoreResponse<TPayload, TExtraMetadata>) => boolean;
-		readonly continuationToken: string;
-	},
-): Pick<PagingQuery<TPayload, TExtraMetadata>, "toPromise" | "toAllPromise"> {
-	return {
-		...getQuery<TPayload, TBodyData, TExtraMetadata>(data),
-		toAllPromise: async () => {
-			return await resolvePagingQueryAsync<TPayload, TBodyData, TExtraMetadata>(data);
-		},
-	};
-}
-
-export function extractContinuationToken(responseHeaders: readonly Header[]): string | undefined {
-	return responseHeaders.find((header) => header.name.toLowerCase() === ("X-Continuation" satisfies ContinuationHeaderName).toLowerCase())
-		?.value;
-}
-
-function getHttpService(config: CoreSdkConfig) {
-	return config.httpService ?? getDefaultHttpService();
-}
-
-function getCombinedRequestHeaders({
-	requestHeaders,
-	continuationToken,
-	authorizationApiKey,
-	sdkInfo,
-}: {
-	readonly requestHeaders: readonly Header[];
-	readonly continuationToken: string | undefined;
-	readonly authorizationApiKey: string | undefined;
-	readonly sdkInfo: SDKInfo;
-}): readonly Header[] {
-	return [
-		getSdkIdHeader({
-			host: "npmjs.com",
-			name: sdkInfo.name,
-			version: sdkInfo.version,
-		}),
-		...requestHeaders,
-		...(continuationToken
-			? [
-					{
-						name: "X-Continuation" satisfies CommonHeaderNames,
-						value: continuationToken,
-					},
-				]
-			: []),
-		...(authorizationApiKey
-			? [
-					{
-						name: "Authorization" satisfies CommonHeaderNames,
-						value: `Bearer ${authorizationApiKey}`,
-					},
-				]
-			: []),
-	];
-}
-
-async function resolvePagingQueryAsync<TPayload extends JsonValue, TBodyData extends JsonValue, TExtraMetadata = EmptyObject>(
-	data: Parameters<typeof getPagingQuery<TPayload, TBodyData, TExtraMetadata>>[0],
-): Promise<ResolveToAllPromiseQuery<TPayload, TExtraMetadata>> {
-	const responses: CoreResponse<TPayload, TExtraMetadata>[] = [];
-	let nextContinuationToken: string | undefined = data.continuationToken;
-
-	while (nextContinuationToken) {
-		const { success, response, error } = await getQuery<TPayload, TBodyData, TExtraMetadata>({
-			...data,
-			continuationToken: nextContinuationToken,
-		}).toPromise();
-
-		if (success) {
-			responses.push(response);
-
-			if (data.canFetchNextResponse(response)) {
-				nextContinuationToken = response.meta.continuationToken;
-			} else {
-				nextContinuationToken = undefined;
-			}
-		} else {
-			return {
-				success: false,
-				error: error,
-			};
-		}
-	}
-
-	if (responses.length === 0) {
-		return {
-			success: false,
-			error: {
-				reason: "noResponses",
-				url: data.url,
-				message: "No responses were processed. Expected at least one response to be fetched when using paging queries.",
-			},
-		};
-	}
-
-	return {
-		success: true,
-		responses: responses,
-		lastContinuationToken: responses.at(-1)?.meta.continuationToken ?? "",
-	};
-}
-
-async function resolveQueryAsync<TPayload extends JsonValue, TBodyData extends JsonValue, TExtraMetadata>({
-	config,
-	request,
-	url,
-	extraMetadata,
-	zodSchema,
-	continuationToken,
-	sdkInfo,
-	authorizationApiKey,
-}: {
-	readonly continuationToken: string | undefined;
-	readonly request: Parameters<HttpService["requestAsync"]>[number] & { readonly body: TBodyData };
-	readonly extraMetadata: (response: SuccessfulHttpResponse<TPayload, TBodyData>) => TExtraMetadata;
-	readonly config: CoreSdkConfig;
-	readonly url: string;
-	readonly zodSchema: ZodType<TPayload>;
-	readonly sdkInfo: SDKInfo;
-	readonly authorizationApiKey: string | undefined;
-}): ResolveToPromiseQuery<TPayload, TExtraMetadata> {
-	const { success, response, error } = await getHttpService(config).requestAsync<TPayload, TBodyData>({
-		...request,
-		requestHeaders: getCombinedRequestHeaders({
-			requestHeaders: request.requestHeaders ?? [],
-			continuationToken,
-			authorizationApiKey: authorizationApiKey,
-			sdkInfo,
-		}),
-	});
-
-	if (!success) {
-		return {
-			success: false,
-			error,
-		};
-	}
-
-	if (config.responseValidation?.enable) {
-		const { isValid, error: validationError } = await validateResponseAsync(response.data, zodSchema);
-		if (!isValid) {
-			return {
-				success: false,
-				error: {
-					message: `Failed to validate response schema for url '${url}'`,
-					reason: "validationFailed",
-					zodError: validationError,
-					response,
-					url,
-				},
-			};
-		}
-	}
-
-	const result: Awaited<ResolveToPromiseQuery<TPayload, TExtraMetadata>> = {
-		success: true,
-		response: {
-			payload: response.data,
-			meta: {
-				responseHeaders: response.adapterResponse.responseHeaders,
-				status: response.adapterResponse.status,
-				continuationToken: extractContinuationToken(response.adapterResponse.responseHeaders),
-				...extraMetadata(response),
-			},
-		},
-	};
-
-	return result;
-}
-
-async function validateResponseAsync<TPayload extends JsonValue>(
-	data: TPayload,
-	zodSchema: ZodType<TPayload>,
-): Promise<
-	| {
-			readonly isValid: true;
-			readonly error?: never;
-	  }
-	| {
-			readonly isValid: false;
-			readonly error: ZodError;
-	  }
-> {
-	const validateResult = await zodSchema.safeParseAsync(data);
-
-	if (validateResult.success) {
-		return {
-			isValid: true,
-		};
-	}
-
-	return {
-		isValid: false,
-		error: validateResult.error,
-	};
-}

package/lib/sdk-info.ts

@@ -1,5 +0,0 @@
-export const sdkInfo = {
-	host: "npmjs.com",
-	version: "{{version}}",
-	name: "@kontent-ai/core-sdk",
-};

package/lib/testkit/test.utils.ts

@@ -1,79 +0,0 @@
-import type { Mock } from "vitest";
-import { vi } from "vitest";
-import type { HttpServiceStatus } from "../http/http.models.js";
-import type { CommonHeaderNames } from "../models/core.models.js";
-import type { JsonValue } from "../models/json.models.js";
-import type { Header } from "../public_api.js";
-import { isNotUndefined } from "../utils/core.utils.js";
-import { toFetchHeaders } from "../utils/header.utils.js";
-
-export function getFetchJsonMock<TResponseData extends JsonValue>({
-	json,
-	status,
-	responseHeaders,
-}: {
-	readonly json: TResponseData;
-	readonly status: HttpServiceStatus;
-	readonly responseHeaders?: readonly Header[];
-}): Mock<() => Promise<Response>> {
-	return getFetchMock<JsonValue>({
-		status,
-		responseHeaders: responseHeaders ?? [],
-		blob: undefined,
-		json,
-	});
-}
-
-export function getFetchBlobMock({
-	blob,
-	status,
-	responseHeaders,
-}: {
-	readonly blob: Blob;
-	readonly status: HttpServiceStatus;
-	readonly responseHeaders?: readonly Header[];
-}): Mock<() => Promise<Response>> {
-	return getFetchMock<Blob>({
-		blob,
-		status,
-		responseHeaders: responseHeaders ?? [],
-		json: undefined,
-	});
-}
-
-export function getFakeBlob(): Blob {
-	return new Blob(["x"], { type: "text/plain" });
-}
-
-function getFetchMock<TResponseData extends JsonValue | Blob>({
-	json,
-	blob,
-	status,
-	responseHeaders,
-}: {
-	readonly json: TResponseData extends JsonValue ? JsonValue : undefined;
-	readonly blob: TResponseData extends Blob ? Blob : undefined;
-	readonly status: HttpServiceStatus;
-	readonly responseHeaders: readonly Header[];
-}): Mock<() => Promise<Response>> {
-	return vi.fn(() => {
-		const contentTypeHeader: Header | undefined = responseHeaders.find(
-			(m) => m.name.toLowerCase() === ("Content-Type" satisfies CommonHeaderNames).toLowerCase(),
-		)
-			? undefined
-			: {
-					name: "Content-Type" satisfies CommonHeaderNames,
-					value: "application/json",
-				};
-
-		return Promise.resolve<Response>({
-			// only implement the methods we need, ignore the rest
-			...({} as Response),
-			ok: status === 200,
-			headers: toFetchHeaders([...responseHeaders, contentTypeHeader].filter(isNotUndefined)),
-			status,
-			json: async () => await Promise.resolve(json),
-			...(blob ? { blob: async () => await Promise.resolve(blob) } : {}),
-		});
-	});
-}

package/lib/testkit/testkit.models.ts

@@ -1,7 +0,0 @@
-import type { HttpServiceStatus } from "../http/http.models.js";
-import type { JsonValue } from "../models/json.models.js";
-
-export type FetchResponse = {
-	readonly statusCode: HttpServiceStatus;
-	readonly json: JsonValue;
-};

package/lib/testkit_api.ts

@@ -1,3 +0,0 @@
-// biome-ignore lint/performance/noBarrelFile: One barrel for the Devkit API is fine
-export { getFakeBlob, getFetchBlobMock, getFetchJsonMock } from "./testkit/test.utils.js";
-export type { FetchResponse } from "./testkit/testkit.models.js";

package/lib/utils/core.utils.ts

@@ -1,3 +0,0 @@
-export function isNotUndefined<T>(value: T): value is NonNullable<T> {
-	return value !== undefined;
-}

package/lib/utils/error.utils.ts

@@ -1,48 +0,0 @@
-import type { AdapterResponse } from "../http/http.models.js";
-import type { HttpMethod, KontentErrorResponseData, KontentValidationError } from "../models/core.models.js";
-import type { CoreSdkError, ErrorReason } from "../models/error.models.js";
-import { isNotUndefined } from "./core.utils.js";
-
-export function isKontent404Error(error: CoreSdkError): error is CoreSdkError<"invalidResponse"> {
-	return isErrorOfType("invalidResponse", error) && error.status === 404;
-}
-
-export function getErrorMessage({
-	method,
-	url,
-	adapterResponse,
-	kontentErrorResponse,
-}: {
-	readonly url: string;
-	readonly method: HttpMethod;
-	readonly adapterResponse: AdapterResponse;
-	readonly kontentErrorResponse?: KontentErrorResponseData;
-}): string {
-	const details = kontentErrorResponse ? getKontentErrorResponseMessage(adapterResponse, kontentErrorResponse) : undefined;
-	return `Failed to execute '${method}' request '${url}'.${details ? ` ${details}` : ""}`;
-}
-
-function isErrorOfType<TReason extends ErrorReason>(reason: TReason, error: CoreSdkError): error is CoreSdkError<TReason> {
-	return error.reason === reason;
-}
-
-function getValidationErrorMessage(validationErrors?: readonly KontentValidationError[]): string | undefined {
-	if (!validationErrors?.length) {
-		return undefined;
-	}
-	return validationErrors
-		.map((m) => {
-			const details: readonly string[] = [
-				m.path ? `path: ${m.path}` : undefined,
-				m.line ? `line: ${m.line}` : undefined,
-				m.position ? `position: ${m.position}` : undefined,
-			].filter(isNotUndefined);
-			return `${m.message}${details.length ? ` (${details.join(", ")})` : ""}`;
-		})
-		.join(", ");
-}
-
-function getKontentErrorResponseMessage(adapterResponse: AdapterResponse, kontentErrorResponse: KontentErrorResponseData): string {
-	const validationErrorMessage = getValidationErrorMessage(kontentErrorResponse.validation_errors);
-	return `Response failed with status '${adapterResponse.status}' and status text '${adapterResponse.statusText}'.${kontentErrorResponse.message}${validationErrorMessage ? ` ${validationErrorMessage}` : ""}`;
-}

package/lib/utils/header.utils.ts

@@ -1,40 +0,0 @@
-import type { CommonHeaderNames, Header, SDKInfo } from "../models/core.models.js";
-
-export function getSdkIdHeader(info: SDKInfo): Header {
-	return {
-		name: "X-KC-SDKID" satisfies CommonHeaderNames,
-		value: `${info.host};${info.name};${info.version}`,
-	};
-}
-
-export function getRetryAfterHeaderValue(headers: readonly Header[]): number | undefined {
-	const retryAfterHeader = headers.find(
-		(header) => header.name.toLowerCase() === ("Retry-After" satisfies CommonHeaderNames).toLowerCase(),
-	);
-
-	if (!retryAfterHeader) {
-		return undefined;
-	}
-
-	const numberValue = +retryAfterHeader.value;
-
-	if (!Number.isSafeInteger(numberValue)) {
-		return undefined;
-	}
-
-	return numberValue;
-}
-
-export function toSdkHeaders(headers: Headers): readonly Header[] {
-	return Array.from(headers.entries()).map(([key, value]) => ({
-		name: key,
-		value: value,
-	}));
-}
-
-export function toFetchHeaders(headers: readonly Header[]): Headers {
-	return headers.reduce<Headers>((headers, header) => {
-		headers.append(header.name, header.value);
-		return headers;
-	}, new Headers());
-}

package/lib/utils/retry.utils.ts

@@ -1,156 +0,0 @@
-import type { HttpResponse } from "../http/http.models.js";
-import type { Header, HttpMethod, RetryStrategyOptions } from "../models/core.models.js";
-import type { CoreSdkError } from "../models/error.models.js";
-import type { JsonValue } from "../models/json.models.js";
-import { getRetryAfterHeaderValue } from "./header.utils.js";
-
-type RetryResult =
-	| {
-			readonly canRetry: false;
-	  }
-	| {
-			readonly canRetry: true;
-			readonly retryInMs: number;
-	  };
-
-const defaultMaxRetries: NonNullable<RetryStrategyOptions["maxRetries"]> = 3;
-const getDefaultDelayBetweenRetriesMs: NonNullable<RetryStrategyOptions["getDelayBetweenRetriesMs"]> = (error) => {
-	if (error.reason === "notFound" || error.reason === "invalidResponse") {
-		return getRetryFromHeaderMs({ error });
-	}
-
-	return 0;
-};
-const defaultCanRetryError: NonNullable<RetryStrategyOptions["canRetryError"]> = (error) => {
-	if (error.reason === "invalidResponse") {
-		if (error.kontentErrorResponse) {
-			// The request is clearly invalid as we got an error response from the API
-			return false;
-		}
-
-		return error.status >= 500 || error.status === 429;
-	}
-
-	return true;
-};
-
-export async function runWithRetryAsync<TResponse extends JsonValue | Blob, TBodyData extends JsonValue | Blob>(data: {
-	readonly funcAsync: () => Promise<HttpResponse<TResponse, TBodyData>>;
-	readonly retryStrategyOptions: Required<RetryStrategyOptions>;
-	readonly retryAttempt: number;
-	readonly url: string;
-	readonly requestHeaders: readonly Header[];
-	readonly method: HttpMethod;
-}): Promise<HttpResponse<TResponse, TBodyData>> {
-	const { success, response, error } = await data.funcAsync();
-
-	if (success) {
-		return {
-			success: true,
-			response,
-		};
-	}
-
-	const newRetryAttempt = data.retryAttempt + 1;
-
-	const retryResult = getRetryResult({
-		error,
-		retryAttempt: data.retryAttempt,
-		options: data.retryStrategyOptions,
-	});
-
-	if (!retryResult.canRetry) {
-		return {
-			success: false,
-			error: {
-				...error,
-				retryAttempt: data.retryAttempt,
-				retryStrategyOptions: data.retryStrategyOptions,
-			},
-		};
-	}
-
-	logRetryAttempt(data.retryStrategyOptions, newRetryAttempt, data.url);
-
-	await waitAsync(retryResult.retryInMs);
-
-	return await runWithRetryAsync({
-		funcAsync: data.funcAsync,
-		retryStrategyOptions: data.retryStrategyOptions,
-		retryAttempt: newRetryAttempt,
-		url: data.url,
-		requestHeaders: data.requestHeaders,
-		method: data.method,
-	});
-}
-
-export function toRequiredRetryStrategyOptions(options?: RetryStrategyOptions): Required<RetryStrategyOptions> {
-	const maxRetries: number = options?.maxRetries ?? defaultMaxRetries;
-
-	return {
-		maxRetries: maxRetries,
-		canRetryError: options?.canRetryError ?? defaultCanRetryError,
-		getDelayBetweenRetriesMs: options?.getDelayBetweenRetriesMs ?? getDefaultDelayBetweenRetriesMs,
-		logRetryAttempt:
-			options?.logRetryAttempt === false
-				? false
-				: (attempt, url) => {
-						if (options?.logRetryAttempt) {
-							options.logRetryAttempt(attempt, url);
-						} else {
-							console.warn(getDefaultRetryAttemptLogMessage(attempt, maxRetries, url));
-						}
-					},
-	};
-}
-
-export function getDefaultRetryAttemptLogMessage(retryAttempt: number, maxRetries: number, url: string): string {
-	return `Retry attempt '${retryAttempt}' from a maximum of '${maxRetries}' retries. Requested url: '${url}'`;
-}
-
-function logRetryAttempt(opts: Pick<RetryStrategyOptions, "logRetryAttempt">, retryAttempt: number, url: string): void {
-	if (opts.logRetryAttempt) {
-		opts.logRetryAttempt(retryAttempt, url);
-	}
-}
-
-function waitAsync(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function getRetryResult({
-	retryAttempt,
-	error,
-	options,
-}: {
-	readonly retryAttempt: number;
-	readonly error: CoreSdkError;
-	readonly options: Required<RetryStrategyOptions>;
-}): RetryResult {
-	if (retryAttempt >= options.maxRetries) {
-		return {
-			canRetry: false,
-		};
-	}
-
-	if (!options.canRetryError(error)) {
-		return {
-			canRetry: false,
-		};
-	}
-
-	return {
-		canRetry: true,
-		retryInMs: options.getDelayBetweenRetriesMs(error),
-	};
-}
-
-function getRetryFromHeaderMs({ error }: { readonly error: CoreSdkError<"invalidResponse" | "notFound"> }): number {
-	const retryAfterHeaderValue = getRetryAfterHeaderValue(error.responseHeaders);
-
-	if (retryAfterHeaderValue) {
-		return retryAfterHeaderValue * 1000;
-	}
-
-	return 0;
-}

package/lib/utils/sdk-version.utils.ts

@@ -1,16 +0,0 @@
-import { readFileSync, writeFileSync } from "node:fs";
-import chalk from "chalk";
-
-const sdkVersionPlaceholderMacro = "{{version}}";
-
-export function replaceSdkVersionPlaceholder(filePath: string, version: string): void {
-	const fileContent = readFileSync(filePath, "utf8");
-
-	if (!fileContent.includes(sdkVersionPlaceholderMacro)) {
-		throw new Error(`File '${filePath}' does not contain macro '${sdkVersionPlaceholderMacro}'`);
-	}
-
-	writeFileSync(filePath, fileContent.replace(sdkVersionPlaceholderMacro, version));
-
-	console.log(`Updated SDK version in '${chalk.yellow(filePath)}' to '${chalk.green(version)}'`);
-}

package/lib/utils/try.utils.ts

@@ -1,30 +0,0 @@
-type Success<TData> = {
-	readonly success: true;
-	readonly data: TData;
-	readonly error?: never;
-};
-
-type Failure<TError = unknown> = {
-	readonly success: false;
-	readonly data?: never;
-	readonly error: TError;
-};
-
-export type Result<TData, TError = unknown> = Success<TData> | Failure<TError>;
-
-export async function tryCatchAsync<T>(fn: () => Promise<T>): Promise<Result<T>> {
-	try {
-		const data = await fn();
-		return { success: true, data };
-	} catch (error) {
-		return { success: false, error };
-	}
-}
-
-export function tryCatch<T>(fn: () => T): Result<T> {
-	try {
-		return { success: true, data: fn() };
-	} catch (error) {
-		return { success: false, error };
-	}
-}