@enonic/nextjs-adapter 1.0.1 → 1.0.2

package/UrlProcessor.d.ts

@@ -18,6 +18,7 @@ export declare class UrlProcessor {
     static processSrcSet(srcset: string, meta: MetaData): string;
     private static stripApiUrl;
     private static isPageUrl;
+    private static startsWithHash;
     private static getApiUrl;
 }
 export declare const getUrl: (url: string, meta: MetaData) => string;

package/UrlProcessor.js

@@ -3,8 +3,9 @@ import { useRouter } from 'next/router';
 class UrlProcessor {
     static process(url, meta) {
         let result;
-        if (!meta || !this.isPageUrl(url) && meta.renderMode === RENDER_MODE.NEXT) {
-            // keep content urls absolute in next mode for everything but page urls
+        if (this.startsWithHash(url) || !meta || !this.isPageUrl(url) && meta.renderMode === RENDER_MODE.NEXT) {
+            // keep page-relative urls starting with hash
+            // keep urls absolute in next mode for everything but page urls
             result = url;
         }
         else {
@@ -60,6 +61,9 @@ class UrlProcessor {
     static isPageUrl(url) {
         return !this.IMG_ATMT_REGEXP.test(url);
     }
+    static startsWithHash(url) {
+        return (url === null || url === void 0 ? void 0 : url.charAt(0)) == '#';
+    }
     static getApiUrl(meta) {
         var _a, _b;
         let combinedUrl = ((_a = meta.apiUrl) === null || _a === void 0 ? void 0 : _a.replace(this.endSlashPattern, '')) || '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enonic/nextjs-adapter",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "license": "Apache-2.0",
   "main": "index.js",
   "publishConfig": {
@@ -13,22 +13,22 @@
     "lint:fix": "eslint --fix server && eslint --fix src"
   },
   "dependencies": {
-    "html-react-parser": "^3.0.15",
-    "lru-cache": "^8.0.4",
-    "next": "^13.2.4",
+    "html-react-parser": "^3.0.16",
+    "lru-cache": "^9.1.1",
+    "next": "^13.3.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "unescape": "^1.0.1"
   },
   "devDependencies": {
     "@enonic/eslint-config": "^1.1.0",
-    "@types/node": "^18.15.10",
-    "@types/react": "^18.0.29",
+    "@types/node": "^18.16.0",
+    "@types/react": "^18.0.38",
     "@types/react-dom": "^18.0.11",
-    "@typescript-eslint/eslint-plugin": "^5.56.0",
-    "@typescript-eslint/parser": "^5.56.0",
-    "eslint": "^8.36.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.0",
+    "@typescript-eslint/parser": "^5.59.0",
+    "eslint": "^8.39.0",
     "eslint-plugin-react": "^7.32.2",
-    "typescript": "^5.0.2"
+    "typescript": "^5.0.4"
   }
 }

package/server/ClearableFileCache.d.ts

@@ -9,9 +9,13 @@ export default class ClearableFileCache implements CacheHandler {
     private flushToDisk?;
     private serverDistDir;
     private appDir;
+    private tagsManifestPath?;
     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, }: {

package/server/ClearableFileCache.js

@@ -40,8 +40,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var path_1 = __importDefault(require("path"));
-var lru_cache_1 = __importDefault(require("lru-cache"));
+var lru_cache_1 = require("lru-cache");
+var constants_1 = require("next/dist/lib/constants");
 var memoryCache;
+var tagsManifest;
 var ClearableFileCache = /** @class */ (function () {
     function ClearableFileCache(ctx) {
         this.fs = ctx.fs;
@@ -49,7 +51,7 @@ var ClearableFileCache = /** @class */ (function () {
         this.serverDistDir = ctx.serverDistDir;
         this.appDir = !!ctx._appDir;
         if (ctx.maxMemoryCacheSize && !memoryCache) {
-            var config = {
+            memoryCache = new lru_cache_1.LRUCache({
                 max: ctx.maxMemoryCacheSize,
                 maxSize: 10 * ctx.maxMemoryCacheSize,
                 sizeCalculation: function (_a) {
@@ -73,8 +75,11 @@ var ClearableFileCache = /** @class */ (function () {
                     // rough estimate of size of cache value
                     return (value.html.length + (((_b = JSON.stringify(value.pageData)) === null || _b === void 0 ? void 0 : _b.length) || 0));
                 },
-            };
-            memoryCache = new lru_cache_1.default(config);
+            });
+        }
+        if (this.serverDistDir && this.fs) {
+            this.tagsManifestPath = path_1.default.join(this.serverDistDir, '..', 'cache', 'fetch-cache', 'tags-manifest.json');
+            this.loadTagsManifest();
         }
     }
     ClearableFileCache.prototype.clear = function () {
@@ -83,93 +88,175 @@ var ClearableFileCache = /** @class */ (function () {
     ClearableFileCache.prototype.delete = function (path) {
         return memoryCache === null || memoryCache === void 0 ? void 0 : memoryCache.delete(path);
     };
+    ClearableFileCache.prototype.loadTagsManifest = function () {
+        if (!this.tagsManifestPath || !this.fs)
+            return;
+        try {
+            tagsManifest = JSON.parse(this.fs.readFileSync(this.tagsManifestPath).toString('utf8'));
+        }
+        catch (err) {
+            tagsManifest = { version: 1, items: {} };
+        }
+    };
+    ClearableFileCache.prototype.setTags = function (key, tags) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, tags_1, tag, data, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.loadTagsManifest();
+                        if (!tagsManifest || !this.tagsManifestPath) {
+                            return [2 /*return*/];
+                        }
+                        for (_i = 0, tags_1 = tags; _i < tags_1.length; _i++) {
+                            tag = tags_1[_i];
+                            data = tagsManifest.items[tag] || { keys: [] };
+                            if (!data.keys.includes(key)) {
+                                data.keys.push(key);
+                            }
+                            tagsManifest.items[tag] = data;
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, this.fs.mkdir(path_1.default.dirname(this.tagsManifestPath))];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.fs.writeFile(this.tagsManifestPath, JSON.stringify(tagsManifest || {}))];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        console.warn('Failed to update tags manifest.', err_1);
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ClearableFileCache.prototype.revalidateTag = function (tag) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // 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 [2 /*return*/];
+                        }
+                        data = tagsManifest.items[tag] || { keys: [] };
+                        data.revalidatedAt = Date.now();
+                        tagsManifest.items[tag] = data;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, this.fs.mkdir(path_1.default.dirname(this.tagsManifestPath))];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.fs.writeFile(this.tagsManifestPath, JSON.stringify(tagsManifest || {}))];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_2 = _a.sent();
+                        console.warn('Failed to update tags manifest.', err_2);
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
     ClearableFileCache.prototype.get = function (key, fetchCache) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var data, filePath, fileData, mtime, meta, _a, _b, cacheEntry, _1, _c, filePath, isAppPath, fileData, mtime, lastModified, pageData, _d, _e, _f, _g, _h, _j, _k, _2;
-            return __generator(this, function (_l) {
-                switch (_l.label) {
+            var data, filePath, fileData, mtime, meta, _c, _d, cacheEntry, _1, _e, filePath, isAppPath, fileData, mtime, lastModified, parsedData, pageData, _f, _g, _h, _j, _k, _l, _m, _2, innerData, isStale;
+            return __generator(this, function (_o) {
+                switch (_o.label) {
                     case 0:
                         data = memoryCache === null || memoryCache === void 0 ? void 0 : memoryCache.get(key);
-                        if (!(!data && process.env.NEXT_RUNTIME !== 'edge')) return [3 /*break*/, 21];
-                        _l.label = 1;
+                        if (!(!data && process.env.NEXT_RUNTIME !== 'edge')) return [3 /*break*/, 20];
+                        _o.label = 1;
                     case 1:
-                        _l.trys.push([1, 6, , 7]);
+                        _o.trys.push([1, 6, , 7]);
                         return [4 /*yield*/, this.getFsPath({
                                 pathname: "".concat(key, ".body"),
                                 appDir: true,
                             })];
                     case 2:
-                        filePath = (_l.sent()).filePath;
+                        filePath = (_o.sent()).filePath;
                         return [4 /*yield*/, this.fs.readFile(filePath)];
                     case 3:
-                        fileData = _l.sent();
+                        fileData = _o.sent();
                         return [4 /*yield*/, this.fs.stat(filePath)];
                     case 4:
-                        mtime = (_l.sent()).mtime;
-                        _b = (_a = JSON).parse;
+                        mtime = (_o.sent()).mtime;
+                        _d = (_c = JSON).parse;
                         return [4 /*yield*/, this.fs.readFile(filePath.replace(/\.body$/, '.meta'))];
                     case 5:
-                        meta = _b.apply(_a, [_l.sent()]);
+                        meta = _d.apply(_c, [(_o.sent()).toString('utf8')]);
                         cacheEntry = {
                             lastModified: mtime.getTime(),
                             value: {
                                 kind: 'ROUTE',
-                                body: Buffer.from(fileData),
+                                body: fileData,
                                 headers: meta.headers,
                                 status: meta.status,
                             },
                         };
                         return [2 /*return*/, cacheEntry];
                     case 6:
-                        _1 = _l.sent();
+                        _1 = _o.sent();
                         return [3 /*break*/, 7];
                     case 7:
-                        _l.trys.push([7, 20, , 21]);
+                        _o.trys.push([7, 19, , 20]);
                         return [4 /*yield*/, this.getFsPath({
                                 pathname: fetchCache ? key : "".concat(key, ".html"),
                                 fetchCache: fetchCache,
                             })];
                     case 8:
-                        _c = _l.sent(), filePath = _c.filePath, isAppPath = _c.isAppPath;
+                        _e = _o.sent(), filePath = _e.filePath, isAppPath = _e.isAppPath;
                         return [4 /*yield*/, this.fs.readFile(filePath)];
                     case 9:
-                        fileData = _l.sent();
+                        fileData = (_o.sent()).toString('utf-8');
                         return [4 /*yield*/, this.fs.stat(filePath)];
                     case 10:
-                        mtime = (_l.sent()).mtime;
+                        mtime = (_o.sent()).mtime;
                         if (!fetchCache) return [3 /*break*/, 11];
                         lastModified = mtime.getTime();
+                        parsedData = JSON.parse(fileData);
                         data = {
                             lastModified: lastModified,
-                            value: JSON.parse(fileData),
+                            value: parsedData,
                         };
-                        return [3 /*break*/, 19];
+                        return [3 /*break*/, 18];
                     case 11:
                         if (!isAppPath) return [3 /*break*/, 14];
-                        _f = (_e = this.fs).readFile;
-                        return [4 /*yield*/, this.getFsPath({ pathname: "".concat(key, ".rsc"), appDir: true })];
-                    case 12: return [4 /*yield*/, _f.apply(_e, [(_l.sent()).filePath])];
+                        _h = (_g = this.fs).readFile;
+                        return [4 /*yield*/, this.getFsPath({
+                                pathname: "".concat(key, ".rsc"),
+                                appDir: true,
+                            })];
+                    case 12: return [4 /*yield*/, _h.apply(_g, [(_o.sent()).filePath])];
                     case 13:
-                        _d = _l.sent();
-                        return [3 /*break*/, 18];
+                        _f = (_o.sent()).toString('utf8');
+                        return [3 /*break*/, 17];
                     case 14:
-                        _h = (_g = JSON).parse;
-                        _k = (_j = this.fs).readFile;
+                        _k = (_j = JSON).parse;
+                        _m = (_l = this.fs).readFile;
                         return [4 /*yield*/, this.getFsPath({
                                 pathname: "".concat(key, ".json"),
                                 appDir: false,
                             })];
-                    case 15: 
-                    // eslint-disable-next-line @typescript-eslint/await-thenable
-                    return [4 /*yield*/, (_l.sent()).filePath];
-                    case 16: return [4 /*yield*/, _k.apply(_j, [
-                            // eslint-disable-next-line @typescript-eslint/await-thenable
-                            _l.sent()])];
+                    case 15: return [4 /*yield*/, _m.apply(_l, [(_o.sent()).filePath])];
+                    case 16:
+                        _f = _k.apply(_j, [(_o.sent()).toString('utf8')]);
+                        _o.label = 17;
                     case 17:
-                        _d = _h.apply(_g, [_l.sent()]);
-                        _l.label = 18;
-                    case 18:
-                        pageData = _d;
+                        pageData = _f;
                         data = {
                             lastModified: mtime.getTime(),
                             value: {
@@ -178,16 +265,30 @@ var ClearableFileCache = /** @class */ (function () {
                                 pageData: pageData,
                             },
                         };
-                        _l.label = 19;
-                    case 19:
+                        _o.label = 18;
+                    case 18:
                         if (data) {
                             memoryCache === null || memoryCache === void 0 ? void 0 : memoryCache.set(key, data);
                         }
-                        return [3 /*break*/, 21];
+                        return [3 /*break*/, 20];
+                    case 19:
+                        _2 = _o.sent();
+                        return [3 /*break*/, 20];
                     case 20:
-                        _2 = _l.sent();
-                        return [3 /*break*/, 21];
-                    case 21: return [2 /*return*/, data || null];
+                        if (data && ((_a = data === null || data === void 0 ? void 0 : data.value) === null || _a === void 0 ? void 0 : _a.kind) === 'FETCH') {
+                            this.loadTagsManifest();
+                            innerData = data.value.data;
+                            isStale = (_b = innerData.tags) === null || _b === void 0 ? void 0 : _b.some(function (tag) {
+                                var _a;
+                                return (((_a = tagsManifest === null || tagsManifest === void 0 ? void 0 : tagsManifest.items[tag]) === null || _a === void 0 ? void 0 : _a.revalidatedAt) &&
+                                    (tagsManifest === null || tagsManifest === void 0 ? void 0 : tagsManifest.items[tag].revalidatedAt) >=
+                                        ((data === null || data === void 0 ? void 0 : data.lastModified) || Date.now()));
+                            });
+                            if (isStale) {
+                                data.lastModified = Date.now() - constants_1.CACHE_ONE_YEAR;
+                            }
+                        }
+                        return [2 /*return*/, data || null];
                 }
             });
         });
@@ -245,9 +346,9 @@ var ClearableFileCache = /** @class */ (function () {
                             isAppPath ? data.pageData : JSON.stringify(data.pageData)])];
                     case 10:
                         _c.sent();
-                        return [3 /*break*/, 15];
+                        return [3 /*break*/, 16];
                     case 11:
-                        if (!((data === null || data === void 0 ? void 0 : data.kind) === 'FETCH')) return [3 /*break*/, 15];
+                        if (!((data === null || data === void 0 ? void 0 : data.kind) === 'FETCH')) return [3 /*break*/, 16];
                         return [4 /*yield*/, this.getFsPath({
                                 pathname: key,
                                 fetchCache: true,
@@ -260,8 +361,11 @@ var ClearableFileCache = /** @class */ (function () {
                         return [4 /*yield*/, this.fs.writeFile(filePath, JSON.stringify(data))];
                     case 14:
                         _c.sent();
-                        _c.label = 15;
-                    case 15: return [2 /*return*/];
+                        return [4 /*yield*/, this.setTags(key, data.data.tags || [])];
+                    case 15:
+                        _c.sent();
+                        _c.label = 16;
+                    case 16: return [2 /*return*/];
                 }
             });
         });
@@ -269,7 +373,7 @@ var ClearableFileCache = /** @class */ (function () {
     ClearableFileCache.prototype.getFsPath = function (_a) {
         var pathname = _a.pathname, appDir = _a.appDir, fetchCache = _a.fetchCache;
         return __awaiter(this, void 0, void 0, function () {
-            var isAppPath, filePath, err_1;
+            var isAppPath, filePath, err_3;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -299,7 +403,7 @@ var ClearableFileCache = /** @class */ (function () {
                                 isAppPath: isAppPath,
                             }];
                     case 3:
-                        err_1 = _b.sent();
+                        err_3 = _b.sent();
                         return [2 /*return*/, {
                                 filePath: path_1.default.join(this.serverDistDir, 'app', pathname),
                                 isAppPath: true,

package/server/cache.js

@@ -77,24 +77,24 @@ var purgeCache = function (cache, pathname) { return __awaiter(void 0, void 0, v
 }); };
 exports.purgeCache = purgeCache;
 var purgePath = function (cache, pathname) { return __awaiter(void 0, void 0, void 0, function () {
-    var handler, fullPathname;
+    var handler, fsPathObj;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 handler = getCacheHandler(cache);
                 return [4 /*yield*/, handler.getFsPath({ pathname: pathname })];
             case 1:
-                fullPathname = _a.sent();
+                fsPathObj = _a.sent();
                 try {
                     /* Delete entry in cache */
                     handler.delete(pathname);
                     /* Delete files from disc */
-                    fs.unlinkSync("".concat(fullPathname, ".html"));
-                    fs.unlinkSync("".concat(fullPathname, ".json"));
-                    console.info("\nCache deleted for '".concat(fullPathname, "'\n"));
+                    fs.unlinkSync("".concat(fsPathObj.filePath, ".html"));
+                    fs.unlinkSync("".concat(fsPathObj.filePath, ".json"));
+                    console.info("\nCache deleted for '".concat(fsPathObj.filePath, "'\n"));
                 }
                 catch (err) {
-                    console.error("Could not delete cache of '".concat(fullPathname, "':"), err);
+                    console.error("Could not delete cache of '".concat(fsPathObj.filePath, "':"), err);
                 }
                 return [2 /*return*/];
         }