@enonic/nextjs-adapter 2.0.0-B3 → 2.0.1

package/server/ClearableFileCache.ts

@@ -0,0 +1,410 @@
+import path from 'path';
+import {LRUCache} from 'lru-cache';
+import {CacheHandler, CacheHandlerContext, CacheHandlerValue} from 'next/dist/server/lib/incremental-cache';
+import {CacheFs} from 'next/dist/shared/lib/utils';
+import {CachedFetchValue, IncrementalCacheValue} from 'next/dist/server/response-cache';
+import type {OutgoingHttpHeaders} from 'http';
+import {getDerivedTags} from 'next/dist/server/lib/incremental-cache/utils';
+
+type FileSystemCacheContext = Omit<
+    CacheHandlerContext,
+    'fs' | 'serverDistDir'
+> & {
+    fs: CacheFs
+    serverDistDir: string
+};
+
+type TagsManifest = {
+    version: 1
+    items: { [tag: string]: { keys: string[]; revalidatedAt: number } }
+};
+let memoryCache: LRUCache<string, CacheHandlerValue> | undefined;
+let tagsManifest: TagsManifest | undefined;
+
+export default class FileSystemCache implements CacheHandler {
+    private fs: FileSystemCacheContext['fs'];
+    private flushToDisk?: FileSystemCacheContext['flushToDisk'];
+    private serverDistDir: FileSystemCacheContext['serverDistDir'];
+    private appDir: boolean;
+    private tagsManifestPath?: string;
+    private revalidatedTags: string[];
+
+    constructor(ctx: FileSystemCacheContext) {
+        this.fs = ctx.fs;
+        this.flushToDisk = ctx.flushToDisk;
+        this.serverDistDir = ctx.serverDistDir;
+        this.appDir = !!ctx._appDir;
+        this.revalidatedTags = ctx.revalidatedTags;
+
+        if (ctx.maxMemoryCacheSize && !memoryCache) {
+            memoryCache = new LRUCache({
+                max: ctx.maxMemoryCacheSize,
+                maxSize: 10 * ctx.maxMemoryCacheSize, // had to be used sizeCalculation function
+                sizeCalculation({value}: { value: IncrementalCacheValue | null }) {
+                    if (!value) {
+                        return 25;
+                    } else if (value.kind === 'REDIRECT') {
+                        return JSON.stringify(value.props).length;
+                    } else if (value.kind === 'IMAGE') {
+                        throw new Error('invariant image should not be incremental-cache');
+                    } else if (value.kind === 'FETCH') {
+                        return JSON.stringify(value.data || '').length;
+                    } else if (value.kind === 'ROUTE') {
+                        return value.body.length;
+                    }
+                    // rough estimate of size of cache value
+                    return (
+                        value.html.length + (JSON.stringify(value.pageData)?.length || 0)
+                    );
+                },
+            });
+        }
+        if (this.serverDistDir && this.fs) {
+            this.tagsManifestPath = path.join(
+                this.serverDistDir,
+                '..',
+                'cache',
+                'fetch-cache',
+                'tags-manifest.json',
+            );
+            this.loadTagsManifest();
+        }
+    }
+
+    public clear() {
+        memoryCache?.clear();
+    }
+
+    public delete(path: string) {
+        return memoryCache?.delete(path);
+    }
+
+    private loadTagsManifest() {
+        if (!this.tagsManifestPath || !this.fs || tagsManifest) return;
+        try {
+            tagsManifest = JSON.parse(
+                this.fs.readFileSync(this.tagsManifestPath).toString('utf8'),
+            );
+        } catch (err: any) {
+            tagsManifest = {version: 1, items: {}};
+        }
+    }
+
+    async setTags(key: string, tags: string[]) {
+        this.loadTagsManifest();
+        if (!tagsManifest || !this.tagsManifestPath) {
+            return;
+        }
+
+        for (const tag of tags) {
+            const data = tagsManifest.items[tag] || {keys: []};
+            if (!data.keys.includes(key)) {
+                data.keys.push(key);
+            }
+            tagsManifest.items[tag] = data;
+        }
+
+        try {
+            await this.fs.mkdir(path.dirname(this.tagsManifestPath));
+            await this.fs.writeFile(
+                this.tagsManifestPath,
+                JSON.stringify(tagsManifest || {}),
+            );
+        } catch (err: any) {
+            console.warn('Failed to update tags manifest.', err);
+        }
+    }
+
+    public async revalidateTag(tag: string) {
+        // we need to ensure the tagsManifest is refreshed
+        // since separate workers can be updating it at the same
+        // time and we can't flush out of sync data
+        this.loadTagsManifest();
+        if (!tagsManifest || !this.tagsManifestPath) {
+            return;
+        }
+
+        const data = tagsManifest.items[tag] || {keys: []};
+        data.revalidatedAt = Date.now();
+        tagsManifest.items[tag] = data;
+
+        try {
+            await this.fs.mkdir(path.dirname(this.tagsManifestPath));
+            await this.fs.writeFile(
+                this.tagsManifestPath,
+                JSON.stringify(tagsManifest || {}),
+            );
+        } catch (err: any) {
+            console.warn('Failed to update tags manifest.', err);
+        }
+    }
+
+    public async get(key: string, fetchCache?: boolean) {
+        let data = memoryCache?.get(key);
+
+        // let's check the disk for seed data
+        if (!data && process.env.NEXT_RUNTIME !== 'edge') {
+            try {
+                const {filePath} = await this.getFsPath({
+                    pathname: `${key}.body`,
+                    appDir: true,
+                });
+                const fileData = await this.fs.readFile(filePath);
+                const {mtime} = await this.fs.stat(filePath);
+
+                const meta = JSON.parse(
+                    (
+                        await this.fs.readFile(filePath.replace(/\.body$/, '.meta'))
+                    ).toString('utf8'),
+                );
+
+                const cacheEntry: CacheHandlerValue = {
+                    lastModified: mtime.getTime(),
+                    value: {
+                        kind: 'ROUTE',
+                        body: fileData,
+                        headers: meta.headers,
+                        status: meta.status,
+                    },
+                };
+                return cacheEntry;
+            } catch (_) {
+                // no .meta data for the related key
+            }
+
+            try {
+                const {filePath, isAppPath} = await this.getFsPath({
+                    pathname: fetchCache ? key : `${key}.html`,
+                    fetchCache,
+                });
+                const fileData = (await this.fs.readFile(filePath)).toString('utf-8');
+                const {mtime} = await this.fs.stat(filePath);
+
+                if (fetchCache) {
+                    const lastModified = mtime.getTime();
+                    const parsedData: CachedFetchValue = JSON.parse(fileData);
+                    data = {
+                        lastModified,
+                        value: parsedData,
+                    };
+                } else {
+                    const pageData = isAppPath
+                        ? (
+                            await this.fs.readFile(
+                                (
+                                    await this.getFsPath({
+                                        pathname: `${key}.rsc`,
+                                        appDir: true,
+                                    })
+                                ).filePath,
+                            )
+                        ).toString('utf8')
+                        : JSON.parse(
+                            (
+                                await this.fs.readFile(
+                                    (
+                                        await this.getFsPath({
+                                            pathname: `${key}.json`,
+                                            appDir: false,
+                                        })
+                                    ).filePath,
+                                )
+                            ).toString('utf8'),
+                        );
+
+                    let meta: { status?: number; headers?: OutgoingHttpHeaders } = {};
+
+                    if (isAppPath) {
+                        try {
+                            meta = JSON.parse(
+                                (
+                                    await this.fs.readFile(filePath.replace(/\.html$/, '.meta'))
+                                ).toString('utf-8'),
+                            );
+                        } catch (_) { /* empty */
+                        }
+                    }
+
+                    data = {
+                        lastModified: mtime.getTime(),
+                        value: {
+                            kind: 'PAGE',
+                            html: fileData,
+                            pageData,
+                            headers: meta.headers,
+                            status: meta.status,
+                        },
+                    };
+                }
+
+                if (data) {
+                    memoryCache?.set(key, data);
+                }
+            } catch (_) {
+                // unable to get data from disk
+            }
+        }
+        let cacheTags: undefined | string[];
+
+        if (data?.value?.kind === 'PAGE') {
+            const tagsHeader = data.value.headers?.['x-next-cache-tags'];
+
+            if (typeof tagsHeader === 'string') {
+                cacheTags = tagsHeader.split(',');
+            }
+        }
+
+        if (data?.value?.kind === 'PAGE' && cacheTags?.length) {
+            this.loadTagsManifest();
+            const derivedTags = getDerivedTags(cacheTags || []);
+
+            const isStale = derivedTags.some((tag) => {
+                return (
+                    tagsManifest?.items[tag]?.revalidatedAt &&
+                    tagsManifest?.items[tag].revalidatedAt >=
+                    (data?.lastModified || Date.now())
+                );
+            });
+
+            // we trigger a blocking validation if an ISR page
+            // had a tag revalidated, if we want to be a background
+            // revalidation instead we return data.lastModified = -1
+            if (isStale) {
+                data = undefined;
+            }
+        }
+
+        if (data && data?.value?.kind === 'FETCH') {
+            this.loadTagsManifest();
+            const innerData = data.value.data;
+            const derivedTags = getDerivedTags(innerData.tags || []);
+
+            const wasRevalidated = derivedTags.some((tag) => {
+                if (this.revalidatedTags.includes(tag)) {
+                    return true;
+                }
+
+                return (
+                    tagsManifest?.items[tag]?.revalidatedAt &&
+                    tagsManifest?.items[tag].revalidatedAt >=
+                    (data?.lastModified || Date.now())
+                );
+            });
+            // When revalidate tag is called we don't return
+            // stale data so it's updated right away
+            if (wasRevalidated) {
+                data = undefined;
+            }
+        }
+
+        return data || null;
+    }
+
+    public async set(key: string, data: CacheHandlerValue['value']) {
+        memoryCache?.set(key, {
+            value: data,
+            lastModified: Date.now(),
+        });
+        if (!this.flushToDisk) return;
+
+        if (data?.kind === 'ROUTE') {
+            const {filePath} = await this.getFsPath({
+                pathname: `${key}.body`,
+                appDir: true,
+            });
+            await this.fs.mkdir(path.dirname(filePath));
+            await this.fs.writeFile(filePath, data.body);
+            await this.fs.writeFile(
+                filePath.replace(/\.body$/, '.meta'),
+                JSON.stringify({headers: data.headers, status: data.status}),
+            );
+            return;
+        }
+
+        if (data?.kind === 'PAGE') {
+            const isAppPath = typeof data.pageData === 'string';
+            const {filePath: htmlPath} = await this.getFsPath({
+                pathname: `${key}.html`,
+                appDir: isAppPath,
+            });
+            await this.fs.mkdir(path.dirname(htmlPath));
+            await this.fs.writeFile(htmlPath, data.html);
+
+            await this.fs.writeFile(
+                (
+                    await this.getFsPath({
+                        pathname: `${key}.${isAppPath ? 'rsc' : 'json'}`,
+                        appDir: isAppPath,
+                    })
+                ).filePath,
+                isAppPath ? data.pageData : JSON.stringify(data.pageData),
+            );
+
+            if (data.headers || data.status) {
+                await this.fs.writeFile(
+                    htmlPath.replace(/\.html$/, '.meta'),
+                    JSON.stringify({
+                        headers: data.headers,
+                        status: data.status,
+                    }),
+                );
+            }
+        } else if (data?.kind === 'FETCH') {
+            const {filePath} = await this.getFsPath({
+                pathname: key,
+                fetchCache: true,
+            });
+            await this.fs.mkdir(path.dirname(filePath));
+            await this.fs.writeFile(filePath, JSON.stringify(data));
+            await this.setTags(key, data.data.tags || []);
+        }
+    }
+
+    public async getFsPath({
+                               pathname,
+                               appDir,
+                               fetchCache,
+                           }: {
+        pathname: string
+        appDir?: boolean
+        fetchCache?: boolean
+    }): Promise<{
+        filePath: string
+        isAppPath: boolean
+    }> {
+        if (fetchCache) {
+            // we store in .next/cache/fetch-cache so it can be persisted
+            // across deploys
+            return {
+                filePath: path.join(
+                    this.serverDistDir,
+                    '..',
+                    'cache',
+                    'fetch-cache',
+                    pathname,
+                ),
+                isAppPath: false,
+            };
+        }
+        const isAppPath = false;
+        const filePath = path.join(this.serverDistDir, 'pages', pathname);
+
+        if (!this.appDir || appDir === false)
+            return {
+                filePath,
+                isAppPath,
+            };
+        try {
+            await this.fs.readFile(filePath);
+            return {
+                filePath,
+                isAppPath,
+            };
+        } catch (err) {
+            return {
+                filePath: path.join(this.serverDistDir, 'app', pathname),
+                isAppPath: true,
+            };
+        }
+    }
+}

package/server/cache.ts

@@ -0,0 +1,50 @@
+import * as fs from 'fs';
+import {IncrementalCache} from 'next/dist/server/lib/incremental-cache';
+import ClearableFileCache from './ClearableFileCache';
+
+const getCacheHandler = (cache: IncrementalCache): ClearableFileCache => {
+    return cache.cacheHandler as ClearableFileCache;
+};
+
+export const purgeCache = async (cache: IncrementalCache, pathname?: string) => {
+    if (pathname) {
+        return purgePath(cache, pathname);
+    } else {
+        return purgeAll(cache);
+    }
+};
+
+const purgePath = async (cache: IncrementalCache, pathname: string) => {
+    const handler = getCacheHandler(cache);
+    const fsPathObj = await handler.getFsPath({pathname});
+    try {
+        /* Delete entry in cache */
+        handler.delete(pathname);
+
+        /* Delete files from disc */
+        fs.unlinkSync(`${fsPathObj.filePath}.html`);
+        fs.unlinkSync(`${fsPathObj.filePath}.json`);
+
+        console.info(`\nCache deleted for '${fsPathObj.filePath}'\n`);
+    } catch (err) {
+        console.error(`Could not delete cache of '${fsPathObj.filePath}':`, err);
+    }
+};
+
+const purgeAll = async (cache: IncrementalCache) => {
+    const handler = getCacheHandler(cache);
+    try {
+        /* Purge cache */
+        handler.clear();
+
+        const {filePath: pagesRoot} = await handler.getFsPath({pathname: ''});
+
+        if (fs.existsSync(pagesRoot)) {
+            fs.rmSync(pagesRoot, {recursive: true});
+        }
+
+        console.info('\nCache was successfully purged\n');
+    } catch (err) {
+        console.error('Could not purge cache:', err);
+    }
+};

package/server/index.ts

@@ -0,0 +1,74 @@
+import {createServer} from 'http';
+import {purgeCache} from './cache';
+import {NextServer} from 'next/dist/server/next';
+import path from 'path';
+import {NextConfig} from 'next/dist/server/config-shared';
+
+const hostname = process.env.HOST || '127.0.0.1';
+const dev = process.env.NODE_ENV !== 'production';
+const port = process.env.PORT && parseInt(process.env.PORT, 10) || (dev ? 3000 : 4242);
+
+export const PURGE_CACHE_URL = '/_/enonic/cache/purge';
+
+export const withEnonicCache = function (config: any) {
+    const exp = config.experimental || {};
+    exp.isrMemoryCacheSize = exp.isrMemoryCacheSize || 1000000;
+    exp.incrementalCacheHandlerPath = path.resolve(__dirname, 'ClearableFileCache.js');
+    config.experimental = exp;
+    return config;
+};
+
+// Not typed to prevent collision of local types with end-user ones
+export default async (next: (options: any) => any) => {
+    const nextServer = next({dev, hostname, port}) as NextServer;
+    const nextHandler = nextServer.getRequestHandler();
+    return await nextServer.prepare().then(async () => {
+        const nextNodeServer = await nextServer['getServer']?.();
+        if (!nextNodeServer) {
+            console.error('Unable to access incremental cache, cache purge endpoint will be disabled');
+            return nextServer;
+        }
+        const opts: NextConfig = nextNodeServer['serverOptions'].conf;
+        const purgeUrl = (opts?.basePath || '') + PURGE_CACHE_URL;
+
+        console.info(`Staring cache purge endpoint at ${purgeUrl}...`);
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        const server = createServer(async (req, res) => {
+            const parsedUrl = new URL(`http://${hostname}:${port}${req.url || ''}`);
+            if (parsedUrl.pathname !== purgeUrl) {
+                await nextHandler(req, res);
+            } else if (dev) {
+                console.warn('\nCache clearing is not available in DEV mode.\n');
+
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({purged: false}));
+            } else {
+                const tokenParam = parsedUrl.searchParams.get('token');
+                if (tokenParam !== process.env.ENONIC_API_TOKEN) {
+                    // XP hijacks 401 to show login page, so send 407 instead
+                    res.statusCode = 407;
+                    res.end(JSON.stringify({message: 'Invalid token'}));
+                    return;
+                }
+
+                const cache = nextNodeServer.getIncrementalCache({
+                    requestHeaders: Object.assign({}, req.headers),
+                });
+
+                const pathParam = parsedUrl.searchParams.get('path') || undefined;
+                await purgeCache(cache, pathParam);
+
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({purged: true}));
+            }
+
+        }).listen(port, hostname, () => {
+            console.info(`Server ready on ${hostname}:${port}`);
+        }).on('error', (e) => {
+            console.error('Server error:', e);
+            server.close();
+        });
+
+        return nextServer;
+    });
+};

package/server/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "skipLibCheck": true,
+    "moduleResolution": "Node",
+    "lib": [
+      "es6"
+    ],
+    "strict": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "noImplicitAny": true,
+    "outDir": "../dist/server",
+    "resolveJsonModule": true,
+    "declaration": true
+  },
+  "include": [
+    "../next-env.d.ts",
+    "**/*.ts"
+  ],
+  "exclude": []
+}

package/setversion.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { execSync } = require("child_process");
+const version = execSync("git describe --tags --abbrev=0").toString().slice(1).trim();
+
+execSync(`awk -v ver="${version}" '{gsub(/"version": ".*"/,"\\"version\\": \\""ver"\\"")}1' package.json > tmp && mv tmp package.json`);

package/src/.eslintrc.js

@@ -0,0 +1,11 @@
+module.exports = {
+    extends: ['../.eslintrc.js'],
+    overrides: [{
+        extends: '../.eslint-childrc.js',
+        files: ['*.ts', '*.tsx'],
+        parserOptions: {
+            tsconfigRootDir: __dirname,
+            project: './tsconfig.json',
+        },
+    }],
+};