@sitecore-content-sdk/core 0.1.0-beta.1

package/types/layout/utils.d.ts

@@ -0,0 +1,40 @@
+import { ComponentRendering, ComponentFields, Field, GenericFieldValue } from './models';
+/**
+ * Safely extracts a field value from a rendering or fields object.
+ * Null will be returned if the field is not defined.
+ * @param {ComponentRendering | Fields} renderingOrFields the rendering or fields object to extract the field from
+ * @param {string} fieldName the name of the field to extract
+ * @returns {T | undefined} the field value or null if the field is not defined
+ */
+export declare function getFieldValue<T>(renderingOrFields: ComponentRendering | ComponentFields, fieldName: string): T | undefined;
+export declare function getFieldValue<T>(renderingOrFields: ComponentRendering | ComponentFields, fieldName: string, defaultValue: T): T;
+/**
+ * Gets rendering definitions in a given child placeholder under a current rendering.
+ * @param {ComponentRendering} rendering
+ * @param {string} placeholderName
+ * @returns {ComponentRendering[]} child placeholder
+ */
+export declare function getChildPlaceholder(rendering: ComponentRendering, placeholderName: string): ComponentRendering[];
+/**
+ * Returns a regular expression pattern for a dynamic placeholder name.
+ * @param {string} placeholder Placeholder name with a dynamic segment (e.g. 'main-{*}')
+ * @returns Regular expression pattern for the dynamic segment
+ */
+export declare const getDynamicPlaceholderPattern: (placeholder: string) => RegExp;
+/**
+ * Checks if the placeholder name is dynamic.
+ * @param {string} placeholder Placeholder name
+ * @returns True if the placeholder name is dynamic
+ */
+export declare const isDynamicPlaceholder: (placeholder: string) => boolean;
+/**
+ * The default value for an empty Date field.
+ * This value is defined as a default one by .NET
+ */
+export declare const EMPTY_DATE_FIELD_VALUE = "0001-01-01T00:00:00Z";
+/**
+ * Determines if the passed in field object's value is empty.
+ * @param {GenericFieldValue | Partial<Field>} field the field object.
+ * Partial<T> type is used here because _field.value_ could be required or optional for the different field types
+ */
+export declare function isFieldValueEmpty(field: GenericFieldValue | Partial<Field>): boolean;

package/types/media/index.d.ts

@@ -0,0 +1,2 @@
+import * as mediaApi from './media-api';
+export { mediaApi };

package/types/media/media-api.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Get required query string params which should be merged with user params
+ * @param {object} qs layout service parsed query string
+ * @returns {object} requiredParams
+ */
+export declare const getRequiredParams: (qs: {
+    [key: string]: string | undefined;
+}) => {
+    rev: string | undefined;
+    db: string | undefined;
+    la: string | undefined;
+    vs: string | undefined;
+    ts: string | undefined;
+};
+/**
+ * Replace `/~/media` or `/-/media` with `/~/jssmedia` or `/-/jssmedia`, respectively.
+ * Can use `mediaUrlPrefix` in order to use a custom prefix.
+ * @param {string} url The URL to replace the media URL prefix in
+ * @param {RegExp} [mediaUrlPrefix] The regex to match the media URL prefix
+ * @returns {string} The URL with the media URL prefix replaced
+ */
+export declare const replaceMediaUrlPrefix: (url: string, mediaUrlPrefix?: RegExp) => string;
+/**
+ * Prepares a Sitecore media URL with `params` for use by the JSS media handler.
+ * This is done by replacing `/~/media` or `/-/media` with `/~/jssmedia` or `/-/jssmedia`, respectively.
+ * Provided `params` are used as the querystring parameters for the media URL.
+ * Can use `mediaUrlPrefix` in order to use a custom prefix.
+ * If no `params` are sent, the original media URL is returned.
+ * @param {string} url The URL to prepare
+ * @param {object} [params] The querystring parameters to use
+ * @param {RegExp} [mediaUrlPrefix] The regex to match the media URL prefix
+ * @returns {string} The prepared URL
+ */
+export declare const updateImageUrl: (url: string, params?: {
+    [key: string]: string | number | undefined;
+} | null, mediaUrlPrefix?: RegExp) => string;
+/**
+ * Receives an array of `srcSet` parameters that are iterated and used as parameters to generate
+ * a corresponding set of updated Sitecore media URLs via @see updateImageUrl. The result is a comma-delimited
+ * list of media URLs with respective dimension parameters.
+ * @example
+ * // returns '/ipsum.jpg?h=1000&w=1000 1000w, /ipsum.jpg?mh=250&mw=250 250w'
+ * getSrcSet('/ipsum.jpg', [{ h: 1000, w: 1000 }, { mh: 250, mw: 250 } ])
+ * More information about `srcSet`: {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img}
+ * @param {string} url The URL to prepare
+ * @param {Array} srcSet The array of parameters to use
+ * @param {object} [imageParams] The querystring parameters to use
+ * @param {RegExp} [mediaUrlPrefix] The regex to match the media URL prefix
+ * @returns {string} The prepared URL
+ */
+export declare const getSrcSet: (url: string, srcSet: Array<{
+    [key: string]: string | number | undefined;
+}>, imageParams?: {
+    [key: string]: string | number | undefined;
+}, mediaUrlPrefix?: RegExp) => string;

package/types/models.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Html <link> tag data model
+ */
+export type HTMLLink = {
+    [key: string]: unknown;
+} & Pick<HTMLLinkElement, 'rel' | 'href'>;

package/types/native-fetcher.d.ts

@@ -0,0 +1,121 @@
+import { Debugger } from './debug';
+type NativeDataFetcherOptions = {
+    /**
+     * Override debugger for logging. Uses 'core:http' by default.
+     */
+    debugger?: Debugger;
+    /**
+     * Override fetch method. Uses native (or polyfilled) fetch by default.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Optional request timeout.
+     */
+    timeout?: number;
+};
+/**
+ * Response data for an HTTP request sent to an API
+ * @template T the type of data model requested
+ */
+export interface NativeDataFetcherResponse<T> {
+    /** HTTP status code of the response (i.e. 200, 404) */
+    status: number;
+    /** HTTP status text of the response (i.e. 'OK', 'Bad Request') */
+    statusText: string;
+    /** Response content */
+    data: T;
+    /** Response headers */
+    headers?: HeadersInit;
+}
+/**
+ * Native fetcher error type to include response text and status
+ */
+export type NativeDataFetcherError = Error & {
+    response: NativeDataFetcherResponse<unknown>;
+};
+/**
+ * A function that fetches data from a given URL and returns a `NativeDataFetcherResponse`.
+ * @param {string} url The URL to request (can include query string parameters).
+ * @param {unknown} [data] Optional data to send with the request (e.g., for POST or PUT requests).
+ * @returns {Promise<NativeDataFetcherResponse<T>>} A promise that resolves to a `NativeDataFetcherResponse<T>`,
+ */
+export type NativeDataFetcherFunction<T> = (url: string, data?: RequestInit) => Promise<NativeDataFetcherResponse<T>>;
+export type NativeDataFetcherConfig = NativeDataFetcherOptions & RequestInit;
+export declare class NativeDataFetcher {
+    protected config: NativeDataFetcherConfig;
+    private abortTimeout?;
+    constructor(config?: NativeDataFetcherConfig);
+    /**
+     * Implements a data fetcher.
+     * @param {string} url The URL to request (may include query string)
+     * @param {RequestInit} [options] Optional fetch options
+     * @returns {Promise<NativeDataFetcherResponse<T>>} response
+     */
+    fetch<T>(url: string, options?: RequestInit): Promise<NativeDataFetcherResponse<T>>;
+    /**
+     * Perform a GET request
+     * @param {string} url The URL to request (may include query string)
+     * @param {RequestInit} [options] Fetch options
+     * @returns {Promise<NativeDataFetcherResponse<T>>} response
+     */
+    get<T>(url: string, options?: RequestInit): Promise<NativeDataFetcherResponse<T>>;
+    /**
+     * Perform a POST request
+     * @param {string} url The URL to request (may include query string)
+     * @param {unknown} body The data to send with the request
+     * @param {RequestInit} [options] Fetch options
+     * @returns {Promise<NativeDataFetcherResponse<T>>} response
+     */
+    post<T>(url: string, body: unknown, options?: RequestInit): Promise<NativeDataFetcherResponse<T>>;
+    /**
+     * Perform a DELETE request
+     * @param {string} url The URL to request (may include query string)
+     * @param {RequestInit} [options] Fetch options
+     * @returns {Promise<NativeDataFetcherResponse<T>>} response
+     */
+    delete<T>(url: string, options?: RequestInit): Promise<NativeDataFetcherResponse<T>>;
+    /**
+     * Perform a PUT request
+     * @param {string} url The URL to request (may include query string)
+     * @param {unknown} body The data to send with the request
+     * @param {RequestInit} [options] Fetch options
+     * @returns {Promise<NativeDataFetcherResponse<T>>} response
+     */
+    put<T>(url: string, body: unknown, options?: RequestInit): Promise<NativeDataFetcherResponse<T>>;
+    /**
+     * Perform a HEAD request
+     * @param {string} url The URL to request (may include query string)
+     * @param {RequestInit} [options] Fetch options
+     * @returns {Promise<NativeDataFetcherResponse<T>>} response
+     */
+    head<T>(url: string, options?: RequestInit): Promise<NativeDataFetcherResponse<T>>;
+    /**
+     * Determines settings for the request
+     * @param {RequestInit} init Custom settings for request
+     * @returns {RequestInit} The final request settings
+     */
+    protected getRequestInit(init?: RequestInit): RequestInit;
+    /**
+     * Safely extract all headers for debug logging
+     * @param {HeadersInit} incomingHeaders Incoming headers
+     * @returns Object with headers as key/value pairs
+     */
+    protected extractDebugHeaders(incomingHeaders?: HeadersInit): {
+        [key: string]: string | string[];
+    };
+    /**
+     * Parses the response data.
+     * @param {Response} response - The fetch response object.
+     * @param {Function} debug - The debug logger function.
+     * @returns {Promise<unknown>} - The parsed response data.
+     */
+    private parseResponse;
+    /**
+     * Creates a custom error for fetch failures.
+     * @param {Response} response - The fetch response object.
+     * @param {unknown} data - The parsed response data.
+     * @returns {NativeDataFetcherError} - The constructed error object.
+     */
+    private createError;
+}
+export {};

package/types/personalize/graphql-personalize-service.d.ts

@@ -0,0 +1,80 @@
+import { GraphQLClient, GraphQLRequestClientFactory } from '../graphql-request-client';
+import { CacheClient, CacheOptions } from '../cache-client';
+export type GraphQLPersonalizeServiceConfig = CacheOptions & {
+    /**
+     * Timeout (ms) for the Personalize request. Default is 400.
+     */
+    timeout?: number;
+    /**
+     * Optional Sitecore Personalize scope identifier allowing you to isolate your personalization data between XM Cloud environments
+     * @deprecated Will be removed in a future release.
+     */
+    scope?: string;
+    /**
+     * Override fetch method. Uses 'GraphQLRequestClient' default otherwise.
+     */
+    fetch?: typeof fetch;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+};
+/**
+ * Object model of personlize info
+ */
+export type PersonalizeInfo = {
+    /**
+     * The page id
+     */
+    pageId: string;
+    /**
+     * The configured variant ids
+     */
+    variantIds: string[];
+};
+type PersonalizeQueryResult = {
+    layout: {
+        item: {
+            id: string;
+            version: string;
+            personalization: {
+                variantIds: string[];
+            };
+        };
+    };
+};
+export declare class GraphQLPersonalizeService {
+    protected config: GraphQLPersonalizeServiceConfig;
+    private graphQLClient;
+    private cache;
+    /**
+     * Fetch personalize data using the Sitecore GraphQL endpoint.
+     * @param {GraphQLPersonalizeServiceConfig} config
+     */
+    constructor(config: GraphQLPersonalizeServiceConfig);
+    protected get query(): string;
+    /**
+     * Get personalize information for a route
+     * @param {string} itemPath page route
+     * @param {string} language language
+     * @param {string} siteName site name
+     * @returns {Promise<PersonalizeInfo | undefined>} the personalize information or undefined (if itemPath / language not found)
+     */
+    getPersonalizeInfo(itemPath: string, language: string, siteName: string): Promise<PersonalizeInfo | undefined>;
+    /**
+     * Gets cache client implementation
+     * Override this method if custom cache needs to be used
+     * @returns CacheClient instance
+     */
+    protected getCacheClient(): CacheClient<PersonalizeQueryResult>;
+    protected getCacheKey(itemPath: string, language: string, siteName: string): string;
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+}
+export {};

package/types/personalize/index.d.ts

@@ -0,0 +1,3 @@
+export { personalizeLayout } from './layout-personalizer';
+export { PersonalizeInfo, GraphQLPersonalizeService, GraphQLPersonalizeServiceConfig, } from './graphql-personalize-service';
+export { getPersonalizedRewrite, getPersonalizedRewriteData, getGroomedVariantIds, normalizePersonalizedRewrite, PersonalizedRewriteData, CdpHelper, DEFAULT_VARIANT, } from './utils';

package/types/personalize/layout-personalizer.d.ts

@@ -0,0 +1,27 @@
+import { LayoutServiceData, ComponentRendering, PlaceholdersData } from '../layout/models';
+export type ComponentRenderingWithExperiences = ComponentRendering & {
+    experiences: {
+        [name: string]: ComponentRenderingWithExperiences;
+    };
+};
+/**
+ * Apply personalization to layout data. This will recursively go through all placeholders/components, check experiences nodes and replace default with object from specific experience.
+ * @param {LayoutServiceData} layout Layout data
+ * @param {string} variantId variant id
+ * @param {string[]} [componentVariantIds] component variant ids
+ */
+export declare function personalizeLayout(layout: LayoutServiceData, variantId: string, componentVariantIds?: string[]): PlaceholdersData<string> | undefined;
+/**
+ * @param {Array} components components within placeholder
+ * @param {string[]} variantIds variant ids
+ * @param {boolean} isEditing indicates if page is rendered in metadata edit mode
+ * @returns {ComponentRendering[]} components with personalization applied
+ */
+export declare function personalizePlaceholder(components: ComponentRendering[], variantIds: string[], isEditing?: boolean): ComponentRendering[];
+/**
+ * @param {ComponentRenderingWithExperiences} component component with experiences
+ * @param {string[]} variantIds variant ids
+ * @param {boolean} isEditing indicates if page is rendered in metadata edit mode
+ * @returns {ComponentRendering | null} component with personalization applied or null if hidden
+ */
+export declare function personalizeComponent(component: ComponentRenderingWithExperiences, variantIds: string[], isEditing?: boolean): ComponentRendering | null;

package/types/personalize/utils.d.ts

@@ -0,0 +1,69 @@
+export declare const DEFAULT_VARIANT = "_default";
+export declare const VARIANT_PREFIX = "_variantId_";
+export type PersonalizedRewriteData = {
+    variantId: string;
+    componentVariantIds?: string[];
+};
+/**
+ * Get a personalized rewrite path for given pathname
+ * @param {string} pathname the pathname
+ * @param {string[]} variantIds the variantIds to include in the rewrite
+ * @returns {string} the rewrite path
+ */
+export declare function getPersonalizedRewrite(pathname: string, variantIds: string[]): string;
+/**
+ * Get personalize data from the rewrite path
+ * @param {string} pathname the pathname
+ * @returns {PersonalizedRewriteData} the personalize data from the rewrite
+ */
+export declare function getPersonalizedRewriteData(pathname: string): PersonalizedRewriteData;
+/**
+ * Parses a list of variantIds and divides into layout and component variants
+ * @param {string[]} variantIds the list of variant IDs for a page
+ * @returns {PersonalizedRewriteData} object with variant IDs sorted
+ */
+export declare function getGroomedVariantIds(variantIds: string[]): PersonalizedRewriteData;
+/**
+ * Normalize a personalized rewrite path (remove personalize data)
+ * @param {string} pathname the pathname
+ * @returns {string} the pathname with personalize data removed
+ */
+export declare function normalizePersonalizedRewrite(pathname: string): string;
+/**
+ * Static utility class for Sitecore CDP
+ */
+export declare class CdpHelper {
+    /**
+     * Gets the page variant id for CDP in the required format
+     * @param {string} pageId the page id
+     * @param {string} language the language
+     * @param {string} variantId the variant id
+     * @param {string} [scope] the scope value
+     * @returns {string} the formatted page variant id
+     */
+    static getPageVariantId(pageId: string, language: string, variantId: string, scope?: string): string;
+    /**
+     * Gets the friendly id for (page-level) Embedded Personalization in the required format `embedded_[<scope>_]<id>_<lang>`
+     * @param {string} pageId the page id
+     * @param {string} language the language
+     * @param {string} [scope] the scope value
+     * @returns {string} the friendly id
+     */
+    static getPageFriendlyId(pageId: string, language: string, scope?: string): string;
+    /**
+     * Gets the friendly id for Component A/B Testing in the required format `component_[<scope>_]<pageId>_<componentId>_<language>*`
+     * @param {string} pageId the page id
+     * @param {string} componentId the component id
+     * @param {string} language the language
+     * @param {string} [scope] the scope value
+     * @returns {string} the friendly id
+     */
+    static getComponentFriendlyId(pageId: string, componentId: string, language: string, scope?: string): string;
+    /**
+     * Normalizes the scope from the given string value
+     * Removes all non-alphanumeric characters
+     * @param {string} [scope] the scope value
+     * @returns {string} normalized scope value
+     */
+    static normalizeScope(scope?: string): string;
+}

package/types/site/graphql-error-pages-service.d.ts

@@ -0,0 +1,57 @@
+import { GraphQLClient, GraphQLRequestClientConfig } from '../graphql';
+import { LayoutServiceData } from '../layout';
+import { GraphQLRequestClientFactory } from '../graphql-request-client';
+export interface GraphQLErrorPagesServiceConfig extends Pick<GraphQLRequestClientConfig, 'retries' | 'retryStrategy'> {
+    /**
+     * The JSS application name
+     */
+    siteName: string;
+    /**
+     * The language
+     */
+    language: string;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+}
+/**
+ * Object model of Error Pages result
+ */
+export type ErrorPages = {
+    notFoundPage: {
+        rendered: LayoutServiceData;
+    };
+    notFoundPagePath: string;
+    serverErrorPage: {
+        rendered: LayoutServiceData;
+    };
+    serverErrorPagePath: string;
+};
+/**
+ * Service that fetch the error pages data using Sitecore's GraphQL API.
+ */
+export declare class GraphQLErrorPagesService {
+    options: GraphQLErrorPagesServiceConfig;
+    private graphQLClient;
+    /**
+     * Creates an instance of graphQL error pages service with the provided options
+     * @param {GraphQLErrorPagesServiceConfig} options instance
+     */
+    constructor(options: GraphQLErrorPagesServiceConfig);
+    protected get query(): string;
+    /**
+     * Fetch list of error pages for the site
+     * @returns {ErrorPages} list of url's error pages
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchErrorPages(): Promise<ErrorPages | null>;
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+}

package/types/site/graphql-redirects-service.d.ts

@@ -0,0 +1,68 @@
+import { GraphQLClient } from '../graphql';
+import { CacheOptions, CacheClient } from '../cache-client';
+import { GraphQLRequestClientFactory } from '../graphql-request-client';
+export declare const REDIRECT_TYPE_301 = "REDIRECT_301";
+export declare const REDIRECT_TYPE_302 = "REDIRECT_302";
+export declare const REDIRECT_TYPE_SERVER_TRANSFER = "SERVER_TRANSFER";
+export type RedirectInfo = {
+    pattern: string;
+    target: string;
+    redirectType: string;
+    isQueryStringPreserved: boolean;
+    locale: string;
+};
+export type GraphQLRedirectsServiceConfig = CacheOptions & {
+    /**
+     * Override fetch method. Uses 'GraphQLRequestClient' default otherwise.
+     */
+    fetch?: typeof fetch;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+};
+/**
+ * The schema of data returned in response to redirects array request
+ */
+export type RedirectsQueryResult = {
+    site: {
+        siteInfo: {
+            redirects: RedirectInfo[];
+        } | null;
+    };
+};
+/**
+ *  The GraphQLRedirectsService class is used to query the JSS redirects using Graphql endpoint
+ */
+export declare class GraphQLRedirectsService {
+    private options;
+    private graphQLClient;
+    private cache;
+    /**
+     * Creates an instance of graphQL redirects service with the provided options
+     * @param {GraphQLRedirectsServiceConfig} options instance
+     */
+    constructor(options: GraphQLRedirectsServiceConfig);
+    protected get query(): string;
+    /**
+     * Fetch an array of redirects from API
+     * @param {string} siteName site name
+     * @returns Promise<RedirectInfo[]>
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchRedirects(siteName: string): Promise<RedirectInfo[]>;
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+    /**
+     * Gets cache client implementation
+     * Override this method if custom cache needs to be used
+     * @returns CacheClient instance
+     */
+    protected getCacheClient(): CacheClient<RedirectsQueryResult>;
+}

package/types/site/graphql-robots-service.d.ts

@@ -0,0 +1,49 @@
+import { GraphQLClient } from '../graphql';
+import { GraphQLRequestClientFactory } from '../graphql-request-client';
+export type GraphQLRobotsServiceConfig = {
+    /**
+     * The JSS application name
+     */
+    siteName: string;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+};
+/**
+ * The schema of data returned in response to robots.txt request
+ */
+export type RobotsQueryResult = {
+    site: {
+        siteInfo: {
+            robots: string;
+        };
+    };
+};
+/**
+ * Service that fetch the robots.txt data using Sitecore's GraphQL API.
+ */
+export declare class GraphQLRobotsService {
+    options: GraphQLRobotsServiceConfig;
+    private graphQLClient;
+    /**
+     * Creates an instance of graphQL robots.txt service with the provided options
+     * @param {GraphQLRobotsServiceConfig} options instance
+     */
+    constructor(options: GraphQLRobotsServiceConfig);
+    protected get query(): string;
+    /**
+     * Fetch a data of robots.txt from API
+     * @returns text of robots.txt
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchRobots(): Promise<string>;
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+}

package/types/site/graphql-siteinfo-service.d.ts

@@ -0,0 +1,70 @@
+import { GraphQLClient } from '../graphql';
+import { CacheClient, CacheOptions } from '../cache-client';
+import { GraphQLRequestClientFactory } from '../graphql-request-client';
+export type SiteInfo = {
+    /**
+     * Additional user-defined properties
+     */
+    [key: string]: unknown;
+    /**
+     * Site name
+     */
+    name: string;
+    /**
+     * Site host name. May include multiple values (separated by '|') and wildcards ('*')
+     */
+    hostName: string;
+    /**
+     * Site default language
+     */
+    language: string;
+};
+export type GraphQLSiteInfoServiceConfig = CacheOptions & {
+    /**
+     * common variable for all GraphQL queries
+     * it will be used for every type of query to regulate result batch size
+     * Optional. How many result items to fetch in each GraphQL call. This is needed for pagination.
+     * @default 10
+     */
+    pageSize?: number;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+};
+export type GraphQLSiteInfoResult = {
+    name: string;
+    hostName: string;
+    language: string;
+};
+export declare class GraphQLSiteInfoService {
+    private config;
+    private graphQLClient;
+    private cache;
+    /**
+     * Creates an instance of graphQL service to retrieve site configuration list from Sitecore
+     * @param {GraphQLSiteInfoServiceConfig} config instance
+     */
+    constructor(config: GraphQLSiteInfoServiceConfig);
+    /**
+     * site query is available on XM Cloud and XP 10.4+
+     */
+    protected get siteQuery(): string;
+    fetchSiteInfo(): Promise<SiteInfo[]>;
+    protected fetchWithSiteQuery(): Promise<SiteInfo[]>;
+    /**
+     * Gets cache client implementation
+     * Override this method if custom cache needs to be used
+     * @returns CacheClient instance
+     */
+    protected getCacheClient(): CacheClient<SiteInfo[]>;
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+    private getCacheKey;
+}