@enonic/nextjs-adapter 2.0.1 → 2.0.3

package/server/.eslintrc.js

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

package/server/ClearableFileCache.ts

@@ -1,410 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,23 +0,0 @@
-{
-  "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/src/.eslintrc.js

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