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

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

@@ -0,0 +1,100 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import debug from '../debug';
+import { MemoryCacheClient } from '../cache-client';
+const siteQuery = /* GraphQL */ `
+  query {
+    site {
+      siteInfoCollection {
+        name
+        hostName: hostname
+        language
+      }
+    }
+  }
+`;
+export class GraphQLSiteInfoService {
+    /**
+     * Creates an instance of graphQL service to retrieve site configuration list from Sitecore
+     * @param {GraphQLSiteInfoServiceConfig} 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;
+    }
+    fetchSiteInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 results = yield this.fetchWithSiteQuery();
+            this.cache.setCacheValue(this.getCacheKey(), results);
+            return results;
+        });
+    }
+    fetchWithSiteQuery() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const response = yield this.graphQLClient.request(this.siteQuery);
+            const result = (_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;
+            }, []);
+            return result;
+        });
+    }
+    /**
+     * 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/graphql-sitemap-service.js

@@ -0,0 +1,86 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { siteNameError } from '../constants';
+import debug from '../debug';
+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.
+ */
+export class GraphQLSitemapXmlService {
+    /**
+     * Creates an instance of graphQL sitemaps service with the provided options
+     * @param {GraphQLSitemapXmlServiceConfig} 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
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchSitemaps() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const siteName = this.options.siteName;
+            if (!siteName) {
+                throw new Error(siteNameError);
+            }
+            const sitemapResult = this.graphQLClient.request(this.query, {
+                siteName,
+            });
+            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
+     */
+    getSitemap(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchSitemap = `${PREFIX_NAME_SITEMAP}${id}.xml`;
+            const sitemaps = yield 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/index.js

@@ -0,0 +1,7 @@
+export { GraphQLRobotsService, } from './graphql-robots-service';
+export { REDIRECT_TYPE_301, REDIRECT_TYPE_302, REDIRECT_TYPE_SERVER_TRANSFER, GraphQLRedirectsService, } from './graphql-redirects-service';
+export { GraphQLSitemapXmlService, } from './graphql-sitemap-service';
+export { GraphQLErrorPagesService, } from './graphql-error-pages-service';
+export { GraphQLSiteInfoService, } from './graphql-siteinfo-service';
+export { getSiteRewrite, getSiteRewriteData, normalizeSiteRewrite } from './utils';
+export { SiteResolver } from './site-resolver';

package/dist/esm/site/site-resolver.js

@@ -0,0 +1,75 @@
+// Delimiters for multi-value hostnames
+const DELIMITERS = /\||,|;/g;
+/**
+ * Resolves site based on the provided host or site name
+ */
+export class SiteResolver {
+    /**
+     * @param {SiteInfo[]} sites Array of sites to be used in resolution
+     */
+    constructor(sites) {
+        this.sites = sites;
+        /**
+         * Resolve site by host name
+         * @param {string} hostName the host name
+         * @returns {SiteInfo} the resolved site
+         * @throws {Error} if a matching site is not found
+         */
+        this.getByHost = (hostName) => {
+            for (const [hostname, site] of this.getHostMap()) {
+                if (this.matchesPattern(hostName, hostname)) {
+                    return site;
+                }
+            }
+            throw new Error(`Could not resolve site for host ${hostName}`);
+        };
+        /**
+         * Resolve site by site name
+         * @param {string} siteName the site name
+         * @returns {SiteInfo} the resolved site
+         * @throws {Error} if a matching site is not found
+         */
+        this.getByName = (siteName) => {
+            const siteInfo = this.sites.find((info) => info.name.toLocaleLowerCase() === siteName.toLocaleLowerCase());
+            if (!siteInfo) {
+                throw new Error(`Could not resolve site for name ${siteName}`);
+            }
+            return siteInfo;
+        };
+        this.getHostMap = () => {
+            const map = new Map();
+            // First collect unique hostnames.
+            // For sites with same hostname defined, priority is given to the first encountered.
+            this.sites.forEach((site) => {
+                const hostnames = site.hostName
+                    .replace(/\s/g, '')
+                    .toLocaleLowerCase()
+                    .split(DELIMITERS);
+                hostnames.forEach((hostname) => {
+                    if (!map.has(hostname)) {
+                        map.set(hostname, site);
+                    }
+                });
+            });
+            // Now order by specificity.
+            // This equivalates to sorting from longest to shortest with the assumption
+            // that your match is less specific as wildcards are introduced.
+            // E.g. order.eu.site.com → *.eu.site.com → *.site.com → *
+            // In case of a tie (e.g. *.site.com vs i.site.com), prefer one with less wildcards.
+            return new Map(Array.from(map).sort((a, b) => {
+                if (a[0].length === b[0].length) {
+                    return (a[0].match(/\*/g) || []).length - (b[0].match(/\*/g) || []).length;
+                }
+                return b[0].length - a[0].length;
+            }));
+        };
+    }
+    // b[0].match(/\*/g) || []).length
+    matchesPattern(hostname, pattern) {
+        // dots should be treated as chars
+        // stars should be treated as wildcards
+        const regExpPattern = pattern.replace(/\./g, '\\.').replace(/\*/g, '.*');
+        const regExp = new RegExp(`^${regExpPattern}$`, 'gi');
+        return !!hostname.match(regExp);
+    }
+}

package/dist/esm/site/utils.js

@@ -0,0 +1,37 @@
+export const SITE_PREFIX = '_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
+ */
+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
+ */
+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
+ */
+export function normalizeSiteRewrite(pathname) {
+    const result = pathname.match(`${SITE_PREFIX}.*?(?:\\/|$)`);
+    return result === null ? pathname : pathname.replace(result[0], '');
+}

package/dist/esm/utils/env.js

@@ -0,0 +1,22 @@
+/**
+ * Method to parse JSON-formatted environment variables
+ * @param {string} envValue - can be undefined when providing values via process.env
+ * @param {T} defaultValue - default value
+ * @returns {T | string} parsed value
+ */
+export const tryParseEnvValue = (envValue, defaultValue) => {
+    if (!envValue) {
+        return defaultValue;
+    }
+    if (envValue.startsWith('{') && envValue.endsWith('}')) {
+        try {
+            return JSON.parse(envValue);
+        }
+        catch (error) {
+            console.warn('Parsing of env variable failed');
+            console.warn(`Attempted to parse ${envValue}`);
+            return defaultValue;
+        }
+    }
+    return defaultValue;
+};

package/dist/esm/utils/index.js

@@ -0,0 +1,3 @@
+export { default as isServer } from './is-server';
+export { resolveUrl, isAbsoluteUrl, isTimeoutError, enforceCors, getAllowedOriginsFromEnv, isRegexOrUrl, areURLSearchParamsEqual, escapeNonSpecialQuestionMarks, mergeURLSearchParams, } from './utils';
+export { tryParseEnvValue } from './env';

package/dist/esm/utils/is-server.js

@@ -0,0 +1,8 @@
+/**
+ * Determines whether the current execution context is server-side
+ * @returns true if executing server-side
+ */
+function isServer() {
+    return !(typeof window !== 'undefined' && window.document);
+}
+export default isServer;

package/dist/esm/utils/timeout-promise.js

@@ -0,0 +1,28 @@
+/**
+ * A helper to assign timeouts to fetch or other promises
+ * Useful in nextjs middleware until fetch.signal is fully supported by Vercel edge functions
+ */
+export default class TimeoutPromise {
+    constructor(timeout) {
+        this.timeout = timeout;
+        this.timeoutId = undefined;
+    }
+    /**
+     * Creates a timeout promise
+     */
+    get start() {
+        return new Promise((_, reject) => {
+            this.timeoutId = setTimeout(() => {
+                const abortError = new Error(`Request timed out, timeout of ${this.timeout}ms is exceeded`);
+                abortError.name = 'AbortError';
+                reject(abortError);
+            }, this.timeout);
+        });
+    }
+    /**
+     * Clears the timeout from timeout promise
+     */
+    clear() {
+        this.timeoutId && clearTimeout(this.timeoutId);
+    }
+}

package/dist/esm/utils/utils.js

@@ -0,0 +1,207 @@
+import isServer from './is-server';
+/**
+ * note: encodeURIComponent is available via browser (window) or natively in node.js
+ * if you use another js engine for server-side rendering you may not have native encodeURIComponent
+ * and would then need to install a package for that functionality
+ * @param {ParsedUrlQueryInput} params query string parameters
+ * @returns {string} query string
+ */
+function getQueryString(params) {
+    return Object.keys(params)
+        .map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(String(params[k]))}`)
+        .join('&');
+}
+/**
+ * Resolves a base URL that may contain query string parameters and an additional set of query
+ * string parameters into a unified string representation.
+ * @param {string} urlBase the base URL that may contain query string parameters
+ * @param {ParsedUrlQueryInput} params query string parameters
+ * @returns a URL string
+ * @throws {RangeError} if the provided url is an empty string
+ */
+export function resolveUrl(urlBase, params = {}) {
+    if (!urlBase) {
+        throw new RangeError('url must be a non-empty string');
+    }
+    // This is a better way to work with URLs since it handles different user input
+    // edge cases. This works in Node and all browser except IE11.
+    // https://developer.mozilla.org/en-US/docs/Web/API/URL
+    // TODO: Verify our browser support requirements.
+    if (isServer()) {
+        const url = new URL(urlBase);
+        for (const key in params) {
+            if ({}.hasOwnProperty.call(params, key)) {
+                url.searchParams.append(key, String(params[key]));
+            }
+        }
+        const result = url.toString();
+        return result;
+    }
+    const qs = getQueryString(params);
+    const result = urlBase.indexOf('?') !== -1 ? `${urlBase}&${qs}` : `${urlBase}?${qs}`;
+    return result;
+}
+export const isAbsoluteUrl = (url) => {
+    if (!url) {
+        return false;
+    }
+    if (typeof url !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    return /^[a-z][a-z0-9+.-]*:/.test(url);
+};
+/**
+ * Indicates whether the error is a timeout error
+ * @param {unknown} error error
+ * @returns {boolean} is timeout error
+ */
+export const isTimeoutError = (error) => {
+    var _a;
+    return ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 408 || error.name === 'AbortError';
+};
+/**
+ * Converts a string value in a regex pattern allowing wildcard matching
+ * @param {string} pattern input with wildcards i.e. site.*.com
+ * @returns {string} modified string that can be used as regexp input
+ */
+const convertToWildcardRegex = (pattern) => {
+    return ('^' +
+        pattern
+            .replace(/\//g, '\\/')
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*') +
+        '$');
+};
+/**
+ * Gets allowed origins from JSS_ALLOWED_ORIGINS env variable
+ * @returns {string[]} list of allowed origins from JSS_ALLOWED_ORIGINS env variable
+ */
+export const getAllowedOriginsFromEnv = () => process.env.JSS_ALLOWED_ORIGINS
+    ? process.env.JSS_ALLOWED_ORIGINS.replace(' ', '').split(',')
+    : [];
+/**
+ * Tests origin from incoming request against allowed origins list that can be
+ * set in JSS's JSS_ALLOWED_ORIGINS env variable, passed via allowedOrigins param and/or
+ * be already set in Access-Control-Allow-Origin by other logic.
+ * Applies Access-Control-Allow-Origin and Access-Control-Allow-Methods on match
+ * Also applies Access-Control-Allow-Headers for preflight requests
+ * @param {IncomingMessage} req incoming request
+ * @param {OutgoingMessage} res response to set CORS headers for
+ * @param {string[]} [allowedOrigins] additional list of origins to test against
+ * @returns true if incoming origin matches the allowed lists, false when it does not
+ */
+export const enforceCors = (req, res, allowedOrigins) => {
+    // origin in not present for non-CORS requests (e.g. server-side) - so we skip the checks
+    if (!req.headers.origin) {
+        return true;
+    }
+    // 3 sources of allowed origins are considered:
+    // the env value
+    const defaultAllowedOrigins = getAllowedOriginsFromEnv();
+    // the allowedOrigins prop
+    allowedOrigins = defaultAllowedOrigins.concat(allowedOrigins || []);
+    // and the existing CORS header, if present (i.e. set by nextjs config)
+    const presetCors = res.getHeader('Access-Control-Allow-Origin');
+    if (presetCors) {
+        allowedOrigins.push(presetCors);
+    }
+    const origin = req.headers.origin;
+    if (origin &&
+        allowedOrigins.some((allowedOrigin) => origin === allowedOrigin || new RegExp(convertToWildcardRegex(allowedOrigin)).test(origin))) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE, PUT, PATCH');
+        // set the allowed headers for preflight requests
+        if (req.method === 'OPTIONS') {
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        }
+        return true;
+    }
+    return false;
+};
+/**
+ * Determines whether the given input is a regular expression or resembles a URL.
+ * @param {string} input - The input string to evaluate.
+ * @returns {'regex' | 'url'} - Returns 'url' if the input looks like a URL, otherwise 'regex'.
+ */
+export const isRegexOrUrl = (input) => {
+    // Remove the trailing slash.
+    input = input.slice(0, -1);
+    // Check if the string resembles a URL.
+    const isUrlLike = /^\/[a-zA-Z0-9\-\/]+(\?([a-zA-Z0-9\-_]+=[a-zA-Z0-9\-_]+)(&[a-zA-Z0-9\-_]+=[a-zA-Z0-9\-_]+)*)?$/.test(input);
+    if (isUrlLike) {
+        return 'url';
+    }
+    // If it doesn't resemble a URL, it's likely a regular expression.
+    return 'regex';
+};
+/**
+ * Compares two URLSearchParams objects to determine if they are equal.
+ * @param {URLSearchParams} params1 - The first set of URL search parameters.
+ * @param {URLSearchParams} params2 - The second set of URL search parameters.
+ * @returns {boolean} - Returns true if the parameters are equal, otherwise false.
+ */
+export const areURLSearchParamsEqual = (params1, params2) => {
+    // Generates a sorted string representation of URL search parameters.
+    const getSortedParamsString = (params) => {
+        return [...params.entries()]
+            .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+    };
+    // Compare the sorted strings of both parameter sets.
+    return getSortedParamsString(params1) === getSortedParamsString(params2);
+};
+/**
+ * Escapes non-special "?" characters in a string or regex.
+ * - For regular strings, it escapes all unescaped "?" characters by adding a backslash (`\`).
+ * - For regex patterns (strings enclosed in `/.../`), it analyzes each "?" to determine if it has special meaning
+ *   (e.g., `?` in `(abc)?`, `.*?`, `(?!...)`) or is just a literal character. Only literal "?" characters are escaped.
+ * @param {string} input - The input string or regex pattern.
+ * @returns {string} - The modified string or regex with non-special "?" characters escaped.
+ */
+export const escapeNonSpecialQuestionMarks = (input) => {
+    const regexPattern = /(?<!\\)\?/g; // Match unescaped "?" characters
+    const negativeLookaheadPattern = /\(\?!$/; // Detect the start of a Negative Lookahead pattern
+    const specialRegexSymbols = /[.*+)\[\]|\(]$/; // Check for special regex symbols before "?"
+    let result = '';
+    let lastIndex = 0;
+    let match;
+    while ((match = regexPattern.exec(input)) !== null) {
+        const index = match.index; // Position of the "?" in the string
+        const before = input.slice(lastIndex, index); // Context before the "?"
+        // Check if "?" is part of a Negative Lookahead
+        const isNegativeLookahead = negativeLookaheadPattern.test(before.slice(-3));
+        // Check if "?" follows a special regex symbol
+        const isSpecialRegexSymbol = specialRegexSymbols.test(before.slice(-1));
+        if (isNegativeLookahead || isSpecialRegexSymbol) {
+            // If it's a special case, keep the "?" as is
+            result += input.slice(lastIndex, index + 1);
+        }
+        else {
+            // Otherwise, escape the "?"
+            result += input.slice(lastIndex, index) + '\\?';
+        }
+        lastIndex = index + 1; // Move to the next part of the string
+    }
+    // Append the remaining part of the string
+    result += input.slice(lastIndex);
+    return result;
+};
+/**
+ * Merges two URLSearchParams objects. If both objects contain the same key, the value from the second object overrides the first.
+ * @param {URLSearchParams} params1 - The first set of URL search parameters.
+ * @param {URLSearchParams} params2 - The second set of URL search parameters.
+ * @returns {string} - A string representation of the merged URL search parameters.
+ */
+export const mergeURLSearchParams = (params1, params2) => {
+    const merged = new URLSearchParams();
+    // Add all keys and values from the first object.
+    for (const [key, value] of params1.entries()) {
+        merged.set(key, value);
+    }
+    // Add all keys and values from the second object, replacing existing ones.
+    for (const [key, value] of params2.entries()) {
+        merged.set(key, value);
+    }
+    return merged.toString();
+};

package/editing.d.ts

@@ -0,0 +1 @@
+export * from './types/editing/index';

package/editing.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/editing/index');

package/graphql.d.ts

@@ -0,0 +1 @@
+export * from './types/graphql/index';

package/graphql.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/graphql/index');

package/i18n.d.ts

@@ -0,0 +1 @@
+export * from './types/i18n/index';

package/i18n.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/i18n/index');

package/layout.d.ts

@@ -0,0 +1 @@
+export * from './types/layout/index';

package/layout.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/layout/index');

package/media.d.ts

@@ -0,0 +1 @@
+export * from './types/media/index';

package/media.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/media/index');