@enonic/nextjs-adapter 0.0.1-alpha.1

package/guillotine/fetchContent.js

@@ -0,0 +1,644 @@
+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, pageFragmentQuery, } from './getMetaData';
+import adapterConstants, { APP_NAME, APP_NAME_DASHED, FRAGMENT_CONTENTTYPE_NAME, FRAGMENT_DEFAULT_REGION_NAME, getContentApiUrl, getXpBaseUrl, IS_DEV_MODE, PAGE_TEMPLATE_CONTENTTYPE_NAME, PAGE_TEMPLATE_FOLDER, RENDER_MODE, sanitizeGraphqlName, SITE_KEY, XP_COMPONENT_TYPE, XP_REQUEST_TYPE, } from '../utils';
+import { ComponentRegistry } from '../ComponentRegistry';
+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, method = 'POST') => __awaiter(void 0, void 0, void 0, function* () {
+    const options = {
+        method,
+        headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'X-Guillotine-SiteKey': SITE_KEY,
+        },
+        body: JSON.stringify(body),
+    };
+    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()}')`,
+        }));
+    }
+    let json;
+    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, xpContentPath) => __awaiter(void 0, void 0, void 0, function* () {
+    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 result = yield fetchFromApi(contentApiUrl, body)
+        .then(json => {
+        let errors = (json || {}).errors;
+        if (errors) {
+            if (!Array.isArray(errors)) {
+                errors = [errors];
+            }
+            console.warn(`${errors.length} error(s) when trying to fetch data (path = ${JSON.stringify(xpContentPath)}):`);
+            errors.forEach(error => {
+                console.error(error);
+            });
+            console.warn(`Query:\n${body.query}`);
+            console.warn(`Variables: ${JSON.stringify(body.variables, null, 2)}`);
+            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 (path = ${JSON.stringify(xpContentPath)})`, 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) => __awaiter(void 0, void 0, void 0, function* () {
+    var _b;
+    const body = {
+        query: getMetaQuery(pageFragmentQuery()),
+        variables: {
+            path: xpContentPath,
+        },
+    };
+    const metaResult = yield fetchGuillotine(contentApiUrl, body, xpContentPath);
+    if (metaResult.error) {
+        return metaResult;
+    }
+    else {
+        return {
+            meta: (_b = metaResult === null || metaResult === void 0 ? void 0 : metaResult.guillotine) === null || _b === void 0 ? void 0 : _b.get,
+        };
+    }
+});
+const fetchContentData = (contentApiUrl, xpContentPath, query, variables) => __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, xpContentPath);
+    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;
+            });
+            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 = []) {
+    let page = {
+        type: XP_COMPONENT_TYPE.PAGE,
+        path: '/',
+    };
+    const tree = {};
+    if (contentType === FRAGMENT_CONTENTTYPE_NAME) {
+        page.regions = tree;
+    }
+    comps.forEach(cmp => {
+        var _a;
+        const cmpPath = parseComponentPath(contentType, cmp.path);
+        let region;
+        if (cmp.path === '/' && cmp.type === XP_COMPONENT_TYPE.PAGE) {
+            // add page values to page object
+            page = Object.assign(page, cmp);
+            page.page.regions = tree;
+            return;
+        }
+        else {
+            region = getParentRegion(tree, contentType, cmpPath, comps, true);
+        }
+        if (region) {
+            // getting the index of component from string like '/main/0/left/11'
+            const cmpIndex = (_a = cmpPath[cmpPath.length - 1]) === null || _a === void 0 ? void 0 : _a.index;
+            if (cmpIndex >= 0) {
+                region.components.splice(cmpIndex, 0, cmp);
+            }
+            else {
+                throw Error(`Could not find [${cmp.type}] component index at ${JSON.stringify(cmpPath, null, 2)}, rendering not possible.`);
+            }
+        }
+    });
+    return page;
+}
+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];
+        });
+    });
+    // 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++];
+            }
+            return yield propsProcessor(data, context);
+        }));
+        return Promise.allSettled(processorPromises);
+    });
+}
+function collectComponentDescriptors(components, componentRegistry, requestedComponentPath, xpContentPath, context) {
+    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 cmpData = cmp[cmp.type];
+                const config = cmpData && 'config' in cmpData ? cmpData.config : undefined;
+                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(cmp.fragment.fragment.components, componentRegistry, requestedComponentPath, 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') {
+        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') {
+        throw Error(`Query for content type ${type} should be a string, not: ${typeof query}`);
+    }
+    if (query) {
+        return {
+            query: query,
+            variables: getVariables ? getVariables(path, context, config) : { path },
+        };
+    }
+}
+function createPageData(contentType, components) {
+    let page;
+    if (components) {
+        page = buildPage(contentType, components);
+    }
+    return page;
+}
+function createMetaData(contentType, contentPath, requestType, renderMode, apiUrl, baseUrl, 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,
+    };
+    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 (pageDesc) {
+        // always render a page if there is a descriptor (show missing in case it's not implemented)
+        meta.canRender = true;
+        meta.catchAll = false; // catchAll only refers to content type catch-all
+    }
+    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, 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,
+        },
+    };
+}
+// /////////////////////////////  ENTRY 1 - THE BUILDER:
+/**
+ * Configures, builds and returns a general fetchContent function.
+ * @param adapterConstants Object containing attributes imported from enonic-connecion-config.js: constants and function concerned with connection to the XP backend. Easiest: caller imports enonic-connection-config and just passes that entire object here as adapterConstants.
+ * @param componentRegistry ComponentRegistry object from ComponentRegistry.ts, holding user type mappings that are set in typesRegistration.ts file
+ * @returns ContentFetcher
+ */
+export const buildContentFetcher = (config) => {
+    const { APP_NAME, APP_NAME_DASHED, getXPRequestType, getRenderMode, getSingleComponentPath, componentRegistry, } = config;
+    return (contentPathOrArray, context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const xpBaseUrl = getXpBaseUrl(context);
+        const contentApiUrl = getContentApiUrl(context);
+        const requestType = getXPRequestType(context);
+        const renderMode = getRenderMode(context);
+        let contentPath;
+        try {
+            const siteRelativeContentPath = getCleanContentPathArrayOrThrow400(contentPathOrArray);
+            let requestedComponentPath;
+            if (requestType === XP_REQUEST_TYPE.COMPONENT) {
+                requestedComponentPath = getSingleComponentPath(context);
+            }
+            // /////////////  FIRST GUILLOTINE CALL FOR METADATA     /////////////////
+            const metaResult = yield fetchMetaData(contentApiUrl, '${site}/' + siteRelativeContentPath);
+            // ///////////////////////////////////////////////////////////////////////
+            const { type, components, _path } = metaResult.meta || {};
+            contentPath = _path || '';
+            if (metaResult.error) {
+                return errorResponse(metaResult.error.code, metaResult.error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, contentPath);
+            }
+            if (!metaResult.meta) {
+                return errorResponse('404', 'No meta data found for content, most likely content does not exist', requestType, renderMode, contentApiUrl, xpBaseUrl, contentPath);
+            }
+            else if (!type) {
+                return errorResponse('500', "Server responded with incomplete meta data: missing content 'type' attribute.", requestType, renderMode, contentApiUrl, xpBaseUrl, 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, contentPath);
+            }
+            // //////////////////////////////////////////////////  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, requestedComponentPath, 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, contentPath);
+            }
+            // ///////////////    SECOND GUILLOTINE CALL FOR DATA   //////////////////////
+            const contentResults = yield fetchContentData(contentApiUrl, contentPath, query, variables);
+            // ///////////////////////////////////////////////////////////////////////////
+            // 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, requestedComponentPath, page, components);
+            return {
+                data: contentData,
+                common,
+                meta,
+                page: page || null,
+            };
+            // ///////////////////////////////////////////////////////////  Catch
+        }
+        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, contentPath);
+        }
+    });
+};
+// ////////////////////////////  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 }));