@enonic/nextjs-adapter 0.13.0 → 1.0.0-RC1

package/server/ClearableFileCache.js

@@ -0,0 +1,314 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+var lru_cache_1 = __importDefault(require("lru-cache"));
+var memoryCache;
+var ClearableFileCache = /** @class */ (function () {
+    function ClearableFileCache(ctx) {
+        this.fs = ctx.fs;
+        this.flushToDisk = ctx.flushToDisk;
+        this.serverDistDir = ctx.serverDistDir;
+        this.appDir = !!ctx._appDir;
+        if (ctx.maxMemoryCacheSize && !memoryCache) {
+            var config = {
+                max: ctx.maxMemoryCacheSize,
+                maxSize: 10 * ctx.maxMemoryCacheSize,
+                sizeCalculation: function (_a) {
+                    var _b;
+                    var value = _a.value;
+                    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 + (((_b = JSON.stringify(value.pageData)) === null || _b === void 0 ? void 0 : _b.length) || 0));
+                },
+            };
+            memoryCache = new lru_cache_1.default(config);
+        }
+    }
+    ClearableFileCache.prototype.clear = function () {
+        memoryCache === null || memoryCache === void 0 ? void 0 : memoryCache.clear();
+    };
+    ClearableFileCache.prototype.delete = function (path) {
+        return memoryCache === null || memoryCache === void 0 ? void 0 : memoryCache.delete(path);
+    };
+    ClearableFileCache.prototype.get = function (key, fetchCache) {
+        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) {
+                    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;
+                    case 1:
+                        _l.trys.push([1, 6, , 7]);
+                        return [4 /*yield*/, this.getFsPath({
+                                pathname: "".concat(key, ".body"),
+                                appDir: true,
+                            })];
+                    case 2:
+                        filePath = (_l.sent()).filePath;
+                        return [4 /*yield*/, this.fs.readFile(filePath)];
+                    case 3:
+                        fileData = _l.sent();
+                        return [4 /*yield*/, this.fs.stat(filePath)];
+                    case 4:
+                        mtime = (_l.sent()).mtime;
+                        _b = (_a = JSON).parse;
+                        return [4 /*yield*/, this.fs.readFile(filePath.replace(/\.body$/, '.meta'))];
+                    case 5:
+                        meta = _b.apply(_a, [_l.sent()]);
+                        cacheEntry = {
+                            lastModified: mtime.getTime(),
+                            value: {
+                                kind: 'ROUTE',
+                                body: Buffer.from(fileData),
+                                headers: meta.headers,
+                                status: meta.status,
+                            },
+                        };
+                        return [2 /*return*/, cacheEntry];
+                    case 6:
+                        _1 = _l.sent();
+                        return [3 /*break*/, 7];
+                    case 7:
+                        _l.trys.push([7, 20, , 21]);
+                        return [4 /*yield*/, this.getFsPath({
+                                pathname: fetchCache ? key : "".concat(key, ".html"),
+                                fetchCache: fetchCache,
+                            })];
+                    case 8:
+                        _c = _l.sent(), filePath = _c.filePath, isAppPath = _c.isAppPath;
+                        return [4 /*yield*/, this.fs.readFile(filePath)];
+                    case 9:
+                        fileData = _l.sent();
+                        return [4 /*yield*/, this.fs.stat(filePath)];
+                    case 10:
+                        mtime = (_l.sent()).mtime;
+                        if (!fetchCache) return [3 /*break*/, 11];
+                        lastModified = mtime.getTime();
+                        data = {
+                            lastModified: lastModified,
+                            value: JSON.parse(fileData),
+                        };
+                        return [3 /*break*/, 19];
+                    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])];
+                    case 13:
+                        _d = _l.sent();
+                        return [3 /*break*/, 18];
+                    case 14:
+                        _h = (_g = JSON).parse;
+                        _k = (_j = 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 17:
+                        _d = _h.apply(_g, [_l.sent()]);
+                        _l.label = 18;
+                    case 18:
+                        pageData = _d;
+                        data = {
+                            lastModified: mtime.getTime(),
+                            value: {
+                                kind: 'PAGE',
+                                html: fileData,
+                                pageData: pageData,
+                            },
+                        };
+                        _l.label = 19;
+                    case 19:
+                        if (data) {
+                            memoryCache === null || memoryCache === void 0 ? void 0 : memoryCache.set(key, data);
+                        }
+                        return [3 /*break*/, 21];
+                    case 20:
+                        _2 = _l.sent();
+                        return [3 /*break*/, 21];
+                    case 21: return [2 /*return*/, data || null];
+                }
+            });
+        });
+    };
+    ClearableFileCache.prototype.set = function (key, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filePath, isAppPath, htmlPath, _a, _b, filePath;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        memoryCache === null || memoryCache === void 0 ? void 0 : memoryCache.set(key, {
+                            value: data,
+                            lastModified: Date.now(),
+                        });
+                        if (!this.flushToDisk)
+                            return [2 /*return*/];
+                        if (!((data === null || data === void 0 ? void 0 : data.kind) === 'ROUTE')) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.getFsPath({
+                                pathname: "".concat(key, ".body"),
+                                appDir: true,
+                            })];
+                    case 1:
+                        filePath = (_c.sent()).filePath;
+                        return [4 /*yield*/, this.fs.mkdir(path_1.default.dirname(filePath))];
+                    case 2:
+                        _c.sent();
+                        return [4 /*yield*/, this.fs.writeFile(filePath, data.body)];
+                    case 3:
+                        _c.sent();
+                        return [4 /*yield*/, this.fs.writeFile(filePath.replace(/\.body$/, '.meta'), JSON.stringify({ headers: data.headers, status: data.status }))];
+                    case 4:
+                        _c.sent();
+                        return [2 /*return*/];
+                    case 5:
+                        if (!((data === null || data === void 0 ? void 0 : data.kind) === 'PAGE')) return [3 /*break*/, 11];
+                        isAppPath = typeof data.pageData === 'string';
+                        return [4 /*yield*/, this.getFsPath({
+                                pathname: "".concat(key, ".html"),
+                                appDir: isAppPath,
+                            })];
+                    case 6:
+                        htmlPath = (_c.sent()).filePath;
+                        return [4 /*yield*/, this.fs.mkdir(path_1.default.dirname(htmlPath))];
+                    case 7:
+                        _c.sent();
+                        return [4 /*yield*/, this.fs.writeFile(htmlPath, data.html)];
+                    case 8:
+                        _c.sent();
+                        _b = (_a = this.fs).writeFile;
+                        return [4 /*yield*/, this.getFsPath({
+                                pathname: "".concat(key, ".").concat(isAppPath ? 'rsc' : 'json'),
+                                appDir: isAppPath,
+                            })];
+                    case 9: return [4 /*yield*/, _b.apply(_a, [(_c.sent()).filePath,
+                            isAppPath ? data.pageData : JSON.stringify(data.pageData)])];
+                    case 10:
+                        _c.sent();
+                        return [3 /*break*/, 15];
+                    case 11:
+                        if (!((data === null || data === void 0 ? void 0 : data.kind) === 'FETCH')) return [3 /*break*/, 15];
+                        return [4 /*yield*/, this.getFsPath({
+                                pathname: key,
+                                fetchCache: true,
+                            })];
+                    case 12:
+                        filePath = (_c.sent()).filePath;
+                        return [4 /*yield*/, this.fs.mkdir(path_1.default.dirname(filePath))];
+                    case 13:
+                        _c.sent();
+                        return [4 /*yield*/, this.fs.writeFile(filePath, JSON.stringify(data))];
+                    case 14:
+                        _c.sent();
+                        _c.label = 15;
+                    case 15: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    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;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (fetchCache) {
+                            // we store in .next/cache/fetch-cache so it can be persisted
+                            // across deploys
+                            return [2 /*return*/, {
+                                    filePath: path_1.default.join(this.serverDistDir, '..', 'cache', 'fetch-cache', pathname),
+                                    isAppPath: false,
+                                }];
+                        }
+                        isAppPath = false;
+                        filePath = path_1.default.join(this.serverDistDir, 'pages', pathname);
+                        if (!this.appDir || appDir === false)
+                            return [2 /*return*/, {
+                                    filePath: filePath,
+                                    isAppPath: isAppPath,
+                                }];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.fs.readFile(filePath)];
+                    case 2:
+                        _b.sent();
+                        return [2 /*return*/, {
+                                filePath: filePath,
+                                isAppPath: isAppPath,
+                            }];
+                    case 3:
+                        err_1 = _b.sent();
+                        return [2 /*return*/, {
+                                filePath: path_1.default.join(this.serverDistDir, 'app', pathname),
+                                isAppPath: true,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return ClearableFileCache;
+}());
+exports.default = ClearableFileCache;

package/server/cache.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.purgeCache = void 0;
+var fs = __importStar(require("fs"));
+var getCacheHandler = function (cache) {
+    return cache.cacheHandler;
+};
+var purgeCache = function (cache, pathname) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        if (pathname) {
+            return [2 /*return*/, purgePath(cache, pathname)];
+        }
+        else {
+            return [2 /*return*/, purgeAll(cache)];
+        }
+        return [2 /*return*/];
+    });
+}); };
+exports.purgeCache = purgeCache;
+var purgePath = function (cache, pathname) { return __awaiter(void 0, void 0, void 0, function () {
+    var handler, fullPathname;
+    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();
+                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"));
+                }
+                catch (err) {
+                    console.error("Could not delete cache of '".concat(fullPathname, "':"), err);
+                }
+                return [2 /*return*/];
+        }
+    });
+}); };
+var purgeAll = function (cache) { return __awaiter(void 0, void 0, void 0, function () {
+    var handler, pagesRoot, err_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                handler = getCacheHandler(cache);
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                /* Purge cache */
+                handler.clear();
+                return [4 /*yield*/, handler.getFsPath({ pathname: '' })];
+            case 2:
+                pagesRoot = (_a.sent()).filePath;
+                if (fs.existsSync(pagesRoot)) {
+                    fs.rmSync(pagesRoot, { recursive: true });
+                }
+                console.info('\nCache was successfully purged\n');
+                return [3 /*break*/, 4];
+            case 3:
+                err_1 = _a.sent();
+                console.error('Could not purge cache:', err_1);
+                return [3 /*break*/, 4];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };

package/server/index.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withEnonicCache = exports.PURGE_CACHE_URL = void 0;
+var http_1 = require("http");
+var cache_1 = require("./cache");
+var path_1 = __importDefault(require("path"));
+var host = process.env.HOST || '127.0.0.1';
+var dev = process.env.NODE_ENV !== 'production';
+var port = process.env.PORT && parseInt(process.env.PORT, 10) || (dev ? 3000 : 4242);
+exports.PURGE_CACHE_URL = '/_/enonic/cache/purge';
+var withEnonicCache = function (config) {
+    var exp = config.experimental || {};
+    exp.isrMemoryCacheSize = exp.isrMemoryCacheSize || 1000000;
+    exp.incrementalCacheHandlerPath = path_1.default.resolve(__dirname, 'ClearableFileCache.js');
+    config.experimental = exp;
+    return config;
+};
+exports.withEnonicCache = withEnonicCache;
+// Not typed to prevent collision of local types with end-user ones
+exports.default = (function (next) { return __awaiter(void 0, void 0, void 0, function () {
+    var nextServer, nextHandler;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                nextServer = next({ dev: dev });
+                nextHandler = nextServer.getRequestHandler();
+                return [4 /*yield*/, nextServer.prepare().then(function () {
+                        var nextNodeServer = nextServer['server'];
+                        var opts = nextNodeServer['serverOptions'].conf;
+                        var purgeUrl = ((opts === null || opts === void 0 ? void 0 : opts.basePath) || '') + exports.PURGE_CACHE_URL;
+                        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                        var server = (0, http_1.createServer)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+                            var parsedUrl, tokenParam, cache, pathParam;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        parsedUrl = new URL("http://".concat(host, ":").concat(port).concat(req.url || ''));
+                                        if (!(parsedUrl.pathname !== purgeUrl)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, nextHandler(req, res)];
+                                    case 1:
+                                        _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 2:
+                                        tokenParam = parsedUrl.searchParams.get('token');
+                                        if (tokenParam !== process.env.API_TOKEN) {
+                                            // XP hijacks 401 to show login page, so send 407 instead
+                                            res.statusCode = 407;
+                                            res.end(JSON.stringify({ message: 'Invalid token' }));
+                                            return [2 /*return*/];
+                                        }
+                                        cache = nextNodeServer.getIncrementalCache({
+                                            requestHeaders: Object.assign({}, req.headers),
+                                        });
+                                        pathParam = parsedUrl.searchParams.get('path') || undefined;
+                                        return [4 /*yield*/, (0, cache_1.purgeCache)(cache, pathParam)];
+                                    case 3:
+                                        _a.sent();
+                                        res.setHeader('Content-Type', 'application/json');
+                                        res.end(JSON.stringify({ purged: true }));
+                                        _a.label = 4;
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); }).listen(port, host, function () {
+                            console.info("Server ready on ".concat(host, ":").concat(port));
+                        }).on('error', function (e) {
+                            console.error('Server error:', e);
+                            server.close();
+                        });
+                        return nextServer;
+                    })];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); });

package/utils.d.ts

@@ -1,5 +1,5 @@
 /** Import config values from .env, .env.development and .env.production */
-import { Context, MinimalContext } from './guillotine/fetchContent';
+import { MinimalContext } from './guillotine/fetchContent';
 export declare const IS_DEV_MODE: boolean;
 /** Optional utility value - defining in one place the name of the target app (the app that defines the content types, the app name is therefore part of the content type strings used both in typeselector and in query introspections) */
 export declare const APP_NAME: string;
@@ -8,9 +8,7 @@ export declare const APP_NAME_UNDERSCORED: string;
 /** Optional utility value - derived from APP_NAME, only with dashes instead of dots */
 export declare const APP_NAME_DASHED: string;
 export declare const SITE_KEY: string;
-export declare const FROM_XP_PARAM = "__fromxp__";
 export declare const XP_BASE_URL_HEADER = "xpbaseurl";
-export declare const COMPONENT_SUBPATH_HEADER = "xp-component-path";
 export declare const RENDER_MODE_HEADER = "content-studio-mode";
 export declare const JSESSIONID_HEADER = "jsessionid";
 export declare const PORTAL_COMPONENT_ATTRIBUTE = "data-portal-component-type";
@@ -40,11 +38,9 @@ export declare enum XP_COMPONENT_TYPE {
     FRAGMENT = "fragment",
     PAGE = "page"
 }
-/** Returns true if the context object (from next.js in [[...contentPath]].jsx ) stems from a request that comes from XP in a CS-preview, i.e. has the URI param FROM_XP_PARAM (defined as '__fromXp__' above).
- *  False if no context, query or FROM_XP_PARAM param */
-export declare const isRequestFromXP: (context?: Context) => boolean;
-export declare const getXPRequestType: (context?: Context) => XP_REQUEST_TYPE;
+export declare const getRenderMode: (context?: MinimalContext) => RENDER_MODE;
 export declare function getContentApiUrl(context?: MinimalContext): string;
+export declare function getJsessionHeaders(context?: MinimalContext): Object;
 export declare const getXpBaseUrl: (context?: MinimalContext) => string;
 export declare const commonChars: (s1?: string, s2?: string) => string;
 export declare const sanitizeGraphqlName: (text: string) => string;
@@ -54,12 +50,7 @@ declare const adapterConstants: {
     APP_NAME_UNDERSCORED: string;
     APP_NAME_DASHED: string;
     SITE_KEY: string;
-    FROM_XP_PARAM: string;
-    COMPONENT_SUBPATH_HEADER: string;
     PORTAL_COMPONENT_ATTRIBUTE: string;
     PORTAL_REGION_ATTRIBUTE: string;
-    getXPRequestType: (context?: Context) => XP_REQUEST_TYPE;
-    getSingleComponentPath: (context?: Context) => string | undefined;
-    getRenderMode: (context?: MinimalContext) => RENDER_MODE;
 };
 export default adapterConstants;

package/utils.js

@@ -12,9 +12,7 @@ export const APP_NAME_DASHED = (APP_NAME || '').replace(/\./g, '-');
 export const SITE_KEY = (process.env.SITE_KEY || process.env.NEXT_PUBLIC_SITE_KEY);
 // ////////////////////////////////////////////////////////////////////////  Hardcode-able constants
 // URI parameter marking that a request is for a preview for CS. MUST MATCH THE VALUE OF 'FROM_XP_PARAM' on XP side.
-export const FROM_XP_PARAM = '__fromxp__';
 export const XP_BASE_URL_HEADER = 'xpbaseurl';
-export const COMPONENT_SUBPATH_HEADER = 'xp-component-path';
 export const RENDER_MODE_HEADER = 'content-studio-mode';
 export const JSESSIONID_HEADER = 'jsessionid';
 export const PORTAL_COMPONENT_ATTRIBUTE = 'data-portal-component-type';
@@ -49,31 +47,25 @@ export var XP_COMPONENT_TYPE;
     XP_COMPONENT_TYPE["FRAGMENT"] = "fragment";
     XP_COMPONENT_TYPE["PAGE"] = "page";
 })(XP_COMPONENT_TYPE || (XP_COMPONENT_TYPE = {}));
-/** Returns true if the context object (from next.js in [[...contentPath]].jsx ) stems from a request that comes from XP in a CS-preview, i.e. has the URI param FROM_XP_PARAM (defined as '__fromXp__' above).
- *  False if no context, query or FROM_XP_PARAM param */
-export const isRequestFromXP = (context) => {
-    return !!getXPRequestType(context);
-};
-export const getXPRequestType = (context) => {
-    var _a;
-    const headerValue = (((_a = context === null || context === void 0 ? void 0 : context.req) === null || _a === void 0 ? void 0 : _a.headers) || {})[FROM_XP_PARAM];
-    const enumValue = XP_REQUEST_TYPE[headerValue === null || headerValue === void 0 ? void 0 : headerValue.toUpperCase()];
-    return enumValue || XP_REQUEST_TYPE.PAGE; // need to have some defaults here in case of rendering without XP
-};
-const getRenderMode = (context) => {
+export const getRenderMode = (context) => {
     var _a;
     const value = (((_a = context === null || context === void 0 ? void 0 : context.req) === null || _a === void 0 ? void 0 : _a.headers) || {})[RENDER_MODE_HEADER];
     const enumValue = RENDER_MODE[value === null || value === void 0 ? void 0 : value.toUpperCase()];
     return enumValue || RENDER_MODE[process.env.RENDER_MODE] || RENDER_MODE.NEXT;
 };
-const getSingleComponentPath = (context) => {
-    var _a;
-    return (((_a = context === null || context === void 0 ? void 0 : context.req) === null || _a === void 0 ? void 0 : _a.headers) || {})[COMPONENT_SUBPATH_HEADER];
-};
 export function getContentApiUrl(context) {
     const mode = getRenderMode(context);
     return mode === RENDER_MODE.NEXT ? CONTENT_API_MASTER : CONTENT_API_DRAFT;
 }
+export function getJsessionHeaders(context) {
+    var _a;
+    const headers = {};
+    const jsessionid = (_a = context === null || context === void 0 ? void 0 : context.req) === null || _a === void 0 ? void 0 : _a.headers[JSESSIONID_HEADER];
+    if (jsessionid) {
+        headers['Cookie'] = `${JSESSIONID_HEADER}=${jsessionid}`;
+    }
+    return headers;
+}
 /** For '<a href="..."' link values in props when clicking the link should navigate to an XP content item page
  *  and the query returns the XP _path to the target content item:
  *  When viewed directly, the header will have a `<base href='/' />` (see src/pages/_app.tsx), and when viewed through an
@@ -129,13 +121,8 @@ const adapterConstants = {
     APP_NAME_UNDERSCORED,
     APP_NAME_DASHED,
     SITE_KEY,
-    FROM_XP_PARAM,
-    COMPONENT_SUBPATH_HEADER,
     PORTAL_COMPONENT_ATTRIBUTE,
     PORTAL_REGION_ATTRIBUTE,
-    getXPRequestType,
-    getSingleComponentPath,
-    getRenderMode,
 };
 // Verify required values
 const NOT_REQUIRED = ['IS_DEV_MODE'];