jopijs 0.0.1

package/dist/@core/jopiRequest.js

@@ -0,0 +1,1060 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ServerFetch } from "./serverFetch.js";
+import React, {} from "react";
+import { PageController_ExposePrivate } from "jopijs/ui";
+import * as ReactServer from "react-dom/server";
+import * as cheerio from "cheerio";
+import * as jk_schema from "jopi-toolkit/jk_schema";
+import * as jk_what from "jopi-toolkit/jk_what";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+import Page from "./PageComponent.js";
+import { initCheerio } from "./jQuery.js";
+import {} from "./caches/cache.js";
+import { SBPE_DirectSendThisResponseException, SBPE_NotAuthorizedException, WebSiteImpl } from "./jopiWebSite.js";
+import { parseCookies } from "./internalTools.js";
+import * as jk_term from "jopi-toolkit/jk_term";
+import { isNodeJS } from "jopi-toolkit/jk_what";
+import { isSinglePageMode } from "jopijs/loader-client";
+import { createBundleForPage } from "./bundler/bundler.js";
+import {} from "./browserCacheControl.js";
+import { WebSiteMirrorCache } from "./caches/webSiteMirrorCache.js";
+export class JopiRequest {
+    webSite;
+    _urlInfos;
+    coreRequest;
+    coreServer;
+    routeInfos;
+    cache;
+    mainCache;
+    cookies;
+    _headers;
+    constructor(webSite, _urlInfos, coreRequest, coreServer, routeInfos) {
+        this.webSite = webSite;
+        this._urlInfos = _urlInfos;
+        this.coreRequest = coreRequest;
+        this.coreServer = coreServer;
+        this.routeInfos = routeInfos;
+        this.cache = webSite.mainCache;
+        this.mainCache = this.cache;
+        this._headers = this.coreRequest.headers;
+    }
+    //region Properties
+    _customData;
+    get urlInfos() {
+        if (!this._urlInfos) {
+            this._urlInfos = new URL(this.coreRequest.url);
+            this._urlInfos.hash = "";
+        }
+        return this._urlInfos;
+    }
+    get customData() {
+        if (!this._customData)
+            this._customData = {};
+        return this._customData;
+    }
+    /**
+     * Return the verb used for the request (GET, POST, PUT, DELETE, ...)
+     */
+    get method() {
+        return this.coreRequest.method;
+    }
+    /**
+     * Return the content type of the request.
+     */
+    get reqContentType() {
+        return this.coreRequest.headers.get("content-type");
+    }
+    get url() {
+        return this.coreRequest.url;
+    }
+    get body() {
+        return this.coreRequest.body;
+    }
+    get headers() {
+        return this._headers;
+    }
+    set headers(value) {
+        this._headers = value;
+    }
+    /**
+     * The part of the url.
+     * if : https://mywebsite/product-name/list
+     * and route http://mywebsite/:product/list
+     * then urlParts contains {product: "product-name"}
+     */
+    urlParts;
+    /**
+     * Returns the url search params.
+     * For "https://my-site/?sort=asc&filter=jopi", it returns {sort: "asc", filter: "jopi"}.
+     */
+    get urlSearchParams() {
+        const sp = this.urlInfos.searchParams;
+        if (!sp.size)
+            return {};
+        const res = {};
+        sp.forEach((value, key) => res[key] = value);
+        return res;
+    }
+    /**
+     * Returns information on the caller IP.
+     */
+    get requestIP() {
+        return this.coreServer.requestIP(this.coreRequest);
+    }
+    get isFromLocalhost() {
+        const ip = this.requestIP;
+        if (!ip)
+            return false;
+        const address = ip.address;
+        switch (address) {
+            case "::1":
+            case "127.0.0.1":
+            case "::ffff:127.0.0.1":
+                return true;
+        }
+        return false;
+    }
+    //endregion
+    //region Body transforming
+    /**
+     * Returns all the data about the request.
+     * It's concat all data source.
+     *
+     * - The url parts.
+     * - The search param (query string).
+     * - The POST/PUT data if available.
+     */
+    async req_getData(options) {
+        let res = {};
+        if (!(options && options.ignoreUrl)) {
+            const searchParams = this.urlInfos.searchParams;
+            if (searchParams.size) {
+                searchParams.forEach((value, key) => res[key] = value);
+            }
+            if (this.urlParts) {
+                res = { ...res, ...this.urlParts };
+            }
+        }
+        if (this.req_isBodyJson) {
+            try {
+                const asJson = await this.req_bodyAsJson();
+                if (asJson)
+                    res = { ...res, ...asJson };
+            }
+            catch {
+                // If JSON is invalid.
+            }
+        }
+        else if (this.req_isBodyXFormUrlEncoded) {
+            try {
+                let data = await this.req_bodyAsText();
+                new URLSearchParams(data).forEach((value, key) => res[key] = value);
+            }
+            catch {
+                // If invalid.
+            }
+        }
+        else if (this.req_isBodyFormData) {
+            try {
+                const asFormData = await this.req_bodyAsFormData();
+                asFormData.forEach((value, key) => res[key] = value);
+            }
+            catch {
+                // If FormData is invalid.
+            }
+        }
+        if (options && options.dataSchema) {
+            this.tool_validateDataSchema(res, options.dataSchema);
+        }
+        return res;
+    }
+    /**
+     * Get the request body and decode it properly.
+     */
+    async req_getBodyData(options) {
+        let res = {};
+        if (this.req_isBodyJson) {
+            try {
+                const asJson = await this.req_bodyAsJson();
+                if (asJson)
+                    res = { ...res, ...asJson };
+            }
+            catch {
+                // If JSON is invalid.
+            }
+        }
+        else if (this.req_isBodyXFormUrlEncoded) {
+            try {
+                let data = await this.req_bodyAsText();
+                new URLSearchParams(data).forEach((value, key) => res[key] = value);
+            }
+            catch {
+                // If invalid.
+            }
+        }
+        else if (this.req_isBodyFormData) {
+            try {
+                const asFormData = await this.req_bodyAsFormData();
+                asFormData.forEach((value, key) => res[key] = value);
+            }
+            catch {
+                // If FormData is invalid.
+            }
+        }
+        if (options && options.dataSchema) {
+            this.tool_validateDataSchema(res, options.dataSchema);
+        }
+        return res;
+    }
+    /**
+     * Returns all the data about the request, organized by category.
+     */
+    async req_getDataInfos() {
+        let res = {};
+        const searchParams = this.urlInfos.searchParams;
+        if (searchParams.size) {
+            const t = res.searchParams = {};
+            searchParams.forEach((value, key) => t[key] = value);
+        }
+        if (this.urlParts) {
+            res.urlParts = { ...this.urlParts };
+        }
+        if (this.req_isBodyJson) {
+            try {
+                res.body = await this.req_bodyAsJson();
+            }
+            catch {
+                // If JSON is invalid.
+            }
+        }
+        else if (this.req_isBodyFormData) {
+            try {
+                const t = res.formData = {};
+                const asFormData = await this.req_bodyAsFormData();
+                asFormData.forEach((value, key) => t[key] = value);
+            }
+            catch {
+                // If FormData is invalid.
+            }
+        }
+        else if (this.req_isBodyXFormUrlEncoded) {
+            try {
+                let data = await this.req_bodyAsText();
+                const t = res.formUrlEncoded = {};
+                new URLSearchParams(data).forEach((value, key) => t[key] = value);
+            }
+            catch {
+                // If invalid.
+            }
+        }
+        return res;
+    }
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/API/Request/bodyUsed
+     */
+    get req_isBodyUsed() {
+        return this.coreRequest.bodyUsed;
+    }
+    get req_isBodyJson() {
+        const ct = this.reqContentType;
+        if (ct === null)
+            return false;
+        return ct.startsWith("application/json");
+    }
+    get req_isBodyFormData() {
+        const ct = this.reqContentType;
+        if (ct === null)
+            return false;
+        return ct.startsWith("multipart/form-data");
+    }
+    get req_isBodyXFormUrlEncoded() {
+        const ct = this.reqContentType;
+        if (ct === null)
+            return false;
+        return ct.startsWith("application/x-www-form-urlencoded");
+    }
+    req_bodyAsText() {
+        return this.coreRequest.text();
+    }
+    /**
+     * Validate the data Schema.
+     * If invalid, throw a special exception allowing
+     * to directly send a response to the caller.
+     */
+    tool_validateDataSchema(data, schema) {
+        let error = jk_schema.validateSchema(data, schema);
+        if (error) {
+            throw new SBPE_DirectSendThisResponseException(() => {
+                return this.res_returnError400_BadRequest("Invalid data");
+            });
+        }
+    }
+    async req_bodyAsJson(dataSchema) {
+        if (dataSchema) {
+            const data = await this.req_bodyAsJson();
+            this.tool_validateDataSchema(data, dataSchema);
+            return data;
+        }
+        return await this.coreRequest.json();
+    }
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/API/Request/arrayBuffer
+     */
+    req_bodyAsArrayBuffer() {
+        return this.coreRequest.arrayBuffer();
+    }
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/API/Request/blob
+     */
+    req_bodyAsBlob() {
+        return this.coreRequest.blob();
+    }
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/API/Request/bytes
+     */
+    req_bodyAsBytes() {
+        return this.coreRequest.bytes();
+    }
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/API/Request/formData
+     */
+    req_bodyAsFormData() {
+        return this.coreRequest.formData();
+    }
+    //endregion
+    //region Request timeout
+    /**
+     * When DDOS protection is enabled, the request has a timeout of 60 seconds.
+     * Here it'd allow you to extend this time for a request you knew was slow.
+     */
+    req_extendTimeout_sec(sec) {
+        this.coreServer.timeout(this.coreRequest, sec);
+    }
+    //endregion
+    //region Response helpers
+    res_redirectResponse(permanent = false, url) {
+        if (!url)
+            url = this.urlInfos;
+        return new Response(null, { status: permanent ? 301 : 302, headers: { "location": url.toString() } });
+    }
+    res_textResponse(text, statusCode = 200) {
+        return new Response(text, { status: statusCode, headers: { "content-type": "text/plain;charset=utf-8" } });
+    }
+    res_returnResultMessage(isOk, message) {
+        return this.res_jsonResponse({ isOk, message });
+    }
+    res_htmlResponse(html, statusCode = 200) {
+        return new Response(html, { status: statusCode, headers: { "content-type": "text/html;charset=utf-8" } });
+    }
+    res_jsonResponse(json, statusCode = 200) {
+        return new Response(JSON.stringify(json), {
+            status: statusCode,
+            headers: { "content-type": "application/json;charset=utf-8" }
+        });
+    }
+    res_jsonStringResponse(json, statusCode = 200) {
+        return new Response(json, { status: statusCode, headers: { "content-type": "application/json;charset=utf-8" } });
+    }
+    res_returnError404_NotFound() {
+        return this.webSite.return404(this);
+    }
+    res_returnError500_ServerError(error) {
+        return this.webSite.return500(this, error);
+    }
+    res_returnError401_Unauthorized(error) {
+        return this.webSite.return401(this, error);
+    }
+    res_returnError400_BadRequest(error) {
+        return Promise.resolve(new Response(error ? error.toString() : "Bad request", { status: 400 }));
+    }
+    //endregion
+    //region Fetch / Proxy
+    proxy_directProxyToServer() {
+        return this.webSite.loadBalancer.directProxy(this);
+    }
+    proxy_proxyRequestTo(server) {
+        return server.directProxy(this);
+    }
+    proxy_directProxyWith(server) {
+        return server.directProxy(this);
+    }
+    proxy_fetchServer(headers, method = "GET", url, body) {
+        if (!url)
+            url = this.urlInfos;
+        return this.webSite.loadBalancer.fetch(method, url, body, headers);
+    }
+    //endregion
+    //region Cache
+    _isAddedToCache = false;
+    /**
+     * Get from the cache the entry corresponding to the current url.
+     */
+    async cache_getFromCache() {
+        return await this.cache.getFromCache(this, this.urlInfos);
+    }
+    async cache_hasInCache() {
+        return await this.cache.hasInCache(this.urlInfos);
+    }
+    cache_removeFromCache(url) {
+        // Avoid double.
+        //
+        if (!url) {
+            url = this.urlInfos;
+            url.hostname = url.hostname.toLowerCase();
+            url.pathname = url.pathname.toLowerCase();
+        }
+        return this.cache.removeFromCache(url || this.urlInfos);
+    }
+    cache_addToCache(response) {
+        // Avoid adding two times in the same request.
+        // This is required with automatic add functionnality.
+        //
+        if (this._isAddedToCache)
+            return;
+        this._isAddedToCache = false;
+        return this.cache.addToCache(this, this.urlInfos, response, this.webSite.getHeadersToCache());
+    }
+    /**
+     * Allow using a sub-cache.
+     * For example, a cache dedicated per user.
+     */
+    cache_useCache(cache) {
+        this.cache = cache;
+    }
+    cache_getSubCache(name) {
+        return this.cache.createSubCache(name);
+    }
+    cache_getCacheEntryIterator() {
+        return this.cache.getCacheEntryIterator();
+    }
+    //endregion
+    //region Test type / React on type
+    resValue_getContentTypeOf(response) {
+        return response.headers.get("content-type");
+    }
+    resValue_getContentTypeCategory(response) {
+        const contentType = response.headers.get("content-type");
+        if (!contentType)
+            return ContentTypeCategory.OTHER;
+        if (contentType.startsWith("text/")) {
+            if (contentType.startsWith("html", 5)) {
+                return ContentTypeCategory.TEXT_HTML;
+            }
+            else if (contentType.startsWith("css")) {
+                return ContentTypeCategory.TEXT_CSS;
+            }
+            else if (contentType.startsWith("javascript", 5)) {
+                return ContentTypeCategory.TEXT_JAVASCRIPT;
+            }
+            else if (contentType.startsWith("json")) {
+                return ContentTypeCategory.TEXT_JSON;
+            }
+        }
+        else if (contentType.startsWith("image")) {
+            return ContentTypeCategory.IMAGE;
+        }
+        else if (contentType.startsWith("application")) {
+            if (contentType.startsWith("x-www-form-urlencoded", 12)) {
+                return ContentTypeCategory.FORM_URL_ENCODED;
+            }
+            else if (contentType.startsWith("json", 12)) {
+                return ContentTypeCategory.TEXT_JSON;
+            }
+            else if (contentType.startsWith("javascript", 12)) {
+                return ContentTypeCategory.TEXT_JAVASCRIPT;
+            }
+        }
+        else if (contentType.startsWith("multipart/form-data")) {
+            return ContentTypeCategory.FORM_MULTIPART;
+        }
+        return ContentTypeCategory.OTHER;
+    }
+    resValue_isHtml(response) {
+        const contentType = response.headers.get("content-type");
+        if (contentType === null)
+            return false;
+        return contentType.startsWith("text/html");
+    }
+    resValue_isCss(response) {
+        const contentType = response.headers.get("content-type");
+        if (contentType === null)
+            return false;
+        return contentType.startsWith("text/css");
+    }
+    resValue_isJavascript(response) {
+        const contentType = response.headers.get("content-type");
+        if (contentType === null)
+            return false;
+        return contentType.startsWith("application/javascript") || contentType.startsWith("text/javascript");
+    }
+    resValue_isJson(response) {
+        const contentType = response.headers.get("content-type");
+        if (contentType === null)
+            return false;
+        return contentType.startsWith("application/json");
+    }
+    resValue_isXFormUrlEncoded(response) {
+        const contentType = response.headers.get("content-type");
+        if (contentType === null)
+            return false;
+        return contentType.startsWith("x-www-form-urlencoded");
+    }
+    async resValue_hookIfHtml(res, ...hooks) {
+        if (this.resValue_isHtml(res)) {
+            if (isNodeJS) {
+                let headers = new Headers(res.headers);
+                headers.delete("content-length");
+                headers.delete("content-encoding");
+                let newHTML = await this.resValue_applyTextModifiers(res, hooks);
+                return new Response(newHTML, { status: res.status, headers });
+            }
+            else {
+                res.headers.delete("content-length");
+                res.headers.delete("content-encoding");
+                return new Response(await this.resValue_applyTextModifiers(res, hooks), { status: res.status, headers: res.headers });
+            }
+        }
+        return Promise.resolve(res);
+    }
+    async resValue_hookIfCss(res, ...hooks) {
+        if (this.resValue_isCss(res)) {
+            return new Response(await this.resValue_applyTextModifiers(res, hooks), { status: res.status, headers: res.headers });
+        }
+        return Promise.resolve(res);
+    }
+    async resValue_hookIfJavascript(res, ...hooks) {
+        if (this.resValue_isJavascript(res)) {
+            return new Response(await this.resValue_applyTextModifiers(res, hooks), { status: res.status, headers: res.headers });
+        }
+        return Promise.resolve(res);
+    }
+    async resValue_applyTextModifiers(res, hooks) {
+        let text = await res.text();
+        for (const hook of hooks) {
+            const hRes = hook(text, this);
+            text = hRes instanceof Promise ? await hRes : hRes;
+        }
+        return text;
+    }
+    async resValue_executeModifiers(res, hooks) {
+        for (const hook of hooks) {
+            const hRes = hook(res, this);
+            res = hRes instanceof Promise ? await hRes : hRes;
+        }
+        return res;
+    }
+    async resValue_replaceWebSiteOrigin(res, toReplace, redirectionCode) {
+        let location = res.headers.get("location");
+        if (location) {
+            const thisOrigin = this.webSite.getWelcomeUrl();
+            location = location.replace(toReplace, thisOrigin);
+            if (location.startsWith("/"))
+                location = thisOrigin + location;
+            res = Response.redirect(location, redirectionCode ? redirectionCode : res.status);
+        }
+        else {
+            // It's a helper function that allows decoding
+            // and re-encoding a response if his content is of type HTML.
+            //
+            res = await this.resValue_hookIfHtml(res, (html) => {
+                const thisOrigin = this.webSite.getWelcomeUrl();
+                return html.replaceAll(toReplace, thisOrigin);
+            });
+        }
+        return res;
+    }
+    //endregion
+    //region Tools
+    async tool_duplicateReadableStream(stream) {
+        if (!stream)
+            return [null, null];
+        return stream.tee();
+    }
+    async tool_duplicateRawRequest(raw) {
+        const [str1, str2] = await this.tool_duplicateReadableStream(raw.body);
+        const res1 = new Request(raw.url, {
+            body: str1,
+            headers: raw.headers,
+            method: raw.method
+        });
+        const res2 = new Request(raw.url, {
+            body: str2,
+            headers: raw.headers,
+            method: raw.method
+        });
+        return [res1, res2];
+    }
+    async tool_duplicateResponse(raw) {
+        const [str1, str2] = await this.tool_duplicateReadableStream(raw.body);
+        const res1 = new Response(str1, {
+            status: raw.status,
+            headers: raw.headers
+        });
+        const res2 = new Response(str2, {
+            status: raw.status,
+            headers: raw.headers
+        });
+        return [res1, res2];
+    }
+    async tool_spyRequest(handleRequest) {
+        return this.tool_spyRequestData(handleRequest, (data) => {
+            this.tool_printSpyRequestData(data);
+        });
+    }
+    async tool_printSpyRequestData(data) {
+        const headerColor = jk_term.buildWriter(jk_term.C_RED);
+        const titleColor = jk_term.buildWriter(jk_term.C_ORANGE);
+        let resAsText = "";
+        //
+        try {
+            if (data.res) {
+                let res = data.res();
+                if (!res)
+                    resAsText = "[NO SET]";
+                else
+                    resAsText = await res.text();
+            }
+            else {
+                resAsText = "[NO SET]";
+            }
+        }
+        catch {
+        }
+        console.log();
+        console.log(headerColor(this.method, this.url));
+        console.log(titleColor("|- referer: "), data.reqReferer);
+        console.log(titleColor("|- reqContentType:"), data.reqContentType);
+        console.log(titleColor("|- reqData:"), data.reqData);
+        console.log(titleColor("|- reqCookie:"), data.reqCookies);
+        console.log(titleColor("|- resContentType:"), data.resContentType);
+        console.log(titleColor("|- resCookieSet:"), data.resCookieSet);
+        console.log(titleColor("|- resHeaders:"), data.resHeaders);
+        console.log(titleColor("|- resData:"), resAsText);
+    }
+    async tool_spyRequestData(handleRequest, onSpy) {
+        const [bunNewReq, spyReq] = await this.tool_duplicateRawRequest(this.coreRequest);
+        // Required because the body is already consumed.
+        this.coreRequest = bunNewReq;
+        let res = await handleRequest(this);
+        const [bunNewRes, spyRes] = await this.tool_duplicateResponse(res);
+        // Required because the body is already consumed.
+        this.coreRequest = spyReq;
+        onSpy({
+            method: this.method,
+            res: () => spyRes,
+            reqUrl: this.url,
+            reqReferer: this.headers.get("referer"),
+            reqContentType: this.reqContentType,
+            reqData: await this.req_getDataInfos(),
+            resContentType: res.headers.get("content-type"),
+            resContentTypeCat: this.resValue_getContentTypeCategory(res),
+            reqCookies: this.headers.get("cookie"),
+            resCookieSet: spyRes.headers.getSetCookie(),
+            resStatus: spyRes.status,
+            resLocation: spyRes.headers.get("location"),
+            resHeaders: spyRes.headers
+        }, this);
+        return bunNewRes;
+    }
+    tool_filterSearchParams(filter) {
+        if (filter) {
+            filter(this.urlInfos);
+        }
+        else {
+            if (this.routeInfos.searchParamFilter) {
+                this.routeInfos.searchParamFilter(this.urlInfos);
+            }
+        }
+    }
+    //endregion
+    //region Post process
+    postProcess;
+    _applyPostProcess(res) {
+        if (!this.postProcess)
+            return res;
+        this.postProcess.forEach(hook => res = hook(res));
+        return res;
+    }
+    //endregion
+    //region Cookies
+    cookie_reqHasCookie(name, value) {
+        if (!this.cookies)
+            this.cookies = parseCookies(this.coreRequest.headers);
+        if (value)
+            return this.cookies[name] === value;
+        return this.cookies[name] !== undefined;
+    }
+    cookie_getReqCookie(name) {
+        if (!this.cookies)
+            this.cookies = parseCookies(this.coreRequest.headers);
+        return this.cookies[name];
+    }
+    async cookie_hookIfResHasCookie(res, name, testCookieValue, ...hooks) {
+        const cookieValue = this.cookie_getReqCookie(name);
+        if (cookieValue) {
+            if (testCookieValue && !testCookieValue(cookieValue)) {
+                return Promise.resolve(res);
+            }
+            return this.res_htmlResponse(await this.resValue_applyTextModifiers(res, hooks));
+        }
+        return Promise.resolve(res);
+    }
+    cookie_addCookieToRes(cookieName, cookieValue, options) {
+        let cookie = `${cookieName}=${cookieValue};`;
+        if (options) {
+            if (options.maxAge) {
+                cookie += ` Max-Age=${options.maxAge};`;
+            }
+        }
+        if (!this.postProcess)
+            this.postProcess = [];
+        this.postProcess.push((res) => {
+            let current = res.headers.get("set-cookie");
+            if (current)
+                cookie = current + cookie;
+            // With node, res.headers is immutable.
+            // And a Response object is also immutable.
+            // It's why we need to create a new response.
+            //
+            if (jk_what.isNodeJS) {
+                const headers = new Headers(res.headers);
+                headers.append("set-cookie", cookie);
+                res = new Response(res.body, {
+                    headers: headers,
+                    status: res.status
+                });
+            }
+            else {
+                res.headers.append("set-cookie", cookie);
+            }
+            return res;
+        });
+    }
+    //endregion
+    //region ReactJS
+    /**
+     * Allow rendering a document fully formed from a React component.
+     */
+    react_toResponse(E) {
+        return this.res_htmlResponse(ReactServer.renderToStaticMarkup(E));
+    }
+    react_toString(element) {
+        return ReactServer.renderToStaticMarkup(element);
+    }
+    /**
+     * The new render function.
+     * Used while refactoring the renderer.
+     * Used while refactoring the renderer.
+     */
+    async react_fromPage(pageKey, C) {
+        try {
+            let bundlePath = "/_bundle/";
+            // When dev-mode (JOPI_DEV or JOPI_DEV_UI) then we compile the page one by one.
+            //
+            if (gIsSinglePageMode) {
+                await createBundleForPage(pageKey, this.routeInfos.route);
+                bundlePath += pageKey + "/";
+            }
+            // What we will include in our HTML.
+            const options = {
+                head: [_jsx("link", { rel: "stylesheet", type: "text/css", href: bundlePath + pageKey + ".css" }, "jopi.mainBundle")],
+                bodyEnd: [_jsx("script", { type: "module", src: bundlePath + pageKey + ".js" }, "jopi.mainSript")]
+            };
+            // Allow faking the environment of the page.
+            const controller = new PageController_ExposePrivate(false, this.webSite.mustRemoveTrailingSlashs, options);
+            controller.setServerRequest(this);
+            this.webSite.executeBrowserInstall(controller);
+            const params = this.urlParts;
+            const searchParams = this.urlInfos.searchParams;
+            const html = ReactServer.renderToStaticMarkup(_jsx(Page, { controller: controller, children: _jsx(C, { params: params, searchParams: searchParams }) }));
+            return new Response(html, { status: 200, headers: { "content-type": "text/html;charset=utf-8" } });
+        }
+        catch (e) {
+            console.error(e);
+            return await this.res_returnError500_ServerError(e);
+        }
+    }
+    //endregion
+    //region JQuery
+    jquery_htmlToJquery(html) {
+        const res = cheerio.load(html);
+        initCheerio(res);
+        return res;
+    }
+    //endregion
+    //region JWT Tokens
+    /**
+     * Create a JWT token with the data.
+     */
+    user_createJwtToken(data) {
+        return this.userJwtToken = this.webSite.createJwtToken(data);
+    }
+    /**
+     * Extract the JWT token from the Authorization header.
+     */
+    user_getJwtToken() {
+        if (this.userJwtToken) {
+            return this.userJwtToken;
+        }
+        if (this.hasNoUserInfos) {
+            return undefined;
+        }
+        let authHeader = this.headers.get("authorization");
+        if (authHeader) {
+            if (authHeader.startsWith("Bearer ")) {
+                return this.userJwtToken = authHeader.slice(7);
+            }
+        }
+        let authCookie = this.cookie_getReqCookie("authorization");
+        if (authCookie) {
+            if (authCookie.startsWith("jwt ")) {
+                return this.userJwtToken = authCookie.slice(4);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Try to sign in the user with information you provide.
+     * Return true if he is signed in, false otherwise.
+     *
+     * If signed in, then it automatically adds the Authorization header.
+     *
+     * @param loginInfo
+     *      Information with things like login/password-hash/...
+     *      Must match with you have used with webSite.setUserLoginManager.
+     */
+    async user_tryAuthWithJWT(loginInfo) {
+        const authResult = await this.webSite.tryAuthUser(loginInfo);
+        if (authResult.isOk) {
+            if (!authResult.authToken) {
+                authResult.authToken = this.user_createJwtToken(authResult.userInfos);
+            }
+            // The token will be added to cookie "authorization" in the post-process step.
+            this.userJwtToken = authResult.authToken;
+            this.userInfos = authResult.userInfos;
+            this.webSite.storeJwtToken(this);
+            return authResult;
+        }
+        this.userInfos = undefined;
+        this.userJwtToken = undefined;
+        return authResult;
+    }
+    /**
+     * Verify and decode the JWT token.
+     * Once done, the data is saved and can be read through req.userTokenData.
+     */
+    user_decodeJwtToken() {
+        if (this.isFakingNoUsers)
+            return undefined;
+        const token = this.user_getJwtToken();
+        if (!token)
+            return undefined;
+        return this.webSite.decodeJwtToken(token);
+    }
+    /**
+     * Allow faking a state where there is no user connected.
+     * Is mainly used by the automatic cache to generate
+     * a generic anonymous page.
+     */
+    user_fakeNoUsers() {
+        let fakeNoUser;
+        if (this._onFakeNoUser) {
+            fakeNoUser = this._onFakeNoUser;
+        }
+        else if (this.webSite.fakeNoUser) {
+            fakeNoUser = this.webSite.fakeNoUser;
+        }
+        if (fakeNoUser) {
+            let r = fakeNoUser(this);
+            if (r === false)
+                return;
+        }
+        this.isFakingNoUsers = true;
+    }
+    /**
+     * Allows setting a listener which is call when `fakeNoUsers`is called.
+     * If this listener explicitly returns false, then the call to fakeNoUsers is ignored.
+     */
+    user_onFakeNoUser(handler) {
+        this._onFakeNoUser = handler;
+    }
+    user_getUserInfos() {
+        if (this.isFakingNoUsers)
+            return undefined;
+        if (this.userInfos)
+            return this.userInfos;
+        if (this.hasNoUserInfos)
+            return undefined;
+        const userInfos = this.user_decodeJwtToken();
+        if (userInfos) {
+            this.userInfos = userInfos;
+            return userInfos;
+        }
+        this.hasNoUserInfos = true;
+        return undefined;
+    }
+    use_requireUserInfos() {
+        let userInfos = this.user_getUserInfos();
+        if (!userInfos)
+            throw new SBPE_NotAuthorizedException();
+        return userInfos;
+    }
+    isFakingNoUsers = false;
+    _onFakeNoUser;
+    hasNoUserInfos = false;
+    userInfos;
+    userJwtToken;
+    //endregion
+    //region User roles
+    /**
+     * Returns the roles of the user.
+     */
+    role_getUserRoles() {
+        const userInfos = this.user_getUserInfos();
+        if (!userInfos || !userInfos.roles)
+            return [];
+        return userInfos.roles;
+    }
+    /**
+     * Check if the user has all these roles.
+     * Return true if ok, false otherwise.
+     */
+    role_userHasRoles(requiredRoles) {
+        const userInfos = this.user_getUserInfos();
+        if (!userInfos)
+            return false;
+        const userRoles = userInfos.roles;
+        if (!userRoles)
+            return false;
+        for (let role of requiredRoles) {
+            if (!userRoles.includes(role))
+                return false;
+        }
+        return true;
+    }
+    role_assertUserHasRoles(requiredRoles) {
+        if (!this.role_userHasRoles(requiredRoles)) {
+            throw new SBPE_NotAuthorizedException();
+        }
+    }
+    //endregion
+    //region File Serving
+    async file_returnFile(filePath, params) {
+        const res = await this.file_tryReturnFile(filePath, params);
+        if (res)
+            return res;
+        return this.res_returnError404_NotFound();
+    }
+    async file_tryReturnFile(filePath, params) {
+        let cacheValidationInfos = await this.file_validateCacheHeaders(filePath);
+        // Mean that the file doesn't exist.
+        if (cacheValidationInfos === undefined)
+            return undefined;
+        // Mean that the browser cache is valid. Returns code 304.
+        if (cacheValidationInfos instanceof Response)
+            return cacheValidationInfos;
+        // Will return the file and add the browser cache headers.
+        return this.webSite.tryReturnFile({
+            req: this,
+            filePath,
+            contentEncoding: params?.contentEncoding,
+            validationInfos: cacheValidationInfos
+        });
+    }
+    /**
+     * Allow serving a file as a response.
+     * Automatically get the file from the url and a root dir.
+     */
+    async file_serveFromDir(filesRootPath, options) {
+        options = options || gEmptyObject;
+        if (options.replaceIndexHtml !== false) {
+            if (this.urlInfos.pathname.endsWith("/index.html")) {
+                this.urlInfos.pathname = this.urlInfos.pathname.slice(0, -10);
+                return this.res_redirectResponse(false);
+            }
+            if (this.urlInfos.pathname.endsWith("/")) {
+                this.urlInfos.pathname += "index.html";
+            }
+        }
+        const sfc = new WebSiteMirrorCache(filesRootPath);
+        const fromCache = await sfc.getFromCache(this, this.urlInfos);
+        if (fromCache)
+            return fromCache;
+        if (options.onNotFound) {
+            return options.onNotFound(this);
+        }
+        return this.res_returnError404_NotFound();
+    }
+    file_calcFileEtag(filePath) {
+        return jk_fs.calcFileHash(filePath);
+    }
+    file_validateCacheHeadersWith(headers) {
+        let reqEtag = this.headers.get("if-none-match");
+        let myEtag = headers["etag"];
+        if (reqEtag && (reqEtag === myEtag)) {
+            return new Response(null, {
+                status: 304,
+                headers: { "etag": myEtag }
+            });
+        }
+        let reqLastModifiedSince = this.headers.get("if-modified-since");
+        let myLastModifiedSince = headers["if-modified-since"];
+        if (myLastModifiedSince && reqLastModifiedSince) {
+            const dMyLastModifiedSince = new Date(myLastModifiedSince).getTime();
+            const dReqLastModifiedSince = new Date(reqLastModifiedSince).getTime();
+            if (dReqLastModifiedSince < dMyLastModifiedSince) {
+                return new Response(null, {
+                    status: 304,
+                    headers: { "last-modified": myLastModifiedSince }
+                });
+            }
+        }
+    }
+    async file_validateCacheHeaders(filePath) {
+        let fileState = await jk_fs.getFileStat(filePath);
+        if (!fileState)
+            return undefined;
+        let lastModifiedSince = this.headers.get("if-modified-since");
+        if (lastModifiedSince) {
+            const fileModifiedTime = new Date(fileState.mtimeMs).getTime();
+            const clientModifiedTime = new Date(lastModifiedSince).getTime();
+            if (fileModifiedTime <= clientModifiedTime) {
+                return new Response(null, {
+                    status: 304,
+                    headers: { "last-modified": new Date(fileState.mtimeMs).toUTCString() }
+                });
+            }
+        }
+        let etag = this.headers.get("if-none-match");
+        let calcEtag;
+        if (etag) {
+            calcEtag = await jk_fs.calcFileHash(filePath);
+            if (etag === calcEtag) {
+                return new Response(null, {
+                    status: 304,
+                    headers: { "etag": etag }
+                });
+            }
+        }
+        if (!calcEtag)
+            calcEtag = await jk_fs.calcFileHash(filePath);
+        return { etag: calcEtag, fileState: fileState };
+    }
+}
+export var ContentTypeCategory;
+(function (ContentTypeCategory) {
+    ContentTypeCategory[ContentTypeCategory["OTHER"] = 0] = "OTHER";
+    ContentTypeCategory[ContentTypeCategory["_TEXT_"] = 10] = "_TEXT_";
+    ContentTypeCategory[ContentTypeCategory["TEXT_HTML"] = 11] = "TEXT_HTML";
+    ContentTypeCategory[ContentTypeCategory["TEXT_CSS"] = 12] = "TEXT_CSS";
+    ContentTypeCategory[ContentTypeCategory["TEXT_JAVASCRIPT"] = 13] = "TEXT_JAVASCRIPT";
+    ContentTypeCategory[ContentTypeCategory["TEXT_JSON"] = 14] = "TEXT_JSON";
+    ContentTypeCategory[ContentTypeCategory["_FORM_"] = 20] = "_FORM_";
+    ContentTypeCategory[ContentTypeCategory["FORM_MULTIPART"] = 20] = "FORM_MULTIPART";
+    ContentTypeCategory[ContentTypeCategory["FORM_URL_ENCODED"] = 21] = "FORM_URL_ENCODED";
+    ContentTypeCategory[ContentTypeCategory["_BINARY_"] = 30] = "_BINARY_";
+    ContentTypeCategory[ContentTypeCategory["IMAGE"] = 31] = "IMAGE";
+})(ContentTypeCategory || (ContentTypeCategory = {}));
+const gEmptyObject = {};
+const gIsSinglePageMode = isSinglePageMode();
+//# sourceMappingURL=jopiRequest.js.map