@enonic/nextjs-adapter 2.0.0 → 2.0.1

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

@@ -1,22 +1,121 @@
-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 {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>[];
 };
-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 : {}; });
+
+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
+};
+
+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 ?? {};
+
 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 = (apiUrl, body, projectConfig, headers, method = 'POST') => __awaiter(void 0, void 0, void 0, function* () {
+export const fetchFromApi = async (
+    apiUrl: string,
+    body: ContentApiBaseBody,
+    projectConfig: LocaleProjectConfig,
+    headers?: {},
+    method = 'POST',
+) => {
     const options = {
         method,
         headers: {
@@ -26,47 +125,55 @@ export const fetchFromApi = (apiUrl, body, projectConfig, headers, method = 'POS
         },
         body: JSON.stringify(body),
     };
+
     if (headers) {
         Object.assign(options.headers, headers);
     }
+
     let res;
     try {
-        res = yield fetch(apiUrl, options);
-    }
-    catch (e) {
+        res = await fetch(apiUrl, options);
+    } catch (e: any) {
         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: '${yield res.text()}')`,
+            message: `Data fetching failed (message: '${await res.text()}')`,
         }));
     }
+
     let json;
     try {
-        json = yield res.json();
-    }
-    catch (e) {
+        json = await res.json();
+    } catch (e) {
         throw new Error(JSON.stringify({
             code: 500,
-            message: `API call completed but with non-JSON data: ${JSON.stringify(yield res.text())}`,
+            message: `API call completed but with non-JSON data: ${JSON.stringify(await res.text())}`,
         }));
     }
+
     if (!json) {
         throw new Error(JSON.stringify({
             code: 500,
-            message: `API call completed but with unexpectedly empty data: ${JSON.stringify(yield res.text())}`,
+            message: `API call completed but with unexpectedly empty data: ${JSON.stringify(await res.text())}`,
         }));
     }
+
     return json;
-});
+};
+
 /** Guillotine-specialized fetch, using the generic fetch above */
-export const fetchGuillotine = (contentApiUrl, body, projectConfig, headers) => __awaiter(void 0, void 0, void 0, function* () {
-    var _b;
+export const fetchGuillotine = async (
+    contentApiUrl: string,
+    body: ContentApiBaseBody,
+    projectConfig: LocaleProjectConfig,
+    headers?: {}): Promise<GuillotineResult> => {
     if (typeof body.query !== 'string' || !body.query.trim()) {
         return {
             error: {
@@ -75,98 +182,129 @@ export const fetchGuillotine = (contentApiUrl, body, projectConfig, headers) =>
             },
         };
     }
-    const path = (_b = body.variables) === null || _b === void 0 ? void 0 : _b.path;
+    const path = body.variables?.path;
     const pathMessage = path ? JSON.stringify(path) : '';
-    const result = yield fetchFromApi(contentApiUrl, body, projectConfig, headers)
+    const result = await fetchFromApi(
+        contentApiUrl,
+        body,
+        projectConfig,
+        headers,
+    )
         .then(json => {
-        let errors = (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)}
+            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.`,
-                },
-            };
-        }
-        return json.data;
-    })
+                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;
-});
+            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;
+};
+
 // /////////////////////////////////////////////////////////////////////////////// Specific fetch wrappers:
-const fetchMetaData = (contentApiUrl, xpContentPath, projectConfig, headers) => __awaiter(void 0, void 0, void 0, function* () {
-    var _c;
-    const body = {
+
+const fetchMetaData = async (contentApiUrl: string, xpContentPath: string, projectConfig: LocaleProjectConfig, headers?: {}): Promise<MetaResult> => {
+    const body: ContentApiBaseBody = {
         query: getMetaQuery(pageFragmentQuery()),
         variables: {
             path: xpContentPath,
         },
     };
-    const metaResult = yield fetchGuillotine(contentApiUrl, body, projectConfig, headers);
+    const metaResult = await fetchGuillotine(contentApiUrl, body, projectConfig, headers);
     if (metaResult.error) {
         return metaResult;
-    }
-    else {
+    } else {
         return {
-            meta: (_c = metaResult === null || metaResult === void 0 ? void 0 : metaResult.guillotine) === null || _c === void 0 ? void 0 : _c.get,
+            meta: metaResult?.guillotine?.get,
         };
     }
-});
-const fetchContentData = (contentApiUrl, xpContentPath, projectConfig, query, variables, headers) => __awaiter(void 0, void 0, void 0, function* () {
-    const body = { query };
+};
+
+
+const fetchContentData = async <T>(
+    contentApiUrl: string,
+    xpContentPath: string,
+    projectConfig: LocaleProjectConfig,
+    query: string,
+    variables?: {},
+    headers?: {},
+): Promise<ContentResult> => {
+
+    const body: ContentApiBaseBody = {query};
     if (variables && Object.keys(variables).length > 0) {
         body.variables = variables;
     }
-    const contentResults = yield fetchGuillotine(contentApiUrl, body, projectConfig, headers);
+    const contentResults = await 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) => {
+const getCleanContentPathArrayOrThrow400 = (contentPath: string | string[] | undefined): string => {
     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('/');
     }
 };
-function parseComponentPath(contentType, path) {
-    const matches = [];
+
+
+// ------------------------------------------------------------- XP view component data handling
+
+
+type PathFragment = { region: string, index: number };
+
+function parseComponentPath(contentType: string, path: string): PathFragment[] {
+    const matches: PathFragment[] = [];
     let match;
     const myRegexp = /(?:(\w+)\/(\d+))+/g;
     while ((match = myRegexp.exec(path)) !== null) {
@@ -185,15 +323,20 @@ function parseComponentPath(contentType, path) {
     }
     return matches;
 }
-function getParentRegion(source, contentType, cmpPath, components = [], createMissing) {
-    let currentTree = source;
-    let currentRegion;
+
+function getParentRegion(source: RegionTree, contentType: string, cmpPath: PathFragment[], components: PageComponent[] = [],
+                         createMissing?: boolean): PageRegion | undefined {
+
+    let currentTree: RegionTree = source;
+    let currentRegion: PageRegion | undefined;
     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 = {
@@ -201,14 +344,15 @@ function getParentRegion(source, contentType, cmpPath, components = [], createMi
                     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) => {
+
+            const layout = components.find((cmp: PageComponent) => {
                 return cmp.type === XP_COMPONENT_TYPE.LAYOUT && prefixLayoutPath(contentType, cmp.path) === parentPath;
             });
             if (!layout) {
@@ -220,94 +364,107 @@ function getParentRegion(source, contentType, cmpPath, components = [], createMi
             currentTree = layout.regions;
         }
     }
+
     return currentRegion;
 }
-function prefixLayoutPath(contentType, path) {
+
+function prefixLayoutPath(contentType: string, path: string): string {
     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, comps = []) {
-    const page = {
+
+function buildPage(contentType: string, comps: PageComponent[] = []): PageComponent {
+
+    const page: PageComponent = {
         type: XP_COMPONENT_TYPE.PAGE,
         path: '/',
     };
+
     return buildComponentTree(comps, page, contentType);
 }
-function buildComponentTree(comps, rootComp, contentType) {
-    const rootTree = {};
+
+function buildComponentTree(comps: PageComponent[], rootComp: PageComponent, contentType?: string): PageComponent {
+    const rootTree: RegionTree = {};
     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((_b = (_a = cmp.fragment) === null || _a === void 0 ? void 0 : _a.fragment) === null || _b === void 0 ? void 0 : _b.components, cmp, contentType);
+            cmp = buildComponentTree(cmp.fragment?.fragment?.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 = (_c = cmpPath[cmpPath.length - 1]) === null || _c === void 0 ? void 0 : _c.index;
+            const cmpIndex = cmpPath[cmpPath.length - 1]?.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) {
-    const queries = [];
-    const fragments = [];
-    const superVars = {};
-    const superParams = [];
-    queriesWithVars.forEach((componentDescriptor, index) => {
+
+
+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) => {
         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 === null || match === void 0 ? void 0 : match.length) === 1) {
+        if (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
@@ -328,50 +485,62 @@ function combineMultipleQueries(queriesWithVars) {
         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,
     };
 }
-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);
+
+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);
     });
+
+    return Promise.allSettled(processorPromises);
 }
-function getComponentConfig(cmp) {
+
+function getComponentConfig(cmp?: PageComponent) {
     const cmpData = cmp && cmp[cmp.type];
     return cmpData && 'config' in cmpData ? cmpData.config : undefined;
 }
-function collectComponentDescriptors(components, componentRegistry, xpContentPath, context) {
-    var _a, _b;
-    const descriptors = [];
+
+function collectComponentDescriptors(components: PageComponent[],
+                                     componentRegistry: typeof ComponentRegistry,
+                                     xpContentPath: string,
+                                     context: Context | undefined,
+): ComponentDescriptor[] {
+
+    const descriptors: ComponentDescriptor[] = [];
+
     for (const cmp of (components || [])) {
         processComponentConfig(APP_NAME, APP_NAME_DASHED, cmp);
         // only look for parts
@@ -390,18 +559,19 @@ function collectComponentDescriptors(components, componentRegistry, xpContentPat
                     });
                 }
             }
-        }
-        else {
+        } else {
             // look for parts inside fragments
-            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);
+            const fragPartDescs = collectComponentDescriptors(cmp.fragment?.fragment?.components, componentRegistry, xpContentPath, context);
             if (fragPartDescs.length) {
                 descriptors.push(...fragPartDescs);
             }
         }
     }
+
     return descriptors;
 }
-function processComponentConfig(myAppName, myAppNameDashed, cmp) {
+
+function processComponentConfig(myAppName: string, myAppNameDashed: string, cmp: PageComponent) {
     const cmpData = cmp[cmp.type];
     if (cmpData && 'descriptor' in cmpData && cmpData.descriptor) {
         const [appName, cmpName] = cmpData.descriptor.split(':');
@@ -409,7 +579,7 @@ function processComponentConfig(myAppName, myAppNameDashed, cmp) {
             return;
         }
         let config;
-        const configArray = [];
+        const configArray: Object[] = [];
         if ('configAsJson' in cmpData && cmpData.configAsJson && cmpData.configAsJson[myAppNameDashed]) {
             config = cmpData.configAsJson[myAppNameDashed][cmpName];
             if (config) {
@@ -429,86 +599,108 @@ function processComponentConfig(myAppName, myAppNameDashed, cmp) {
         }
     }
 }
-function getQueryAndVariables(type, path, selectedQuery, context, config) {
+
+function getQueryAndVariables(type: string,
+                              path: string,
+                              selectedQuery?: SelectedQueryMaybeVariablesFunc,
+                              context?: Context,
+                              config?: any): QueryAndVariables | undefined {
+
     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, components, componentPath) {
+
+
+function createPageData(contentType: string, components: PageComponent[], componentPath?: string): PageComponent | undefined {
     let page;
     if (components && !componentPath) {
         page = buildPage(contentType, components);
-    }
-    else {
+    } else {
         // Don't build page for single component
         page = null;
     }
-    return page;
+    return page as PageComponent;
 }
-function createMetaData(contentType, contentPath, requestType, renderMode, apiUrl, baseUrl, locale, defaultLocale, requestedComponentPath, pageCmp, components = []) {
-    var _a;
+
+
+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 {
     // .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 = {
+    const meta: MetaData = {
         type: contentType,
         path: contentPath,
         requestType: requestType,
         renderMode: renderMode,
         canRender: false,
-        catchAll: false,
+        catchAll: false,  // catchAll only refers to content type catch-all
         apiUrl,
         baseUrl,
         locale,
         defaultLocale,
     };
+
     if (requestedComponentPath) {
         meta.requestedComponent = components.find(cmp => cmp.path === requestedComponentPath);
     }
-    const pageDesc = (_a = pageCmp === null || pageCmp === void 0 ? void 0 : pageCmp.page) === null || _a === void 0 ? void 0 : _a.descriptor;
+
+    const pageDesc = pageCmp?.page?.descriptor;
     const typeDef = ComponentRegistry.getContentType(contentType);
-    if ((typeDef === null || typeDef === void 0 ? void 0 : typeDef.view) && !typeDef.catchAll) {
+    if (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 === null || typeDef === void 0 ? void 0 : typeDef.view) {
+    } else if (typeDef?.view) {
         meta.canRender = true;
         meta.catchAll = true;
     }
+
     return meta;
 }
-function errorResponse(code = '500', message = 'Unknown error', requestType, renderMode, apiUrl, baseUrl, locale, defaultLocale, contentPath) {
+
+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 {
     return {
         error: {
             code,
@@ -531,18 +723,22 @@ function errorResponse(code = '500', message = 'Unknown error', requestType, ren
         },
     };
 }
-function restrictComponentsToPath(contentType, components, componentPath) {
-    if (!componentPath || !(components === null || components === void 0 ? void 0 : components.length)) {
+
+function restrictComponentsToPath(contentType: string, components?: PageComponent[], componentPath?: string) {
+    if (!componentPath || !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 = [component];
+
+    let result: PageComponent[] = [component];
     if (component.type !== XP_COMPONENT_TYPE.LAYOUT) {
         // remember to include all parent layouts too !
         const cmpPath = parseComponentPath(contentType, component.path);
@@ -553,8 +749,7 @@ function restrictComponentsToPath(contentType, components, componentPath) {
                 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) {
@@ -563,30 +758,40 @@ function restrictComponentsToPath(contentType, components, componentPath) {
     }
     return result;
 }
-const COMPONENT_PATH_KEY = /\/?_\/component/; // first slash is optional for root components
-const getContentAndComponentPaths = (requestPath, context) => {
+
+const COMPONENT_PATH_KEY = /\/?_\/component/;   // first slash is optional for root components
+
+const getContentAndComponentPaths = (requestPath: string, context: Context): string[] => {
     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 = (config) => {
-    const { APP_NAME, APP_NAME_DASHED, componentRegistry, } = config;
-    return (contentPathOrArray, context) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
+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> => {
+
         if (context.preview) {
             populateEnonicHeaders(context);
         }
+
         const headers = {};
         addJsessionHeaders(headers, context);
         addLocaleHeaders(headers, context);
@@ -595,70 +800,91 @@ const buildContentFetcher = (config) => {
         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 = yield fetchMetaData(contentApiUrl, '${site}/' + siteRelativeContentPath, projectConfig, headers);
+            const metaResult = await 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 = [];
+
+            const allDescriptors: ComponentDescriptor[] = [];
+
             // Add the content type query at all cases
-            const contentTypeDef = componentRegistry === null || componentRegistry === void 0 ? void 0 : componentRegistry.getContentType(type);
+            const contentTypeDef = 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 === 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);
+
+            const contentQueryAndVars = getQueryAndVariables(type, contentPath, contentTypeDef?.query, context, pageCmp?.page?.config);
             if (contentQueryAndVars) {
                 allDescriptors.push({
                     type: contentTypeDef,
                     queryAndVariables: contentQueryAndVars,
                 });
             }
-            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);
+
+            const commonQueryAndVars = getQueryAndVariables(type, contentPath, componentRegistry.getCommonQuery(), context,
+                pageCmp?.page?.config);
             if (commonQueryAndVars) {
                 allDescriptors.push({
                     type: contentTypeDef,
                     queryAndVariables: commonQueryAndVars,
                 });
             }
-            if ((components === null || components === void 0 ? void 0 : components.length) && componentRegistry) {
+
+            if (components?.length && componentRegistry) {
                 for (const cmp of (components || [])) {
                     processComponentConfig(APP_NAME, APP_NAME_DASHED, cmp);
                 }
@@ -668,20 +894,29 @@ const buildContentFetcher = (config) => {
                     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 = yield fetchContentData(contentApiUrl, contentPath, projectConfig, query, variables, headers);
+            const contentResults = await 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 = yield applyProcessors(allDescriptors, contentResults, context);
+            const datas = await applyProcessors(allDescriptors, contentResults, context);
+
             //  Unwind the data back to components
+
             let contentData = null, common = null;
             let startFrom = 0;
             if (contentQueryAndVars) {
@@ -694,6 +929,7 @@ const buildContentFetcher = (config) => {
                 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
@@ -702,42 +938,46 @@ const buildContentFetcher = (config) => {
                     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,
-            };
-        }
-        catch (e) {
+            } as FetchContentResult;
+
+        } catch (e: any) {
             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
@@ -746,11 +986,16 @@ const buildContentFetcher = (config) => {
  * @param context object from Next, contains .query info
  * @returns FetchContentResult object: {data?: T, error?: {code, message}}
  */
-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;
+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;
     if (meta.type === 'base:shortcut' && pageUrl) {
         if (meta.renderMode !== RENDER_MODE.NEXT) {
             // console.debug(`Returning 404 for shortcut in ${RENDER_MODE.NEXT} mode`);
@@ -759,6 +1004,7 @@ export function createResponse(props, context, isStatic = true) {
                 notFound: true,
             };
         }
+
         const destination = getUrl(pageUrl, meta, true);
         // console.debug('Redirecting to', destination);
         return {
@@ -768,62 +1014,66 @@ export function createResponse(props, context, isStatic = true) {
             },
         };
     }
+
     // 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 === 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;
+
+    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;
+
     // console.debug('Returning view ' + (notFound ? '(not found)' : ''));
-    const result = {
+    const result: GetStaticPropsResult<FetchContentResult> | GetServerSidePropsResult<FetchContentResult> = {
         notFound,
         props,
     };
+
     if (isStatic) {
-        result.revalidate = 3600; // In seconds, meaning every hour
+        (<GetStaticPropsResult<FetchContentResult>>result).revalidate = 3600;   // In seconds, meaning every hour
     }
+
     return result;
 }
-function populateEnonicHeaders(context) {
+
+function populateEnonicHeaders(context: Context) {
     const pd = context.previewData;
     if (!pd) {
         return;
     }
-    const req = context.req || {};
+    const req = context.req || {} as any;
     req.headers = Object.assign(req.headers || {}, pd.headers);
     context.params = Object.assign(context.params || {}, pd.params);
     context.req = req;
 }
-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 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 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;
-            }, []);
-        });
+
+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;
+        }, []);
     });
 }