@enonic/nextjs-adapter 2.0.0 → 3.0.0-B2

package/guillotine/fetchContent.js

@@ -7,823 +7,216 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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{}().,:"'`]+}/;
-/** Generic fetch */
-export const fetchFromApi = (apiUrl, body, projectConfig, headers, method = 'POST') => __awaiter(void 0, void 0, void 0, function* () {
-    const options = {
-        method,
-        headers: {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'X-Guillotine-SiteKey': projectConfig.site,
-        },
-        body: JSON.stringify(body),
-    };
-    if (headers) {
-        Object.assign(options.headers, headers);
-    }
-    let res;
-    try {
-        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: '${yield res.text()}')`,
-        }));
+import { headers } from 'next/headers';
+import { ComponentRegistry } from '../common/ComponentRegistry';
+import { UrlProcessor } from '../common/UrlProcessor';
+import { FRAGMENT_CONTENTTYPE_NAME, PAGE_TEMPLATE_CONTENTTYPE_NAME, PAGE_TEMPLATE_FOLDER, RENDER_MODE, XP_COMPONENT_TYPE, XP_REQUEST_TYPE, } from '../common/constants';
+import { APP_NAME, APP_NAME_DASHED, IS_DEV_MODE } from '../common/env';
+import { getContentApiUrl } from '../utils/getContentApiUrl';
+import { getProjectLocaleConfig } from '../utils/getProjectLocaleConfig';
+import { getRenderMode } from '../utils/getRenderMode';
+import { getXpBaseUrl } from '../utils/getXpBaseUrl';
+import { getRequestLocaleInfo } from '../utils/getRequestLocaleInfo';
+import { buildGuillotineRequestHeaders } from '../utils/buildGuillotineRequestHeaders';
+import { buildPage } from './buildPage';
+import { fetchMetaData } from './fetchMetaData';
+import { getCleanContentPathArrayOrThrow400 } from './getCleanContentPathArrayOrThrow400';
+import { buildErrorResponse } from './buildErrorResponse';
+import { getContentAndComponentPaths } from './getContentAndComponentPaths';
+import { restrictComponentsToPath } from './restrictComponentsToPath';
+import { processComponentConfig } from './processComponentConfig';
+import { getQueryAndVariables } from './getQueryAndVariables';
+import { collectComponentDescriptors } from './collectComponentDescriptors';
+import { combineMultipleQueries } from './combineMultipleQueries';
+import { fetchContentData } from './fetchContentData';
+import { applyProcessors } from './applyProcessors';
+import { createMetaData } from './createMetaData';
+/**
+ * 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
+ * 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 context object from Next, contains .query info
+ * @returns FetchContentResult object: {data?: T, error?: {code, message}}
+ */
+export const fetchContent = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { locale, locales, defaultLocale } = getRequestLocaleInfo(context);
+    // ideally we only want to set headers in draft mode,
+    // but draft mode token is not passed in non-static mode
+    // so try to add them whenever they are absent
+    if (!context.headers) {
+        // TODO does this break routing or dynamic server-side rendering?
+        // I guess hydration will fix it anyway?
+        const allHeaders = headers();
+        context.headers = new Headers();
+        allHeaders.forEach((value, key) => {
+            context.headers.set(key, value);
+        });
     }
-    let json;
+    const outHeaders = buildGuillotineRequestHeaders({
+        context,
+        defaultLocale,
+        locale,
+        locales,
+    });
+    const xpBaseUrl = getXpBaseUrl(context);
+    const contentApiUrl = getContentApiUrl(context);
+    const projectConfig = getProjectLocaleConfig(context);
+    const renderMode = getRenderMode(context);
+    let requestType = XP_REQUEST_TYPE.TYPE;
+    const requestContentPath = getCleanContentPathArrayOrThrow400(context.contentPath);
+    const errorResponse = buildErrorResponse(requestType, renderMode, contentApiUrl, xpBaseUrl, locale, defaultLocale, requestContentPath);
+    UrlProcessor.setSiteKey(projectConfig.site);
     try {
-        json = yield 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())}`,
-        }));
-    }
-    if (!json) {
-        throw new Error(JSON.stringify({
-            code: 500,
-            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 = (contentApiUrl, body, projectConfig, headers) => __awaiter(void 0, void 0, void 0, function* () {
-    var _b;
-    if (typeof body.query !== 'string' || !body.query.trim()) {
-        return {
-            error: {
-                code: '400',
-                message: `Invalid or missing query. JSON.stringify(query) = ${JSON.stringify(body.query)}`,
-            },
-        };
-    }
-    const path = (_b = body.variables) === null || _b === void 0 ? void 0 : _b.path;
-    const pathMessage = path ? JSON.stringify(path) : '';
-    const result = yield 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)}
-                variables: ${JSON.stringify(body.variables, null, 2)}`);
-            errors.forEach(error => {
-                console.error(error);
+        const [siteRelativeContentPath, componentPath] = getContentAndComponentPaths(requestContentPath);
+        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, outHeaders);
+        // ///////////////////////////////////////////////////////////////////////
+        const { _path, type } = metaResult.meta || {};
+        const contentPath = _path || siteRelativeContentPath;
+        if (metaResult.error) {
+            console.error(metaResult.error);
+            return errorResponse(metaResult.error.code, metaResult.error.message);
+        }
+        if (!metaResult.meta) {
+            return errorResponse('404', 'No meta data found for content, most likely content does not exist');
+        }
+        else if (!type) {
+            return errorResponse('500', "Server responded with incomplete meta data: missing content 'type' attribute.");
+        }
+        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`);
+        }
+        const components = restrictComponentsToPath(type, metaResult.meta.components, componentPath);
+        if (componentPath && !components.length) {
+            // component was not found
+            return errorResponse('404', `Component ${componentPath} was not found`);
+        }
+        if (requestType !== XP_REQUEST_TYPE.COMPONENT && components.length > 0) {
+            requestType = XP_REQUEST_TYPE.PAGE;
+        }
+        // //////////////////////////////////////////////////  Content type established. Proceed to data call:
+        const allDescriptors = [];
+        // Add the content type query at all cases
+        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, context, contentTypeDef === null || contentTypeDef === void 0 ? void 0 : contentTypeDef.query, (_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,
             });
-            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;
-});
-// /////////////////////////////////////////////////////////////////////////////// Specific fetch wrappers:
-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 = yield fetchGuillotine(contentApiUrl, body, projectConfig, headers);
-    if (metaResult.error) {
-        return metaResult;
-    }
-    else {
-        return {
-            meta: (_c = metaResult === null || metaResult === void 0 ? void 0 : metaResult.guillotine) === null || _c === void 0 ? void 0 : _c.get,
-        };
-    }
-});
-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 = yield fetchGuillotine(contentApiUrl, body, projectConfig, headers);
-    if (contentResults.error) {
-        return contentResults;
-    }
-    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) => {
-    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)})`,
-            }));
-        }
-        return contentPath;
-    }
-    else {
-        return (contentPath).join('/');
-    }
-};
-function parseComponentPath(contentType, path) {
-    const matches = [];
-    let match;
-    const myRegexp = /(?:(\w+)\/(\d+))+/g;
-    while ((match = myRegexp.exec(path)) !== null) {
-        matches.push({
-            region: match[1],
-            index: +match[2],
-        });
-    }
-    if (contentType === FRAGMENT_CONTENTTYPE_NAME) {
-        // there is no main region in fragment content and the root component has '/' path
-        // prepend FRAGMENT_DEFAULT_REGION_NAME to path to conform to page structure
-        matches.unshift({
-            region: FRAGMENT_DEFAULT_REGION_NAME,
-            index: 0,
-        });
-    }
-    return matches;
-}
-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 = {
-                    name: regionName,
-                    components: [],
-                };
-                currentTree[regionName] = currentRegion;
-            }
-            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) => {
-                return cmp.type === XP_COMPONENT_TYPE.LAYOUT && prefixLayoutPath(contentType, cmp.path) === parentPath;
+        const commonQueryAndVars = getQueryAndVariables(type, contentPath, context, ComponentRegistry.getCommonQuery(), (_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 (!layout) {
-                throw `Layout [${parentPath}] not found among components, but needed for component [${JSON.stringify(cmpPath, null, 2)}]`;
-            }
-            if (!layout.regions) {
-                layout.regions = {};
-            }
-            currentTree = layout.regions;
         }
-    }
-    return currentRegion;
-}
-function prefixLayoutPath(contentType, path) {
-    if (contentType !== FRAGMENT_CONTENTTYPE_NAME) {
-        return path;
-    }
-    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 = {
-        type: XP_COMPONENT_TYPE.PAGE,
-        path: '/',
-    };
-    return buildComponentTree(comps, page, contentType);
-}
-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) {
-                // 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 ((components === null || components === void 0 ? void 0 : components.length) && ComponentRegistry) {
+            for (const cmp of (components || [])) {
+                processComponentConfig(APP_NAME, APP_NAME_DASHED, cmp);
             }
-        }
-        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);
-        }
-        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;
-            if (cmpIndex >= 0) {
-                region.components.splice(cmpIndex, 0, cmp);
+            // Collect component queries if defined
+            const componentDescriptors = collectComponentDescriptors({
+                components,
+                xpContentPath: contentPath,
+                context,
+            });
+            if (componentDescriptors.length) {
+                allDescriptors.push(...componentDescriptors);
+            }
+        }
+        const { query, variables } = combineMultipleQueries(allDescriptors);
+        if (!query.trim()) {
+            return errorResponse('400', `Missing or empty query override for content type ${type}`);
+        }
+        // ///////////////    SECOND GUILLOTINE CALL FOR DATA   //////////////////////
+        const contentResults = yield fetchContentData(contentApiUrl, contentPath, projectConfig, query, variables, outHeaders);
+        // ///////////////////////////////////////////////////////////////////////////
+        if (contentResults.error) {
+            console.error(contentResults.error);
+            return errorResponse(contentResults.error.code, contentResults.error.message);
+        }
+        // Apply processors to every component
+        const datas = yield applyProcessors(allDescriptors, contentResults, context);
+        //  Unwind the data back to components
+        let contentData = null, common = null;
+        let startFrom = 0;
+        if (contentQueryAndVars) {
+            const item = datas[startFrom];
+            contentData = item.status === 'fulfilled' ? item.value : item.reason;
+            startFrom++;
+        }
+        if (commonQueryAndVars) {
+            const item = datas[startFrom];
+            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
+            const datum = datas[i];
+            if (datum.status === 'rejected') {
+                let reason = datum.reason;
+                if (reason instanceof Error) {
+                    reason = reason.message;
+                }
+                else if (typeof reason !== 'string') {
+                    reason = String(reason);
+                }
+                allDescriptors[i].component.error = reason;
             }
             else {
-                throw Error(`Could not find [${cmp.type}] component index at ${JSON.stringify(cmpPath, null, 2)}, rendering not possible.`);
+                allDescriptors[i].component.data = datum.value;
             }
         }
-    });
-    return rootComp;
-}
-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 === 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) {
-            // both query and params are present
-            query = match[2];
-            // process args
-            const args = match[1];
-            if (args) {
-                args.split(',').forEach(originalParamString => {
-                    const [originalKey, originalVal] = originalParamString.trim().split(':');
-                    const [prefixedKey, prefixedVal] = [`$${ALIAS_PREFIX}${index}_${originalKey.substr(1)}`, originalVal];
-                    superParams.push(`${prefixedKey}:${prefixedVal}`);
-                    // also update param references in query itself !
-                    // query = query.replaceAll(originalKey, prefixedKey);
-                    // replaceAll is not supported in older nodejs versions
-                    const origKeyPattern = new RegExp(originalKey.replace(/\$/g, '\\$'), 'g');
-                    query = query.replace(origKeyPattern, prefixedKey);
-                });
-            }
-        }
-        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];
+        const page = buildPage(type, components);
+        const meta = createMetaData({
+            apiUrl: contentApiUrl,
+            baseUrl: xpBaseUrl,
+            components,
+            contentPath: siteRelativeContentPath,
+            contentType: type,
+            defaultLocale,
+            locale,
+            pageCmp: page,
+            renderMode,
+            requestedComponentPath: componentPath,
+            requestType,
         });
-    });
-    // 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);
-    });
-}
-function getComponentConfig(cmp) {
-    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 = [];
-    for (const cmp of (components || [])) {
-        processComponentConfig(APP_NAME, APP_NAME_DASHED, cmp);
-        // only look for parts
-        // look for single part if it is a single component request
-        if (XP_COMPONENT_TYPE.FRAGMENT !== cmp.type) {
-            const cmpDef = ComponentRegistry.getByComponent(cmp);
-            if (cmpDef) {
-                // const partPath = `${xpContentPath}/_component${cmp.path}`;
-                const config = getComponentConfig(cmp);
-                const queryAndVariables = getQueryAndVariables(cmp.type, xpContentPath, cmpDef.query, context, config);
-                if (queryAndVariables) {
-                    descriptors.push({
-                        component: cmp,
-                        type: cmpDef,
-                        queryAndVariables: queryAndVariables,
-                    });
-                }
-            }
-        }
-        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);
-            if (fragPartDescs.length) {
-                descriptors.push(...fragPartDescs);
-            }
-        }
-    }
-    return descriptors;
-}
-function processComponentConfig(myAppName, myAppNameDashed, cmp) {
-    const cmpData = cmp[cmp.type];
-    if (cmpData && 'descriptor' in cmpData && cmpData.descriptor) {
-        const [appName, cmpName] = cmpData.descriptor.split(':');
-        if (appName !== myAppName) {
-            return;
-        }
-        let config;
-        const configArray = [];
-        if ('configAsJson' in cmpData && cmpData.configAsJson && cmpData.configAsJson[myAppNameDashed]) {
-            config = cmpData.configAsJson[myAppNameDashed][cmpName];
-            if (config) {
-                configArray.push(config);
-                delete cmpData.configAsJson;
-            }
-        }
-        const sanitizedAppName = sanitizeGraphqlName(appName);
-        if ('config' in cmpData && cmpData.config && cmpData.config[sanitizedAppName]) {
-            config = cmpData.config[sanitizedAppName][sanitizeGraphqlName(cmpName)];
-            if (config) {
-                configArray.push(config);
-            }
-        }
-        if (configArray.length) {
-            cmpData.config = Object.assign({}, ...configArray);
-        }
-    }
-}
-function getQueryAndVariables(type, path, selectedQuery, context, config) {
-    let query, getVariables;
-    if (typeof selectedQuery === 'string' || typeof selectedQuery === 'function') {
-        query = selectedQuery;
-    }
-    else if (Array.isArray(selectedQuery)) {
-        query = selectedQuery[0];
-        getVariables = selectedQuery[1];
-    }
-    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 },
+            data: contentData,
+            common,
+            meta,
+            page,
         };
     }
-}
-function createPageData(contentType, components, componentPath) {
-    let page;
-    if (components && !componentPath) {
-        page = buildPage(contentType, components);
-    }
-    else {
-        // Don't build page for single component
-        page = null;
-    }
-    return page;
-}
-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 = {
-        type: contentType,
-        path: contentPath,
-        requestType: requestType,
-        renderMode: renderMode,
-        canRender: false,
-        catchAll: false,
-        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 typeDef = ComponentRegistry.getContentType(contentType);
-    if ((typeDef === null || typeDef === void 0 ? void 0 : typeDef.view) && !typeDef.catchAll) {
-        meta.canRender = true;
-    }
-    else if (requestType === XP_REQUEST_TYPE.COMPONENT) {
-        // always render a single component (show missing if not implemented)
-        meta.canRender = true;
-    }
-    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) {
-        meta.canRender = true;
-        meta.catchAll = true;
-    }
-    return meta;
-}
-function errorResponse(code = '500', message = 'Unknown error', requestType, renderMode, apiUrl, baseUrl, locale, defaultLocale, contentPath) {
-    return {
-        error: {
-            code,
-            message,
-        },
-        page: null,
-        common: null,
-        data: null,
-        meta: {
-            type: '',
-            requestType: requestType,
-            renderMode: renderMode,
-            path: contentPath || '',
-            canRender: false,
-            catchAll: false,
-            apiUrl,
-            baseUrl,
-            locale,
-            defaultLocale,
-        },
-    };
-}
-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 = [component];
-    if (component.type !== XP_COMPONENT_TYPE.LAYOUT) {
-        // remember to include all parent layouts too !
-        const cmpPath = parseComponentPath(contentType, component.path);
-        for (let i = cmpPath.length - 2; i >= 0; i--) {
-            const parentPath = cmpPath[i];
-            const parentCmp = components.find(cmp => cmp.path === `/${parentPath.region}/${parentPath.index}`);
-            if (parentCmp) {
-                result.unshift(parentCmp);
-            }
-        }
-    }
-    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) {
-            result = result.concat(childCmps);
-        }
-    }
-    return result;
-}
-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 {
-        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;
-        if (context.preview) {
-            populateEnonicHeaders(context);
-        }
-        const headers = {};
-        addJsessionHeaders(headers, context);
-        addLocaleHeaders(headers, context);
-        const xpBaseUrl = getXpBaseUrl(context);
-        const contentApiUrl = getContentApiUrl(context);
-        const projectConfig = getLocaleProjectConfig(context);
-        const renderMode = getRenderMode(context);
-        let requestType = XP_REQUEST_TYPE.TYPE;
-        UrlProcessor.setSiteKey(projectConfig.site);
+    catch (e) {
+        console.error(e);
+        let error;
         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 { _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);
-            }
-            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 &&
-                (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);
-            }
-            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);
-            }
-            if (requestType !== XP_REQUEST_TYPE.COMPONENT && components.length > 0) {
-                requestType = XP_REQUEST_TYPE.PAGE;
-            }
-            // //////////////////////////////////////////////////  Content type established. Proceed to data call:
-            const allDescriptors = [];
-            // Add the content type query at all cases
-            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 === 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, (_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 === null || components === void 0 ? void 0 : components.length) && componentRegistry) {
-                for (const cmp of (components || [])) {
-                    processComponentConfig(APP_NAME, APP_NAME_DASHED, cmp);
-                }
-                // Collect component queries if defined
-                const componentDescriptors = collectComponentDescriptors(components, componentRegistry, contentPath, context);
-                if (componentDescriptors.length) {
-                    allDescriptors.push(...componentDescriptors);
-                }
-            }
-            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);
-            }
-            // ///////////////    SECOND GUILLOTINE CALL FOR DATA   //////////////////////
-            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);
-            }
-            // Apply processors to every component
-            const datas = yield applyProcessors(allDescriptors, contentResults, context);
-            //  Unwind the data back to components
-            let contentData = null, common = null;
-            let startFrom = 0;
-            if (contentQueryAndVars) {
-                const item = datas[startFrom];
-                contentData = item.status === 'fulfilled' ? item.value : item.reason;
-                startFrom++;
-            }
-            if (commonQueryAndVars) {
-                const item = datas[startFrom];
-                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
-                const datum = datas[i];
-                if (datum.status === 'rejected') {
-                    let reason = datum.reason;
-                    if (reason instanceof Error) {
-                        reason = reason.message;
-                    }
-                    else if (typeof reason !== 'string') {
-                        reason = String(reason);
-                    }
-                    allDescriptors[i].component.error = reason;
-                }
-                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,
-            };
+            error = JSON.parse(e.message);
         }
-        catch (e) {
-            console.error(e);
-            let error;
-            try {
-                error = JSON.parse(e.message);
-            }
-            catch (e2) {
-                error = {
-                    code: 'Local',
-                    message: e.message,
-                };
-            }
-            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
- * 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: local (site-relative) path to a content available on the API (by XP _path - obtainable by running contentPath through getXpPath). Pre-split into string array, or already a slash-delimited string.
- * @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;
-    if (meta.type === 'base:shortcut' && pageUrl) {
-        if (meta.renderMode !== RENDER_MODE.NEXT) {
-            // console.debug(`Returning 404 for shortcut in ${RENDER_MODE.NEXT} mode`);
-            // do not show shortcut targets in preview/edit mode
-            return {
-                notFound: true,
+        catch (e2) {
+            error = {
+                code: 'Local',
+                message: e.message,
             };
         }
-        const destination = getUrl(pageUrl, meta, true);
-        // console.debug('Redirecting to', destination);
-        return {
-            redirect: {
-                statusCode: 307,
-                destination,
-            },
-        };
-    }
-    // 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;
-    // console.debug('Returning view ' + (notFound ? '(not found)' : ''));
-    const result = {
-        notFound,
-        props,
-    };
-    if (isStatic) {
-        result.revalidate = 3600; // In seconds, meaning every hour
+        return errorResponse(error.code, error.message);
     }
-    return result;
-}
-function populateEnonicHeaders(context) {
-    const pd = context.previewData;
-    if (!pd) {
-        return;
-    }
-    const req = context.req || {};
-    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 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;
-            }, []);
-        });
-    });
-}
+});
+//# sourceMappingURL=fetchContent.js.map