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

package/dist/cjs/middleware/redirects-middleware.js

@@ -0,0 +1,264 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedirectsMiddleware = void 0;
+const core_1 = require("@sitecore-content-sdk/core");
+const site_1 = require("@sitecore-content-sdk/core/site");
+const utils_1 = require("@sitecore-content-sdk/core/utils");
+const server_1 = require("next/server");
+const regex_parser_1 = __importDefault(require("regex-parser"));
+const middleware_1 = require("./middleware");
+const REGEXP_CONTEXT_SITE_LANG = new RegExp(/\$siteLang/, 'i');
+const REGEXP_ABSOLUTE_URL = new RegExp('^(?:[a-z]+:)?//', 'i');
+/**
+ * Middleware / handler fetches all redirects from Sitecore instance by grapqhl service
+ * compares with current url and redirects to target url
+ */
+class RedirectsMiddleware extends middleware_1.MiddlewareBase {
+    /**
+     * @param {RedirectsMiddlewareConfig} [config] redirects middleware config
+     */
+    constructor(config) {
+        super(config);
+        this.config = config;
+        this.handler = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            const pathname = req.nextUrl.pathname;
+            const language = this.getLanguage(req);
+            const hostname = this.getHostHeader(req) || this.defaultHostname;
+            let site;
+            const startTimestamp = Date.now();
+            core_1.debug.redirects('redirects middleware start: %o', {
+                pathname,
+                language,
+                hostname,
+            });
+            const createResponse = () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const response = res || server_1.NextResponse.next();
+                if (this.config.disabled && this.config.disabled(req, res || server_1.NextResponse.next())) {
+                    core_1.debug.redirects('skipped (redirects middleware is disabled)');
+                    return response;
+                }
+                if (this.isPreview(req) || this.excludeRoute(pathname)) {
+                    core_1.debug.redirects('skipped (%s)', this.isPreview(req) ? 'preview' : 'route excluded');
+                    return response;
+                }
+                // Skip prefetch requests from Next.js, which are not original client requests
+                // as they load unnecessary requests that burden the redirects middleware with meaningless traffic
+                if (this.isPrefetch(req)) {
+                    core_1.debug.redirects('skipped (prefetch)');
+                    response.headers.set('x-middleware-cache', 'no-cache');
+                    return response;
+                }
+                site = this.getSite(req, res);
+                // Find the redirect from result of RedirectService
+                const existsRedirect = yield this.getExistsRedirect(req, site.name);
+                if (!existsRedirect) {
+                    core_1.debug.redirects('skipped (redirect does not exist)');
+                    return response;
+                }
+                // Find context site language and replace token
+                if (REGEXP_CONTEXT_SITE_LANG.test(existsRedirect.target) &&
+                    !(REGEXP_ABSOLUTE_URL.test(existsRedirect.target) &&
+                        existsRedirect.target.includes(hostname))) {
+                    existsRedirect.target = existsRedirect.target.replace(REGEXP_CONTEXT_SITE_LANG, site.language);
+                    req.nextUrl.locale = site.language;
+                }
+                const url = this.normalizeUrl(req.nextUrl.clone());
+                if (REGEXP_ABSOLUTE_URL.test(existsRedirect.target)) {
+                    url.href = existsRedirect.target;
+                }
+                else {
+                    const isUrl = (0, utils_1.isRegexOrUrl)(existsRedirect.pattern) === 'url';
+                    const targetParts = existsRedirect.target.split('/');
+                    const urlFirstPart = targetParts[1];
+                    if (this.locales.includes(urlFirstPart)) {
+                        req.nextUrl.locale = urlFirstPart;
+                        existsRedirect.target = existsRedirect.target.replace(`/${urlFirstPart}`, '');
+                    }
+                    const targetSegments = isUrl
+                        ? existsRedirect.target.split('?')
+                        : url.pathname.replace(/\/*$/gi, '') + existsRedirect.matchedQueryString;
+                    const [targetPath, targetQueryString] = isUrl
+                        ? targetSegments
+                        : targetSegments
+                            .replace((0, regex_parser_1.default)(existsRedirect.pattern), existsRedirect.target)
+                            .replace(/^\/\//, '/')
+                            .split('?');
+                    const mergedQueryString = existsRedirect.isQueryStringPreserved
+                        ? (0, utils_1.mergeURLSearchParams)(new URLSearchParams((_a = url.search) !== null && _a !== void 0 ? _a : ''), new URLSearchParams(targetQueryString || ''))
+                        : targetQueryString || '';
+                    const prepareNewURL = new URL(`${targetPath}${mergedQueryString ? '?' + mergedQueryString : ''}`, url.origin);
+                    url.href = prepareNewURL.href;
+                    url.pathname = prepareNewURL.pathname;
+                    url.search = prepareNewURL.search;
+                    url.locale = req.nextUrl.locale;
+                }
+                /** return Response redirect with http code of redirect type */
+                switch (existsRedirect.redirectType) {
+                    case site_1.REDIRECT_TYPE_301: {
+                        return this.createRedirectResponse(url, response, 301, 'Moved Permanently');
+                    }
+                    case site_1.REDIRECT_TYPE_302: {
+                        return this.createRedirectResponse(url, response, 302, 'Found');
+                    }
+                    case site_1.REDIRECT_TYPE_SERVER_TRANSFER: {
+                        return this.rewrite(url.href, req, response);
+                    }
+                    default:
+                        return response;
+                }
+            });
+            const response = yield createResponse();
+            core_1.debug.redirects('redirects middleware end in %dms: %o', Date.now() - startTimestamp, {
+                redirected: response.redirected,
+                status: response.status,
+                url: response.url,
+                headers: this.extractDebugHeaders(response.headers),
+            });
+            return response;
+        });
+        // NOTE: we provide native fetch for compatibility on Next.js Edge Runtime
+        // (underlying default 'cross-fetch' is not currently compatible: https://github.com/lquixada/cross-fetch/issues/78)
+        this.redirectsService = new site_1.GraphQLRedirectsService(Object.assign(Object.assign({}, config), { fetch: fetch }));
+        this.locales = config.locales;
+    }
+    /**
+     * Gets the Next.js middleware handler with error handling
+     * @returns route handler
+     */
+    getHandler() {
+        return (req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.handler(req, res);
+            }
+            catch (error) {
+                console.log('Redirect middleware failed:');
+                console.log(error);
+                return res || server_1.NextResponse.next();
+            }
+        });
+    }
+    /**
+     * Method returns RedirectInfo when matches
+     * @param {NextRequest} req request
+     * @param {string} siteName site name
+     * @returns Promise<RedirectInfo | undefined>
+     * @private
+     */
+    getExistsRedirect(req, siteName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pathname: targetURL, search: targetQS = '', locale } = this.normalizeUrl(req.nextUrl.clone());
+            const normalizedPath = targetURL.replace(/\/*$/gi, '');
+            const redirects = yield this.redirectsService.fetchRedirects(siteName);
+            const language = this.getLanguage(req);
+            const modifyRedirects = structuredClone(redirects);
+            let matchedQueryString;
+            return modifyRedirects.length
+                ? modifyRedirects.find((redirect) => {
+                    var _a;
+                    if ((0, utils_1.isRegexOrUrl)(redirect.pattern) === 'url') {
+                        const parseUrlPattern = redirect.pattern.endsWith('/')
+                            ? redirect.pattern.slice(0, -1).split('?')
+                            : redirect.pattern.split('?');
+                        return ((parseUrlPattern[0] === normalizedPath ||
+                            parseUrlPattern[0] === `/${locale}${normalizedPath}`) &&
+                            (0, utils_1.areURLSearchParamsEqual)(new URLSearchParams((_a = parseUrlPattern[1]) !== null && _a !== void 0 ? _a : ''), new URLSearchParams(targetQS)));
+                    }
+                    // Modify the redirect pattern to ignore the language prefix in the path
+                    // And escapes non-special "?" characters in a string or regex.
+                    redirect.pattern = (0, utils_1.escapeNonSpecialQuestionMarks)(redirect.pattern.replace(new RegExp(`^[^]?/${language}/`, 'gi'), ''));
+                    // Prepare the redirect pattern as a regular expression, making it more flexible for matching URLs
+                    redirect.pattern = `/^\/${redirect.pattern
+                        .replace(/^\/|\/$/g, '') // Removes leading and trailing slashes
+                        .replace(/^\^\/|\/\$$/g, '') // Removes unnecessary start (^) and end ($) anchors
+                        .replace(/^\^|\$$/g, '') // Further cleans up anchors
+                        .replace(/\$\/gi$/g, '')}[\/]?$/i`; // Ensures the pattern allows an optional trailing slash
+                    matchedQueryString = [
+                        (0, regex_parser_1.default)(redirect.pattern).test(`${normalizedPath}${targetQS}`),
+                        (0, regex_parser_1.default)(redirect.pattern).test(`/${locale}${normalizedPath}${targetQS}`),
+                    ].some(Boolean)
+                        ? targetQS
+                        : undefined;
+                    // Save the matched query string (if found) into the redirect object
+                    redirect.matchedQueryString = matchedQueryString || '';
+                    return (!!((0, regex_parser_1.default)(redirect.pattern).test(targetURL) ||
+                        (0, regex_parser_1.default)(redirect.pattern).test(`/${req.nextUrl.locale}${targetURL}`) ||
+                        matchedQueryString) && (redirect.locale ? redirect.locale.toLowerCase() === locale.toLowerCase() : true));
+                })
+                : undefined;
+        });
+    }
+    /**
+     * When a user clicks on a link generated by the Link component from next/link,
+     * Next.js adds special parameters in the route called path.
+     * This method removes these special parameters.
+     * @param {NextURL} url
+     * @returns {string} normalize url
+     */
+    normalizeUrl(url) {
+        if (!url.search) {
+            return url;
+        }
+        /**
+         * Prepare special parameters for exclusion.
+         */
+        const splittedPathname = url.pathname
+            .split('/')
+            .filter((route) => route)
+            .map((route) => `path=${route}`);
+        /**
+         * Remove special parameters(Next.JS)
+         * Example: /about/contact/us
+         * When a user clicks on this link, Next.js should generate a link for the middleware, formatted like this:
+         * http://host/about/contact/us?path=about&path=contact&path=us
+         */
+        const newQueryString = url.search
+            .replace(/^\?/, '')
+            .split('&')
+            .filter((param) => {
+            if (!splittedPathname.includes(param)) {
+                return param;
+            }
+            return false;
+        })
+            .join('&');
+        const newUrl = new URL(`${url.pathname}?${newQueryString}`, url.origin);
+        url.search = newUrl.search;
+        url.pathname = newUrl.pathname;
+        url.href = newUrl.href;
+        return url;
+    }
+    /**
+     * Helper function to create a redirect response and remove the x-middleware-next header.
+     * @param {NextURL} url The URL to redirect to.
+     * @param {Response} res The response object.
+     * @param {number} status The HTTP status code of the redirect.
+     * @param {string} statusText The status text of the redirect.
+     * @returns {NextResponse<unknown>} The redirect response.
+     */
+    createRedirectResponse(url, res, status, statusText) {
+        const redirect = server_1.NextResponse.redirect(url, {
+            status,
+            statusText,
+            headers: res === null || res === void 0 ? void 0 : res.headers,
+        });
+        if (res === null || res === void 0 ? void 0 : res.headers) {
+            redirect.headers.delete('x-middleware-next');
+            redirect.headers.delete('x-middleware-rewrite');
+        }
+        return redirect;
+    }
+}
+exports.RedirectsMiddleware = RedirectsMiddleware;

package/dist/cjs/monitoring/healthcheck-middleware.js

@@ -0,0 +1,30 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthcheckMiddleware = void 0;
+/**
+ * Middleware / handler for use in healthcheck Next.js API route (e.g. '/api/healthz').
+ */
+class HealthcheckMiddleware {
+    constructor() {
+        this.handler = (_req, res) => __awaiter(this, void 0, void 0, function* () {
+            res.status(200).send('Healthy');
+        });
+    }
+    /**
+     * Gets the Next.js API route handler
+     * @returns route handler
+     */
+    getHandler() {
+        return this.handler;
+    }
+}
+exports.HealthcheckMiddleware = HealthcheckMiddleware;

package/dist/cjs/monitoring/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthcheckMiddleware = void 0;
+var healthcheck_middleware_1 = require("./healthcheck-middleware");
+Object.defineProperty(exports, "HealthcheckMiddleware", { enumerable: true, get: function () { return healthcheck_middleware_1.HealthcheckMiddleware; } });

package/dist/cjs/services/base-graphql-sitemap-service.js

@@ -0,0 +1,206 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGraphQLSitemapService = exports.siteError = exports.languageError = void 0;
+exports.getSiteEmptyError = getSiteEmptyError;
+const core_1 = require("@sitecore-content-sdk/core");
+const personalize_1 = require("@sitecore-content-sdk/core/personalize");
+/** @private */
+exports.languageError = 'The list of languages cannot be empty';
+exports.siteError = 'The service needs a site name';
+/**
+ * @param {string} siteName to inject into error text
+ * @private
+ */
+function getSiteEmptyError(siteName) {
+    return `Site "${siteName}" does not exist or site item tree is missing`;
+}
+const languageEmptyError = 'The language must be a non-empty string';
+/**
+ * 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>
+ */
+class BaseGraphQLSitemapService {
+    /**
+     * Creates an instance of graphQL sitemap service with the provided options
+     * @param {GraphQLSitemapServiceConfig} 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 sitemap which could be used for generation of static pages during `next export`.
+     * The `locale` parameter will be used in the item query, but since i18n is not supported,
+     * the output paths will not include a `language` property.
+     * @param {string} locale which application supports
+     * @returns an array of @see StaticPath objects
+     */
+    fetchExportSitemap(locale) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formatPath = (path) => ({
+                params: {
+                    path,
+                },
+            });
+            return this.fetchSitemap([locale], formatPath);
+        });
+    }
+    /**
+     * Fetch sitemap which could be used for generation of static pages using SSG mode
+     * @param {string[]} locales locales which application supports
+     * @returns an array of @see StaticPath objects
+     */
+    fetchSSGSitemap(locales) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formatPath = (path, locale) => ({
+                params: {
+                    path,
+                },
+                locale,
+            });
+            return this.fetchSitemap(locales, formatPath);
+        });
+    }
+    getTranformedPaths(siteName, languages, formatStaticPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const paths = new Array();
+            for (const language of languages) {
+                if (language === '') {
+                    throw new RangeError(languageEmptyError);
+                }
+                core_1.debug.sitemap('fetching sitemap data for %s %s', language, siteName);
+                const results = yield this.fetchLanguageSitePaths(language, siteName);
+                const transformedPaths = yield this.transformLanguageSitePaths(results, formatStaticPath, language);
+                paths.push(...transformedPaths);
+            }
+            return paths;
+        });
+    }
+    transformLanguageSitePaths(sitePaths, formatStaticPath, language) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formatPath = (path) => formatStaticPath(path.replace(/^\/|\/$/g, '').split('/'), language);
+            const aggregatedPaths = [];
+            sitePaths.forEach((item) => {
+                var _a, _b, _c;
+                if (!item)
+                    return;
+                aggregatedPaths.push(formatPath(item.path));
+                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 variants
+                );
+                if (variantIds === null || variantIds === void 0 ? void 0 : variantIds.length) {
+                    aggregatedPaths.push(...variantIds.map((varId) => formatPath((0, personalize_1.getPersonalizedRewrite)(item.path, [varId]))));
+                }
+            });
+            return aggregatedPaths;
+        });
+    }
+    fetchLanguageSitePaths(language, siteName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = '';
+            while (hasNext) {
+                const fetchResponse = yield this.graphQLClient.request(this.query, Object.assign(Object.assign({}, args), { after }));
+                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;
+                }
+            }
+            return results;
+        });
+    }
+    /**
+     * 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: core_1.debug.sitemap,
+        });
+    }
+}
+exports.BaseGraphQLSitemapService = BaseGraphQLSitemapService;

package/dist/cjs/services/component-props-service.js

@@ -0,0 +1,167 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentPropsService = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class ComponentPropsService {
+    /**
+     * SSR mode
+     * Fetch component props using getServerSideProps function
+     * @param {FetchComponentPropsArguments<GetServerSidePropsContext>} params fetch params
+     * @returns {Promise<ComponentPropsCollection>} props
+     */
+    fetchServerSideComponentProps(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { moduleFactory, layoutData, context } = params;
+            const fetchFunctionFactory = (componentName) => __awaiter(this, void 0, void 0, function* () {
+                const module = yield moduleFactory(componentName);
+                return module === null || module === void 0 ? void 0 : module.getServerSideProps;
+            });
+            return this.fetchComponentProps(fetchFunctionFactory, layoutData, context);
+        });
+    }
+    /**
+     * SSG mode
+     * Fetch component props using getStaticProps function
+     * @param {FetchComponentPropsArguments<GetStaticPropsContext>} params fetch arguments
+     * @returns {Promise<ComponentPropsCollection>} props
+     */
+    fetchStaticComponentProps(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { moduleFactory, layoutData, context } = params;
+            const fetchFunctionFactory = (componentName) => __awaiter(this, void 0, void 0, function* () {
+                const module = yield moduleFactory(componentName);
+                return module === null || module === void 0 ? void 0 : module.getStaticProps;
+            });
+            return this.fetchComponentProps(fetchFunctionFactory, layoutData, context);
+        });
+    }
+    /**
+     * Traverse Layout Service data tree and call side effects on component level.
+     * Side effect function can be: getStaticProps (SSG) or getServerSideProps (SSR)
+     * @param {FetchFunctionFactory<NextContext>} fetchFunctionFactory fetch function factory
+     * @param {LayoutServiceData} layoutData layout data
+     * @param {NextContext} context next context
+     * @returns {Promise<ComponentPropsCollection>} component props
+     */
+    fetchComponentProps(fetchFunctionFactory, layoutData, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Array of side effect functions
+            const requests = yield this.collectRequests({
+                placeholders: (_a = layoutData.sitecore.route) === null || _a === void 0 ? void 0 : _a.placeholders,
+                fetchFunctionFactory,
+                layoutData,
+                context,
+            });
+            return yield this.execRequests(requests);
+        });
+    }
+    /**
+     * Go through layout service data, check all renderings using displayName, which should make some side effects.
+     * Write result in requests variable
+     * @param {object} params params
+     * @param {PlaceholdersData} [params.placeholders]
+     * @param {FetchFunctionFactory<NextContext>} params.fetchFunctionFactory
+     * @param {LayoutServiceData} params.layoutData
+     * @param {NextContext} params.context
+     * @param {ComponentPropsRequest<NextContext>[]} params.requests
+     * @returns {ComponentPropsRequest<NextContext>[]} array of requests
+     */
+    collectRequests(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { placeholders = {}, fetchFunctionFactory, layoutData, context } = params;
+            // Will be called on first round
+            if (!params.requests) {
+                params.requests = [];
+            }
+            const renderings = this.flatRenderings(placeholders);
+            const actions = renderings.map((r) => __awaiter(this, void 0, void 0, function* () {
+                const fetchFunc = yield fetchFunctionFactory(r.componentName);
+                if (fetchFunc) {
+                    params.requests &&
+                        params.requests.push({
+                            fetch: fetchFunc,
+                            rendering: r,
+                            layoutData: layoutData,
+                            context,
+                        });
+                }
+                // If placeholders exist in current rendering
+                if (r.placeholders) {
+                    yield this.collectRequests(Object.assign(Object.assign({}, params), { placeholders: r.placeholders }));
+                }
+            }));
+            yield Promise.all(actions);
+            return params.requests;
+        });
+    }
+    /**
+     * Execute request for component props
+     * @param {ComponentPropsRequest<NextContext>[]} requests requests
+     * @returns {Promise<ComponentPropsCollection>} requests result
+     */
+    execRequests(requests) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const componentProps = {};
+            const promises = requests.map((req) => {
+                const { uid } = req.rendering;
+                if (!uid) {
+                    console.log(`Component ${req.rendering.componentName} doesn't have uid, can't store data for this component`);
+                    return;
+                }
+                return req
+                    .fetch(req.rendering, req.layoutData, req.context)
+                    .then((result) => {
+                    // Set component specific data in componentProps store
+                    componentProps[uid] = result;
+                })
+                    .catch((error) => {
+                    const errLog = `Error during preload data for component ${req.rendering.componentName} (${uid}): ${error.message || error}`;
+                    console.error(chalk_1.default.red(errLog));
+                    componentProps[uid] = {
+                        error: error.message || errLog,
+                        componentName: req.rendering.componentName,
+                    };
+                });
+            });
+            yield Promise.all(promises);
+            return componentProps;
+        });
+    }
+    /**
+     * Take renderings from all placeholders and returns a flat array of renderings.
+     * @example
+     * const placeholders = {
+     *    x1: [{ uid: 1 }, { uid: 2 }],
+     *    x2: [{ uid: 11 }, { uid: 22 }]
+     * }
+     *
+     * flatRenderings(placeholders);
+     *
+     * RESULT: [{ uid: 1 }, { uid: 2 }, { uid: 11 }, { uid: 22 }]
+     * @param {PlaceholdersData} placeholders placeholders
+     * @returns {ComponentRendering[]} renderings
+     */
+    flatRenderings(placeholders) {
+        const allComponentRenderings = [];
+        const placeholdersArr = Object.values(placeholders);
+        placeholdersArr.forEach((pl) => {
+            const renderings = pl;
+            allComponentRenderings.push(...renderings);
+        });
+        return allComponentRenderings;
+    }
+}
+exports.ComponentPropsService = ComponentPropsService;