@enonic/nextjs-adapter 1.0.2 → 2.0.0-B1

package/ComponentRegistry.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import { PageComponent } from './guillotine/getMetaData';
-import { Context } from './guillotine/fetchContent';
+import { Context } from './utils';
 /**
  *  Object that configures the handling of a particular content type. All attributes are optional (see examples below), and missing values will fall back to default behavior:
  *          - 'query' (used in fetchContent.ts) Guillotine query for fetching content data, may also have a function that supplies guillotine variables. So, 'query' can EITHER be only a query string, OR also add a get-guillotine-variables function. In the latter case, 'query' can be an object with 'query' and 'variables' attributes, or an array where the query string is first and the get-variables function is second. Either way, the get-variables function takes two arguments: path (content path, mandatory) and context (next.js-supplied Context from getServerSideProps etc. Optional, and requires that fetchContent is called with the context, of course).

package/ComponentRegistry.js

@@ -10,7 +10,7 @@ function toSelectorName(type) {
     }
 }
 export const CATCH_ALL = '*';
-class ComponentRegistry {
+export class ComponentRegistry {
     static getSelector(name) {
         switch (name) {
             case 'contentType':
@@ -119,4 +119,3 @@ ComponentRegistry.components = {};
 ComponentRegistry.parts = {};
 ComponentRegistry.layouts = {};
 ComponentRegistry.macros = {};
-export { ComponentRegistry };

package/UrlProcessor.d.ts

@@ -11,14 +11,15 @@ export declare class UrlProcessor {
     private static startSlashPattern;
     private static localhostPattern;
     private static siteKey;
-    static process(url: string, meta: MetaData): string;
+    static process(url: string, meta: MetaData, serverSide?: boolean): string;
     static setSiteKey(key: string): void;
     static isMediaLink(ref: string, linkData: LinkData[]): boolean;
     static isContentImage(ref: string, linkData: ImageData[]): boolean;
     static processSrcSet(srcset: string, meta: MetaData): string;
     private static stripApiUrl;
-    private static isPageUrl;
+    private static isAttachmentUrl;
     private static startsWithHash;
+    private static isRelative;
     private static getApiUrl;
 }
-export declare const getUrl: (url: string, meta: MetaData) => string;
+export declare const getUrl: (url: string, meta: MetaData, serverSide?: boolean) => string;

package/UrlProcessor.js

@@ -1,29 +1,34 @@
-import { commonChars, RENDER_MODE, SITE_KEY } from './utils';
-import { useRouter } from 'next/router';
-class UrlProcessor {
-    static process(url, meta) {
+import { commonChars, fixDoubleSlashes, getLocaleProjectConfigs, RENDER_MODE } from './utils';
+import { addBasePath } from 'next/dist/client/add-base-path';
+export class UrlProcessor {
+    static process(url, meta, serverSide = false) {
+        if (this.startsWithHash(url) || !meta || (this.isAttachmentUrl(url)) && meta.renderMode === RENDER_MODE.NEXT) {
+            // do not process if:
+            // - url starts with #
+            // - meta is absent
+            // - attachment urls in NEXT mode
+            return url;
+        }
         let result;
-        if (this.startsWithHash(url) || !meta || !this.isPageUrl(url) && meta.renderMode === RENDER_MODE.NEXT) {
-            // keep page-relative urls starting with hash
-            // keep urls absolute in next mode for everything but page urls
-            result = url;
+        const apiUrl = this.getApiUrl(meta);
+        const strippedUrl = this.stripApiUrl(url, apiUrl);
+        const baseUrl = (meta === null || meta === void 0 ? void 0 : meta.baseUrl) && (meta === null || meta === void 0 ? void 0 : meta.baseUrl) !== '/' ? meta.baseUrl : '';
+        if (meta.renderMode === RENDER_MODE.NEXT) {
+            // only add basePath and locale in next mode
+            result = `/${strippedUrl}`;
+            if (!this.isRelative(url) && meta.locale !== meta.defaultLocale) {
+                // do not append locale to local assets (having relative urls)
+                result = `/${meta.locale}${result}`;
+            }
+            if (!serverSide) {
+                // no need for baseurl and basepath on server
+                result = addBasePath(`${baseUrl}${result}`);
+            }
         }
         else {
-            const apiUrl = this.getApiUrl(meta);
-            const strippedUrl = this.stripApiUrl(url, apiUrl);
-            let basePath;
-            // only add basePath in next
-            if (meta.renderMode === RENDER_MODE.NEXT) {
-                try {
-                    basePath = useRouter().basePath;
-                }
-                catch (e) {
-                    console.error('Error getting basePath from nextjs router', e);
-                }
-            }
-            result = (basePath && basePath !== '/' ? basePath : '') + ((meta === null || meta === void 0 ? void 0 : meta.baseUrl) || '') + strippedUrl;
+            result = `${baseUrl}/${strippedUrl}`;
         }
-        return result;
+        return fixDoubleSlashes(result);
     }
     static setSiteKey(key) {
         this.siteKey = key;
@@ -58,12 +63,15 @@ class UrlProcessor {
         const remaining = common.length > 0 ? normalUrl.substring(common.length) : normalUrl;
         return (remaining.length > 0 && remaining.charAt(0) === '/') ? remaining.substring(1) : remaining;
     }
-    static isPageUrl(url) {
-        return !this.IMG_ATMT_REGEXP.test(url);
+    static isAttachmentUrl(url) {
+        return this.IMG_ATMT_REGEXP.test(url);
     }
     static startsWithHash(url) {
         return (url === null || url === void 0 ? void 0 : url.charAt(0)) == '#';
     }
+    static isRelative(url) {
+        return !/^(?:ht|f)tps?:\/\/[^ :\r\n\t]+/.test(url);
+    }
     static getApiUrl(meta) {
         var _a, _b;
         let combinedUrl = ((_a = meta.apiUrl) === null || _a === void 0 ? void 0 : _a.replace(this.endSlashPattern, '')) || '';
@@ -83,6 +91,7 @@ UrlProcessor.IMG_ATMT_REGEXP = /_\/image\/|_\/attachment\//;
 UrlProcessor.endSlashPattern = /\/+$/;
 UrlProcessor.startSlashPattern = /^\/+/;
 UrlProcessor.localhostPattern = /localhost/;
-export { UrlProcessor };
-UrlProcessor.setSiteKey(SITE_KEY);
+// Actual site is going to be set in fetchContent method, but set a default fallback here too
+const defaultConfig = getLocaleProjectConfigs().default;
+UrlProcessor.setSiteKey(defaultConfig.site);
 export const getUrl = UrlProcessor.process.bind(UrlProcessor);

package/baseMappings.js

@@ -7,10 +7,14 @@ import BaseLayout from './views/BaseLayout';
 import TextView from './views/Text';
 import DefaultMacro from './views/macros/DefaultMacro';
 import DisableMacro from './views/macros/DisableMacro';
+import { getShortcutQuery } from './query/Shortcut';
 // Base Content Types
 ComponentRegistry.addContentType(FRAGMENT_CONTENTTYPE_NAME, {
     view: FragmentView,
 });
+ComponentRegistry.addContentType('base:shortcut', {
+    query: getShortcutQuery,
+});
 // Base Components
 ComponentRegistry.addComponent(XP_COMPONENT_TYPE.PAGE, {
     view: BasePage,

package/guillotine/fetchContent.d.ts

@@ -1,17 +1,13 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { MetaData, PageComponent } from './getMetaData';
-import { ParsedUrlQuery } from 'node:querystring';
-import { type GetServerSidePropsContext } from 'next';
-import { IncomingMessage } from 'http';
-import { type NextApiRequestCookies } from 'next/dist/server/api-utils';
+import { ContentPathItem, Context, LocaleProjectConfig } from '../utils';
+import { GetStaticPropsResult } from 'next';
 type Result = {
     error?: {
         code: string;
         message: string;
     } | null;
 };
-type GuillotineResult = Result & {
+export type GuillotineResult = Result & {
     [dataKey: string]: any;
 };
 export type FetchContentResult = Result & {
@@ -20,37 +16,23 @@ export type FetchContentResult = Result & {
     meta: MetaData;
     page: PageComponent | null;
 };
-export interface ServerSideParams extends ParsedUrlQuery {
-    contentPath?: string[];
-    mode?: string;
-}
-export interface PreviewParams {
-    contentPath: string[];
-    headers: Record<string, string>;
-    params: Record<string, string>;
-}
-export type Context = GetServerSidePropsContext<ServerSideParams, PreviewParams>;
-export interface MinimalContext {
-    req: IncomingMessage & {
-        cookies: NextApiRequestCookies;
-    };
-}
 /**
  * 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>;
+export type ContentFetcher = (contentPath: string | string[], context?: Context) => Promise<FetchContentResult>;
 export type ContentApiBaseBody = {
     query?: string;
     variables?: {
         path?: string;
+        [key: string]: string | number | undefined;
     };
 };
 /** Generic fetch */
-export declare const fetchFromApi: (apiUrl: string, body: ContentApiBaseBody, headers?: {}, method?: string) => Promise<any>;
+export declare const fetchFromApi: (apiUrl: string, body: ContentApiBaseBody, projectConfig: LocaleProjectConfig, headers?: {}, method?: string) => Promise<any>;
 /** Guillotine-specialized fetch, using the generic fetch above */
-export declare const fetchGuillotine: (contentApiUrl: string, body: ContentApiBaseBody, headers?: {}) => Promise<GuillotineResult>;
+export declare const fetchGuillotine: (contentApiUrl: string, body: ContentApiBaseBody, projectConfig: LocaleProjectConfig, headers?: {}) => Promise<GuillotineResult>;
 /**
  * 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
@@ -60,4 +42,7 @@ export declare const fetchGuillotine: (contentApiUrl: string, body: ContentApiBa
  * @returns FetchContentResult object: {data?: T, error?: {code, message}}
  */
 export declare const fetchContent: ContentFetcher;
+export declare function createResponse(props: FetchContentResult, context?: Context): GetStaticPropsResult<FetchContentResult>;
+export declare function fetchContentPathsForAllLocales(path: string, query?: string, countPerLocale?: number): Promise<ContentPathItem[]>;
+export declare function fetchContentPathsForLocale(path: string, config: LocaleProjectConfig, query?: string, count?: number): Promise<ContentPathItem[]>;
 export {};

package/guillotine/fetchContent.js

@@ -8,20 +8,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { getMetaQuery, pageFragmentQuery } from './getMetaData';
-import adapterConstants, { APP_NAME, APP_NAME_DASHED, FRAGMENT_CONTENTTYPE_NAME, FRAGMENT_DEFAULT_REGION_NAME, getContentApiUrl, getJsessionHeaders, getRenderMode, 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 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, 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, headers, method = 'POST') => __awaiter(void 0, void 0, void 0, function* () {
+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': SITE_KEY,
+            'X-Guillotine-SiteKey': projectConfig.site,
         },
         body: JSON.stringify(body),
     };
@@ -64,7 +65,7 @@ export const fetchFromApi = (apiUrl, body, headers, method = 'POST') => __awaite
     return json;
 });
 /** Guillotine-specialized fetch, using the generic fetch above */
-export const fetchGuillotine = (contentApiUrl, body, headers) => __awaiter(void 0, void 0, void 0, function* () {
+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 {
@@ -75,20 +76,20 @@ export const fetchGuillotine = (contentApiUrl, body, headers) => __awaiter(void
         };
     }
     const path = (_b = body.variables) === null || _b === void 0 ? void 0 : _b.path;
-    const pathMessage = path ? `(path = ${JSON.stringify(path)})` : '';
-    const result = yield fetchFromApi(contentApiUrl, body, headers)
+    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.warn(`${errors.length} error(s) when trying to fetch data ${pathMessage}:`);
+            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);
             });
-            console.warn(`Query:\n${body.query}`);
-            console.warn(`Variables: ${JSON.stringify(body.variables, null, 2)}`);
             return {
                 error: {
                     code: '500',
@@ -110,7 +111,7 @@ export const fetchGuillotine = (contentApiUrl, body, headers) => __awaiter(void
     return result;
 });
 // /////////////////////////////////////////////////////////////////////////////// Specific fetch wrappers:
-const fetchMetaData = (contentApiUrl, xpContentPath, headers) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchMetaData = (contentApiUrl, xpContentPath, projectConfig, headers) => __awaiter(void 0, void 0, void 0, function* () {
     var _c;
     const body = {
         query: getMetaQuery(pageFragmentQuery()),
@@ -118,7 +119,7 @@ const fetchMetaData = (contentApiUrl, xpContentPath, headers) => __awaiter(void
             path: xpContentPath,
         },
     };
-    const metaResult = yield fetchGuillotine(contentApiUrl, body, headers);
+    const metaResult = yield fetchGuillotine(contentApiUrl, body, projectConfig, headers);
     if (metaResult.error) {
         return metaResult;
     }
@@ -128,12 +129,12 @@ const fetchMetaData = (contentApiUrl, xpContentPath, headers) => __awaiter(void
         };
     }
 });
-const fetchContentData = (contentApiUrl, xpContentPath, query, variables, headers) => __awaiter(void 0, void 0, void 0, function* () {
+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, headers);
+    const contentResults = yield fetchGuillotine(contentApiUrl, body, projectConfig, headers);
     if (contentResults.error) {
         return contentResults;
     }
@@ -245,8 +246,8 @@ function buildComponentTree(comps, rootComp, contentType) {
     if (isFragmentType) {
         rootComp.regions = rootTree;
     }
-    comps.forEach(cmp => {
-        var _a;
+    (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) {
@@ -264,12 +265,12 @@ function buildComponentTree(comps, rootComp, contentType) {
         }
         if (cmp.type === XP_COMPONENT_TYPE.FRAGMENT) {
             // build component subtree for fragment
-            cmp = buildComponentTree(cmp.fragment.fragment.components, cmp, contentType);
+            cmp = buildComponentTree((_b = (_a = cmp.fragment) === null || _a === void 0 ? void 0 : _a.fragment) === null || _b === void 0 ? void 0 : _b.components, cmp, contentType);
         }
         const region = getParentRegion(rootTree, contentType, cmpPath, comps, true);
         if (region) {
             // getting the index of component from string like '/main/0/left/11'
-            const cmpIndex = (_a = cmpPath[cmpPath.length - 1]) === null || _a === void 0 ? void 0 : _a.index;
+            const cmpIndex = (_c = cmpPath[cmpPath.length - 1]) === null || _c === void 0 ? void 0 : _c.index;
             if (cmpIndex >= 0) {
                 region.components.splice(cmpIndex, 0, cmp);
             }
@@ -369,6 +370,7 @@ function getComponentConfig(cmp) {
     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);
@@ -391,7 +393,7 @@ function collectComponentDescriptors(components, componentRegistry, xpContentPat
         }
         else {
             // look for parts inside fragments
-            const fragPartDescs = collectComponentDescriptors(cmp.fragment.fragment.components, componentRegistry, xpContentPath, context);
+            const fragPartDescs = collectComponentDescriptors((_b = (_a = cmp.fragment) === null || _a === void 0 ? void 0 : _a.fragment) === null || _b === void 0 ? void 0 : _b.components, componentRegistry, xpContentPath, context);
             if (fragPartDescs.length) {
                 descriptors.push(...fragPartDescs);
             }
@@ -467,7 +469,7 @@ function createPageData(contentType, components, componentPath) {
     }
     return page;
 }
-function createMetaData(contentType, contentPath, requestType, renderMode, apiUrl, baseUrl, requestedComponentPath, pageCmp, components = []) {
+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
@@ -481,6 +483,8 @@ function createMetaData(contentType, contentPath, requestType, renderMode, apiUr
         catchAll: false,
         apiUrl,
         baseUrl,
+        locale,
+        defaultLocale,
     };
     if (requestedComponentPath) {
         meta.requestedComponent = components.find(cmp => cmp.path === requestedComponentPath);
@@ -504,7 +508,7 @@ function createMetaData(contentType, contentPath, requestType, renderMode, apiUr
     }
     return meta;
 }
-function errorResponse(code = '500', message = 'Unknown error', requestType, renderMode, apiUrl, baseUrl, contentPath) {
+function errorResponse(code = '500', message = 'Unknown error', requestType, renderMode, apiUrl, baseUrl, locale, defaultLocale, contentPath) {
     return {
         error: {
             code,
@@ -522,6 +526,8 @@ function errorResponse(code = '500', message = 'Unknown error', requestType, ren
             catchAll: false,
             apiUrl,
             baseUrl,
+            locale,
+            defaultLocale,
         },
     };
 }
@@ -578,11 +584,18 @@ 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 headers = getJsessionHeaders(context);
+        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);
         try {
             const requestContentPath = getCleanContentPathArrayOrThrow400(contentPathOrArray);
             const [siteRelativeContentPath, componentPath] = getContentAndComponentPaths(requestContentPath, context);
@@ -591,30 +604,30 @@ const buildContentFetcher = (config) => {
                 requestType = XP_REQUEST_TYPE.COMPONENT;
             }
             // /////////////  FIRST GUILLOTINE CALL FOR METADATA     /////////////////
-            const metaResult = yield fetchMetaData(contentApiUrl, '${site}/' + siteRelativeContentPath, headers);
+            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, 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, contentPath);
+                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, contentPath);
+                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, 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, 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;
@@ -653,14 +666,14 @@ const buildContentFetcher = (config) => {
             }
             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);
+                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, query, variables, headers);
+            const contentResults = yield fetchContentData(contentApiUrl, contentPath, projectConfig, query, variables, headers);
             // ///////////////////////////////////////////////////////////////////////////
             if (contentResults.error) {
                 console.error(contentResults.error);
-                return errorResponse(contentResults.error.code, contentResults.error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, 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);
@@ -696,7 +709,7 @@ const buildContentFetcher = (config) => {
                 }
             }
             const page = createPageData(type, components);
-            const meta = createMetaData(type, siteRelativeContentPath, requestType, renderMode, contentApiUrl, xpBaseUrl, componentPath, page, components);
+            const meta = createMetaData(type, siteRelativeContentPath, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, componentPath, page, components);
             return {
                 data: contentData,
                 common,
@@ -716,7 +729,7 @@ const buildContentFetcher = (config) => {
                     message: e.message,
                 };
             }
-            return errorResponse(error.code, error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, contentPathOrArray.toString());
+            return errorResponse(error.code, error.message, requestType, renderMode, contentApiUrl, xpBaseUrl, context.locale, context.defaultLocale, contentPathOrArray.toString());
         }
     });
 };
@@ -730,3 +743,80 @@ const buildContentFetcher = (config) => {
  * @returns FetchContentResult object: {data?: T, error?: {code, message}}
  */
 export const fetchContent = buildContentFetcher(Object.assign(Object.assign({}, adapterConstants), { componentRegistry: ComponentRegistry }));
+export function createResponse(props, context) {
+    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,
+            };
+        }
+        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)' : ''));
+    return {
+        notFound,
+        props,
+        revalidate: 3600, // In seconds, meaning every hour
+    };
+}
+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) {
+    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) {
+    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.query.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;
+            }, []);
+        });
+    });
+}

package/guillotine/getMetaData.d.ts

@@ -74,6 +74,7 @@ export interface PageData {
     regions?: RegionTree;
 }
 export interface FragmentData {
+    id: string;
     fragment: {
         components: PageComponent[];
     };
@@ -88,4 +89,6 @@ export interface MetaData {
     catchAll: boolean;
     apiUrl: string;
     baseUrl: string;
+    locale: string;
+    defaultLocale: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enonic/nextjs-adapter",
-  "version": "1.0.2",
+  "version": "2.0.0-B1",
   "license": "Apache-2.0",
   "main": "index.js",
   "publishConfig": {
@@ -13,22 +13,22 @@
     "lint:fix": "eslint --fix server && eslint --fix src"
   },
   "dependencies": {
-    "html-react-parser": "^3.0.16",
-    "lru-cache": "^9.1.1",
-    "next": "^13.3.1",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
+    "html-react-parser": "^4.2.0",
+    "lru-cache": "^10.0.0",
+    "next": "13.4.12",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
     "unescape": "^1.0.1"
   },
   "devDependencies": {
     "@enonic/eslint-config": "^1.1.0",
-    "@types/node": "^18.16.0",
-    "@types/react": "^18.0.38",
-    "@types/react-dom": "^18.0.11",
-    "@typescript-eslint/eslint-plugin": "^5.59.0",
-    "@typescript-eslint/parser": "^5.59.0",
-    "eslint": "^8.39.0",
-    "eslint-plugin-react": "^7.32.2",
-    "typescript": "^5.0.4"
+    "@types/node": "^20.4.4",
+    "@types/react": "18.2.15",
+    "@types/react-dom": "18.2.7",
+    "@typescript-eslint/eslint-plugin": "^5.61.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "eslint": "^8.45.0",
+    "eslint-plugin-react": "^7.33.0",
+    "typescript": "^5.1.6"
   }
 }

package/query/Shortcut.d.ts

@@ -0,0 +1 @@
+export declare const getShortcutQuery = "\n  query($path:ID!){\n    guillotine {\n      get(key:$path) {\n        ... on base_Shortcut {\n          data {\n            target {\n              pageUrl(type: absolute)\n            }\n          }\n        }\n      }\n    }\n  }";

package/query/Shortcut.js

@@ -0,0 +1,14 @@
+export const getShortcutQuery = `
+  query($path:ID!){
+    guillotine {
+      get(key:$path) {
+        ... on base_Shortcut {
+          data {
+            target {
+              pageUrl(type: absolute)
+            }
+          }
+        }
+      }
+    }
+  }`;