@sitecore-content-sdk/content 1.5.0-canary.10

package/dist/esm/site/siteinfo-service.js

@@ -0,0 +1,87 @@
+import { MemoryCacheClient } from '@sitecore-content-sdk/core';
+import debug from '../debug';
+const siteQuery = /* GraphQL */ `
+  query {
+    site {
+      siteInfoCollection {
+        name
+        hostName: hostname
+        language
+      }
+    }
+  }
+`;
+/**
+ * Service to fetch site information
+ * @public
+ */
+export class SiteInfoService {
+    /**
+     * Creates an instance of graphQL service to retrieve site configuration list from Sitecore
+     * @param {SiteInfoServiceConfig} config instance
+     */
+    constructor(config) {
+        this.config = config;
+        this.graphQLClient = this.getGraphQLClient();
+        this.cache = this.getCacheClient();
+    }
+    /**
+     * site query is available on XM Cloud and XP 10.4+
+     */
+    get siteQuery() {
+        return siteQuery;
+    }
+    async fetchSiteInfo(fetchOptions) {
+        var _a, _b;
+        const cachedResult = this.cache.getCacheValue(this.getCacheKey());
+        if (cachedResult) {
+            return cachedResult;
+        }
+        if (process.env.SITECORE) {
+            debug.multisite('Skipping site information fetch (building on XM Cloud)');
+            return [];
+        }
+        const response = await this.graphQLClient.request(this.siteQuery, {}, fetchOptions);
+        const results = (_b = (_a = response === null || response === void 0 ? void 0 : response.site) === null || _a === void 0 ? void 0 : _a.siteInfoCollection) === null || _b === void 0 ? void 0 : _b.reduce((result, current) => {
+            // filter out built in website
+            current.name !== 'website' &&
+                result.push({
+                    name: current.name,
+                    hostName: current.hostName,
+                    language: current.language,
+                });
+            return result;
+        }, []);
+        this.cache.setCacheValue(this.getCacheKey(), results);
+        return results;
+    }
+    /**
+     * Gets cache client implementation
+     * Override this method if custom cache needs to be used
+     * @returns CacheClient instance
+     */
+    getCacheClient() {
+        var _a, _b;
+        return new MemoryCacheClient({
+            cacheEnabled: (_a = this.config.cacheEnabled) !== null && _a !== void 0 ? _a : true,
+            cacheTimeout: (_b = this.config.cacheTimeout) !== null && _b !== void 0 ? _b : 10,
+        });
+    }
+    /**
+     * 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
+     */
+    getGraphQLClient() {
+        if (!this.config.clientFactory) {
+            throw new Error('clientFactory needs to be provided when initializing GraphQL client.');
+        }
+        return this.config.clientFactory({
+            debugger: debug.multisite,
+        });
+    }
+    getCacheKey() {
+        return 'siteinfo-service-cache';
+    }
+}

package/dist/esm/site/sitemap-xml-service.js

@@ -0,0 +1,85 @@
+import debug from '../debug';
+import { siteNameError } from '../constants';
+const PREFIX_NAME_SITEMAP = 'sitemap';
+// The default query for request sitemaps
+const defaultQuery = /* GraphQL */ `
+  query SitemapQuery($siteName: String!) {
+    site {
+      siteInfo(site: $siteName) {
+        sitemap
+      }
+    }
+  }
+`;
+/**
+ * Service that fetch the sitemaps data using Sitecore's GraphQL API.
+ * @public
+ */
+export class SitemapXmlService {
+    /**
+     * Creates an instance of graphQL sitemaps service with the provided options
+     * @param {SitemapXmlServiceConfig} options instance
+     */
+    constructor(options) {
+        this.options = options;
+        this.graphQLClient = this.getGraphQLClient();
+    }
+    get query() {
+        return defaultQuery;
+    }
+    /**
+     * Fetch list of sitemaps for the site
+     * @returns {string[]} list of sitemap paths
+     * @param {FetchOptions} [fetchOptions] Options to override graphQL client details like retries and fetch implementation
+     * @throws {Error} if the siteName is empty.
+     */
+    async fetchSitemaps(fetchOptions) {
+        const siteName = this.options.siteName;
+        if (!siteName) {
+            throw new Error(siteNameError);
+        }
+        const sitemapResult = this.graphQLClient.request(this.query, {
+            siteName,
+        }, fetchOptions);
+        try {
+            return sitemapResult.then((result) => result.site.siteInfo.sitemap);
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+    /**
+     * Get sitemap file path for sitemap id
+     * @param {string} id the sitemap id (can be empty for default 'sitemap.xml' file)
+     * @returns {string | undefined} the sitemap file path or undefined if one doesn't exist
+     */
+    async getSitemap(id) {
+        let searchSitemap;
+        if (id === undefined) {
+            return undefined;
+        }
+        else if (id === '') {
+            searchSitemap = `${PREFIX_NAME_SITEMAP}.xml`;
+        }
+        else {
+            const normalizedId = id.startsWith('-') ? id.slice(1) : id;
+            searchSitemap = `${PREFIX_NAME_SITEMAP}-${normalizedId}.xml`;
+        }
+        const sitemaps = await this.fetchSitemaps();
+        return sitemaps.find((sitemap) => sitemap.includes(searchSitemap));
+    }
+    /**
+     * 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
+     */
+    getGraphQLClient() {
+        if (!this.options.clientFactory) {
+            throw new Error('clientFactory needs to be provided when initializing GraphQL client.');
+        }
+        return this.options.clientFactory({
+            debugger: debug.sitemap,
+        });
+    }
+}

package/dist/esm/site/sitepath-service.js

@@ -0,0 +1,193 @@
+import { getPersonalizedRewrite } from '../personalize';
+import { getSiteRewrite } from '../site';
+import debug from '../debug';
+/** @private */
+export const languageError = 'The list of languages cannot be empty';
+export const siteError = 'The service needs a site name';
+export const sitesError = 'The list of sites cannot be empty';
+/**
+ * @param {string} siteName to inject into error text
+ * @private
+ */
+export function getSiteEmptyError(siteName) {
+    return `Site "${siteName}" does not exist or site item tree is missing`;
+}
+/**
+ * GQL query made dynamic based whether personalization is enabled or not
+ * @param {boolean} usesPersonalize flag to detrmine which variation of a query to run
+ * @returns GraphQL query to fetch site paths with
+ */
+const defaultQuery = (usesPersonalize) => /* GraphQL */ `
+query ${usesPersonalize ? 'PersonalizeSitemapQuery' : 'DefaultSitemapQuery'}(
+  $siteName: String!
+  $language: String!
+  $includedPaths: [String]
+  $excludedPaths: [String]
+  $pageSize: Int = 100
+  $after: String
+) {
+  site {
+    siteInfo(site: $siteName) {
+      routes(
+        language: $language
+        includedPaths: $includedPaths
+        excludedPaths: $excludedPaths
+        first: $pageSize
+        after: $after
+      ){
+        total
+        pageInfo {
+          endCursor
+          hasNext
+        }
+        results {
+          path: routePath
+          ${usesPersonalize
+    ? `
+              route {
+                personalization {
+                  variantIds
+                }
+              }`
+    : ''}
+        }
+      }
+    }
+  }
+}
+`;
+/**
+ * Service that fetches the list of site pages using Sitecore's GraphQL API.
+ * Used to handle a single site
+ * This list is used for SSG and Export functionality.
+ * @mixes SearchQueryService<PageListQueryResult>
+ * @public
+ */
+export class SitePathService {
+    /**
+     * Creates an instance of graphQL sitemap service with the provided options
+     * @param {SitePathServiceConfig} options instance
+     */
+    constructor(options) {
+        this.options = options;
+        this._graphQLClient = this.getGraphQLClient();
+    }
+    /**
+     * GraphQL client accessible by descendant classes when needed
+     */
+    get graphQLClient() {
+        return this._graphQLClient;
+    }
+    /**
+     * Gets the default query used for fetching the list of site pages
+     */
+    get query() {
+        return defaultQuery(this.options.includePersonalizedRoutes);
+    }
+    /**
+     * Fetch a flat list of all pages that belong to all the requested sites and have a
+     * version in the specified language(s).
+     * @param {string[]} sites Fetch pages for these sites.
+     * @param {string[]} languages Fetch pages that have versions in this language(s).
+     * @param {FetchOptions} fetchOptions Options to override graphQL client details like retries and fetch implementation
+     * @returns list of pages
+     * @throws {RangeError} if the list of languages is empty.
+     * @throws {RangeError} if the any of the languages is an empty string.
+     */
+    async fetchSiteRoutes(sites, languages, fetchOptions) {
+        const formatPath = (path, locale) => ({
+            params: {
+                path,
+            },
+            locale,
+        });
+        const paths = new Array();
+        if (!languages.length) {
+            throw new RangeError(languageError);
+        }
+        // Get all sites
+        if (!sites || !sites.length) {
+            throw new RangeError(sitesError);
+        }
+        // Fetch paths for each site
+        for (let i = 0; i < sites.length; i++) {
+            for (const language of languages) {
+                // Fetch paths using all locales
+                const sitePaths = await this.fetchLanguageSitePaths(language, sites[i], fetchOptions);
+                const transformedPaths = await this.transformLanguageSitePaths(sitePaths, formatPath, language);
+                paths.push(...transformedPaths);
+            }
+        }
+        return [].concat(...paths);
+    }
+    async transformLanguageSitePaths(sitePaths, formatStaticPath, language) {
+        const toSegments = (p) => decodeURI(p)
+            .replace(/^\/|\/$/g, '')
+            .split('/');
+        const aggregatedPaths = [];
+        sitePaths.forEach((item) => {
+            var _a, _b, _c;
+            if (!item)
+                return;
+            aggregatedPaths.push(formatStaticPath(toSegments(item.path), language));
+            const variantIds = (_c = (_b = (_a = item.route) === null || _a === void 0 ? void 0 : _a.personalization) === null || _b === void 0 ? void 0 : _b.variantIds) === null || _c === void 0 ? void 0 : _c.filter((variantId) => !variantId.includes('_') // exclude component A/B test
+            );
+            if (variantIds === null || variantIds === void 0 ? void 0 : variantIds.length) {
+                aggregatedPaths.push(...variantIds.map((varId) => formatStaticPath(toSegments(getPersonalizedRewrite(item.path, [varId])), language)));
+            }
+        });
+        return aggregatedPaths;
+    }
+    /**
+     * 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
+     */
+    getGraphQLClient() {
+        if (!this.options.clientFactory) {
+            throw new Error('clientFactory needs to be provided when initializing GraphQL client.');
+        }
+        return this.options.clientFactory({
+            debugger: debug.sitemap,
+        });
+    }
+    /**
+     * Fetch and return site paths for multisite implementation, with prefixes included
+     * @param {string} language path language
+     * @param {string} siteName site name
+     * @param {FetchOptions} fetchOptions Options to override graphQL client details like retries and fetch implementation
+     * @returns modified paths
+     */
+    async fetchLanguageSitePaths(language, siteName, fetchOptions) {
+        var _a, _b, _c, _d;
+        const args = {
+            siteName: siteName,
+            language: language,
+            pageSize: this.options.pageSize,
+            includedPaths: this.options.includedPaths,
+            excludedPaths: this.options.excludedPaths,
+        };
+        let results = [];
+        let hasNext = true;
+        let after = '';
+        debug.sitemap('fetching sitemap data for %s %s', language, siteName);
+        while (hasNext) {
+            const fetchResponse = await this.graphQLClient.request(this.query, Object.assign(Object.assign({}, args), { after }), fetchOptions);
+            if (!((_a = fetchResponse === null || fetchResponse === void 0 ? void 0 : fetchResponse.site) === null || _a === void 0 ? void 0 : _a.siteInfo)) {
+                throw new RangeError(getSiteEmptyError(siteName));
+            }
+            else {
+                results = results.concat((_b = fetchResponse.site.siteInfo.routes) === null || _b === void 0 ? void 0 : _b.results);
+                hasNext = (_c = fetchResponse.site.siteInfo.routes) === null || _c === void 0 ? void 0 : _c.pageInfo.hasNext;
+                after = (_d = fetchResponse.site.siteInfo.routes) === null || _d === void 0 ? void 0 : _d.pageInfo.endCursor;
+            }
+        }
+        results.forEach((item) => {
+            if (item) {
+                item.path = getSiteRewrite(item.path, { siteName: siteName });
+            }
+        });
+        return results;
+    }
+}

package/dist/esm/site/utils.js

@@ -0,0 +1,49 @@
+/**
+ * Site prefix for rewrite path
+ * @public
+ */
+export const SITE_PREFIX = '_site_';
+/**
+ * Site key for cookie and query string parameter access
+ * @public
+ */
+export const SITE_KEY = 'sc_site';
+/**
+ * Get a site rewrite path for given pathname
+ * @param {string} pathname the pathname
+ * @param {SiteRewriteData} data the site data to include in the rewrite
+ * @returns {string} the rewrite path
+ * @public
+ */
+export function getSiteRewrite(pathname, data) {
+    const path = pathname.startsWith('/') ? pathname : '/' + pathname;
+    return `/${SITE_PREFIX}${data.siteName}${path}`;
+}
+/**
+ * Get site data from the rewrite path
+ * @param {string} pathname the pathname
+ * @param {string} defaultSiteName the default site name
+ * @returns {SiteRewriteData} the site data from the rewrite
+ * @public
+ */
+export function getSiteRewriteData(pathname, defaultSiteName) {
+    const data = {
+        siteName: defaultSiteName,
+    };
+    const path = pathname.endsWith('/') ? pathname : pathname + '/';
+    const result = path.match(`${SITE_PREFIX}(.*?)\\/`);
+    if (result && result[1] !== '') {
+        data.siteName = result[1];
+    }
+    return data;
+}
+/**
+ * Normalize a site rewrite path (remove site data)
+ * @param {string} pathname the pathname
+ * @returns {string} the pathname with site data removed
+ * @public
+ */
+export function normalizeSiteRewrite(pathname) {
+    const result = pathname.match(`${SITE_PREFIX}.*?(?:\\/|$)`);
+    return result === null ? pathname : pathname.replace(result[0], '');
+}

package/dist/esm/sitecore-service-base.js

@@ -0,0 +1,29 @@
+import { debug } from '@sitecore-content-sdk/core';
+/**
+ * Base abstraction to implement custom layout service
+ */
+export class SitecoreServiceBase {
+    /**
+     * Fetch layout data using the Sitecore GraphQL endpoint.
+     * @param {GraphQLServiceConfig} serviceConfig configuration
+     */
+    constructor(serviceConfig) {
+        this.serviceConfig = serviceConfig;
+        this.graphQLClient = this.getGraphQLClient();
+    }
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    getGraphQLClient() {
+        var _a, _b;
+        if (!this.serviceConfig.clientFactory) {
+            throw new Error('clientFactory needs to be provided when initializing GraphQL client.');
+        }
+        return this.serviceConfig.clientFactory({
+            debugger: this.serviceConfig.debugger || debug.http,
+            retries: (_a = this.serviceConfig.retries) === null || _a === void 0 ? void 0 : _a.count,
+            retryStrategy: (_b = this.serviceConfig.retries) === null || _b === void 0 ? void 0 : _b.retryStrategy,
+        });
+    }
+}

package/dist/esm/tools/codegen/component-generation.js

@@ -0,0 +1,44 @@
+import { constants, debug } from '@sitecore-content-sdk/core';
+const { SITECORE_EDGE_PLATFORM_URL_DEFAULT } = constants;
+/**
+ * Gets the component spec url.
+ * @param {GetComponentSpecParams} params - The parameters for getting the component spec url.
+ * @returns {string} The component spec url.
+ * @internal
+ */
+export const getComponentSpecUrl = ({ componentId, edgeUrl = SITECORE_EDGE_PLATFORM_URL_DEFAULT, targetPath, token, }) => {
+    let url = `${edgeUrl}/authoring/api/v1/components/generated/${componentId}?token=${token}`;
+    if (targetPath) {
+        url += `&targetPath=${encodeURIComponent(targetPath)}`;
+    }
+    return url;
+};
+/**
+ * Fetches the component spec.
+ * @param {GetComponentSpecParams} params - The parameters for fetching the component spec.
+ * @returns {Promise<ComponentSpec>} The component spec.
+ * @internal
+ */
+export const getComponentSpec = async ({ componentId, edgeUrl = SITECORE_EDGE_PLATFORM_URL_DEFAULT, targetPath, token, }) => {
+    const url = getComponentSpecUrl({ componentId, edgeUrl, targetPath, token });
+    debug.common('Fetching component spec for %s: %s', componentId, url);
+    try {
+        const response = await fetch(url);
+        if (response.status === 404) {
+            throw new Error(`Component '${componentId}' was not found. Please verify the component ID is correct and exists.`);
+        }
+        if (response.status === 401) {
+            throw new Error('The token is incorrect or expired or the component ID is incorrect.');
+        }
+        if (!response.ok) {
+            throw new Error(`Failed to fetch component ${componentId}`);
+        }
+        const spec = await response.json();
+        debug.common('Component spec fetched successfully for %s: %o', componentId, spec);
+        return spec;
+    }
+    catch (error) {
+        debug.common('Failed to fetch component spec: %s', String(error));
+        throw error;
+    }
+};

package/dist/esm/tools/codegen/extract-files.js

@@ -0,0 +1,97 @@
+/* eslint-disable jsdoc/require-jsdoc */
+import chalk from 'chalk';
+import { ExtractedFileType, resolveComponentImportFiles, sendCode, validateDeployContext, readNamedExports, } from './utils';
+import { auth } from '@sitecore-content-sdk/core/tools';
+import { debug } from '@sitecore-content-sdk/core';
+import path from 'path';
+import fs from 'fs';
+/**
+ * Extracts components from the app folder and sends them to XMCloud.
+ * @param {ExtractFilesConfig} args - Config for components extraction
+ * @public
+ */
+export let extractFiles = _extractFiles;
+// mock setup for unit tests to make sinon happy and mock-able with esbuild/tsx
+// https://sinonjs.org/how-to/typescript-swc/
+// This, plus the `_` names make the exports writable for sinon
+export const unitMocks = {
+    set extractFiles(mockImplementation) {
+        extractFiles = mockImplementation;
+    },
+    get extractFiles() {
+        return _extractFiles;
+    },
+};
+function _extractFiles(args = {}) {
+    const authParams = {
+        clientId: process.env.SITECORE_AUTH_CLIENT_ID || '',
+        clientSecret: process.env.SITECORE_AUTH_CLIENT_SECRET || '',
+        authority: process.env.SITECORE_AUTH_AUTHORITY,
+        audience: process.env.SITECORE_AUTH_AUDIENCE,
+    };
+    const renderingHost = process.env.SITECORE_RENDERINGHOST_NAME;
+    return async ({ scConfig }) => {
+        if (!scConfig) {
+            throw new Error('Sitecore configuration is required to be provided');
+        }
+        if ((args.customValidateDeployContext && !args.customValidateDeployContext()) ||
+            !validateDeployContext()) {
+            debug.common('Skipping code extraction, not in deploy context');
+            return;
+        }
+        if (scConfig.disableCodeGeneration) {
+            debug.common('Skipping code extraction, code generation has been disabled');
+            return;
+        }
+        console.log(chalk.green('Code extraction started'));
+        const basePath = process.cwd();
+        try {
+            // Use Edge Platform mesh endpoint - staging is ready, prod QA in progress
+            const targetUrl = scConfig.api.edge.edgeUrl;
+            const { accessToken } = await auth.clientCredentialsFlow(authParams);
+            if (!accessToken) {
+                console.error(chalk.red('Failed to get access token, aborting code extraction'));
+                return;
+            }
+            // Resolve files from component-map
+            const resolvedImports = await resolveComponentImportFiles(basePath, args.componentMapPath);
+            const clientComponentMapPath = args.clientComponentMapPath || '.sitecore/component-map.client.ts';
+            const absClientMapPath = path.isAbsolute(clientComponentMapPath)
+                ? clientComponentMapPath
+                : path.resolve(basePath, clientComponentMapPath);
+            const exists = fs.existsSync(absClientMapPath);
+            if (exists) {
+                resolvedImports.push(...(await resolveComponentImportFiles(basePath, absClientMapPath)));
+            }
+            const fileDispatches = [];
+            for (const { componentKey, filePath, fileType } of resolvedImports) {
+                let extraLabels;
+                // return an array of export names (e.g., ['Default','Cooler'])
+                const variantNames = readNamedExports(filePath);
+                extraLabels = Object.assign(Object.assign({}, (variantNames.length ? { variantNames } : {})), (renderingHost ? { renderingHost } : {}));
+                fileDispatches.push(sendCode({
+                    file: {
+                        labels: extraLabels,
+                        name: componentKey,
+                        path: filePath,
+                        type: fileType,
+                    },
+                    targetUrl,
+                    token: accessToken,
+                }));
+            }
+            fileDispatches.push(sendCode({
+                file: Object.assign(Object.assign({}, (renderingHost ? { labels: { renderingHost } } : {})), { name: 'package.json', path: path.resolve(basePath, './package.json'), type: ExtractedFileType.PackageJson }),
+                targetUrl,
+                token: accessToken,
+            }));
+            const files = await Promise.all(fileDispatches);
+            console.log(chalk.green(`Code extraction completed successfully, files extracted:\r\n${files
+                .filter((file) => file !== null)
+                .join('\r\n')}`));
+        }
+        catch (error) {
+            console.warn(chalk.yellow('Error during code extraction:', error, error.stack));
+        }
+    };
+}