@enonic/nextjs-adapter 3.3.0-B1 → 3.3.0

package/src/guillotine/fetchContentData.ts

@@ -1,31 +0,0 @@
-import type {ContentApiBaseBody, ContentApiBaseBodyVariables, ContentResult, LocaleMapping, GuillotineRequestHeaders} from '../types';
-
-import {fetchGuillotine} from './fetchGuillotine';
-
-
-export const fetchContentData = async <Content = Record<string, unknown>>(
-    contentApiUrl: string,
-    xpContentPath: string,
-    mapping: LocaleMapping,
-    query: string,
-    variables?: ContentApiBaseBodyVariables,
-    headers?: GuillotineRequestHeaders
-): Promise<ContentResult> => {
-    const body: ContentApiBaseBody = {query};
-    if (variables && Object.keys(variables).length > 0) {
-        body.variables = variables;
-    }
-    const contentResults = await fetchGuillotine<ContentResult<Content>>(contentApiUrl, mapping, {
-        body,
-        headers
-    });
-
-    if (contentResults.error) {
-        return contentResults;
-    } else {
-        return {
-            // omit the aliases and return values
-            contents: Object.values(contentResults)
-        };
-    }
-};

package/src/guillotine/fetchContentPathsForAllLocales.ts

@@ -1,21 +0,0 @@
-import type {ContentPathItem} from '../types';
-
-import {GET_STATIC_PATHS_QUERY} from '../common/constants';
-import {getLocaleMappings} from '../utils/getLocaleMappings';
-import {fetchContentPathsForLocale} from './fetchContentPathsForLocale';
-
-
-export async function fetchContentPathsForAllLocales(
-    path: string,
-    query: string = GET_STATIC_PATHS_QUERY,
-    countPerLocale = 999
-): Promise<ContentPathItem[]> {
-    const promises = Object.values(getLocaleMappings()).map(
-        config => fetchContentPathsForLocale(
-            path, config, query, countPerLocale
-        )
-    );
-    return Promise.all(promises).then(results => {
-        return results.reduce((all, localePaths) => all.concat(localePaths), []);
-    });
-}

package/src/guillotine/fetchContentPathsForLocale.ts

@@ -1,43 +0,0 @@
-import type {ContentApiBaseBody, ContentPathItem, GuillotineResult, LocaleMapping} from '../types';
-
-
-import {GET_STATIC_PATHS_QUERY} from '../common/constants';
-import {getContentApiUrl} from '../utils/getContentApiUrl';
-import {fetchGuillotine} from './fetchGuillotine';
-
-
-export async function fetchContentPathsForLocale(
-    path: string,
-    config: LocaleMapping,
-    query: string = GET_STATIC_PATHS_QUERY,
-    count = 999
-): Promise<ContentPathItem[]> {
-    const contentApiUrl = getContentApiUrl({
-        contentPath: path,
-        locale: config.locale
-    });
-    const body: ContentApiBaseBody = {
-        query,
-        variables: {
-            path,
-            pathRegex: `/content${config.site}/*`,
-            count
-        }
-    };
-    return fetchGuillotine<ContentPathItem[]>(contentApiUrl, config, {body}).then((
-        results: GuillotineResult
-    ) => {
-        return results.guillotine.queryDsl.reduce((
-            prev: ContentPathItem[],
-            child: any
-        ) => {
-            const regexp = new RegExp(`^/${child.site?._name ? `${child.site._name}/?` : ''}`);
-            const contentPath = child._path.replace(regexp, '');
-            prev.push({
-                contentPath: contentPath.split('/'),
-                locale: config.locale
-            });
-            return prev;
-        }, []);
-    });
-}

package/src/guillotine/fetchFromApi.ts

@@ -1,76 +0,0 @@
-import type {FetchOptions, GuillotineResponse, GuillotineResponseJson, LocaleMapping} from '../types';
-
-/** Generic fetch */
-export async function fetchFromApi<Data = Record<string, unknown>>(
-    apiUrl: string,
-    mapping: LocaleMapping,
-    options?: FetchOptions
-): Promise<GuillotineResponseJson> {
-
-    const opts = {
-        method: options?.method || 'POST',
-        body: options?.body ? JSON.stringify(options?.body) : null,
-        headers: mergeHeaders(mapping, options?.headers),
-        next: options?.next,
-        cache: options?.cache
-    };
-
-    let res: GuillotineResponse<Data>;
-    try {
-        res = await fetch(apiUrl, opts as RequestInit);
-    } catch (e: any) {
-        console.warn(apiUrl, e);
-        throw new Error(JSON.stringify({
-            code: 'API',
-            message: e.message
-        }));
-    }
-
-    if (!res.ok) {
-        throw new Error(JSON.stringify({
-            code: res.status,
-            message: `Data fetching failed (message: '${await res.text()}')`
-        }));
-    }
-
-    let json: GuillotineResponseJson<Data>;
-    try {
-        json = await res.json();
-    } catch (e) {
-        throw new Error(JSON.stringify({
-            code: 500,
-            message: `API call completed but with non-JSON data: ${JSON.stringify(await res.text())}`
-        }));
-    }
-
-    if (!json) {
-        throw new Error(JSON.stringify({
-            code: 500,
-            message: `API call completed but with unexpectedly empty data: ${JSON.stringify(await res.text())}`
-        }));
-    }
-
-    if (Array.isArray(json)) {
-        throw new Error(JSON.stringify({
-            code: 500,
-            message: `API call completed but with unexpected array data: ${JSON.stringify(json)}`
-        }));
-    }
-
-    return json;
-}
-
-function mergeHeaders(mapping: LocaleMapping, headers?: HeadersInit): Headers {
-    const newHeaders = new Headers({
-        'Accept': 'application/json',
-        'Content-Type': 'application/json'
-    });
-    if (headers) {
-        Object.keys(headers).forEach((headersKey) => {
-            newHeaders.set(headersKey, headers[headersKey]);
-        });
-    }
-    // append last to make sure it is not overwritten
-    newHeaders.set('X-Guillotine-SiteKey', mapping.site);
-    return newHeaders;
-}

package/src/guillotine/fetchGuillotine.ts

@@ -1,76 +0,0 @@
-import type {FetchOptions, GuillotineResult, LocaleMapping} from '../types';
-import gqlmin from 'gqlmin';
-
-import {fetchFromApi} from './fetchFromApi';
-
-const XP_ERROR_PATTERN = '/_/error/';
-
-/** Guillotine-specialized fetch, using the generic fetch above */
-export async function fetchGuillotine<Data = Record<string, unknown>>(
-    contentApiUrl: string,
-    mapping: LocaleMapping,
-    options?: FetchOptions
-): Promise<GuillotineResult> {
-    const body = options?.body;
-    const path = body?.variables?.path;
-
-    if (typeof body.query !== 'string' || !body.query.trim()) {
-        return {
-            error: {
-                code: '400',
-                message: `Invalid or missing query. JSON.stringify(query) = ${JSON.stringify(body.query)}`
-            }
-        };
-    } else {
-        // special case for not sending XP generated error paths to guillotine
-        const pathArr = path?.split(XP_ERROR_PATTERN);
-        if (pathArr?.length === 2) {
-            return {
-                error: {
-                    code: pathArr[1],
-                    message: `XP error URL detected`
-                }
-            }
-        } else {
-            // Minify the query to avoid hitting 200k space limit
-            body.query = gqlmin(body.query);
-        }
-    }
-
-    const pathMessage = path ? JSON.stringify(path) : '';
-    return await fetchFromApi<Data>(
-        contentApiUrl,
-        mapping,
-        options
-    )
-        .then(json => {
-            let errors: any[] = json.errors; // fetchFromApi ensures json is an object
-
-            if (errors) {
-                if (!Array.isArray(errors)) {
-                    errors = [errors];
-                }
-                console.error(`${errors.length} error(s) when fetching data from: ${contentApiUrl}`);
-                errors.forEach(error => {
-                    console.error(error);
-                });
-
-                return {
-                    error: {
-                        code: '500',
-                        message: `Server responded with ${errors.length} error(s), probably from guillotine - see log.`
-                    }
-                };
-            }
-
-            return json.data;
-        })
-        .catch((err) => {
-            console.warn(`Client-side error when trying to fetch data ${pathMessage}`, err);
-            try {
-                return {error: JSON.parse(err.message)};
-            } catch (e2) {
-                return {error: {code: 'Client-side error', message: err.message}};
-            }
-        });
-}

package/src/guillotine/fetchMetaData.ts

@@ -1,31 +0,0 @@
-import type {ContentApiBaseBody, MetaResult, LocaleMapping, GuillotineRequestHeaders} from '../types';
-
-
-import {getMetaQuery, pageFragmentQuery} from './getMetaData';
-import {fetchGuillotine} from './fetchGuillotine';
-
-
-export const fetchMetaData = async (
-    contentApiUrl: string,
-    xpContentPath: string,
-    mapping: LocaleMapping,
-    headers?: GuillotineRequestHeaders
-): Promise<MetaResult> => {
-    const body: ContentApiBaseBody = {
-        query: getMetaQuery(pageFragmentQuery()),
-        variables: {
-            path: xpContentPath
-        }
-    };
-    const metaResult = await fetchGuillotine<MetaResult>(contentApiUrl, mapping, {
-        body,
-        headers
-    });
-    if (metaResult.error) {
-        return metaResult;
-    } else {
-        return {
-            meta: metaResult?.guillotine?.get
-        };
-    }
-};

package/src/guillotine/metadata/configQuery.ts

@@ -1,46 +0,0 @@
-import type {ComponentDefinition} from '../../types';
-
-
-import {sanitizeGraphqlName} from '../../utils/sanitizeGraphqlName';
-
-
-export const configQuery = (
-    list: [string, ComponentDefinition][],
-    includeAppName = true,
-    canUseConfigAsJson = true
-): string => {
-    const hasQueryList = list?.filter(([key, def]) => def.configQuery) || [];
-    if (hasQueryList.length === 0) {
-        return canUseConfigAsJson ? 'configAsJson' : '';
-    }
-
-    const configsByApp: Record<string,string[]> = {};
-    hasQueryList
-        .forEach((entry) => {
-            const nameParts = entry[0].split(':');
-            if (nameParts.length === 2) {
-                const sanitizedAppName = sanitizeGraphqlName(nameParts[0]);
-                let existingConfigs = configsByApp[sanitizedAppName];
-                if (!existingConfigs) {
-                    existingConfigs = [];
-                    configsByApp[sanitizedAppName] = existingConfigs;
-                }
-                existingConfigs.push(`${sanitizeGraphqlName(nameParts[1])}${entry[1].configQuery}`);
-            }
-        });
-
-    // Still query for configAsJson if at least one item has no configQuery defined
-    const configAsJsonQuery = canUseConfigAsJson && hasQueryList.length < list.length ? 'configAsJson' : '';
-
-    if (!includeAppName) {
-        return `${configAsJsonQuery}
-                config {
-                    ${Object.values(configsByApp).reduce((arr, curr) => arr.concat(curr), []).join('\n')}
-                }`;
-    } else {
-        return `${configAsJsonQuery}
-                config {
-                    ${Object.entries(configsByApp).map(entry => entry[0] + '{\n' + entry[1].join('\n') + '\n}')}
-                }`;
-    }
-};

package/src/guillotine/validateData.ts

@@ -1,11 +0,0 @@
-import type {FetchContentResult} from '../types';
-
-
-import {validateNotFound} from './validateNotFound';
-import {validateShortcut} from './validateShortcut';
-
-
-export function validateData(props: FetchContentResult): void {
-    validateNotFound(props);
-    validateShortcut(props);
-}

package/src/i18n/LocaleContext.tsx

@@ -1,59 +0,0 @@
-'use client';
-import type {Dict, LocaleContextType} from '../types';
-
-import React, {createContext, useContext, useEffect, useState} from 'react';
-import {getPhrase, loadPhrases} from './i18n';
-
-
-const LocaleContext = createContext<LocaleContextType>({
-    dictionary: {},
-    locale: '',
-    localize: (key: string, ...args: any[]) => key,
-    setLocale: (locale: string) => Promise.resolve({})
-});
-
-export const useLocaleContext = () => useContext(LocaleContext);
-
-export const LocaleContextProvider = ({
-    children,
-    locale: localeProps = ''
-}: {
-    children: any
-    locale?: string
-}) => {
-    const [currentLocale, setLocaleState] = useState(localeProps);
-    const [dictionary, setPhrasesState] = useState<Dict>({});
-    const [isLoaded, setLoadedState] = useState(false);
-
-    const setLocale = async (locale: string): Promise<Dict> => {
-        setLocaleState(locale);
-        setLoadedState(false);
-
-        return loadPhrases(locale).then((phrases) => {
-            setPhrasesState(phrases);
-            setLoadedState(true);
-            return phrases;
-        });
-    };
-
-    useEffect(() => {
-        if (localeProps) {
-            void setLocale(localeProps); // void to avoid @typescript-eslint/no-floating-promises
-        }
-    }, []);
-
-    const localize = (key: string, ...args: any[]) => {
-        return isLoaded ? getPhrase(currentLocale, dictionary, key, ...args) : key;
-    };
-
-    return (
-        <LocaleContext.Provider value={{
-            setLocale,
-            locale: currentLocale,
-            dictionary,
-            localize
-        }}>
-            {children}
-        </LocaleContext.Provider>
-    );
-};

package/src/i18n/i18n.ts

@@ -1,57 +0,0 @@
-import type {Dict} from '../types';
-
-
-export class I18n {
-    private static locale = '';
-    private static dictionary: Dict = {};
-    private static isLoaded = false;
-
-    public static async setLocale(locale: string): Promise<Dict> {
-        this.locale = locale;
-        this.isLoaded = false;
-
-        return loadPhrases(locale).then((phrases) => {
-            this.dictionary = phrases;
-            this.isLoaded = true;
-            return phrases;
-        });
-    }
-
-    public static localize(key: string, ...args: any[]): string {
-        return this.isLoaded ? getPhrase(this.locale, this.dictionary, key, ...args) : key;
-    }
-
-    public static getLocale() {
-        return this.locale;
-    }
-
-    public static getDictionary() {
-        return this.dictionary;
-    }
-}
-
-export const loadPhrases = async (locale: string): Promise<Dict> => {
-    return import(`@phrases/${locale}.json`)
-        .then((module) => module.default)
-        .catch((e) => {
-            console.error(`Failed to load phrases for locale "${locale}"`, e);
-            return {};
-        });
-};
-
-export const getPhrase = (locale: string, dict: Dict, key: string, ...args: any[]) => {
-    const template = dict[key];
-    if (!template) {
-        console.warn(`Missing localization phrase for locale "${locale}": <${key}>`);
-        return `<${key}>`;
-    }
-    if (args.length) {
-        let index = -1;
-        return template.replace(/{(\d+)?}/g, (match, digit) => {
-            index++;
-            return args[digit || index] ?? match;
-        });
-    }
-    return template;
-};
-

package/src/index.ts

@@ -1,42 +0,0 @@
-export {
-    APP_NAME,
-    APP_NAME_DASHED,
-    APP_NAME_UNDERSCORED,
-    IS_DEV_MODE
-} from './common/env';
-
-export type * from './types';
-
-export {ComponentRegistry} from './common/ComponentRegistry';
-
-export {
-    CATCH_ALL,
-    JSESSIONID_HEADER,
-    PORTAL_COMPONENT_ATTRIBUTE,
-    PORTAL_REGION_ATTRIBUTE,
-    PROJECT_ID_HEADER,
-    RENDER_MODE,
-    RENDER_MODE_HEADER,
-    XP_BASE_URL_HEADER,
-    XP_COMPONENT_TYPE,
-    XP_REQUEST_TYPE
-} from './common/constants';
-
-
-export {richTextQuery} from './guillotine/metadata/richTextQuery';
-export {validateData} from './guillotine/validateData';
-
-export {I18n} from './i18n/i18n';
-
-export {getContentApiUrl} from './utils/getContentApiUrl';
-export {getLocaleMapping} from './utils/getLocaleMapping';
-export {getLocaleMappingByProjectId} from './utils/getLocaleMappingByProjectId';
-export {getLocaleMappingByLocale} from './utils/getLocaleMappingByLocale';
-export {getRequestLocaleInfo} from './utils/getRequestLocaleInfo';
-export {sanitizeGraphqlName} from './utils/sanitizeGraphqlName';
-
-export {
-    UrlProcessor,
-    getAsset,
-    getUrl
-} from './common/UrlProcessor';

package/src/server/getServerRenderedHtml.ts

@@ -1,3 +0,0 @@
-export function getServerRenderedHtml(component: React.ReactNode): string {
-    return require('react-dom/server').renderToString(component);
-}

package/src/server.ts

@@ -1,5 +0,0 @@
-export {fetchContent} from './guillotine/fetchContent';
-export {fetchContentPathsForAllLocales} from './guillotine/fetchContentPathsForAllLocales';
-export {fetchContentPathsForLocale} from './guillotine/fetchContentPathsForLocale';
-export {fetchFromApi} from './guillotine/fetchFromApi';
-export {fetchGuillotine} from './guillotine/fetchGuillotine';

package/src/types/componentProps.ts

@@ -1,143 +0,0 @@
-import {DOMNode} from 'html-react-parser';
-import type {RENDER_MODE, XP_REQUEST_TYPE} from '../common/constants';
-import type {
-    FragmentData,
-    LayoutData,
-    MacroConfig,
-    MacroData,
-    PageComponent,
-    PageData,
-    PartData,
-    RichTextData,
-    RegionTree
-} from './component';
-import type {ReactNode} from 'react';
-
-
-export interface BaseComponentProps {
-    component: PageComponent;
-    meta: MetaData;
-    common?: any;                  // Content is passed down for optional consumption in componentviews.
-    // TODO: Use a react contextprovider instead of "manually" passing everything down
-}
-
-export interface BaseLayoutProps {
-    component?: LayoutData;
-    path: string;
-    regions?: RegionTree;
-    common?: any;
-    meta: MetaData;
-}
-
-export interface BaseMacroProps {
-    children: ReactNode;
-    data: Omit<MacroData, 'ref'>;
-    meta: MetaData;
-    renderInEditMode?: boolean;
-}
-
-export interface BasePageProps {
-    component?: PageData;
-    path?: string;
-    common?: any;
-    data?: any;
-    error?: string;
-    meta: MetaData;
-}
-
-export interface BasePartProps {
-    component?: PartData;
-    path: string;
-    common?: any;
-    data?: any;
-    error?: string;
-    meta: MetaData;
-}
-
-export interface FragmentProps {
-    page?: PageData;
-    component?: FragmentData;
-    common?: any;
-    meta: MetaData;
-}
-
-export interface LayoutProps {
-    layout: LayoutData;
-    path: string;
-    common: any;
-    meta: MetaData;
-}
-
-export interface MacroProps {
-    name: string;
-    children: string | React.ReactNode;
-    config: MacroConfig;
-    meta: MetaData;
-}
-
-export interface MetaData {
-    id: string,
-    type: string,
-    path: string,
-    requestType: XP_REQUEST_TYPE,
-    renderMode: RENDER_MODE,
-    requestedComponent?: PageComponent,
-    canRender: boolean,
-    catchAll: boolean,
-    apiUrl: string,
-    baseUrl: string,
-    locale: string,
-    defaultLocale: string
-}
-
-export interface PageProps {
-    page: PageData;
-    path: string;
-    data?: any;
-    common?: any; // Content is passed down to componentviews. TODO: Use a react contextprovider instead?
-    meta: MetaData;
-}
-
-export interface PartProps {
-    part: PartData
-    path: string
-    data?: any
-    // Content is passed down to componentviews. TODO: Use a react contextprovider instead?
-    common?: any
-    meta: MetaData
-}
-
-export interface RegionProps {
-    name: string
-    components?: PageComponent[]
-    className?: string
-    // Content is passed down for optional consumption in componentviews. TODO: Use a react contextprovider instead?
-    common?: any
-    meta: MetaData
-}
-
-export interface RegionsProps {
-    page: PageData | null;
-    name?: string;
-    // Content is passed down for optional consumption in componentviews. TODO: Use a react contextprovider instead?
-    common?: any;
-    meta: MetaData;
-}
-
-export type Replacer = (
-    domNode: DOMNode,
-    data: RichTextData,
-    meta: MetaData,
-    renderMacroInEditMode: boolean
-) => ReplacerResult;
-
-export type ReplacerResult = JSX.Element | DOMNode;
-
-export interface RichTextViewProps {
-    data: RichTextData
-    meta: MetaData
-    className?: string
-    tag?: string
-    renderMacroInEditMode?: boolean
-    customReplacer?: Replacer
-}