@enonic/nextjs-adapter 3.0.0-B3 → 3.0.0-B4

package/src/types/guillotine.ts

@@ -0,0 +1,426 @@
+import type {PublishInfo} from '@enonic-types/core';
+import type {PageComponent, PageData} from './component';
+import type {MetaData} from './componentProps';
+import type {Context} from './next';
+import type {RecursivePartial} from './util';
+
+
+export interface GuillotineError {
+    errorType: string
+    locations: {
+        line: number
+        column: number
+    }[]
+    message: string
+    validationErrorType?: string
+}
+
+// A specific observed error
+// export interface GuillotineValidationError extends GuillotineError {
+//     errorType: 'ValidationError'
+//     validationErrorType: string // 'FieldUndefined'
+// }
+
+// export interface GuillotineErrorResponseJson {
+//     errors: GuillotineError[]
+// }
+
+// export interface GuillotineOkResponseJson<Data = Record<string,unknown>> {
+//     data: Data
+// }
+
+// export type GuillotineResponseJson<Data> = GuillotineOkResponseJson<Data> | GuillotineErrorResponseJson;
+
+export interface GuillotineResponseJson<Guillotine = RecursivePartial<HeadlessCms>> {
+    // NOTE: guillotine is the actual field on the top Query, but can be used multiple times via aliases
+    data?: Record<string, Guillotine>
+    errors?: GuillotineError[]
+}
+
+export interface GuillotineResponse<Data = Record<string,unknown>> {
+    json: () => Promise<GuillotineResponseJson<Data>>
+    text: () => Promise<string>
+    ok: boolean
+    status: number
+}
+
+/**
+ * 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 = (context: Context) => Promise<FetchContentResult>;
+
+export interface ContentResult<Content = Record<string, unknown>> extends Result {
+    contents?: Content[]
+}
+
+export interface FetchContentResult extends Result {
+    data: Record<string, any> | null
+    common: Record<string, any> | null
+    meta: MetaData
+    page: PageComponent | null
+}
+
+// Seems like NodeJS.fetch lowercases all headers, so we need to lowercase the
+// header names here.
+export interface GuillotineRequestHeaders {
+    Cookie?: string
+    locale: string
+    locales: string
+    'default-locale': string
+}
+
+export type GuillotineResult = Result & Record<string, any>;
+
+export interface MetaResult extends Result {
+    meta?: {
+        _path: string
+        type: string
+        pageAsJson?: PageData
+        components?: PageComponent[]
+    }
+}
+
+export interface Result {
+    error?: {
+        code: string
+        message: string
+    } | null
+}
+
+// Types from Query Playground Docs:
+
+interface AccessControlEntry {
+    principal: PrincipalKey
+    allow: [Permission]
+    deny: [Permission]
+}
+
+interface Attachment {
+    name: string
+    label: string
+    size: number
+    mimeType: string
+    attachmentUrl: string
+}
+
+type DateTime = string;
+
+export interface Component {
+    type: ComponentType
+    path: string
+    page?: PageComponentData | null
+    layout?: LayoutComponentData | null
+    image?: ImageComponentData | null
+    part?: PartComponentData | null
+    text?: TextComponentData | null
+    fragment?: FragmentComponentData | null
+}
+
+type ComponentType = 'page' | 'layout' | 'image' | 'part' | 'text' | 'fragment';
+
+interface Content {
+    _id: string // !
+    _name: string // !
+    _path: string // !
+    _references?: Content[]
+    _score?: number
+    creator?: PrincipalKey
+    modifier?: PrincipalKey
+    createdTime?: DateTime
+    modifiedTime?: DateTime
+    owner?: PrincipalKey
+    type?: string
+    contentType?: ContentType
+    displayName?: string
+    hasChildren?: boolean
+    language?: string
+    valid?: boolean
+    dataAsJson?: JSON
+    x?: ExtraData
+    xAsJson?: JSON
+    pageAsJson?: JSON
+    pageTemplate?: Content
+    components?: Component[]
+    attachments?: Attachment[]
+    publish?: PublishInfo
+    pageUrl?: string
+    site?: portal_Site
+    parent?: Content
+    children?: Content[]
+    childrenConnection?: ContentConnection
+    permissions?: Permissions
+}
+
+interface ContentConnection {
+    totalCount: Int
+    edges: ContentEdge[]
+    pageInfo: PageInfo
+}
+
+interface ContentEdge {
+    node: Content
+    cursor: string
+}
+
+interface ContentType {
+    name: string
+    displayName: string
+    description: string
+    superType: string
+    abstract: boolean
+    final: boolean
+    allowChildContent: boolean
+    contentDisplayNameScript: string
+    icon: Icon
+    form: FormItem[]
+    formAsJson: JSON
+    getInstances: Content[]
+    getInstanceConnection: ContentConnection
+}
+
+type ExtraData<App = Record<string,unknown>> = App & {
+    media: XData_media_ApplicationConfig
+    base: XData_base_ApplicationConfig
+};
+
+type Float = number;
+
+interface FormItem {
+    formItemType: FormItemType
+    name: string
+    label: string
+}
+
+type FormItemType = 'ItemSet' | 'Layout' | 'Input' | 'OptionSet';
+
+interface FragmentComponentData {
+    id: string
+    fragment: Content
+}
+
+interface GeoPoint {
+    value: string
+    latitude: Float
+    longitude: Float
+}
+
+export interface HeadlessCms {
+    get?: Content
+    getChildren?: Content[]
+    getChildrenConnection?: ContentConnection
+    getPermissions?: Permissions
+    getSite?: portal_Site
+    getType?: ContentType
+    getTypes?: ContentType[]
+    query?: Content[]
+    queryConnection?: QueryContentConnection
+    queryDsl?: Content[]
+    queryDslConnection?: QueryDSLContentConnection
+}
+
+interface Icon {
+    mimeType: string
+    modifiedTime: string
+}
+
+interface Image {
+    image: Content
+    ref: string
+    style: ImageStyle
+}
+
+interface ImageComponentData {
+    id: string
+    caption?: string
+    image: media_Image
+}
+
+interface ImageStyle {
+    name: string
+    aspectRatio: string
+    filter: string
+}
+
+type Int = number;
+
+type JSON = Record<string, unknown>;
+
+interface LayoutComponentData {
+    descriptor: string
+    configAsJson: JSON | null
+}
+
+interface Link {
+    ref: string
+    uri: string
+    media: Media
+    content: Content
+}
+
+type LocalDateTime = string;
+
+interface Macro_system_disable_DataConfig {
+    body: string
+}
+
+interface Macro_system_embed_DataConfig {
+    body: string
+}
+
+interface Macro {
+    ref: string
+    name: string
+    descriptor: string
+    config: MacroConfig
+}
+
+interface MacroConfig {
+    disable: Macro_system_disable_DataConfig
+    embed: Macro_system_embed_DataConfig
+}
+
+interface Media {
+    content: Content
+    intent: MediaIntentType
+}
+
+type MediaIntentType = 'download' | 'inline';
+
+interface media_Image extends Content {
+    mediaUrl: string
+    imageUrl: string
+    data: media_Image_Data
+}
+
+interface media_Image_Data {
+    media: MediaUploader
+    caption: string
+    altText: string
+    artist: string[]
+    copyright: string
+    tags: string[]
+}
+
+interface MediaFocalPoint {
+    x: number
+    y: number
+}
+
+interface MediaUploader {
+    attachment: string
+    focalPoint: MediaFocalPoint
+}
+
+interface PageComponentData {
+    descriptor?: string
+    customized?: boolean
+    configAsJson?: JSON
+    template?: Content | null
+}
+
+interface PageInfo {
+    startCursor: string // !
+    endCursor: string // !
+    hasNext: boolean // !
+}
+
+interface PartComponentData<Config = Record<string, unknown>> {
+    descriptor: string
+    config: Config
+    configAsJson: JSON
+}
+
+type Permission = 'READ' | 'CREATE' | 'MODIFY' | 'DELETE' | 'PUBLISH' | 'READ_PERMISSIONS' | 'WRITE_PERMISSIONS';
+
+interface Permissions {
+    inheritsPermissions: boolean
+    permissions: AccessControlEntry[]
+}
+
+interface portal_Site extends Content {
+    data: portal_Site_Data
+}
+
+interface portal_Site_Data {
+    description: string
+}
+
+type PrincipalType = 'user' | 'group' | 'role';
+
+interface PrincipalKey {
+    value: string
+    type: PrincipalType
+    idProvider: string
+    principalId: string
+}
+
+interface QueryContentConnection extends ContentConnection {
+    aggregationsAsJson: JSON
+}
+
+interface QueryDSLContentConnection extends QueryContentConnection {
+    highlightAsJson: JSON
+}
+
+interface RichText {
+    raw: string
+    processedHtml: string
+    macrosAsJson: JSON
+    macros: Macro[]
+    images: Image[]
+    links: Link[]
+}
+
+interface TextComponentData {
+    value: RichText
+}
+
+interface XData_base_ApplicationConfig {
+    gpsInfo: XData_base_gpsInfo_DataConfig
+}
+
+interface XData_base_gpsInfo_DataConfig {
+    geoPoint: GeoPoint
+    altitude: String
+    direction: String
+}
+
+interface XData_media_ApplicationConfig {
+    imageInfo: XData_media_imageInfo_DataConfig
+    cameraInfo: XData_media_cameraInfo_DataConfig
+}
+
+interface XData_media_imageInfo_DataConfig {
+    pixelSize: number
+    imageHeight: number
+    imageWidth: number
+    contentType: string
+    description: string
+    byteSize: number
+    colorSpace: string[]
+    fileSource: string
+}
+
+interface XData_media_cameraInfo_DataConfig {
+    date: LocalDateTime
+    make: string
+    model: string
+    lens: string
+    iso: string
+    focalLength: string
+    focalLength35: string
+    exposureBias: string
+    aperture: string[]
+    shutterTime: string
+    flash: string
+    autoFlashCompensation: string
+    whiteBalance: string
+    exposureProgram: string
+    shootingMode: string
+    meteringMode: string
+    exposureMode: string
+    focusDistance: string
+    orientation: string
+}

package/src/types/i18n.ts

@@ -0,0 +1,8 @@
+export type Dict = Record<string, string>;
+
+export interface LocaleContextType {
+    dictionary: Dict
+    locale: string
+    localize: (key: string, ...args: any[]) => string
+    setLocale: (locale: string) => Promise<Dict>
+}

package/src/types/index.ts

@@ -0,0 +1,58 @@
+/// <reference types="react" />
+
+export type * from './component';
+export type * from './componentProps';
+export type * from './guillotine';
+export type * from './i18n';
+export type * from './next';
+export type * from './util';
+
+
+// Shape of content base-data API body
+export interface ContentApiBaseBody {
+    query?: string,                 // Override the default base-data query
+    variables?: {                   // GraphQL variables inserted into the query
+        path?: string,              // Full content item _path
+        [key: string]: string | number | undefined,
+    }
+}
+
+export interface ContentPathItem {
+    contentPath: string[]
+    locale: string,
+}
+
+export interface PathFragment {
+    index: number
+    region: string
+}
+
+export interface PreviewParams {
+    contentPath: string[]
+    headers: Record<string, string>
+    params: Record<string, string>
+}
+
+export interface ProjectLocaleConfig {
+    default: boolean
+    project: string
+    site: string
+    locale: string
+}
+
+export type ProjectLocalesConfig = Record<string, ProjectLocaleConfig>;
+
+export type SelectorName = 'contentType' | 'page' | 'component' | 'part' | 'layout' | 'macro';
+
+export interface ServerSideParams
+    extends NodeJS.Dict<string | string[]> {
+    // String array catching a sub-path assumed to match the site-relative path of an XP content.
+    contentPath?: string[];
+    mode?: string;
+}
+
+export interface StaticContentProps extends Record<string, any> {
+    children?: React.ReactNode;
+    element?: string;
+    condition: boolean;
+}

package/src/types/next.ts

@@ -0,0 +1,7 @@
+import type {ReadonlyHeaders} from 'next/dist/server/web/spec-extension/adapters/headers';
+
+export interface Context {
+    headers?: ReadonlyHeaders | Headers
+    locale?: string
+    contentPath: string | string[]
+}

package/src/types/util.ts

@@ -0,0 +1,5 @@
+export type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+};
+
+// export type PartialExcept<T, K extends keyof T> = RecursivePartial<T> & Pick<T, K>;

package/src/utils/addLineNumbers.ts

@@ -0,0 +1,3 @@
+export function addLineNumbers(s: string) {
+    return s.split('\n').map((line, i) => `${i + 1}: ${line}`).join('\n');
+}

package/src/utils/buildGuillotineRequestHeaders.ts

@@ -0,0 +1,32 @@
+import type {Context, GuillotineRequestHeaders} from '../types';
+
+
+import {
+    GUILLOTINE_REQUEST_HEADERS,
+    JSESSIONID_HEADER,
+} from '../common/constants';
+
+
+export function buildGuillotineRequestHeaders({
+    context,
+    defaultLocale,
+    locale,
+    locales,
+}: {
+    context: Context
+    defaultLocale: string
+    locale: string
+    locales: string[]
+}): GuillotineRequestHeaders {
+    const guillotineRequestHeaders: GuillotineRequestHeaders = {
+        [GUILLOTINE_REQUEST_HEADERS.DEFAULT_LOCALE]: defaultLocale,
+        [GUILLOTINE_REQUEST_HEADERS.LOCALE]: locale,
+        [GUILLOTINE_REQUEST_HEADERS.LOCALES]: JSON.stringify(locales),
+    };
+    const jsessionid = context.headers?.get(JSESSIONID_HEADER);
+    if (jsessionid) {
+        guillotineRequestHeaders[GUILLOTINE_REQUEST_HEADERS.COOKIE] =
+            `${JSESSIONID_HEADER}=${jsessionid}`;
+    }
+    return guillotineRequestHeaders;
+}

package/src/utils/commonChars.ts

@@ -0,0 +1,16 @@
+export const commonChars = (s1?: string, s2?: string) => {
+    let result = '';
+    if (!s1 || s1.length === 0 || !s2 || s2.length === 0) {
+        return result;
+    }
+    for (let i = 0; i < s1.length; i++) {
+        const s1Element = s1[i];
+        if (s2[i] === s1Element) {
+            result += s1Element;
+        } else {
+            break;
+        }
+    }
+
+    return result;
+};

package/src/utils/fixDoubleSlashes.ts

@@ -0,0 +1,3 @@
+export function fixDoubleSlashes(str: string) {
+    return str.replace(/(^|[^:/])\/{2,}/g, '$1/');
+}

package/src/utils/getContentApiUrl.ts

@@ -0,0 +1,20 @@
+import type {Context} from '../types';
+
+
+import {RENDER_MODE} from '../common/constants';
+import {API_URL} from '../common/env';
+import {getProjectLocaleConfig} from './getProjectLocaleConfig';
+import {fixDoubleSlashes} from './fixDoubleSlashes';
+import {getRenderMode} from './getRenderMode';
+
+
+export function getContentApiUrl(context: Context): string {
+    const project = getProjectLocaleConfig(context).project;
+    const branch = getRenderMode(context) === RENDER_MODE.NEXT
+        ? 'master'
+        : getRenderMode(context) === RENDER_MODE.LIVE
+            ? 'master'
+            : 'draft';
+
+    return fixDoubleSlashes(`${API_URL}/${project}/${branch}`);
+}

package/src/utils/getProjectLocaleConfig.ts

@@ -0,0 +1,24 @@
+import type {Context, ProjectLocaleConfig} from '../types';
+
+
+import {PROJECT_ID_HEADER} from '../common/constants';
+import {getProjectLocaleConfigById} from './getProjectLocaleConfigById';
+import {getProjectLocaleConfigByLocale} from './getProjectLocaleConfigByLocale';
+
+
+export function getProjectLocaleConfig(context: Context): ProjectLocaleConfig {
+    const projectId = context.headers?.get(PROJECT_ID_HEADER);
+
+    let config: ProjectLocaleConfig;
+    if (projectId) {
+        // first use project id header
+        config = getProjectLocaleConfigById(projectId, false);
+    }
+    if (!config) {
+        // next try to use locale from url
+        // it will fall back to default locale if not found
+        config = getProjectLocaleConfigByLocale(context.locale);
+    }
+
+    return config;
+}

package/src/utils/getProjectLocaleConfigById.ts

@@ -0,0 +1,21 @@
+import type {ProjectLocaleConfig} from '../types';
+
+
+import {getProjectLocaleConfigs} from './getProjectLocaleConfigs';
+
+
+export function getProjectLocaleConfigById(projectId?: string, useDefault = true): ProjectLocaleConfig {
+    const configs = getProjectLocaleConfigs();
+
+    let config: ProjectLocaleConfig;
+    if (projectId) {
+        config = Object.values(configs).find(p => {
+            return p?.project?.toLowerCase() === projectId.toLowerCase();
+        });
+    }
+    if (!config && useDefault) {
+        config = Object.values(configs).find(c => c.default);
+    }
+
+    return config;
+}

package/src/utils/getProjectLocaleConfigByLocale.ts

@@ -0,0 +1,19 @@
+import type {ProjectLocaleConfig} from '../types';
+
+
+import {getProjectLocaleConfigs} from './getProjectLocaleConfigs';
+
+
+export function getProjectLocaleConfigByLocale(locale?: string, useDefault = true): ProjectLocaleConfig {
+    const configs = getProjectLocaleConfigs();
+
+    let config: ProjectLocaleConfig;
+    if (locale) {
+        config = configs[locale];
+    }
+    if (!config && useDefault) {
+        config = Object.values(configs).find(c => c.default);
+    }
+
+    return config;
+}

package/src/utils/getProjectLocaleConfigs.ts

@@ -0,0 +1,36 @@
+import type {ProjectLocalesConfig} from '../types';
+
+
+import {ENV_VARS} from '../common/constants';
+import {PROJECTS} from '../common/env';
+
+
+// NOTE: Dissallowing slash and any whitespace in 2nd capture group.
+const PROJECT_CONFIG_REGEXP = /^([\w-]+):([^/\s]+)(\/[\w.-]+)?$/i;
+
+
+export function getProjectLocaleConfigs(): ProjectLocalesConfig {
+    const str = PROJECTS;
+    if (!str?.length) {
+        throw new Error(`Did you forget to define "${ENV_VARS.PROJECTS}" environmental variable?
+        Format: <default-language>:<default-repository-name>/<default-site-path>,<language>:<repository-name>/<site-path>,...`);
+    }
+    return str.split(',').reduce((config, prjStr, index: number) => {
+        const trimmedprjStr = prjStr.trim();
+        if (!trimmedprjStr.length) {
+            return config;
+        }
+        const matches: RegExpExecArray = PROJECT_CONFIG_REGEXP.exec(trimmedprjStr);
+        if (!matches?.length) {
+            throw new Error(`Project "${prjStr}" doesn't match format: <default-language>:<default-repository-name>/<default-site-path>,<language>:<repository-name>/<site-path>`);
+        }
+        const [_full, lang, project, site] = matches;
+        config[lang] = {
+            default: index === 0,
+            project,
+            site,
+            locale: lang,
+        };
+        return config;
+    }, {});
+}

package/src/utils/getProjectLocales.ts

@@ -0,0 +1,6 @@
+import {getProjectLocaleConfigs} from './getProjectLocaleConfigs';
+
+
+export function getProjectLocales(): string[] {
+    return Object.keys(getProjectLocaleConfigs());
+}