@enonic/nextjs-adapter 2.0.1 → 2.0.2

package/{src/guillotine/fetchContent.ts → guillotine/fetchContent.js}

@@ -1,121 +1,22 @@
-import {getMetaQuery, MetaData, PageComponent, PageData, pageFragmentQuery, PageRegion, RegionTree} from './getMetaData';
-
-import adapterConstants, {
-    addJsessionHeaders,
-    addLocaleHeaders,
-    APP_NAME,
-    APP_NAME_DASHED,
-    ContentPathItem,
-    Context,
-    FRAGMENT_CONTENTTYPE_NAME,
-    FRAGMENT_DEFAULT_REGION_NAME,
-    GET_STATIC_PATHS_QUERY,
-    getContentApiUrl,
-    getLocaleProjectConfig,
-    getLocaleProjectConfigs,
-    getRenderMode,
-    getXpBaseUrl,
-    IS_DEV_MODE,
-    LocaleProjectConfig,
-    normalizeLocale,
-    PAGE_TEMPLATE_CONTENTTYPE_NAME,
-    PAGE_TEMPLATE_FOLDER,
-    PURGE_CACHE_URL,
-    RENDER_MODE,
-    sanitizeGraphqlName,
-    XP_COMPONENT_TYPE,
-    XP_REQUEST_TYPE,
-} from '../utils';
-import {ComponentDefinition, ComponentRegistry, SelectedQueryMaybeVariablesFunc} from '../ComponentRegistry';
-import {getUrl, UrlProcessor} from '../UrlProcessor';
-import {GetServerSidePropsResult, GetStaticPropsResult} from 'next';
-
-type AdapterConstants = {
-    APP_NAME: string,
-    APP_NAME_DASHED: string,
-};
-
-type Result = {
-    error?: {
-        code: string,
-        message: string
-    } | null;
-};
-
-export type GuillotineResult = Result & {
-    [dataKey: string]: any;
-};
-
-type MetaResult = Result & {
-    meta?: {
-        _path: string;
-        type: string,
-        pageAsJson?: PageData,
-        components?: PageComponent[],
-    }
-};
-
-type ContentResult = Result & {
-    contents?: Record<string, any>[];
-};
-
-interface ComponentDescriptor {
-    type?: ComponentDefinition;
-    component?: PageComponent;
-    queryAndVariables?: QueryAndVariables;
-}
-
-export type FetchContentResult = Result & {
-    data: Record<string, any> | null,
-    common: Record<string, any> | null,
-    meta: MetaData,
-    page: PageComponent | null,
-};
-
-
-type FetcherConfig<T extends AdapterConstants> = T & {
-    componentRegistry: typeof ComponentRegistry
+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());
+    });
 };
-
-interface QueryAndVariables {
-    query: string;
-    variables?: Record<string, any>;
-}
-
-/**
- * Sends one query to the guillotine API and asks for content type, then uses the type to select a second query and variables, which is sent to the API and fetches content data.
- * @param contentPath string or string array: pre-split or slash-delimited _path to a content available on the API
- * @returns FetchContentResult object: {data?: T, error?: {code, message}}
- */
-export type ContentFetcher = (contentPath: string | string[], context?: Context) => Promise<FetchContentResult>;
-
-const NO_PROPS_PROCESSOR = async (props: any) => await props ?? {};
-
+import { getMetaQuery, pageFragmentQuery } from './getMetaData';
+import adapterConstants, { addJsessionHeaders, addLocaleHeaders, APP_NAME, APP_NAME_DASHED, FRAGMENT_CONTENTTYPE_NAME, FRAGMENT_DEFAULT_REGION_NAME, GET_STATIC_PATHS_QUERY, getContentApiUrl, getLocaleProjectConfig, getLocaleProjectConfigs, getRenderMode, getXpBaseUrl, IS_DEV_MODE, normalizeLocale, PAGE_TEMPLATE_CONTENTTYPE_NAME, PAGE_TEMPLATE_FOLDER, PURGE_CACHE_URL, RENDER_MODE, sanitizeGraphqlName, XP_COMPONENT_TYPE, XP_REQUEST_TYPE, } from '../utils';
+import { ComponentRegistry } from '../ComponentRegistry';
+import { getUrl, UrlProcessor } from '../UrlProcessor';
+const NO_PROPS_PROCESSOR = (props) => __awaiter(void 0, void 0, void 0, function* () { var _a; return (_a = yield props) !== null && _a !== void 0 ? _a : {}; });
 const ALIAS_PREFIX = 'request';
-
 const GUILLOTINE_QUERY_REGEXP = /^\s*query\s*(?:\((.*)*\))?\s*{\s*guillotine\s*{((?:.|\s)+)}\s*}\s*$/;
-
 const GRAPHQL_FRAGMENTS_REGEXP = /fragment\s+.+\s+on\s+.+\s*{[\s\w{}().,:"'`]+}/;
-
-// /////////////////////////////////////////////////////////////////////////////// Data
-
-// Shape of content base-data API body
-export type ContentApiBaseBody = {
-    query?: string,                 // Override the default base-data query
-    variables?: {                   // GraphQL variables inserted into the query
-        path?: string,              // Full content item _path
-        [key: string]: string | number | undefined,
-    }
-};
-
 /** Generic fetch */
-export const fetchFromApi = async (
-    apiUrl: string,
-    body: ContentApiBaseBody,
-    projectConfig: LocaleProjectConfig,
-    headers?: {},
-    method = 'POST',
-) => {
+export const fetchFromApi = (apiUrl, body, projectConfig, headers, method = 'POST') => __awaiter(void 0, void 0, void 0, function* () {
     const options = {
         method,
         headers: {
@@ -125,55 +26,47 @@ export const fetchFromApi = async (
         },
         body: JSON.stringify(body),
     };
-
     if (headers) {
         Object.assign(options.headers, headers);
     }
-
     let res;
     try {
-        res = await fetch(apiUrl, options);
-    } catch (e: any) {
+        res = yield fetch(apiUrl, options);
+    }
+    catch (e) {
         console.warn(apiUrl, e);
         throw new Error(JSON.stringify({
             code: 'API',
             message: e.message,
         }));
     }
-
     if (!res.ok) {
         throw new Error(JSON.stringify({
             code: res.status,
-            message: `Data fetching failed (message: '${await res.text()}')`,
+            message: `Data fetching failed (message: '${yield res.text()}')`,
         }));
     }
-
     let json;
     try {
-        json = await res.json();
-    } catch (e) {
+        json = yield res.json();
+    }
+    catch (e) {
         throw new Error(JSON.stringify({
             code: 500,
-            message: `API call completed but with non-JSON data: ${JSON.stringify(await res.text())}`,
+            message: `API call completed but with non-JSON data: ${JSON.stringify(yield res.text())}`,
         }));
     }
-
     if (!json) {
         throw new Error(JSON.stringify({
             code: 500,
-            message: `API call completed but with unexpectedly empty data: ${JSON.stringify(await res.text())}`,
+            message: `API call completed but with unexpectedly empty data: ${JSON.stringify(yield res.text())}`,
         }));
     }
-
     return json;
-};
-
+});
 /** Guillotine-specialized fetch, using the generic fetch above */
-export const fetchGuillotine = async (
-    contentApiUrl: string,
-    body: ContentApiBaseBody,
-    projectConfig: LocaleProjectConfig,
-    headers?: {}): Promise<GuillotineResult> => {
+export const fetchGuillotine = (contentApiUrl, body, projectConfig, headers) => __awaiter(void 0, void 0, void 0, function* () {
+    var _b;
     if (typeof body.query !== 'string' || !body.query.trim()) {
         return {
             error: {
@@ -182,129 +75,98 @@ export const fetchGuillotine = async (
             },
         };
     }
-    const path = body.variables?.path;
+    const path = (_b = body.variables) === null || _b === void 0 ? void 0 : _b.path;
     const pathMessage = path ? JSON.stringify(path) : '';
-    const result = await fetchFromApi(
-        contentApiUrl,
-        body,
-        projectConfig,
-        headers,
-    )
+    const result = yield fetchFromApi(contentApiUrl, body, projectConfig, headers)
         .then(json => {
-            let errors: any[] = (json || {}).errors;
-
-            if (errors) {
-                if (!Array.isArray(errors)) {
-                    errors = [errors];
-                }
-                console.error(`${errors.length} error(s) when fetching data from: ${contentApiUrl}`);
-                console.error(`headers: ${JSON.stringify(headers, null, 2)}
-                variables: ${JSON.stringify(body.variables, null, 2)}`);
-                errors.forEach(error => {
-                    console.error(error);
-                });
-
-                return {
-                    error: {
-                        code: '500',
-                        message: `Server responded with ${errors.length} error(s), probably from guillotine - see log.`,
-                    },
-                };
+        let errors = (json || {}).errors;
+        if (errors) {
+            if (!Array.isArray(errors)) {
+                errors = [errors];
             }
-
-            return json.data;
-        })
+            console.error(`${errors.length} error(s) when fetching data from: ${contentApiUrl}`);
+            console.error(`headers: ${JSON.stringify(headers, null, 2)}
+                variables: ${JSON.stringify(body.variables, null, 2)}`);
+            errors.forEach(error => {
+                console.error(error);
+            });
+            return {
+                error: {
+                    code: '500',
+                    message: `Server responded with ${errors.length} error(s), probably from guillotine - see log.`,
+                },
+            };
+        }
+        return json.data;
+    })
         .catch((err) => {
-            console.warn(`Client-side error when trying to fetch data ${pathMessage}`, err);
-            try {
-                return {error: JSON.parse(err.message)};
-            } catch (e2) {
-                return {error: {code: 'Client-side error', message: err.message}};
-            }
-        });
-
-    return result as GuillotineResult;
-};
-
+        console.warn(`Client-side error when trying to fetch data ${pathMessage}`, err);
+        try {
+            return { error: JSON.parse(err.message) };
+        }
+        catch (e2) {
+            return { error: { code: 'Client-side error', message: err.message } };
+        }
+    });
+    return result;
+});
 // /////////////////////////////////////////////////////////////////////////////// Specific fetch wrappers:
-
-const fetchMetaData = async (contentApiUrl: string, xpContentPath: string, projectConfig: LocaleProjectConfig, headers?: {}): Promise<MetaResult> => {
-    const body: ContentApiBaseBody = {
+const fetchMetaData = (contentApiUrl, xpContentPath, projectConfig, headers) => __awaiter(void 0, void 0, void 0, function* () {
+    var _c;
+    const body = {
         query: getMetaQuery(pageFragmentQuery()),
         variables: {
             path: xpContentPath,
         },
     };
-    const metaResult = await fetchGuillotine(contentApiUrl, body, projectConfig, headers);
+    const metaResult = yield fetchGuillotine(contentApiUrl, body, projectConfig, headers);
     if (metaResult.error) {
         return metaResult;
-    } else {
+    }
+    else {
         return {
-            meta: metaResult?.guillotine?.get,
+            meta: (_c = metaResult === null || metaResult === void 0 ? void 0 : metaResult.guillotine) === null || _c === void 0 ? void 0 : _c.get,
         };
     }
-};
-
-
-const fetchContentData = async <T>(
-    contentApiUrl: string,
-    xpContentPath: string,
-    projectConfig: LocaleProjectConfig,
-    query: string,
-    variables?: {},
-    headers?: {},
-): Promise<ContentResult> => {
-
-    const body: ContentApiBaseBody = {query};
+});
+const fetchContentData = (contentApiUrl, xpContentPath, projectConfig, query, variables, headers) => __awaiter(void 0, void 0, void 0, function* () {
+    const body = { query };
     if (variables && Object.keys(variables).length > 0) {
         body.variables = variables;
     }
-    const contentResults = await fetchGuillotine(contentApiUrl, body, projectConfig, headers);
-
+    const contentResults = yield fetchGuillotine(contentApiUrl, body, projectConfig, headers);
     if (contentResults.error) {
         return contentResults;
-    } else {
+    }
+    else {
         return {
             // omit the aliases and return values
             contents: Object.values(contentResults),
         };
     }
-};
-
-
+});
 // /////////////////////////////////////////////////////////////////////////////// Error checking:
-
 /** Checks a site-relative contentPath as a slash-delimited string or a string array, and returns a pure site-relative path string (no double slashes, starts with a slash, does not end with one). */
-const getCleanContentPathArrayOrThrow400 = (contentPath: string | string[] | undefined): string => {
+const getCleanContentPathArrayOrThrow400 = (contentPath) => {
     if (contentPath === undefined) {
         return '';
     }
     const isArray = Array.isArray(contentPath);
-
     if (!isArray) {
         if (typeof contentPath !== 'string') {
             throw Error(JSON.stringify({
                 code: 400,
-                message: `Unexpected target content _path: contentPath must be a string or pure string array (contentPath=${JSON.stringify(
-                    contentPath)})`,
+                message: `Unexpected target content _path: contentPath must be a string or pure string array (contentPath=${JSON.stringify(contentPath)})`,
             }));
         }
-
         return contentPath;
-
-    } else {
+    }
+    else {
         return (contentPath).join('/');
     }
 };
-
-
-// ------------------------------------------------------------- XP view component data handling
-
-
-type PathFragment = { region: string, index: number };
-
-function parseComponentPath(contentType: string, path: string): PathFragment[] {
-    const matches: PathFragment[] = [];
+function parseComponentPath(contentType, path) {
+    const matches = [];
     let match;
     const myRegexp = /(?:(\w+)\/(\d+))+/g;
     while ((match = myRegexp.exec(path)) !== null) {
@@ -323,20 +185,15 @@ function parseComponentPath(contentType: string, path: string): PathFragment[] {
     }
     return matches;
 }
-
-function getParentRegion(source: RegionTree, contentType: string, cmpPath: PathFragment[], components: PageComponent[] = [],
-                         createMissing?: boolean): PageRegion | undefined {
-
-    let currentTree: RegionTree = source;
-    let currentRegion: PageRegion | undefined;
+function getParentRegion(source, contentType, cmpPath, components = [], createMissing) {
+    let currentTree = source;
+    let currentRegion;
     let parentPath = '';
-
     for (let i = 0; i < cmpPath.length; i++) {
         const pathFragment = cmpPath[i];
         const regionName = pathFragment.region;
         parentPath += `/${pathFragment.region}/${pathFragment.index}`;
         currentRegion = currentTree[regionName];
-
         if (!currentRegion) {
             if (createMissing) {
                 currentRegion = {
@@ -344,15 +201,14 @@ function getParentRegion(source: RegionTree, contentType: string, cmpPath: PathF
                     components: [],
                 };
                 currentTree[regionName] = currentRegion;
-            } else {
+            }
+            else {
                 throw `Region [${regionName}] was not found`;
             }
         }
-
         if (i < cmpPath.length - 1) {
             // look for layouts inside if this is not the last path fragment
-
-            const layout = components.find((cmp: PageComponent) => {
+            const layout = components.find((cmp) => {
                 return cmp.type === XP_COMPONENT_TYPE.LAYOUT && prefixLayoutPath(contentType, cmp.path) === parentPath;
             });
             if (!layout) {
@@ -364,107 +220,94 @@ function getParentRegion(source: RegionTree, contentType: string, cmpPath: PathF
             currentTree = layout.regions;
         }
     }
-
     return currentRegion;
 }
-
-function prefixLayoutPath(contentType: string, path: string): string {
+function prefixLayoutPath(contentType, path) {
     if (contentType !== FRAGMENT_CONTENTTYPE_NAME) {
         return path;
-    } else {
+    }
+    else {
         // prepend FRAGMENT_DEFAULT_REGION_NAME to path to conform to page structure
         // so that component with path '/' becomes /FRAGMENT_DEFAULT_REGION_NAME/0
         // path /left/1 becomes /FRAGMENT_DEFAULT_REGION_NAME/0/left/1
         return `/${FRAGMENT_DEFAULT_REGION_NAME}/0${path === '/' ? '' : path}`;
     }
 }
-
-function buildPage(contentType: string, comps: PageComponent[] = []): PageComponent {
-
-    const page: PageComponent = {
+function buildPage(contentType, comps = []) {
+    const page = {
         type: XP_COMPONENT_TYPE.PAGE,
         path: '/',
     };
-
     return buildComponentTree(comps, page, contentType);
 }
-
-function buildComponentTree(comps: PageComponent[], rootComp: PageComponent, contentType?: string): PageComponent {
-    const rootTree: RegionTree = {};
+function buildComponentTree(comps, rootComp, contentType) {
+    const rootTree = {};
     const isFragmentType = contentType === FRAGMENT_CONTENTTYPE_NAME;
-
     if (isFragmentType) {
         rootComp.regions = rootTree;
     }
-
     (comps || []).forEach(cmp => {
+        var _a, _b, _c;
         const cmpPath = parseComponentPath(contentType, cmp.path);
-
         if (cmp.path === '/') {
             if (cmp.type === XP_COMPONENT_TYPE.PAGE && rootComp.type === XP_COMPONENT_TYPE.PAGE) {
                 // add page values to page object
                 rootComp = Object.assign(rootComp, cmp);
                 rootComp.page.regions = rootTree;
                 return;
-            } else if (cmp.type === XP_COMPONENT_TYPE.LAYOUT && rootComp.type === XP_COMPONENT_TYPE.FRAGMENT) {
+            }
+            else if (cmp.type === XP_COMPONENT_TYPE.LAYOUT && rootComp.type === XP_COMPONENT_TYPE.FRAGMENT) {
                 // when rendering fragment as part of the page with layout at root path
                 // remove other children from list as they will be included in layout
                 rootComp.fragment.fragment.components = [cmp];
                 cmp.regions = rootTree;
             }
         }
-
         if (cmp.type === XP_COMPONENT_TYPE.FRAGMENT) {
             // build component subtree for fragment
-            cmp = buildComponentTree(cmp.fragment?.fragment?.components, cmp, contentType);
+            cmp = buildComponentTree((_b = (_a = cmp.fragment) === null || _a === void 0 ? void 0 : _a.fragment) === null || _b === void 0 ? void 0 : _b.components, cmp, contentType);
         }
-
         const region = getParentRegion(rootTree, contentType, cmpPath, comps, true);
-
         if (region) {
             // getting the index of component from string like '/main/0/left/11'
-            const cmpIndex = cmpPath[cmpPath.length - 1]?.index;
+            const cmpIndex = (_c = cmpPath[cmpPath.length - 1]) === null || _c === void 0 ? void 0 : _c.index;
             if (cmpIndex >= 0) {
                 region.components.splice(cmpIndex, 0, cmp);
-            } else {
+            }
+            else {
                 throw Error(`Could not find [${cmp.type}] component index at ${JSON.stringify(cmpPath, null, 2)}, rendering not possible.`);
             }
         }
     });
-
     return rootComp;
 }
-
-
-function combineMultipleQueries(queriesWithVars: ComponentDescriptor[]): QueryAndVariables {
-    const queries: string[] = [];
-    const fragments: string[] = [];
-    const superVars: { [key: string]: any } = {};
-    const superParams: string[] = [];
-
-    queriesWithVars.forEach((componentDescriptor: ComponentDescriptor, index: number) => {
+function combineMultipleQueries(queriesWithVars) {
+    const queries = [];
+    const fragments = [];
+    const superVars = {};
+    const superParams = [];
+    queriesWithVars.forEach((componentDescriptor, index) => {
         const queryAndVars = componentDescriptor.queryAndVariables;
         if (!queryAndVars) {
             return;
         }
-
         // Extract fragments first if exist
         let q = queryAndVars.query;
         let match = q.match(GRAPHQL_FRAGMENTS_REGEXP);
-        if (match?.length === 1) {
+        if ((match === null || match === void 0 ? void 0 : match.length) === 1) {
             // extract a fragment to put it at root level
             fragments.push(match[0]);
             // remove it from query because queries are going to get wrapped
             q = q.replace(match[0], '');
         }
-
         // Extract graphql query and its params and add prefixes to exclude collisions with other queries
         match = q.match(GUILLOTINE_QUERY_REGEXP);
         let query = '';
         if (match && match.length === 2) {
             // no params, just query
             query = match[1];
-        } else if (match && match.length === 3) {
+        }
+        else if (match && match.length === 3) {
             // both query and params are present
             query = match[2];
             // process args
@@ -485,62 +328,50 @@ function combineMultipleQueries(queriesWithVars: ComponentDescriptor[]): QueryAn
         if (query.length) {
             queries.push(`${ALIAS_PREFIX}${index}:guillotine {${query}}`);
         }
-
         // Update variables with the same prefixes
         Object.entries(queryAndVars.variables || {}).forEach(entry => {
             superVars[`${ALIAS_PREFIX}${index}_${entry[0]}`] = entry[1];
         });
     });
-
     // Compose the super query
     const superQuery = `query ${superParams.length ? `(${superParams.join(', ')})` : ''} {
         ${queries.join('\n')}
     }
     ${fragments.join('\n')}
     `;
-
     return {
         query: superQuery,
         variables: superVars,
     };
 }
-
-async function applyProcessors(componentDescriptors: ComponentDescriptor[], contentResults: ContentResult,
-                               context?: Context): Promise<PromiseSettledResult<any>[]> {
-
-    let dataCounter = 0;
-    const processorPromises = componentDescriptors.map(async (desc: ComponentDescriptor) => {
-        // we're iterating component descriptors here
-        // some of them might not have provided graphql requests
-        // but we still need to run props processor for them
-        // in case they want to fetch their data from elsewhere
-        const propsProcessor = desc.type?.processor || NO_PROPS_PROCESSOR;
-        let data;
-        if (desc.queryAndVariables) {
-            // if there is a query then there must be a result for it
-            data = contentResults.contents[dataCounter++];
-        }
-
-        const config = getComponentConfig(desc.component);
-        return await propsProcessor(data, context, config);
+function applyProcessors(componentDescriptors, contentResults, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let dataCounter = 0;
+        const processorPromises = componentDescriptors.map((desc) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // we're iterating component descriptors here
+            // some of them might not have provided graphql requests
+            // but we still need to run props processor for them
+            // in case they want to fetch their data from elsewhere
+            const propsProcessor = ((_a = desc.type) === null || _a === void 0 ? void 0 : _a.processor) || NO_PROPS_PROCESSOR;
+            let data;
+            if (desc.queryAndVariables) {
+                // if there is a query then there must be a result for it
+                data = contentResults.contents[dataCounter++];
+            }
+            const config = getComponentConfig(desc.component);
+            return yield propsProcessor(data, context, config);
+        }));
+        return Promise.allSettled(processorPromises);
     });
-
-    return Promise.allSettled(processorPromises);
 }
-
-function getComponentConfig(cmp?: PageComponent) {
+function getComponentConfig(cmp) {
     const cmpData = cmp && cmp[cmp.type];
     return cmpData && 'config' in cmpData ? cmpData.config : undefined;
 }
-
-function collectComponentDescriptors(components: PageComponent[],
-                                     componentRegistry: typeof ComponentRegistry,
-                                     xpContentPath: string,
-                                     context: Context | undefined,
-): ComponentDescriptor[] {
-
-    const descriptors: ComponentDescriptor[] = [];
-
+function collectComponentDescriptors(components, componentRegistry, xpContentPath, context) {
+    var _a, _b;
+    const descriptors = [];
     for (const cmp of (components || [])) {
         processComponentConfig(APP_NAME, APP_NAME_DASHED, cmp);
         // only look for parts
@@ -559,19 +390,18 @@ function collectComponentDescriptors(components: PageComponent[],
                     });
                 }
             }
-        } else {
+        }
+        else {
             // look for parts inside fragments
-            const fragPartDescs = collectComponentDescriptors(cmp.fragment?.fragment?.components, componentRegistry, xpContentPath, context);
+            const fragPartDescs = collectComponentDescriptors((_b = (_a = cmp.fragment) === null || _a === void 0 ? void 0 : _a.fragment) === null || _b === void 0 ? void 0 : _b.components, componentRegistry, xpContentPath, context);
             if (fragPartDescs.length) {
                 descriptors.push(...fragPartDescs);
             }
         }
     }
-
     return descriptors;
 }
-
-function processComponentConfig(myAppName: string, myAppNameDashed: string, cmp: PageComponent) {
+function processComponentConfig(myAppName, myAppNameDashed, cmp) {
     const cmpData = cmp[cmp.type];
     if (cmpData && 'descriptor' in cmpData && cmpData.descriptor) {
         const [appName, cmpName] = cmpData.descriptor.split(':');
@@ -579,7 +409,7 @@ function processComponentConfig(myAppName: string, myAppNameDashed: string, cmp:
             return;
         }
         let config;
-        const configArray: Object[] = [];
+        const configArray = [];
         if ('configAsJson' in cmpData && cmpData.configAsJson && cmpData.configAsJson[myAppNameDashed]) {
             config = cmpData.configAsJson[myAppNameDashed][cmpName];
             if (config) {
@@ -599,108 +429,86 @@ function processComponentConfig(myAppName: string, myAppNameDashed: string, cmp:
         }
     }
 }
-
-function getQueryAndVariables(type: string,
-                              path: string,
-                              selectedQuery?: SelectedQueryMaybeVariablesFunc,
-                              context?: Context,
-                              config?: any): QueryAndVariables | undefined {
-
+function getQueryAndVariables(type, path, selectedQuery, context, config) {
     let query, getVariables;
-
     if (typeof selectedQuery === 'string' || typeof selectedQuery === 'function') {
         query = selectedQuery;
-
-    } else if (Array.isArray(selectedQuery)) {
+    }
+    else if (Array.isArray(selectedQuery)) {
         query = selectedQuery[0];
         getVariables = selectedQuery[1];
-
-    } else if (typeof selectedQuery === 'object') {
+    }
+    else if (typeof selectedQuery === 'object') {
         query = selectedQuery.query;
         getVariables = selectedQuery.variables;
     }
-
     if (getVariables && typeof getVariables !== 'function') {
         throw Error(`getVariables for content type ${type} should be a function, not: ${typeof getVariables}`);
     }
-
     if (query && typeof query !== 'string' && typeof query !== 'function') {
         throw Error(`Query for content type ${type} should be a string or function, not: ${typeof query}`);
     }
-
     if (typeof query === 'function') {
         query = query(path, context, config);
     }
-
     if (query) {
         return {
             query,
-            variables: getVariables ? getVariables(path, context, config) : {path},
+            variables: getVariables ? getVariables(path, context, config) : { path },
         };
     }
 }
-
-
-function createPageData(contentType: string, components: PageComponent[], componentPath?: string): PageComponent | undefined {
+function createPageData(contentType, components, componentPath) {
     let page;
     if (components && !componentPath) {
         page = buildPage(contentType, components);
-    } else {
+    }
+    else {
         // Don't build page for single component
         page = null;
     }
-    return page as PageComponent;
+    return page;
 }
-
-
-function createMetaData(contentType: string, contentPath: string,
-                        requestType: XP_REQUEST_TYPE, renderMode: RENDER_MODE,
-                        apiUrl: string, baseUrl: string,
-                        locale: string, defaultLocale: string,
-                        requestedComponentPath: string | undefined,
-                        pageCmp?: PageComponent, components: PageComponent[] = []): MetaData {
+function createMetaData(contentType, contentPath, requestType, renderMode, apiUrl, baseUrl, locale, defaultLocale, requestedComponentPath, pageCmp, components = []) {
+    var _a;
     // .meta will be visible in final rendered inline props.
     // Only adding some .meta attributes here on certain conditions
     // (instead of always adding them and letting them be visible as false/undefined etc)
-    const meta: MetaData = {
+    const meta = {
         type: contentType,
         path: contentPath,
         requestType: requestType,
         renderMode: renderMode,
         canRender: false,
-        catchAll: false,  // catchAll only refers to content type catch-all
+        catchAll: false,
         apiUrl,
         baseUrl,
         locale,
         defaultLocale,
     };
-
     if (requestedComponentPath) {
         meta.requestedComponent = components.find(cmp => cmp.path === requestedComponentPath);
     }
-
-    const pageDesc = pageCmp?.page?.descriptor;
+    const pageDesc = (_a = pageCmp === null || pageCmp === void 0 ? void 0 : pageCmp.page) === null || _a === void 0 ? void 0 : _a.descriptor;
     const typeDef = ComponentRegistry.getContentType(contentType);
-    if (typeDef?.view && !typeDef.catchAll) {
+    if ((typeDef === null || typeDef === void 0 ? void 0 : typeDef.view) && !typeDef.catchAll) {
         meta.canRender = true;
-    } else if (requestType === XP_REQUEST_TYPE.COMPONENT) {
+    }
+    else if (requestType === XP_REQUEST_TYPE.COMPONENT) {
         // always render a single component (show missing if not implemented)
         meta.canRender = true;
-    } else if (pageDesc) {
+    }
+    else if (pageDesc) {
         // always render a page if there is a descriptor (show missing if not implemented)
         meta.canRender = true;
-    } else if (typeDef?.view) {
+    }
+    else if (typeDef === null || typeDef === void 0 ? void 0 : typeDef.view) {
         meta.canRender = true;
         meta.catchAll = true;
     }
-
     return meta;
 }
-
-function errorResponse(code = '500', message = 'Unknown error',
-                       requestType: XP_REQUEST_TYPE, renderMode: RENDER_MODE,
-                       apiUrl: string, baseUrl: string, locale: string, defaultLocale: string,
-                       contentPath?: string): FetchContentResult {
+function errorResponse(code = '500', message = 'Unknown error', requestType, renderMode, apiUrl, baseUrl, locale, defaultLocale, contentPath) {
     return {
         error: {
             code,
@@ -723,22 +531,18 @@ function errorResponse(code = '500', message = 'Unknown error',
         },
     };
 }
-
-function restrictComponentsToPath(contentType: string, components?: PageComponent[], componentPath?: string) {
-    if (!componentPath || !components?.length) {
+function restrictComponentsToPath(contentType, components, componentPath) {
+    if (!componentPath || !(components === null || components === void 0 ? void 0 : components.length)) {
         return components || [];
     }
-
     // filter components to the requested one only
     const component = components.find(cmp => {
         return cmp.path === componentPath;
     });
-
     if (!component) {
         return [];
     }
-
-    let result: PageComponent[] = [component];
+    let result = [component];
     if (component.type !== XP_COMPONENT_TYPE.LAYOUT) {
         // remember to include all parent layouts too !
         const cmpPath = parseComponentPath(contentType, component.path);
@@ -749,7 +553,8 @@ function restrictComponentsToPath(contentType: string, components?: PageComponen
                 result.unshift(parentCmp);
             }
         }
-    } else {
+    }
+    else {
         // It's a layout, include child components
         const childCmps = components.filter(cmp => cmp.path !== component.path && cmp.path.startsWith(component.path));
         if (childCmps.length) {
@@ -758,40 +563,30 @@ function restrictComponentsToPath(contentType: string, components?: PageComponen
     }
     return result;
 }
-
-const COMPONENT_PATH_KEY = /\/?_\/component/;   // first slash is optional for root components
-
-const getContentAndComponentPaths = (requestPath: string, context: Context): string[] => {
+const COMPONENT_PATH_KEY = /\/?_\/component/; // first slash is optional for root components
+const getContentAndComponentPaths = (requestPath, context) => {
     let contentPath, componentPath;
     if (COMPONENT_PATH_KEY.test(requestPath)) {
         [contentPath, componentPath] = requestPath.split(COMPONENT_PATH_KEY);
-    } else {
+    }
+    else {
         contentPath = requestPath;
     }
     return [contentPath, componentPath];
 };
-
 // /////////////////////////////  ENTRY 1 - THE BUILDER:
-
 /**
  * Configures, builds and returns a general fetchContent function.
  * @param config object containing ComponentRegistry as well as constants imported from enonic-connecion-config.js
  * @returns ContentFetcher
  */
-const buildContentFetcher = <T extends AdapterConstants>(config: FetcherConfig<T>): ContentFetcher => {
-
-    const {
-        APP_NAME,
-        APP_NAME_DASHED,
-        componentRegistry,
-    } = config;
-
-    return async (contentPathOrArray: string | string[], context: Context): Promise<FetchContentResult> => {
-
+const buildContentFetcher = (config) => {
+    const { APP_NAME, APP_NAME_DASHED, componentRegistry, } = config;
+    return (contentPathOrArray, context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
         if (context.preview) {
             populateEnonicHeaders(context);
         }
-
         const headers = {};
         addJsessionHeaders(headers, context);
         addLocaleHeaders(headers, context);
@@ -800,91 +595,70 @@ const buildContentFetcher = <T extends AdapterConstants>(config: FetcherConfig<T
         const projectConfig = getLocaleProjectConfig(context);
         const renderMode = getRenderMode(context);
         let requestType = XP_REQUEST_TYPE.TYPE;
-
         UrlProcessor.setSiteKey(projectConfig.site);
-
         try {
             const requestContentPath = getCleanContentPathArrayOrThrow400(contentPathOrArray);
-
             if ('/' + requestContentPath === PURGE_CACHE_URL) {
                 // return 404 for /_/cache/enonic/purge because it should've been handled by standalone endpoint
                 return errorResponse('404', 'Not found', requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, requestContentPath);
             }
-
             const [siteRelativeContentPath, componentPath] = getContentAndComponentPaths(requestContentPath, context);
             if (componentPath) {
                 // set component request type because url contains component path
                 requestType = XP_REQUEST_TYPE.COMPONENT;
             }
-
             // /////////////  FIRST GUILLOTINE CALL FOR METADATA     /////////////////
-            const metaResult = await fetchMetaData(contentApiUrl, '${site}/' + siteRelativeContentPath, projectConfig, headers);
+            const metaResult = yield fetchMetaData(contentApiUrl, '${site}/' + siteRelativeContentPath, projectConfig, headers);
             // ///////////////////////////////////////////////////////////////////////
-
-            const {_path, type} = metaResult.meta || {};
+            const { _path, type } = metaResult.meta || {};
             const contentPath = _path || siteRelativeContentPath;
-
             if (metaResult.error) {
                 console.error(metaResult.error);
-                return errorResponse(metaResult.error.code, metaResult.error.message, requestType, renderMode, contentApiUrl, xpBaseUrl,
-                    context.locale, context.defaultLocale, contentPath);
+                return errorResponse(metaResult.error.code, metaResult.error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
             }
-
             if (!metaResult.meta) {
-                return errorResponse('404', 'No meta data found for content, most likely content does not exist', requestType, renderMode,
-                    contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
-            } else if (!type) {
-                return errorResponse('500', "Server responded with incomplete meta data: missing content 'type' attribute.", requestType,
-                    renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
-
-            } else if (renderMode === RENDER_MODE.NEXT && !IS_DEV_MODE &&
+                return errorResponse('404', 'No meta data found for content, most likely content does not exist', requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+            }
+            else if (!type) {
+                return errorResponse('500', "Server responded with incomplete meta data: missing content 'type' attribute.", requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+            }
+            else if (renderMode === RENDER_MODE.NEXT && !IS_DEV_MODE &&
                 (type === FRAGMENT_CONTENTTYPE_NAME ||
                     type === PAGE_TEMPLATE_CONTENTTYPE_NAME ||
                     type === PAGE_TEMPLATE_FOLDER)) {
-                return errorResponse('404', `Content type [${type}] is not accessible in ${renderMode} mode`, requestType, renderMode,
-                    contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                return errorResponse('404', `Content type [${type}] is not accessible in ${renderMode} mode`, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
             }
-
             const components = restrictComponentsToPath(type, metaResult.meta.components, componentPath);
             if (componentPath && !components.length) {
                 // component was not found
-                return errorResponse('404', `Component ${componentPath} was not found`, requestType, renderMode,
-                    contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                return errorResponse('404', `Component ${componentPath} was not found`, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
             }
-
             if (requestType !== XP_REQUEST_TYPE.COMPONENT && components.length > 0) {
                 requestType = XP_REQUEST_TYPE.PAGE;
             }
-
             // //////////////////////////////////////////////////  Content type established. Proceed to data call:
-
-            const allDescriptors: ComponentDescriptor[] = [];
-
+            const allDescriptors = [];
             // Add the content type query at all cases
-            const contentTypeDef = componentRegistry?.getContentType(type);
+            const contentTypeDef = componentRegistry === null || componentRegistry === void 0 ? void 0 : componentRegistry.getContentType(type);
             const pageCmp = (components || []).find(cmp => cmp.type === XP_COMPONENT_TYPE.PAGE);
             if (pageCmp) {
                 processComponentConfig(APP_NAME, APP_NAME_DASHED, pageCmp);
             }
-
-            const contentQueryAndVars = getQueryAndVariables(type, contentPath, contentTypeDef?.query, context, pageCmp?.page?.config);
+            const contentQueryAndVars = getQueryAndVariables(type, contentPath, contentTypeDef === null || contentTypeDef === void 0 ? void 0 : contentTypeDef.query, context, (_a = pageCmp === null || pageCmp === void 0 ? void 0 : pageCmp.page) === null || _a === void 0 ? void 0 : _a.config);
             if (contentQueryAndVars) {
                 allDescriptors.push({
                     type: contentTypeDef,
                     queryAndVariables: contentQueryAndVars,
                 });
             }
-
-            const commonQueryAndVars = getQueryAndVariables(type, contentPath, componentRegistry.getCommonQuery(), context,
-                pageCmp?.page?.config);
+            const commonQueryAndVars = getQueryAndVariables(type, contentPath, componentRegistry.getCommonQuery(), context, (_b = pageCmp === null || pageCmp === void 0 ? void 0 : pageCmp.page) === null || _b === void 0 ? void 0 : _b.config);
             if (commonQueryAndVars) {
                 allDescriptors.push({
                     type: contentTypeDef,
                     queryAndVariables: commonQueryAndVars,
                 });
             }
-
-            if (components?.length && componentRegistry) {
+            if ((components === null || components === void 0 ? void 0 : components.length) && componentRegistry) {
                 for (const cmp of (components || [])) {
                     processComponentConfig(APP_NAME, APP_NAME_DASHED, cmp);
                 }
@@ -894,29 +668,20 @@ const buildContentFetcher = <T extends AdapterConstants>(config: FetcherConfig<T
                     allDescriptors.push(...componentDescriptors);
                 }
             }
-
-            const {query, variables} = combineMultipleQueries(allDescriptors);
-
+            const { query, variables } = combineMultipleQueries(allDescriptors);
             if (!query.trim()) {
-                return errorResponse('400', `Missing or empty query override for content type ${type}`, requestType, renderMode,
-                    contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                return errorResponse('400', `Missing or empty query override for content type ${type}`, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
             }
-
             // ///////////////    SECOND GUILLOTINE CALL FOR DATA   //////////////////////
-            const contentResults = await fetchContentData(contentApiUrl, contentPath, projectConfig, query, variables, headers);
+            const contentResults = yield fetchContentData(contentApiUrl, contentPath, projectConfig, query, variables, headers);
             // ///////////////////////////////////////////////////////////////////////////
-
             if (contentResults.error) {
                 console.error(contentResults.error);
-                return errorResponse(contentResults.error.code, contentResults.error.message, requestType, renderMode, contentApiUrl,
-                    xpBaseUrl, context.locale, context.defaultLocale, contentPath);
+                return errorResponse(contentResults.error.code, contentResults.error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPath);
             }
-
             // Apply processors to every component
-            const datas = await applyProcessors(allDescriptors, contentResults, context);
-
+            const datas = yield applyProcessors(allDescriptors, contentResults, context);
             //  Unwind the data back to components
-
             let contentData = null, common = null;
             let startFrom = 0;
             if (contentQueryAndVars) {
@@ -929,7 +694,6 @@ const buildContentFetcher = <T extends AdapterConstants>(config: FetcherConfig<T
                 common = item.status === 'fulfilled' ? item.value : item.reason;
                 startFrom++;
             }
-
             for (let i = startFrom; i < datas.length; i++) {
                 // component descriptors hold references to components
                 // that will later be used for creating page regions
@@ -938,46 +702,42 @@ const buildContentFetcher = <T extends AdapterConstants>(config: FetcherConfig<T
                     let reason = datum.reason;
                     if (reason instanceof Error) {
                         reason = reason.message;
-                    } else if (typeof reason !== 'string') {
+                    }
+                    else if (typeof reason !== 'string') {
                         reason = String(reason);
                     }
                     allDescriptors[i].component.error = reason;
-                } else {
+                }
+                else {
                     allDescriptors[i].component.data = datum.value;
                 }
             }
-
             const page = createPageData(type, components);
             const meta = createMetaData(type, siteRelativeContentPath, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, componentPath, page, components);
-
             return {
                 data: contentData,
                 common,
                 meta,
                 page,
-            } as FetchContentResult;
-
-        } catch (e: any) {
+            };
+        }
+        catch (e) {
             console.error(e);
-
             let error;
             try {
                 error = JSON.parse(e.message);
-            } catch (e2) {
+            }
+            catch (e2) {
                 error = {
                     code: 'Local',
                     message: e.message,
                 };
             }
-            return errorResponse(error.code, error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale,
-                context.defaultLocale, contentPathOrArray.toString());
+            return errorResponse(error.code, error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPathOrArray.toString());
         }
-    };
+    });
 };
-
-
 // ////////////////////////////  ENTRY 2: ready-to-use fetchContent function
-
 /**
  * Default fetchContent function, built with params from imports.
  * It runs custom content-type-specific guillotine calls against an XP guillotine endpoint, returns content data, error and some meta data
@@ -986,16 +746,11 @@ const buildContentFetcher = <T extends AdapterConstants>(config: FetcherConfig<T
  * @param context object from Next, contains .query info
  * @returns FetchContentResult object: {data?: T, error?: {code, message}}
  */
-export const fetchContent: ContentFetcher = buildContentFetcher<AdapterConstants>({
-    ...adapterConstants,
-    componentRegistry: ComponentRegistry,
-});
-
-export function createResponse(props: FetchContentResult, context?: Context, isStatic?: true): GetStaticPropsResult<FetchContentResult>;
-export function createResponse(props: FetchContentResult, context?: Context, isStatic?: false): GetServerSidePropsResult<FetchContentResult>;
-export function createResponse(props: FetchContentResult, context?: Context, isStatic = true): GetStaticPropsResult<FetchContentResult> | GetServerSidePropsResult<FetchContentResult> {
-    const {data, meta, error} = props;
-    const pageUrl = data?.get?.data?.target?.pageUrl;
+export const fetchContent = buildContentFetcher(Object.assign(Object.assign({}, adapterConstants), { componentRegistry: ComponentRegistry }));
+export function createResponse(props, context, isStatic = true) {
+    var _a, _b, _c, _d;
+    const { data, meta, error } = props;
+    const pageUrl = (_c = (_b = (_a = data === null || data === void 0 ? void 0 : data.get) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.target) === null || _c === void 0 ? void 0 : _c.pageUrl;
     if (meta.type === 'base:shortcut' && pageUrl) {
         if (meta.renderMode !== RENDER_MODE.NEXT) {
             // console.debug(`Returning 404 for shortcut in ${RENDER_MODE.NEXT} mode`);
@@ -1004,7 +759,6 @@ export function createResponse(props: FetchContentResult, context?: Context, isS
                 notFound: true,
             };
         }
-
         const destination = getUrl(pageUrl, meta, true);
         // console.debug('Redirecting to', destination);
         return {
@@ -1014,66 +768,62 @@ export function createResponse(props: FetchContentResult, context?: Context, isS
             },
         };
     }
-
     // we can not set 418 for static paths,
     // but we can show 404 instead to be handled in CS
     const canNotRender = meta && !meta.canRender && meta.renderMode !== RENDER_MODE.EDIT;
-
-    const catchAllInNextProdMode = meta?.renderMode === RENDER_MODE.NEXT && !IS_DEV_MODE && meta?.catchAll;
-
-    const notFound = (error && error.code === '404') || context.res?.statusCode === 404 || canNotRender || catchAllInNextProdMode || undefined;
-
+    const catchAllInNextProdMode = (meta === null || meta === void 0 ? void 0 : meta.renderMode) === RENDER_MODE.NEXT && !IS_DEV_MODE && (meta === null || meta === void 0 ? void 0 : meta.catchAll);
+    const notFound = (error && error.code === '404') || ((_d = context.res) === null || _d === void 0 ? void 0 : _d.statusCode) === 404 || canNotRender || catchAllInNextProdMode || undefined;
     // console.debug('Returning view ' + (notFound ? '(not found)' : ''));
-    const result: GetStaticPropsResult<FetchContentResult> | GetServerSidePropsResult<FetchContentResult> = {
+    const result = {
         notFound,
         props,
     };
-
     if (isStatic) {
-        (<GetStaticPropsResult<FetchContentResult>>result).revalidate = 3600;   // In seconds, meaning every hour
+        result.revalidate = 3600; // In seconds, meaning every hour
     }
-
     return result;
 }
-
-function populateEnonicHeaders(context: Context) {
+function populateEnonicHeaders(context) {
     const pd = context.previewData;
     if (!pd) {
         return;
     }
-    const req = context.req || {} as any;
+    const req = context.req || {};
     req.headers = Object.assign(req.headers || {}, pd.headers);
     context.params = Object.assign(context.params || {}, pd.params);
     context.req = req;
 }
-
-export async function fetchContentPathsForAllLocales(path: string, query: string = GET_STATIC_PATHS_QUERY, countPerLocale = 999): Promise<ContentPathItem[]> {
-    const promises = Object.values(getLocaleProjectConfigs()).map(config => fetchContentPathsForLocale(path, config, query, countPerLocale));
-    return Promise.all(promises).then(results => {
-        return results.reduce((all, localePaths) => all.concat(localePaths), []);
+export function fetchContentPathsForAllLocales(path, query = GET_STATIC_PATHS_QUERY, countPerLocale = 999) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const promises = Object.values(getLocaleProjectConfigs()).map(config => fetchContentPathsForLocale(path, config, query, countPerLocale));
+        return Promise.all(promises).then(results => {
+            return results.reduce((all, localePaths) => all.concat(localePaths), []);
+        });
     });
 }
-
-export async function fetchContentPathsForLocale(path: string, config: LocaleProjectConfig, query: string = GET_STATIC_PATHS_QUERY, count = 999): Promise<ContentPathItem[]> {
-    const contentApiUrl = getContentApiUrl({locale: config.locale});
-    const body: ContentApiBaseBody = {
-        query,
-        variables: {
-            path,
-            count,
-        },
-    };
-    return fetchGuillotine(contentApiUrl, body, config).then((results: GuillotineResult) => {
-        return results.guillotine.queryDsl.reduce((prev: ContentPathItem[], child: any) => {
-            const regexp = new RegExp(`/${child.site?._name}/?`);
-            const contentPath = child._path.replace(regexp, '');
-            prev.push({
-                params: {
-                    contentPath: contentPath.split('/'),
-                },
-                locale: normalizeLocale(config.locale),
-            });
-            return prev;
-        }, []);
+export function fetchContentPathsForLocale(path, config, query = GET_STATIC_PATHS_QUERY, count = 999) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contentApiUrl = getContentApiUrl({ locale: config.locale });
+        const body = {
+            query,
+            variables: {
+                path,
+                count,
+            },
+        };
+        return fetchGuillotine(contentApiUrl, body, config).then((results) => {
+            return results.guillotine.queryDsl.reduce((prev, child) => {
+                var _a;
+                const regexp = new RegExp(`/${(_a = child.site) === null || _a === void 0 ? void 0 : _a._name}/?`);
+                const contentPath = child._path.replace(regexp, '');
+                prev.push({
+                    params: {
+                        contentPath: contentPath.split('/'),
+                    },
+                    locale: normalizeLocale(config.locale),
+                });
+                return prev;
+            }, []);
+        });
     });
 }