@enonic/nextjs-adapter 2.0.1 → 2.0.2

package/guillotine/getMetaData.d.ts

@@ -0,0 +1,94 @@
+import { RENDER_MODE, XP_COMPONENT_TYPE, XP_REQUEST_TYPE } from '../utils';
+export declare const richTextQuery: (fieldName: string) => string;
+export declare const pageFragmentQuery: () => string;
+export declare function getMetaQuery(pageFragment?: string): string;
+export interface PageComponent {
+    [key: string]: any;
+    type: XP_COMPONENT_TYPE;
+    path: string;
+    page?: PageData;
+    part?: PartData;
+    layout?: LayoutData;
+    fragment?: FragmentData;
+    text?: TextData;
+    image?: any;
+    regions?: RegionTree;
+    data?: any;
+    error?: any;
+}
+export interface TextData {
+    value: RichTextData;
+}
+export interface RichTextData {
+    processedHtml: string;
+    links: LinkData[];
+    macros: MacroData[];
+    images: ImageData[];
+}
+export interface LinkData {
+    ref: string;
+    media: {
+        content: {
+            id: string;
+        };
+    } | null;
+}
+export interface MacroData {
+    ref: string;
+    name: string;
+    descriptor: string;
+    config: {
+        [name: string]: MacroConfig;
+    };
+}
+export interface ImageData {
+    ref: string;
+    image: {
+        id: string;
+    } | null;
+}
+export interface MacroConfig {
+    [key: string]: any;
+}
+export interface RegionTree {
+    [key: string]: PageRegion;
+}
+export interface PageRegion {
+    name: string;
+    components: PageComponent[];
+}
+export interface PartData {
+    descriptor: string;
+    config: any;
+    [customKeysFromQuery: string]: any;
+}
+export interface LayoutData {
+    descriptor: string;
+    config?: any;
+    [customKeysFromQuery: string]: any;
+}
+export interface PageData {
+    descriptor: string;
+    config?: any;
+    template?: string | null;
+    regions?: RegionTree;
+}
+export interface FragmentData {
+    id: string;
+    fragment: {
+        components: PageComponent[];
+    };
+}
+export interface MetaData {
+    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;
+}

package/guillotine/getMetaData.js

@@ -0,0 +1,128 @@
+import { sanitizeGraphqlName } from '../utils';
+import { ComponentRegistry } from '../ComponentRegistry';
+const macroConfigQuery = () => {
+    return configQuery(ComponentRegistry.getMacros(), false, false);
+};
+const partConfigQuery = () => {
+    return configQuery(ComponentRegistry.getParts());
+};
+const layoutConfigQuery = () => {
+    return configQuery(ComponentRegistry.getLayouts());
+};
+const pageConfigQuery = () => {
+    return configQuery(ComponentRegistry.getPages());
+};
+const configQuery = (list, includeAppName = true, canUseConfigAsJson = true) => {
+    const hasQueryList = (list === null || list === void 0 ? void 0 : list.filter(([key, def]) => def.configQuery)) || [];
+    if (hasQueryList.length === 0) {
+        return canUseConfigAsJson ? 'configAsJson' : '';
+    }
+    const configsByApp = {};
+    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}')}
+                }`;
+    }
+};
+/*
+    IMPORTANT: make sure to transform your queries into functions too when using this function inside them !!!
+ */
+export const richTextQuery = (fieldName) => {
+    return `${fieldName}(processHtml:{type:absolute, imageWidths:[400, 800, 1200], imageSizes:"(max-width: 400px) 400px, (max-width: 800px) 800px, 1200px"}) {
+                processedHtml
+                macros {
+                    ref
+                    name
+                    descriptor
+                    ${macroConfigQuery()}
+                }
+                links {
+                    ref
+                    media {
+                        content {
+                            _id
+                        }
+                    }
+                }
+                images {
+                    ref
+                    image {
+                        _id
+                    }
+                }
+            }`;
+};
+const componentsQuery = () => `
+        type
+        path
+        page {
+          descriptor
+          ${pageConfigQuery()}
+          template {
+            _path
+          }
+        }
+        layout {
+          descriptor
+          ${layoutConfigQuery()}
+        }
+        text {
+            ${richTextQuery('value')}
+        }
+        part {
+          descriptor
+          ${partConfigQuery()}
+        }
+        image {
+          caption
+          image {
+            imageUrl (type:absolute, scale: "width-768")
+          }
+        }
+`;
+// THIS QUERY DOES NOT SUPPORT NESTED FRAGMENTS
+export const pageFragmentQuery = () => `
+      components(resolveFragment: false, resolveTemplate: true) {
+        fragment {
+          id
+          fragment {
+            components {
+              ${componentsQuery()}
+            }
+          }
+        }
+        ${componentsQuery()}
+      }`;
+export function getMetaQuery(pageFragment) {
+    return `query($path:ID!){
+              guillotine {
+                get(key:$path) {
+                  _path
+                  type
+                  ${pageFragment || ''}
+                }
+              }
+            }`;
+}

package/{src/index.ts → index.d.ts}

@@ -2,4 +2,4 @@ export * from './utils';
 export * from './guillotine/fetchContent';
 export * from './guillotine/getMetaData';
 export * from './ComponentRegistry';
-export * from './UrlProcessor';
+export * from './UrlProcessor';

package/index.js

@@ -0,0 +1,5 @@
+export * from './utils';
+export * from './guillotine/fetchContent';
+export * from './guillotine/getMetaData';
+export * from './ComponentRegistry';
+export * from './UrlProcessor';

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@enonic/nextjs-adapter",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "license": "Apache-2.0",
   "main": "index.js",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "copy": "npx --yes cpy-cli package.json README.md dist",
+    "copy": "npx --yes cpy-cli package.json README.md setversion.js dist",
     "build": "tsc --build src/tsconfig.json && tsc --build server/tsconfig.json",
     "lint": "eslint --quiet server && eslint --quiet src",
     "lint:fix": "eslint --fix server && eslint --fix src",

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/server/ClearableFileCache.d.ts

@@ -0,0 +1,31 @@
+import { CacheHandler, CacheHandlerContext, CacheHandlerValue } from 'next/dist/server/lib/incremental-cache';
+import { CacheFs } from 'next/dist/shared/lib/utils';
+type FileSystemCacheContext = Omit<CacheHandlerContext, 'fs' | 'serverDistDir'> & {
+    fs: CacheFs;
+    serverDistDir: string;
+};
+export default class FileSystemCache implements CacheHandler {
+    private fs;
+    private flushToDisk?;
+    private serverDistDir;
+    private appDir;
+    private tagsManifestPath?;
+    private revalidatedTags;
+    constructor(ctx: FileSystemCacheContext);
+    clear(): void;
+    delete(path: string): boolean | undefined;
+    private loadTagsManifest;
+    setTags(key: string, tags: string[]): Promise<void>;
+    revalidateTag(tag: string): Promise<void>;
+    get(key: string, fetchCache?: boolean): Promise<CacheHandlerValue | null>;
+    set(key: string, data: CacheHandlerValue['value']): Promise<void>;
+    getFsPath({ pathname, appDir, fetchCache, }: {
+        pathname: string;
+        appDir?: boolean;
+        fetchCache?: boolean;
+    }): Promise<{
+        filePath: string;
+        isAppPath: boolean;
+    }>;
+}
+export {};