@enonic/nextjs-adapter 1.0.1 → 2.0.0-B1

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*/];
         }

package/server/index.js

@@ -43,7 +43,7 @@ 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 hostname = 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';
@@ -61,59 +61,71 @@ exports.default = (function (next) { return __awaiter(void 0, void 0, void 0, fu
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                nextServer = next({ dev: dev });
+                nextServer = next({ dev: dev, hostname: hostname, port: port });
                 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*/, 5];
-                                    case 2:
-                                        if (!dev) return [3 /*break*/, 3];
-                                        console.warn('\nCache clearing is not available in DEV mode.\n');
-                                        res.setHeader('Content-Type', 'application/json');
-                                        res.end(JSON.stringify({ purged: false }));
-                                        return [3 /*break*/, 5];
-                                    case 3:
-                                        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),
+                return [4 /*yield*/, nextServer.prepare().then(function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var nextNodeServer, opts, purgeUrl, server;
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0: return [4 /*yield*/, ((_a = nextServer['getServer']) === null || _a === void 0 ? void 0 : _a.call(nextServer))];
+                                case 1:
+                                    nextNodeServer = _b.sent();
+                                    if (!nextNodeServer) {
+                                        console.error('Unable to access incremental cache, cache purge endpoint will be disabled');
+                                        return [2 /*return*/, nextServer];
+                                    }
+                                    opts = nextNodeServer['serverOptions'].conf;
+                                    purgeUrl = ((opts === null || opts === void 0 ? void 0 : opts.basePath) || '') + exports.PURGE_CACHE_URL;
+                                    console.info("Staring cache purge endpoint at ".concat(purgeUrl, "..."));
+                                    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(hostname, ":").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*/, 5];
+                                                case 2:
+                                                    if (!dev) return [3 /*break*/, 3];
+                                                    console.warn('\nCache clearing is not available in DEV mode.\n');
+                                                    res.setHeader('Content-Type', 'application/json');
+                                                    res.end(JSON.stringify({ purged: false }));
+                                                    return [3 /*break*/, 5];
+                                                case 3:
+                                                    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 4:
+                                                    _a.sent();
+                                                    res.setHeader('Content-Type', 'application/json');
+                                                    res.end(JSON.stringify({ purged: true }));
+                                                    _a.label = 5;
+                                                case 5: return [2 /*return*/];
+                                            }
                                         });
-                                        pathParam = parsedUrl.searchParams.get('path') || undefined;
-                                        return [4 /*yield*/, (0, cache_1.purgeCache)(cache, pathParam)];
-                                    case 4:
-                                        _a.sent();
-                                        res.setHeader('Content-Type', 'application/json');
-                                        res.end(JSON.stringify({ purged: true }));
-                                        _a.label = 5;
-                                    case 5: 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();
+                                    }); }).listen(port, hostname, function () {
+                                        console.info("Server ready on ".concat(hostname, ":").concat(port));
+                                    }).on('error', function (e) {
+                                        console.error('Server error:', e);
+                                        server.close();
+                                    });
+                                    return [2 /*return*/, nextServer];
+                            }
                         });
-                        return nextServer;
-                    })];
+                    }); })];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });

package/utils.d.ts

@@ -1,15 +1,24 @@
+/// <reference types="node" />
+/// <reference types="node" />
 /** Import config values from .env, .env.development and .env.production */
-import { MinimalContext } from './guillotine/fetchContent';
+import { GetServerSidePropsContext } from 'next';
+import { ParsedUrlQuery } from 'node:querystring';
+import { IncomingHttpHeaders } from 'http';
 export declare const IS_DEV_MODE: boolean;
+export declare enum ENV_VARS {
+    PROJECTS = "ENONIC_PROJECTS",
+    API = "ENONIC_API",
+    API_TOKEN = "ENONIC_API_TOKEN"
+}
 /** 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;
 /** Optional utility value - derived from APP_NAME, only with underscores instead of dots */
 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 XP_BASE_URL_HEADER = "xpbaseurl";
 export declare const RENDER_MODE_HEADER = "content-studio-mode";
+export declare const PROJECT_ID_HEADER = "content-studio-project";
 export declare const JSESSIONID_HEADER = "jsessionid";
 export declare const PORTAL_COMPONENT_ATTRIBUTE = "data-portal-component-type";
 export declare const PORTAL_REGION_ATTRIBUTE = "data-portal-region";
@@ -18,6 +27,16 @@ export declare const FRAGMENT_DEFAULT_REGION_NAME = "fragment";
 export declare const PAGE_TEMPLATE_CONTENTTYPE_NAME = "portal:page-template";
 export declare const PAGE_TEMPLATE_FOLDER = "portal:template-folder";
 export declare const SITE_CONTENTTYPE_NAME = "portal:site";
+export declare const LOCALE_HEADER = "locale";
+export declare const LOCALES_HEADER = "locales";
+export declare const DEFAULT_LOCALE_HEADER = "default-locale";
+/** excluded contents:
+ * - folder
+ * - shortcuts (redirect can't be used in prerender)
+ * - media
+ * - paths with '/_' in them
+ */
+export declare const GET_STATIC_PATHS_QUERY = "query ($count: Int = 100){\n  guillotine {\n    query(query: \"type != 'base:folder' AND type != 'base:shortcut' AND type NOT LIKE 'media:*' AND _path NOT LIKE '*/_*'\", first: $count) {\n      _name\n      _path\n      site {\n        _name\n      }\n    }\n  }\n}";
 export declare enum XP_REQUEST_TYPE {
     COMPONENT = "component",
     TYPE = "type",
@@ -38,9 +57,48 @@ export declare enum XP_COMPONENT_TYPE {
     FRAGMENT = "fragment",
     PAGE = "page"
 }
+export interface ServerSideParams extends ParsedUrlQuery {
+    contentPath?: string[];
+    mode?: string;
+}
+export interface PreviewParams {
+    contentPath: string[];
+    headers: Record<string, string>;
+    params: Record<string, string>;
+}
+export type Context = GetServerSidePropsContext<ServerSideParams, PreviewParams>;
+export type LocaleProjectConfig = {
+    project: string;
+    site: string;
+    locale: string;
+};
+export type LocaleProjectConfigs = {
+    default: LocaleProjectConfig;
+    [locale: string]: LocaleProjectConfig;
+};
+export interface MinimalContext {
+    req?: {
+        headers: IncomingHttpHeaders;
+    };
+    locale?: string;
+    defaultLocale?: string;
+    locales?: string[];
+}
+export interface ContentPathItem {
+    params: {
+        contentPath: string[];
+    };
+    locale?: string;
+}
 export declare const getRenderMode: (context?: MinimalContext) => RENDER_MODE;
+export declare function normalizeLocale(locale: string): string | undefined;
+export declare function getLocaleProjectConfig(context?: MinimalContext): LocaleProjectConfig;
+export declare function getLocaleProjectConfigById(projectId?: string, useDefault?: boolean): LocaleProjectConfig;
+export declare function getLocaleProjectConfigs(): LocaleProjectConfigs;
+export declare function fixDoubleSlashes(str: string): string;
 export declare function getContentApiUrl(context?: MinimalContext): string;
-export declare function getJsessionHeaders(context?: MinimalContext): Object;
+export declare function addJsessionHeaders(headers?: Object, context?: MinimalContext): void;
+export declare function addLocaleHeaders(headers?: Object, context?: Context): void;
 export declare const getXpBaseUrl: (context?: MinimalContext) => string;
 export declare const commonChars: (s1?: string, s2?: string) => string;
 export declare const sanitizeGraphqlName: (text: string) => string;
@@ -49,7 +107,6 @@ declare const adapterConstants: {
     APP_NAME: string;
     APP_NAME_UNDERSCORED: string;
     APP_NAME_DASHED: string;
-    SITE_KEY: string;
     PORTAL_COMPONENT_ATTRIBUTE: string;
     PORTAL_REGION_ATTRIBUTE: string;
 };